#include <kis_shortcut_matcher.h>

Inheritance diagram for KisShortcutMatcher:

Classes
struct	RecursionGuard

struct	RecursionNotifier

Public Member Functions
bool	actionsSuppressed () const

bool	actionsSuppressedIgnoreFocus () const

void	addShortcut (KisNativeGestureShortcut *shortcut)

void	addShortcut (KisSingleActionShortcut *shortcut)

void	addShortcut (KisStrokeShortcut *shortcut)

void	addShortcut (KisTouchShortcut *shortcut)

bool	autoRepeatedKeyPressed (Qt::Key key)

bool	buttonPressed (Qt::MouseButton button, QEvent *event)

bool	buttonReleased (Qt::MouseButton button, QEvent *event)

void	clearShortcuts ()

QVector< Qt::Key >	debugPressedKeys () const

void	enterEvent ()

void	handlePolledKeys (const QVector< Qt::Key > &keys)

bool	hasPolledKeys ()

bool	hasRunningShortcut () const

bool	hasTouchHoldShortcut () const

bool	KeyboardActionsSuppressed () const

bool	keyPressed (Qt::Key key)

bool	keyReleased (Qt::Key key)

	KisShortcutMatcher ()

void	leaveEvent ()

void	lostFocusEvent (const QPointF &localPos)

bool	nativeGestureBeginEvent (QNativeGestureEvent *event)

bool	nativeGestureEndEvent (QNativeGestureEvent *event)

bool	nativeGestureEvent (QNativeGestureEvent *event)

bool	pointerMoved (QEvent *event)

	Private ()

void	reinitialize ()

void	reinitializeButtons ()

bool	sanityCheckModifiersCorrectness (Qt::KeyboardModifiers modifiers) const

void	setInputActionGroupsMaskCallback (std::function< KisInputActionGroupsMask()> func)

bool	supportsHiResInputEvents ()

void	suppressAllActions (bool value)

void	suppressAllKeyboardActions (bool value)

void	suppressConflictingKeyActions (const QVector< QKeySequence > &shortcuts)

void	toolHasBeenActivated ()

bool	touchBeginEvent (QTouchEvent *event)

void	touchCancelEvent (QTouchEvent *event, const QPointF &localPos)

bool	touchEndEvent (QTouchEvent *event)

bool	touchHoldBeginEvent (QTouchEvent *event)

bool	touchUpdateEvent (QTouchEvent *event)

bool	wheelEvent (KisSingleActionShortcut::WheelAction wheelAction, QWheelEvent *event)

	~KisShortcutMatcher ()

	~Private ()

Public Attributes
std::function< KisInputActionGroupsMask()>	actionGroupMask

QScopedPointer< QEvent >	bestCandidateTouchEvent

int	brokenByRecursion = 0

QSet< Qt::MouseButton >	buttons

QList< KisStrokeShortcut * >	candidateShortcuts

bool	cursorEntered

bool	isTouchDragDetected {false}

bool	isTouchHeld {false}

QSet< Qt::Key >	keys

QList< QTouchEvent::TouchPoint >	lastTouchPoints

int	matchingIteration {0}

int	maxTouchPoints {0}

KisNativeGestureShortcut *	nativeGestureShortcut

QList< KisNativeGestureShortcut * >	nativeGestureShortcuts

QSet< Qt::Key >	polledKeys

KisStrokeShortcut *	readyShortcut

int	recursiveCounter = 0

KisStrokeShortcut *	runningShortcut

QList< KisSingleActionShortcut * >	singleActionShortcuts

QList< KisStrokeShortcut * >	strokeShortcuts

bool	suppressAllActions

bool	suppressAllKeyboardActions

QSet< KisSingleActionShortcut * >	suppressedSingleActionShortcuts

KisTouchShortcut *	touchShortcut

QList< KisTouchShortcut * >	touchShortcuts

Static Public Attributes
static constexpr int	TOUCH_SLOP_SQUARED = 16 * 16

Private Member Functions
void	fireReadyTouchShortcut (QTouchEvent *event)

void	forceDeactivateAllActions ()

void	forceEndRunningShortcut (const QPointF &localPos)

KisTouchShortcut *	matchTouchShortcut (QTouchEvent *event)

bool	matchTouchShortcutBasedOnState (QTouchEvent event, KisTouchShortcut shortcut)

void	prepareReadyShortcuts ()

void	reset ()

void	reset (QString msg)

void	setMaxTouchPointEvent (QTouchEvent *event)

void	tryActivateReadyShortcut ()

bool	tryEndNativeGestureShortcut (QNativeGestureEvent *event)

bool	tryEndRunningShortcut (Qt::MouseButton button, QEvent *event)

bool	tryEndTouchShortcut (QTouchEvent *event)

bool	tryRunNativeGestureShortcut (QNativeGestureEvent *event)

bool	tryRunReadyShortcut (Qt::MouseButton button, QEvent *event)

template<typename T , typename U >
bool	tryRunSingleActionShortcutImpl (T param, U *event, const QSet< Qt::Key > &keysState, bool keyboard=true)

bool	tryRunTouchShortcut (QTouchEvent *event)

bool	tryRunWheelShortcut (KisSingleActionShortcut::WheelAction wheelAction, QWheelEvent *event)

Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
Private *const	m_d

Private Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Friends
class	KisInputManagerTest

Detailed Description

The class that manages connections between shortcuts and actions.

It processes input events and generates state transitions for the actions basing on the data, represented by the shortcuts.

The class works with two types of actions: long running (represented by KisStrokeShortcuts) and "atomic" (KisSingleActionShortcut). The former one involves some long interaction with the user by means of a mouse cursor or a tablet, the latter one simple action like "Zoom 100%" or "Reset Rotation".

The single action shortcuts are handled quite easily. The matcher listens to the events coming, manages two lists of the pressed keys and buttons and when their content corresponds to some single action shortcut it just runs this shortcut once.

The strategy for handling the stroke shortcuts is a bit more complex. Each such action may be in one of the three states:

Idle <-> Ready <-> Running

In "Idle" state the action is completely inactive and has no access to the user

When the action is in "Ready" state, it means that all the modifiers for the action are already pressed and we are only waiting for a user to press the mouse button and start a stroke. In this state the action can show the user its Cursor to notify the user what is going to happen next.

In the "Running" state, the action has full access to the user input and is considered to perform all the work it was created for.

To implement such state transitions for the actions, KisShortcutMatcher first forms a list of the actions which can be moved to a ready state (m_d->readyShortcuts), then chooses the one with the highest priority to be the only shortcut in the "Ready" state and activates it (m_d->readyShortcut). Then when the user presses the mouse button, the matcher looks through the list of ready shortcuts, chooses which will be running now, deactivates (if needed) currently activated action and starts the chosen one.

See also: KisSingleActionShortcut; KisStrokeShortcut

Definition at line 46 of file kis_shortcut_matcher.cpp.

Constructor & Destructor Documentation

◆ ~Private()

KisShortcutMatcher::~Private ( )

inline

Definition at line 60 of file kis_shortcut_matcher.cpp.

    {
        qDeleteAll(singleActionShortcuts);
        qDeleteAll(strokeShortcuts);
        qDeleteAll(touchShortcuts);
    }

◆ KisShortcutMatcher()

KisShortcutMatcher::KisShortcutMatcher ( )

Definition at line 155 of file kis_shortcut_matcher.cpp.

156 : m_d(new Private)

157{}

KisShortcutMatcher::m_d

Private *const m_d

Definition kis_shortcut_matcher.h:319

Private

Definition SvgTransformParser.cpp:20

◆ ~KisShortcutMatcher()

KisShortcutMatcher::~KisShortcutMatcher ( )

Definition at line 159 of file kis_shortcut_matcher.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

◆ actionsSuppressed()

bool KisShortcutMatcher::actionsSuppressed ( ) const

