#include <kis_tool_crop.h>

Inheritance diagram for KisToolCrop:

Public Types
enum	CropToolType { ImageCropType , CanvasCropType , LayerCropType , FrameCropType }

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

void	deactivate () override

void	requestRedoDuringStroke () override

void	requestStrokeCancellation () override

void	requestStrokeEnd () override

void	requestUndoDuringStroke () override

void	setAllowGrow (bool g)

void	setCropHeight (int y)

void	setCropType (CropToolType cropType)

void	setCropTypeLegacy (int cropType)

void	setCropTypeSelectable (bool selectable)

void	setCropWidth (int x)

void	setCropX (int x)

void	setCropY (int y)

void	setDecoration (int i)

void	setGrowCenter (bool g)

void	setLockHeight (bool lock)

void	setLockRatio (bool lock)

void	setLockWidth (bool lock)

void	setRatio (double ratio)

void	showSizeOnCanvas ()

void	slotRectChanged ()

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	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	canGrowChanged (bool value)

void	cropHeightChanged (int value)

void	cropTypeChanged (int value)

void	cropTypeSelectableChanged ()

void	cropWidthChanged (int value)

void	cropXChanged (int value)

void	cropYChanged (int value)

void	decorationChanged (int value)

void	isCenteredChanged (bool value)

void	lockHeightChanged (bool value)

void	lockRatioChanged (bool value)

void	lockWidthChanged (bool value)

void	ratioChanged (double value)

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
bool	allowGrow () const

void	beginPrimaryAction (KoPointerEvent *event) override

void	beginPrimaryDoubleClickAction (KoPointerEvent *event) override

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

void	continuePrimaryAction (KoPointerEvent *event) override

QWidget *	createOptionWidget () override

int	cropHeight () const

CropToolType	cropType () const

bool	cropTypeSelectable () const

int	cropWidth () const

int	cropX () const

int	cropY () const

int	decoration () const

void	endPrimaryAction (KoPointerEvent *event) override

bool	growCenter () const

	KisToolCrop (KoCanvasBase *canvas)

bool	lockHeight () const

bool	lockRatio () const

bool	lockWidth () const

void	mouseMoveEvent (KoPointerEvent *e) override

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

QMenu *	popupActionsMenu () override

double	ratio () const

	~KisToolCrop () override

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

virtual void	activatePrimaryAction ()

virtual bool	alternateActionSupportsHiResEvents (AlternateAction action) const

virtual void	beginAlternateAction (KoPointerEvent *event, AlternateAction action)

virtual void	beginAlternateDoubleClickAction (KoPointerEvent *event, AlternateAction action)

virtual void	continueAlternateAction (KoPointerEvent *event, AlternateAction action)

virtual void	deactivateAlternateAction (AlternateAction action)

virtual void	deactivatePrimaryAction ()

void	deleteSelection () override

virtual void	endAlternateAction (KoPointerEvent *event, AlternateAction action)

virtual int	flags () const

bool	isActive () const

	KisTool (KoCanvasBase *canvas, const QCursor &cursor)

void	mouseDoubleClickEvent (KoPointerEvent *event) override

void	mousePressEvent (KoPointerEvent *event) override

void	mouseReleaseEvent (KoPointerEvent *event) override

void	mouseTripleClickEvent (KoPointerEvent *event) override

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

KisTool::NodePaintAbility	nodePaintAbility ()

virtual bool	primaryActionSupportsHiResEvents () const

virtual bool	supportsPaintingAssistants () const

	~KisTool () override

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

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

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

virtual void	copy () const

QCursor	cursor () const
	return the last emitted cursor

virtual void	customMoveEvent (KoPointerEvent *event)

virtual void	customPressEvent (KoPointerEvent *event)

virtual void	customReleaseEvent (KoPointerEvent *event)

virtual void	cut ()

virtual QRectF	decorationsRect () const

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

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

virtual void	dragLeaveEvent (QDragLeaveEvent *event)

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

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

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

KoToolFactoryBase *	factory () const

virtual void	focusInEvent (QFocusEvent *event)

virtual void	focusOutEvent (QFocusEvent *event)

virtual bool	hasSelection ()

virtual void	inputMethodEvent (QInputMethodEvent *event)

virtual QVariant	inputMethodQuery (Qt::InputMethodQuery query) const

bool	isInTextMode () const

bool	isOpacityPresetMode () const

virtual void	keyPressEvent (QKeyEvent *event)

virtual void	keyReleaseEvent (QKeyEvent *event)

	KoToolBase (KoCanvasBase *canvas)

bool	maskSyntheticEvents () const

QList< QPointer< QWidget > >	optionWidgets ()

virtual bool	paste ()

virtual KisPopupWidgetInterface *	popupWidget ()

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

virtual KoToolSelection *	selection ()

Q_INVOKABLE QString	toolId () const

virtual bool	wantsAutoScroll () const

	~KoToolBase () override

Properties
int	cropHeight

CropToolType	cropType

bool	cropTypeSelectable

int	cropWidth

int	cropX

int	cropY

int	decoration

bool	lockHeight

bool	lockRatio

bool	lockWidth

double	ratio

Properties inherited from KisTool
bool	isActive

Private Types
enum	handleType { None = 0 , UpperLeft = 1 , UpperRight = 2 , LowerLeft = 3 , LowerRight = 4 , Upper = 5 , Lower = 6 , Left = 7 , Right = 8 , Inside = 9 }

Private Member Functions
QRectF	borderLineRect ()

QRectF	boundingRect ()

void	cancelStroke ()

void	doCanvasUpdate (const QRect &updateRect)

void	drawDecorationLine (QPainter p, DecorationLine decorLine, QRectF rect)

QPainterPath	handlesPath ()

QRectF	leftHandleRect (QRectF cropBorderRect)

QRectF	lowerHandleRect (QRectF cropBorderRect)

QRectF	lowerLeftHandleRect (QRectF cropBorderRect)

QRectF	lowerRightHandleRect (QRectF cropBorderRect)

qint32	mouseOnHandle (const QPointF currentViewPoint)

void	paintOutlineWithHandles (QPainter &gc)

	Q_ENUMS (CropToolType)

QRectF	rightHandleRect (QRectF cropBorderRect)

void	setMoveResizeCursor (qint32 handle)

bool	tryContinueLastCropAction ()

QRectF	upperHandleRect (QRectF cropBorderRect)

QRectF	upperLeftHandleRect (QRectF cropBorderRect)

QRectF	upperRightHandleRect (QRectF cropBorderRect)

Private Attributes
KisAction *	applyCrop {nullptr}

KisAction *	centerToggleOption {nullptr}

KConfigGroup	configGroup

KisAction *	growToggleOption {nullptr}

KisAction *	lockHeightToggleOption {nullptr}

KisAction *	lockRatioToggleOption {nullptr}

KisAction *	lockWidthToggleOption {nullptr}

QScopedPointer< QMenu >	m_contextMenu

CropToolType	m_cropType {ImageCropType}

bool	m_cropTypeSelectable {false}

int	m_decoration {1}

QList< DecorationLine * >	m_decorations

QPointF	m_dragOffsetDoc

QPoint	m_dragStart

KisConstrainedRect	m_finalRect

qint32	m_handleSize {13}

bool	m_haveCropSelection {false}

QRect	m_initialDragRect

QRect	m_lastCanvasUpdateRect

qint32	m_mouseOnHandleType {0}

bool	m_resettingStroke {false}

KisToolCropConfigWidget *	optionsWidget {nullptr}

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

Public Attributes inherited from KisTool
KoColor	currentBgColor

float	currentExposure {1.0}

KoColor	currentFgColor

KisFilterConfigurationSP	currentGenerator

KoAbstractGradientSP	currentGradient

KoPatternSP	currentPattern

QCursor	cursor

bool	m_isActive {false}

ToolMode	m_mode {HOVER_MODE}

QWidget *	optionWidget {0}

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

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

Protected Slots inherited from KisTool
virtual void	resetCursorStyle ()

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

