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
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	slotChangeTextType (int index)
void	slotResetMeshGradientState ()

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
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 40 of file DefaultTool.h.

Member Enumeration Documentation

CanvasResource

enum DefaultTool::CanvasResource

Enumerator
HotPosition

Definition at line 52 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 415 of file DefaultTool.cpp.

    : KoInteractionTool(canvas)
    , m_lastHandle(KoFlake::NoHandle)
    , m_hotPosition(KoFlake::TopLeft)
    , m_mouseWasInsideHandles(false)
    , 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()));
    }
}

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

~DefaultTool()

DefaultTool::~DefaultTool ( )

override

Definition at line 476 of file DefaultTool.cpp.

{
}

Member Function Documentation

activate

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

overrideslot

Definition at line 1201 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)));
 
    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(), connect(), m_alignSignalsMapper, m_booleanSignalsMapper, m_distributeSignalsMapper, m_lastHandle, m_mouseWasInsideHandles, m_tabbedOptionWidget, m_textPropertyInterface, m_textTypeSignalsMapper, m_transformSignalsMapper, KoFlake::NoHandle, KoToolBase::repaintDecorations(), selectionAlign(), selectionBooleanOp(), selectionBringToFront(), selectionDistribute(), selectionGroup(), selectionMoveDown(), selectionMoveUp(), selectionSendToBack(), selectionSplitShapes(), selectionTransform(), selectionUngroup(), KisTextPropertiesManager::setTextPropertiesInterface(), slotChangeTextType(), DefaultToolTextPropertiesInterface::slotSelectionChanged(), KisViewManager::textPropertyManager(), updateActions(), KoToolBase::useCursor(), and KisCanvas2::viewManager().

addMappedAction()

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

private

Definition at line 556 of file DefaultTool.cpp.

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

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

addTransformActions()

void DefaultTool::addTransformActions ( QMenu * menu ) const

protected

Definition at line 1971 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 1674 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 1053 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 1643 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(), connect(), KoToolBase::isActivated(), m_tabbedOptionWidget, slotActivateEditFillGradient(), slotActivateEditFillMeshGradient(), slotActivateEditStrokeGradient(), and slotResetMeshGradientState().

createStrategy()

KoInteractionStrategy * DefaultTool::createStrategy ( KoPointerEvent * event )

overrideprotectedvirtual

Implements KoInteractionTool.

Definition at line 1682 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 1249 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);
 
    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_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 1035 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();
    }
 
    return dirtyRect;
}

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

deleteSelection()

void DefaultTool::deleteSelection ( )

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Reimplemented in ToolReferenceImages.

Definition at line 1065 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 1098 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 1982 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 1113 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 938 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 882 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 1016 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 1106 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 963 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 910 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 895 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;
    }
 
    KoInteractionTool::mousePressEvent(event);
    updateCursor();
}

References KoToolBase::canvas(), isValidForCurrentLayer(), KisFloatingMessage::Medium, KoInteractionTool::mousePressEvent(), KisViewManager::showFloatingMessage(), 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 957 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 980 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 846 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);
    }
 
    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, KisViewManager::nodeManager(), KoSnapGuide::paint(), KoInteractionTool::paint(), selection(), KoCanvasBase::snapGuide, and KisCanvas2::viewManager().

paste()

bool DefaultTool::paste ( )

overridevirtual

reimplemented

Reimplemented from KoToolBase.

Definition at line 1079 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 1914 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"));
    }
 
    return m_contextMenu.data();
}

References KoToolBase::action(), and m_contextMenu.

recalcSelectionBox()

void DefaultTool::recalcSelectionBox ( KoSelection * selection )

private

Definition at line 1166 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 609 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 1085 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 1909 of file DefaultTool.cpp.

{
    return m_selectionHandler;
}

References m_selectionHandler.

selectionAlign

void DefaultTool::selectionAlign ( int _align )

privateslot

Definition at line 1555 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 1427 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 1605 of file DefaultTool.cpp.

{
    selectionReorder(KoShapeReorderCommand::BringToFront);
}

References KoShapeReorderCommand::BringToFront, and selectionReorder().

selectionDistribute

void DefaultTool::selectionDistribute ( int _distribute )

privateslot

Definition at line 1587 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 1291 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 1615 of file DefaultTool.cpp.

{
    selectionReorder(KoShapeReorderCommand::LowerShape);
}

References KoShapeReorderCommand::LowerShape, and selectionReorder().

selectionMoveUp

void DefaultTool::selectionMoveUp ( )

privateslot

Definition at line 1610 of file DefaultTool.cpp.

{
    selectionReorder(KoShapeReorderCommand::RaiseShape);
}

References KoShapeReorderCommand::RaiseShape, and selectionReorder().

selectionReorder()

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

private

Definition at line 1625 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 1620 of file DefaultTool.cpp.

{
    selectionReorder(KoShapeReorderCommand::SendToBack);
}

References selectionReorder(), and KoShapeReorderCommand::SendToBack.

selectionSplitShapes

void DefaultTool::selectionSplitShapes ( )

privateslot

Definition at line 1520 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 1349 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 1317 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 563 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);
 
    m_contextMenu.reset(new QMenu());
}

References addMappedAction(), 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_textTypeSignalsMapper, m_transformSignalsMapper, KoSvgTextShape::PreformattedText, KoSvgTextShape::PrePositionedText, 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 891 of file DefaultTool.cpp.

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

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

slotActivateEditFillGradient

void DefaultTool::slotActivateEditFillGradient ( bool value )

privateslot

Definition at line 480 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 504 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(), connect(), KoFlake::Fill, m_tabbedOptionWidget, meshgradientHandleSelected(), KoInteractionTool::removeInteractionFactory(), and value().

