#include <kis_tool_transform.h>

Inheritance diagram for KisToolTransform:

Public Types
enum	TransformToolMode { FreeTransformMode , WarpTransformMode , CageTransformMode , LiquifyTransformMode , PerspectiveTransformMode , MeshTransformMode }

enum	WarpType { RigidWarpType , AffineWarpType , SimilitudeWarpType }

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

void	canvasUpdateRequested ()

void	convexHullCalculationRequested ()

void	cursorOutlineUpdateRequested (const QPointF &imagePos)

void	deactivate () override

void	imageTooBigRequested (bool value)

void	requestImageRecalculation ()

void	requestRedoDuringStroke () override

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

void	requestUndoDuringStroke () override

void	resetRotationCenterButtonsRequested ()

void	setRotateX (double rotation)

void	setRotateY (double rotation)

void	setRotateZ (double rotation)

void	setScaleX (double scaleX)

void	setScaleY (double scaleY)

void	setShearX (double shearX)

void	setShearY (double shearY)

void	setTransformMode (KisToolTransform::TransformToolMode newMode)

void	setTranslateX (double translateX)

void	setTranslateY (double translateY)

void	setWarpFlexibility (double flexibility)

void	setWarpPointDensity (int density)

void	setWarpType (WarpType type)

void	slotConvexHullCalculated (QPolygon hull, void *strokeStrategyCookie)

void	updateOptionWidget ()

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

void	transformModeChanged ()

void	warpTransformChanged ()

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	activateAlternateAction (AlternateAction action) override

void	activatePrimaryAction () override

void	beginActionImpl (KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)

void	beginAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	beginPrimaryAction (KoPointerEvent *event) override

void	continueActionImpl (KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)

void	continueAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	continuePrimaryAction (KoPointerEvent *event) override

QWidget *	createOptionWidget () override

void	deactivateAlternateAction (AlternateAction action) override

void	deactivatePrimaryAction () override

void	endActionImpl (KoPointerEvent *event, bool usePrimaryAction, KisTool::AlternateAction action)

void	endAlternateAction (KoPointerEvent *event, AlternateAction action) override

void	endPrimaryAction (KoPointerEvent *event) override

	KisToolTransform (KoCanvasBase *canvas)

void	mouseMoveEvent (KoPointerEvent *e) override

void	mousePressEvent (KoPointerEvent *e) override

void	mouseReleaseEvent (KoPointerEvent *e) override

void	newActivationWithExternalSource (KisPaintDeviceSP externalSource) override
	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.

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

QMenu *	popupActionsMenu () override

double	rotateX () const

double	rotateY () const

double	rotateZ () const

double	scaleX () const

double	scaleY () const

void	setNextActivationTransformMode (TransformToolMode mode)

double	shearX () const

double	shearY () const

TransformToolMode	transformMode () const

double	translateX () const

double	translateY () const

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

double	warpFlexibility () const

int	warpPointDensity () const

WarpType	warpType () const

	~KisToolTransform () override

Public Member Functions inherited from KisTool
virtual bool	alternateActionSupportsHiResEvents (AlternateAction action) const

virtual void	beginAlternateDoubleClickAction (KoPointerEvent *event, AlternateAction action)

virtual void	beginPrimaryDoubleClickAction (KoPointerEvent *event)

void	deleteSelection () override

virtual int	flags () const

bool	isActive () const

	KisTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mouseTripleClickEvent (KoPointerEvent *event) override

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 KisPopupWidgetInterface *	popupWidget ()

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

virtual KoToolSelection *	selection ()

Q_INVOKABLE QString	toolId () const

	~KoToolBase () override

Static Public Member Functions
static ToolTransformArgs::TransformMode	toArgsMode (KisToolTransform::TransformToolMode toolMode)

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

Protected Slots
void	resetCursorStyle () override

void	slotGlobalConfigChanged ()

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

Properties
double	rotateX

double	rotateY

double	rotateZ

double	scaleX

double	scaleY

double	shearX

double	shearY

TransformToolMode	transformMode

double	translateX

double	translateY

double	warpFlexibility

int	warpPointDensity

WarpType	warpType

Properties inherited from KisTool
bool	isActive

Private Slots
void	slotApplyTransform ()

void	slotCancelTransform ()

void	slotEditingFinished ()

void	slotMoveDiscreteDown ()

void	slotMoveDiscreteDownMore ()

void	slotMoveDiscreteLeft ()

void	slotMoveDiscreteLeftMore ()

void	slotMoveDiscreteRight ()

void	slotMoveDiscreteRightMore ()

void	slotMoveDiscreteUp ()

void	slotMoveDiscreteUpMore ()

void	slotPreviewDeviceGenerated (KisPaintDeviceSP device)

void	slotResetTransform (ToolTransformArgs::TransformMode mode)

void	slotRestartAndContinueTransform ()

void	slotRestartTransform ()

void	slotTrackerChangedConfig (KisToolChangesTrackerDataSP status)

void	slotTransactionGenerated (TransformTransactionProperties transaction, ToolTransformArgs args, void *strokeStrategyCookie)

void	slotUiChangedConfig (bool needsPreviewRecalculation)

void	slotUpdateToCageType ()

void	slotUpdateToFreeTransformType ()

void	slotUpdateToLiquifyType ()

void	slotUpdateToMeshType ()

void	slotUpdateToPerspectiveType ()

void	slotUpdateToWarpType ()

Private Member Functions
void	cancelStroke ()

void	commitChanges ()

KisTransformStrategyBase *	currentStrategy () const

void	endStroke ()

void	initGuiAfterTransformMode ()

void	initThumbnailImage (KisPaintDeviceSP previewDevice)

void	initTransformMode (ToolTransformArgs::TransformMode mode)

void	outlineChanged ()

void	setFunctionalCursor ()

void	setTransformFunction (QPointF mousePos, Qt::KeyboardModifiers modifiers)

void	startStroke (ToolTransformArgs::TransformMode mode, bool forceReset)

void	updateApplyResetAvailability ()

Private Attributes
KisAction *	applyTransformation {0}

KisAction *	cageAction {0}

KisAction *	freeTransformAction {0}

KisAction *	keepAspectRatioAction {0}

KisAction *	liquifyAction {0}

KisSignalAutoConnectionsStore	m_actionConnections

bool	m_actuallyMoveWhileSelected {false}

KisAsynchronousStrokeUpdateHelper	m_asyncUpdateHelper

QScopedPointer< KisCageTransformStrategy >	m_cageStrategy

QPointer< KisCanvas2 >	m_canvas

KisToolChangesTracker	m_changesTracker

QScopedPointer< QMenu >	m_contextMenu

ToolTransformArgs	m_currentArgs

bool	m_currentlyUsingOverlayPreviewStyle {false}

QPainterPath	m_cursorOutline

KisPaintDeviceSP	m_externalSourceForNextActivation

bool	m_forceLodMode {false}

QScopedPointer< KisFreeTransformStrategy >	m_freeStrategy

QScopedPointer< KisLiquifyTransformStrategy >	m_liquifyStrategy

QScopedPointer< KisMeshTransformStrategy >	m_meshStrategy

KisToolTransformConfigWidget *	m_optionsWidget {0}

QScopedPointer< KisPerspectiveTransformStrategy >	m_perspectiveStrategy

bool	m_preferOverlayPreviewStyle {false}

QRectF	m_refRect

KisPaintDeviceSP	m_selectedPortionCache

QPainterPath	m_selectionPath

KisStrokeId	m_strokeId

void *	m_strokeStrategyCookie {0}

TransformTransactionProperties	m_transaction

QScopedPointer< KisWarpTransformStrategy >	m_warpStrategy

KisAction *	meshAction {0}

KisAction *	mirrorHorizontalAction {0}

KisAction *	mirrorVerticalAction {0}

TransformToolMode	nextActivationTransformMode {FreeTransformMode}

KisAction *	perspectiveAction {0}

KisAction *	resetTransformation {0}

KisAction *	rotateNinetyCCWAction {0}

KisAction *	rotateNinetyCWAction {0}

KisAction *	warpAction {0}
	actions for the context click menu

Additional Inherited Members
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

Detailed Description

Transform tool This tool offers several modes.

Free Transform mode allows the user to translate, scale, shear, rotate and apply a perspective transformation to a selection or the whole canvas.
Warp mode allows the user to warp the selection of the canvas by grabbing and moving control points placed on the image. The user can either work with default control points, like a grid whose density can be modified, or place the control points manually. The modifications made on the selected pixels are applied only when the user clicks the Apply button : the semi-transparent image displayed until the user click that button is only a preview.
Cage transform is similar to warp transform with control points exactly placed on the outer boundary. The user draws a boundary polygon, the vertices of which become control points.
Perspective transform applies a two-point perspective transformation. The user can manipulate the corners of the selection. If the vanishing points of the resulting quadrilateral are on screen, the user can manipulate those as well.
Liquify transform transforms the selection by painting motions, as if the user was finger painting.

Definition at line 78 of file kis_tool_transform.h.

Member Enumeration Documentation

◆ TransformToolMode

enum KisToolTransform::TransformToolMode

Enumerator
FreeTransformMode
WarpTransformMode
CageTransformMode
LiquifyTransformMode
PerspectiveTransformMode
MeshTransformMode

Definition at line 105 of file kis_tool_transform.h.

                           {
        FreeTransformMode,
        WarpTransformMode,
        CageTransformMode,
        LiquifyTransformMode,
        PerspectiveTransformMode,
        MeshTransformMode
    };

◆ WarpType

enum KisToolTransform::WarpType

Enumerator
RigidWarpType
AffineWarpType
SimilitudeWarpType

Definition at line 115 of file kis_tool_transform.h.

                  {
        RigidWarpType,
        AffineWarpType,
        SimilitudeWarpType
    };

Constructor & Destructor Documentation

◆ KisToolTransform()

KisToolTransform::KisToolTransform ( KoCanvasBase * canvas )

