DefaultTool Class Reference

#include <DefaultTool.h>

Inheritance diagram for DefaultTool:

Classes
class	MoveGradientHandleInteractionFactory
class	MoveMeshGradientHandleInteractionFactory

Public Types
enum	CanvasResource { HotPosition = 1410100299 }

Public Slots
void	activate (const QSet< KoShape * > &shapes) override
void	deactivate () override
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	meshgradientHandleSelected (KoShapeMeshGradientHandles::Handle)
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	copy () const override
	reimplemented
QRectF	decorationsRect () const override
	DefaultTool (KoCanvasBase *canvas, bool connectToSelectedShapesProxy=false)
void	deleteSelection () override
	reimplemented
void	deselect () override
	reimplemented
void	explicitUserStrokeEndRequest () override
	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.
KoFlake::SelectionHandle	handleAt (const QPointF &point, bool *innerHandleMeaning=0)
void	keyPressEvent (QKeyEvent *event) override
void	mouseDoubleClickEvent (KoPointerEvent *event) override
void	mouseMoveEvent (KoPointerEvent *event) override
void	mousePressEvent (KoPointerEvent *event) override
void	mouseReleaseEvent (KoPointerEvent *event) override
void	paint (QPainter &painter, const KoViewConverter &converter) override
bool	paste () override
	reimplemented
QMenu *	popupActionsMenu () override
bool	selectAll () override
	reimplemented
KoToolSelection *	selection () override
	reimplemented
KoSvgTextShape *	tryFetchCurrentShapeManagerOwnerTextShape () const
bool	updateTextContourMode ()
bool	wantsAutoScroll () const override
	~DefaultTool () override
Public Member Functions inherited from KoInteractionTool
void	keyPressEvent (QKeyEvent *event) override
void	keyReleaseEvent (QKeyEvent *event) override
	KoInteractionTool (KoCanvasBase *canvas)
void	mouseMoveEvent (KoPointerEvent *event) override
void	mousePressEvent (KoPointerEvent *event) override
void	mouseReleaseEvent (KoPointerEvent *event) override
void	paint (QPainter &painter, const KoViewConverter &converter) override
	~KoInteractionTool () override
Public Member Functions inherited from KoToolBase
QAction *	action (const QString &name) const
KoCanvasBase *	canvas () const
	Returns the canvas the tool is working on.
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 ()
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	dragLeaveEvent (QDragLeaveEvent *event)
virtual void	dragMoveEvent (QDragMoveEvent *event, const QPointF &point)
virtual void	dropEvent (QDropEvent *event, const QPointF &point)
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
	KoToolBase (KoCanvasBase *canvas)
bool	maskSyntheticEvents () const
virtual void	mouseTripleClickEvent (KoPointerEvent *event)
QList< QPointer< QWidget > >	optionWidgets ()
virtual KisPopupWidgetInterface *	popupWidget ()
Q_INVOKABLE QString	toolId () const
	~KoToolBase () override

Protected Slots
void	updateActions ()
	Update actions on selection change.

Protected Member Functions
void	addTransformActions (QMenu *menu) const
QList< QPointer< QWidget > >	createOptionWidgets () override
KoInteractionStrategy *	createStrategy (KoPointerEvent *event) override
virtual bool	isValidForCurrentLayer () const
virtual KoSelection *	koSelection () const
virtual KoShapeManager *	shapeManager () const
virtual void	updateDistinctiveActions (const QList< KoShape * > &editableShapes)
Protected Member Functions inherited from KoInteractionTool
void	addInteractionFactory (KoInteractionStrategyFactory *factory)
void	cancelCurrentStrategy ()
	Cancels the current strategy and deletes it.
KoInteractionStrategy *	createStrategyBase (KoPointerEvent *event)
KoInteractionStrategy *	currentStrategy ()
bool	hasInteractionFactory (const QString &id)
	KoInteractionTool (KoInteractionToolPrivate &dd)
void	removeInteractionFactory (const QString &id)
bool	tryUseCustomCursor ()
Protected Member Functions inherited from KoToolBase
virtual QWidget *	createOptionWidget ()
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
QScopedPointer< QMenu >	m_contextMenu
Protected Attributes inherited from KoToolBase
KoToolBasePrivate *	d_ptr

Private Slots
void	selectionAlign (int _align)
void	selectionBooleanOp (int booleanOp)
void	selectionBringToFront ()
void	selectionDistribute (int _distribute)
void	selectionGroup ()
void	selectionMoveDown ()
void	selectionMoveUp ()
void	selectionSendToBack ()
void	selectionSplitShapes ()
void	selectionTransform (int transformAction)
void	selectionUngroup ()
void	slotActivateEditFillGradient (bool value)
void	slotActivateEditFillMeshGradient (bool value)
void	slotActivateEditStrokeGradient (bool value)
void	slotAddShapesToFlow ()
void	slotChangeTextType (int index)
void	slotPutTextOnPath ()
void	slotRemoveShapesFromFlow ()
void	slotReorderFlowShapes (int type)
void	slotResetMeshGradientState ()
void	slotSubtractShapesFromFlow ()
void	slotToggleFlowShapeType ()

Private Member Functions
void	addMappedAction (KisSignalMapper *mapper, const QString &actionId, int type)
void	canvasResourceChanged (int key, const QVariant &res) override
QRectF	handlesSize ()
	Returns selection rectangle adjusted by handle proximity threshold.
bool	moveSelection (int direction, Qt::KeyboardModifiers modifiers)
void	recalcSelectionBox (KoSelection *selection)
qreal	rotationOfHandle (KoFlake::SelectionHandle handle, bool useEdgeRotation)
	Returns rotation angle of given handle of the current selection.
void	selectionReorder (KoShapeReorderCommand::MoveShapeType order)
void	setupActions ()
void	updateCursor ()

Private Attributes
KisSignalMapper *	m_alignSignalsMapper {0}
qreal	m_angle
KisSignalMapper *	m_booleanSignalsMapper {0}
QScopedPointer< SelectionDecorator >	m_decorator
KisSignalMapper *	m_distributeSignalsMapper {0}
KoFlake::AnchorPosition	m_hotPosition
KoShapeMeshGradientHandles::Handle	m_hoveredMeshHandle
KoFlake::SelectionHandle	m_lastHandle
QPointF	m_lastPoint
bool	m_mouseWasInsideHandles
QCursor	m_rotateCursors [8]
KoShapeMeshGradientHandles::Handle	m_selectedMeshHandle
QPointF	m_selectionBox [8]
KoToolSelection *	m_selectionHandler
QPolygonF	m_selectionOutline
QCursor	m_shearCursors [8]
QCursor	m_sizeCursors [8]
DefaultToolTabbedWidget *	m_tabbedOptionWidget
KisSignalMapper *	m_textFlowSignalsMapper {0}
QScopedPointer< KoSvgTextShapeOutlineHelper >	m_textOutlineHelper
DefaultToolTextPropertiesInterface *	m_textPropertyInterface {0}
KisSignalMapper *	m_textTypeSignalsMapper {0}
KisSignalMapper *	m_transformSignalsMapper {0}

Friends
class	SelectionHandler
class	SelectionInteractionStrategy

Detailed Description

The default tool (associated with the arrow icon) implements the default interactions you have with flake objects.
The tool provides scaling, moving, selecting, rotation and soon skewing of any number of shapes.

Note that the implementation of those different strategies are delegated to the InteractionStrategy class and its subclasses.

Definition at line 41 of file DefaultTool.h.

Member Enumeration Documentation

CanvasResource

enum DefaultTool::CanvasResource

Enumerator
HotPosition

Definition at line 53 of file DefaultTool.h.

                        {
        HotPosition = 1410100299
    };

Constructor & Destructor Documentation

DefaultTool()

DefaultTool::DefaultTool ( KoCanvasBase * canvas, bool connectToSelectedShapesProxy = false )

explicit

Constructor for basic interaction tool where user actions are translated and handled by interaction strategies of type KoInteractionStrategy.

Parameters

canvas

the canvas this tool will be working for.

Definition at line 422 of file DefaultTool.cpp.

    : KoInteractionTool(canvas)
    , m_lastHandle(KoFlake::NoHandle)
    , m_hotPosition(KoFlake::TopLeft)
    , m_mouseWasInsideHandles(false)
    , m_textOutlineHelper(new KoSvgTextShapeOutlineHelper(canvas))
    , m_selectionHandler(new SelectionHandler(this))
    , m_tabbedOptionWidget(0)
    , m_textPropertyInterface(new DefaultToolTextPropertiesInterface(this))
{
    setupActions();
 
    QPixmap rotatePixmap, shearPixmap;
    rotatePixmap.load(":/cursor_rotate.png");
    Q_ASSERT(!rotatePixmap.isNull());
    shearPixmap.load(":/cursor_shear.png");
    Q_ASSERT(!shearPixmap.isNull());
 
    m_rotateCursors[0] = QCursor(rotatePixmap.transformed(QTransform().rotate(45)));
    m_rotateCursors[1] = QCursor(rotatePixmap.transformed(QTransform().rotate(90)));
    m_rotateCursors[2] = QCursor(rotatePixmap.transformed(QTransform().rotate(135)));
    m_rotateCursors[3] = QCursor(rotatePixmap.transformed(QTransform().rotate(180)));
    m_rotateCursors[4] = QCursor(rotatePixmap.transformed(QTransform().rotate(225)));
    m_rotateCursors[5] = QCursor(rotatePixmap.transformed(QTransform().rotate(270)));
    m_rotateCursors[6] = QCursor(rotatePixmap.transformed(QTransform().rotate(315)));
    m_rotateCursors[7] = QCursor(rotatePixmap);
    /*
        m_rotateCursors[0] = QCursor(Qt::RotateNCursor);
        m_rotateCursors[1] = QCursor(Qt::RotateNECursor);
        m_rotateCursors[2] = QCursor(Qt::RotateECursor);
        m_rotateCursors[3] = QCursor(Qt::RotateSECursor);
        m_rotateCursors[4] = QCursor(Qt::RotateSCursor);
        m_rotateCursors[5] = QCursor(Qt::RotateSWCursor);
        m_rotateCursors[6] = QCursor(Qt::RotateWCursor);
        m_rotateCursors[7] = QCursor(Qt::RotateNWCursor);
    */
    m_shearCursors[0] = QCursor(shearPixmap);
    m_shearCursors[1] = QCursor(shearPixmap.transformed(QTransform().rotate(45)));
    m_shearCursors[2] = QCursor(shearPixmap.transformed(QTransform().rotate(90)));
    m_shearCursors[3] = QCursor(shearPixmap.transformed(QTransform().rotate(135)));
    m_shearCursors[4] = QCursor(shearPixmap.transformed(QTransform().rotate(180)));
    m_shearCursors[5] = QCursor(shearPixmap.transformed(QTransform().rotate(225)));
    m_shearCursors[6] = QCursor(shearPixmap.transformed(QTransform().rotate(270)));
    m_shearCursors[7] = QCursor(shearPixmap.transformed(QTransform().rotate(315)));
    m_sizeCursors[0] = Qt::SizeVerCursor;
    m_sizeCursors[1] = Qt::SizeBDiagCursor;
    m_sizeCursors[2] = Qt::SizeHorCursor;
    m_sizeCursors[3] = Qt::SizeFDiagCursor;
    m_sizeCursors[4] = Qt::SizeVerCursor;
    m_sizeCursors[5] = Qt::SizeBDiagCursor;
    m_sizeCursors[6] = Qt::SizeHorCursor;
    m_sizeCursors[7] = Qt::SizeFDiagCursor;
 
    if (connectToSelectedShapesProxy) {
        connect(canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(updateActions()));
 
        connect(canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), this, SLOT(repaintDecorations()));
        connect(canvas->selectedShapesProxy(), SIGNAL(selectionChanged()), m_textPropertyInterface, SLOT(slotSelectionChanged()));
        connect(canvas->selectedShapesProxy(), SIGNAL(selectionContentChanged()), this, SLOT(repaintDecorations()));
    }
 
    m_textOutlineHelper->setDrawBoundingRect(false);
    m_textOutlineHelper->setDrawShapeOutlines(true);
}

References KoToolBase::canvas(), m_rotateCursors, m_shearCursors, m_sizeCursors, m_textOutlineHelper, m_textPropertyInterface, KoToolBase::repaintDecorations(), KoCanvasBase::selectedShapesProxy(), KoToolBase::selectionChanged(), setupActions(), and updateActions().

~DefaultTool()

DefaultTool::~DefaultTool ( )

override

Definition at line 487 of file DefaultTool.cpp.

{
}

Member Function Documentation

activate

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

overrideslot

Definition at line 1476 of file DefaultTool.cpp.

