KisRotateCanvasAction Class Reference

Rotate Canvas implementation of KisAbstractInputAction. More...

#include <kis_rotate_canvas_action.h>

Inheritance diagram for KisRotateCanvasAction:

Classes
class	Private

Public Types
enum	Shortcut {   RotateModeShortcut , DiscreteRotateModeShortcut , RotateLeftShortcut , RotateRightShortcut ,   RotateResetShortcut }

Public Member Functions
void	activate (int shortcut) override
void	begin (int shortcut, QEvent *event) override
void	cursorMovedAbsolute (const QPointF &startPos, const QPointF &pos) override
void	deactivate (int shortcut) override
void	end (QEvent *event) override
KisInputActionGroup	inputActionGroup (int shortcut) const override
void	inputEvent (QEvent *event) override
	KisRotateCanvasAction ()
int	priority () const override
bool	supportsHiResInputEvents (int shortcut) const override
	~KisRotateCanvasAction () override
Public Member Functions inherited from KisAbstractInputAction
virtual bool	canIgnoreModifiers () const
virtual QString	description () const
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	~KisAbstractInputAction ()

Private Attributes
Private *const	d {nullptr}

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

Rotate Canvas implementation of KisAbstractInputAction.

The Rotate Canvas action rotates the canvas.

Definition at line 18 of file kis_rotate_canvas_action.h.

Member Enumeration Documentation

Shortcut

enum KisRotateCanvasAction::Shortcut

The different behaviours for this action.

Enumerator
RotateModeShortcut	Toggle Rotate mode.
DiscreteRotateModeShortcut	Toggle Discrete Rotate mode.
RotateLeftShortcut	Rotate left by a fixed amount.
RotateRightShortcut	Rotate right by a fixed amount.
RotateResetShortcut	Reset the rotation to 0.

Definition at line 25 of file kis_rotate_canvas_action.h.

                  {
        RotateModeShortcut, 
        DiscreteRotateModeShortcut, 
        RotateLeftShortcut, 
        RotateRightShortcut, 
        RotateResetShortcut 
    };

Constructor & Destructor Documentation

KisRotateCanvasAction()

KisRotateCanvasAction::KisRotateCanvasAction ( )

explicit

Definition at line 39 of file kis_rotate_canvas_action.cpp.

    : KisAbstractInputAction("Rotate Canvas")
    , d(new Private())
{
    setName(i18n("Rotate Canvas"));
    setDescription(i18n("The <i>Rotate Canvas</i> action rotates the canvas."));
 
    QHash<QString, int> shortcuts;
    shortcuts.insert(i18n("Rotate Mode"), RotateModeShortcut);
    shortcuts.insert(i18n("Discrete Rotate Mode"), DiscreteRotateModeShortcut);
    shortcuts.insert(i18n("Rotate Left"), RotateLeftShortcut);
    shortcuts.insert(i18n("Rotate Right"), RotateRightShortcut);
    shortcuts.insert(i18n("Reset Rotation"), RotateResetShortcut);
    setShortcutIndexes(shortcuts);
}

References DiscreteRotateModeShortcut, RotateLeftShortcut, RotateModeShortcut, RotateResetShortcut, RotateRightShortcut, KisAbstractInputAction::setDescription(), KisAbstractInputAction::setName(), and KisAbstractInputAction::setShortcutIndexes().

~KisRotateCanvasAction()

KisRotateCanvasAction::~KisRotateCanvasAction ( )

override

Definition at line 55 of file kis_rotate_canvas_action.cpp.

{
    delete d;
}

References d.

Member Function Documentation

activate()

void KisRotateCanvasAction::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 65 of file kis_rotate_canvas_action.cpp.

{
    if (shortcut == DiscreteRotateModeShortcut) {
        QApplication::setOverrideCursor(KisCursor::rotateCanvasDiscreteCursor());
    } else /* if (shortcut == SmoothRotateModeShortcut) */ {
        QApplication::setOverrideCursor(KisCursor::rotateCanvasSmoothCursor());
    }
}

References DiscreteRotateModeShortcut, KisCursor::rotateCanvasDiscreteCursor(), and KisCursor::rotateCanvasSmoothCursor().

begin()

void KisRotateCanvasAction::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 80 of file kis_rotate_canvas_action.cpp.

{
    KisAbstractInputAction::begin(shortcut, event);
    d->allowRotation = false;
    d->previousAngle = 0;
    d->snapRotation = 0;
    d->touchRotation = 0;
 
    KisCanvasController *canvasController =
        dynamic_cast<KisCanvasController*>(inputManager()->canvas()->canvasController());
    KIS_SAFE_ASSERT_RECOVER_RETURN(canvasController);
 
    d->mode = (Shortcut)shortcut;
 
    switch(shortcut) {
        case RotateModeShortcut:
        case DiscreteRotateModeShortcut: {
            // If the canvas has been rotated to an angle that is not an exact multiple of DISCRETE_ANGLE_STEP,
            // we need to adjust the final discrete rotation by that angle difference.
            // trunc() is used to round the negative numbers towards zero.
            const qreal startRotation = inputManager()->canvas()->rotationAngle();
            d->snapRotation = startRotation - std::trunc(startRotation / DISCRETE_ANGLE_STEP) * DISCRETE_ANGLE_STEP;
            canvasController->beginCanvasRotation();
            d->actionStillPoint = inputManager()->canvas()->coordinatesConverter()->makeWidgetStillPoint(eventPosF(event));
            break;
        }
        case RotateLeftShortcut:
            canvasController->rotateCanvasLeft15();
            break;
        case RotateRightShortcut:
            canvasController->rotateCanvasRight15();
            break;
        case RotateResetShortcut:
            canvasController->resetCanvasRotation();
            break;
    }
}