Crop tool

Definition at line 36 of file kis_tool_crop.h.

Member Enumeration Documentation

◆ CropToolType

enum KisToolCrop::CropToolType

Enumerator
ImageCropType
CanvasCropType
LayerCropType
FrameCropType

Definition at line 54 of file kis_tool_crop.h.

                      {
        ImageCropType,
        CanvasCropType,
        LayerCropType,
        FrameCropType
    };

◆ handleType

enum KisToolCrop::handleType

private

Enumerator
None
UpperLeft
UpperRight
LowerLeft
LowerRight
Upper
Lower
Left
Right
Inside

Definition at line 190 of file kis_tool_crop.h.

                    {
        None = 0,
        UpperLeft = 1,
        UpperRight = 2,
        LowerLeft = 3,
        LowerRight = 4,
        Upper = 5,
        Lower = 6,
        Left = 7,
        Right = 8,
        Inside = 9
    };

Constructor & Destructor Documentation

◆ KisToolCrop()

KisToolCrop::KisToolCrop ( KoCanvasBase * canvas )

Definition at line 96 of file kis_tool_crop.cc.

        : KisTool(canvas, KisCursor::load("tool_crop_cursor.png", 6, 6))
{
    setObjectName("tool_crop");
    m_handleSize = 13;
    m_haveCropSelection = false;
    m_cropTypeSelectable = false;
    m_cropType = ImageCropType;
    m_decoration = 1;
 
    connect(&m_finalRect, SIGNAL(sigValuesChanged()), SLOT(slotRectChanged()));
    connect(&m_finalRect, SIGNAL(sigLockValuesChanged()), SLOT(slotRectChanged()));
 
    // context menu options (mirrors tool options)
    m_contextMenu.reset(new QMenu());
    applyCrop = new KisAction(i18n("Crop"));
 
    centerToggleOption = new KisAction(i18n("Center"));
    centerToggleOption->setCheckable(true);
    
    growToggleOption = new KisAction(i18nc("Grow as in crop tool", "Grow"));
    growToggleOption->setCheckable(true);
    
    lockWidthToggleOption = new KisAction(i18n("Lock Width"));
    lockWidthToggleOption->setCheckable(true);
    
    lockHeightToggleOption = new KisAction(i18n("Lock Height"));
    lockHeightToggleOption->setCheckable(true);
    
    lockRatioToggleOption = new KisAction(i18n("Lock Ratio"));
    lockRatioToggleOption->setCheckable(true);
}

References applyCrop, centerToggleOption, connect(), growToggleOption, ImageCropType, lockHeightToggleOption, lockRatioToggleOption, lockWidthToggleOption, m_contextMenu, m_cropType, m_cropTypeSelectable, m_decoration, m_finalRect, m_handleSize, m_haveCropSelection, and slotRectChanged().

◆ ~KisToolCrop()

KisToolCrop::~KisToolCrop ( )

override

Definition at line 129 of file kis_tool_crop.cc.

{
    delete applyCrop;
    delete centerToggleOption;
    delete growToggleOption;
    delete lockWidthToggleOption;
    delete lockHeightToggleOption;
    delete lockRatioToggleOption;
}

References applyCrop, centerToggleOption, growToggleOption, lockHeightToggleOption, lockRatioToggleOption, and lockWidthToggleOption.

Member Function Documentation

◆ activate

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

overrideslot

Definition at line 139 of file kis_tool_crop.cc.

{
 
    KisTool::activate(shapes);
    configGroup =  KSharedConfig::openConfig()->group(toolId()); // save settings to kritarc
 
    KisResourcesSnapshotSP resources =
        new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
 
 
    // load settings from configuration
    setGrowCenter(configGroup.readEntry("growCenter", false));
    setAllowGrow(configGroup.readEntry("allowGrow", true));
 
    // Default: thirds decoration
    setDecoration(configGroup.readEntry("decoration", 1));
 
    // Default: crop the entire image
    setCropType(CropToolType(configGroup.readEntry("cropType", 0)));
 
    m_finalRect.setCropRect(image()->bounds());
 
    KisSelectionSP sel = resources->activeSelection();
    if (sel) {
        m_haveCropSelection = true;
        m_finalRect.setRectInitial(sel->selectedExactRect());
    }
    useCursor(cursor());
 
    //pixel layer
    if(resources->currentNode() && resources->currentNode()->paintDevice()) {
        setCropTypeSelectable(true);
    }
    //vector layer
    else {
        if (m_cropType != ImageCropType && m_cropType != CanvasCropType) {
            setCropType(ImageCropType);
        }
        setCropTypeSelectable(false);
    }
    connect(&m_finalRect, SIGNAL(sigValuesChanged()), SLOT(showSizeOnCanvas()));
}

References KisTool::activate(), KisResourcesSnapshot::activeSelection(), bounds, Private::canvas, CanvasCropType, configGroup, connect(), KisResourcesSnapshot::currentNode(), KisTool::currentNode(), KisTool::cursor, KisTool::image(), ImageCropType, m_cropType, m_finalRect, m_haveCropSelection, KisBaseNode::paintDevice(), KisSelection::selectedExactRect(), setAllowGrow(), KisConstrainedRect::setCropRect(), setCropType(), setCropTypeSelectable(), setDecoration(), setGrowCenter(), KisConstrainedRect::setRectInitial(), showSizeOnCanvas(), KoToolBase::toolId(), and KoToolBase::useCursor().

◆ allowGrow()

bool KisToolCrop::allowGrow ( ) const

Definition at line 668 of file kis_tool_crop.cc.

{
    return m_finalRect.canGrow();
}

References KisConstrainedRect::canGrow(), and m_finalRect.

◆ beginPrimaryAction()

void KisToolCrop::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 271 of file kis_tool_crop.cc.

{
    m_finalRect.setCropRect(image()->bounds());
    setMode(KisTool::PAINT_MODE);
 
    const QPointF imagePoint = convertToPixelCoord(event);
    m_mouseOnHandleType = mouseOnHandle(pixelToView(imagePoint));
 
    if (m_mouseOnHandleType != KisConstrainedRect::None) {
        QPointF snapPoint = m_finalRect.handleSnapPoint(KisConstrainedRect::HandleType(m_mouseOnHandleType), imagePoint);
        QPointF snapDocPoint = image()->pixelToDocument(snapPoint);
        m_dragOffsetDoc = snapDocPoint - event->point;
    } else {
        m_dragOffsetDoc = QPointF();
    }
 
    QPointF snappedPoint = convertToPixelCoordAndSnap(event, m_dragOffsetDoc);
 
    m_dragStart = snappedPoint.toPoint();
    m_resettingStroke = false;
 
    if (!m_haveCropSelection || m_mouseOnHandleType == None) {
        m_lastCanvasUpdateRect = image()->bounds();
        const int initialWidth = m_finalRect.widthLocked() ? m_finalRect.rect().width() : 1;
        const int initialHeight = m_finalRect.heightLocked() ? m_finalRect.rect().height() : 1;
        const QRect initialRect = QRect(m_dragStart, QSize(initialWidth, initialHeight));
        m_finalRect.setRectInitial(initialRect);
        m_initialDragRect = initialRect;
        m_mouseOnHandleType = KisConstrainedRect::Creation;
        m_resettingStroke = true;
    } else {
        m_initialDragRect = m_finalRect.rect();
    }
}

◆ beginPrimaryDoubleClickAction()

void KisToolCrop::beginPrimaryDoubleClickAction ( KoPointerEvent * event )

overridevirtual

The same as beginPrimaryAction(), but called when the stroke is started by a double-click

See also: beginPrimaryAction()

Reimplemented from KisTool.

Definition at line 397 of file kis_tool_crop.cc.

{
    if (m_haveCropSelection) crop();
 
    // this action will have no continuation
    event->ignore();
}

References crop(), and m_haveCropSelection.

◆ borderLineRect()

QRectF KisToolCrop::borderLineRect ( )

private

Definition at line 410 of file kis_tool_crop.cc.

