KisZoomAndRotateAction Class Reference

This class handles both rotation and zooming operation. This is separate from Zoom and Rotate operation applied individually because the order of transformation is different. More...

#include <kis_zoom_and_rotate_action.h>

Inheritance diagram for KisZoomAndRotateAction:

Classes
class	Private

Public Types
enum	Shortcut { ContinuousRotateMode , DiscreteRotateMode }

Public Member Functions
void	activate (int shortcut) override
void	begin (int shortcut, QEvent *event) override
void	cursorMovedAbsolute (const QPointF &lastPos, const QPointF &pos) override
void	deactivate (int shortcut) override
KisInputActionGroup	inputActionGroup (int shortcut) const override
void	inputEvent (QEvent *event) override
	KisZoomAndRotateAction ()
int	priority () const override
	~KisZoomAndRotateAction ()
Public Member Functions inherited from KisAbstractInputAction
virtual bool	canIgnoreModifiers () const
virtual QString	description () const
virtual void	end (QEvent *event)
virtual QString	id () const
virtual bool	isAvailable () const
virtual bool	isShortcutRequired (int shortcut) const
	KisAbstractInputAction (const QString &id)
virtual QString	name () const
virtual QHash< QString, int >	shortcutIndexes () const
virtual bool	supportsHiResInputEvents (int shortcut) const
virtual	~KisAbstractInputAction ()

Private Member Functions
qreal	canvasRotationAngle (QPointF p0, QPointF p1)

Private Attributes
const QScopedPointer< Private >	d

Additional Inherited Members
Public Attributes inherited from KisAbstractInputAction
QString	description
QString	id
QHash< QString, int >	indexes
QPointF	lastCursorPosition
QString	name
QPointF	startCursorPosition
Static Public Attributes inherited from KisAbstractInputAction
static KisInputManager *	inputManager
Protected Member Functions inherited from KisAbstractInputAction
virtual void	cursorMoved (const QPointF &lastPos, const QPointF &pos)
QPoint	eventPos (const QEvent *event)
QPointF	eventPosF (const QEvent *event)
KisInputManager *	inputManager () const
void	setDescription (const QString &description)
void	setName (const QString &name)
void	setShortcutIndexes (const QHash< QString, int > &indexes)

Detailed Description

This class handles both rotation and zooming operation. This is separate from Zoom and Rotate operation applied individually because the order of transformation is different.

Definition at line 19 of file kis_zoom_and_rotate_action.h.

Member Enumeration Documentation

Shortcut

enum KisZoomAndRotateAction::Shortcut

Enumerator
ContinuousRotateMode
DiscreteRotateMode

Definition at line 22 of file kis_zoom_and_rotate_action.h.

                  {
        ContinuousRotateMode,
        DiscreteRotateMode,
    };

Constructor & Destructor Documentation

KisZoomAndRotateAction()

KisZoomAndRotateAction::KisZoomAndRotateAction

(

)

Definition at line 35 of file kis_zoom_and_rotate_action.cpp.

    : KisAbstractInputAction ("Zoom and Rotate Canvas")
    , d(new Private)
{
    setName(i18n("Zoom and Rotate Canvas"));
    QHash<QString, int> shortcuts;
    shortcuts.insert(i18n("Rotate Mode"), ContinuousRotateMode);
    shortcuts.insert(i18n("Discrete Rotate Mode"), DiscreteRotateMode);
    setShortcutIndexes(shortcuts);
}

References ContinuousRotateMode, DiscreteRotateMode, KisAbstractInputAction::setName(), and KisAbstractInputAction::setShortcutIndexes().

~KisZoomAndRotateAction()

KisZoomAndRotateAction::~KisZoomAndRotateAction

(

)

Definition at line 46 of file kis_zoom_and_rotate_action.cpp.

{
}

Member Function Documentation

activate()

void KisZoomAndRotateAction::activate ( int shortcut )

overridevirtual

The method is called when the action is yet to be started, that is, e.g. the user has pressed all the modifiers for the action but hasn't started painting yet. This method is a right place to show the user what is going to happen, e.g. change the cursor.

Reimplemented from KisAbstractInputAction.

Definition at line 55 of file kis_zoom_and_rotate_action.cpp.