Definition at line 84 of file kis_tool_transform.cc.

    : KisTool(canvas, KisCursor::rotateCursor())
    , m_warpStrategy(
        new KisWarpTransformStrategy(
            dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
            dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
            m_currentArgs, m_transaction))
    , m_cageStrategy(
        new KisCageTransformStrategy(
            dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
            dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
            m_currentArgs, m_transaction))
    , m_liquifyStrategy(
        new KisLiquifyTransformStrategy(
            dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
            m_currentArgs, m_transaction, canvas->resourceManager()))
    , m_meshStrategy(
        new KisMeshTransformStrategy(
            dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
            dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
            m_currentArgs, m_transaction))
    , m_freeStrategy(
        new KisFreeTransformStrategy(
            dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
            dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
            m_currentArgs, m_transaction))
    , m_perspectiveStrategy(
        new KisPerspectiveTransformStrategy(
            dynamic_cast<KisCanvas2*>(canvas)->coordinatesConverter(),
            dynamic_cast<KisCanvas2*>(canvas)->snapGuide(),
            m_currentArgs, m_transaction))
{
    m_canvas = dynamic_cast<KisCanvas2*>(canvas);
    Q_ASSERT(m_canvas);
 
    setObjectName("tool_transform");
    m_optionsWidget = 0;
 
    warpAction = new KisAction(i18nc("Warp Transform Tab Label", "Warp"));
    liquifyAction = new KisAction(i18nc("Liquify Transform Tab Label", "Liquify"));
    meshAction = new KisAction(i18nc("Mesh Transform Tab Label", "Mesh"));
    cageAction = new KisAction(i18nc("Cage Transform Tab Label", "Cage"));
    freeTransformAction = new KisAction(i18nc("Free Transform Tab Label", "Free"));
    perspectiveAction = new KisAction(i18nc("Perspective Transform Tab Label", "Perspective"));
 
    // extra actions for free transform that are in the tool options
    mirrorHorizontalAction = new KisAction(i18n("Mirror Horizontal"));
    mirrorVerticalAction = new KisAction(i18n("Mirror Vertical"));
    rotateNinetyCWAction = new KisAction(i18n("Rotate 90 degrees Clockwise"));
    rotateNinetyCCWAction = new KisAction(i18n("Rotate 90 degrees CounterClockwise"));
 
    keepAspectRatioAction = new KisAction(i18n("Keep Aspect Ratio"));
    keepAspectRatioAction->setCheckable(true);
    keepAspectRatioAction->setChecked(false);
 
    applyTransformation = new KisAction(i18n("Apply"));
    resetTransformation = new KisAction(i18n("Reset"));
 
    m_contextMenu.reset(new QMenu());
 
    connect(m_warpStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
    connect(m_warpStrategy.data(), SIGNAL(requestImageRecalculation()), SLOT(requestImageRecalculation()));
    connect(m_cageStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
    connect(m_cageStrategy.data(), SIGNAL(requestImageRecalculation()), SLOT(requestImageRecalculation()));
    connect(m_liquifyStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
    connect(m_liquifyStrategy.data(), SIGNAL(requestCursorOutlineUpdate(QPointF)), SLOT(cursorOutlineUpdateRequested(QPointF)));
    connect(m_liquifyStrategy.data(), SIGNAL(requestUpdateOptionWidget()), SLOT(updateOptionWidget()));
    connect(m_liquifyStrategy.data(), SIGNAL(requestImageRecalculation()), SLOT(requestImageRecalculation()));
    connect(m_freeStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
    connect(m_freeStrategy.data(), SIGNAL(requestResetRotationCenterButtons()), SLOT(resetRotationCenterButtonsRequested()));
    connect(m_freeStrategy.data(), SIGNAL(requestShowImageTooBig(bool)), SLOT(imageTooBigRequested(bool)));
    connect(m_freeStrategy.data(), SIGNAL(requestImageRecalculation()), SLOT(requestImageRecalculation()));
    connect(m_freeStrategy.data(), SIGNAL(requestConvexHullCalculation()), SLOT(convexHullCalculationRequested()));
    connect(m_perspectiveStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
    connect(m_perspectiveStrategy.data(), SIGNAL(requestShowImageTooBig(bool)), SLOT(imageTooBigRequested(bool)));
    connect(m_perspectiveStrategy.data(), SIGNAL(requestImageRecalculation()), SLOT(requestImageRecalculation()));
    connect(m_meshStrategy.data(), SIGNAL(requestCanvasUpdate()), SLOT(canvasUpdateRequested()));
    connect(m_meshStrategy.data(), SIGNAL(requestImageRecalculation()), SLOT(requestImageRecalculation()));
 
    connect(&m_changesTracker, SIGNAL(sigConfigChanged(KisToolChangesTrackerDataSP)),
            this, SLOT(slotTrackerChangedConfig(KisToolChangesTrackerDataSP)));
 
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotGlobalConfigChanged()));
}

References applyTransformation, cageAction, Private::canvas, canvasUpdateRequested(), convexHullCalculationRequested(), cursorOutlineUpdateRequested(), freeTransformAction, imageTooBigRequested(), KisConfigNotifier::instance(), keepAspectRatioAction, liquifyAction, m_cageStrategy, m_canvas, m_changesTracker, m_contextMenu, m_freeStrategy, m_liquifyStrategy, m_meshStrategy, m_optionsWidget, m_perspectiveStrategy, m_warpStrategy, meshAction, mirrorHorizontalAction, mirrorVerticalAction, perspectiveAction, requestImageRecalculation(), resetRotationCenterButtonsRequested(), resetTransformation, rotateNinetyCCWAction, rotateNinetyCWAction, slotGlobalConfigChanged(), slotTrackerChangedConfig(), updateOptionWidget(), and warpAction.

◆ ~KisToolTransform()

KisToolTransform::~KisToolTransform ( )

override

Definition at line 169 of file kis_tool_transform.cc.

{
    cancelStroke();
 
    delete warpAction;
    delete meshAction;
    delete liquifyAction;
    delete cageAction;
    delete freeTransformAction;
    delete perspectiveAction;
    delete applyTransformation;
    delete resetTransformation;
    delete mirrorHorizontalAction;
    delete mirrorVerticalAction;
    delete rotateNinetyCWAction;
    delete rotateNinetyCCWAction;
    delete keepAspectRatioAction;
}

References applyTransformation, cageAction, cancelStroke(), freeTransformAction, keepAspectRatioAction, liquifyAction, meshAction, mirrorHorizontalAction, mirrorVerticalAction, perspectiveAction, resetTransformation, rotateNinetyCCWAction, rotateNinetyCWAction, and warpAction.

Member Function Documentation

◆ activate

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

overrideslot

we cannot initialize the setting in the constructor, because factory() is not yet initialized, so we cannot get toolId()

Definition at line 817 of file kis_tool_transform.cc.

{
    KisTool::activate(shapes);
 
    slotGlobalConfigChanged();
 
    m_actionConnections.addConnection(action("movetool-move-up"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteUp()));
    m_actionConnections.addConnection(action("movetool-move-up-more"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteUpMore()));
    m_actionConnections.addConnection(action("movetool-move-down"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteDown()));
    m_actionConnections.addConnection(action("movetool-move-down-more"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteDownMore()));
    m_actionConnections.addConnection(action("movetool-move-left"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteLeft()));
    m_actionConnections.addConnection(action("movetool-move-left-more"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteLeftMore()));
    m_actionConnections.addConnection(action("movetool-move-right"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteRight()));
    m_actionConnections.addConnection(action("movetool-move-right-more"), SIGNAL(triggered(bool)),
                                      this, SLOT(slotMoveDiscreteRightMore()));
 
    if (currentNode()) {
        m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeList(), {});
    }
 
    startStroke(toArgsMode(nextActivationTransformMode), false);
    nextActivationTransformMode = KisToolTransform::FreeTransformMode;
}

References KoToolBase::action(), KisTool::activate(), KisSignalAutoConnectionsStore::addConnection(), KisTool::currentNode(), FreeTransformMode, m_actionConnections, m_currentArgs, m_transaction, nextActivationTransformMode, slotGlobalConfigChanged(), slotMoveDiscreteDown(), slotMoveDiscreteDownMore(), slotMoveDiscreteLeft(), slotMoveDiscreteLeftMore(), slotMoveDiscreteRight(), slotMoveDiscreteRightMore(), slotMoveDiscreteUp(), slotMoveDiscreteUpMore(), startStroke(), and toArgsMode().

◆ activateAlternateAction()

void KisToolTransform::activateAlternateAction ( AlternateAction action )

overridevirtual

Reimplemented from KisTool.

Definition at line 481 of file kis_tool_transform.cc.

{
    currentStrategy()->activateAlternateAction(action);
    setFunctionalCursor();
}

References KoToolBase::action(), KisTransformStrategyBase::activateAlternateAction(), currentStrategy(), and setFunctionalCursor().

◆ activatePrimaryAction()

void KisToolTransform::activatePrimaryAction ( )

overridevirtual

Called by KisToolProxy when the primary action of the tool is going to be started now, that is when all the modifiers are pressed and the only thing left is just to press the mouse button. On coming of this callback the tool is supposed to prepare the cursor and/or the outline to show the user shat is going to happen next

Reimplemented from KisTool.

Definition at line 470 of file kis_tool_transform.cc.

{
    currentStrategy()->activatePrimaryAction();
    setFunctionalCursor();
}

References KisTransformStrategyBase::activatePrimaryAction(), currentStrategy(), and setFunctionalCursor().

◆ applyTransform

void KisToolTransform::applyTransform ( )

slot

Definition at line 539 of file kis_tool_transform.cc.

{
    slotApplyTransform();
}

References slotApplyTransform().

◆ beginActionImpl()

void KisToolTransform::beginActionImpl	(	KoPointerEvent *	event,
		bool	usePrimaryAction,
		KisTool::AlternateAction	action )

Definition at line 347 of file kis_tool_transform.cc.

{
    if (!nodeEditable()) {
        event->ignore();
        return;
    }
 
    if (!m_strokeId) {
        startStroke(m_currentArgs.mode(), action == KisTool::ChangeSize);
    } else if (!m_transaction.rootNodes().isEmpty()) {
        bool result = false;
 
        if (usePrimaryAction) {
            result = currentStrategy()->beginPrimaryAction(event);
        } else {
            result = currentStrategy()->beginAlternateAction(event, action);
        }
 
        if (result) {
            setMode(KisTool::PAINT_MODE);
        }
    }
 
    m_actuallyMoveWhileSelected = false;
 
    outlineChanged();
}

References KoToolBase::action(), KisTransformStrategyBase::beginAlternateAction(), KisTransformStrategyBase::beginPrimaryAction(), KisTool::ChangeSize, currentStrategy(), m_actuallyMoveWhileSelected, m_currentArgs, m_strokeId, m_transaction, ToolTransformArgs::mode(), KisTool::nodeEditable(), outlineChanged(), KisTool::PAINT_MODE, TransformTransactionProperties::rootNodes(), KisTool::setMode(), and startStroke().

◆ beginAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 492 of file kis_tool_transform.cc.

{
    beginActionImpl(event, false, action);
}

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

◆ beginPrimaryAction()

void KisToolTransform::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 455 of file kis_tool_transform.cc.

{
    beginActionImpl(event, true, KisTool::NONE);
}

References beginActionImpl(), and KisTool::NONE.

◆ cancelStroke()

void KisToolTransform::cancelStroke ( )

private

Definition at line 1111 of file kis_tool_transform.cc.

{
    if (!m_strokeId) return;
 
    if (m_asyncUpdateHelper.isActive()) {
        m_asyncUpdateHelper.cancelUpdateStream();
    }
 
    image()->cancelStroke(m_strokeId);
    m_strokeStrategyCookie = 0;
    m_strokeId.clear();
    m_changesTracker.reset();
    m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeList(), {});
    outlineChanged();
}

References KisImage::cancelStroke(), KisAsynchronousStrokeUpdateHelper::cancelUpdateStream(), KisTool::image(), KisAsynchronousStrokeUpdateHelper::isActive(), m_asyncUpdateHelper, m_changesTracker, m_currentArgs, m_strokeId, m_strokeStrategyCookie, m_transaction, outlineChanged(), and KisToolChangesTracker::reset().

◆ canvasUpdateRequested

void KisToolTransform::canvasUpdateRequested ( )

slot

Definition at line 194 of file kis_tool_transform.cc.

{
    m_canvas->updateCanvas();
}

References m_canvas.

◆ commitChanges()

void KisToolTransform::commitChanges ( )

private

Definition at line 1127 of file kis_tool_transform.cc.

{
    if (!m_strokeId || m_transaction.rootNodes().isEmpty()) return;
 
    m_changesTracker.commitConfig(toQShared(m_currentArgs.clone()));
}

References ToolTransformArgs::clone(), KisToolChangesTracker::commitConfig(), m_changesTracker, m_currentArgs, m_strokeId, m_transaction, TransformTransactionProperties::rootNodes(), and toQShared().

◆ continueActionImpl()

void KisToolTransform::continueActionImpl	(	KoPointerEvent *	event,
		bool	usePrimaryAction,
		KisTool::AlternateAction	action )

Definition at line 375 of file kis_tool_transform.cc.

{
    if (mode() != KisTool::PAINT_MODE) return;
    if (m_transaction.rootNodes().isEmpty()) return;
 
    m_actuallyMoveWhileSelected = true;
 
    if (usePrimaryAction) {
        currentStrategy()->continuePrimaryAction(event);
    } else {
        currentStrategy()->continueAlternateAction(event, action);
    }
 
    updateOptionWidget();
    outlineChanged();
}

References KoToolBase::action(), KisTransformStrategyBase::continueAlternateAction(), KisTransformStrategyBase::continuePrimaryAction(), currentStrategy(), m_actuallyMoveWhileSelected, m_transaction, KisTool::mode(), outlineChanged(), KisTool::PAINT_MODE, TransformTransactionProperties::rootNodes(), and updateOptionWidget().

◆ continueAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 497 of file kis_tool_transform.cc.

{
    continueActionImpl(event, false, action);
}

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

◆ continuePrimaryAction()

void KisToolTransform::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 460 of file kis_tool_transform.cc.

{
    continueActionImpl(event, true, KisTool::NONE);
}

References continueActionImpl(), and KisTool::NONE.

◆ convexHullCalculationRequested

void KisToolTransform::convexHullCalculationRequested ( )

slot

Free transform strategy issues the recalculation request every time the user performs a bounds rotation action, so we should skip actual recalculation, when it is not necessary anymore

Definition at line 223 of file kis_tool_transform.cc.

{
    if (m_strokeId && !m_transaction.rootNodes().isEmpty()) {
        if (m_transaction.convexHullHasBeenRequested()) {
            return;
        }
 
        m_transaction.setConvexHullHasBeenRequested(true);
 
        if (m_currentlyUsingOverlayPreviewStyle) {
            image()->addJob(m_strokeId, new TransformStrokeStrategy::CalculateConvexHullData());
        } else {
            image()->addJob(m_strokeId, new InplaceTransformStrokeStrategy::CalculateConvexHullData());
        }
    }
}

References KisImage::addJob(), TransformTransactionProperties::convexHullHasBeenRequested(), KisTool::image(), m_currentlyUsingOverlayPreviewStyle, m_strokeId, m_transaction, TransformTransactionProperties::rootNodes(), and TransformTransactionProperties::setConvexHullHasBeenRequested().

◆ createOptionWidget()

QWidget * KisToolTransform::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 1145 of file kis_tool_transform.cc.

{
    if (!m_canvas) return 0;
     
    m_optionsWidget = new KisToolTransformConfigWidget(&m_transaction, m_canvas, 0);
    Q_CHECK_PTR(m_optionsWidget);
    m_optionsWidget->setObjectName(toolId() + " option widget");
 
    // 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);
 
 
    connect(m_optionsWidget, SIGNAL(sigConfigChanged(bool)),
            this, SLOT(slotUiChangedConfig(bool)));
 
    connect(m_optionsWidget, SIGNAL(sigApplyTransform()),
            this, SLOT(slotApplyTransform()));
 
    connect(m_optionsWidget, SIGNAL(sigResetTransform(ToolTransformArgs::TransformMode)),
            this, SLOT(slotResetTransform(ToolTransformArgs::TransformMode)));
 
    connect(m_optionsWidget, SIGNAL(sigCancelTransform()),
            this, SLOT(slotCancelTransform()));
 
    connect(m_optionsWidget, SIGNAL(sigRestartTransform()),
            this, SLOT(slotRestartTransform()));
 
    connect(m_optionsWidget, SIGNAL(sigUpdateGlobalConfig()),
            this, SLOT(slotGlobalConfigChanged()));
 
    connect(m_optionsWidget, SIGNAL(sigRestartAndContinueTransform()),
            this, SLOT(slotRestartAndContinueTransform()));
 
    connect(m_optionsWidget, SIGNAL(sigEditingFinished()),
            this, SLOT(slotEditingFinished()));
 
 
    connect(mirrorHorizontalAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotFlipX()));
    connect(mirrorVerticalAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotFlipY()));
    connect(rotateNinetyCWAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotRotateCW()));
    connect(rotateNinetyCCWAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotRotateCCW()));
 
    connect(keepAspectRatioAction, SIGNAL(triggered(bool)), m_optionsWidget, SLOT(slotSetKeepAspectRatio(bool)));
 
 
    connect(warpAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToWarpType()));
    connect(perspectiveAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToPerspectiveType()));
    connect(freeTransformAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToFreeTransformType()));
    connect(liquifyAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToLiquifyType()));
    connect(meshAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToMeshType()));
    connect(cageAction, SIGNAL(triggered(bool)), this, SLOT(slotUpdateToCageType()));
 
    connect(applyTransformation, SIGNAL(triggered(bool)), this, SLOT(slotApplyTransform()));
    connect(resetTransformation, SIGNAL(triggered(bool)), this, SLOT(slotCancelTransform()));
 
 
    updateOptionWidget();
 
    return m_optionsWidget;
}