{
    QRectF borderRect = pixelToView(m_finalRect.rect());
 
    // Draw the border line right next to the crop rectangle perimeter.
    borderRect.adjust(-HALF_BORDER_LINE_WIDTH, -HALF_BORDER_LINE_WIDTH, HALF_BORDER_LINE_WIDTH, HALF_BORDER_LINE_WIDTH);
 
    return borderRect;
}

References HALF_BORDER_LINE_WIDTH, m_finalRect, KisTool::pixelToView(), and KisConstrainedRect::rect().

◆ boundingRect()

QRectF KisToolCrop::boundingRect ( )

private

Definition at line 895 of file kis_tool_crop.cc.

{
    QRectF rect = handlesPath().boundingRect();
    rect.adjust(-HANDLE_BORDER_LINE_WIDTH, -HANDLE_BORDER_LINE_WIDTH, HANDLE_BORDER_LINE_WIDTH, HANDLE_BORDER_LINE_WIDTH);
    return rect;
}

References HANDLE_BORDER_LINE_WIDTH, and handlesPath().

◆ cancelStroke()

void KisToolCrop::cancelStroke ( )

private

Definition at line 182 of file kis_tool_crop.cc.

{
    m_haveCropSelection = false;
    useCursor(cursor());
    doCanvasUpdate(image()->bounds());
}

References bounds, KisTool::cursor, doCanvasUpdate(), KisTool::image(), m_haveCropSelection, and KoToolBase::useCursor().

◆ canGrowChanged

void KisToolCrop::canGrowChanged ( bool value )

signal

◆ canvasResourceChanged()

void KisToolCrop::canvasResourceChanged	(	int	key,
		const QVariant &	res )

overridevirtual

This method is called whenever a property in the resource provider associated with the canvas this tool belongs to changes. An example is currently selected foreground color.

Reimplemented from KoToolBase.

Definition at line 215 of file kis_tool_crop.cc.

{
    KisTool::canvasResourceChanged(key, res);
 
    //pixel layer
    if(currentNode() && currentNode()->paintDevice()) {
        setCropTypeSelectable(true);
    }
    //vector layer
    else {
        if (m_cropType != ImageCropType && m_cropType != CanvasCropType) {
            setCropType(ImageCropType);
        }
        setCropTypeSelectable(false);
    }
}

References CanvasCropType, KisTool::canvasResourceChanged(), KisTool::currentNode(), ImageCropType, m_cropType, setCropType(), and setCropTypeSelectable().

◆ continuePrimaryAction()

void KisToolCrop::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 306 of file kis_tool_crop.cc.

{
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
    const QPointF pos = convertToPixelCoordAndSnap(event, m_dragOffsetDoc);
    const QPoint drag = pos.toPoint() - m_dragStart;
 
    m_finalRect.moveHandle(KisConstrainedRect::HandleType(m_mouseOnHandleType), drag, m_initialDragRect);
}

References CHECK_MODE_SANITY_OR_RETURN, KisTool::convertToPixelCoordAndSnap(), m_dragOffsetDoc, m_dragStart, m_finalRect, m_initialDragRect, m_mouseOnHandleType, KisConstrainedRect::moveHandle(), and KisTool::PAINT_MODE.

◆ createOptionWidget()

QWidget * KisToolCrop::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 732 of file kis_tool_crop.cc.

{
    optionsWidget = new KisToolCropConfigWidget(0, this);
    // See https://bugs.kde.org/show_bug.cgi?id=316896
    QWidget *specialSpacer = new QWidget(optionsWidget);
    specialSpacer->setObjectName("SpecialSpacer");
    specialSpacer->setFixedSize(0, 0);
    optionsWidget->layout()->addWidget(specialSpacer);
 
    Q_CHECK_PTR(optionsWidget);
    optionsWidget->setObjectName(toolId() + " option widget");
 
    connect(optionsWidget->bnCrop, SIGNAL(clicked()), this, SLOT(crop()));
 
    connect(optionsWidget, SIGNAL(cropTypeChanged(int)), this, SLOT(setCropTypeLegacy(int)));
    connect(optionsWidget, SIGNAL(cropXChanged(int)), this, SLOT(setCropX(int)));
    connect(optionsWidget, SIGNAL(cropYChanged(int)), this, SLOT(setCropY(int)));
    connect(optionsWidget, SIGNAL(cropHeightChanged(int)), this, SLOT(setCropHeight(int)));
    connect(optionsWidget, SIGNAL(lockHeightChanged(bool)), this, SLOT(setLockHeight(bool)));
    connect(optionsWidget, SIGNAL(cropWidthChanged(int)), this, SLOT(setCropWidth(int)));
    connect(optionsWidget, SIGNAL(lockWidthChanged(bool)), this, SLOT(setLockWidth(bool)));
    connect(optionsWidget, SIGNAL(ratioChanged(double)), this, SLOT(setRatio(double)));
    connect(optionsWidget, SIGNAL(lockRatioChanged(bool)), this, SLOT(setLockRatio(bool)));
    connect(optionsWidget, SIGNAL(decorationChanged(int)), this, SLOT(setDecoration(int)));
    connect(optionsWidget, SIGNAL(allowGrowChanged(bool)), this, SLOT(setAllowGrow(bool)));
    connect(optionsWidget, SIGNAL(growCenterChanged(bool)), this, SLOT(setGrowCenter(bool)));
 
    optionsWidget->setFixedHeight(optionsWidget->sizeHint().height());
 
    connect(applyCrop, SIGNAL(triggered(bool)), this, SLOT(crop()));
    connect(centerToggleOption, SIGNAL(triggered(bool)), this, SLOT(setGrowCenter(bool)));
    connect(growToggleOption, SIGNAL(triggered(bool)), this, SLOT(setAllowGrow(bool)));
    connect(lockWidthToggleOption, SIGNAL(triggered(bool)), this, SLOT(setLockWidth(bool)));
    connect(lockHeightToggleOption, SIGNAL(triggered(bool)), this, SLOT(setLockHeight(bool)));
    connect(lockRatioToggleOption, SIGNAL(triggered(bool)), this, SLOT(setLockRatio(bool)));
 
    return optionsWidget;
}

References applyCrop, centerToggleOption, connect(), crop(), cropHeightChanged(), cropTypeChanged(), cropWidthChanged(), cropXChanged(), cropYChanged(), decorationChanged(), growToggleOption, lockHeightChanged(), lockHeightToggleOption, lockRatioChanged(), lockRatioToggleOption, lockWidthChanged(), lockWidthToggleOption, optionsWidget, ratioChanged(), setAllowGrow(), setCropHeight(), setCropTypeLegacy(), setCropWidth(), setCropX(), setCropY(), setDecoration(), setGrowCenter(), setLockHeight(), setLockRatio(), setLockWidth(), setRatio(), and KoToolBase::toolId().

◆ crop

void KisToolCrop::crop ( )

slot

Definition at line 458 of file kis_tool_crop.cc.

{
    KIS_ASSERT_RECOVER_RETURN(currentImage());
    if (m_finalRect.rect().isEmpty()) return;
 
    const bool imageCrop = m_cropType == ImageCropType || m_cropType == CanvasCropType;
 
    if (!imageCrop) {
        //Cropping layer
        if (!nodeEditable()) {
            return;
        }
    }
 
    m_haveCropSelection = false;
    useCursor(cursor());
 
    QRect cropRect = m_finalRect.rect();
 
    // The visitor adds the undo steps to the macro
    if (imageCrop || !currentNode()->paintDevice()) {
        if (m_cropType == CanvasCropType) {
            currentImage()->resizeImage(cropRect);
        } else {
            currentImage()->cropImage(cropRect);
        }
    } else {
        currentImage()->cropNode(currentNode(), cropRect, m_cropType == FrameCropType);
    }
}