inline

Definition at line 137 of file kis_shortcut_matcher.cpp.

                                          {
#ifndef Q_OS_ANDROID
        return suppressAllActions || !cursorEntered;
#else
        // when S-pen is not pointing the canvas, actions on canvas are disabled, till it points back to canvas.
        return false;
#endif
    }

◆ actionsSuppressedIgnoreFocus()

bool KisShortcutMatcher::actionsSuppressedIgnoreFocus ( ) const

inline

Definition at line 146 of file kis_shortcut_matcher.cpp.

                                                     {
        return suppressAllActions;
    }

◆ addShortcut() [1/4]

void KisShortcutMatcher::addShortcut ( KisNativeGestureShortcut * shortcut )

Definition at line 194 of file kis_shortcut_matcher.cpp.

                                                                       {
    m_d->nativeGestureShortcuts.append(shortcut);
}

References m_d.

◆ addShortcut() [2/4]

void KisShortcutMatcher::addShortcut ( KisSingleActionShortcut * shortcut )

Definition at line 179 of file kis_shortcut_matcher.cpp.

{
    m_d->singleActionShortcuts.append(shortcut);
}

References m_d.

◆ addShortcut() [3/4]

void KisShortcutMatcher::addShortcut ( KisStrokeShortcut * shortcut )

Definition at line 184 of file kis_shortcut_matcher.cpp.

{
    m_d->strokeShortcuts.append(shortcut);
}

References m_d.

◆ addShortcut() [4/4]

void KisShortcutMatcher::addShortcut ( KisTouchShortcut * shortcut )

Definition at line 189 of file kis_shortcut_matcher.cpp.

{
    m_d->touchShortcuts.append(shortcut);
}

References m_d.

◆ autoRepeatedKeyPressed()

bool KisShortcutMatcher::autoRepeatedKeyPressed ( Qt::Key key )

Handles a key press event that has been generated by the autorepeat.

Returns: whether the event has been handled successfully and should be eaten by the events filter

Definition at line 233 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
 
    bool retval = false;
 
    if (!m_d->keys.contains(key)) { DEBUG_ACTION("Peculiar, autorepeated key but can't remember it was pressed"); }
 
    if (m_d->polledKeys.contains(key)) {
        m_d->polledKeys.remove(key);
    }
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        // Autorepeated key should not be included in the shortcut
        QSet<Qt::Key> filteredKeys = m_d->keys;
        filteredKeys.remove(key);
        retval = tryRunSingleActionShortcutImpl(key, (QEvent*)0, filteredKeys);
    }
 
    return retval;
}

References DEBUG_ACTION, forceDeactivateAllActions(), hasRunningShortcut(), m_d, and tryRunSingleActionShortcutImpl().

◆ buttonPressed()

bool KisShortcutMatcher::buttonPressed	(	Qt::MouseButton	button,
		QEvent *	event )

Handles button presses from a tablet or mouse.

Parameters

event the event that caused this call. Must be of type QTabletEvent or QMouseEvent.

Returns: whether the event has been handled successfully and should be eaten by the events filter

Definition at line 279 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
    DEBUG_BUTTON_ACTION("entered", button);
 
    bool retval = false;
 
    if (m_d->buttons.contains(button)) { DEBUG_ACTION("Peculiar, button was already pressed."); }
 
    if (!hasRunningShortcut() && !notifier.isInRecursion()) {
        prepareReadyShortcuts();
        retval = tryRunReadyShortcut(button, event);
    }
 
    m_d->buttons.insert(button);
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return retval;
}

References button(), DEBUG_ACTION, DEBUG_BUTTON_ACTION, forceDeactivateAllActions(), hasRunningShortcut(), m_d, prepareReadyShortcuts(), tryActivateReadyShortcut(), and tryRunReadyShortcut().

◆ buttonReleased()

bool KisShortcutMatcher::buttonReleased	(	Qt::MouseButton	button,
		QEvent *	event )

Handles the mouse button release event

Parameters

event the event that caused this call. Must be of type QTabletEvent or QMouseEvent.

Returns: whether the event has been handled successfully and should be eaten by the events filter

Definition at line 305 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
    DEBUG_BUTTON_ACTION("entered", button);
 
    bool retval = false;
 
    // here we check for the presence of the **stroke** shortcut only
    if (m_d->runningShortcut) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(!notifier.isInRecursion());
 
        retval = tryEndRunningShortcut(button, event);
        DEBUG_BUTTON_ACTION("ended", button);
    }
 
    if (!m_d->buttons.contains(button)) reset("Peculiar, button released but we can't remember it was pressed");
    else m_d->buttons.remove(button);
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return retval;
}

References button(), DEBUG_BUTTON_ACTION, forceDeactivateAllActions(), hasRunningShortcut(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, prepareReadyShortcuts(), reset(), tryActivateReadyShortcut(), and tryEndRunningShortcut().

◆ clearShortcuts()

void KisShortcutMatcher::clearShortcuts ( )

Remove all shortcuts that have been registered.

Definition at line 787 of file kis_shortcut_matcher.cpp.

{
    reset("Clearing shortcuts");
    qDeleteAll(m_d->singleActionShortcuts);
    m_d->singleActionShortcuts.clear();
    qDeleteAll(m_d->strokeShortcuts);
    qDeleteAll(m_d->touchShortcuts);
    m_d->strokeShortcuts.clear();
    m_d->candidateShortcuts.clear();
    m_d->touchShortcuts.clear();
    m_d->runningShortcut = 0;
    m_d->readyShortcut = 0;
}

References m_d, and reset().

◆ debugPressedKeys()

QVector< Qt::Key > KisShortcutMatcher::debugPressedKeys ( ) const

Return the internal state of the tracked modifiers.

Definition at line 701 of file kis_shortcut_matcher.cpp.

{
    QVector<Qt::Key> keys;
    std::copy(m_d->keys.begin(), m_d->keys.end(), std::back_inserter(keys));
    return keys;
}

References keys, and m_d.

◆ enterEvent()

void KisShortcutMatcher::enterEvent ( )

Handle cursor's Enter event. We never eat it because it might be used by someone else

Definition at line 365 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    m_d->cursorEntered = true;
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
}

References forceDeactivateAllActions(), hasRunningShortcut(), m_d, prepareReadyShortcuts(), and tryActivateReadyShortcut().

◆ fireReadyTouchShortcut()

void KisShortcutMatcher::fireReadyTouchShortcut ( QTouchEvent * event )

private

Definition at line 1026 of file kis_shortcut_matcher.cpp.

{
    KisTouchShortcut *goodCandidate = matchTouchShortcut(event);
    if (goodCandidate) {
        DEBUG_TOUCH_ACTION("starting", event)
        goodCandidate->action()->activate(goodCandidate->shortcutIndex());
        goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
 
        goodCandidate->action()->end(event);
        goodCandidate->action()->deactivate(goodCandidate->shortcutIndex());
    }
}

References KisAbstractShortcut::action, KisAbstractInputAction::activate(), KisAbstractInputAction::begin(), KisAbstractInputAction::deactivate(), DEBUG_TOUCH_ACTION, KisAbstractInputAction::end(), matchTouchShortcut(), and KisAbstractShortcut::shortcutIndex.

◆ forceDeactivateAllActions()

void KisShortcutMatcher::forceDeactivateAllActions ( )

private

Definition at line 1003 of file kis_shortcut_matcher.cpp.

{
    if (m_d->readyShortcut) {
        DEBUG_SHORTCUT("Forcefully deactivating action", m_d->readyShortcut);
        m_d->readyShortcut->action()->deactivate(m_d->readyShortcut->shortcutIndex());
        m_d->readyShortcut = 0;
    }
}

References DEBUG_SHORTCUT, and m_d.

◆ forceEndRunningShortcut()

void KisShortcutMatcher::forceEndRunningShortcut ( const QPointF & localPos )