References applyTransformation, cageAction, freeTransformAction, keepAspectRatioAction, liquifyAction, m_canvas, m_optionsWidget, m_transaction, meshAction, mirrorHorizontalAction, mirrorVerticalAction, perspectiveAction, resetTransformation, rotateNinetyCCWAction, rotateNinetyCWAction, slotApplyTransform(), slotCancelTransform(), slotEditingFinished(), slotGlobalConfigChanged(), slotResetTransform(), slotRestartAndContinueTransform(), slotRestartTransform(), slotUiChangedConfig(), slotUpdateToCageType(), slotUpdateToFreeTransformType(), slotUpdateToLiquifyType(), slotUpdateToMeshType(), slotUpdateToPerspectiveType(), slotUpdateToWarpType(), KoToolBase::toolId(), updateOptionWidget(), and warpAction.

◆ currentStrategy()

KisTransformStrategyBase * KisToolTransform::currentStrategy ( ) const

private

Definition at line 266 of file kis_tool_transform.cc.

{
    if (m_currentArgs.mode() == ToolTransformArgs::FREE_TRANSFORM) {
        return m_freeStrategy.data();
    } else if (m_currentArgs.mode() == ToolTransformArgs::WARP) {
        return m_warpStrategy.data();
    } else if (m_currentArgs.mode() == ToolTransformArgs::CAGE) {
        return m_cageStrategy.data();
    } else if (m_currentArgs.mode() == ToolTransformArgs::LIQUIFY) {
        return m_liquifyStrategy.data();
    } else if (m_currentArgs.mode() == ToolTransformArgs::MESH) {
        return m_meshStrategy.data();
    } else /* if (m_currentArgs.mode() == ToolTransformArgs::PERSPECTIVE_4POINT) */ {
        return m_perspectiveStrategy.data();
    }
}

References ToolTransformArgs::CAGE, ToolTransformArgs::FREE_TRANSFORM, ToolTransformArgs::LIQUIFY, m_cageStrategy, m_currentArgs, m_freeStrategy, m_liquifyStrategy, m_meshStrategy, m_perspectiveStrategy, m_warpStrategy, ToolTransformArgs::MESH, ToolTransformArgs::mode(), and ToolTransformArgs::WARP.

◆ cursorOutlineUpdateRequested

void KisToolTransform::cursorOutlineUpdateRequested ( const QPointF & imagePos )

slot

Definition at line 322 of file kis_tool_transform.cc.

{
    QRect canvasUpdateRect;
 
    if (!m_cursorOutline.isEmpty()) {
        canvasUpdateRect = m_canvas->coordinatesConverter()->
            imageToDocument(m_cursorOutline.boundingRect()).toAlignedRect();
    }
 
    m_cursorOutline = currentStrategy()->
        getCursorOutline().translated(imagePos);
 
    if (!m_cursorOutline.isEmpty()) {
        canvasUpdateRect |=
            m_canvas->coordinatesConverter()->
            imageToDocument(m_cursorOutline.boundingRect()).toAlignedRect();
    }
 
    if (!canvasUpdateRect.isEmpty()) {
        // grow rect a bit to follow interpolation fuzziness
        canvasUpdateRect = kisGrowRect(canvasUpdateRect, 2);
        m_canvas->updateCanvas(canvasUpdateRect);
    }
}

References currentStrategy(), kisGrowRect(), m_canvas, and m_cursorOutline.

◆ deactivate

void KisToolTransform::deactivate ( )

overrideslot

Definition at line 850 of file kis_tool_transform.cc.

{
    endStroke();
    m_canvas->updateCanvas();
    m_actionConnections.clear();
    KisTool::deactivate();
}

References KisSignalAutoConnectionsStore::clear(), KisTool::deactivate(), endStroke(), m_actionConnections, and m_canvas.

◆ deactivateAlternateAction()

void KisToolTransform::deactivateAlternateAction ( AlternateAction action )

overridevirtual

Reimplemented from KisTool.

Definition at line 487 of file kis_tool_transform.cc.

{
    currentStrategy()->deactivateAlternateAction(action);
}

References KoToolBase::action(), currentStrategy(), and KisTransformStrategyBase::deactivateAlternateAction().

◆ deactivatePrimaryAction()

void KisToolTransform::deactivatePrimaryAction ( )

overridevirtual

Called by KisToolProxy when the primary is no longer possible to be started now, e.g. when its modifiers and released. The tool is supposed to revert all the preparations it has done in activatePrimaryAction().

Reimplemented from KisTool.

Definition at line 476 of file kis_tool_transform.cc.

{
    currentStrategy()->deactivatePrimaryAction();
}

References currentStrategy(), and KisTransformStrategyBase::deactivatePrimaryAction().

◆ endActionImpl()

void KisToolTransform::endActionImpl	(	KoPointerEvent *	event,
		bool	usePrimaryAction,
		KisTool::AlternateAction	action )

Definition at line 392 of file kis_tool_transform.cc.

{
    if (mode() != KisTool::PAINT_MODE) return;
 
    setMode(KisTool::HOVER_MODE);
 
    if (m_actuallyMoveWhileSelected ||
        currentStrategy()->acceptsClicks()) {
 
        bool result = false;
 
        if (usePrimaryAction) {
            result = currentStrategy()->endPrimaryAction(event);
        } else {
            result = currentStrategy()->endAlternateAction(event, action);
        }
 
        if (result) {
            commitChanges();
        }
 
        outlineChanged();
    }
 
    updateOptionWidget();
    updateApplyResetAvailability();
}

References KoToolBase::action(), commitChanges(), currentStrategy(), KisTransformStrategyBase::endAlternateAction(), KisTransformStrategyBase::endPrimaryAction(), KisTool::HOVER_MODE, m_actuallyMoveWhileSelected, KisTool::mode(), outlineChanged(), KisTool::PAINT_MODE, KisTool::setMode(), updateApplyResetAvailability(), and updateOptionWidget().

◆ endAlternateAction()

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

overridevirtual

Reimplemented from KisTool.

Definition at line 502 of file kis_tool_transform.cc.

{
    endActionImpl(event, false, action);
}

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

◆ endPrimaryAction()

void KisToolTransform::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 465 of file kis_tool_transform.cc.

{
    endActionImpl(event, true, KisTool::NONE);
}

References endActionImpl(), and KisTool::NONE.

◆ endStroke()

void KisToolTransform::endStroke ( )

private

Definition at line 1025 of file kis_tool_transform.cc.

{
    if (!m_strokeId) return;
 
    if (m_currentlyUsingOverlayPreviewStyle &&
        !m_transaction.rootNodes().isEmpty() &&
        !m_currentArgs.isUnchanging()) {
 
        image()->addJob(m_strokeId,
                        new TransformStrokeStrategy::TransformAllData(m_currentArgs));
    }
 
    if (m_asyncUpdateHelper.isActive()) {
        m_asyncUpdateHelper.endUpdateStream();
    }
 
    image()->endStroke(m_strokeId);
 
    m_strokeStrategyCookie = 0;
    m_strokeId.clear();
    m_changesTracker.reset();
    m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeList(), {});
    outlineChanged();
}

References KisImage::addJob(), KisImage::endStroke(), KisAsynchronousStrokeUpdateHelper::endUpdateStream(), KisTool::image(), KisAsynchronousStrokeUpdateHelper::isActive(), ToolTransformArgs::isUnchanging(), m_asyncUpdateHelper, m_changesTracker, m_currentArgs, m_currentlyUsingOverlayPreviewStyle, m_strokeId, m_strokeStrategyCookie, m_transaction, outlineChanged(), KisToolChangesTracker::reset(), and TransformTransactionProperties::rootNodes().

◆ freeTransformChanged

void KisToolTransform::freeTransformChanged ( )

signal

◆ imageTooBigRequested

void KisToolTransform::imageTooBigRequested ( bool value )

slot

Definition at line 217 of file kis_tool_transform.cc.

{
    if (!m_optionsWidget) return;
    m_optionsWidget->setTooBigLabelVisible(value);
}

References m_optionsWidget, KisToolTransformConfigWidget::setTooBigLabelVisible(), and value().

◆ initGuiAfterTransformMode()

void KisToolTransform::initGuiAfterTransformMode ( )

private

Definition at line 750 of file kis_tool_transform.cc.

{
    currentStrategy()->externalConfigChanged();
    outlineChanged();
    updateOptionWidget();
    updateApplyResetAvailability();
    setFunctionalCursor();
}

References currentStrategy(), KisTransformStrategyBase::externalConfigChanged(), outlineChanged(), setFunctionalCursor(), updateApplyResetAvailability(), and updateOptionWidget().

◆ initThumbnailImage()

void KisToolTransform::initThumbnailImage ( KisPaintDeviceSP previewDevice )

private

Definition at line 759 of file kis_tool_transform.cc.