References CanvasCropType, KisImage::cropImage(), KisImage::cropNode(), KisTool::currentImage(), KisTool::currentNode(), KisTool::cursor, FrameCropType, ImageCropType, KIS_ASSERT_RECOVER_RETURN, m_cropType, m_finalRect, m_haveCropSelection, KisTool::nodeEditable(), KisConstrainedRect::rect(), KisImage::resizeImage(), and KoToolBase::useCursor().

◆ cropHeight()

int KisToolCrop::cropHeight ( ) const

Definition at line 644 of file kis_tool_crop.cc.

{
    return m_finalRect.rect().height();
}

References m_finalRect, and KisConstrainedRect::rect().

◆ cropHeightChanged

void KisToolCrop::cropHeightChanged ( int value )

signal

◆ cropType()

KisToolCrop::CropToolType KisToolCrop::cropType ( ) const

Definition at line 505 of file kis_tool_crop.cc.

{
    return m_cropType;
}

References m_cropType.

◆ cropTypeChanged

void KisToolCrop::cropTypeChanged ( int value )

signal

◆ cropTypeSelectable()

bool KisToolCrop::cropTypeSelectable ( ) const

Definition at line 518 of file kis_tool_crop.cc.

{
    return m_cropTypeSelectable;
}

References m_cropTypeSelectable.

◆ cropTypeSelectableChanged

void KisToolCrop::cropTypeSelectableChanged ( )

signal

◆ cropWidth()

int KisToolCrop::cropWidth ( ) const

Definition at line 616 of file kis_tool_crop.cc.

{
    return m_finalRect.rect().width();
}

References m_finalRect, and KisConstrainedRect::rect().

◆ cropWidthChanged

void KisToolCrop::cropWidthChanged ( int value )

signal

◆ cropX()

int KisToolCrop::cropX ( ) const

Definition at line 578 of file kis_tool_crop.cc.

{
    return m_finalRect.rect().x();
}

References m_finalRect, and KisConstrainedRect::rect().

◆ cropXChanged

void KisToolCrop::cropXChanged ( int value )

signal

◆ cropY()

int KisToolCrop::cropY ( ) const

Definition at line 598 of file kis_tool_crop.cc.

{
    return m_finalRect.rect().y();
}

References m_finalRect, and KisConstrainedRect::rect().

◆ cropYChanged

void KisToolCrop::cropYChanged ( int value )

signal

◆ deactivate

void KisToolCrop::deactivate ( )

overrideslot

Definition at line 189 of file kis_tool_crop.cc.

{
    cancelStroke();
    KisTool::deactivate();
}

References cancelStroke(), and KisTool::deactivate().

◆ decoration()

int KisToolCrop::decoration ( ) const

Definition at line 523 of file kis_tool_crop.cc.

{
    return m_decoration;
}

References m_decoration.

◆ decorationChanged

void KisToolCrop::decorationChanged ( int value )

signal

◆ doCanvasUpdate()

void KisToolCrop::doCanvasUpdate ( const QRect & updateRect )

private

Definition at line 540 of file kis_tool_crop.cc.

{
    updateCanvasViewRect(updateRect | m_lastCanvasUpdateRect);
    m_lastCanvasUpdateRect = updateRect;
}

References m_lastCanvasUpdateRect, and KisTool::updateCanvasViewRect().

◆ drawDecorationLine()

void KisToolCrop::drawDecorationLine	(	QPainter *	p,
		DecorationLine *	decorLine,
		QRectF	rect )

private

Definition at line 902 of file kis_tool_crop.cc.

{
    QPointF start = rect.topLeft();
    QPointF end = rect.topLeft();
    qreal small = qMin(rect.width(), rect.height());
    qreal large = qMax(rect.width(), rect.height());
 
    switch (decorLine->startXRelation) {
    case DecorationLine::Width:
        start.setX(start.x() + decorLine->start.x() * rect.width());
        break;
    case DecorationLine::Height:
        start.setX(start.x() + decorLine->start.x() * rect.height());
        break;
    case DecorationLine::Smallest:
        start.setX(start.x() + decorLine->start.x() * small);
        break;
    case DecorationLine::Largest:
        start.setX(start.x() + decorLine->start.x() * large);
        break;
    }
 
    switch (decorLine->startYRelation) {
    case DecorationLine::Width:
        start.setY(start.y() + decorLine->start.y() * rect.width());
        break;
    case DecorationLine::Height:
        start.setY(start.y() + decorLine->start.y() * rect.height());
        break;
    case DecorationLine::Smallest:
        start.setY(start.y() + decorLine->start.y() * small);
        break;
    case DecorationLine::Largest:
        start.setY(start.y() + decorLine->start.y() * large);
        break;
    }
 
    switch (decorLine->endXRelation) {
    case DecorationLine::Width:
        end.setX(end.x() + decorLine->end.x() * rect.width());
        break;
    case DecorationLine::Height:
        end.setX(end.x() + decorLine->end.x() * rect.height());
        break;
    case DecorationLine::Smallest:
        end.setX(end.x() + decorLine->end.x() * small);
        break;
    case DecorationLine::Largest:
        end.setX(end.x() + decorLine->end.x() * large);
        break;
    }
 
    switch (decorLine->endYRelation) {
    case DecorationLine::Width:
        end.setY(end.y() + decorLine->end.y() * rect.width());
        break;
    case DecorationLine::Height:
        end.setY(end.y() + decorLine->end.y() * rect.height());
        break;
    case DecorationLine::Smallest:
        end.setY(end.y() + decorLine->end.y() * small);
        break;
    case DecorationLine::Largest:
        end.setY(end.y() + decorLine->end.y() * large);
        break;
    }
 
    p->drawLine(start, end);
}

References DecorationLine::end, DecorationLine::endXRelation, DecorationLine::endYRelation, DecorationLine::Height, DecorationLine::Largest, p, DecorationLine::Smallest, DecorationLine::start, DecorationLine::startXRelation, DecorationLine::startYRelation, and DecorationLine::Width.

◆ endPrimaryAction()

void KisToolCrop::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 351 of file kis_tool_crop.cc.

{
    CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
    setMode(KisTool::HOVER_MODE);
 
    QRectF viewCropRect = pixelToView(m_finalRect.rect());
    const bool haveValidRect =
        viewCropRect.width() > m_handleSize &&
        viewCropRect.height() > m_handleSize;
 
 
    if (!m_haveCropSelection && !haveValidRect) {
        if (!tryContinueLastCropAction()) {
            m_finalRect.setRectInitial(image()->bounds());
            m_haveCropSelection = true;
        }
    } else if (m_resettingStroke && !haveValidRect) {
        m_lastCanvasUpdateRect = image()->bounds();
        m_haveCropSelection = false;
    } else {
        m_haveCropSelection = true;
    }
 
    m_finalRect.normalize();
 
    qint32 type = mouseOnHandle(pixelToView(convertToPixelCoordAndSnap(event, m_dragOffsetDoc)));
    setMoveResizeCursor(type);
}

References KisImage::bounds(), bounds, CHECK_MODE_SANITY_OR_RETURN, KisTool::convertToPixelCoordAndSnap(), KisTool::HOVER_MODE, KisTool::image(), m_dragOffsetDoc, m_finalRect, m_handleSize, m_haveCropSelection, m_lastCanvasUpdateRect, m_resettingStroke, mouseOnHandle(), KisConstrainedRect::normalize(), KisTool::PAINT_MODE, KisTool::pixelToView(), KisConstrainedRect::rect(), KisTool::setMode(), setMoveResizeCursor(), KisConstrainedRect::setRectInitial(), and tryContinueLastCropAction().

◆ growCenter()

bool KisToolCrop::growCenter ( ) const

Definition at line 683 of file kis_tool_crop.cc.

{
    return m_finalRect.centered();
}

References KisConstrainedRect::centered(), and m_finalRect.

◆ handlesPath()

QPainterPath KisToolCrop::handlesPath ( )

private

Definition at line 811 of file kis_tool_crop.cc.