{
    Q_UNUSED(shortcut);
}

begin()

void KisZoomAndRotateAction::begin ( int shortcut, QEvent * event )

overridevirtual

Begin the action.

Parameters

shortcut	The index of the behaviour to trigger.
event	The mouse event that has triggered this action. Is null for keyboard-activated actions.

Reimplemented from KisAbstractInputAction.

Definition at line 65 of file kis_zoom_and_rotate_action.cpp.

{
    QTouchEvent *touchEvent = dynamic_cast<QTouchEvent *>(event);
 
    if (touchEvent && touchEvent->touchPoints().size() > 0) {
        d->shortcutIndex = shortcut;
        d->lastPosition = touchEvent->touchPoints().at(0).pos();
        d->lastDistance = 0;
        d->previousAngle = 0;
        d->initialReferenceAngle = 0;
        d->accumRotationAngle = 0;
        d->actionStillPoint = inputManager()->canvas()->coordinatesConverter()->makeWidgetStillPoint(d->lastPosition);
    }
}

References KisInputManager::canvas(), KisCanvas2::coordinatesConverter, d, KisAbstractInputAction::inputManager, and KisCoordinatesConverter::makeWidgetStillPoint().

canvasRotationAngle()

qreal KisZoomAndRotateAction::canvasRotationAngle ( QPointF p0, QPointF p1 )

private

Definition at line 133 of file kis_zoom_and_rotate_action.cpp.

{
    const QPointF slope = p1 - p0;
    const qreal currentAngle = std::atan2(slope.y(), slope.x());
 
    switch (d->shortcutIndex) {
    case ContinuousRotateMode: {
        if (!d->previousAngle) {
            d->previousAngle = currentAngle;
            return 0;
        }
        qreal rotationAngle = (180 / M_PI) * (currentAngle - d->previousAngle);
        d->previousAngle = currentAngle;
 
        KisCanvas2 *canvas = inputManager()->canvas();
        KisCanvasController *controller = static_cast<KisCanvasController *>(canvas->canvasController());
        const qreal canvasAnglePostRotation = controller->rotation() + rotationAngle;
        const qreal snapDelta = angleForSnapping(canvasAnglePostRotation);
        // we snap the canvas to an angle that is a multiple of 45
        if (abs(snapDelta) <= 2 && abs(d->accumRotationAngle) <= 2) {
            // accumulate the relative angle of finger from the point when we started snapping
            d->accumRotationAngle += rotationAngle;
            rotationAngle = rotationAngle - snapDelta;
        } else {
            // snap the canvas out using the accumulated angle
            rotationAngle += d->accumRotationAngle;
            d->accumRotationAngle = 0;
        }
 
        return rotationAngle;
    }
    case DiscreteRotateMode: {
        if (!d->initialReferenceAngle) {
            d->initialReferenceAngle = currentAngle;
            return 0;
        }
        qreal rotationAngle = 0;
        const qreal relativeAngle = (180 / M_PI) * (currentAngle - d->initialReferenceAngle);
        const qreal rotationThreshold = 15;
 
        // if the canvas is moved in either direction with an angle greater than the threshold, we rotate the canvas in
        // that direction by 15°.
        if (std::abs(relativeAngle) >= rotationThreshold && std::abs(relativeAngle) <= (360 - rotationThreshold)) {
            // set reference as currentAngle to check if we go beyond the threshold next time
            d->initialReferenceAngle = currentAngle;
 
            if (std::abs(relativeAngle) <= 180) {
                rotationAngle = KisAlgebra2D::copysign(15.0, relativeAngle);
            } else {
                // if we're over 180, it means the canvas has to be rotated in the opposite direction of the current
                // angle. E.g if the relative angle is +341° then we move the canvas by -15° (because the actual effect
                // is 341 - 360 = -19°  on the original theta).
                rotationAngle = KisAlgebra2D::copysign(15.0, -relativeAngle);
            }
        }
        return rotationAngle;
    }
    default:
        qWarning() << "KisZoomAndRotateAction: Unrecognized shortcut" << d->shortcutIndex;
        return 0;
    }
}