{
    QImage origImg;
    m_selectedPortionCache = previewDevice;
 
    QTransform thumbToImageTransform;
 
    const int maxSize = 2000;
 
    QRect srcRect(m_transaction.originalRect().toAlignedRect());
    int x, y, w, h;
    srcRect.getRect(&x, &y, &w, &h);
 
    if (m_selectedPortionCache) {
        if (w > maxSize || h > maxSize) {
            qreal scale = qreal(maxSize) / (w > h ? w : h);
            QTransform scaleTransform = QTransform::fromScale(scale, scale);
 
            QRect thumbRect = scaleTransform.mapRect(m_transaction.originalRect()).toAlignedRect();
 
            origImg = m_selectedPortionCache->
                    createThumbnail(thumbRect.width(),
                                    thumbRect.height(),
                                    srcRect, 1,
                                    KoColorConversionTransformation::internalRenderingIntent(),
                                    KoColorConversionTransformation::internalConversionFlags());
            thumbToImageTransform = scaleTransform.inverted();
 
        } else {
            origImg = m_selectedPortionCache->convertToQImage(0, x, y, w, h,
                                                              KoColorConversionTransformation::internalRenderingIntent(),
                                                              KoColorConversionTransformation::internalConversionFlags());
            thumbToImageTransform = QTransform();
        }
    }
 
    // init both strokes since the thumbnail is initialized only once
    // during the stroke
    m_freeStrategy->setThumbnailImage(origImg, thumbToImageTransform);
    m_perspectiveStrategy->setThumbnailImage(origImg, thumbToImageTransform);
    m_warpStrategy->setThumbnailImage(origImg, thumbToImageTransform);
    m_cageStrategy->setThumbnailImage(origImg, thumbToImageTransform);
    m_liquifyStrategy->setThumbnailImage(origImg, thumbToImageTransform);
    m_meshStrategy->setThumbnailImage(origImg, thumbToImageTransform);
}

References KisPaintDevice::convertToQImage(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), m_cageStrategy, m_freeStrategy, m_liquifyStrategy, m_meshStrategy, m_perspectiveStrategy, m_selectedPortionCache, m_transaction, m_warpStrategy, and TransformTransactionProperties::originalRect().

◆ initTransformMode()

void KisToolTransform::initTransformMode ( ToolTransformArgs::TransformMode mode )

private

Definition at line 744 of file kis_tool_transform.cc.

{
    m_currentArgs = KisTransformUtils::resetArgsForMode(mode, m_currentArgs.filterId(), m_transaction, m_currentArgs.externalSource());
    initGuiAfterTransformMode();
}

References ToolTransformArgs::externalSource(), ToolTransformArgs::filterId(), initGuiAfterTransformMode(), m_currentArgs, m_transaction, KisTool::mode(), and KisTransformUtils::resetArgsForMode().

◆ mouseMoveEvent()

void KisToolTransform::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 520 of file kis_tool_transform.cc.

{
    QPointF mousePos = m_canvas->coordinatesConverter()->documentToImage(event->point);
 
    cursorOutlineUpdateRequested(mousePos);
 
    if (this->mode() != KisTool::PAINT_MODE) {
        currentStrategy()->hoverActionCommon(event);
        setFunctionalCursor();
        KisTool::mouseMoveEvent(event);
        return;
    }
}

References currentStrategy(), cursorOutlineUpdateRequested(), KisTransformStrategyBase::hoverActionCommon(), m_canvas, KisTool::mode(), KisTool::mouseMoveEvent(), KisTool::PAINT_MODE, KoPointerEvent::point, and setFunctionalCursor().

◆ mousePressEvent()

void KisToolTransform::mousePressEvent ( KoPointerEvent * event )

overridevirtual

Called when (one of) the mouse or stylus buttons is pressed. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus press

Reimplemented from KisTool.

Definition at line 507 of file kis_tool_transform.cc.

{
    // When using touch drawing, we only ever receive move events after the
    // finger has pressed down. This confuses the strategies greatly, since they
    // expect to receive a hover to tell which anchor the user wants to
    // manipulate or similar. So in this case, we send an artificial hover.
    if (event->isTouchEvent() && this->mode() != KisTool::PAINT_MODE) {
        currentStrategy()->hoverActionCommon(event);
        setFunctionalCursor();
    }
    KisTool::mousePressEvent(event);
}

References currentStrategy(), KisTransformStrategyBase::hoverActionCommon(), KoPointerEvent::isTouchEvent(), KisTool::mousePressEvent(), KisTool::PAINT_MODE, and setFunctionalCursor().

◆ mouseReleaseEvent()

void KisToolTransform::mouseReleaseEvent ( KoPointerEvent * event )

overridevirtual

Called when (one of) the mouse or stylus buttons is released. Implementors should call event->ignore() if they do not actually use the event.

Parameters

event state and reason of this mouse or stylus release

Reimplemented from KisTool.

Definition at line 534 of file kis_tool_transform.cc.

{
    KisTool::mouseReleaseEvent(event);
}

References KisTool::mouseReleaseEvent().

◆ newActivationWithExternalSource()

void KisToolTransform::newActivationWithExternalSource ( KisPaintDeviceSP externalSource )

overridevirtual

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.

This is currently implemented by the Transform tool to paste an image into the current layer and transform it.

Reimplemented from KisTool.

Definition at line 805 of file kis_tool_transform.cc.

{
    m_externalSourceForNextActivation = externalSource;
    if (isActive()) {
        QSet<KoShape*> dummy;
        deactivate();
        activate(dummy);
    } else {
        KoToolManager::instance()->switchToolRequested("KisToolTransform");
    }
}

References activate(), deactivate(), KoToolManager::instance(), KisTool::isActive, m_externalSourceForNextActivation, and KoToolManager::switchToolRequested().

◆ outlineChanged()

void KisToolTransform::outlineChanged ( )

private

Definition at line 188 of file kis_tool_transform.cc.

{
    Q_EMIT freeTransformChanged();
    m_canvas->updateCanvas();
}

References freeTransformChanged(), and m_canvas.

◆ paint()

void KisToolTransform::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 283 of file kis_tool_transform.cc.

{
    Q_UNUSED(converter);
 
    if (!m_strokeId || m_transaction.rootNodes().isEmpty()) return;
 
    QRectF newRefRect = KisTransformUtils::imageToFlake(m_canvas->coordinatesConverter(), QRectF(0.0,0.0,1.0,1.0));
    if (m_refRect != newRefRect) {
        m_refRect = newRefRect;
        currentStrategy()->externalConfigChanged();
    }
    currentStrategy()->setDecorationThickness(decorationThickness());
    currentStrategy()->paint(gc);
 
 
    if (!m_cursorOutline.isEmpty()) {
        QPainterPath mappedOutline =
            KisTransformUtils::imageToFlakeTransform(
                m_canvas->coordinatesConverter()).map(m_cursorOutline);
        paintToolOutline(&gc, mappedOutline);
    }
}

References currentStrategy(), KoToolBase::decorationThickness(), KisTransformStrategyBase::externalConfigChanged(), KisTransformUtils::imageToFlake(), KisTransformUtils::imageToFlakeTransform(), m_canvas, m_cursorOutline, m_refRect, m_strokeId, m_transaction, KisTransformStrategyBase::paint(), KisTool::paintToolOutline(), TransformTransactionProperties::rootNodes(), and KisTransformStrategyBase::setDecorationThickness().

◆ popupActionsMenu()

QMenu * KisToolTransform::popupActionsMenu ( )

overridevirtual

Returns: a menu with context-aware actions for the current selection. If the returned value is null, no context menu is shown.

Reimplemented from KoToolBase.

Definition at line 420 of file kis_tool_transform.cc.

{
    if (m_contextMenu) {
        m_contextMenu->clear();
 
        m_contextMenu->addSection(i18n("Transform Tool Actions"));
        // add a quick switch to different transform types
        m_contextMenu->addAction(freeTransformAction);
        m_contextMenu->addAction(perspectiveAction);
        m_contextMenu->addAction(warpAction);
        m_contextMenu->addAction(cageAction);
        m_contextMenu->addAction(liquifyAction);
        m_contextMenu->addAction(meshAction);
 
        // extra options if free transform is selected
        if (transformMode() == FreeTransformMode) {
            m_contextMenu->addSeparator();
            m_contextMenu->addAction(mirrorHorizontalAction);
            m_contextMenu->addAction(mirrorVerticalAction);
            m_contextMenu->addAction(rotateNinetyCWAction);
            m_contextMenu->addAction(rotateNinetyCCWAction);
 
            m_contextMenu->addSeparator();
            keepAspectRatioAction->setChecked(m_currentArgs.keepAspectRatio());
            m_contextMenu->addAction(keepAspectRatioAction);
        }
 
        m_contextMenu->addSeparator();
        m_contextMenu->addAction(applyTransformation);
        m_contextMenu->addAction(resetTransformation);
    }
 
    return m_contextMenu.data();
}

References applyTransformation, cageAction, freeTransformAction, FreeTransformMode, ToolTransformArgs::keepAspectRatio(), keepAspectRatioAction, liquifyAction, m_contextMenu, m_currentArgs, meshAction, mirrorHorizontalAction, mirrorVerticalAction, perspectiveAction, resetTransformation, rotateNinetyCCWAction, rotateNinetyCWAction, transformMode, and warpAction.

◆ requestImageRecalculation

void KisToolTransform::requestImageRecalculation ( )

slot

Definition at line 892 of file kis_tool_transform.cc.

{
    if (!m_currentlyUsingOverlayPreviewStyle && m_strokeId && !m_transaction.rootNodes().isEmpty()) {
        image()->addJob(
            m_strokeId,
            new InplaceTransformStrokeStrategy::UpdateTransformData(
                m_currentArgs,
                InplaceTransformStrokeStrategy::UpdateTransformData::PAINT_DEVICE));
    }
}

References KisImage::addJob(), KisTool::image(), m_currentArgs, m_currentlyUsingOverlayPreviewStyle, m_strokeId, m_transaction, InplaceTransformStrokeStrategy::UpdateTransformData::PAINT_DEVICE, and TransformTransactionProperties::rootNodes().

◆ requestRedoDuringStroke

void KisToolTransform::requestRedoDuringStroke ( )

overrideslot

Definition at line 869 of file kis_tool_transform.cc.

{
    if (!m_strokeId || m_transaction.rootNodes().isEmpty()) return;
 
    if (m_changesTracker.canRedo()) {
        m_changesTracker.requestRedo();
    }
}

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

◆ requestStrokeCancellation

void KisToolTransform::requestStrokeCancellation ( )

overrideslot

Definition at line 883 of file kis_tool_transform.cc.

{
    if (m_transaction.rootNodes().isEmpty() || m_currentArgs.isIdentity()) {
        cancelStroke();
    } else {
        slotCancelTransform();
    }
}

References cancelStroke(), ToolTransformArgs::isIdentity(), m_currentArgs, m_transaction, TransformTransactionProperties::rootNodes(), and slotCancelTransform().

◆ requestStrokeEnd

void KisToolTransform::requestStrokeEnd ( )

overrideslot

Definition at line 878 of file kis_tool_transform.cc.

{
    endStroke();
}

References endStroke().

◆ requestUndoDuringStroke

void KisToolTransform::requestUndoDuringStroke ( )

overrideslot

Definition at line 858 of file kis_tool_transform.cc.

{
    if (!m_strokeId || m_transaction.rootNodes().isEmpty() || mode() != HOVER_MODE) return;
 
    if (!m_changesTracker.canUndo()) {
        cancelStroke();
    } else {
        m_changesTracker.requestUndo();
    }
}

References cancelStroke(), KisToolChangesTracker::canUndo(), KisTool::HOVER_MODE, m_changesTracker, m_strokeId, m_transaction, KisTool::mode(), KisToolChangesTracker::requestUndo(), and TransformTransactionProperties::rootNodes().

◆ resetCursorStyle

void KisToolTransform::resetCursorStyle ( )

overrideprotectedslot

Definition at line 199 of file kis_tool_transform.cc.

{
    setFunctionalCursor();
}

References setFunctionalCursor().

◆ resetRotationCenterButtonsRequested

void KisToolTransform::resetRotationCenterButtonsRequested ( )

slot

Definition at line 211 of file kis_tool_transform.cc.

{
    if (!m_optionsWidget) return;
    m_optionsWidget->resetRotationCenterButtons();
}

References m_optionsWidget, and KisToolTransformConfigWidget::resetRotationCenterButtons().