private

Definition at line 978 of file kis_shortcut_matcher.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->runningShortcut);
    KIS_SAFE_ASSERT_RECOVER(!m_d->readyShortcut) {
        // it shouldn't have happened, running and ready shortcuts
        // at the same time should not be possible
        forceDeactivateAllActions();
    }
 
    // first reset running shortcut to avoid infinite recursion via end()
    KisStrokeShortcut *runningShortcut = m_d->runningShortcut;
    m_d->runningShortcut = 0;
 
    if (runningShortcut->action()) {
        DEBUG_ACTION("Forced ending running shortcut at event");
        KisAbstractInputAction* action = runningShortcut->action();
        int shortcutIndex = runningShortcut->shortcutIndex();
 
        QMouseEvent event = runningShortcut->fakeEndEvent(localPos);
 
        action->end(&event);
        action->deactivate(shortcutIndex);
    }
}

References KisAbstractShortcut::action, KisAbstractInputAction::deactivate(), DEBUG_ACTION, KisAbstractInputAction::end(), KisStrokeShortcut::fakeEndEvent(), forceDeactivateAllActions(), KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, runningShortcut, and KisAbstractShortcut::shortcutIndex.

◆ handlePolledKeys()

void KisShortcutMatcher::handlePolledKeys ( const QVector< Qt::Key > & keys )

Resets the internal state of the matcher, tries to resync it to the state passed via argument and activates the prepared action if possible.

This synchronization happens when the user hovers Krita windows, without having keyboard focus set to it (therefore matcher cannot get key press and release events), and is also used for various other fixes.

Definition at line 661 of file kis_shortcut_matcher.cpp.

{
    Q_FOREACH (Qt::Key key, m_d->keys) {
        if (!keys.contains(key)) {
            keyReleased(key);
        }
    }
 
    Q_FOREACH (Qt::Key key, keys) {
        if (!m_d->keys.contains(key)) {
            keyPressed(key);
            m_d->polledKeys << key;
        }
    }
 
    Private::RecursionNotifier notifier(this);
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    DEBUG_ACTION("recoverySyncModifiers");
}

References DEBUG_ACTION, forceDeactivateAllActions(), hasRunningShortcut(), keyPressed(), keyReleased(), keys, m_d, prepareReadyShortcuts(), and tryActivateReadyShortcut().

◆ hasPolledKeys()

bool KisShortcutMatcher::hasPolledKeys ( )

Check if polled keys are present, which signals that we need to call KisInputManager::Private::fixShortcutMatcherModifiersState.

Definition at line 708 of file kis_shortcut_matcher.cpp.

{
    return !m_d->polledKeys.empty();
}

References m_d.

◆ hasRunningShortcut()

bool KisShortcutMatcher::hasRunningShortcut ( ) const

Definition at line 164 of file kis_shortcut_matcher.cpp.

{
    return m_d->runningShortcut || m_d->touchShortcut || m_d->nativeGestureShortcut;
}

References m_d.

◆ hasTouchHoldShortcut()

bool KisShortcutMatcher::hasTouchHoldShortcut ( ) const

Definition at line 169 of file kis_shortcut_matcher.cpp.

{
    for (const KisTouchShortcut *shortcut : m_d->touchShortcuts) {
        if (shortcut->isHoldType() && shortcut->isAvailable(m_d->actionGroupMask())) {
            return true;
        }
    }
    return false;
}

References m_d.

◆ KeyboardActionsSuppressed()

bool KisShortcutMatcher::KeyboardActionsSuppressed ( ) const

inline

Definition at line 150 of file kis_shortcut_matcher.cpp.

                                                  {
        return suppressAllKeyboardActions;
    }

◆ keyPressed()

bool KisShortcutMatcher::keyPressed ( Qt::Key key )

Handles a key press event. No autorepeat events should be passed to this method.

Returns: whether the event has been handled successfully and should be eaten by the events filter

Definition at line 208 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    bool retval = false;
 
    if (m_d->keys.contains(key)) { DEBUG_ACTION("Peculiar, records show key was already pressed"); }
 
    if (!hasRunningShortcut() && !notifier.isInRecursion()) {
        retval =  tryRunSingleActionShortcutImpl(key, (QEvent*)0, m_d->keys);
    }
 
    m_d->keys.insert(key);
    DEBUG_KEY("Pressed");
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return retval;
}

References DEBUG_ACTION, DEBUG_KEY, forceDeactivateAllActions(), hasRunningShortcut(), m_d, prepareReadyShortcuts(), tryActivateReadyShortcut(), and tryRunSingleActionShortcutImpl().

◆ keyReleased()

bool KisShortcutMatcher::keyReleased ( Qt::Key key )

Handles a key release event. No autorepeat events should be passed to this method.

Returns: whether the event has been handled successfully and should be eaten by the events filter

Definition at line 258 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    if (!m_d->keys.contains(key)) { DEBUG_ACTION("Peculiar, key released but can't remember it was pressed"); }
    else m_d->keys.remove(key);
 
    m_d->polledKeys.remove(key);
 
    DEBUG_KEY("Released");
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return false;
}

References DEBUG_ACTION, DEBUG_KEY, forceDeactivateAllActions(), hasRunningShortcut(), m_d, prepareReadyShortcuts(), and tryActivateReadyShortcut().

◆ leaveEvent()

void KisShortcutMatcher::leaveEvent ( )

Handle cursor's Leave event. We never eat it because it might be used by someone else

Definition at line 379 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    m_d->cursorEntered = false;
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
}

References forceDeactivateAllActions(), hasRunningShortcut(), m_d, prepareReadyShortcuts(), and tryActivateReadyShortcut().

◆ lostFocusEvent()

void KisShortcutMatcher::lostFocusEvent ( const QPointF & localPos )

Krita lost focus, it means that all the running actions should be ended forcefully.

TODO: it might be that we should also deactivate touch and native gestures on focus-out events. After testing on Windows it seems like it works fine without any explicit stopping the touch strokes. They just continue in the unfocused application (given that Krita does not get overlapped by another window)

Definition at line 713 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    DEBUG_ACTION("lostFocusEvent");
 
    if (m_d->runningShortcut) {
        forceEndRunningShortcut(localPos);
    }
 
    forceDeactivateAllActions();
 
}

References DEBUG_ACTION, forceDeactivateAllActions(), forceEndRunningShortcut(), and m_d.

◆ matchTouchShortcut()

KisTouchShortcut * KisShortcutMatcher::matchTouchShortcut ( QTouchEvent * event )

private

Definition at line 1039 of file kis_shortcut_matcher.cpp.

{
    KisTouchShortcut *goodCandidate = nullptr;
    Q_FOREACH (KisTouchShortcut *shortcut, m_d->touchShortcuts) {
        if (shortcut->isAvailable(m_d->actionGroupMask())
            && matchTouchShortcutBasedOnState(event, shortcut)
            && (!goodCandidate || shortcut->priority() > goodCandidate->priority())) {
 
            goodCandidate = shortcut;
        }
    }
    return goodCandidate;
}

References KisAbstractShortcut::isAvailable(), m_d, matchTouchShortcutBasedOnState(), and KisTouchShortcut::priority().

◆ matchTouchShortcutBasedOnState()

bool KisShortcutMatcher::matchTouchShortcutBasedOnState	(	QTouchEvent *	event,
		KisTouchShortcut *	shortcut )

private

Definition at line 1053 of file kis_shortcut_matcher.cpp.

{
    if (m_d->isTouchHeld) {
        return shortcut->matchHoldType(event);
    } else if (m_d->isTouchDragDetected) {
        return shortcut->matchDragType(event);
    } else {
        return shortcut->matchTapType(event);
    }
}

References m_d, KisTouchShortcut::matchDragType(), KisTouchShortcut::matchHoldType(), and KisTouchShortcut::matchTapType().

