KoShapeRubberSelectStrategy Class Reference

#include <KoShapeRubberSelectStrategy.h>

Inheritance diagram for KoShapeRubberSelectStrategy:

Public Member Functions
KUndo2Command *	createCommand () override
void	handleMouseMove (const QPointF &mouseLocation, Qt::KeyboardModifiers modifiers) override
	KoShapeRubberSelectStrategy (KoToolBase *tool, const QPointF &clicked, bool useSnapToGrid=false)
void	paint (QPainter &painter, const KoViewConverter &converter) override
Public Member Functions inherited from KoInteractionStrategy
virtual void	cancelInteraction ()
virtual void	finishInteraction (Qt::KeyboardModifiers modifiers)=0
	KoInteractionStrategy (KoToolBase *parent)
	constructor
KoToolBase *	tool () const
virtual	~KoInteractionStrategy ()
	Destructor.

Protected Types
enum	SelectionMode { CrossingSelection , CoveringSelection }

Protected Member Functions
virtual SelectionMode	currentMode () const
	KoShapeRubberSelectStrategy (KoShapeRubberSelectStrategyPrivate &)
	constructor
QRectF	selectedRectangle () const
Protected Member Functions inherited from KoInteractionStrategy
uint	decorationThickness () const
uint	grabSensitivity () const
	Convenience function to get the global grab sensitivity.
uint	handleRadius () const
	Convenience function to get the global handle radius.
	KoInteractionStrategy (KoInteractionStrategyPrivate &)
	constructor

Additional Inherited Members
Protected Attributes inherited from KoInteractionStrategy
KoInteractionStrategyPrivate *	d_ptr

Detailed Description

This is a base class for interactions based on dragging a rectangular area on the canvas, such as selection, zooming or shape creation.

When the user selects stuff in left-to-right way, selection is in "covering" (or "containing") mode, when in "left-to-right" in "crossing" mode

Definition at line 28 of file KoShapeRubberSelectStrategy.h.

Member Enumeration Documentation

SelectionMode

enum KoShapeRubberSelectStrategy::SelectionMode

protected

Enumerator
CrossingSelection
CoveringSelection

Definition at line 52 of file KoShapeRubberSelectStrategy.h.

                       {
        CrossingSelection,
        CoveringSelection
    };

Constructor & Destructor Documentation

KoShapeRubberSelectStrategy() [1/2]

KoShapeRubberSelectStrategy::KoShapeRubberSelectStrategy	(	KoToolBase *	tool,
		const QPointF &	clicked,
		bool	useSnapToGrid = false )

Constructor that initiates the rubber select. A rubber select is basically rectangle area that the user drags out from clicked to a point later provided in the handleMouseMove() continuously showing a semi-transparent 'rubber-mat' over the objects it is about to select.

Parameters

tool	the parent tool which controls this strategy
clicked	the initial point that the user depressed (in pt).
useSnapToGrid	use the snap-to-grid settings while doing the rubberstamp.

Definition at line 19 of file KoShapeRubberSelectStrategy.cpp.

    : KoInteractionStrategy(*(new KoShapeRubberSelectStrategyPrivate(tool)))
{
    Q_D(KoShapeRubberSelectStrategy);
    d->snapGuide->enableSnapStrategies(KoSnapGuide::GridSnapping);
    d->snapGuide->enableSnapping(useSnapToGrid);
 
    d->selectRect = QRectF(d->snapGuide->snap(clicked, QFlags<Qt::KeyboardModifier>()), QSizeF(0, 0));
}

References KoSnapGuide::GridSnapping.

KoShapeRubberSelectStrategy() [2/2]

KoShapeRubberSelectStrategy::KoShapeRubberSelectStrategy ( KoShapeRubberSelectStrategyPrivate & )

protected

constructor

Member Function Documentation

createCommand()

KUndo2Command * KoShapeRubberSelectStrategy::createCommand ( )

overridevirtual

For interactions that are undo-able this method should be implemented to return such a command. Implementations should return 0 otherwise.

Returns

a command, or 0.

Implements KoInteractionStrategy.

Definition at line 103 of file KoShapeRubberSelectStrategy.cpp.

{
    return 0;
}

currentMode()

KoShapeRubberSelectStrategy::SelectionMode KoShapeRubberSelectStrategy::currentMode ( ) const

protectedvirtual