{
    KoToolBase::activate(shapes);
 
    QAction *actionBringToFront = action("object_order_front");
    connect(actionBringToFront, SIGNAL(triggered()), this, SLOT(selectionBringToFront()), Qt::UniqueConnection);
 
    QAction *actionRaise = action("object_order_raise");
    connect(actionRaise, SIGNAL(triggered()), this, SLOT(selectionMoveUp()), Qt::UniqueConnection);
 
    QAction *actionLower = action("object_order_lower");
    connect(actionLower, SIGNAL(triggered()), this, SLOT(selectionMoveDown()));
 
    QAction *actionSendToBack = action("object_order_back");
    connect(actionSendToBack, SIGNAL(triggered()), this, SLOT(selectionSendToBack()), Qt::UniqueConnection);
 
    QAction *actionGroupBottom = action("object_group");
    connect(actionGroupBottom, SIGNAL(triggered()), this, SLOT(selectionGroup()), Qt::UniqueConnection);
 
    QAction *actionUngroupBottom = action("object_ungroup");
    connect(actionUngroupBottom, SIGNAL(triggered()), this, SLOT(selectionUngroup()), Qt::UniqueConnection);
 
    QAction *actionSplit = action("object_split");
    connect(actionSplit, SIGNAL(triggered()), this, SLOT(selectionSplitShapes()), Qt::UniqueConnection);
 
    connect(m_alignSignalsMapper, SIGNAL(mapped(int)), SLOT(selectionAlign(int)));
    connect(m_distributeSignalsMapper, SIGNAL(mapped(int)), SLOT(selectionDistribute(int)));
    connect(m_transformSignalsMapper, SIGNAL(mapped(int)), SLOT(selectionTransform(int)));
    connect(m_booleanSignalsMapper, SIGNAL(mapped(int)), SLOT(selectionBooleanOp(int)));
    connect(m_textTypeSignalsMapper, SIGNAL(mapped(int)), SLOT(slotChangeTextType(int)));
    connect(m_textFlowSignalsMapper, SIGNAL(mapped(int)), SLOT(slotReorderFlowShapes(int)));
 
    QAction *actionTextInside = action("add_shape_to_flow_area");
    connect(actionTextInside, SIGNAL(triggered()), this, SLOT(slotAddShapesToFlow()), Qt::UniqueConnection);
 
    QAction *actionTextSubtract = action("subtract_shape_from_flow_area");
    connect(actionTextSubtract, SIGNAL(triggered()), this, SLOT(slotSubtractShapesFromFlow()), Qt::UniqueConnection);
 
    QAction *actionTextOnPath = action("put_text_on_path");
    connect(actionTextOnPath, SIGNAL(triggered()), this, SLOT(slotPutTextOnPath()), Qt::UniqueConnection);
 
    QAction *actionTextRemoveFlow = action("remove_shapes_from_text_flow");
    connect(actionTextRemoveFlow, SIGNAL(triggered()), this, SLOT(slotRemoveShapesFromFlow()), Qt::UniqueConnection);
 
    QAction *actionTextFlowToggle = action("flow_shape_type_toggle");
    connect(actionTextFlowToggle, SIGNAL(triggered()), this, SLOT(slotToggleFlowShapeType()), Qt::UniqueConnection);
 
    m_mouseWasInsideHandles = false;
    m_lastHandle = KoFlake::NoHandle;
    useCursor(Qt::ArrowCursor);
    repaintDecorations();
    updateActions();
 
    const KisCanvas2 *canvas2 = qobject_cast<const KisCanvas2 *>(this->canvas());
    if (canvas2) {
        canvas2->viewManager()->textPropertyManager()->setTextPropertiesInterface(m_textPropertyInterface);
        m_textPropertyInterface->slotSelectionChanged();
    }
 
    if (m_tabbedOptionWidget) {
        m_tabbedOptionWidget->activate();
    }
}

References KoToolBase::action(), DefaultToolTabbedWidget::activate(), KoToolBase::activate(), KoToolBase::canvas(), m_alignSignalsMapper, m_booleanSignalsMapper, m_distributeSignalsMapper, m_lastHandle, m_mouseWasInsideHandles, m_tabbedOptionWidget, m_textFlowSignalsMapper, m_textPropertyInterface, m_textTypeSignalsMapper, m_transformSignalsMapper, KoFlake::NoHandle, KoToolBase::repaintDecorations(), selectionAlign(), selectionBooleanOp(), selectionBringToFront(), selectionDistribute(), selectionGroup(), selectionMoveDown(), selectionMoveUp(), selectionSendToBack(), selectionSplitShapes(), selectionTransform(), selectionUngroup(), KisTextPropertiesManager::setTextPropertiesInterface(), slotAddShapesToFlow(), slotChangeTextType(), slotPutTextOnPath(), slotRemoveShapesFromFlow(), slotReorderFlowShapes(), DefaultToolTextPropertiesInterface::slotSelectionChanged(), slotSubtractShapesFromFlow(), slotToggleFlowShapeType(), KisViewManager::textPropertyManager(), updateActions(), KoToolBase::useCursor(), and KisCanvas2::viewManager().

addMappedAction()

void DefaultTool::addMappedAction ( KisSignalMapper * mapper, const QString & actionId, int type )

private

Definition at line 799 of file DefaultTool.cpp.

{
    QAction *a =action(actionId);
    connect(a, SIGNAL(triggered()), mapper, SLOT(map()));
    mapper->setMapping(a, commandType);
}

References KoToolBase::action(), and KisSignalMapper::setMapping().

addTransformActions()

void DefaultTool::addTransformActions ( QMenu * menu ) const

protected

Definition at line 2335 of file DefaultTool.cpp.

                                                       {
    menu->addAction(action("object_transform_rotate_90_cw"));
    menu->addAction(action("object_transform_rotate_90_ccw"));
    menu->addAction(action("object_transform_rotate_180"));
    menu->addSeparator();
    menu->addAction(action("object_transform_mirror_horizontally"));
    menu->addAction(action("object_transform_mirror_vertically"));
    menu->addSeparator();
    menu->addAction(action("object_transform_reset"));
}

References KoToolBase::action().

canvasResourceChanged()

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

overrideprivatevirtual

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 1977 of file DefaultTool.cpp.

{
    if (key == HotPosition) {
        m_hotPosition = KoFlake::AnchorPosition(res.toInt());
        repaintDecorations();
    }
}

References HotPosition, m_hotPosition, and KoToolBase::repaintDecorations().

copy()

void DefaultTool::copy ( ) const

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 1328 of file DefaultTool.cpp.

{
    // all the selected shapes, not only editable!
    QList<KoShape *> shapes = koSelection()->selectedShapes();
 
    if (!shapes.isEmpty()) {
        KoDrag drag;
        drag.setSvg(shapes);
        drag.addToClipboard();
    }
}

References KoDrag::addToClipboard(), koSelection(), KoSelection::selectedShapes(), and KoDrag::setSvg().

createOptionWidgets()

QList< QPointer< QWidget > > DefaultTool::createOptionWidgets ( )

overrideprotectedvirtual

Reimplemented from KoToolBase.

Reimplemented in ToolReferenceImages.

Definition at line 1946 of file DefaultTool.cpp.

{
    QList<QPointer<QWidget> > widgets;
 
    m_tabbedOptionWidget = new DefaultToolTabbedWidget(this);
 
    if (isActivated()) {
        m_tabbedOptionWidget->activate();
    }
    widgets.append(m_tabbedOptionWidget);
 
    connect(m_tabbedOptionWidget,
            SIGNAL(sigSwitchModeEditFillGradient(bool)),
            SLOT(slotActivateEditFillGradient(bool)));
 
    connect(m_tabbedOptionWidget,
            SIGNAL(sigSwitchModeEditStrokeGradient(bool)),
            SLOT(slotActivateEditStrokeGradient(bool)));
 
    connect(m_tabbedOptionWidget,
            SIGNAL(sigSwitchModeEditFillGradient(bool)),
            SLOT(slotActivateEditFillMeshGradient(bool)));
    // TODO: strokes!!
 
    connect(m_tabbedOptionWidget,
            SIGNAL(sigMeshGradientResetted()),
            SLOT(slotResetMeshGradientState()));
 
    return widgets;
}

References DefaultToolTabbedWidget::activate(), KoToolBase::isActivated(), m_tabbedOptionWidget, slotActivateEditFillGradient(), slotActivateEditFillMeshGradient(), slotActivateEditStrokeGradient(), and slotResetMeshGradientState().

createStrategy()

KoInteractionStrategy * DefaultTool::createStrategy ( KoPointerEvent * event )

overrideprotectedvirtual

Implements KoInteractionTool.

Definition at line 1985 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (!selection) return nullptr;
 
    bool insideSelection = false;
    KoFlake::SelectionHandle handle = handleAt(event->point, &insideSelection);
 
    bool editableShape = !selection->selectedEditableShapes().isEmpty();
 
    const bool selectMultiple = event->modifiers() & Qt::ShiftModifier;
    const bool selectNextInStack = event->modifiers() & Qt::ControlModifier;
    const bool avoidSelection = event->modifiers() & Qt::AltModifier;
 
    if (selectNextInStack) {
        // change the hot selection position when middle clicking on a handle
        KoFlake::AnchorPosition newHotPosition = m_hotPosition;
        switch (handle) {
        case KoFlake::TopMiddleHandle:
            newHotPosition = KoFlake::Top;
            break;
        case KoFlake::TopRightHandle:
            newHotPosition = KoFlake::TopRight;
            break;
        case KoFlake::RightMiddleHandle:
            newHotPosition = KoFlake::Right;
            break;
        case KoFlake::BottomRightHandle:
            newHotPosition = KoFlake::BottomRight;
            break;
        case KoFlake::BottomMiddleHandle:
            newHotPosition = KoFlake::Bottom;
            break;
        case KoFlake::BottomLeftHandle:
            newHotPosition = KoFlake::BottomLeft;
            break;
        case KoFlake::LeftMiddleHandle:
            newHotPosition = KoFlake::Left;
            break;
        case KoFlake::TopLeftHandle:
            newHotPosition = KoFlake::TopLeft;
            break;
        case KoFlake::NoHandle:
        default:
            // check if we had hit the center point
            const KoViewConverter *converter = canvas()->viewConverter();
            QPointF pt = converter->documentToView(event->point);
 
            // TODO: use calculated values instead!
            QPointF centerPt = converter->documentToView(selection->absolutePosition());
 
            if (kisSquareDistance(pt, centerPt) < HANDLE_DISTANCE_SQ) {
                newHotPosition = KoFlake::Center;
            }
 
            break;
        }
 
        if (m_hotPosition != newHotPosition) {
            canvas()->resourceManager()->setResource(HotPosition, newHotPosition);
            return new NopInteractionStrategy(this);
        }
    }
 
    if (!avoidSelection && editableShape) {
        // manipulation of selected shapes goes first
        if (handle != KoFlake::NoHandle) {
            // resizing or shearing only with left mouse button
            if (insideSelection) {
                bool forceUniformScaling = m_tabbedOptionWidget && m_tabbedOptionWidget->useUniformScaling();
                return new ShapeResizeStrategy(this, selection, event->point, handle, forceUniformScaling);
            }
 
            if (handle == KoFlake::TopMiddleHandle || handle == KoFlake::RightMiddleHandle ||
                handle == KoFlake::BottomMiddleHandle || handle == KoFlake::LeftMiddleHandle) {
 
                return new ShapeShearStrategy(this, selection, event->point, handle);
            }
 
            // rotating is allowed for right mouse button too
            if (handle == KoFlake::TopLeftHandle || handle == KoFlake::TopRightHandle ||
                    handle == KoFlake::BottomLeftHandle || handle == KoFlake::BottomRightHandle) {
 
                return new ShapeRotateStrategy(this, selection, event->point, event->buttons());
            }
        }
 
        if (!selectMultiple && !selectNextInStack) {
 
           if (insideSelection) {
                return new ShapeMoveStrategy(this, selection, event->point);
            }
        }
    }
 
    KoShape *shape = shapeManager()->shapeAt(event->point, selectNextInStack ? KoFlake::NextUnselected : KoFlake::ShapeOnTop);
 
    if (avoidSelection || (!shape && handle == KoFlake::NoHandle)) {
        if (!selectMultiple) {
            selection->deselectAll();
        }
        return new SelectionInteractionStrategy(this, event->point, false);
    }
 
    if (selection->isSelected(shape)) {
        if (selectMultiple) {
            selection->deselect(shape);
        }
    } else if (handle == KoFlake::NoHandle) { // clicked on shape which is not selected
        if (!selectMultiple) {
            selection->deselectAll();
        }
        selection->select(shape);
        // tablet selection isn't precise and may lead to a move, preventing that
        if (event->isTabletEvent()) {
            return new NopInteractionStrategy(this);
        }
        return new ShapeMoveStrategy(this, selection, event->point);
    }
    return 0;
}

References KoFlake::Bottom, KoFlake::BottomLeft, KoFlake::BottomLeftHandle, KoFlake::BottomMiddleHandle, KoFlake::BottomRight, KoFlake::BottomRightHandle, KoPointerEvent::buttons(), KoToolBase::canvas(), KoFlake::Center, KoViewConverter::documentToView(), HANDLE_DISTANCE_SQ, handleAt(), HotPosition, KoPointerEvent::isTabletEvent(), kisSquareDistance(), koSelection(), KoFlake::Left, KoFlake::LeftMiddleHandle, m_hotPosition, m_tabbedOptionWidget, KoFlake::NextUnselected, KoFlake::NoHandle, KoPointerEvent::point, KoCanvasBase::resourceManager, KoFlake::Right, KoFlake::RightMiddleHandle, selection(), SelectionInteractionStrategy, KoShapeManager::shapeAt(), shapeManager(), KoFlake::ShapeOnTop, KoFlake::Top, KoFlake::TopLeft, KoFlake::TopLeftHandle, KoFlake::TopMiddleHandle, KoFlake::TopRight, KoFlake::TopRightHandle, DefaultToolTabbedWidget::useUniformScaling(), and KoCanvasBase::viewConverter().

deactivate

void DefaultTool::deactivate ( )

overrideslot

Definition at line 1540 of file DefaultTool.cpp.

{
    KoToolBase::deactivate();
 
    QAction *actionBringToFront = action("object_order_front");
    disconnect(actionBringToFront, 0, this, 0);
 
    QAction *actionRaise = action("object_order_raise");
    disconnect(actionRaise, 0, this, 0);
 
    QAction *actionLower = action("object_order_lower");
    disconnect(actionLower, 0, this, 0);
 
    QAction *actionSendToBack = action("object_order_back");
    disconnect(actionSendToBack, 0, this, 0);
 
    QAction *actionGroupBottom = action("object_group");
    disconnect(actionGroupBottom, 0, this, 0);
 
    QAction *actionUngroupBottom = action("object_ungroup");
    disconnect(actionUngroupBottom, 0, this, 0);
 
    QAction *actionSplit = action("object_split");
    disconnect(actionSplit, 0, this, 0);
 
    disconnect(m_alignSignalsMapper, 0, this, 0);
    disconnect(m_distributeSignalsMapper, 0, this, 0);
    disconnect(m_transformSignalsMapper, 0, this, 0);
    disconnect(m_booleanSignalsMapper, 0, this, 0);
    disconnect(m_textTypeSignalsMapper, 0, this, 0);
    disconnect(m_textFlowSignalsMapper, 0, this, 0);
 
    QAction *actionTextInside = action("add_shape_to_flow_area");
    disconnect(actionTextInside, 0, this, 0);
    QAction *actionTextSubtract = action("subtract_shape_from_flow_area");
    disconnect(actionTextSubtract, 0, this, 0);
    QAction *actionTextOnPath = action("put_text_on_path");
    disconnect(actionTextOnPath, 0, this, 0);
    QAction *actionTextRemoveFlow = action("remove_shapes_from_text_flow");
    disconnect(actionTextRemoveFlow, 0, this, 0);
    QAction *actionTextFlowToggle = action("flow_shape_type_toggle");
    disconnect(actionTextFlowToggle, 0, this, 0);
 
    const KisCanvas2 *canvas2 = qobject_cast<const KisCanvas2 *>(this->canvas());
    if (canvas2) {
        canvas2->viewManager()->textPropertyManager()->setTextPropertiesInterface(nullptr);
        m_textPropertyInterface->clearSelection();
    }
 
    if (m_tabbedOptionWidget) {
        m_tabbedOptionWidget->deactivate();
    }
}