References KisRotateCanvasAction::Private::actionStillPoint, KisRotateCanvasAction::Private::allowRotation, KisAbstractInputAction::begin(), KisCanvasController::beginCanvasRotation(), KisInputManager::canvas(), KoCanvasBase::canvasController(), KisCanvas2::coordinatesConverter, d, DISCRETE_ANGLE_STEP, DiscreteRotateModeShortcut, KisAbstractInputAction::eventPosF(), KisAbstractInputAction::inputManager, KIS_SAFE_ASSERT_RECOVER_RETURN, KisCoordinatesConverter::makeWidgetStillPoint(), KisRotateCanvasAction::Private::mode, KisRotateCanvasAction::Private::previousAngle, KisCanvasController::resetCanvasRotation(), KisCanvasController::rotateCanvasLeft15(), KisCanvasController::rotateCanvasRight15(), RotateLeftShortcut, RotateModeShortcut, RotateResetShortcut, RotateRightShortcut, KisCanvas2::rotationAngle(), KisRotateCanvasAction::Private::snapRotation, and KisRotateCanvasAction::Private::touchRotation.

cursorMovedAbsolute()

void KisRotateCanvasAction::cursorMovedAbsolute ( const QPointF & startPos, const QPointF & pos )

overridevirtual

Reimplemented from KisAbstractInputAction.

Definition at line 136 of file kis_rotate_canvas_action.cpp.

{
    if (d->mode == RotateResetShortcut) {
        return;
    }
 
    const KisCoordinatesConverter *converter = inputManager()->canvas()->coordinatesConverter();
    const QPointF centerPoint = converter->flakeToWidget(converter->flakeCenterPoint());
    const QPointF startPoint = startPos - centerPoint;
    const QPointF newPoint = pos - centerPoint;
 
    const qreal oldAngle = atan2(startPoint.y(), startPoint.x());
    const qreal newAngle = atan2(newPoint.y(), newPoint.x());
 
    qreal newRotation = (180 / M_PI) * (newAngle - oldAngle);
 
    if (d->mode == DiscreteRotateModeShortcut) {
        // Do not snap unless the user rotated half-way in the desired direction.
        if (qAbs(newRotation) > 0.5 * DISCRETE_ANGLE_STEP || d->allowRotation) {
            d->allowRotation = true;
            newRotation = qRound((newRotation + d->snapRotation) / DISCRETE_ANGLE_STEP) * DISCRETE_ANGLE_STEP - d->snapRotation;
        } else {
            newRotation = 0.0;
        }
    }
 
    KisCanvasController *canvasController =
        dynamic_cast<KisCanvasController*>(inputManager()->canvas()->canvasController());
    KIS_SAFE_ASSERT_RECOVER_RETURN(canvasController);
    canvasController->rotateCanvas(newRotation);
}

References KisRotateCanvasAction::Private::allowRotation, KisInputManager::canvas(), KoCanvasBase::canvasController(), KisCanvas2::coordinatesConverter, d, DISCRETE_ANGLE_STEP, DiscreteRotateModeShortcut, KisCoordinatesConverter::flakeCenterPoint(), KisCoordinatesConverter::flakeToWidget(), KisAbstractInputAction::inputManager, KIS_SAFE_ASSERT_RECOVER_RETURN, M_PI, KisRotateCanvasAction::Private::mode, KisCanvasController::rotateCanvas(), RotateResetShortcut, and KisRotateCanvasAction::Private::snapRotation.

deactivate()

void KisRotateCanvasAction::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 74 of file kis_rotate_canvas_action.cpp.

{
    Q_UNUSED(shortcut);
    QApplication::restoreOverrideCursor();
}

end()

void KisRotateCanvasAction::end ( QEvent * event )

overridevirtual

End the action.

Parameters

event

The mouse event that has finished this action. Is null for keyboard-activated actions.

Reimplemented from KisAbstractInputAction.

Definition at line 118 of file kis_rotate_canvas_action.cpp.

{
    Q_UNUSED(event);
 
    KisCanvasController *canvasController =
        dynamic_cast<KisCanvasController*>(inputManager()->canvas()->canvasController());
    KIS_SAFE_ASSERT_RECOVER_RETURN(canvasController);
 
    switch(d->mode) {
    case RotateModeShortcut:
    case DiscreteRotateModeShortcut:
        canvasController->endCanvasRotation();
        break;
    default:
        break;
    }
}