◆ nativeGestureBeginEvent()

bool KisShortcutMatcher::nativeGestureBeginEvent ( QNativeGestureEvent * event )

Definition at line 582 of file kis_shortcut_matcher.cpp.

{
    Q_UNUSED(event);
 
    Private::RecursionNotifier notifier(this);
 
    return !notifier.isInRecursion();
}

◆ nativeGestureEndEvent()

bool KisShortcutMatcher::nativeGestureEndEvent ( QNativeGestureEvent * event )

Definition at line 605 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    if ( m_d->nativeGestureShortcut && !m_d->nativeGestureShortcut->match( event ) ) {
        tryEndNativeGestureShortcut( event );
    }
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return true;
}

References forceDeactivateAllActions(), hasRunningShortcut(), m_d, prepareReadyShortcuts(), tryActivateReadyShortcut(), and tryEndNativeGestureShortcut().

◆ nativeGestureEvent()

bool KisShortcutMatcher::nativeGestureEvent ( QNativeGestureEvent * event )

Definition at line 591 of file kis_shortcut_matcher.cpp.

{
    bool retval = false;
    if (!hasRunningShortcut()) {
        retval = tryRunNativeGestureShortcut( event );
    }
    else if (m_d->nativeGestureShortcut) {
        m_d->nativeGestureShortcut->action()->inputEvent( event );
        retval = true;
    }
 
    return retval;
}

References hasRunningShortcut(), m_d, and tryRunNativeGestureShortcut().

◆ pointerMoved()

bool KisShortcutMatcher::pointerMoved ( QEvent * event )

Handles tablet and mouse move events.

Parameters

event the event that caused this call

Returns: whether the event has been handled successfully and should be eaten by the events filter

Definition at line 346 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    if (notifier.isInRecursion()) {
        return false;
    }
 
    bool retval = false;
 
    if (m_d->runningShortcut) {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!m_d->touchShortcut && !m_d->nativeGestureShortcut, false);
        m_d->runningShortcut->action()->inputEvent(event);
        retval = true;
    }
 
    return retval;
}

References KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and m_d.

◆ prepareReadyShortcuts()

void KisShortcutMatcher::prepareReadyShortcuts ( )

private

Definition at line 843 of file kis_shortcut_matcher.cpp.

{
    m_d->candidateShortcuts.clear();
    if (m_d->actionsSuppressed()) return;
 
    // Allow letting the modifiers to be matched so key_shift + middle mouse move can be matched, but key_v + mouse drag can not.
    bool containsOnlyModifiers = !m_d->keys.isEmpty();
    Q_FOREACH(const Qt::Key k, m_d->keys) {
        if (k != Qt::Key_Shift && k != Qt::Key_Control && k != Qt::Key_Alt && k != Qt::Key_Meta) {
            containsOnlyModifiers = false;
            break;
        }
    }
    if (m_d->KeyboardActionsSuppressed()
            && !containsOnlyModifiers && !m_d->keys.isEmpty()
            && m_d->buttons.isEmpty()) {
        return;
    }
 
    Q_FOREACH (KisStrokeShortcut *s, m_d->strokeShortcuts) {
        if (s->matchReady(m_d->keys, m_d->buttons)) {
            m_d->candidateShortcuts.append(s);
        }
    }
}

References m_d, and KisStrokeShortcut::matchReady().

◆ Private()

KisShortcutMatcher::Private ( )

inline

Definition at line 49 of file kis_shortcut_matcher.cpp.

        : runningShortcut(0)
        , readyShortcut(0)
        , touchShortcut(0)
        , nativeGestureShortcut(0)
        , actionGroupMask([] () { return AllActionGroup; })
        , suppressAllActions(false)
        , suppressAllKeyboardActions(false)
        , cursorEntered(false)
    {}

References AllActionGroup.

◆ reinitialize()

void KisShortcutMatcher::reinitialize ( )

Resets the internal state of the matcher and activates the prepared action if possible.

This should be done when the window has lost the focus for some time, so that several events could be lost

Definition at line 631 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
 
    reset("reinitialize");
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
}

References forceDeactivateAllActions(), hasRunningShortcut(), prepareReadyShortcuts(), reset(), and tryActivateReadyShortcut().

◆ reinitializeButtons()

void KisShortcutMatcher::reinitializeButtons ( )

Resets the internal state of the buttons inside matcher and activates the prepared action if possible.

This should be done when the window has lost the focus for some time, so that several events could be lost

Definition at line 646 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    m_d->buttons.clear();
    DEBUG_ACTION("reinitializing buttons");
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
}

References DEBUG_ACTION, forceDeactivateAllActions(), hasRunningShortcut(), m_d, prepareReadyShortcuts(), and tryActivateReadyShortcut().

◆ reset() [1/2]

void KisShortcutMatcher::reset ( )

private

Definition at line 748 of file kis_shortcut_matcher.cpp.

{
    m_d->keys.clear();
    m_d->buttons.clear();
    DEBUG_ACTION("reset!");
}

References DEBUG_ACTION, and m_d.

◆ reset() [2/2]

void KisShortcutMatcher::reset ( QString msg )

private

Definition at line 756 of file kis_shortcut_matcher.cpp.

{
    m_d->keys.clear();
    m_d->buttons.clear();
    Q_UNUSED(msg);
    DEBUG_ACTION(msg);
}

References DEBUG_ACTION, and m_d.

◆ sanityCheckModifiersCorrectness()

bool KisShortcutMatcher::sanityCheckModifiersCorrectness ( Qt::KeyboardModifiers modifiers ) const

Sanity check correctness of the internal state of the matcher by comparing it to the standard modifiers that we get with every input event. Right now this sanity check is used on Windows only.

Definition at line 688 of file kis_shortcut_matcher.cpp.

{
    auto checkKey = [this, modifiers] (Qt::Key key, Qt::KeyboardModifier modifier) {
        return m_d->keys.contains(key) == bool(modifiers & modifier);
    };
 
    return checkKey(Qt::Key_Shift, Qt::ShiftModifier) &&
        checkKey(Qt::Key_Control, Qt::ControlModifier) &&
        checkKey(Qt::Key_Alt, Qt::AltModifier) &&
        checkKey(Qt::Key_Meta, Qt::MetaModifier);
 
}

References m_d.

◆ setInputActionGroupsMaskCallback()

void KisShortcutMatcher::setInputActionGroupsMaskCallback ( std::function< KisInputActionGroupsMask()> func )

Definition at line 801 of file kis_shortcut_matcher.cpp.

{
    m_d->actionGroupMask = func;
}

References m_d.

◆ setMaxTouchPointEvent()

void KisShortcutMatcher::setMaxTouchPointEvent ( QTouchEvent * event )

private

Definition at line 1012 of file kis_shortcut_matcher.cpp.

{
    int touchPointCount = event->touchPoints().size();
    if (touchPointCount > m_d->maxTouchPoints) {
        m_d->maxTouchPoints = touchPointCount;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
        KoPointerEvent::copyQtPointerEvent(event, m_d->bestCandidateTouchEvent);
#else
        m_d->bestCandidateTouchEvent.reset(event->clone());
#endif
 
    }
}

References m_d.

◆ supportsHiResInputEvents()

bool KisShortcutMatcher::supportsHiResInputEvents ( )

Returns true if the currently running shortcut supports processing hi resolution flow of events from the tablet device. In most of the cases (except of the painting itself) too many events make the execution of the action too slow, so the action can decide whether it needs it.

Definition at line 198 of file kis_shortcut_matcher.cpp.

{
    return (m_d->runningShortcut && m_d->runningShortcut->action()
            && m_d->runningShortcut->action()->supportsHiResInputEvents(m_d->runningShortcut->shortcutIndex()))
        || (m_d->touchShortcut && m_d->touchShortcut->action()
            && m_d->touchShortcut->action()->supportsHiResInputEvents(m_d->touchShortcut->shortcutIndex()))
        || (m_d->nativeGestureShortcut && m_d->nativeGestureShortcut->action()
            && m_d->nativeGestureShortcut->action()->supportsHiResInputEvents(m_d->nativeGestureShortcut->shortcutIndex()));
}