References KoToolBase::action(), KoToolBase::canvas(), DefaultToolTextPropertiesInterface::clearSelection(), KoToolBase::deactivate(), DefaultToolTabbedWidget::deactivate(), m_alignSignalsMapper, m_booleanSignalsMapper, m_distributeSignalsMapper, m_tabbedOptionWidget, m_textFlowSignalsMapper, m_textPropertyInterface, m_textTypeSignalsMapper, m_transformSignalsMapper, KisTextPropertiesManager::setTextPropertiesInterface(), KisViewManager::textPropertyManager(), and KisCanvas2::viewManager().

decorationsRect()

QRectF DefaultTool::decorationsRect ( ) const

overridevirtual

TODO: avoid cons_cast by implementing proper caching strategy inrecalcSelectionBox() and handlesSize()

Reimplemented from KoToolBase.

Definition at line 1309 of file DefaultTool.cpp.

{
    QRectF dirtyRect;
 
    if (koSelection() && koSelection()->count() > 0) {
        dirtyRect = const_cast<DefaultTool*>(this)->handlesSize();
    }
 
    if (canvas()->snapGuide()->isSnapping()) {
        dirtyRect |= canvas()->snapGuide()->boundingRect();
    }
    dirtyRect |= m_textOutlineHelper->decorationRect();
 
    return dirtyRect;
}

References KoSnapGuide::boundingRect(), KoToolBase::canvas(), handlesSize(), KoSnapGuide::isSnapping(), koSelection(), m_textOutlineHelper, and KoCanvasBase::snapGuide.

deleteSelection()

void DefaultTool::deleteSelection ( )

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Reimplemented in ToolReferenceImages.

Definition at line 1340 of file DefaultTool.cpp.

{
    QList<KoShape *> shapes;
    foreach (KoShape *s, koSelection()->selectedShapes()) {
        if (s->isGeometryProtected()) {
            continue;
        }
        shapes << s;
    }
    if (!shapes.empty()) {
        canvas()->addCommand(canvas()->shapeController()->removeShapes(shapes));
    }
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KoShape::isGeometryProtected(), and koSelection().

deselect()

void DefaultTool::deselect ( )

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 1373 of file DefaultTool.cpp.

{
    Q_ASSERT(canvas());
    Q_ASSERT(canvas()->selectedShapesProxy());
    canvas()->selectedShapesProxy()->selection()->deselectAll();
    repaintDecorations();
}

References KoToolBase::canvas(), KoSelection::deselectAll(), KoToolBase::repaintDecorations(), KoCanvasBase::selectedShapesProxy(), and KoSelectedShapesProxy::selection().

explicitUserStrokeEndRequest()

void DefaultTool::explicitUserStrokeEndRequest ( )

overridevirtual

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.

Reimplemented from KoToolBase.

Definition at line 2346 of file DefaultTool.cpp.

{
    QList<KoShape *> shapes = koSelection()->selectedEditableShapesAndDelegates();
    QString tool = KoToolManager::instance()->preferredToolForSelection(shapes);
    QTimer::singleShot(0, [tool = std::move(tool)]() {
        KoToolManager::instance()->switchToolRequested(tool);
    });
}

References KoToolManager::instance(), koSelection(), KoToolManager::preferredToolForSelection(), KoSelection::selectedEditableShapesAndDelegates(), and KoToolManager::switchToolRequested().

handleAt()

KoFlake::SelectionHandle DefaultTool::handleAt	(	const QPointF &	point,
		bool *	innerHandleMeaning = 0 )

Returns which selection handle is at params point (or NoHandle if none).

Returns

which selection handle is at params point (or NoHandle if none).

Parameters

point	the location (in pt) where we should look for a handle
innerHandleMeaning	this boolean is altered to true if the point is inside the selection rectangle and false if it is just outside. The value of innerHandleMeaning is undefined if the handle location is NoHandle

Definition at line 1388 of file DefaultTool.cpp.

{
    // check for handles in this order; meaning that when handles overlap the one on top is chosen
    static const KoFlake::SelectionHandle handleOrder[] = {
        KoFlake::BottomRightHandle,
        KoFlake::TopLeftHandle,
        KoFlake::BottomLeftHandle,
        KoFlake::TopRightHandle,
        KoFlake::BottomMiddleHandle,
        KoFlake::RightMiddleHandle,
        KoFlake::LeftMiddleHandle,
        KoFlake::TopMiddleHandle,
        KoFlake::NoHandle
    };
 
    const KoViewConverter *converter = canvas()->viewConverter();
    KoSelection *selection = koSelection();
 
    if (!selection || !selection->count() || !converter) {
        return KoFlake::NoHandle;
    }
 
    recalcSelectionBox(selection);
 
    if (innerHandleMeaning) {
        QPainterPath path;
        path.addPolygon(m_selectionOutline);
        *innerHandleMeaning = path.contains(point) || path.intersects(handlePaintRect(point));
    }
 
    const QPointF viewPoint = converter->documentToView(point);
 
    for (int i = 0; i < KoFlake::NoHandle; ++i) {
        KoFlake::SelectionHandle handle = handleOrder[i];
 
        const QPointF handlePoint = converter->documentToView(m_selectionBox[handle]);
        const qreal distanceSq = kisSquareDistance(viewPoint, handlePoint);
 
        // if just inside the outline
        if (distanceSq < HANDLE_DISTANCE_SQ) {
 
            if (innerHandleMeaning) {
                if (distanceSq < INNER_HANDLE_DISTANCE_SQ) {
                    *innerHandleMeaning = true;
                }
            }
 
            return handle;
        }
    }
    return KoFlake::NoHandle;
}

References KoFlake::BottomLeftHandle, KoFlake::BottomMiddleHandle, KoFlake::BottomRightHandle, KoToolBase::canvas(), KoViewConverter::documentToView(), HANDLE_DISTANCE_SQ, KoToolBase::handlePaintRect(), INNER_HANDLE_DISTANCE_SQ, kisSquareDistance(), koSelection(), KoFlake::LeftMiddleHandle, m_selectionBox, m_selectionOutline, KoFlake::NoHandle, recalcSelectionBox(), KoFlake::RightMiddleHandle, selection(), KoFlake::TopLeftHandle, KoFlake::TopMiddleHandle, KoFlake::TopRightHandle, and KoCanvasBase::viewConverter().

handlesSize()

QRectF DefaultTool::handlesSize ( )

private

Returns selection rectangle adjusted by handle proximity threshold.

Definition at line 1212 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (!selection || !selection->count()) return QRectF();
 
    recalcSelectionBox(selection);
 
    QRectF bound = m_selectionOutline.boundingRect();
 
    // expansion Border
    if (!canvas() || !canvas()->viewConverter()) {
        return bound;
    }
 
    QPointF border = canvas()->viewConverter()->viewToDocument(QPointF(HANDLE_DISTANCE, HANDLE_DISTANCE));
    bound.adjust(-border.x(), -border.y(), border.x(), border.y());
    return bound;
}

References KoToolBase::canvas(), HANDLE_DISTANCE, koSelection(), m_selectionOutline, recalcSelectionBox(), selection(), KoCanvasBase::viewConverter(), and KoViewConverter::viewToDocument().

isValidForCurrentLayer()

bool DefaultTool::isValidForCurrentLayer ( ) const

protectedvirtual

Reimplemented in ToolReferenceImages.

Definition at line 1149 of file DefaultTool.cpp.

{
    // if the currently active node has a shape manager, then it is
    // probably our client :)
 
    KisCanvas2 *kisCanvas = static_cast<KisCanvas2 *>(canvas());
    return bool(kisCanvas->localShapeManager());
}

References KoToolBase::canvas(), and KisCanvas2::localShapeManager().

keyPressEvent()

void DefaultTool::keyPressEvent ( QKeyEvent * event )

overridevirtual

Called when a key is pressed. Implementors should call event->ignore() if they do not actually use the event. Default implementation ignores this event.

Parameters

event

state and reason of this key press

Reimplemented from KoToolBase.

Definition at line 1290 of file DefaultTool.cpp.

{
    KoInteractionTool::keyPressEvent(event);
    if (currentStrategy() == 0) {
        switch (event->key()) {
        case Qt::Key_Left:
        case Qt::Key_Right:
        case Qt::Key_Up:
        case Qt::Key_Down:
            if (moveSelection(event->key(), event->modifiers())) {
                event->accept();
            }
            break;
        default:
            return;
        }
    }
}

References KoInteractionTool::currentStrategy(), KoInteractionTool::keyPressEvent(), and moveSelection().

koSelection()

KoSelection * DefaultTool::koSelection ( ) const

protectedvirtual

Reimplemented in ToolReferenceImages.

Definition at line 1381 of file DefaultTool.cpp.

{
    Q_ASSERT(canvas());
    Q_ASSERT(canvas()->selectedShapesProxy());
    return canvas()->selectedShapesProxy()->selection();
}

References KoToolBase::canvas(), KoCanvasBase::selectedShapesProxy(), and KoSelectedShapesProxy::selection().

meshgradientHandleSelected

void DefaultTool::meshgradientHandleSelected ( KoShapeMeshGradientHandles::Handle )

signal

mouseDoubleClickEvent()

void DefaultTool::mouseDoubleClickEvent ( KoPointerEvent * event )

overridevirtual

Called when (one of) the mouse or stylus buttons is double clicked. Implementors should call event->ignore() if they do not actually use the event. Default implementation ignores this event.

Parameters

event

state and reason of this mouse or stylus press

Reimplemented from KoToolBase.

Reimplemented in ToolReferenceImages.

Definition at line 1237 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
 
    KoShape *shape = shapeManager()->shapeAt(event->point, KoFlake::ShapeOnTop);
    if (shape && selection && !selection->isSelected(shape)) {
 
        if (!(event->modifiers() & Qt::ShiftModifier)) {
            selection->deselectAll();
        }
 
        selection->select(shape);
    }
 
    explicitUserStrokeEndRequest();
}

References explicitUserStrokeEndRequest(), koSelection(), KoPointerEvent::modifiers(), KoPointerEvent::point, selection(), KoShapeManager::shapeAt(), shapeManager(), and KoFlake::ShapeOnTop.

mouseMoveEvent()

void DefaultTool::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

Implements KoToolBase.

Definition at line 1184 of file DefaultTool.cpp.

{
    KoInteractionTool::mouseMoveEvent(event);
    if (currentStrategy() == 0 && koSelection() && koSelection()->count() > 0) {
        QRectF bound = handlesSize();
 
        if (bound.contains(event->point)) {
            bool inside;
            KoFlake::SelectionHandle newDirection = handleAt(event->point, &inside);
 
            if (inside != m_mouseWasInsideHandles || m_lastHandle != newDirection) {
                m_lastHandle = newDirection;
                m_mouseWasInsideHandles = inside;
            }
        } else {
            m_lastHandle = KoFlake::NoHandle;
            m_mouseWasInsideHandles = false;
 
            // there used to be guides... :'''(
        }
    } else {
        // there used to be guides... :'''(
    }
 
 
    updateCursor();
}

References KoInteractionTool::currentStrategy(), handleAt(), handlesSize(), koSelection(), m_lastHandle, m_mouseWasInsideHandles, KoInteractionTool::mouseMoveEvent(), KoFlake::NoHandle, KoPointerEvent::point, and updateCursor().

mousePressEvent()

void DefaultTool::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

Implements KoToolBase.

Definition at line 1162 of file DefaultTool.cpp.

{
    // this tool only works on a vector layer right now, so give a warning if another layer type is trying to use it
    if (!isValidForCurrentLayer()) {
        KisCanvas2 *kiscanvas = static_cast<KisCanvas2 *>(canvas());
        kiscanvas->viewManager()->showFloatingMessage(
                i18n("This tool only works on vector layers. You probably want the move tool."),
                QIcon(), 2000, KisFloatingMessage::Medium, Qt::AlignCenter);
        return;
    }
 
    if (KoSvgTextShape *shape = m_textOutlineHelper->contourModeButtonHovered(event->point)) {
        m_textOutlineHelper->toggleTextContourMode(shape);
        updateActions();
        event->accept();
        updateCursor();
        return;
    }
    KoInteractionTool::mousePressEvent(event);
    updateCursor();
}

References KoToolBase::canvas(), isValidForCurrentLayer(), m_textOutlineHelper, KisFloatingMessage::Medium, KoInteractionTool::mousePressEvent(), KoPointerEvent::point, KisViewManager::showFloatingMessage(), updateActions(), updateCursor(), and KisCanvas2::viewManager().

mouseReleaseEvent()

void DefaultTool::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

Implements KoToolBase.

Definition at line 1231 of file DefaultTool.cpp.

{
    KoInteractionTool::mouseReleaseEvent(event);
    updateCursor();
}

References KoInteractionTool::mouseReleaseEvent(), and updateCursor().

moveSelection()

bool DefaultTool::moveSelection ( int direction, Qt::KeyboardModifiers modifiers )

private

Definition at line 1254 of file DefaultTool.cpp.