{
    QRectF cropBorderRect = borderLineRect();
    QPainterPath path;
 
    path.addRect(upperLeftHandleRect(cropBorderRect));
    path.addRect(upperRightHandleRect(cropBorderRect));
    path.addRect(lowerLeftHandleRect(cropBorderRect));
    path.addRect(lowerRightHandleRect(cropBorderRect));
    path.addRect(upperHandleRect(cropBorderRect));
    path.addRect(lowerHandleRect(cropBorderRect));
    path.addRect(leftHandleRect(cropBorderRect));
    path.addRect(rightHandleRect(cropBorderRect));
 
    return path;
}

References borderLineRect(), leftHandleRect(), lowerHandleRect(), lowerLeftHandleRect(), lowerRightHandleRect(), rightHandleRect(), upperHandleRect(), upperLeftHandleRect(), and upperRightHandleRect().

◆ isCenteredChanged

void KisToolCrop::isCenteredChanged ( bool value )

signal

◆ leftHandleRect()

QRectF KisToolCrop::leftHandleRect ( QRectF cropBorderRect )

private

Definition at line 806 of file kis_tool_crop.cc.

{
    return QRectF(cropBorderRect.left() - m_handleSize / 2.0, cropBorderRect.top() + (cropBorderRect.height() - m_handleSize) / 2.0, m_handleSize, m_handleSize);
}

References m_handleSize.

◆ lockHeight()

bool KisToolCrop::lockHeight ( ) const

Definition at line 654 of file kis_tool_crop.cc.

{
    return m_finalRect.heightLocked();
}

References KisConstrainedRect::heightLocked(), and m_finalRect.

◆ lockHeightChanged

void KisToolCrop::lockHeightChanged ( bool value )

signal

◆ lockRatio()

bool KisToolCrop::lockRatio ( ) const

Definition at line 711 of file kis_tool_crop.cc.

{
    return m_finalRect.ratioLocked();
}

References m_finalRect, and KisConstrainedRect::ratioLocked().

◆ lockRatioChanged

void KisToolCrop::lockRatioChanged ( bool value )

signal

◆ lockWidth()

bool KisToolCrop::lockWidth ( ) const

Definition at line 626 of file kis_tool_crop.cc.

{
    return m_finalRect.widthLocked();
}

References m_finalRect, and KisConstrainedRect::widthLocked().

◆ lockWidthChanged

void KisToolCrop::lockWidthChanged ( bool value )

signal

◆ lowerHandleRect()

QRectF KisToolCrop::lowerHandleRect ( QRectF cropBorderRect )

private

Definition at line 791 of file kis_tool_crop.cc.

{
    return QRectF(cropBorderRect.left() + (cropBorderRect.width() - m_handleSize) / 2.0 , cropBorderRect.bottom() - m_handleSize / 2.0, m_handleSize, m_handleSize);
}

References m_handleSize.

◆ lowerLeftHandleRect()

QRectF KisToolCrop::lowerLeftHandleRect ( QRectF cropBorderRect )

private

Definition at line 781 of file kis_tool_crop.cc.

{
    return QRectF(cropBorderRect.left() - m_handleSize / 2.0 , cropBorderRect.bottom() - m_handleSize / 2.0, m_handleSize, m_handleSize);
}

References m_handleSize.

◆ lowerRightHandleRect()

QRectF KisToolCrop::lowerRightHandleRect ( QRectF cropBorderRect )

private

Definition at line 771 of file kis_tool_crop.cc.

{
    return QRectF(cropBorderRect.right() - m_handleSize / 2.0, cropBorderRect.bottom() - m_handleSize / 2.0, m_handleSize, m_handleSize);
}

References m_handleSize.

◆ mouseMoveEvent()

void KisToolCrop::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 380 of file kis_tool_crop.cc.

{
    QPointF pos = convertToPixelCoordAndSnap(event);
 
    if (m_haveCropSelection) {  //if the crop selection is set
        //set resize cursor if we are on one of the handles
        if(mode() == KisTool::PAINT_MODE) {
            //keep the same cursor as the one we clicked with
            setMoveResizeCursor(m_mouseOnHandleType);
        }else{
            //hovering
            qint32 type = mouseOnHandle(pixelToView(pos));
            setMoveResizeCursor(type);
        }
    }
}

References KisTool::convertToPixelCoordAndSnap(), m_haveCropSelection, m_mouseOnHandleType, KisTool::mode(), mouseOnHandle(), KisTool::PAINT_MODE, KisTool::pixelToView(), and setMoveResizeCursor().

◆ mouseOnHandle()

qint32 KisToolCrop::mouseOnHandle ( const QPointF currentViewPoint )

private

Definition at line 828 of file kis_tool_crop.cc.

{
    QRectF borderRect = borderLineRect();
    qint32 handleType = None;
 
    if (!m_haveCropSelection) {
        return None;
    }
 
    if (upperLeftHandleRect(borderRect).contains(currentViewPoint)) {
        handleType = UpperLeft;
    } else if (lowerLeftHandleRect(borderRect).contains(currentViewPoint)) {
        handleType = LowerLeft;
    } else if (upperRightHandleRect(borderRect).contains(currentViewPoint)) {
        handleType = UpperRight;
    } else if (lowerRightHandleRect(borderRect).contains(currentViewPoint)) {
        handleType = LowerRight;
    } else if (upperHandleRect(borderRect).contains(currentViewPoint)) {
        handleType = Upper;
    } else if (lowerHandleRect(borderRect).contains(currentViewPoint)) {
        handleType = Lower;
    } else if (leftHandleRect(borderRect).contains(currentViewPoint)) {
        handleType = Left;
    } else if (rightHandleRect(borderRect).contains(currentViewPoint)) {
        handleType = Right;
    } else if (borderRect.contains(currentViewPoint)) {
        handleType = Inside;
    }
 
    return handleType;
}

References borderLineRect(), Inside, Left, leftHandleRect(), Lower, lowerHandleRect(), LowerLeft, lowerLeftHandleRect(), LowerRight, lowerRightHandleRect(), m_haveCropSelection, None, Right, rightHandleRect(), Upper, upperHandleRect(), UpperLeft, upperLeftHandleRect(), UpperRight, and upperRightHandleRect().

◆ paint()

void KisToolCrop::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 232 of file kis_tool_crop.cc.

{
    Q_UNUSED(converter);
    paintOutlineWithHandles(painter);
}

References paintOutlineWithHandles().

◆ paintOutlineWithHandles()

void KisToolCrop::paintOutlineWithHandles ( QPainter & gc )

private

Definition at line 422 of file kis_tool_crop.cc.

{
    if (canvas() && (mode() == KisTool::PAINT_MODE || m_haveCropSelection)) {
        gc.save();
 
        QRectF wholeImageRect = pixelToView(image()->bounds());
        QRectF borderRect = borderLineRect();
 
        QPainterPath path;
 
        path.addRect(wholeImageRect);
        path.addRect(borderRect);
        gc.setPen(Qt::NoPen);
        gc.setBrush(QColor(0, 0, 0, OUTSIDE_CROP_ALPHA));
        gc.drawPath(path);
 
        // Handles
        QPen pen(Qt::SolidLine);
        pen.setWidth(HANDLE_BORDER_LINE_WIDTH * decorationThickness());
        pen.setColor(Qt::black);
        pen.setCosmetic(true);
        gc.setPen(pen);
        gc.setBrush(QColor(200, 200, 200, OUTSIDE_CROP_ALPHA));
        gc.drawPath(handlesPath());
 
        gc.setClipRect(borderRect, Qt::IntersectClip);
 
        if (m_decoration > 0) {
            for (int i = decorsIndex[m_decoration-1]; i<decorsIndex[m_decoration]; i++) {
                drawDecorationLine(&gc, &(decors[i]), borderRect);
            }
        }
        gc.restore();
    }
}

References borderLineRect(), bounds, Private::canvas, KoToolBase::decorationThickness(), decors, decorsIndex, drawDecorationLine(), HANDLE_BORDER_LINE_WIDTH, handlesPath(), KisTool::image(), m_decoration, m_haveCropSelection, KisTool::mode(), OUTSIDE_CROP_ALPHA, KisTool::PAINT_MODE, and KisTool::pixelToView().