References m_d.

◆ suppressAllActions()

void KisShortcutMatcher::suppressAllActions ( bool value )

Disables the start of any actions.

WARNING: the actions that has been started before this call will not be ended. They will be ended in their usual way, when the mouse button will be released.

◆ suppressAllKeyboardActions()

void KisShortcutMatcher::suppressAllKeyboardActions ( bool value )

Disable keyboard actions.

This will disable all actions that consist of only keyboard keys being pressed without mouse or stylus buttons being pressed.

This is turned on when the tool is in text mode.

◆ suppressConflictingKeyActions()

void KisShortcutMatcher::suppressConflictingKeyActions ( const QVector< QKeySequence > & shortcuts )

Disable one-time actions whose shortcuts conflict with the listed shortcuts

Definition at line 769 of file kis_shortcut_matcher.cpp.

{
    m_d->suppressedSingleActionShortcuts.clear();
 
    Q_FOREACH (KisSingleActionShortcut *s, m_d->singleActionShortcuts) {
        Q_FOREACH (const QKeySequence &seq, shortcuts) {
            if (s->conflictsWith(seq)) {
                m_d->suppressedSingleActionShortcuts.insert(s);
            }
        }
    }
}

References KisSingleActionShortcut::conflictsWith(), and m_d.

◆ toolHasBeenActivated()

void KisShortcutMatcher::toolHasBeenActivated ( )

Is called when a new tool has been activated. The method activates any tool's action if possible with the currently active modifiers.

Definition at line 734 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    DEBUG_ACTION("toolHasBeenActivated");
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
}

References DEBUG_ACTION, forceDeactivateAllActions(), hasRunningShortcut(), prepareReadyShortcuts(), and tryActivateReadyShortcut().

◆ touchBeginEvent()

bool KisShortcutMatcher::touchBeginEvent ( QTouchEvent * event )

Definition at line 393 of file kis_shortcut_matcher.cpp.

{
    DEBUG_TOUCH_ACTION("entered", event)
 
    Private::RecursionNotifier notifier(this);
 
    m_d->lastTouchPoints = event->touchPoints();
 
    // reset state
    m_d->maxTouchPoints = event->touchPoints().size();
    m_d->matchingIteration = 1;
    m_d->isTouchDragDetected = false;
    m_d->isTouchHeld = false;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    KoPointerEvent::copyQtPointerEvent(event, m_d->bestCandidateTouchEvent);
#else
    m_d->bestCandidateTouchEvent.reset(event->clone());
#endif
 
    return !notifier.isInRecursion();
}

References DEBUG_TOUCH_ACTION, and m_d.

◆ touchCancelEvent()

void KisShortcutMatcher::touchCancelEvent	(	QTouchEvent *	event,
		const QPointF &	localPos )

We received TouchCancel event, it means this event sequence has ended right here i.e without a valid TouchEnd, so we should immediately stop all running actions.

Definition at line 517 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    m_d->maxTouchPoints = 0;
    m_d->isTouchHeld = false;
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->runningShortcut || !m_d->touchShortcut);
 
    // end the stroke types
    if (m_d->touchShortcut) {
        KisTouchShortcut *touchShortcut = m_d->touchShortcut;
        m_d->touchShortcut = 0;
        QScopedPointer<QEvent> dstEvent;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
        KoPointerEvent::copyQtPointerEvent(event, dstEvent);
#else
        dstEvent.reset(event->clone());
#endif
 
        // HACK: Because TouchEvents in KoPointerEvent need to contain at least one touchpoint
        QTouchEvent* touchEvent = dynamic_cast<QTouchEvent *>(dstEvent.data());
        KIS_ASSERT(touchEvent);
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
        touchEvent->setTouchPoints(m_d->lastTouchPoints);
#else
        dstEvent.reset(new QTouchEvent(event->type(),
                                       event->pointingDevice(),
                                       event->modifiers(),
                                       m_d->lastTouchPoints));
#endif
        touchShortcut->action()->end(dstEvent.data());
        touchShortcut->action()->deactivate(touchShortcut->shortcutIndex());
    }
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
}

References KisAbstractShortcut::action, KisAbstractInputAction::deactivate(), KisAbstractInputAction::end(), forceDeactivateAllActions(), hasRunningShortcut(), KIS_ASSERT, KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, prepareReadyShortcuts(), KisAbstractShortcut::shortcutIndex, touchShortcut, and tryActivateReadyShortcut().

◆ touchEndEvent()

bool KisShortcutMatcher::touchEndEvent ( QTouchEvent * event )

Definition at line 492 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    m_d->maxTouchPoints = 0;
    m_d->isTouchHeld = false;
 
    if (!m_d->isTouchDragDetected && m_d->bestCandidateTouchEvent && !hasRunningShortcut()) {
        fireReadyTouchShortcut(static_cast<QTouchEvent *>(m_d->bestCandidateTouchEvent.data()));
    }
 
    DEBUG_TOUCH_ACTION("ending", event)
    // we should try and end the shortcut too (it might be that there is none? (sketch))
    const bool retval = tryEndTouchShortcut(event);
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return retval;
}

References DEBUG_TOUCH_ACTION, fireReadyTouchShortcut(), forceDeactivateAllActions(), hasRunningShortcut(), m_d, prepareReadyShortcuts(), tryActivateReadyShortcut(), and tryEndTouchShortcut().

◆ touchHoldBeginEvent()

bool KisShortcutMatcher::touchHoldBeginEvent ( QTouchEvent * event )

Effectively a long-press touch event, generated by KisInputManager when the user touches and holds a spot with one finger. Replaces touchBeginEvent, but other events keep streaming in as normal.

Definition at line 560 of file kis_shortcut_matcher.cpp.

{
    DEBUG_TOUCH_ACTION("hold", event)
 
    // Can happen when multiple shortcut sources interact.
    if (m_d->runningShortcut) {
        return false;
    }
 
    m_d->isTouchHeld = true; // Must be set first, used in tryRunTouchShortcut.
    if (tryRunTouchShortcut(event)) {
        DEBUG_ACTION("touch shortcut found");
        return true;
    } else {
        // Shouldn't really happen, since KisInputManager checks whether a touch
        // hold shortcut exists beforehand. We'll just handle this though.
        DEBUG_ACTION("touch shortcut not found");
        m_d->isTouchHeld = false;
        return touchBeginEvent(event);
    }
}

References DEBUG_ACTION, DEBUG_TOUCH_ACTION, m_d, touchBeginEvent(), and tryRunTouchShortcut().

◆ touchUpdateEvent()

bool KisShortcutMatcher::touchUpdateEvent ( QTouchEvent * event )

Definition at line 415 of file kis_shortcut_matcher.cpp.