{
    bool result = false;
 
    qreal x = 0.0, y = 0.0;
    if (direction == Qt::Key_Left) {
        x = -5;
    } else if (direction == Qt::Key_Right) {
        x = 5;
    } else if (direction == Qt::Key_Up) {
        y = -5;
    } else if (direction == Qt::Key_Down) {
        y = 5;
    }
 
    if (x != 0.0 || y != 0.0) { // actually move
 
        if ((modifiers & Qt::ShiftModifier) != 0) {
            x *= 10;
            y *= 10;
        } else if ((modifiers & Qt::AltModifier) != 0) { // more precise
            x /= 5;
            y /= 5;
        }
 
        QList<KoShape *> shapes = koSelection()->selectedEditableShapes();
 
        if (!shapes.isEmpty()) {
            canvas()->addCommand(new KoShapeMoveCommand(shapes, QPointF(x, y)));
            result = true;
        }
    }
 
    return result;
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), koSelection(), and KoSelection::selectedEditableShapes().

paint()

void DefaultTool::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.

Selection masks don't render the outline of the shapes, so we should do that explicitly when rendering them via selection

Implements KoToolBase.

Definition at line 1107 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (selection) {
        m_decorator.reset(new SelectionDecorator(canvas()->resourceManager()));
 
        {
            KisCanvas2 *kisCanvas = static_cast<KisCanvas2 *>(canvas());
            KisNodeSP node = kisCanvas->viewManager()->nodeManager()->activeNode();
            const bool isSelectionMask = node && node->inherits("KisSelectionMask");
            m_decorator->setForceShapeOutlines(isSelectionMask);
 
 
        }
 
        m_decorator->setSelection(selection);
        m_decorator->setHandleRadius(handleRadius());
        m_decorator->setDecorationThickness(decorationThickness());
        m_decorator->setShowFillGradientHandles(hasInteractionFactory(EditFillGradientFactoryId));
        m_decorator->setShowStrokeFillGradientHandles(hasInteractionFactory(EditStrokeGradientFactoryId));
        m_decorator->setShowFillMeshGradientHandles(hasInteractionFactory(EditFillMeshGradientFactoryId));
        m_decorator->setCurrentMeshGradientHandles(m_selectedMeshHandle, m_hoveredMeshHandle);
        m_decorator->paint(painter, converter);
    }
 
    m_textOutlineHelper->setHandleRadius(handleRadius());
    m_textOutlineHelper->setDecorationThickness(decorationThickness());
    m_textOutlineHelper->paint(&painter, converter);
 
    KoInteractionTool::paint(painter, converter);
 
    painter.save();
    painter.setTransform(converter.documentToView(), true);
    canvas()->snapGuide()->paint(painter, converter);
    painter.restore();
}

References KisNodeManager::activeNode(), KoToolBase::canvas(), KoToolBase::decorationThickness(), KoViewConverter::documentToView(), KoToolBase::handleRadius(), KoInteractionTool::hasInteractionFactory(), isSelectionMask(), koSelection(), m_decorator, m_hoveredMeshHandle, m_selectedMeshHandle, m_textOutlineHelper, KisViewManager::nodeManager(), KoSnapGuide::paint(), KoInteractionTool::paint(), selection(), KoCanvasBase::snapGuide, and KisCanvas2::viewManager().

paste()

bool DefaultTool::paste ( )

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 1354 of file DefaultTool.cpp.

{
    // we no longer have to do anything as tool Proxy will do it for us
    return false;
}

popupActionsMenu()

QMenu * DefaultTool::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.

Reimplemented in ToolReferenceImages.

Definition at line 2260 of file DefaultTool.cpp.

{
    if (m_contextMenu) {
        m_contextMenu->clear();
 
        m_contextMenu->addSection(i18n("Vector Shape Actions"));
        m_contextMenu->addSeparator();
 
        QMenu *transform = m_contextMenu->addMenu(i18n("Transform"));
 
        transform->addAction(action("object_transform_rotate_90_cw"));
        transform->addAction(action("object_transform_rotate_90_ccw"));
        transform->addAction(action("object_transform_rotate_180"));
        transform->addSeparator();
        transform->addAction(action("object_transform_mirror_horizontally"));
        transform->addAction(action("object_transform_mirror_vertically"));
        transform->addSeparator();
        transform->addAction(action("object_transform_reset"));
 
        if (action("object_unite")->isEnabled() ||
            action("object_intersect")->isEnabled() ||
            action("object_subtract")->isEnabled() ||
            action("object_split")->isEnabled()) {
 
            QMenu *transform = m_contextMenu->addMenu(i18n("Logical Operations"));
            transform->addAction(action("object_unite"));
            transform->addAction(action("object_intersect"));
            transform->addAction(action("object_subtract"));
            transform->addAction(action("object_split"));
        }
 
        m_contextMenu->addSeparator();
 
        m_contextMenu->addAction(action("edit_cut"));
        m_contextMenu->addAction(action("edit_copy"));
        m_contextMenu->addAction(action("edit_paste"));
        m_contextMenu->addAction(action("paste_at"));
 
        m_contextMenu->addSeparator();
 
        m_contextMenu->addAction(action("object_order_front"));
        m_contextMenu->addAction(action("object_order_raise"));
        m_contextMenu->addAction(action("object_order_lower"));
        m_contextMenu->addAction(action("object_order_back"));
 
        if (action("object_group")->isEnabled() || action("object_ungroup")->isEnabled()) {
            m_contextMenu->addSeparator();
            m_contextMenu->addAction(action("object_group"));
            m_contextMenu->addAction(action("object_ungroup"));
        }
        m_contextMenu->addSeparator();
        m_contextMenu->addAction(action("convert_shapes_to_vector_selection"));
 
        m_contextMenu->addSeparator();
        QMenu *text = m_contextMenu->addMenu(i18n("Text"));
        text->addAction(action("add_shape_to_flow_area"));
        text->addAction(action("subtract_shape_from_flow_area"));
        text->addAction(action("put_text_on_path"));
        text->addSeparator();
        text->addAction(action("text_type_preformatted"));
        text->addAction(action("text_type_inline_wrap"));
        text->addAction(action("text_type_pre_positioned"));
        text->addSeparator();
        text->addAction(action("remove_shapes_from_text_flow"));
        text->addAction(action("flow_shape_type_toggle"));
        text->addSeparator();
        text->addAction(action("flow_shape_order_back"));
        text->addAction(action("flow_shape_order_earlier"));
        text->addAction(action("flow_shape_order_later"));
        text->addAction(action("flow_shape_order_front"));
    }
 
    return m_contextMenu.data();
}

References KoToolBase::action(), and m_contextMenu.

recalcSelectionBox()

void DefaultTool::recalcSelectionBox ( KoSelection * selection )

private

Definition at line 1441 of file DefaultTool.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(selection->count());
 
    QTransform matrix = selection->absoluteTransformation();
    m_selectionOutline = matrix.map(QPolygonF(selection->outlineRect()));
    m_angle = 0.0;
 
    QPolygonF outline = m_selectionOutline; //shorter name in the following :)
    m_selectionBox[KoFlake::TopMiddleHandle] = (outline.value(0) + outline.value(1)) / 2;
    m_selectionBox[KoFlake::TopRightHandle] = outline.value(1);
    m_selectionBox[KoFlake::RightMiddleHandle] = (outline.value(1) + outline.value(2)) / 2;
    m_selectionBox[KoFlake::BottomRightHandle] = outline.value(2);
    m_selectionBox[KoFlake::BottomMiddleHandle] = (outline.value(2) + outline.value(3)) / 2;
    m_selectionBox[KoFlake::BottomLeftHandle] = outline.value(3);
    m_selectionBox[KoFlake::LeftMiddleHandle] = (outline.value(3) + outline.value(0)) / 2;
    m_selectionBox[KoFlake::TopLeftHandle] = outline.value(0);
    if (selection->count() == 1) {
#if 0        // TODO detect mirroring
        KoShape *s = koSelection()->firstSelectedShape();
 
        if (s->scaleX() < 0) { // vertically mirrored: swap left / right
            std::swap(m_selectionBox[KoFlake::TopLeftHandle], m_selectionBox[KoFlake::TopRightHandle]);
            std::swap(m_selectionBox[KoFlake::LeftMiddleHandle], m_selectionBox[KoFlake::RightMiddleHandle]);
            std::swap(m_selectionBox[KoFlake::BottomLeftHandle], m_selectionBox[KoFlake::BottomRightHandle]);
        }
        if (s->scaleY() < 0) { // vertically mirrored: swap top / bottom
            std::swap(m_selectionBox[KoFlake::TopLeftHandle], m_selectionBox[KoFlake::BottomLeftHandle]);
            std::swap(m_selectionBox[KoFlake::TopMiddleHandle], m_selectionBox[KoFlake::BottomMiddleHandle]);
            std::swap(m_selectionBox[KoFlake::TopRightHandle], m_selectionBox[KoFlake::BottomRightHandle]);
        }
#endif
    }
}

References KoFlake::BottomLeftHandle, KoFlake::BottomMiddleHandle, KoFlake::BottomRightHandle, KoSelection::firstSelectedShape(), KIS_ASSERT_RECOVER_RETURN, koSelection(), KoFlake::LeftMiddleHandle, m_angle, m_selectionBox, m_selectionOutline, KoFlake::RightMiddleHandle, selection(), KoFlake::TopLeftHandle, KoFlake::TopMiddleHandle, and KoFlake::TopRightHandle.

rotationOfHandle()

qreal DefaultTool::rotationOfHandle ( KoFlake::SelectionHandle handle, bool useEdgeRotation )

private

Returns rotation angle of given handle of the current selection.

Definition at line 870 of file DefaultTool.cpp.

{
    QPointF selectionCenter = koSelection()->absolutePosition();
    QPointF direction;
 
    switch (handle) {
    case KoFlake::TopMiddleHandle:
        if (useEdgeRotation) {
            direction = koSelection()->absolutePosition(KoFlake::TopRight)
                        - koSelection()->absolutePosition(KoFlake::TopLeft);
        } else {
            QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopLeft);
            handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::TopRight) - handlePosition);
            direction = handlePosition - selectionCenter;
        }
        break;
    case KoFlake::TopRightHandle:
        direction = (QVector2D(koSelection()->absolutePosition(KoFlake::TopRight) - koSelection()->absolutePosition(KoFlake::TopLeft)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::TopRight) - koSelection()->absolutePosition(KoFlake::BottomRight)).normalized()).toPointF();
        break;
    case KoFlake::RightMiddleHandle:
        if (useEdgeRotation) {
            direction = koSelection()->absolutePosition(KoFlake::BottomRight)
                        - koSelection()->absolutePosition(KoFlake::TopRight);
        } else {
            QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopRight);
            handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomRight) - handlePosition);
            direction = handlePosition - selectionCenter;
        }
        break;
    case KoFlake::BottomRightHandle:
        direction = (QVector2D(koSelection()->absolutePosition(KoFlake::BottomRight) - koSelection()->absolutePosition(KoFlake::BottomLeft)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::BottomRight) - koSelection()->absolutePosition(KoFlake::TopRight)).normalized()).toPointF();
        break;
    case KoFlake::BottomMiddleHandle:
        if (useEdgeRotation) {
            direction = koSelection()->absolutePosition(KoFlake::BottomLeft)
                        - koSelection()->absolutePosition(KoFlake::BottomRight);
        } else {
            QPointF handlePosition = koSelection()->absolutePosition(KoFlake::BottomLeft);
            handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomRight) - handlePosition);
            direction = handlePosition - selectionCenter;
        }
        break;
    case KoFlake::BottomLeftHandle:
        direction = koSelection()->absolutePosition(KoFlake::BottomLeft) - selectionCenter;
        direction = (QVector2D(koSelection()->absolutePosition(KoFlake::BottomLeft) - koSelection()->absolutePosition(KoFlake::BottomRight)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::BottomLeft) - koSelection()->absolutePosition(KoFlake::TopLeft)).normalized()).toPointF();
        break;
    case KoFlake::LeftMiddleHandle:
        if (useEdgeRotation) {
            direction = koSelection()->absolutePosition(KoFlake::TopLeft)
                        - koSelection()->absolutePosition(KoFlake::BottomLeft);
        } else {
            QPointF handlePosition = koSelection()->absolutePosition(KoFlake::TopLeft);
            handlePosition += 0.5 * (koSelection()->absolutePosition(KoFlake::BottomLeft) - handlePosition);
            direction = handlePosition - selectionCenter;
        }
        break;
    case KoFlake::TopLeftHandle:
        direction = koSelection()->absolutePosition(KoFlake::TopLeft) - selectionCenter;
        direction = (QVector2D(koSelection()->absolutePosition(KoFlake::TopLeft) - koSelection()->absolutePosition(KoFlake::TopRight)).normalized() + QVector2D(koSelection()->absolutePosition(KoFlake::TopLeft) - koSelection()->absolutePosition(KoFlake::BottomLeft)).normalized()).toPointF();
        break;
    case KoFlake::NoHandle:
        return 0.0;
        break;
    }
 
    qreal rotation = atan2(direction.y(), direction.x()) * 180.0 / M_PI;
 
    switch (handle) {
    case KoFlake::TopMiddleHandle:
        if (useEdgeRotation) {
            rotation -= 0.0;
        } else {
            rotation -= 270.0;
        }
        break;
    case KoFlake::TopRightHandle:
        rotation -= 315.0;
        break;
    case KoFlake::RightMiddleHandle:
        if (useEdgeRotation) {
            rotation -= 90.0;
        } else {
            rotation -= 0.0;
        }
        break;
    case KoFlake::BottomRightHandle:
        rotation -= 45.0;
        break;
    case KoFlake::BottomMiddleHandle:
        if (useEdgeRotation) {
            rotation -= 180.0;
        } else {
            rotation -= 90.0;
        }
        break;
    case KoFlake::BottomLeftHandle:
        rotation -= 135.0;
        break;
    case KoFlake::LeftMiddleHandle:
        if (useEdgeRotation) {
            rotation -= 270.0;
        } else {
            rotation -= 180.0;
        }
        break;
    case KoFlake::TopLeftHandle:
        rotation -= 225.0;
        break;
    default:
        ;
    }
 
    if (rotation < 0.0) {
        rotation += 360.0;
    }
 
    return rotation;
}