◆ rotateX()

double KisToolTransform::rotateX ( ) const

Definition at line 590 of file kis_tool_transform.cc.

{
    return m_currentArgs.aX();
}

References ToolTransformArgs::aX(), and m_currentArgs.

◆ rotateY()

double KisToolTransform::rotateY ( ) const

Definition at line 595 of file kis_tool_transform.cc.

{
    return m_currentArgs.aY();
}

References ToolTransformArgs::aY(), and m_currentArgs.

◆ rotateZ()

double KisToolTransform::rotateZ ( ) const

Definition at line 600 of file kis_tool_transform.cc.

{
    return m_currentArgs.aZ();
}

References ToolTransformArgs::aZ(), and m_currentArgs.

◆ scaleX()

double KisToolTransform::scaleX ( ) const

Definition at line 605 of file kis_tool_transform.cc.

{
    return m_currentArgs.scaleX();
}

References m_currentArgs, and ToolTransformArgs::scaleX().

◆ scaleY()

double KisToolTransform::scaleY ( ) const

Definition at line 610 of file kis_tool_transform.cc.

{
    return m_currentArgs.scaleY();
}

References m_currentArgs, and ToolTransformArgs::scaleY().

◆ setFunctionalCursor()

void KisToolTransform::setFunctionalCursor ( )

private

Definition at line 306 of file kis_tool_transform.cc.

{
    if (overrideCursorIfNotEditable()) {
        return;
    }
 
    if (!m_strokeId) {
        useCursor(KisCursor::pointingHandCursor());
    } else if (m_strokeId && m_transaction.rootNodes().isEmpty()) {
        // we are in the middle of stroke initialization
        useCursor(KisCursor::waitCursor());
    } else {
        useCursor(currentStrategy()->getCurrentCursor());
    }
}

References currentStrategy(), m_strokeId, m_transaction, KisTool::overrideCursorIfNotEditable(), KisCursor::pointingHandCursor(), TransformTransactionProperties::rootNodes(), KoToolBase::useCursor(), and KisCursor::waitCursor().

◆ setNextActivationTransformMode()

void KisToolTransform::setNextActivationTransformMode ( KisToolTransform::TransformToolMode mode )

Definition at line 544 of file kis_tool_transform.cc.

{
    nextActivationTransformMode = mode;
}

References KisTool::mode(), and nextActivationTransformMode.

◆ setRotateX

void KisToolTransform::setRotateX ( double rotation )

slot

Definition at line 702 of file kis_tool_transform.cc.

{
    m_currentArgs.setAX( rotation );
}

References m_currentArgs, and ToolTransformArgs::setAX().

◆ setRotateY

void KisToolTransform::setRotateY ( double rotation )

slot

Definition at line 707 of file kis_tool_transform.cc.

{
    m_currentArgs.setAY( rotation );
}

References m_currentArgs, and ToolTransformArgs::setAY().

◆ setRotateZ

void KisToolTransform::setRotateZ ( double rotation )

slot

Definition at line 712 of file kis_tool_transform.cc.

{
    m_currentArgs.setAZ( rotation );
}

References m_currentArgs, and ToolTransformArgs::setAZ().

◆ setScaleX

void KisToolTransform::setScaleX ( double scaleX )

slot

Definition at line 1425 of file kis_tool_transform.cc.

{
    m_optionsWidget->slotSetScaleX(scale);
}

References m_optionsWidget, and KisToolTransformConfigWidget::slotSetScaleX().

◆ setScaleY

void KisToolTransform::setScaleY ( double scaleY )

slot

Definition at line 1420 of file kis_tool_transform.cc.

{
    m_optionsWidget->slotSetScaleY(scale);
}

References m_optionsWidget, and KisToolTransformConfigWidget::slotSetScaleY().

◆ setShearX

void KisToolTransform::setShearX ( double shearX )

slot

Definition at line 1415 of file kis_tool_transform.cc.

{
    m_optionsWidget->slotSetShearX(shear);
}

References m_optionsWidget, and KisToolTransformConfigWidget::slotSetShearX().

◆ setShearY

void KisToolTransform::setShearY ( double shearY )

slot

Definition at line 1410 of file kis_tool_transform.cc.

{
    m_optionsWidget->slotSetShearY(shear);
}

References m_optionsWidget, and KisToolTransformConfigWidget::slotSetShearY().

◆ setTransformFunction()

void KisToolTransform::setTransformFunction	(	QPointF	mousePos,
		Qt::KeyboardModifiers	modifiers )

private

◆ setTransformMode

void KisToolTransform::setTransformMode ( KisToolTransform::TransformToolMode newMode )

slot

Definition at line 679 of file kis_tool_transform.cc.

{
    ToolTransformArgs::TransformMode mode = toArgsMode(newMode);
 
    if( mode != m_currentArgs.mode() ) {
        if( newMode == FreeTransformMode ) {
            m_optionsWidget->slotSetFreeTransformModeButtonClicked( true );
        } else if( newMode == WarpTransformMode ) {
            m_optionsWidget->slotSetWarpModeButtonClicked( true );
        } else if( newMode == CageTransformMode ) {
            m_optionsWidget->slotSetCageModeButtonClicked( true );
        } else if( newMode == LiquifyTransformMode ) {
            m_optionsWidget->slotSetLiquifyModeButtonClicked( true );
        } else if( newMode == PerspectiveTransformMode ) {
            m_optionsWidget->slotSetPerspectiveModeButtonClicked( true );
        } else if( newMode == MeshTransformMode ) {
            m_optionsWidget->slotSetMeshModeButtonClicked( true );
        }
 
        Q_EMIT transformModeChanged();
    }
}

References CageTransformMode, FreeTransformMode, LiquifyTransformMode, m_currentArgs, m_optionsWidget, MeshTransformMode, KisTool::mode(), ToolTransformArgs::mode(), PerspectiveTransformMode, KisToolTransformConfigWidget::slotSetCageModeButtonClicked(), KisToolTransformConfigWidget::slotSetFreeTransformModeButtonClicked(), KisToolTransformConfigWidget::slotSetLiquifyModeButtonClicked(), KisToolTransformConfigWidget::slotSetMeshModeButtonClicked(), KisToolTransformConfigWidget::slotSetPerspectiveModeButtonClicked(), KisToolTransformConfigWidget::slotSetWarpModeButtonClicked(), toArgsMode(), transformModeChanged(), and WarpTransformMode.

◆ setTranslateX

void KisToolTransform::setTranslateX ( double translateX )

slot

Definition at line 1442 of file kis_tool_transform.cc.

{
    TransformToolMode mode = transformMode();
 
    if (m_strokeId && (mode == FreeTransformMode || mode == PerspectiveTransformMode)) {
        m_currentArgs.setTransformedCenter(QPointF(translation, translateY()));
        currentStrategy()->externalConfigChanged();
        updateOptionWidget();
        outlineChanged();
    }
}

References currentStrategy(), KisTransformStrategyBase::externalConfigChanged(), FreeTransformMode, m_currentArgs, m_strokeId, KisTool::mode(), outlineChanged(), PerspectiveTransformMode, ToolTransformArgs::setTransformedCenter(), transformMode, translateY, and updateOptionWidget().

◆ setTranslateY

void KisToolTransform::setTranslateY ( double translateY )

slot

Definition at line 1430 of file kis_tool_transform.cc.

{
    TransformToolMode mode = transformMode();
 
    if (m_strokeId && (mode == FreeTransformMode || mode == PerspectiveTransformMode)) {
        m_currentArgs.setTransformedCenter(QPointF(translateX(), translation));
        currentStrategy()->externalConfigChanged();
        updateOptionWidget();
        outlineChanged();
    }
}

References currentStrategy(), KisTransformStrategyBase::externalConfigChanged(), FreeTransformMode, m_currentArgs, m_strokeId, KisTool::mode(), outlineChanged(), PerspectiveTransformMode, ToolTransformArgs::setTransformedCenter(), transformMode, translateX, and updateOptionWidget().

◆ setWarpFlexibility

void KisToolTransform::setWarpFlexibility ( double flexibility )

slot

Definition at line 734 of file kis_tool_transform.cc.

{
    m_currentArgs.setAlpha( flexibility );
}

References m_currentArgs, and ToolTransformArgs::setAlpha().

◆ setWarpPointDensity

void KisToolTransform::setWarpPointDensity ( int density )

slot

Definition at line 739 of file kis_tool_transform.cc.

{
    m_optionsWidget->slotSetWarpDensity(density);
}

References m_optionsWidget, and KisToolTransformConfigWidget::slotSetWarpDensity().

◆ setWarpType

void KisToolTransform::setWarpType ( KisToolTransform::WarpType type )

slot

Definition at line 717 of file kis_tool_transform.cc.

{
    switch( type ) {
    case RigidWarpType:
        m_currentArgs.setWarpType(KisWarpTransformWorker::RIGID_TRANSFORM);
        break;
    case AffineWarpType:
        m_currentArgs.setWarpType(KisWarpTransformWorker::AFFINE_TRANSFORM);
        break;
    case SimilitudeWarpType:
        m_currentArgs.setWarpType(KisWarpTransformWorker::SIMILITUDE_TRANSFORM);
        break;
    default:
        break;
    }
}

References KisWarpTransformWorker::AFFINE_TRANSFORM, AffineWarpType, m_currentArgs, KisWarpTransformWorker::RIGID_TRANSFORM, RigidWarpType, ToolTransformArgs::setWarpType(), KisWarpTransformWorker::SIMILITUDE_TRANSFORM, and SimilitudeWarpType.

◆ shearX()

double KisToolTransform::shearX ( ) const

Definition at line 615 of file kis_tool_transform.cc.

{
    return m_currentArgs.shearX();
}

References m_currentArgs, and ToolTransformArgs::shearX().

◆ shearY()

double KisToolTransform::shearY ( ) const

Definition at line 620 of file kis_tool_transform.cc.

{
    return m_currentArgs.shearY();
}

References m_currentArgs, and ToolTransformArgs::shearY().

◆ slotApplyTransform

void KisToolTransform::slotApplyTransform ( )

privateslot

Definition at line 1246 of file kis_tool_transform.cc.

{
    KisCursorOverrideLock cursorLock(KisCursor::waitCursor());
    endStroke();
}

References endStroke(), and KisCursor::waitCursor().

◆ slotCancelTransform

void KisToolTransform::slotCancelTransform ( )

privateslot

Definition at line 1306 of file kis_tool_transform.cc.

{
    slotResetTransform(m_transaction.currentConfig()->mode());
}

References TransformTransactionProperties::currentConfig(), m_transaction, ToolTransformArgs::mode(), and slotResetTransform().

◆ slotConvexHullCalculated

void KisToolTransform::slotConvexHullCalculated	(	QPolygon	hull,
		void *	strokeStrategyCookie )

slot

Only use the convex hull if it matches the original bounding rect. When we skip setConvexHull() call, nothing serious happens, except that rotatted bounds are rotated around the entire clip rect, not actual clip's data.

Definition at line 245 of file kis_tool_transform.cc.

{
    if (!m_strokeId || strokeStrategyCookie != m_strokeStrategyCookie) return;
    QPolygonF hullF = hull;
    if (hullF.boundingRect() == m_transaction.originalRect()) {
        m_transaction.setConvexHull(hullF);
        currentStrategy()->externalConfigChanged();
        canvasUpdateRequested();
    } else {
        warnTools << "WARNING: KisToolTransform: calculated convex hull's bounds "
                     "differ from the bounding rect of the source clip. It shouldn't "
                     "have happened";
    }
}

References canvasUpdateRequested(), currentStrategy(), KisTransformStrategyBase::externalConfigChanged(), m_strokeId, m_strokeStrategyCookie, m_transaction, TransformTransactionProperties::originalRect(), TransformTransactionProperties::setConvexHull(), and warnTools.

◆ slotEditingFinished

void KisToolTransform::slotEditingFinished ( )

privateslot

Definition at line 1335 of file kis_tool_transform.cc.

{
    commitChanges();
}

References commitChanges().

◆ slotGlobalConfigChanged

void KisToolTransform::slotGlobalConfigChanged ( )

protectedslot

Definition at line 204 of file kis_tool_transform.cc.

{
    KConfigGroup group = KSharedConfig::openConfig()->group(toolId());
    m_preferOverlayPreviewStyle = group.readEntry("useOverlayPreviewStyle", false);
    m_forceLodMode = group.readEntry("forceLodMode", true);
}