◆ popupActionsMenu()

QMenu * KisToolCrop::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 238 of file kis_tool_crop.cc.

{
    if (m_contextMenu) {
        // Sync state of context menu toggles with state of Tool Options toggles
        centerToggleOption->setChecked(growCenter());
        growToggleOption->setChecked(allowGrow());
        lockWidthToggleOption->setChecked(lockWidth());
        lockHeightToggleOption->setChecked(lockHeight());
        lockRatioToggleOption->setChecked(lockRatio());
      
        m_contextMenu->clear();
 
        m_contextMenu->addSection(i18n("Crop Tool Actions"));
        m_contextMenu->addSeparator();
 
        if (m_haveCropSelection) {         // can't crop if there is no selection
            m_contextMenu->addAction(applyCrop);
            m_contextMenu->addSeparator();
        }
 
        m_contextMenu->addAction(centerToggleOption);
        m_contextMenu->addAction(growToggleOption);
        
        m_contextMenu->addSeparator();
        
        m_contextMenu->addAction(lockWidthToggleOption);
        m_contextMenu->addAction(lockHeightToggleOption);
        m_contextMenu->addAction(lockRatioToggleOption);
    }
 
    return m_contextMenu.data();
}

References allowGrow(), applyCrop, centerToggleOption, growCenter(), growToggleOption, lockHeight, lockHeightToggleOption, lockRatio, lockRatioToggleOption, lockWidth, lockWidthToggleOption, m_contextMenu, and m_haveCropSelection.

◆ Q_ENUMS()

KisToolCrop::Q_ENUMS ( CropToolType )

private

◆ ratio()

double KisToolCrop::ratio ( ) const

Definition at line 701 of file kis_tool_crop.cc.

{
    return m_finalRect.ratio();
}

References m_finalRect, and KisConstrainedRect::ratio().

◆ ratioChanged

void KisToolCrop::ratioChanged ( double value )

signal

◆ requestRedoDuringStroke

void KisToolCrop::requestRedoDuringStroke ( )

overrideslot

Definition at line 210 of file kis_tool_crop.cc.

{
    cancelStroke();
}

References cancelStroke().

◆ requestStrokeCancellation

void KisToolCrop::requestStrokeCancellation ( )

overrideslot

Definition at line 200 of file kis_tool_crop.cc.

{
    cancelStroke();
}

References cancelStroke().

◆ requestStrokeEnd

void KisToolCrop::requestStrokeEnd ( )

overrideslot

Definition at line 195 of file kis_tool_crop.cc.

{
    if (m_haveCropSelection) crop();
}

References crop(), and m_haveCropSelection.

◆ requestUndoDuringStroke

void KisToolCrop::requestUndoDuringStroke ( )

overrideslot

Definition at line 205 of file kis_tool_crop.cc.

{
    cancelStroke();
}

References cancelStroke().

◆ rightHandleRect()

QRectF KisToolCrop::rightHandleRect ( QRectF cropBorderRect )

private

Definition at line 796 of file kis_tool_crop.cc.

{
    return QRectF(cropBorderRect.right() - m_handleSize / 2.0 , cropBorderRect.top() + (cropBorderRect.height() - m_handleSize) / 2.0, m_handleSize, m_handleSize);
}

References m_handleSize.

◆ setAllowGrow

void KisToolCrop::setAllowGrow ( bool g )

slot

Definition at line 659 of file kis_tool_crop.cc.

{
    m_finalRect.setCanGrow(g);
    m_finalRect.setCropRect(image()->bounds());
    configGroup.writeEntry("allowGrow", g);
 
    Q_EMIT canGrowChanged(g);
}

References bounds, canGrowChanged(), configGroup, KisTool::image(), m_finalRect, KisConstrainedRect::setCanGrow(), and KisConstrainedRect::setCropRect().

◆ setCropHeight

void KisToolCrop::setCropHeight ( int y )

slot

Definition at line 631 of file kis_tool_crop.cc.

{
    if(h == m_finalRect.rect().height())
        return;
 
    if (!m_haveCropSelection) {
        m_haveCropSelection = true;
        m_finalRect.setRectInitial(image()->bounds());
    }
 
    m_finalRect.setHeight(h);
}

References bounds, KisTool::image(), m_finalRect, m_haveCropSelection, KisConstrainedRect::rect(), KisConstrainedRect::setHeight(), and KisConstrainedRect::setRectInitial().

◆ setCropType

void KisToolCrop::setCropType ( KisToolCrop::CropToolType cropType )

slot

Definition at line 494 of file kis_tool_crop.cc.

{
    if(m_cropType == cropType)
        return;
    m_cropType = cropType;
 
    configGroup.writeEntry("cropType", static_cast<int>(cropType));
 
    Q_EMIT cropTypeChanged(m_cropType);
}

References configGroup, cropType, cropTypeChanged(), and m_cropType.

◆ setCropTypeLegacy

void KisToolCrop::setCropTypeLegacy ( int cropType )

slot

Definition at line 489 of file kis_tool_crop.cc.

{
    setCropType(static_cast<KisToolCrop::CropToolType>(cropType));
}

References cropType, and setCropType().

◆ setCropTypeSelectable

void KisToolCrop::setCropTypeSelectable ( bool selectable )

slot

Definition at line 510 of file kis_tool_crop.cc.

{
    if(selectable == m_cropTypeSelectable)
        return;
    m_cropTypeSelectable = selectable;
    Q_EMIT cropTypeSelectableChanged();
}

References cropTypeSelectableChanged(), and m_cropTypeSelectable.

◆ setCropWidth

void KisToolCrop::setCropWidth ( int x )

slot

Definition at line 603 of file kis_tool_crop.cc.

{
    if(w == m_finalRect.rect().width())
        return;
 
    if (!m_haveCropSelection) {
        m_haveCropSelection = true;
        m_finalRect.setRectInitial(image()->bounds());
    }
 
    m_finalRect.setWidth(w);
}

References bounds, KisTool::image(), m_finalRect, m_haveCropSelection, KisConstrainedRect::rect(), KisConstrainedRect::setRectInitial(), and KisConstrainedRect::setWidth().

◆ setCropX

void KisToolCrop::setCropX ( int x )

slot

Definition at line 563 of file kis_tool_crop.cc.

{
    if(x == m_finalRect.rect().x())
        return;
 
    if (!m_haveCropSelection) {
        m_haveCropSelection = true;
        m_finalRect.setRectInitial(image()->bounds());
    }
 
    QPoint offset = m_finalRect.rect().topLeft();
    offset.setX(x);
    m_finalRect.setOffset(offset);
}

References bounds, KisTool::image(), m_finalRect, m_haveCropSelection, KisConstrainedRect::rect(), KisConstrainedRect::setOffset(), and KisConstrainedRect::setRectInitial().

◆ setCropY

void KisToolCrop::setCropY ( int y )

slot

Definition at line 583 of file kis_tool_crop.cc.

{
    if(y == m_finalRect.rect().y())
        return;
 
    if (!m_haveCropSelection) {
        m_haveCropSelection = true;
        m_finalRect.setRectInitial(image()->bounds());
    }
 
    QPoint offset = m_finalRect.rect().topLeft();
    offset.setY(y);
    m_finalRect.setOffset(offset);
}

References bounds, KisTool::image(), m_finalRect, m_haveCropSelection, KisConstrainedRect::rect(), KisConstrainedRect::setOffset(), and KisConstrainedRect::setRectInitial().

◆ setDecoration

void KisToolCrop::setDecoration ( int i )

slot

Definition at line 528 of file kis_tool_crop.cc.

{
    // This shouldn't happen, but safety first
    if(i < 0 || i > DECORATION_COUNT)
        return;
    m_decoration = i;
    Q_EMIT decorationChanged(decoration());
    updateCanvasViewRect(boundingRect());
 
    configGroup.writeEntry("decoration", i);
}