References KisInputManager::canvas(), KoCanvasBase::canvasController(), d, DiscreteRotateModeShortcut, KisCanvasController::endCanvasRotation(), KisAbstractInputAction::inputManager, KIS_SAFE_ASSERT_RECOVER_RETURN, KisRotateCanvasAction::Private::mode, and RotateModeShortcut.

inputActionGroup()

KisInputActionGroup KisRotateCanvasAction::inputActionGroup ( int shortcut ) const

overridevirtual

Returns

the group of the action the specified shortcut belongs to

Reimplemented from KisAbstractInputAction.

Definition at line 247 of file kis_rotate_canvas_action.cpp.

{
    Q_UNUSED(shortcut);
    return ViewTransformActionGroup;
}

References ViewTransformActionGroup.

inputEvent()

void KisRotateCanvasAction::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 168 of file kis_rotate_canvas_action.cpp.

{
    switch (event->type()) {
        case QEvent::NativeGesture: {
            QNativeGestureEvent *gevent = static_cast<QNativeGestureEvent*>(event);
            KisCanvas2 *canvas = inputManager()->canvas();
            KisCanvasController *controller = static_cast<KisCanvasController*>(canvas->canvasController());
 
            const float angle = gevent->value();
            QPoint widgetPos = canvas->canvasWidget()->mapFromGlobal(gevent->globalPos());
 
            KoViewTransformStillPoint adjustedStillPoint = d->actionStillPoint;
            adjustedStillPoint.second = widgetPos;
 
            controller->rotateCanvas(angle, adjustedStillPoint, true);
            return;
        }
        case QEvent::TouchUpdate: {
            QTouchEvent *touchEvent = static_cast<QTouchEvent*>(event);
 
            if (touchEvent->touchPoints().count() != 2)
                break;
 
            QTouchEvent::TouchPoint tp0 = touchEvent->touchPoints().at(0);
            QTouchEvent::TouchPoint tp1 = touchEvent->touchPoints().at(1);
 
            if (tp0.state() == Qt::TouchPointReleased ||
                tp1.state() == Qt::TouchPointReleased)
            {
                // Workaround: on some devices, the coordinates of TouchPoints
                // in state TouchPointReleased are not reliable, and can
                // "jump" by a significant distance. So we just stop handling
                // the rotation as soon as the user's finger leaves the tablet.
                break;
            }
 
            QPointF p0 = tp0.pos();
            QPointF p1 = tp1.pos();
 
            if ((p0-p1).manhattanLength() < 10)
            {
                // The TouchPoints are too close together. Don't update the
                // rotation as the angle will likely be off. This also deals
                // with a glitch where a newly pressed TouchPoint incorrectly
                // reports the existing TouchPoint's coordinates instead of its
                // own.
                break;
            }
 
            // high school (y2 - y1) / (x2 - x1)
            QPointF slope = p1 - p0;
            qreal newAngle = atan2(slope.y(), slope.x());
 
            // We must have the previous angle measurement to calculate the delta.
            if (d->allowRotation)
            {
                qreal delta = (180 / M_PI) * (newAngle - d->previousAngle);
 
                // Rotate by the effective angle from the beginning of the action.
                d->touchRotation += delta;
 
                KisCanvas2 *canvas = inputManager()->canvas();
                KisCanvasController *controller = static_cast<KisCanvasController*>(canvas->canvasController());
                controller->rotateCanvas(d->touchRotation);
            }
            else
            {
                d->allowRotation = true;
            }
 
            d->previousAngle = newAngle;
            return;
        }
        default:
            break;
    }
    KisAbstractInputAction::inputEvent(event);
}

References KisRotateCanvasAction::Private::actionStillPoint, KisRotateCanvasAction::Private::allowRotation, Private::canvas, KisInputManager::canvas(), KoCanvasBase::canvasController(), KisCanvas2::canvasWidget, d, KisAbstractInputAction::inputEvent(), KisAbstractInputAction::inputManager, M_PI, p0, p1, KisRotateCanvasAction::Private::previousAngle, KisCanvasController::rotateCanvas(), and KisRotateCanvasAction::Private::touchRotation.

priority()

int KisRotateCanvasAction::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 60 of file kis_rotate_canvas_action.cpp.

{
    return 3;
}

supportsHiResInputEvents()

bool KisRotateCanvasAction::supportsHiResInputEvents ( int shortcut ) const

overridevirtual

Returns true if the action can handle HiRes flow of move events which is generated by the tablet. If the function returns false, some of the events will be dropped or postponed. For most of the actions in Krita (except of real painting) it is perfectly acceptable, so 'false' is the default value.

Reimplemented from KisAbstractInputAction.

Definition at line 253 of file kis_rotate_canvas_action.cpp.

{
    Q_UNUSED(shortcut);
    return true;
}

Member Data Documentation

d

Private* const KisRotateCanvasAction::d {nullptr}

private

Definition at line 49 of file kis_rotate_canvas_action.h.

{nullptr};

---

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

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