References m_forceLodMode, m_preferOverlayPreviewStyle, and KoToolBase::toolId().

◆ slotMoveDiscreteDown

void KisToolTransform::slotMoveDiscreteDown ( )

privateslot

Definition at line 1350 of file kis_tool_transform.cc.

{
    setTranslateY(translateY()+1.0);
}

References setTranslateY(), and translateY.

◆ slotMoveDiscreteDownMore

void KisToolTransform::slotMoveDiscreteDownMore ( )

privateslot

Definition at line 1355 of file kis_tool_transform.cc.

{
    setTranslateY(translateY()+10.0);
}

References setTranslateY(), and translateY.

◆ slotMoveDiscreteLeft

void KisToolTransform::slotMoveDiscreteLeft ( )

privateslot

Definition at line 1360 of file kis_tool_transform.cc.

{
    setTranslateX(translateX()-1.0);
}

References setTranslateX(), and translateX.

◆ slotMoveDiscreteLeftMore

void KisToolTransform::slotMoveDiscreteLeftMore ( )

privateslot

Definition at line 1365 of file kis_tool_transform.cc.

{
    setTranslateX(translateX()-10.0);
}

References setTranslateX(), and translateX.

◆ slotMoveDiscreteRight

void KisToolTransform::slotMoveDiscreteRight ( )

privateslot

Definition at line 1370 of file kis_tool_transform.cc.

{
    setTranslateX(translateX()+1.0);
}

References setTranslateX(), and translateX.

◆ slotMoveDiscreteRightMore

void KisToolTransform::slotMoveDiscreteRightMore ( )

privateslot

Definition at line 1375 of file kis_tool_transform.cc.

{
    setTranslateX(translateX()+10.0);
}

References setTranslateX(), and translateX.

◆ slotMoveDiscreteUp

void KisToolTransform::slotMoveDiscreteUp ( )

privateslot

Definition at line 1340 of file kis_tool_transform.cc.

{
    setTranslateY(translateY()-1.0);
}

References setTranslateY(), and translateY.

◆ slotMoveDiscreteUpMore

void KisToolTransform::slotMoveDiscreteUpMore ( )

privateslot

Definition at line 1345 of file kis_tool_transform.cc.

{
    setTranslateY(translateY()-10.0);
}

References setTranslateY(), and translateY.

◆ slotPreviewDeviceGenerated

void KisToolTransform::slotPreviewDeviceGenerated ( KisPaintDeviceSP device )

privateslot

Definition at line 1093 of file kis_tool_transform.cc.

{
    if (device && device->exactBounds().isEmpty()) {
        KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
        KIS_SAFE_ASSERT_RECOVER(kisCanvas) { cancelStroke(); return; }
        kisCanvas->viewManager()->
            showFloatingMessage(
                i18nc("floating message in transformation tool",
                      "Cannot transform empty layer "),
                QIcon(), 1000, KisFloatingMessage::Medium);
 
        cancelStroke();
    } else {
        initThumbnailImage(device);
        initGuiAfterTransformMode();
    }
}

References cancelStroke(), Private::canvas, KisPaintDevice::exactBounds(), initGuiAfterTransformMode(), initThumbnailImage(), KIS_SAFE_ASSERT_RECOVER, KisFloatingMessage::Medium, and KisCanvas2::viewManager().

◆ slotResetTransform

void KisToolTransform::slotResetTransform ( ToolTransformArgs::TransformMode mode )

privateslot

Our reset transform button can be used for two purposes:

1) Reset current transform to the initial one, which was loaded from the previous user action.

2) Reset transform frame to infinity when the frame is unchanged

Definition at line 1252 of file kis_tool_transform.cc.

{
    ToolTransformArgs *config = m_transaction.currentConfig();
    const ToolTransformArgs::TransformMode previousMode = config->mode();
    config->setMode(mode);
 
    if (mode == ToolTransformArgs::WARP) {
        config->setWarpCalculation(KisWarpTransformWorker::WarpCalculation::GRID);
    }
 
    if (!m_strokeId || m_transaction.rootNodes().isEmpty()) return;
 
    if (m_currentArgs.continuedTransform()) {
        ToolTransformArgs::TransformMode savedMode = m_currentArgs.mode();
 
        const bool transformDiffers = !m_currentArgs.continuedTransform()->isSameMode(m_currentArgs);
 
        if (transformDiffers &&
            m_currentArgs.continuedTransform()->mode() == savedMode) {
 
            m_currentArgs.restoreContinuedState();
            initGuiAfterTransformMode();
            slotEditingFinished();
 
        } else {
            cancelStroke();
            startStroke(savedMode, true);
 
            KIS_ASSERT_RECOVER_NOOP(!m_currentArgs.continuedTransform());
        }
    } else {
        if (!KisTransformUtils::shouldRestartStrokeOnModeChange(previousMode,
                                                                m_currentArgs.mode(),
                                                                m_transaction.transformedNodes())) {
            initTransformMode(m_currentArgs.mode());
            slotEditingFinished();
 
        } else {
            cancelStroke();
            startStroke(m_currentArgs.mode(), true);
 
        }
    }
}

References cancelStroke(), ToolTransformArgs::continuedTransform(), TransformTransactionProperties::currentConfig(), initGuiAfterTransformMode(), initTransformMode(), ToolTransformArgs::isSameMode(), KIS_ASSERT_RECOVER_NOOP, m_currentArgs, m_strokeId, m_transaction, KisTool::mode(), ToolTransformArgs::mode(), ToolTransformArgs::restoreContinuedState(), TransformTransactionProperties::rootNodes(), ToolTransformArgs::setMode(), ToolTransformArgs::setWarpCalculation(), KisTransformUtils::shouldRestartStrokeOnModeChange(), slotEditingFinished(), startStroke(), TransformTransactionProperties::transformedNodes(), and ToolTransformArgs::WARP.

◆ slotRestartAndContinueTransform

void KisToolTransform::slotRestartAndContinueTransform ( )

privateslot

Definition at line 1323 of file kis_tool_transform.cc.

{
    if (!m_strokeId || m_transaction.rootNodes().isEmpty()) return;
 
    KisNodeSP root = m_transaction.rootNodes()[0];
    KIS_ASSERT_RECOVER_RETURN(root); // the stroke is guaranteed to be started by an 'if' above
 
    ToolTransformArgs savedArgs(m_currentArgs);
    endStroke();
    startStroke(savedArgs.mode(), false);
}

References endStroke(), KIS_ASSERT_RECOVER_RETURN, m_currentArgs, m_strokeId, m_transaction, ToolTransformArgs::mode(), TransformTransactionProperties::rootNodes(), and startStroke().

◆ slotRestartTransform

void KisToolTransform::slotRestartTransform ( )

privateslot

Definition at line 1311 of file kis_tool_transform.cc.

{
    if (!m_strokeId || m_transaction.rootNodes().isEmpty()) return;
 
    KisNodeSP root = m_transaction.rootNodes()[0];
    KIS_ASSERT_RECOVER_RETURN(root); // the stroke is guaranteed to be started by an 'if' above
 
    ToolTransformArgs savedArgs(m_currentArgs);
    cancelStroke();
    startStroke(savedArgs.mode(), true);
}

References cancelStroke(), KIS_ASSERT_RECOVER_RETURN, m_currentArgs, m_strokeId, m_transaction, ToolTransformArgs::mode(), TransformTransactionProperties::rootNodes(), and startStroke().

◆ slotTrackerChangedConfig

void KisToolTransform::slotTrackerChangedConfig ( KisToolChangesTrackerDataSP status )

privateslot

Definition at line 1134 of file kis_tool_transform.cc.

{
    const ToolTransformArgs *newArgs = dynamic_cast<const ToolTransformArgs*>(status.data());
    KIS_SAFE_ASSERT_RECOVER_RETURN(newArgs);
 
    *m_transaction.currentConfig() = *newArgs;
 
    slotUiChangedConfig(true);
    updateOptionWidget();
}

References TransformTransactionProperties::currentConfig(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_transaction, slotUiChangedConfig(), and updateOptionWidget().

◆ slotTransactionGenerated

void KisToolTransform::slotTransactionGenerated	(	TransformTransactionProperties	transaction,
		ToolTransformArgs	args,
		void *	strokeStrategyCookie )

privateslot

Definition at line 1050 of file kis_tool_transform.cc.

{
    if (!m_strokeId || strokeStrategyCookie != m_strokeStrategyCookie) return;
 
    if (transaction.transformedNodes().isEmpty() ||
        transaction.originalRect().isEmpty()) {
 
        KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
        KIS_ASSERT(kisCanvas);
        kisCanvas->viewManager()->
            showFloatingMessage(
                i18nc("floating message in transformation tool",
                      "Cannot transform empty layer "),
                QIcon(), 1000, KisFloatingMessage::Medium);
 
        cancelStroke();
        return;
    }
 
    m_transaction = transaction;
    m_currentArgs = args;
    m_transaction.setCurrentConfigLocation(&m_currentArgs);
 
    if (!m_currentlyUsingOverlayPreviewStyle) {
        m_asyncUpdateHelper.startUpdateStreamLowLevel();
    }
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_changesTracker.isEmpty());
    commitChanges();
 
    initGuiAfterTransformMode();
 
    if (m_transaction.hasInvisibleNodes()) {
        KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
        KIS_ASSERT(kisCanvas);
        kisCanvas->viewManager()->
            showFloatingMessage(
                i18nc("floating message in transformation tool",
                      "Invisible sublayers will also be transformed. Lock layers if you do not want them to be transformed "),
                QIcon(), 4000, KisFloatingMessage::Low);
    }
}

References cancelStroke(), Private::canvas, commitChanges(), TransformTransactionProperties::hasInvisibleNodes(), initGuiAfterTransformMode(), KisToolChangesTracker::isEmpty(), KIS_ASSERT, KIS_SAFE_ASSERT_RECOVER_NOOP, KisFloatingMessage::Low, m_asyncUpdateHelper, m_changesTracker, m_currentArgs, m_currentlyUsingOverlayPreviewStyle, m_strokeId, m_strokeStrategyCookie, m_transaction, KisFloatingMessage::Medium, TransformTransactionProperties::originalRect(), TransformTransactionProperties::setCurrentConfigLocation(), KisAsynchronousStrokeUpdateHelper::startUpdateStreamLowLevel(), TransformTransactionProperties::transformedNodes(), and KisCanvas2::viewManager().

◆ slotUiChangedConfig

void KisToolTransform::slotUiChangedConfig ( bool needsPreviewRecalculation )

privateslot

Definition at line 1230 of file kis_tool_transform.cc.

{
    if (mode() == KisTool::PAINT_MODE) return;
 
    if (needsPreviewRecalculation) {
        currentStrategy()->externalConfigChanged();
    }
 
    if (m_currentArgs.mode() == ToolTransformArgs::LIQUIFY) {
        m_currentArgs.saveLiquifyTransformMode();
    }
 
    outlineChanged();
    updateApplyResetAvailability();
}

References currentStrategy(), KisTransformStrategyBase::externalConfigChanged(), ToolTransformArgs::LIQUIFY, m_currentArgs, KisTool::mode(), ToolTransformArgs::mode(), outlineChanged(), KisTool::PAINT_MODE, ToolTransformArgs::saveLiquifyTransformMode(), and updateApplyResetAvailability().

◆ slotUpdateToCageType

void KisToolTransform::slotUpdateToCageType ( )

privateslot

Definition at line 1405 of file kis_tool_transform.cc.

{
    setTransformMode(KisToolTransform::TransformToolMode::CageTransformMode);
}

References CageTransformMode, and setTransformMode().

◆ slotUpdateToFreeTransformType

void KisToolTransform::slotUpdateToFreeTransformType ( )

privateslot

Definition at line 1390 of file kis_tool_transform.cc.

{
    setTransformMode(KisToolTransform::TransformToolMode::FreeTransformMode);
}

References FreeTransformMode, and setTransformMode().

◆ slotUpdateToLiquifyType

void KisToolTransform::slotUpdateToLiquifyType ( )

privateslot

Definition at line 1395 of file kis_tool_transform.cc.

{
    setTransformMode(KisToolTransform::TransformToolMode::LiquifyTransformMode);
}