References boundingRect(), configGroup, decoration, DECORATION_COUNT, decorationChanged(), m_decoration, and KisTool::updateCanvasViewRect().

◆ setGrowCenter

void KisToolCrop::setGrowCenter ( bool g )

slot

Definition at line 673 of file kis_tool_crop.cc.

{
    m_finalRect.setCentered(value);
 
 
    configGroup.writeEntry("growCenter", value);
 
    Q_EMIT isCenteredChanged(value);
}

References configGroup, isCenteredChanged(), m_finalRect, KisConstrainedRect::setCentered(), and value().

◆ setLockHeight

void KisToolCrop::setLockHeight ( bool lock )

slot

Definition at line 649 of file kis_tool_crop.cc.

{
    m_finalRect.setHeightLocked(lock);
}

References m_finalRect, and KisConstrainedRect::setHeightLocked().

◆ setLockRatio

void KisToolCrop::setLockRatio ( bool lock )

slot

Definition at line 706 of file kis_tool_crop.cc.

{
    m_finalRect.setRatioLocked(lock);
}

References m_finalRect, and KisConstrainedRect::setRatioLocked().

◆ setLockWidth

void KisToolCrop::setLockWidth ( bool lock )

slot

Definition at line 621 of file kis_tool_crop.cc.

{
    m_finalRect.setWidthLocked(lock);
}

References m_finalRect, and KisConstrainedRect::setWidthLocked().

◆ setMoveResizeCursor()

void KisToolCrop::setMoveResizeCursor ( qint32 handle )

private

Definition at line 860 of file kis_tool_crop.cc.

{
    QCursor cursorType;
 
    switch (handle) {
    case(UpperLeft):
    case(LowerRight):
        cursorType = KisCursor::sizeFDiagCursor();
        break;
    case(LowerLeft):
    case(UpperRight):
        cursorType = KisCursor::sizeBDiagCursor();
        break;
    case(Upper):
    case(Lower):
        cursorType = KisCursor::sizeVerCursor();
        break;
    case(Left):
    case(Right):
        cursorType = KisCursor::sizeHorCursor();
        break;
    case(Inside):
        cursorType = KisCursor::sizeAllCursor();
        break;
    default:
        if (m_haveCropSelection) {
            cursorType = KisCursor::arrowCursor();
        } else {
            cursorType = cursor();
        }
        break;
    }
    useCursor(cursorType);
}

References KisCursor::arrowCursor(), KisTool::cursor, Inside, Left, Lower, LowerLeft, LowerRight, m_haveCropSelection, Right, KisCursor::sizeAllCursor(), KisCursor::sizeBDiagCursor(), KisCursor::sizeFDiagCursor(), KisCursor::sizeHorCursor(), KisCursor::sizeVerCursor(), Upper, UpperLeft, UpperRight, and KoToolBase::useCursor().

◆ setRatio

void KisToolCrop::setRatio ( double ratio )

slot

Definition at line 688 of file kis_tool_crop.cc.

{
    if(ratio == m_finalRect.ratio())
        return;
 
    if (!m_haveCropSelection) {
        m_haveCropSelection = true;
        m_finalRect.setRectInitial(image()->bounds());
    }
 
    m_finalRect.setRatio(ratio);
}

References bounds, KisTool::image(), m_finalRect, m_haveCropSelection, KisConstrainedRect::ratio(), ratio, KisConstrainedRect::setRatio(), and KisConstrainedRect::setRectInitial().

◆ showSizeOnCanvas

void KisToolCrop::showSizeOnCanvas ( )

slot

Definition at line 716 of file kis_tool_crop.cc.