{
    DEBUG_TOUCH_ACTION("entered", event)
 
    if (m_d->isTouchHeld) {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->touchShortcut, false);
        m_d->touchShortcut->action()->inputEvent(event);
        return true;
    }
 
    bool retval = false;
 
    const int touchPointCount = event->touchPoints().size();
    // check whether the touchpoints are relatively stationary or have been moved for dragging.
    for (int i = 0; i < event->touchPoints().size() && !m_d->isTouchDragDetected; ++i) {
        const QTouchEvent::TouchPoint &touchPoint = event->touchPoints().at(i);
        const QPointF delta = touchPoint.pos() - touchPoint.startPos();
        const qreal deltaSquared = delta.x() * delta.x() + delta.y() * delta.y();
        // if the drag is detected, until the next TouchBegin even, we'll be assuming the gesture to be of dragging
        // type.
        m_d->isTouchDragDetected = deltaSquared > TOUCH_SLOP_SQUARED;
    }
 
    // for a first few events we don't process the events right away. But analyze and keep track of the event with most
    // touchpoints. This is done to prevent conditions where in three-finger-tap, two-finger-tap be preceded due to
    // latency
    const int numIterations = 10;
    if (m_d->matchingIteration <= numIterations && !m_d->isTouchDragDetected) {
        m_d->matchingIteration++;
        setMaxTouchPointEvent(event);
        DEBUG_TOUCH_ACTION("return best", event)
        return matchTouchShortcut((QTouchEvent *)m_d->bestCandidateTouchEvent.data());
    }
 
    if (m_d->isTouchDragDetected) {
        if (m_d->touchShortcut && !m_d->touchShortcut->matchDragType(event)) {
            DEBUG_TOUCH_ACTION("ending", event)
            // we should end the event as an event with more touchpoints was received
            retval = tryEndTouchShortcut(event);
        }
        if (!hasRunningShortcut() && touchPointCount >= m_d->maxTouchPoints) {
            m_d->maxTouchPoints = touchPointCount;
            DEBUG_TOUCH_ACTION("starting", event);
            retval = tryRunTouchShortcut(event);
        } else if (m_d->touchShortcut) {
            // The typical assumption when we get here is that the shortcut has been matched, for which we use
            // the events with TouchPointPressed state. But there may be instances where shortcut is never
            // un-matched (meaning: never being tryEndTouchShortcut called on it) even when the finger is
            // released, and when the next contact is made, the shortcut proceeds assuming continuity -- which
            // is a false assumption.
            // So, if we see a TouchPointPressed, we should know that somewhere previously finger was lifted
            // and we should let the action know this.
            if (event->touchPointStates() & Qt::TouchPointPressed) {
                m_d->touchShortcut->action()->begin(m_d->touchShortcut->shortcutIndex(), event);
            } else if (event->touchPointStates() & Qt::TouchPointReleased) {
                m_d->touchShortcut->action()->end(event);
            } else {
                m_d->touchShortcut->action()->inputEvent(event);
            }
            retval = true;
        }
    } else {
        // triggered if a new finger was added, which might result in shortcut not matching the action
        if ((event->touchPointStates() & Qt::TouchPointReleased) == Qt::TouchPointReleased && !hasRunningShortcut()) {
            // we should end the event as an event with more touchpoints was received
            if (m_d->maxTouchPoints <= touchPointCount) {
                m_d->maxTouchPoints = touchPointCount;
                DEBUG_TOUCH_ACTION("firing", event);
                fireReadyTouchShortcut(event);
                m_d->bestCandidateTouchEvent.reset();
            }
        }
    }
 
    return retval;
}

References DEBUG_TOUCH_ACTION, fireReadyTouchShortcut(), hasRunningShortcut(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, matchTouchShortcut(), setMaxTouchPointEvent(), TOUCH_SLOP_SQUARED, tryEndTouchShortcut(), and tryRunTouchShortcut().

◆ tryActivateReadyShortcut()

void KisShortcutMatcher::tryActivateReadyShortcut ( )

private

It is important that we first activate the action, and only after that assign it to m_d->readyShortcut. It makes is possible to activate another tool in KisToolInvocationAction and survive the call to forceDeactivateAllActions() from lostFocusEvent(), which would enter infinite loop otherwise.

Definition at line 914 of file kis_shortcut_matcher.cpp.

{
    KisStrokeShortcut *goodCandidate = 0;
 
    Q_FOREACH (KisStrokeShortcut *s, m_d->candidateShortcuts) {
        if (!goodCandidate || s->priority() > goodCandidate->priority()) {
            goodCandidate = s;
        }
    }
 
    if (goodCandidate) {
        if (m_d->readyShortcut && m_d->readyShortcut != goodCandidate) {
            DEBUG_SHORTCUT("Deactivated previous shortcut action", m_d->readyShortcut);
            m_d->readyShortcut->action()->deactivate(m_d->readyShortcut->shortcutIndex());
            m_d->readyShortcut = 0;
        }
 
        if (!m_d->readyShortcut) {
            DEBUG_SHORTCUT("Preparing new ready action", goodCandidate);
 
            goodCandidate->action()->activate(goodCandidate->shortcutIndex());
            m_d->readyShortcut = goodCandidate;
        }
    } else if (m_d->readyShortcut) {
        DEBUG_SHORTCUT("Deactivating action", m_d->readyShortcut);
        m_d->readyShortcut->action()->deactivate(m_d->readyShortcut->shortcutIndex());
        m_d->readyShortcut = 0;
    }
}

References KisAbstractShortcut::action, KisAbstractInputAction::activate(), DEBUG_SHORTCUT, m_d, KisStrokeShortcut::priority(), and KisAbstractShortcut::shortcutIndex.

◆ tryEndNativeGestureShortcut()

bool KisShortcutMatcher::tryEndNativeGestureShortcut ( QNativeGestureEvent * event )

private

Definition at line 1154 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    if (m_d->nativeGestureShortcut) {
        // first reset running shortcut to avoid infinite recursion via end()
        KisNativeGestureShortcut *nativeGestureShortcut = m_d->nativeGestureShortcut;
 
        nativeGestureShortcut->action()->end(event);
        nativeGestureShortcut->action()->deactivate(m_d->nativeGestureShortcut->shortcutIndex());
 
        m_d->nativeGestureShortcut = 0; // empty it out now that we are done with it
 
        return true;
    }
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return false;
}

References KisAbstractShortcut::action, KisAbstractInputAction::deactivate(), KisAbstractInputAction::end(), forceDeactivateAllActions(), hasRunningShortcut(), m_d, nativeGestureShortcut, prepareReadyShortcuts(), and tryActivateReadyShortcut().

◆ tryEndRunningShortcut()

bool KisShortcutMatcher::tryEndRunningShortcut	(	Qt::MouseButton	button,
		QEvent *	event )

private

Definition at line 951 of file kis_shortcut_matcher.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->runningShortcut, true);
    KIS_SAFE_ASSERT_RECOVER(!m_d->readyShortcut) {
        // it shouldn't have happened, running and ready shortcuts
        // at the same time should not be possible
        forceDeactivateAllActions();
    }
 
    if (m_d->runningShortcut && m_d->runningShortcut->matchBegin(button)) {
 
        // first reset running shortcut to avoid infinite recursion via end()
        KisStrokeShortcut *runningShortcut = m_d->runningShortcut;
        m_d->runningShortcut = 0;
 
        if (runningShortcut->action()) {
            DEBUG_EVENT_ACTION("Ending running shortcut at event", event);
            KisAbstractInputAction* action = runningShortcut->action();
            int shortcutIndex = runningShortcut->shortcutIndex();
            action->end(event);
            action->deactivate(shortcutIndex);
        }
    }
 
    return !m_d->runningShortcut;
}

References KisAbstractShortcut::action, button(), KisAbstractInputAction::deactivate(), DEBUG_EVENT_ACTION, KisAbstractInputAction::end(), forceDeactivateAllActions(), KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, runningShortcut, and KisAbstractShortcut::shortcutIndex.

◆ tryEndTouchShortcut()

bool KisShortcutMatcher::tryEndTouchShortcut ( QTouchEvent * event )

private

Definition at line 1098 of file kis_shortcut_matcher.cpp.

{
    if (m_d->touchShortcut) {
        // first reset running shortcut to avoid infinite recursion via end()
        KisTouchShortcut *touchShortcut = m_d->touchShortcut;
 
        DEBUG_SHORTCUT("ending", touchShortcut)
        touchShortcut->action()->end(event);
        touchShortcut->action()->deactivate(m_d->touchShortcut->shortcutIndex());
 
        m_d->touchShortcut = 0; // empty it out now that we are done with it
 
        return true;
    }
 
    return false;
}