References LiquifyTransformMode, and setTransformMode().

◆ slotUpdateToMeshType

void KisToolTransform::slotUpdateToMeshType ( )

privateslot

Definition at line 1400 of file kis_tool_transform.cc.

{
    setTransformMode(KisToolTransform::TransformToolMode::MeshTransformMode);
}

References MeshTransformMode, and setTransformMode().

◆ slotUpdateToPerspectiveType

void KisToolTransform::slotUpdateToPerspectiveType ( )

privateslot

Definition at line 1385 of file kis_tool_transform.cc.

{
    setTransformMode(KisToolTransform::TransformToolMode::PerspectiveTransformMode);
}

References PerspectiveTransformMode, and setTransformMode().

◆ slotUpdateToWarpType

void KisToolTransform::slotUpdateToWarpType ( )

privateslot

Definition at line 1380 of file kis_tool_transform.cc.

{
    setTransformMode(KisToolTransform::TransformToolMode::WarpTransformMode);
}

References setTransformMode(), and WarpTransformMode.

◆ startStroke()

void KisToolTransform::startStroke	(	ToolTransformArgs::TransformMode	mode,
		bool	forceReset )

private

When working with transform mask, selections are not taken into account.

Definition at line 903 of file kis_tool_transform.cc.

{
    Q_ASSERT(!m_strokeId);
 
    KisPaintDeviceSP externalSource = m_externalSourceForNextActivation;
    m_externalSourceForNextActivation.clear();
 
    // set up and null checks before we do anything
    KisResourcesSnapshotSP resources =
            new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager(), 0, selectedNodes(), 0);
    KisNodeList rootNodes = resources->selectedNodes();
    //Filter out any nodes that might be children of other selected nodes so they aren't used twice
    KisLayerUtils::filterMergeableNodes(rootNodes, true);
    KisSelectionSP selection = resources->activeSelection();
 
    m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeList(), {});
    m_currentArgs = ToolTransformArgs();
 
    Q_FOREACH (KisNodeSP currentNode, resources->selectedNodes()) {
        if (!currentNode || !currentNode->isEditable()) return;
 
        // some layer types cannot be transformed. Give a message and return if a user tries it
        if (currentNode->inherits("KisColorizeMask") ||
            currentNode->inherits("KisFileLayer") ||
            currentNode->inherits("KisCloneLayer")) {
 
            KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
            KIS_ASSERT(kisCanvas);
 
            if(currentNode->inherits("KisColorizeMask")){
                kisCanvas->viewManager()->
                    showFloatingMessage(
                        i18nc("floating message in transformation tool",
                              "Layer type cannot use the transform tool"),
                        koIcon("object-locked"), 4000, KisFloatingMessage::High);
            }
            else{
                kisCanvas->viewManager()->
                    showFloatingMessage(
                        i18nc("floating message in transformation tool",
                              "Layer type cannot use the transform tool. Use transform mask instead."),
                        koIcon("object-locked"), 4000, KisFloatingMessage::High);
            }
            return;
        }
 
        KisNodeSP impossibleMask =
            KisLayerUtils::recursiveFindNode(currentNode,
            [currentNode] (KisNodeSP node) {
                // we can process transform masks of the first level
                if (node == currentNode || node->parent() == currentNode) return false;
 
                return node->inherits("KisTransformMask") && node->visible(true);
            });
 
        if (impossibleMask) {
            KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
            kisCanvas->viewManager()->
                showFloatingMessage(
                    i18nc("floating message in transformation tool",
                          "Layer has children with transform masks. Please disable them before doing transformation."),
                    koIcon("object-locked"), 8000, KisFloatingMessage::High);
            return;
        }
 
        if (selection && dynamic_cast<KisTransformMask*>(currentNode.data())) {
            KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
            kisCanvas->viewManager()->
                showFloatingMessage(
                    i18nc("floating message in transformation tool",
                          "Selections are not used when editing transform masks "),
                    QIcon(), 4000, KisFloatingMessage::Low);
 
            selection = 0;
        }
    }
    // Overlay preview is never used when transforming an externally provided image
    m_currentlyUsingOverlayPreviewStyle = m_preferOverlayPreviewStyle && !externalSource;
 
    KisStrokeStrategy *strategy = 0;
 
    if (m_currentlyUsingOverlayPreviewStyle) {
        TransformStrokeStrategy *transformStrategy = new TransformStrokeStrategy(mode, m_currentArgs.filterId(), forceReset, rootNodes, selection, image().data(), image().data());
        connect(transformStrategy, SIGNAL(sigPreviewDeviceReady(KisPaintDeviceSP)), SLOT(slotPreviewDeviceGenerated(KisPaintDeviceSP)));
        connect(transformStrategy, SIGNAL(sigTransactionGenerated(TransformTransactionProperties, ToolTransformArgs, void*)), SLOT(slotTransactionGenerated(TransformTransactionProperties, ToolTransformArgs, void*)));
        connect(transformStrategy, SIGNAL(sigConvexHullCalculated(QPolygon, void*)), SLOT(slotConvexHullCalculated(QPolygon, void*)));
        strategy = transformStrategy;
 
        // save unique identifier of the stroke so we could
        // recognize it when sigTransactionGenerated() is
        // received (theoretically, the user can start two
        // strokes at the same time, if he is quick enough)
        m_strokeStrategyCookie = transformStrategy;
 
    } else {
        InplaceTransformStrokeStrategy *transformStrategy = new InplaceTransformStrokeStrategy(mode, m_currentArgs.filterId(), forceReset, rootNodes, selection, externalSource, image().data(), image().data(), image()->root(), m_forceLodMode);
        connect(transformStrategy, SIGNAL(sigTransactionGenerated(TransformTransactionProperties, ToolTransformArgs, void*)), SLOT(slotTransactionGenerated(TransformTransactionProperties, ToolTransformArgs, void*)));
        connect(transformStrategy, SIGNAL(sigConvexHullCalculated(QPolygon, void*)), SLOT(slotConvexHullCalculated(QPolygon, void*)));
        strategy = transformStrategy;
 
        // save unique identifier of the stroke so we could
        // recognize it when sigTransactionGenerated() is
        // received (theoretically, the user can start two
        // strokes at the same time, if he is quick enough)
        m_strokeStrategyCookie = transformStrategy;
    }
 
    m_strokeId = image()->startStroke(strategy);
 
    if (!m_currentlyUsingOverlayPreviewStyle) {
        m_asyncUpdateHelper.initUpdateStreamLowLevel(image().data(), m_strokeId);
    }
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_changesTracker.isEmpty());
 
    slotPreviewDeviceGenerated(0);
}

References KisResourcesSnapshot::activeSelection(), Private::canvas, KisSharedPtr< T >::clear(), KisTool::currentNode(), KisSharedPtr< T >::data(), ToolTransformArgs::filterId(), KisLayerUtils::filterMergeableNodes(), KisFloatingMessage::High, KisTool::image(), KisAsynchronousStrokeUpdateHelper::initUpdateStreamLowLevel(), KisBaseNode::isEditable(), KisToolChangesTracker::isEmpty(), KIS_ASSERT, KIS_SAFE_ASSERT_RECOVER_NOOP, koIcon, KisFloatingMessage::Low, m_asyncUpdateHelper, m_changesTracker, m_currentArgs, m_currentlyUsingOverlayPreviewStyle, m_externalSourceForNextActivation, m_forceLodMode, m_preferOverlayPreviewStyle, m_strokeId, m_strokeStrategyCookie, m_transaction, KisTool::mode(), KisNode::parent, KisLayerUtils::recursiveFindNode(), KisResourcesSnapshot::selectedNodes(), KisTool::selectedNodes(), KoToolBase::selection(), slotConvexHullCalculated(), slotPreviewDeviceGenerated(), slotTransactionGenerated(), KisImage::startStroke(), KisCanvas2::viewManager(), and KisBaseNode::visible().

◆ toArgsMode()

ToolTransformArgs::TransformMode KisToolTransform::toArgsMode ( KisToolTransform::TransformToolMode toolMode )

static

Definition at line 649 of file kis_tool_transform.cc.

{
    ToolTransformArgs::TransformMode mode = ToolTransformArgs::FREE_TRANSFORM;
 
    switch (toolMode) {
    case FreeTransformMode:
        mode = ToolTransformArgs::FREE_TRANSFORM;
        break;
    case WarpTransformMode:
        mode = ToolTransformArgs::WARP;
        break;
    case CageTransformMode:
        mode = ToolTransformArgs::CAGE;
        break;
    case LiquifyTransformMode:
        mode = ToolTransformArgs::LIQUIFY;
        break;
    case PerspectiveTransformMode:
        mode = ToolTransformArgs::PERSPECTIVE_4POINT;
        break;
    case MeshTransformMode:
        mode = ToolTransformArgs::MESH;
        break;
    default:
        KIS_ASSERT_RECOVER_NOOP(0 && "unexpected transform mode");
    }
 
    return mode;
}

References ToolTransformArgs::CAGE, CageTransformMode, ToolTransformArgs::FREE_TRANSFORM, FreeTransformMode, KIS_ASSERT_RECOVER_NOOP, ToolTransformArgs::LIQUIFY, LiquifyTransformMode, ToolTransformArgs::MESH, MeshTransformMode, KisTool::mode(), ToolTransformArgs::PERSPECTIVE_4POINT, PerspectiveTransformMode, ToolTransformArgs::WARP, and WarpTransformMode.

◆ transformMode()

KisToolTransform::TransformToolMode KisToolTransform::transformMode ( ) const

Definition at line 549 of file kis_tool_transform.cc.

{
    TransformToolMode mode = FreeTransformMode;
 
    switch (m_currentArgs.mode())
    {
    case ToolTransformArgs::FREE_TRANSFORM:
        mode = FreeTransformMode;
        break;
    case ToolTransformArgs::WARP:
        mode = WarpTransformMode;
        break;
    case ToolTransformArgs::CAGE:
        mode = CageTransformMode;
        break;
    case ToolTransformArgs::LIQUIFY:
        mode = LiquifyTransformMode;
        break;
    case ToolTransformArgs::PERSPECTIVE_4POINT:
        mode = PerspectiveTransformMode;
        break;
    case ToolTransformArgs::MESH:
        mode = MeshTransformMode;
        break;
    default:
        KIS_ASSERT_RECOVER_NOOP(0 && "unexpected transform mode");
    }
 
    return mode;
}

References ToolTransformArgs::CAGE, CageTransformMode, ToolTransformArgs::FREE_TRANSFORM, FreeTransformMode, KIS_ASSERT_RECOVER_NOOP, ToolTransformArgs::LIQUIFY, LiquifyTransformMode, m_currentArgs, ToolTransformArgs::MESH, MeshTransformMode, KisTool::mode(), ToolTransformArgs::mode(), ToolTransformArgs::PERSPECTIVE_4POINT, PerspectiveTransformMode, ToolTransformArgs::WARP, and WarpTransformMode.

◆ transformModeChanged

void KisToolTransform::transformModeChanged ( )

signal

◆ translateX()

double KisToolTransform::translateX ( ) const

Definition at line 580 of file kis_tool_transform.cc.

{
    return m_currentArgs.transformedCenter().x();
}

References m_currentArgs, and ToolTransformArgs::transformedCenter().

◆ translateY()

double KisToolTransform::translateY ( ) const

Definition at line 585 of file kis_tool_transform.cc.

{
    return m_currentArgs.transformedCenter().y();
}

References m_currentArgs, and ToolTransformArgs::transformedCenter().

◆ updateApplyResetAvailability()

void KisToolTransform::updateApplyResetAvailability ( )

private

Definition at line 1223 of file kis_tool_transform.cc.

{
    if (m_optionsWidget) {
        m_optionsWidget->setApplyResetDisabled(m_currentArgs.isIdentity());
    }
}

References ToolTransformArgs::isIdentity(), m_currentArgs, m_optionsWidget, and KisToolTransformConfigWidget::setApplyResetDisabled().

◆ updateOptionWidget

void KisToolTransform::updateOptionWidget ( )

slot

Definition at line 1209 of file kis_tool_transform.cc.

{    
    if (!m_optionsWidget) return;
 
    if (!currentNode()) {
        m_optionsWidget->setEnabled(false);
        return;
    }
    else {
        m_optionsWidget->setEnabled(true);
        m_optionsWidget->updateConfig(m_currentArgs);
    }
}