slotActivateEditStrokeGradient

void DefaultTool::slotActivateEditStrokeGradient ( bool value )

privateslot

Definition at line 492 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().

slotChangeTextType

void DefaultTool::slotChangeTextType ( int index )

privateslot

Definition at line 524 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());
            }
        }
    }
 
    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, koSelection(), KoSelection::selectedShapes(), KoCanvasBase::selectedShapesProxy(), KUndo2Command::setText(), KUndo2Command::text(), and KoSvgTextShape::textType().

slotResetMeshGradientState

void DefaultTool::slotResetMeshGradientState ( )

privateslot

Definition at line 519 of file DefaultTool.cpp.

{
    m_selectedMeshHandle = KoShapeMeshGradientHandles::Handle();
}

References m_selectedMeshHandle.

updateActions

void DefaultTool::updateActions ( )

protectedslot

Update actions on selection change.

Definition at line 1804 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);
 
    updateDistinctiveActions(editableShapes);
 
    Q_EMIT selectionChanged(editableShapes.size());
}

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

updateCursor()

void DefaultTool::updateCursor ( )

private

Definition at line 728 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 1857 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;
    Q_FOREACH (KoShape *shape, editableShapes) {
        KoSvgTextShape *textShape = dynamic_cast<KoSvgTextShape *>(shape);
        if (textShape) {
            if (textShape->textType() != KoSvgTextShape::PreformattedText && !enablePreformatted) {
                enablePreformatted = true;
            }
            if (textShape && textShape->textType() != KoSvgTextShape::PrePositionedText && !enablePrePositioned) {
                enablePrePositioned = true;
            }
            if (textShape && textShape->textType() != KoSvgTextShape::PrePositionedText && !enableInlineWrapped) {
                enableInlineWrapped = true;
            }
        }
    }
    action("text_type_preformatted")->setEnabled(enablePreformatted);
    action("text_type_pre_positioned")->setEnabled(enablePrePositioned);
    action("text_type_inline_wrap")->setEnabled(enableInlineWrapped);
}

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

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

{
    return true;
}

Friends And Related Symbol Documentation

SelectionHandler

friend class SelectionHandler

friend

Definition at line 198 of file DefaultTool.h.

SelectionInteractionStrategy

friend class SelectionInteractionStrategy

friend

Definition at line 145 of file DefaultTool.h.

Member Data Documentation

m_alignSignalsMapper

KisSignalMapper* DefaultTool::m_alignSignalsMapper {0}

private

Definition at line 202 of file DefaultTool.h.

{0};

m_angle

qreal DefaultTool::m_angle

private

Definition at line 196 of file DefaultTool.h.

m_booleanSignalsMapper

KisSignalMapper* DefaultTool::m_booleanSignalsMapper {0}

private

Definition at line 205 of file DefaultTool.h.

{0};

m_contextMenu

QScopedPointer<QMenu> DefaultTool::m_contextMenu

protected

Definition at line 156 of file DefaultTool.h.

m_decorator

QScopedPointer<SelectionDecorator> DefaultTool::m_decorator

private

Definition at line 187 of file DefaultTool.h.

m_distributeSignalsMapper

KisSignalMapper* DefaultTool::m_distributeSignalsMapper {0}

private

Definition at line 203 of file DefaultTool.h.

{0};

m_hotPosition

KoFlake::AnchorPosition DefaultTool::m_hotPosition

private

Definition at line 181 of file DefaultTool.h.

m_hoveredMeshHandle

KoShapeMeshGradientHandles::Handle DefaultTool::m_hoveredMeshHandle

private

Definition at line 190 of file DefaultTool.h.

m_lastHandle

KoFlake::SelectionHandle DefaultTool::m_lastHandle

private

Definition at line 180 of file DefaultTool.h.

m_lastPoint

QPointF DefaultTool::m_lastPoint

private

Definition at line 185 of file DefaultTool.h.

m_mouseWasInsideHandles

bool DefaultTool::m_mouseWasInsideHandles

private

Definition at line 182 of file DefaultTool.h.

m_rotateCursors

QCursor DefaultTool::m_rotateCursors[8]

private

Definition at line 194 of file DefaultTool.h.

m_selectedMeshHandle

KoShapeMeshGradientHandles::Handle DefaultTool::m_selectedMeshHandle

private

Definition at line 189 of file DefaultTool.h.

m_selectionBox

QPointF DefaultTool::m_selectionBox[8]

private

Definition at line 183 of file DefaultTool.h.

m_selectionHandler

KoToolSelection* DefaultTool::m_selectionHandler

private

Definition at line 197 of file DefaultTool.h.

m_selectionOutline

QPolygonF DefaultTool::m_selectionOutline

private

Definition at line 184 of file DefaultTool.h.

m_shearCursors

QCursor DefaultTool::m_shearCursors[8]

private

Definition at line 195 of file DefaultTool.h.

m_sizeCursors

QCursor DefaultTool::m_sizeCursors[8]

private

Definition at line 193 of file DefaultTool.h.

m_tabbedOptionWidget

DefaultToolTabbedWidget* DefaultTool::m_tabbedOptionWidget

private

Definition at line 200 of file DefaultTool.h.

m_textPropertyInterface

DefaultToolTextPropertiesInterface* DefaultTool::m_textPropertyInterface {0}

private

Definition at line 208 of file DefaultTool.h.

{0};

m_textTypeSignalsMapper

KisSignalMapper* DefaultTool::m_textTypeSignalsMapper {0}

private

Definition at line 206 of file DefaultTool.h.

{0};

m_transformSignalsMapper

KisSignalMapper* DefaultTool::m_transformSignalsMapper {0}

private

Definition at line 204 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