References KisAbstractShortcut::action, KisAbstractInputAction::deactivate(), DEBUG_SHORTCUT, KisAbstractInputAction::end(), m_d, and touchShortcut.

◆ tryRunNativeGestureShortcut()

bool KisShortcutMatcher::tryRunNativeGestureShortcut ( QNativeGestureEvent * event )

private

Definition at line 1116 of file kis_shortcut_matcher.cpp.

{
    KisNativeGestureShortcut *goodCandidate = 0;
 
    if (m_d->actionsSuppressed())
        return false;
 
    Q_FOREACH (KisNativeGestureShortcut* shortcut, m_d->nativeGestureShortcuts) {
        if (shortcut->match(event) && (!goodCandidate || shortcut->priority() > goodCandidate->priority())) {
            goodCandidate = shortcut;
        }
    }
 
    if (goodCandidate) {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!m_d->runningShortcut, false);
 
        // Because we don't match keyboard or button based actions with touch system, we have to ensure that we first
        // deactivate an activated readyShortcut, to not throw other statemachines out of place.
        forceDeactivateAllActions();
 
        m_d->nativeGestureShortcut = goodCandidate;
 
        Private::RecursionGuard guard(this);
        goodCandidate->action()->activate(goodCandidate->shortcutIndex());
        goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
 
        // the tool might have opened some dialog, which could break our event loop
        if (guard.brokenByRecursion()) {
            goodCandidate->action()->end(event);
            m_d->nativeGestureShortcut = 0;
 
            forceDeactivateAllActions();
        }
    }
 
    return m_d->nativeGestureShortcut;
}

References KisAbstractShortcut::action, KisAbstractInputAction::activate(), KisAbstractInputAction::begin(), KisAbstractInputAction::end(), forceDeactivateAllActions(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, KisNativeGestureShortcut::match(), KisNativeGestureShortcut::priority(), and KisAbstractShortcut::shortcutIndex.

◆ tryRunReadyShortcut()

bool KisShortcutMatcher::tryRunReadyShortcut	(	Qt::MouseButton	button,
		QEvent *	event )

private

Definition at line 869 of file kis_shortcut_matcher.cpp.

{
    KisStrokeShortcut *goodCandidate = 0;
 
    Q_FOREACH (KisStrokeShortcut *s, m_d->candidateShortcuts) {
        if (s->isAvailable(m_d->actionGroupMask()) &&
            s->matchBegin(button) &&
            (!goodCandidate || s->priority() > goodCandidate->priority())) {
 
            goodCandidate = s;
        }
    }
 
    if (goodCandidate) {
        if (m_d->readyShortcut) {
            if (m_d->readyShortcut != goodCandidate) {
                m_d->readyShortcut->action()->deactivate(m_d->readyShortcut->shortcutIndex());
                goodCandidate->action()->activate(goodCandidate->shortcutIndex());
            }
            m_d->readyShortcut = 0;
        } else {
            DEBUG_EVENT_ACTION("Matched *new* shortcut for event", event);
            goodCandidate->action()->activate(goodCandidate->shortcutIndex());
        }
 
        DEBUG_SHORTCUT("Starting new action", goodCandidate);
 
        {
            m_d->runningShortcut = goodCandidate;
            Private::RecursionGuard guard(this);
            goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
 
            // the tool might have opened some dialog, which could break our event loop
            if (guard.brokenByRecursion()) {
                goodCandidate->action()->end(event);
                m_d->runningShortcut = 0;
 
                forceDeactivateAllActions();
            }
        }
    }
 
    return m_d->runningShortcut;
}

References KisAbstractShortcut::action, KisAbstractInputAction::activate(), KisAbstractInputAction::begin(), button(), DEBUG_EVENT_ACTION, DEBUG_SHORTCUT, KisAbstractInputAction::end(), forceDeactivateAllActions(), KisAbstractShortcut::isAvailable(), m_d, KisStrokeShortcut::matchBegin(), KisStrokeShortcut::priority(), and KisAbstractShortcut::shortcutIndex.

◆ tryRunSingleActionShortcutImpl()

template<typename T , typename U >

bool KisShortcutMatcher::tryRunSingleActionShortcutImpl	(	T	param,
		U *	event,
		const QSet< Qt::Key > &	keysState,
		bool	keyboard = true )

private

Definition at line 813 of file kis_shortcut_matcher.cpp.

{
    if (m_d->actionsSuppressedIgnoreFocus() || (keyboard && m_d->KeyboardActionsSuppressed())) {
        DEBUG_EVENT_ACTION("Event suppressed", event)
        return false;
    }
 
    KisSingleActionShortcut *goodCandidate = 0;
 
    Q_FOREACH (KisSingleActionShortcut *s, m_d->singleActionShortcuts) {
        if (!m_d->suppressedSingleActionShortcuts.contains(s) &&
           s->isAvailable(m_d->actionGroupMask()) &&
           s->match(keysState, param) &&
           (!goodCandidate || s->priority() > goodCandidate->priority())) {
 
            goodCandidate = s;
        }
    }
 
    if (goodCandidate) {
        DEBUG_EVENT_ACTION("Beginning action for event", event);
        goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
        goodCandidate->action()->end(0);
    } else {
        DEBUG_EVENT_ACTION("Could not match a candidate for event", event)
    }
 
    return goodCandidate;
}

References KisAbstractShortcut::action, KisAbstractInputAction::begin(), DEBUG_EVENT_ACTION, KisAbstractInputAction::end(), KisAbstractShortcut::isAvailable(), m_d, KisSingleActionShortcut::match(), KisSingleActionShortcut::priority(), and KisAbstractShortcut::shortcutIndex.

◆ tryRunTouchShortcut()

bool KisShortcutMatcher::tryRunTouchShortcut ( QTouchEvent * event )

private

Definition at line 1064 of file kis_shortcut_matcher.cpp.

{
    KisTouchShortcut *goodCandidate = matchTouchShortcut(event);
 
    if (m_d->actionsSuppressed())
        return false;
 
    if (goodCandidate) {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!m_d->runningShortcut, false);
 
        // Because we don't match keyboard or button based actions with touch system, we have to ensure that we first
        // deactivate an activated readyShortcut, to not throw other statemachines out of place.
        forceDeactivateAllActions();
 
        m_d->touchShortcut = goodCandidate;
 
        Private::RecursionGuard guard(this);
        DEBUG_SHORTCUT("Running a touch shortcut", goodCandidate)
 
        goodCandidate->action()->activate(goodCandidate->shortcutIndex());
        goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
 
        // the tool might have opened some dialog, which could break our event loop
        if (guard.brokenByRecursion()) {
            goodCandidate->action()->end(event);
            m_d->touchShortcut = 0;
 
            forceDeactivateAllActions();
        }
    }
 
    return m_d->touchShortcut;
}

References KisAbstractShortcut::action, KisAbstractInputAction::activate(), KisAbstractInputAction::begin(), DEBUG_SHORTCUT, KisAbstractInputAction::end(), forceDeactivateAllActions(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, matchTouchShortcut(), and KisAbstractShortcut::shortcutIndex.

◆ tryRunWheelShortcut()

bool KisShortcutMatcher::tryRunWheelShortcut	(	KisSingleActionShortcut::WheelAction	wheelAction,
		QWheelEvent *	event )

private

Definition at line 806 of file kis_shortcut_matcher.cpp.

{
    return tryRunSingleActionShortcutImpl(wheelAction, event, m_d->keys, false);
}

References m_d, and tryRunSingleActionShortcutImpl().

◆ wheelEvent()

bool KisShortcutMatcher::wheelEvent	(	KisSingleActionShortcut::WheelAction	wheelAction,
		QWheelEvent *	event )

Handles the mouse wheel event

Returns: whether the event has been handled successfully and should be eaten by the events filter

Definition at line 333 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
 
    if (hasRunningShortcut() || notifier.isInRecursion()) {
        DEBUG_ACTION("Wheel event canceled.");
        return false;
    }
 
    return tryRunWheelShortcut(wheelAction, event);
}