References angleForSnapping(), Private::canvas, KisInputManager::canvas(), KoCanvasBase::canvasController(), ContinuousRotateMode, KisAlgebra2D::copysign(), d, DiscreteRotateMode, KisAbstractInputAction::inputManager, M_PI, p0, p1, and KisCanvasController::rotation().

cursorMovedAbsolute()

void KisZoomAndRotateAction::cursorMovedAbsolute ( const QPointF & lastPos, const QPointF & pos )

overridevirtual

Reimplemented from KisAbstractInputAction.

Definition at line 80 of file kis_zoom_and_rotate_action.cpp.

{
}

deactivate()

void KisZoomAndRotateAction::deactivate ( int shortcut )

overridevirtual

The method is called when the action is not a candidate for the starting anymore. The action should revert everything that was done in activate() method.

See also

activate()

Reimplemented from KisAbstractInputAction.

Definition at line 60 of file kis_zoom_and_rotate_action.cpp.

{
    Q_UNUSED(shortcut);
}

inputActionGroup()

KisInputActionGroup KisZoomAndRotateAction::inputActionGroup ( int shortcut ) const

overridevirtual

Returns

the group of the action the specified shortcut belongs to

Reimplemented from KisAbstractInputAction.

Definition at line 127 of file kis_zoom_and_rotate_action.cpp.

{
    Q_UNUSED(shortcut);
    return ViewTransformActionGroup;
}

References ViewTransformActionGroup.

inputEvent()

void KisZoomAndRotateAction::inputEvent ( QEvent * event )

overridevirtual

Process an input event.

By default handles MouseMove events and passes the data to a convenience cursorMoved() method

Parameters

event

An event to process.

Reimplemented from KisAbstractInputAction.

Definition at line 93 of file kis_zoom_and_rotate_action.cpp.

{
    switch (event->type()) {
    case QEvent::TouchUpdate: {
        QTouchEvent *tevent = dynamic_cast<QTouchEvent *>(event);
        if (tevent && tevent->touchPoints().size() > 1) {
 
            const QPointF p0 = tevent->touchPoints().at(0).pos();
            const QPointF p1 = tevent->touchPoints().at(1).pos();
 
            const qreal rotationAngle = canvasRotationAngle(p0, p1);
            const float dist = QLineF(p0, p1).length();
            const float scaleDelta = qFuzzyCompare(1.0f, 1.0f + d->lastDistance) ? 1.f : dist / d->lastDistance;
 
            KisCanvas2 *canvas = inputManager()->canvas();
            KisCanvasController *controller = static_cast<KisCanvasController *>(canvas->canvasController());
            const qreal newZoom = canvas->viewConverter()->zoom() * scaleDelta;
            KoViewTransformStillPoint adjustedStillPoint = d->actionStillPoint;
            adjustedStillPoint.second = p0;
            controller->setZoom(KoZoomMode::ZOOM_CONSTANT, newZoom, adjustedStillPoint);
            controller->rotateCanvas(rotationAngle, adjustedStillPoint);
 
            d->lastPosition = p0;
            d->lastDistance = dist;
 
            return;
        }
    }
    default:
        break;
    }
    KisAbstractInputAction::inputEvent(event);
}

References Private::canvas, KisInputManager::canvas(), KoCanvasBase::canvasController(), canvasRotationAngle(), d, KisAbstractInputAction::inputEvent(), KisAbstractInputAction::inputManager, p0, p1, qFuzzyCompare(), KisCanvasController::rotateCanvas(), KoCanvasControllerWidget::setZoom(), KisCanvas2::viewConverter(), KoViewConverter::zoom(), and KoZoomMode::ZOOM_CONSTANT.

priority()

int KisZoomAndRotateAction::priority ( ) const

overridevirtual

The priority for this action.

Priority determines how "important" the action is and is used to resolve conflicts when multiple actions can be activated.

Reimplemented from KisAbstractInputAction.

Definition at line 50 of file kis_zoom_and_rotate_action.cpp.

{
    return 5;
}

Member Data Documentation

d

const QScopedPointer<Private> KisZoomAndRotateAction::d

private

Definition at line 44 of file kis_zoom_and_rotate_action.h.

---

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

• libs/ui/input/kis_zoom_and_rotate_action.h
• libs/ui/input/kis_zoom_and_rotate_action.cpp