{
    KisCanvas2 *kisCanvas =dynamic_cast<KisCanvas2*>(canvas());
    Q_ASSERT(kisCanvas);
    if(m_mouseOnHandleType == 9) {
        kisCanvas->viewManager()->showFloatingMessage(i18n("X: %1\nY: %2"
                                                       , optionsWidget->intX->text(), optionsWidget->intY->text())
                                                       , QIcon(), 1000, KisFloatingMessage::High, Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
    }
    else {
        kisCanvas->viewManager()->showFloatingMessage(i18n("Width: %1\nHeight: %2"
                                                   , optionsWidget->intWidth->text(), optionsWidget->intHeight->text())
                                                   , QIcon(), 1000, KisFloatingMessage::High, Qt::AlignLeft | Qt::TextWordWrap | Qt::AlignVCenter);
    }
}

References Private::canvas, KisFloatingMessage::High, m_mouseOnHandleType, optionsWidget, KisViewManager::showFloatingMessage(), and KisCanvas2::viewManager().

◆ slotRectChanged

void KisToolCrop::slotRectChanged ( )

slot

Definition at line 546 of file kis_tool_crop.cc.

{
    Q_EMIT cropHeightChanged(cropHeight());
    Q_EMIT cropWidthChanged(cropWidth());
    Q_EMIT cropXChanged(cropX());
    Q_EMIT cropYChanged(cropY());
    Q_EMIT ratioChanged(ratio());
    Q_EMIT lockHeightChanged(lockHeight());
    Q_EMIT lockWidthChanged(lockWidth());
    Q_EMIT lockRatioChanged(lockRatio());
 
    Q_EMIT canGrowChanged(allowGrow());
    Q_EMIT isCenteredChanged(growCenter());
 
    doCanvasUpdate(boundingRect().toAlignedRect());
}

References allowGrow(), boundingRect(), canGrowChanged(), cropHeight, cropHeightChanged(), cropWidth, cropWidthChanged(), cropX, cropXChanged(), cropY, cropYChanged(), doCanvasUpdate(), growCenter(), isCenteredChanged(), lockHeight, lockHeightChanged(), lockRatio, lockRatioChanged(), lockWidth, lockWidthChanged(), ratio, and ratioChanged().

◆ tryContinueLastCropAction()

bool KisToolCrop::tryContinueLastCropAction ( )

private

Definition at line 316 of file kis_tool_crop.cc.

{
    bool result = false;
 
    const KUndo2Command *lastCommand = image()->undoAdapter()->presentCommand();
    const KisCropSavedExtraData *data = 0;
 
    if ((lastCommand = image()->undoAdapter()->presentCommand()) &&
        (data = dynamic_cast<const KisCropSavedExtraData*>(lastCommand->extraData()))) {
 
        bool cropImageConsistent =
            m_cropType == ImageCropType &&
            (data->type() == KisCropSavedExtraData::CROP_IMAGE ||
             data->type() == KisCropSavedExtraData::RESIZE_IMAGE);
 
        bool cropLayerConsistent =
            m_cropType == LayerCropType &&
            data->type() == KisCropSavedExtraData::CROP_LAYER &&
            currentNode() == data->cropNode();
 
 
        if (cropImageConsistent || cropLayerConsistent) {
            image()->undoAdapter()->undoLastCommand();
            image()->waitForDone();
 
            m_finalRect.setRectInitial(data->cropRect());
            m_haveCropSelection = true;
 
            result = true;
        }
    }
 
    return result;
}

References KisCropSavedExtraData::CROP_IMAGE, KisCropSavedExtraData::CROP_LAYER, KisCropSavedExtraData::cropNode(), KisCropSavedExtraData::cropRect(), KisTool::currentNode(), KUndo2Command::extraData(), KisTool::image(), ImageCropType, LayerCropType, m_cropType, m_finalRect, m_haveCropSelection, KisUndoAdapter::presentCommand(), KisCropSavedExtraData::RESIZE_IMAGE, KisConstrainedRect::setRectInitial(), KisCropSavedExtraData::type(), KisImage::undoAdapter(), KisUndoAdapter::undoLastCommand(), and KisImage::waitForDone().

◆ upperHandleRect()

QRectF KisToolCrop::upperHandleRect ( QRectF cropBorderRect )

private

Definition at line 801 of file kis_tool_crop.cc.

{
    return QRectF(cropBorderRect.left() + (cropBorderRect.width() - m_handleSize) / 2.0 , cropBorderRect.top() - m_handleSize / 2.0, m_handleSize, m_handleSize);
}

References m_handleSize.

◆ upperLeftHandleRect()

QRectF KisToolCrop::upperLeftHandleRect ( QRectF cropBorderRect )

private

Definition at line 786 of file kis_tool_crop.cc.

{
    return QRectF(cropBorderRect.left() - m_handleSize / 2.0, cropBorderRect.top() - m_handleSize / 2.0, m_handleSize, m_handleSize);
}

References m_handleSize.

◆ upperRightHandleRect()

QRectF KisToolCrop::upperRightHandleRect ( QRectF cropBorderRect )

private

Definition at line 776 of file kis_tool_crop.cc.

{
    return QRectF(cropBorderRect.right() - m_handleSize / 2.0 , cropBorderRect.top() - m_handleSize / 2.0, m_handleSize, m_handleSize);
}

References m_handleSize.

Member Data Documentation

◆ applyCrop

KisAction* KisToolCrop::applyCrop {nullptr}

private

Definition at line 183 of file kis_tool_crop.h.

183{nullptr};

◆ centerToggleOption

KisAction* KisToolCrop::centerToggleOption {nullptr}

private

Definition at line 184 of file kis_tool_crop.h.

184{nullptr};

◆ configGroup

KConfigGroup KisToolCrop::configGroup

private

Definition at line 179 of file kis_tool_crop.h.

◆ growToggleOption

KisAction* KisToolCrop::growToggleOption {nullptr}

private

Definition at line 185 of file kis_tool_crop.h.

185{nullptr};

◆ lockHeightToggleOption

KisAction* KisToolCrop::lockHeightToggleOption {nullptr}

private

Definition at line 187 of file kis_tool_crop.h.

187{nullptr};

◆ lockRatioToggleOption

KisAction* KisToolCrop::lockRatioToggleOption {nullptr}

private

Definition at line 188 of file kis_tool_crop.h.

188{nullptr};

◆ lockWidthToggleOption

KisAction* KisToolCrop::lockWidthToggleOption {nullptr}

private

Definition at line 186 of file kis_tool_crop.h.

186{nullptr};

◆ m_contextMenu

QScopedPointer<QMenu> KisToolCrop::m_contextMenu

private

Definition at line 182 of file kis_tool_crop.h.

◆ m_cropType

CropToolType KisToolCrop::m_cropType {ImageCropType}

private

Definition at line 172 of file kis_tool_crop.h.

172{ImageCropType};

◆ m_cropTypeSelectable

bool KisToolCrop::m_cropTypeSelectable {false}

private

Definition at line 173 of file kis_tool_crop.h.

173{false};

◆ m_decoration

int KisToolCrop::m_decoration {1}

private

Definition at line 175 of file kis_tool_crop.h.

175{1};

◆ m_decorations

QList<DecorationLine *> KisToolCrop::m_decorations

private

Definition at line 202 of file kis_tool_crop.h.

◆ m_dragOffsetDoc

QPointF KisToolCrop::m_dragOffsetDoc

private

Definition at line 206 of file kis_tool_crop.h.

◆ m_dragStart

QPoint KisToolCrop::m_dragStart

private

Definition at line 166 of file kis_tool_crop.h.

◆ m_finalRect

KisConstrainedRect KisToolCrop::m_finalRect

private

Definition at line 204 of file kis_tool_crop.h.

◆ m_handleSize

qint32 KisToolCrop::m_handleSize {13}

private

Definition at line 168 of file kis_tool_crop.h.

168{13};

◆ m_haveCropSelection

bool KisToolCrop::m_haveCropSelection {false}

private

Definition at line 169 of file kis_tool_crop.h.

169{false};

◆ m_initialDragRect

QRect KisToolCrop::m_initialDragRect

private

Definition at line 205 of file kis_tool_crop.h.

◆ m_lastCanvasUpdateRect

QRect KisToolCrop::m_lastCanvasUpdateRect

private

Definition at line 177 of file kis_tool_crop.h.

◆ m_mouseOnHandleType

qint32 KisToolCrop::m_mouseOnHandleType {0}

private

Definition at line 170 of file kis_tool_crop.h.

170{0};

◆ m_resettingStroke

bool KisToolCrop::m_resettingStroke {false}

private

Definition at line 176 of file kis_tool_crop.h.

176{false};

◆ optionsWidget

KisToolCropConfigWidget* KisToolCrop::optionsWidget {nullptr}

private

Definition at line 180 of file kis_tool_crop.h.

180{nullptr};

Property Documentation

◆ cropHeight

int KisToolCrop::cropHeight

readwrite

Definition at line 47 of file kis_tool_crop.h.

◆ cropType

CropToolType KisToolCrop::cropType

readwrite

Definition at line 41 of file kis_tool_crop.h.

◆ cropTypeSelectable

bool KisToolCrop::cropTypeSelectable

readwrite

Definition at line 42 of file kis_tool_crop.h.

◆ cropWidth

int KisToolCrop::cropWidth

readwrite

Definition at line 45 of file kis_tool_crop.h.

◆ cropX

int KisToolCrop::cropX

readwrite

Definition at line 43 of file kis_tool_crop.h.

◆ cropY

int KisToolCrop::cropY

readwrite

Definition at line 44 of file kis_tool_crop.h.

◆ decoration

int KisToolCrop::decoration

readwrite

Definition at line 51 of file kis_tool_crop.h.

◆ lockHeight

bool KisToolCrop::lockHeight

readwrite

Definition at line 48 of file kis_tool_crop.h.

◆ lockRatio

bool KisToolCrop::lockRatio

readwrite

Definition at line 50 of file kis_tool_crop.h.

◆ lockWidth

bool KisToolCrop::lockWidth

readwrite

Definition at line 46 of file kis_tool_crop.h.

◆ ratio

double KisToolCrop::ratio

readwrite

Definition at line 49 of file kis_tool_crop.h.

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

plugins/tools/tool_crop/kis_tool_crop.h
plugins/tools/tool_crop/kis_tool_crop.cc

Public Types

Public Slots

Signals

Public Member Functions

Properties

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ CropToolType

◆ handleType

Constructor & Destructor Documentation

◆ KisToolCrop()

◆ ~KisToolCrop()

Member Function Documentation

◆ activate

◆ allowGrow()

◆ beginPrimaryAction()

◆ beginPrimaryDoubleClickAction()

◆ borderLineRect()

◆ boundingRect()

◆ cancelStroke()

◆ canGrowChanged

◆ canvasResourceChanged()

◆ continuePrimaryAction()

◆ createOptionWidget()

◆ crop

◆ cropHeight()

◆ cropHeightChanged

◆ cropType()

◆ cropTypeChanged

◆ cropTypeSelectable()

◆ cropTypeSelectableChanged

◆ cropWidth()

◆ cropWidthChanged

◆ cropX()

◆ cropXChanged

◆ cropY()

◆ cropYChanged

◆ deactivate

◆ decoration()

◆ decorationChanged

◆ doCanvasUpdate()

◆ drawDecorationLine()

◆ endPrimaryAction()

◆ growCenter()

◆ handlesPath()

◆ isCenteredChanged

◆ leftHandleRect()

◆ lockHeight()

◆ lockHeightChanged

◆ lockRatio()

◆ lockRatioChanged

◆ lockWidth()

◆ lockWidthChanged

◆ lowerHandleRect()

◆ lowerLeftHandleRect()

◆ lowerRightHandleRect()

◆ mouseMoveEvent()

◆ mouseOnHandle()

◆ paint()

◆ paintOutlineWithHandles()

◆ popupActionsMenu()

◆ Q_ENUMS()

◆ ratio()

◆ ratioChanged

◆ requestRedoDuringStroke

◆ requestStrokeCancellation

◆ requestStrokeEnd

◆ requestUndoDuringStroke

◆ rightHandleRect()

◆ setAllowGrow

◆ setCropHeight

◆ setCropType

◆ setCropTypeLegacy

◆ setCropTypeSelectable

◆ setCropWidth

◆ setCropX