References DEBUG_ACTION, hasRunningShortcut(), and tryRunWheelShortcut().

Friends And Related Symbol Documentation

◆ KisInputManagerTest

friend class KisInputManagerTest

friend

Definition at line 291 of file kis_shortcut_matcher.h.

Member Data Documentation

◆ actionGroupMask

std::function<KisInputActionGroupsMask()> KisShortcutMatcher::actionGroupMask

Definition at line 92 of file kis_shortcut_matcher.cpp.

◆ bestCandidateTouchEvent

QScopedPointer<QEvent> KisShortcutMatcher::bestCandidateTouchEvent

Definition at line 90 of file kis_shortcut_matcher.cpp.

◆ brokenByRecursion

int KisShortcutMatcher::brokenByRecursion = 0

Definition at line 98 of file kis_shortcut_matcher.cpp.

◆ buttons

QSet<Qt::MouseButton> KisShortcutMatcher::buttons

Definition at line 74 of file kis_shortcut_matcher.cpp.

◆ candidateShortcuts

QList<KisStrokeShortcut*> KisShortcutMatcher::candidateShortcuts

Definition at line 80 of file kis_shortcut_matcher.cpp.

◆ cursorEntered

bool KisShortcutMatcher::cursorEntered

Definition at line 95 of file kis_shortcut_matcher.cpp.

◆ isTouchDragDetected

bool KisShortcutMatcher::isTouchDragDetected {false}

Definition at line 88 of file kis_shortcut_matcher.cpp.

88{false};

◆ isTouchHeld

bool KisShortcutMatcher::isTouchHeld {false}

Definition at line 89 of file kis_shortcut_matcher.cpp.

89{false};

◆ keys

QSet<Qt::Key> KisShortcutMatcher::keys

Definition at line 73 of file kis_shortcut_matcher.cpp.

◆ lastTouchPoints

QList<QTouchEvent::TouchPoint> KisShortcutMatcher::lastTouchPoints

Definition at line 84 of file kis_shortcut_matcher.cpp.

◆ m_d

Private* const KisShortcutMatcher::m_d

private

Definition at line 319 of file kis_shortcut_matcher.h.

◆ matchingIteration

int KisShortcutMatcher::matchingIteration {0}

Definition at line 87 of file kis_shortcut_matcher.cpp.

87{0};

◆ maxTouchPoints

int KisShortcutMatcher::maxTouchPoints {0}

Definition at line 86 of file kis_shortcut_matcher.cpp.

86{0};

◆ nativeGestureShortcut

KisNativeGestureShortcut* KisShortcutMatcher::nativeGestureShortcut

Definition at line 83 of file kis_shortcut_matcher.cpp.

◆ nativeGestureShortcuts

QList<KisNativeGestureShortcut*> KisShortcutMatcher::nativeGestureShortcuts

Definition at line 71 of file kis_shortcut_matcher.cpp.

◆ polledKeys

QSet<Qt::Key> KisShortcutMatcher::polledKeys

Definition at line 76 of file kis_shortcut_matcher.cpp.

◆ readyShortcut

KisStrokeShortcut* KisShortcutMatcher::readyShortcut

Definition at line 79 of file kis_shortcut_matcher.cpp.

◆ recursiveCounter

int KisShortcutMatcher::recursiveCounter = 0

Definition at line 97 of file kis_shortcut_matcher.cpp.

◆ runningShortcut

KisStrokeShortcut* KisShortcutMatcher::runningShortcut

Definition at line 78 of file kis_shortcut_matcher.cpp.

◆ singleActionShortcuts

QList<KisSingleActionShortcut*> KisShortcutMatcher::singleActionShortcuts

Definition at line 67 of file kis_shortcut_matcher.cpp.

◆ strokeShortcuts

QList<KisStrokeShortcut*> KisShortcutMatcher::strokeShortcuts

Definition at line 69 of file kis_shortcut_matcher.cpp.

◆ suppressAllActions

void KisShortcutMatcher::suppressAllActions

Definition at line 93 of file kis_shortcut_matcher.cpp.

◆ suppressAllKeyboardActions

void KisShortcutMatcher::suppressAllKeyboardActions

Definition at line 94 of file kis_shortcut_matcher.cpp.

◆ suppressedSingleActionShortcuts

QSet<KisSingleActionShortcut*> KisShortcutMatcher::suppressedSingleActionShortcuts

Definition at line 68 of file kis_shortcut_matcher.cpp.

◆ TOUCH_SLOP_SQUARED

constexpr int KisShortcutMatcher::TOUCH_SLOP_SQUARED = 16 * 16

staticconstexpr

Definition at line 77 of file kis_shortcut_matcher.h.

◆ touchShortcut

KisTouchShortcut* KisShortcutMatcher::touchShortcut

Definition at line 82 of file kis_shortcut_matcher.cpp.

◆ touchShortcuts

QList<KisTouchShortcut*> KisShortcutMatcher::touchShortcuts

Definition at line 70 of file kis_shortcut_matcher.cpp.

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

libs/ui/input/kis_shortcut_matcher.cpp
libs/ui/input/kis_shortcut_matcher.h

Classes

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ ~Private()

◆ KisShortcutMatcher()

◆ ~KisShortcutMatcher()

Member Function Documentation

◆ actionsSuppressed()

◆ actionsSuppressedIgnoreFocus()

◆ addShortcut() [1/4]

◆ addShortcut() [2/4]

◆ addShortcut() [3/4]

◆ addShortcut() [4/4]

◆ autoRepeatedKeyPressed()

◆ buttonPressed()

◆ buttonReleased()

◆ clearShortcuts()

◆ debugPressedKeys()

◆ enterEvent()

◆ fireReadyTouchShortcut()

◆ forceDeactivateAllActions()

◆ forceEndRunningShortcut()

◆ handlePolledKeys()

◆ hasPolledKeys()

◆ hasRunningShortcut()

◆ hasTouchHoldShortcut()

◆ KeyboardActionsSuppressed()

◆ keyPressed()

◆ keyReleased()

◆ leaveEvent()

◆ lostFocusEvent()

◆ matchTouchShortcut()

◆ matchTouchShortcutBasedOnState()

◆ nativeGestureBeginEvent()

◆ nativeGestureEndEvent()

◆ nativeGestureEvent()

◆ pointerMoved()

◆ prepareReadyShortcuts()

◆ Private()

◆ reinitialize()

◆ reinitializeButtons()

◆ reset() [1/2]

◆ reset() [2/2]

◆ sanityCheckModifiersCorrectness()

◆ setInputActionGroupsMaskCallback()

◆ setMaxTouchPointEvent()

◆ supportsHiResInputEvents()

◆ suppressAllActions()

◆ suppressAllKeyboardActions()

◆ suppressConflictingKeyActions()

◆ toolHasBeenActivated()

◆ touchBeginEvent()

◆ touchCancelEvent()

◆ touchEndEvent()

◆ touchHoldBeginEvent()

◆ touchUpdateEvent()

◆ tryActivateReadyShortcut()

◆ tryEndNativeGestureShortcut()

◆ tryEndRunningShortcut()

◆ tryEndTouchShortcut()

◆ tryRunNativeGestureShortcut()

◆ tryRunReadyShortcut()

◆ tryRunSingleActionShortcutImpl()

◆ tryRunTouchShortcut()

◆ tryRunWheelShortcut()

◆ wheelEvent()

Friends And Related Symbol Documentation

◆ KisInputManagerTest

Member Data Documentation

◆ actionGroupMask

◆ bestCandidateTouchEvent

◆ brokenByRecursion

◆ buttons

◆ candidateShortcuts