References KisTool::currentNode(), m_currentArgs, m_optionsWidget, and KisToolTransformConfigWidget::updateConfig().

◆ wantsAutoScroll()

bool KisToolTransform::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 133 of file kis_tool_transform.h.

                                          {
        return false;
    }

◆ warpFlexibility()

double KisToolTransform::warpFlexibility ( ) const

Definition at line 639 of file kis_tool_transform.cc.

{
    return m_currentArgs.alpha();
}

References ToolTransformArgs::alpha(), and m_currentArgs.

◆ warpPointDensity()

int KisToolTransform::warpPointDensity ( ) const

Definition at line 644 of file kis_tool_transform.cc.

{
    return m_currentArgs.numPoints();
}

References m_currentArgs, and ToolTransformArgs::numPoints().

◆ warpTransformChanged

void KisToolTransform::warpTransformChanged ( )

signal

◆ warpType()

KisToolTransform::WarpType KisToolTransform::warpType ( ) const

Definition at line 625 of file kis_tool_transform.cc.

{
    switch(m_currentArgs.warpType()) {
    case KisWarpTransformWorker::AFFINE_TRANSFORM:
        return AffineWarpType;
    case KisWarpTransformWorker::RIGID_TRANSFORM:
        return RigidWarpType;
    case KisWarpTransformWorker::SIMILITUDE_TRANSFORM:
        return SimilitudeWarpType;
    default:
        return RigidWarpType;
    }
}

References KisWarpTransformWorker::AFFINE_TRANSFORM, AffineWarpType, m_currentArgs, KisWarpTransformWorker::RIGID_TRANSFORM, RigidWarpType, KisWarpTransformWorker::SIMILITUDE_TRANSFORM, SimilitudeWarpType, and ToolTransformArgs::warpType().

Member Data Documentation

◆ applyTransformation

KisAction* KisToolTransform::applyTransformation {0}

private

Definition at line 294 of file kis_tool_transform.h.

294{0};

◆ cageAction

KisAction* KisToolTransform::cageAction {0}

private

Definition at line 291 of file kis_tool_transform.h.

291{0};

◆ freeTransformAction

KisAction* KisToolTransform::freeTransformAction {0}

private

Definition at line 292 of file kis_tool_transform.h.

292{0};

◆ keepAspectRatioAction

KisAction* KisToolTransform::keepAspectRatioAction {0}

private

Definition at line 302 of file kis_tool_transform.h.

302{0};

◆ liquifyAction

KisAction* KisToolTransform::liquifyAction {0}

private

Definition at line 290 of file kis_tool_transform.h.

290{0};

◆ m_actionConnections

KisSignalAutoConnectionsStore KisToolTransform::m_actionConnections

private

Definition at line 283 of file kis_tool_transform.h.

◆ m_actuallyMoveWhileSelected

bool KisToolTransform::m_actuallyMoveWhileSelected {false}

private

Definition at line 266 of file kis_tool_transform.h.

266{false}; // true <=> selection has been moved while clicked

◆ m_asyncUpdateHelper

KisAsynchronousStrokeUpdateHelper KisToolTransform::m_asyncUpdateHelper

private

Definition at line 324 of file kis_tool_transform.h.

◆ m_cageStrategy

QScopedPointer<KisCageTransformStrategy> KisToolTransform::m_cageStrategy

private

Definition at line 315 of file kis_tool_transform.h.

◆ m_canvas

QPointer<KisCanvas2> KisToolTransform::m_canvas

private

Definition at line 279 of file kis_tool_transform.h.

◆ m_changesTracker

KisToolChangesTracker KisToolTransform::m_changesTracker

private

Definition at line 282 of file kis_tool_transform.h.

◆ m_contextMenu

QScopedPointer<QMenu> KisToolTransform::m_contextMenu

private

Definition at line 238 of file kis_tool_transform.h.

◆ m_currentArgs

ToolTransformArgs KisToolTransform::m_currentArgs

private

Definition at line 260 of file kis_tool_transform.h.

◆ m_currentlyUsingOverlayPreviewStyle

bool KisToolTransform::m_currentlyUsingOverlayPreviewStyle {false}

private

Definition at line 271 of file kis_tool_transform.h.

271{false};

◆ m_cursorOutline

QPainterPath KisToolTransform::m_cursorOutline

private

Definition at line 322 of file kis_tool_transform.h.

◆ m_externalSourceForNextActivation

KisPaintDeviceSP KisToolTransform::m_externalSourceForNextActivation

private

Definition at line 264 of file kis_tool_transform.h.

◆ m_forceLodMode

bool KisToolTransform::m_forceLodMode {false}

private

Definition at line 273 of file kis_tool_transform.h.

273{false};

◆ m_freeStrategy

QScopedPointer<KisFreeTransformStrategy> KisToolTransform::m_freeStrategy

private

Definition at line 318 of file kis_tool_transform.h.

◆ m_liquifyStrategy

QScopedPointer<KisLiquifyTransformStrategy> KisToolTransform::m_liquifyStrategy

private

Definition at line 316 of file kis_tool_transform.h.

◆ m_meshStrategy

QScopedPointer<KisMeshTransformStrategy> KisToolTransform::m_meshStrategy

private

Definition at line 317 of file kis_tool_transform.h.

◆ m_optionsWidget

KisToolTransformConfigWidget* KisToolTransform::m_optionsWidget {0}

private

Definition at line 278 of file kis_tool_transform.h.

278{0};

◆ m_perspectiveStrategy

QScopedPointer<KisPerspectiveTransformStrategy> KisToolTransform::m_perspectiveStrategy

private

Definition at line 319 of file kis_tool_transform.h.

◆ m_preferOverlayPreviewStyle

bool KisToolTransform::m_preferOverlayPreviewStyle {false}

private

Definition at line 272 of file kis_tool_transform.h.

272{false};

◆ m_refRect

QRectF KisToolTransform::m_refRect

private

This artificial rect is used to store the image to flake transformation. We check against this rect to get to know whether zoom has changed.

Definition at line 312 of file kis_tool_transform.h.

◆ m_selectedPortionCache

KisPaintDeviceSP KisToolTransform::m_selectedPortionCache

private

Definition at line 268 of file kis_tool_transform.h.

◆ m_selectionPath

QPainterPath KisToolTransform::m_selectionPath

private

Definition at line 276 of file kis_tool_transform.h.

◆ m_strokeId

KisStrokeId KisToolTransform::m_strokeId

private

Definition at line 269 of file kis_tool_transform.h.

◆ m_strokeStrategyCookie

void* KisToolTransform::m_strokeStrategyCookie {0}

private

Definition at line 270 of file kis_tool_transform.h.

270{0};

◆ m_transaction

TransformTransactionProperties KisToolTransform::m_transaction

private

Definition at line 281 of file kis_tool_transform.h.

◆ m_warpStrategy

QScopedPointer<KisWarpTransformStrategy> KisToolTransform::m_warpStrategy

private

Definition at line 314 of file kis_tool_transform.h.

◆ meshAction

KisAction* KisToolTransform::meshAction {0}

private

Definition at line 289 of file kis_tool_transform.h.

289{0};

◆ mirrorHorizontalAction

KisAction* KisToolTransform::mirrorHorizontalAction {0}

private

Definition at line 298 of file kis_tool_transform.h.

298{0};

◆ mirrorVerticalAction

KisAction* KisToolTransform::mirrorVerticalAction {0}

private

Definition at line 299 of file kis_tool_transform.h.

299{0};

◆ nextActivationTransformMode

TransformToolMode KisToolTransform::nextActivationTransformMode {FreeTransformMode}

private

Definition at line 285 of file kis_tool_transform.h.

285{FreeTransformMode};

◆ perspectiveAction

KisAction* KisToolTransform::perspectiveAction {0}

private

Definition at line 293 of file kis_tool_transform.h.

293{0};

◆ resetTransformation

KisAction* KisToolTransform::resetTransformation {0}

private

Definition at line 295 of file kis_tool_transform.h.

295{0};

◆ rotateNinetyCCWAction

KisAction* KisToolTransform::rotateNinetyCCWAction {0}

private

Definition at line 301 of file kis_tool_transform.h.

301{0};

◆ rotateNinetyCWAction

KisAction* KisToolTransform::rotateNinetyCWAction {0}

private

Definition at line 300 of file kis_tool_transform.h.

300{0};

◆ warpAction

KisAction* KisToolTransform::warpAction {0}

private

actions for the context click menu

Definition at line 288 of file kis_tool_transform.h.

288{0};

Property Documentation

◆ rotateX

double KisToolTransform::rotateX

readwrite

Definition at line 88 of file kis_tool_transform.h.

◆ rotateY

double KisToolTransform::rotateY

readwrite

Definition at line 89 of file kis_tool_transform.h.

◆ rotateZ

double KisToolTransform::rotateZ

readwrite

Definition at line 90 of file kis_tool_transform.h.

◆ scaleX

double KisToolTransform::scaleX

readwrite

Definition at line 92 of file kis_tool_transform.h.

◆ scaleY

double KisToolTransform::scaleY

readwrite

Definition at line 93 of file kis_tool_transform.h.

◆ shearX

double KisToolTransform::shearX

readwrite

Definition at line 95 of file kis_tool_transform.h.

◆ shearY

double KisToolTransform::shearY

readwrite

Definition at line 96 of file kis_tool_transform.h.

◆ transformMode

TransformToolMode KisToolTransform::transformMode

readwrite

Definition at line 83 of file kis_tool_transform.h.

◆ translateX

double KisToolTransform::translateX

readwrite

Definition at line 85 of file kis_tool_transform.h.

◆ translateY

double KisToolTransform::translateY

readwrite

Definition at line 86 of file kis_tool_transform.h.

◆ warpFlexibility

double KisToolTransform::warpFlexibility

readwrite

Definition at line 99 of file kis_tool_transform.h.

◆ warpPointDensity

int KisToolTransform::warpPointDensity

readwrite

Definition at line 100 of file kis_tool_transform.h.

◆ warpType

WarpType KisToolTransform::warpType

readwrite

Definition at line 98 of file kis_tool_transform.h.

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

plugins/tools/tool_transform2/kis_tool_transform.h
plugins/tools/tool_transform2/kis_tool_transform.cc

Public Types

Public Slots

Signals

Public Member Functions

Static Public Member Functions

Protected Slots

Properties

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ TransformToolMode

◆ WarpType

Constructor & Destructor Documentation

◆ KisToolTransform()

◆ ~KisToolTransform()

Member Function Documentation

◆ activate

◆ activateAlternateAction()

◆ activatePrimaryAction()

◆ applyTransform

◆ beginActionImpl()

◆ beginAlternateAction()

◆ beginPrimaryAction()

◆ cancelStroke()

◆ canvasUpdateRequested

◆ commitChanges()

◆ continueActionImpl()

◆ continueAlternateAction()

◆ continuePrimaryAction()

◆ convexHullCalculationRequested

◆ createOptionWidget()

◆ currentStrategy()

◆ cursorOutlineUpdateRequested

◆ deactivate

◆ deactivateAlternateAction()

◆ deactivatePrimaryAction()

◆ endActionImpl()

◆ endAlternateAction()

◆ endPrimaryAction()

◆ endStroke()

◆ freeTransformChanged

◆ imageTooBigRequested

◆ initGuiAfterTransformMode()

◆ initThumbnailImage()

◆ initTransformMode()

◆ mouseMoveEvent()

◆ mousePressEvent()

◆ mouseReleaseEvent()

◆ newActivationWithExternalSource()

◆ outlineChanged()

◆ paint()

◆ popupActionsMenu()

◆ requestImageRecalculation

◆ requestRedoDuringStroke

◆ requestStrokeCancellation

◆ requestStrokeEnd

◆ requestUndoDuringStroke

◆ resetCursorStyle

◆ resetRotationCenterButtonsRequested

◆ rotateX()

◆ rotateY()

◆ rotateZ()

◆ scaleX()

◆ scaleY()

◆ setFunctionalCursor()

◆ setNextActivationTransformMode()

◆ setRotateX

◆ setRotateY

◆ setRotateZ

◆ setScaleX

◆ setScaleY

◆ setShearX

◆ setShearY

◆ setTransformFunction()

◆ setTransformMode

◆ setTranslateX

◆ setTranslateY