References KoShape::absolutePosition(), KoFlake::BottomLeft, KoFlake::BottomLeftHandle, KoFlake::BottomMiddleHandle, KoFlake::BottomRight, KoFlake::BottomRightHandle, koSelection(), KoFlake::LeftMiddleHandle, M_PI, KoFlake::NoHandle, KoFlake::RightMiddleHandle, KoFlake::TopLeft, KoFlake::TopLeftHandle, KoFlake::TopMiddleHandle, KoFlake::TopRight, and KoFlake::TopRightHandle.

selectAll()

bool DefaultTool::selectAll ( )

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 1360 of file DefaultTool.cpp.

{
    Q_ASSERT(canvas());
    Q_ASSERT(canvas()->selectedShapesProxy());
    Q_FOREACH(KoShape *shape, canvas()->shapeManager()->shapes()) {
        if (!shape->isSelectable()) continue;
        canvas()->selectedShapesProxy()->selection()->select(shape);
    }
    repaintDecorations();
 
    return true;
}

References KoToolBase::canvas(), KoShape::isSelectable(), KoToolBase::repaintDecorations(), KoSelection::select(), KoCanvasBase::selectedShapesProxy(), KoSelectedShapesProxy::selection(), and shapeManager().

selection()

KoToolSelection * DefaultTool::selection ( )

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 2255 of file DefaultTool.cpp.

{
    return m_selectionHandler;
}

References m_selectionHandler.

selectionAlign

void DefaultTool::selectionAlign ( int _align )

privateslot

Definition at line 1858 of file DefaultTool.cpp.

{
    KoShapeAlignCommand::Align align =
        static_cast<KoShapeAlignCommand::Align>(_align);
 
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> editableShapes = selection->selectedEditableShapes();
    if (editableShapes.isEmpty()) {
        return;
    }
 
    // TODO add an option to the widget so that one can align to the page
    // with multiple selected shapes too
 
    QRectF bb;
 
    // single selected shape is automatically aligned to document rect
    if (editableShapes.count() == 1) {
        if (!canvas()->resourceManager()->hasResource(KoCanvasResource::PageSize)) {
            return;
        }
        bb = QRectF(QPointF(0, 0), canvas()->resourceManager()->sizeResource(KoCanvasResource::PageSize));
    } else {
        bb = KoShape::absoluteOutlineRect(editableShapes);
    }
 
    KoShapeAlignCommand *cmd = new KoShapeAlignCommand(editableShapes, align, bb);
    canvas()->addCommand(cmd);
}

References KoShape::absoluteOutlineRect(), KoCanvasBase::addCommand(), KoToolBase::canvas(), koSelection(), KoCanvasResource::PageSize, and selection().

selectionBooleanOp

void DefaultTool::selectionBooleanOp ( int booleanOp )

privateslot

Definition at line 1730 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> editableShapes = selection->selectedEditableShapes();
    if (editableShapes.isEmpty()) {
        return;
    }
 
    QVector<QPainterPath> srcOutlines;
    QPainterPath dstOutline;
    KUndo2MagicString actionName = kundo2_noi18n("BUG: boolean action name");
 
    // TODO: implement a reference shape selection dialog!
    const int referenceShapeIndex = 0;
    KoShape *referenceShape = editableShapes[referenceShapeIndex];
 
    KisCanvas2 *kisCanvas = static_cast<KisCanvas2 *>(canvas());
    KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
    const QTransform booleanWorkaroundTransform =
        KritaUtils::pathShapeBooleanSpaceWorkaround(kisCanvas->image());
 
    Q_FOREACH (KoShape *shape, editableShapes) {
        srcOutlines <<
            booleanWorkaroundTransform.map(
            shape->absoluteTransformation().map(
                shape->outline()));
    }
 
    if (booleanOp == BooleanUnion) {
        Q_FOREACH (const QPainterPath &path, srcOutlines) {
            dstOutline |= path;
        }
        actionName = kundo2_i18n("Unite Shapes");
    } else if (booleanOp == BooleanIntersection) {
        for (int i = 0; i < srcOutlines.size(); i++) {
            if (i == 0) {
                dstOutline = srcOutlines[i];
            } else {
                dstOutline &= srcOutlines[i];
            }
        }
 
        // there is a bug in Qt, sometimes it leaves the resulting
        // outline open, so just close it explicitly.
        dstOutline.closeSubpath();
 
        actionName = kundo2_i18n("Intersect Shapes");
 
    } else if (booleanOp == BooleanSubtraction) {
        for (int i = 0; i < srcOutlines.size(); i++) {
            dstOutline = srcOutlines[referenceShapeIndex];
            if (i != referenceShapeIndex) {
                dstOutline -= srcOutlines[i];
            }
        }
 
        actionName = kundo2_i18n("Subtract Shapes");
    }
 
    dstOutline = booleanWorkaroundTransform.inverted().map(dstOutline);
 
    KoShape *newShape = 0;
 
    if (!dstOutline.isEmpty()) {
        newShape = KoPathShape::createShapeFromPainterPath(dstOutline);
    }
 
    KUndo2Command *cmd = new KUndo2Command(actionName);
 
    new KoKeepShapesSelectedCommand(editableShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
 
    QList<KoShape*> newSelectedShapes;
 
    if (newShape) {
        newShape->setBackground(referenceShape->background());
        newShape->setStroke(referenceShape->stroke());
        newShape->setZIndex(referenceShape->zIndex());
 
        KoShapeContainer *parent = referenceShape->parent();
        canvas()->shapeController()->addShapeDirect(newShape, parent, cmd);
 
        newSelectedShapes << newShape;
    }
 
    canvas()->shapeController()->removeShapes(editableShapes, cmd);
 
    new KoKeepShapesSelectedCommand({}, newSelectedShapes, canvas()->selectedShapesProxy(), true, cmd);
 
    canvas()->addCommand(cmd);
}

References KoShape::absoluteTransformation(), KoCanvasBase::addCommand(), KoShape::background(), KoToolBase::canvas(), KoPathShape::createShapeFromPainterPath(), KisCanvas2::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, koSelection(), kundo2_i18n(), kundo2_noi18n(), KoShape::outline(), KoShape::parent(), KritaUtils::pathShapeBooleanSpaceWorkaround(), KoCanvasBase::selectedShapesProxy(), selection(), KoShape::setBackground(), KoShape::setStroke(), KoShape::setZIndex(), KoCanvasBase::shapeController, KoShape::stroke(), and KoShape::zIndex().

selectionBringToFront

void DefaultTool::selectionBringToFront ( )

privateslot

Definition at line 1908 of file DefaultTool.cpp.

{
    selectionReorder(KoShapeReorderCommand::BringToFront);
}

References KoShapeReorderCommand::BringToFront, and selectionReorder().

selectionDistribute

void DefaultTool::selectionDistribute ( int _distribute )

privateslot

Definition at line 1890 of file DefaultTool.cpp.

{
    KoShapeDistributeCommand::Distribute distribute =
        static_cast<KoShapeDistributeCommand::Distribute>(_distribute);
 
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> editableShapes = selection->selectedEditableShapes();
    if (editableShapes.size() < 3) {
        return;
    }
 
    QRectF bb = KoShape::absoluteOutlineRect(editableShapes);
    KoShapeDistributeCommand *cmd = new KoShapeDistributeCommand(editableShapes, distribute, bb);
    canvas()->addCommand(cmd);
}

References KoShape::absoluteOutlineRect(), KoCanvasBase::addCommand(), KoToolBase::canvas(), koSelection(), and selection().

selectionGroup

void DefaultTool::selectionGroup ( )

privateslot

Definition at line 1594 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    std::sort(selectedShapes.begin(), selectedShapes.end(), KoShape::compareShapeZIndex);
    if (selectedShapes.isEmpty()) return;
 
    const int groupZIndex = selectedShapes.last()->zIndex();
 
    KoShapeGroup *group = new KoShapeGroup();
    group->setZIndex(groupZIndex);
    // TODO what if only one shape is left?
    KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Group shapes"));
    new KoKeepShapesSelectedCommand(selectedShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
    canvas()->shapeController()->addShapeDirect(group, 0, cmd);
    new KoShapeGroupCommand(group, selectedShapes, true, cmd);
    new KoKeepShapesSelectedCommand({}, {group}, canvas()->selectedShapesProxy(), true, cmd);
    canvas()->addCommand(cmd);
 
    // update selection so we can ungroup immediately again
    selection->deselectAll();
    selection->select(group);
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KoShape::compareShapeZIndex(), koSelection(), kundo2_i18n(), KoCanvasBase::selectedShapesProxy(), selection(), KoShape::setZIndex(), and KoCanvasBase::shapeController.

selectionMoveDown

void DefaultTool::selectionMoveDown ( )

privateslot

Definition at line 1918 of file DefaultTool.cpp.

{
    selectionReorder(KoShapeReorderCommand::LowerShape);
}

References KoShapeReorderCommand::LowerShape, and selectionReorder().

selectionMoveUp

void DefaultTool::selectionMoveUp ( )

privateslot

Definition at line 1913 of file DefaultTool.cpp.

{
    selectionReorder(KoShapeReorderCommand::RaiseShape);
}

References KoShapeReorderCommand::RaiseShape, and selectionReorder().

selectionReorder()

void DefaultTool::selectionReorder ( KoShapeReorderCommand::MoveShapeType order )

private

Definition at line 1928 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (!selection) {
        return;
    }
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    if (selectedShapes.isEmpty()) {
        return;
    }
 
    KUndo2Command *cmd = KoShapeReorderCommand::createCommand(selectedShapes, shapeManager(), order);
    if (cmd) {
        canvas()->addCommand(cmd);
    }
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KoShapeReorderCommand::createCommand(), koSelection(), selection(), and shapeManager().

selectionSendToBack

void DefaultTool::selectionSendToBack ( )

privateslot

Definition at line 1923 of file DefaultTool.cpp.

{
    selectionReorder(KoShapeReorderCommand::SendToBack);
}

References selectionReorder(), and KoShapeReorderCommand::SendToBack.

selectionSplitShapes

void DefaultTool::selectionSplitShapes ( )

privateslot

Definition at line 1823 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> editableShapes = selection->selectedEditableShapes();
    if (editableShapes.isEmpty()) {
        return;
    }
 
    KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Split Shapes"));
 
    new KoKeepShapesSelectedCommand(editableShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
    QList<KoShape*> newShapes;
 
    Q_FOREACH (KoShape *shape, editableShapes) {
        KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape);
        if (!pathShape) return;
 
        QList<KoPathShape*> splitShapes;
        if (pathShape->separate(splitShapes)) {
            QList<KoShape*> normalShapes = implicitCastList<KoShape*>(splitShapes);
 
            KoShapeContainer *parent = shape->parent();
            canvas()->shapeController()->addShapesDirect(normalShapes, parent, cmd);
            canvas()->shapeController()->removeShape(shape, cmd);
            newShapes << normalShapes;
        }
    }
 
    new KoKeepShapesSelectedCommand({}, newShapes, canvas()->selectedShapesProxy(), true, cmd);
 
    canvas()->addCommand(cmd);
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), koSelection(), kundo2_i18n(), KoShape::parent(), KoCanvasBase::selectedShapesProxy(), selection(), KoPathShape::separate(), and KoCanvasBase::shapeController.

selectionTransform

void DefaultTool::selectionTransform ( int transformAction )

privateslot

Definition at line 1652 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> editableShapes = selection->selectedEditableShapes();
    if (editableShapes.isEmpty()) {
        return;
    }
 
    QTransform applyTransform;
    bool shouldReset = false;
    KUndo2MagicString actionName = kundo2_noi18n("BUG: No transform action");
 
 
    switch (TransformActionType(transformAction)) {
    case TransformRotate90CW:
        applyTransform.rotate(90.0);
        actionName = kundo2_i18n("Rotate Object 90° CW");
        break;
    case TransformRotate90CCW:
        applyTransform.rotate(-90.0);
        actionName = kundo2_i18n("Rotate Object 90° CCW");
        break;
    case TransformRotate180:
        applyTransform.rotate(180.0);
        actionName = kundo2_i18n("Rotate Object 180°");
        break;
    case TransformMirrorX:
        applyTransform.scale(-1.0, 1.0);
        actionName = kundo2_i18n("Mirror Object Horizontally");
        break;
    case TransformMirrorY:
        applyTransform.scale(1.0, -1.0);
        actionName = kundo2_i18n("Mirror Object Vertically");
        break;
    case TransformReset:
        shouldReset = true;
        actionName = kundo2_i18n("Reset Object Transformations");
        break;
    }
 
    if (!shouldReset && applyTransform.isIdentity()) return;
 
    QList<QTransform> oldTransforms;
    QList<QTransform> newTransforms;
 
    const QRectF outlineRect = KoShape::absoluteOutlineRect(editableShapes);
    const QPointF centerPoint = outlineRect.center();
    const QTransform centerTrans = QTransform::fromTranslate(centerPoint.x(), centerPoint.y());
    const QTransform centerTransInv = QTransform::fromTranslate(-centerPoint.x(), -centerPoint.y());
 
    // we also add selection to the list of transformed shapes, so that its outline is updated correctly
    QList<KoShape*> transformedShapes = editableShapes;
    transformedShapes << selection;
 
    Q_FOREACH (KoShape *shape, transformedShapes) {
        oldTransforms.append(shape->transformation());
 
        QTransform t;
 
        if (!shouldReset) {
            const QTransform world = shape->absoluteTransformation();
            t =  world * centerTransInv * applyTransform * centerTrans * world.inverted() * shape->transformation();
        } else {
            const QPointF center = shape->outlineRect().center();
            const QPointF offset = shape->transformation().map(center) - center;
            t = QTransform::fromTranslate(offset.x(), offset.y());
        }
 
        newTransforms.append(t);
    }
 
    KoShapeTransformCommand *cmd = new KoShapeTransformCommand(transformedShapes, oldTransforms, newTransforms);
    cmd->setText(actionName);
    canvas()->addCommand(cmd);
}

References KoShape::absoluteOutlineRect(), KoShape::absoluteTransformation(), KoCanvasBase::addCommand(), KoToolBase::canvas(), koSelection(), kundo2_i18n(), kundo2_noi18n(), KoShape::outlineRect(), selection(), KUndo2Command::setText(), and KoShape::transformation().

selectionUngroup

void DefaultTool::selectionUngroup ( )