Reimplemented in KoZoomStrategy.

Definition at line 97 of file KoShapeRubberSelectStrategy.cpp.

{
    Q_D(const KoShapeRubberSelectStrategy);
    return d->selectRect.left() < d->selectRect.right() ? CoveringSelection : CrossingSelection;
}

References CoveringSelection, and CrossingSelection.

handleMouseMove()

void KoShapeRubberSelectStrategy::handleMouseMove ( const QPointF & mouseLocation, Qt::KeyboardModifiers modifiers )

overridevirtual

Extending classes should implement this method to update the selectedShapes based on the new mouse position.

Parameters

mouseLocation	the new location in pt
modifiers	OR-ed set of keys pressed.

Implements KoInteractionStrategy.

Definition at line 56 of file KoShapeRubberSelectStrategy.cpp.

{
    Q_D(KoShapeRubberSelectStrategy);
    QPointF point = d->snapGuide->snap(p, modifiers);
    if (modifiers & Qt::ControlModifier) {
        const QRectF oldDirtyRect = d->selectedRect();
        d->selectRect.moveTopLeft(d->selectRect.topLeft() - (d->lastPos - point));
        d->lastPos = point;
        d->tool->canvas()->updateCanvas(oldDirtyRect | d->selectedRect());
        return;
    }
    d->lastPos = point;
    QPointF old = d->selectRect.bottomRight();
    d->selectRect.setBottomRight(point);
    /*
        +---------------|--+
        |               |  |    We need to figure out rects A and B based on the two points. BUT
        |          old  | A|    we need to do that even if the points are switched places
        |             \ |  |    (i.e. the rect got smaller) and even if the rect is mirrored
        +---------------+  |    in either the horizontal or vertical axis.
        |       B          |
        +------------------+
                            `- point
    */
    QPointF x1 = old;
    x1.setY(d->selectRect.topLeft().y());
    qreal h1 = point.y() - x1.y();
    qreal h2 = old.y() - x1.y();
    QRectF A(x1, QSizeF(point.x() - x1.x(), point.y() < d->selectRect.top() ? qMin(h1, h2) : qMax(h1, h2)));
    A = A.normalized();
    d->tool->canvas()->updateCanvas(A);
 
    QPointF x2 = old;
    x2.setX(d->selectRect.topLeft().x());
    qreal w1 = point.x() - x2.x();
    qreal w2 = old.x() - x2.x();
    QRectF B(x2, QSizeF(point.x() < d->selectRect.left() ? qMin(w1, w2) : qMax(w1, w2), point.y() - x2.y()));
    B = B.normalized();
    d->tool->canvas()->updateCanvas(B);
}

References A, B, and p.

paint()

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

overridevirtual

Reimplement this if the action needs to draw a "blob" on the canvas; that is, a transient decoration like a rubber band.

Reimplemented from KoInteractionStrategy.

Reimplemented in SelectionInteractionStrategy.

Definition at line 29 of file KoShapeRubberSelectStrategy.cpp.

{
    Q_D(KoShapeRubberSelectStrategy);
    painter.setRenderHint(QPainter::Antialiasing, false);
 
    const QColor crossingColor(80,130,8);
    const QColor coveringColor(8,60,167);
 
    QColor selectColor(
        currentMode() == CrossingSelection ?
        crossingColor : coveringColor);
 
    selectColor.setAlphaF(0.8);
    QPen select(selectColor, decorationThickness());
    select.setCosmetic(true);
    painter.setPen(select);
 
    selectColor.setAlphaF(0.4);
    const QBrush fillBrush(selectColor);
    painter.setBrush(fillBrush);
 
    QRectF paintRect = converter.documentToView(d->selectedRect());
    paintRect = paintRect.normalized();
 
    painter.drawRect(paintRect);
}

References CrossingSelection, currentMode(), KoInteractionStrategy::decorationThickness(), and KoViewConverter::documentToView().

selectedRectangle()

QRectF KoShapeRubberSelectStrategy::selectedRectangle ( ) const

protected

Definition at line 108 of file KoShapeRubberSelectStrategy.cpp.

                                                            {
    Q_D(const KoShapeRubberSelectStrategy);
    return d->selectedRect();
}

---

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

• libs/flake/tools/KoShapeRubberSelectStrategy.h
• libs/flake/tools/KoShapeRubberSelectStrategy.cpp