privateslot

Definition at line 1620 of file DefaultTool.cpp.

{
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    std::sort(selectedShapes.begin(), selectedShapes.end(), KoShape::compareShapeZIndex);
 
    KUndo2Command *cmd = 0;
    QList<KoShape*> newShapes;
 
    // add a ungroup command for each found shape container to the macro command
    Q_FOREACH (KoShape *shape, selectedShapes) {
        KoShapeGroup *group = dynamic_cast<KoShapeGroup *>(shape);
        if (group) {
            if (!cmd) {
                cmd = new KUndo2Command(kundo2_i18n("Ungroup shapes"));
                new KoKeepShapesSelectedCommand(selectedShapes, {}, canvas()->selectedShapesProxy(), false, cmd);
            }
            newShapes << group->shapes();
            new KoShapeUngroupCommand(group, group->shapes(),
                                      group->parent() ? QList<KoShape *>() : shapeManager()->topLevelShapes(),
                                      cmd);
            canvas()->shapeController()->removeShape(group, cmd);
        }
    }
    if (cmd) {
        new KoKeepShapesSelectedCommand({}, newShapes, canvas()->selectedShapesProxy(), true, cmd);
        canvas()->addCommand(cmd);
    }
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KoShape::compareShapeZIndex(), koSelection(), kundo2_i18n(), KoShape::parent(), KoCanvasBase::selectedShapesProxy(), selection(), KoCanvasBase::shapeController, shapeManager(), KoShapeContainer::shapes(), and KoShapeManager::topLevelShapes().

setupActions()

void DefaultTool::setupActions ( )

private

Definition at line 806 of file DefaultTool.cpp.

{
    m_alignSignalsMapper = new KisSignalMapper(this);
 
    addMappedAction(m_alignSignalsMapper, "object_align_horizontal_left", KoShapeAlignCommand::HorizontalLeftAlignment);
    addMappedAction(m_alignSignalsMapper, "object_align_horizontal_center", KoShapeAlignCommand::HorizontalCenterAlignment);
    addMappedAction(m_alignSignalsMapper, "object_align_horizontal_right", KoShapeAlignCommand::HorizontalRightAlignment);
    addMappedAction(m_alignSignalsMapper, "object_align_vertical_top", KoShapeAlignCommand::VerticalTopAlignment);
    addMappedAction(m_alignSignalsMapper, "object_align_vertical_center", KoShapeAlignCommand::VerticalCenterAlignment);
    addMappedAction(m_alignSignalsMapper, "object_align_vertical_bottom", KoShapeAlignCommand::VerticalBottomAlignment);
 
    m_distributeSignalsMapper = new KisSignalMapper(this);
 
    addMappedAction(m_distributeSignalsMapper, "object_distribute_horizontal_left", KoShapeDistributeCommand::HorizontalLeftDistribution);
    addMappedAction(m_distributeSignalsMapper, "object_distribute_horizontal_center", KoShapeDistributeCommand::HorizontalCenterDistribution);
    addMappedAction(m_distributeSignalsMapper, "object_distribute_horizontal_right", KoShapeDistributeCommand::HorizontalRightDistribution);
    addMappedAction(m_distributeSignalsMapper, "object_distribute_horizontal_gaps", KoShapeDistributeCommand::HorizontalGapsDistribution);
 
    addMappedAction(m_distributeSignalsMapper, "object_distribute_vertical_top", KoShapeDistributeCommand::VerticalTopDistribution);
    addMappedAction(m_distributeSignalsMapper, "object_distribute_vertical_center", KoShapeDistributeCommand::VerticalCenterDistribution);
    addMappedAction(m_distributeSignalsMapper, "object_distribute_vertical_bottom", KoShapeDistributeCommand::VerticalBottomDistribution);
    addMappedAction(m_distributeSignalsMapper, "object_distribute_vertical_gaps", KoShapeDistributeCommand::VerticalGapsDistribution);
 
    m_transformSignalsMapper = new KisSignalMapper(this);
 
    addMappedAction(m_transformSignalsMapper, "object_transform_rotate_90_cw", TransformRotate90CW);
    addMappedAction(m_transformSignalsMapper, "object_transform_rotate_90_ccw", TransformRotate90CCW);
    addMappedAction(m_transformSignalsMapper, "object_transform_rotate_180", TransformRotate180);
    addMappedAction(m_transformSignalsMapper, "object_transform_mirror_horizontally", TransformMirrorX);
    addMappedAction(m_transformSignalsMapper, "object_transform_mirror_vertically", TransformMirrorY);
    addMappedAction(m_transformSignalsMapper, "object_transform_reset", TransformReset);
 
    m_booleanSignalsMapper = new KisSignalMapper(this);
 
    addMappedAction(m_booleanSignalsMapper, "object_unite", BooleanUnion);
    addMappedAction(m_booleanSignalsMapper, "object_intersect", BooleanIntersection);
    addMappedAction(m_booleanSignalsMapper, "object_subtract", BooleanSubtraction);
 
    m_textTypeSignalsMapper = new KisSignalMapper(this);
    addMappedAction(m_textTypeSignalsMapper, "text_type_preformatted", KoSvgTextShape::PreformattedText);
    addMappedAction(m_textTypeSignalsMapper, "text_type_inline_wrap", KoSvgTextShape::InlineWrap);
    addMappedAction(m_textTypeSignalsMapper, "text_type_pre_positioned", KoSvgTextShape::PrePositionedText);
 
    if (!action("text_type_preformatted")->actionGroup()) {
        QActionGroup *textTypeActions = new QActionGroup(this);
        textTypeActions->addAction(action("text_type_preformatted"));
        textTypeActions->addAction(action("text_type_inline_wrap"));
        textTypeActions->addAction(action("text_type_pre_positioned"));
        textTypeActions->setExclusive(false);
        Q_FOREACH (QAction *a, textTypeActions->actions()) {
            a->setCheckable(false);
        }
    }
 
    m_textFlowSignalsMapper  = new KisSignalMapper(this);
 
    addMappedAction(m_textFlowSignalsMapper, "flow_shape_order_back", KoSvgTextReorderShapeInsideCommand::SendToBack);
    addMappedAction(m_textFlowSignalsMapper, "flow_shape_order_earlier", KoSvgTextReorderShapeInsideCommand::MoveEarlier);
    addMappedAction(m_textFlowSignalsMapper, "flow_shape_order_later", KoSvgTextReorderShapeInsideCommand::MoveLater);
    addMappedAction(m_textFlowSignalsMapper, "flow_shape_order_front", KoSvgTextReorderShapeInsideCommand::BringToFront);
 
    m_contextMenu.reset(new QMenu());
}

References KoToolBase::action(), addMappedAction(), KoSvgTextReorderShapeInsideCommand::BringToFront, KoShapeAlignCommand::HorizontalCenterAlignment, KoShapeDistributeCommand::HorizontalCenterDistribution, KoShapeDistributeCommand::HorizontalGapsDistribution, KoShapeAlignCommand::HorizontalLeftAlignment, KoShapeDistributeCommand::HorizontalLeftDistribution, KoShapeAlignCommand::HorizontalRightAlignment, KoShapeDistributeCommand::HorizontalRightDistribution, KoSvgTextShape::InlineWrap, m_alignSignalsMapper, m_booleanSignalsMapper, m_contextMenu, m_distributeSignalsMapper, m_textFlowSignalsMapper, m_textTypeSignalsMapper, m_transformSignalsMapper, KoSvgTextReorderShapeInsideCommand::MoveEarlier, KoSvgTextReorderShapeInsideCommand::MoveLater, KoSvgTextShape::PreformattedText, KoSvgTextShape::PrePositionedText, KoSvgTextReorderShapeInsideCommand::SendToBack, KoShapeAlignCommand::VerticalBottomAlignment, KoShapeDistributeCommand::VerticalBottomDistribution, KoShapeAlignCommand::VerticalCenterAlignment, KoShapeDistributeCommand::VerticalCenterDistribution, KoShapeDistributeCommand::VerticalGapsDistribution, KoShapeAlignCommand::VerticalTopAlignment, and KoShapeDistributeCommand::VerticalTopDistribution.

shapeManager()

KoShapeManager * DefaultTool::shapeManager ( ) const

protectedvirtual

Reimplemented in ToolReferenceImages.

Definition at line 1158 of file DefaultTool.cpp.

                                                {
    return canvas()->shapeManager();
}

References KoToolBase::canvas(), and KoCanvasBase::shapeManager().

slotActivateEditFillGradient

void DefaultTool::slotActivateEditFillGradient ( bool value )

privateslot

Definition at line 491 of file DefaultTool.cpp.

{
    if (value) {
        addInteractionFactory(
            new MoveGradientHandleInteractionFactory(KoFlake::Fill,
                                                     1, EditFillGradientFactoryId, this));
    } else {
        removeInteractionFactory(EditFillGradientFactoryId);
    }
    repaintDecorations();
}

References KoInteractionTool::addInteractionFactory(), KoFlake::Fill, KoInteractionTool::removeInteractionFactory(), KoToolBase::repaintDecorations(), and value().

slotActivateEditFillMeshGradient

void DefaultTool::slotActivateEditFillMeshGradient ( bool value )

privateslot

Definition at line 515 of file DefaultTool.cpp.

{
    if (value) {
        connect(this, SIGNAL(meshgradientHandleSelected(KoShapeMeshGradientHandles::Handle)),
                m_tabbedOptionWidget, SLOT(slotMeshGradientHandleSelected(KoShapeMeshGradientHandles::Handle)));
        addInteractionFactory(
            new MoveMeshGradientHandleInteractionFactory(KoFlake::Fill, 1,
                                                         EditFillMeshGradientFactoryId, this));
    } else {
        disconnect(this, SIGNAL(meshgradientHandleSelected(KoShapeMeshGradientHandles::Handle)),
                   m_tabbedOptionWidget, SLOT(slotMeshGradientHandleSelected(KoShapeMeshGradientHandles::Handle)));
        removeInteractionFactory(EditFillMeshGradientFactoryId);
    }
}

References KoInteractionTool::addInteractionFactory(), KoFlake::Fill, m_tabbedOptionWidget, meshgradientHandleSelected(), KoInteractionTool::removeInteractionFactory(), and value().

slotActivateEditStrokeGradient

void DefaultTool::slotActivateEditStrokeGradient ( bool value )

privateslot

Definition at line 503 of file DefaultTool.cpp.

{
    if (value) {
        addInteractionFactory(
            new MoveGradientHandleInteractionFactory(KoFlake::StrokeFill,
                                                     0, EditStrokeGradientFactoryId, this));
    } else {
        removeInteractionFactory(EditStrokeGradientFactoryId);
    }
    repaintDecorations();
}

References KoInteractionTool::addInteractionFactory(), KoInteractionTool::removeInteractionFactory(), KoToolBase::repaintDecorations(), KoFlake::StrokeFill, and value().

slotAddShapesToFlow

void DefaultTool::slotAddShapesToFlow ( )

privateslot

Definition at line 563 of file DefaultTool.cpp.

{
    KoSvgTextShape *textShape = nullptr;
    QList<KoShape*> shapes;
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    std::sort(selectedShapes.begin(), selectedShapes.end(), KoShape::compareShapeZIndex);
    if (selectedShapes.isEmpty()) return;
 
    Q_FOREACH(KoShape *shape, selectedShapes) {
        KoSvgTextShape *text = dynamic_cast<KoSvgTextShape*>(shape);
        KoPathShape *path = dynamic_cast<KoPathShape*>(shape);
        if (text && !textShape) {
            textShape = text;
        } else if (path && path->isClosedSubpath(0)) {
            shapes.append(shape);
        }
    }
    if (!textShape) return;
    if (shapes.isEmpty()) return;
 
   KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Add shapes to text flow."));
 
   if (textShape->textType() != KoSvgTextShape::InlineWrap) {
       new KoSvgConvertTextTypeCommand(textShape, KoSvgTextShape::PreformattedText, 0, parentCommand);
   }
   KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(textShape, parentCommand, false, true);
 
    new KoKeepShapesSelectedCommand(selectedShapes, {}, canvas()->selectedShapesProxy(), false, parentCommand);
    Q_FOREACH(KoShape *shape, shapes) {
        new KoSvgTextAddShapeCommand(textShape, shape, true, parentCommand);
    }
    new KoKeepShapesSelectedCommand({}, {textShape}, canvas()->selectedShapesProxy(), true, parentCommand);
 
    canvas()->addCommand(parentCommand);
    selection->deselectAll();
    selection->select(textShape);
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KoShape::compareShapeZIndex(), KoSvgTextShape::InlineWrap, koSelection(), kundo2_i18n(), KoSvgTextShape::PreformattedText, KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(), KoCanvasBase::selectedShapesProxy(), selection(), and KoSvgTextShape::textType().

slotChangeTextType

void DefaultTool::slotChangeTextType ( int index )

privateslot

Definition at line 535 of file DefaultTool.cpp.

{
    QList<KoShape *> shapes = koSelection()->selectedShapes();
 
    if (shapes.isEmpty()) return;
 
    const KoSvgTextShape::TextType type = KoSvgTextShape::TextType(index);
    KUndo2Command *parentCommand = new KUndo2Command();
    bool convertableShape = false;
    new KoKeepShapesSelectedCommand({shapes}, {}, canvas()->selectedShapesProxy(), KisCommandUtils::FlipFlopCommand::State::INITIALIZING, parentCommand);
    Q_FOREACH(KoShape *shape, shapes) {
        KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape*>(shape);
        if (textShape && textShape->textType() != type) {
            KoSvgConvertTextTypeCommand *cmd = new KoSvgConvertTextTypeCommand(textShape, type, 0, parentCommand);
            if (!convertableShape) {
                convertableShape = true;
                parentCommand->setText(cmd->text());
            }
            KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(textShape, parentCommand, textShape->textType() == KoSvgTextShape::TextInShape, type == KoSvgTextShape::InlineWrap);
        }
    }
 
    new KoKeepShapesSelectedCommand({}, {shapes}, canvas()->selectedShapesProxy(), KisCommandUtils::FlipFlopCommand::State::FINALIZING, parentCommand);
    if (convertableShape) {
        canvas()->addCommand(parentCommand);
    }
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KisCommandUtils::FlipFlopCommand::FINALIZING, KisCommandUtils::FlipFlopCommand::INITIALIZING, KoSvgTextShape::InlineWrap, koSelection(), KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(), KoSelection::selectedShapes(), KoCanvasBase::selectedShapesProxy(), KUndo2Command::setText(), KUndo2Command::text(), KoSvgTextShape::TextInShape, and KoSvgTextShape::textType().

slotPutTextOnPath

void DefaultTool::slotPutTextOnPath ( )

privateslot

This will always remove all previous text paths. While Krita's layout engine can handle multiple of them, the interaction hasn't been fully verified yet. So if someone implements multiple textpaths, they will also need to check if the cursor interaction makes sense.

We need to adjust the startOffset by the anchor/direction, because otherwise the text might be largely off the path. This isn't a problem when using cursor to set it, as the cursor-pos can be the startOffset position.

Definition at line 604 of file DefaultTool.cpp.

{
    KoSvgTextShape *textShape = nullptr;
    KoPathShape *textPath = nullptr;
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    std::sort(selectedShapes.begin(), selectedShapes.end(), KoShape::compareShapeZIndex);
    if (selectedShapes.isEmpty()) return;
 
    Q_FOREACH(KoShape *shape, selectedShapes) {
        KoSvgTextShape *text = dynamic_cast<KoSvgTextShape*>(shape);
        if (text && !textShape) {
            textShape = text;
        } else if (KoPathShape *path = dynamic_cast<KoPathShape*>(shape)){
            textPath = path;
        }
        if (textShape && textPath) {
            break;
        }
    }
    if (!(textShape && textPath)) return;
 
   KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Put Text On Path"));
 
   new KoKeepShapesSelectedCommand(selectedShapes, {}, canvas()->selectedShapesProxy(), false, parentCommand);
   if (textShape->textType() != KoSvgTextShape::PreformattedText && textShape->textType() != KoSvgTextShape::PrePositionedText) {
       new KoSvgConvertTextTypeCommand(textShape, KoSvgTextShape::PreformattedText, 0, parentCommand);
   }
 
   KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(textShape, parentCommand, true, true);
   new KoSvgTextSetTextPathOnRangeCommand(textShape, textPath, 0, textShape->posForIndex(textShape->plainText().size()), parentCommand);
 
   KoSvgText::TextAnchor anchor = KoSvgText::TextAnchor(textShape->textProperties().propertyOrDefault(KoSvgTextProperties::TextAnchorId).toInt());
   if ((textShape->direction() == KoSvgText::DirectionRightToLeft && anchor == KoSvgText::AnchorStart)
           || (textShape->direction() == KoSvgText::DirectionLeftToRight && anchor == KoSvgText::AnchorEnd)) {
       KoSvgText::TextOnPathInfo info;
       info.startOffset = 100.0;
       info.startOffsetIsPercentage = true;
       new KoSvgTextPathInfoChangeCommand(textShape, 0, info, parentCommand);
   } else if (anchor == KoSvgText::AnchorMiddle) {
       KoSvgText::TextOnPathInfo info;
       info.startOffset = 50.0;
       info.startOffsetIsPercentage = true;
       new KoSvgTextPathInfoChangeCommand(textShape, 0, info, parentCommand);
   }
 
   new KoKeepShapesSelectedCommand({}, {textShape}, canvas()->selectedShapesProxy(), true, parentCommand);
 
   canvas()->addCommand(parentCommand);
   selection->deselectAll();
   selection->select(textShape);
}

References KoCanvasBase::addCommand(), KoSvgText::AnchorEnd, KoSvgText::AnchorMiddle, KoSvgText::AnchorStart, KoToolBase::canvas(), KoShape::compareShapeZIndex(), KoSvgTextShape::direction(), KoSvgText::DirectionLeftToRight, KoSvgText::DirectionRightToLeft, koSelection(), kundo2_i18n(), KoSvgTextShape::plainText, KoSvgTextShape::posForIndex(), KoSvgTextShape::PreformattedText, KoSvgTextShape::PrePositionedText, KoSvgTextProperties::propertyOrDefault(), KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(), KoCanvasBase::selectedShapesProxy(), selection(), KoSvgText::TextOnPathInfo::startOffset, KoSvgText::TextOnPathInfo::startOffsetIsPercentage, KoSvgTextProperties::TextAnchorId, KoSvgTextShape::textProperties(), and KoSvgTextShape::textType().

slotRemoveShapesFromFlow

void DefaultTool::slotRemoveShapesFromFlow ( )

privateslot

Definition at line 711 of file DefaultTool.cpp.

{
    KoSvgTextShape *textShape = tryFetchCurrentShapeManagerOwnerTextShape();
    if (!textShape) return;
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    if (selectedShapes.isEmpty()) return;
 
    KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Remove shapes from text flow."));
 
    new KoKeepShapesSelectedCommand(selectedShapes, {}, canvas()->selectedShapesProxy(), false, parentCommand);
    Q_FOREACH(KoShape *shape, selectedShapes) {
        if (!textShape->shapeInContours(shape)) continue;
        new KoSvgTextRemoveShapeCommand(textShape, shape, parentCommand);
    }
    new KoKeepShapesSelectedCommand({}, {selectedShapes}, canvas()->selectedShapesProxy(), true, parentCommand);
 
    canvas()->addCommand(parentCommand);
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), koSelection(), kundo2_i18n(), KoCanvasBase::selectedShapesProxy(), selection(), KoSvgTextShape::shapeInContours(), and tryFetchCurrentShapeManagerOwnerTextShape().

slotReorderFlowShapes

void DefaultTool::slotReorderFlowShapes ( int type )

privateslot

Definition at line 756 of file DefaultTool.cpp.

{
    KoSvgTextShape *textShape = tryFetchCurrentShapeManagerOwnerTextShape();
    if (!textShape) return;
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    if (selectedShapes.isEmpty()) return;
 
    KUndo2Command *parentCommand = new KUndo2Command();
    if (type == KoSvgTextReorderShapeInsideCommand::BringToFront) {
        parentCommand->setText(kundo2_i18n("Set Flow Shape as First"));
    } else if (type == KoSvgTextReorderShapeInsideCommand::MoveEarlier) {
        parentCommand->setText(kundo2_i18n("Decrease Flow Shape Index"));
    } else if (type == KoSvgTextReorderShapeInsideCommand::MoveLater) {
        parentCommand->setText(kundo2_i18n("Increase Flow Shape Index"));
    } else {
        parentCommand->setText(kundo2_i18n("Set Flow Shape as Last"));
    }
 
    QList<KoShape *> shapesInside;
    Q_FOREACH(KoShape *shape, selectedShapes) {
        if (!textShape->shapesInside().contains(shape)) continue;
        shapesInside.append(shape);
    }
 
    if (!shapesInside.isEmpty()) {
        new KoSvgTextReorderShapeInsideCommand(textShape, shapesInside, KoSvgTextReorderShapeInsideCommand::MoveShapeType(type), parentCommand);
        canvas()->addCommand(parentCommand);
    }
}

References KoCanvasBase::addCommand(), KoSvgTextReorderShapeInsideCommand::BringToFront, KoToolBase::canvas(), koSelection(), kundo2_i18n(), KoSvgTextReorderShapeInsideCommand::MoveEarlier, KoSvgTextReorderShapeInsideCommand::MoveLater, selection(), KUndo2Command::setText(), KoSvgTextShape::shapesInside, and tryFetchCurrentShapeManagerOwnerTextShape().

slotResetMeshGradientState

void DefaultTool::slotResetMeshGradientState ( )

privateslot

Definition at line 530 of file DefaultTool.cpp.

{
    m_selectedMeshHandle = KoShapeMeshGradientHandles::Handle();
}

References m_selectedMeshHandle.

slotSubtractShapesFromFlow

void DefaultTool::slotSubtractShapesFromFlow ( )

privateslot

Definition at line 665 of file DefaultTool.cpp.

{
    KoSvgTextShape *textShape = nullptr;
    QList<KoShape*> shapes;
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    std::sort(selectedShapes.begin(), selectedShapes.end(), KoShape::compareShapeZIndex);
    if (selectedShapes.isEmpty()) return;
 
    Q_FOREACH(KoShape *shape, selectedShapes) {
        KoSvgTextShape *text = dynamic_cast<KoSvgTextShape*>(shape);
        KoPathShape *path = dynamic_cast<KoPathShape*>(shape);
        if (text && !textShape) {
            textShape = text;
        } else if (path && path->isClosedSubpath(0)) {
            shapes.append(shape);
        }
    }
    if (!textShape) return;
    if (shapes.isEmpty()) return;
 
    KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Subtract shapes from text flow."));
 
    if (textShape->textType() == KoSvgTextShape::InlineWrap) {
        new KoSvgConvertTextTypeCommand(textShape, KoSvgTextShape::PreformattedText, 0, parentCommand);
    }
    KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(textShape, parentCommand, false, true);
 
    new KoKeepShapesSelectedCommand(selectedShapes, {}, canvas()->selectedShapesProxy(), false, parentCommand);
    Q_FOREACH(KoShape *shape, shapes) {
        new KoSvgTextAddShapeCommand(textShape, shape, false, parentCommand);
    }
    new KoKeepShapesSelectedCommand({}, {textShape}, canvas()->selectedShapesProxy(), true, parentCommand);
 
    canvas()->addCommand(parentCommand);
    selection->deselectAll();
    selection->select(textShape);
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), KoShape::compareShapeZIndex(), KoSvgTextShape::InlineWrap, koSelection(), kundo2_i18n(), KoSvgTextShape::PreformattedText, KoSvgTextRemoveShapeCommand::removeContourShapesFromFlow(), KoCanvasBase::selectedShapesProxy(), selection(), and KoSvgTextShape::textType().

slotToggleFlowShapeType

void DefaultTool::slotToggleFlowShapeType ( )

privateslot

Definition at line 733 of file DefaultTool.cpp.

{
    KoSvgTextShape *textShape = tryFetchCurrentShapeManagerOwnerTextShape();
    if (!textShape) return;
    KoSelection *selection = koSelection();
    if (!selection) return;
 
    QList<KoShape *> selectedShapes = selection->selectedEditableShapes();
    if (selectedShapes.isEmpty()) return;
    KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18n("Toggle Flow Shape Type"));
 
    bool addToCanvas = false;
    Q_FOREACH(KoShape *shape, selectedShapes) {
        if (!textShape->shapesInside().contains(shape)
                && !textShape->shapesSubtract().contains(shape)) continue;
        addToCanvas = true;
        new KoSvgTextFlipShapeContourTypeCommand(textShape, shape, parentCommand);
    }
    if (addToCanvas) {
        canvas()->addCommand(parentCommand);
    }
}

References KoCanvasBase::addCommand(), KoToolBase::canvas(), koSelection(), kundo2_i18n(), selection(), KoSvgTextShape::shapesInside, KoSvgTextShape::shapesSubtract, and tryFetchCurrentShapeManagerOwnerTextShape().

tryFetchCurrentShapeManagerOwnerTextShape()

KoSvgTextShape * DefaultTool::tryFetchCurrentShapeManagerOwnerTextShape

(

)

const

Definition at line 706 of file DefaultTool.cpp.

{
    return dynamic_cast<KoSvgTextShape*>(canvas()->currentShapeManagerOwnerShape());
}

References KoToolBase::canvas(), and KoCanvasBase::currentShapeManagerOwnerShape().

updateActions

void DefaultTool::updateActions ( )

protectedslot

Update actions on selection change.

Definition at line 2107 of file DefaultTool.cpp.

{
    QList<KoShape*> editableShapes;
 
    if (koSelection()) {
        editableShapes = koSelection()->selectedEditableShapes();
    }
 
    const bool hasEditableShapes = !editableShapes.isEmpty();
 
    action("object_order_front")->setEnabled(hasEditableShapes);
    action("object_order_raise")->setEnabled(hasEditableShapes);
    action("object_order_lower")->setEnabled(hasEditableShapes);
    action("object_order_back")->setEnabled(hasEditableShapes);
 
    action("object_transform_rotate_90_cw")->setEnabled(hasEditableShapes);
    action("object_transform_rotate_90_ccw")->setEnabled(hasEditableShapes);
    action("object_transform_rotate_180")->setEnabled(hasEditableShapes);
    action("object_transform_mirror_horizontally")->setEnabled(hasEditableShapes);
    action("object_transform_mirror_vertically")->setEnabled(hasEditableShapes);
    action("object_transform_reset")->setEnabled(hasEditableShapes);
 
    const bool multipleSelected = editableShapes.size() > 1;
 
    const bool alignmentEnabled =
       multipleSelected ||
       (!editableShapes.isEmpty() &&
        canvas()->resourceManager()->hasResource(KoCanvasResource::PageSize));
 
    action("object_align_horizontal_left")->setEnabled(alignmentEnabled);
    action("object_align_horizontal_center")->setEnabled(alignmentEnabled);
    action("object_align_horizontal_right")->setEnabled(alignmentEnabled);
    action("object_align_vertical_top")->setEnabled(alignmentEnabled);
    action("object_align_vertical_center")->setEnabled(alignmentEnabled);
    action("object_align_vertical_bottom")->setEnabled(alignmentEnabled);
 
    const bool distributionEnabled = editableShapes.size() > 2;
 
    action("object_distribute_horizontal_left")->setEnabled(distributionEnabled);
    action("object_distribute_horizontal_center")->setEnabled(distributionEnabled);
    action("object_distribute_horizontal_right")->setEnabled(distributionEnabled);
    action("object_distribute_horizontal_gaps")->setEnabled(distributionEnabled);
 
    action("object_distribute_vertical_top")->setEnabled(distributionEnabled);
    action("object_distribute_vertical_center")->setEnabled(distributionEnabled);
    action("object_distribute_vertical_bottom")->setEnabled(distributionEnabled);
    action("object_distribute_vertical_gaps")->setEnabled(distributionEnabled);
 
    /* Handling the text actions */
    bool textShape = false;
    bool otherShapes = false;
    bool filledShapes = false;
    bool shapesInside = false;
    KoSvgTextShape *currentTextShapeGroup = tryFetchCurrentShapeManagerOwnerTextShape();
    const bool editFlowShapes = bool(currentTextShapeGroup);
    Q_FOREACH(KoShape *shape, editableShapes) {
        KoSvgTextShape *text = dynamic_cast<KoSvgTextShape *>(shape);
        if (text && !textShape) {
            textShape = true;
        } else {
            otherShapes = true;
            KoPathShape *path = dynamic_cast<KoPathShape*>(shape);
            filledShapes = filledShapes? filledShapes: (path && path->isClosedSubpath(0));
            if (editFlowShapes) {
                if (!shapesInside && currentTextShapeGroup->shapesInside().contains(shape)) {
                    shapesInside = true;
                }
            }
        }
        if (textShape && otherShapes) break;
    }
    const bool editContours = textShape && otherShapes;
    const bool editFilledContours = textShape && filledShapes;
 
    action("add_shape_to_flow_area")->setEnabled(editFilledContours);
    action("subtract_shape_from_flow_area")->setEnabled(editFilledContours);
    action("put_text_on_path")->setEnabled(editContours);
    action("remove_shapes_from_text_flow")->setEnabled(editFlowShapes);
    action("flow_shape_type_toggle")->setEnabled(editFlowShapes);
    action("flow_shape_order_back")->setEnabled(shapesInside);
    action("flow_shape_order_earlier")->setEnabled(shapesInside);
    action("flow_shape_order_later")->setEnabled(shapesInside);
    action("flow_shape_order_front")->setEnabled(shapesInside);
 
    updateDistinctiveActions(editableShapes);
 
    Q_EMIT selectionChanged(editableShapes.size());
}

References KoToolBase::action(), KoToolBase::canvas(), koSelection(), KoCanvasResource::PageSize, KoCanvasBase::resourceManager, KoSelection::selectedEditableShapes(), KoToolBase::selectionChanged(), KoSvgTextShape::shapesInside, tryFetchCurrentShapeManagerOwnerTextShape(), and updateDistinctiveActions().

updateCursor()

void DefaultTool::updateCursor ( )

private

Definition at line 989 of file DefaultTool.cpp.

{
    if (tryUseCustomCursor()) return;
 
    QCursor cursor = Qt::ArrowCursor;
 
    QString statusText;
 
    KoSelection *selection = koSelection();
    if (selection && selection->count() > 0) { // has a selection
        bool editable = !selection->selectedEditableShapes().isEmpty();
 
        if (!m_mouseWasInsideHandles) {
            m_angle = rotationOfHandle(m_lastHandle, true);
            int rotOctant = 8 + int(8.5 + m_angle / 45);
 
            bool rotateHandle = false;
            bool shearHandle = false;
            switch (m_lastHandle) {
            case KoFlake::TopMiddleHandle:
                cursor = m_shearCursors[(0 + rotOctant) % 8];
                shearHandle = true;
                break;
            case KoFlake::TopRightHandle:
                cursor = m_rotateCursors[(1 + rotOctant) % 8];
                rotateHandle = true;
                break;
            case KoFlake::RightMiddleHandle:
                cursor = m_shearCursors[(2 + rotOctant) % 8];
                shearHandle = true;
                break;
            case KoFlake::BottomRightHandle:
                cursor = m_rotateCursors[(3 + rotOctant) % 8];
                rotateHandle = true;
                break;
            case KoFlake::BottomMiddleHandle:
                cursor = m_shearCursors[(4 + rotOctant) % 8];
                shearHandle = true;
                break;
            case KoFlake::BottomLeftHandle:
                cursor = m_rotateCursors[(5 + rotOctant) % 8];
                rotateHandle = true;
                break;
            case KoFlake::LeftMiddleHandle:
                cursor = m_shearCursors[(6 + rotOctant) % 8];
                shearHandle = true;
                break;
            case KoFlake::TopLeftHandle:
                cursor = m_rotateCursors[(7 + rotOctant) % 8];
                rotateHandle = true;
                break;
            case KoFlake::NoHandle:
                cursor = Qt::ArrowCursor;
                break;
            }
            if (rotateHandle) {
                statusText = i18n("Left click rotates around center, right click around highlighted position.");
            }
            if (shearHandle) {
                statusText = i18n("Click and drag to shear selection.");
            }
 
 
        } else {
            statusText = i18n("Click and drag to resize selection.");
            m_angle = rotationOfHandle(m_lastHandle, false);
            int rotOctant = 8 + int(8.5 + m_angle / 45);
            bool cornerHandle = false;
            switch (m_lastHandle) {
            case KoFlake::TopMiddleHandle:
                cursor = m_sizeCursors[(0 + rotOctant) % 8];
                break;
            case KoFlake::TopRightHandle:
                cursor = m_sizeCursors[(1 + rotOctant) % 8];
                cornerHandle = true;
                break;
            case KoFlake::RightMiddleHandle:
                cursor = m_sizeCursors[(2 + rotOctant) % 8];
                break;
            case KoFlake::BottomRightHandle:
                cursor = m_sizeCursors[(3 + rotOctant) % 8];
                cornerHandle = true;
                break;
            case KoFlake::BottomMiddleHandle:
                cursor = m_sizeCursors[(4 + rotOctant) % 8];
                break;
            case KoFlake::BottomLeftHandle:
                cursor = m_sizeCursors[(5 + rotOctant) % 8];
                cornerHandle = true;
                break;
            case KoFlake::LeftMiddleHandle:
                cursor = m_sizeCursors[(6 + rotOctant) % 8];
                break;
            case KoFlake::TopLeftHandle:
                cursor = m_sizeCursors[(7 + rotOctant) % 8];
                cornerHandle = true;
                break;
            case KoFlake::NoHandle:
                cursor = Qt::SizeAllCursor;
                statusText = i18n("Click and drag to move selection.");
                break;
            }
            if (cornerHandle) {
                statusText = i18n("Click and drag to resize selection. Middle click to set highlighted position.");
            }
        }
        if (!editable) {
            cursor = Qt::ArrowCursor;
        }
    } else {
        // there used to be guides... :'''(
    }
    useCursor(cursor);
    if (currentStrategy() == 0) {
        Q_EMIT statusTextChanged(statusText);
    }
}

References KoFlake::BottomLeftHandle, KoFlake::BottomMiddleHandle, KoFlake::BottomRightHandle, KoInteractionTool::currentStrategy(), KoToolBase::cursor(), koSelection(), KoFlake::LeftMiddleHandle, m_angle, m_lastHandle, m_mouseWasInsideHandles, m_rotateCursors, m_shearCursors, m_sizeCursors, KoFlake::NoHandle, KoFlake::RightMiddleHandle, rotationOfHandle(), selection(), KoToolBase::statusTextChanged(), KoFlake::TopLeftHandle, KoFlake::TopMiddleHandle, KoFlake::TopRightHandle, KoInteractionTool::tryUseCustomCursor(), and KoToolBase::useCursor().

updateDistinctiveActions()

void DefaultTool::updateDistinctiveActions ( const QList< KoShape * > & editableShapes )

protectedvirtual

Enable/disable actions specific to the tool (vector vs. reference images)

Reimplemented in ToolReferenceImages.

Definition at line 2196 of file DefaultTool.cpp.

                                                                                {
    const bool multipleSelected = editableShapes.size() > 1;
 
    action("object_group")->setEnabled(multipleSelected);
 
    action("object_unite")->setEnabled(multipleSelected);
    action("object_intersect")->setEnabled(multipleSelected);
    action("object_subtract")->setEnabled(multipleSelected);
 
    bool hasShapesWithMultipleSegments = false;
    Q_FOREACH (KoShape *shape, editableShapes) {
            KoPathShape *pathShape = dynamic_cast<KoPathShape *>(shape);
            if (pathShape && pathShape->subpathCount() > 1) {
                hasShapesWithMultipleSegments = true;
                break;
            }
        }
    action("object_split")->setEnabled(hasShapesWithMultipleSegments);
 
 
    bool hasGroupShape = false;
            foreach (KoShape *shape, editableShapes) {
            if (dynamic_cast<KoShapeGroup *>(shape)) {
                hasGroupShape = true;
                break;
            }
        }
    action("object_ungroup")->setEnabled(hasGroupShape);
 
    bool enablePreformatted = false;
    bool enablePrePositioned = false;
    bool enableInlineWrapped = false;
    bool text = false;
    Q_FOREACH (KoShape *shape, editableShapes) {
        KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape *>(shape);
        if (textShape) {
            text = true;
            if (textShape->textType() != KoSvgTextShape::PreformattedText && !enablePreformatted) {
                enablePreformatted = true;
            }
            if (textShape && textShape->textType() != KoSvgTextShape::PrePositionedText && !enablePrePositioned) {
                enablePrePositioned = true;
            }
            if (textShape && textShape->textType() != KoSvgTextShape::InlineWrap && !enableInlineWrapped) {
                enableInlineWrapped = true;
            }
        }
    }
    QActionGroup *group = action("text_type_preformatted")->actionGroup();
    if (group) {
        group->setEnabled(text);
    }
 
    action("text_type_preformatted")->setEnabled(enablePreformatted);
    action("text_type_pre_positioned")->setEnabled(enablePrePositioned);
    action("text_type_inline_wrap")->setEnabled(enableInlineWrapped);
}

References KoToolBase::action(), KoSvgTextShape::InlineWrap, KoSvgTextShape::PreformattedText, KoSvgTextShape::PrePositionedText, KoPathShape::subpathCount(), and KoSvgTextShape::textType().

updateTextContourMode()

bool DefaultTool::updateTextContourMode

(

)

Definition at line 789 of file DefaultTool.cpp.

{
    return m_textOutlineHelper->updateTextContourMode();
}

References m_textOutlineHelper.

wantsAutoScroll()

bool DefaultTool::wantsAutoScroll ( ) const

overridevirtual

Return if dragging (moving with the mouse down) to the edge of a canvas should scroll the canvas (default is true).

Returns

if this tool wants mouse events to cause scrolling of canvas.

Reimplemented from KoToolBase.

Definition at line 794 of file DefaultTool.cpp.

{
    return true;
}

Friends And Related Symbol Documentation

SelectionHandler

friend class SelectionHandler

friend

Definition at line 209 of file DefaultTool.h.

SelectionInteractionStrategy

friend class SelectionInteractionStrategy

friend

Definition at line 155 of file DefaultTool.h.

Member Data Documentation

m_alignSignalsMapper

KisSignalMapper* DefaultTool::m_alignSignalsMapper {0}

private

Definition at line 213 of file DefaultTool.h.

{0};

m_angle

qreal DefaultTool::m_angle

private

Definition at line 207 of file DefaultTool.h.

m_booleanSignalsMapper

KisSignalMapper* DefaultTool::m_booleanSignalsMapper {0}

private

Definition at line 216 of file DefaultTool.h.

{0};

m_contextMenu

QScopedPointer<QMenu> DefaultTool::m_contextMenu

protected

Definition at line 166 of file DefaultTool.h.

m_decorator

QScopedPointer<SelectionDecorator> DefaultTool::m_decorator

private

Definition at line 197 of file DefaultTool.h.

m_distributeSignalsMapper

KisSignalMapper* DefaultTool::m_distributeSignalsMapper {0}

private

Definition at line 214 of file DefaultTool.h.

{0};

m_hotPosition

KoFlake::AnchorPosition DefaultTool::m_hotPosition

private

Definition at line 191 of file DefaultTool.h.

m_hoveredMeshHandle

KoShapeMeshGradientHandles::Handle DefaultTool::m_hoveredMeshHandle

private

Definition at line 201 of file DefaultTool.h.

m_lastHandle

KoFlake::SelectionHandle DefaultTool::m_lastHandle

private

Definition at line 190 of file DefaultTool.h.

m_lastPoint

QPointF DefaultTool::m_lastPoint

private

Definition at line 195 of file DefaultTool.h.

m_mouseWasInsideHandles

bool DefaultTool::m_mouseWasInsideHandles

private

Definition at line 192 of file DefaultTool.h.

m_rotateCursors

QCursor DefaultTool::m_rotateCursors[8]

private

Definition at line 205 of file DefaultTool.h.

m_selectedMeshHandle

KoShapeMeshGradientHandles::Handle DefaultTool::m_selectedMeshHandle

private

Definition at line 200 of file DefaultTool.h.

m_selectionBox

QPointF DefaultTool::m_selectionBox[8]

private

Definition at line 193 of file DefaultTool.h.

m_selectionHandler

KoToolSelection* DefaultTool::m_selectionHandler

private

Definition at line 208 of file DefaultTool.h.

m_selectionOutline

QPolygonF DefaultTool::m_selectionOutline

private

Definition at line 194 of file DefaultTool.h.

m_shearCursors

QCursor DefaultTool::m_shearCursors[8]

private

Definition at line 206 of file DefaultTool.h.

m_sizeCursors

QCursor DefaultTool::m_sizeCursors[8]

private

Definition at line 204 of file DefaultTool.h.

m_tabbedOptionWidget

DefaultToolTabbedWidget* DefaultTool::m_tabbedOptionWidget

private

Definition at line 211 of file DefaultTool.h.

m_textFlowSignalsMapper

KisSignalMapper* DefaultTool::m_textFlowSignalsMapper {0}

private

Definition at line 218 of file DefaultTool.h.

{0};

m_textOutlineHelper

QScopedPointer<KoSvgTextShapeOutlineHelper> DefaultTool::m_textOutlineHelper

private

Definition at line 198 of file DefaultTool.h.

m_textPropertyInterface

DefaultToolTextPropertiesInterface* DefaultTool::m_textPropertyInterface {0}

private

Definition at line 220 of file DefaultTool.h.

{0};

m_textTypeSignalsMapper

KisSignalMapper* DefaultTool::m_textTypeSignalsMapper {0}

private

Definition at line 217 of file DefaultTool.h.

{0};

m_transformSignalsMapper

KisSignalMapper* DefaultTool::m_transformSignalsMapper {0}

private

Definition at line 215 of file DefaultTool.h.

{0};

---

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

• plugins/tools/defaulttool/defaulttool/DefaultTool.h
• plugins/tools/defaulttool/defaulttool/DefaultTool.cpp