KisShortcutMatcher Class Reference

#include <kis_shortcut_matcher.h>

Inheritance diagram for KisShortcutMatcher:

Classes
struct	IgnoreMultiFingerCancelWorkaround
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 (KisTouchpadScrollShortcut *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	hasTouchpadScrollShortcuts () const
bool	ignoreMultiFingerCancelWorkaroundEnalbed () 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	setIgnoreMultiFingerCancelWorkaroundEnalbed (bool value)
void	setInputActionGroupsMaskCallback (std::function< KisInputActionGroupsMask()> func)
void	setTouchHoldDelay (int value)
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)
bool	touchEndEvent (QTouchEvent *event)
int	touchHoldDelay () const
bool	touchpadScrollBeginEvent (QWheelEvent *event)
bool	touchpadScrollEndEvent (QWheelEvent *event)
bool	touchpadScrollEvent (QWheelEvent *event)
bool	touchUpdateEvent (QTouchEvent *event)
bool	wheelEvent (KisSingleActionShortcut::WheelAction wheelAction, QWheelEvent *event)
	~KisShortcutMatcher ()
	~Private ()

Public Attributes
std::function< KisInputActionGroupsMask()>	actionGroupMask
QScopedPointer< QEvent >	bestCandidateForTapTouchEvent
int	brokenByRecursion = 0
QSet< Qt::MouseButton >	buttons
QList< KisStrokeShortcut * >	candidateShortcuts
bool	cursorEntered
std::optional< IgnoreMultiFingerCancelWorkaround >	ignoreMultiFingerCancelWorkaround
bool	isTouchDragDetected {false}
bool	isTouchHeld {false}
QSet< Qt::Key >	keys
QScopedPointer< QTouchEvent >	lastProcessedTouchEvent
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
bool	touchActionTracked {false}
int	touchHoldDelayMs {400}
std::optional< KisTouchHoldEventsPostponer >	touchHoldEventPostponer
KisTouchpadScrollShortcut *	touchpadScrollShortcut
QList< KisTouchpadScrollShortcut * >	touchpadScrollShortcuts
KisTouchShortcut *	touchShortcut
QList< KisTouchShortcut * >	touchShortcuts

Static Public Attributes
static constexpr qreal	TOUCH_SLOP = 16
static constexpr int	TOUCH_SLOP_SQUARED = 16 * 16

Private Types
enum class	TouchShortcutMode { Drag = 0 , Tap , Hold }

Private Member Functions
void	forceDeactivateAllActions ()
void	forceEndRunningShortcut (const QPointF &localPos)
KisTouchShortcut *	matchTouchShortcut (QTouchEvent *event, Qt::TouchPointStates allowedStates, TouchShortcutMode mode)
bool	matchTouchShortcutBasedOnState (QTouchEvent *event, KisTouchShortcut *shortcut, Qt::TouchPointStates allowedStates, TouchShortcutMode mode)
void	prepareReadyShortcuts ()
void	reset ()
void	reset (QString msg)
void	setMaxTouchPointEvent (QTouchEvent *event)
void	slotTouchHoldCompleted ()
bool	touchUpdateEventImpl (QTouchEvent *event)
void	tryActivateReadyShortcut ()
void	tryCancelAllCurrentTouchActionsImpl ()
template<typename EventType , typename ShortcutType >
bool	tryEndGestureBasedShortcutImpl (EventType *event, ShortcutType **resultShortcutPtr)
bool	tryEndNativeGestureShortcut (QNativeGestureEvent *event)
bool	tryEndRunningShortcut (Qt::MouseButton button, QEvent *event)
bool	tryEndTouchpadScrollShortcut (QWheelEvent *event)
bool	tryEndTouchShortcut (QTouchEvent *event)
bool	tryFireTapTouchShortcut (QTouchEvent *event, Qt::TouchPointStates allowedStates)
template<typename EventType , typename ShortcutType >
bool	tryRunGestureBasedShortcutImpl (EventType *event, ShortcutType **resultShortcutPtr, const QList< ShortcutType * > allTypedShortcuts)
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	tryRunTouchpadScrollShortcut (QWheelEvent *event)
bool	tryRunTouchShortcut (QTouchEvent *event, Qt::TouchPointStates allowedStates, TouchShortcutMode mode)
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 89 of file kis_shortcut_matcher.cpp.

Member Enumeration Documentation

TouchShortcutMode

enum class KisShortcutMatcher::TouchShortcutMode

strongprivate

Enumerator
Drag
Tap
Hold

Definition at line 320 of file kis_shortcut_matcher.h.

                                 {
        Drag = 0,
        Tap,
        Hold
    };

Constructor & Destructor Documentation

~Private()

KisShortcutMatcher::~Private ( )

inline

Definition at line 104 of file kis_shortcut_matcher.cpp.

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

KisShortcutMatcher()

KisShortcutMatcher::KisShortcutMatcher

(

)

Definition at line 218 of file kis_shortcut_matcher.cpp.

    : m_d(new Private)
{}

~KisShortcutMatcher()

KisShortcutMatcher::~KisShortcutMatcher

(

)

Definition at line 222 of file kis_shortcut_matcher.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

actionsSuppressed()

bool KisShortcutMatcher::actionsSuppressed ( ) const

inline

Definition at line 200 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 suppressAllActions;
#endif
    }

actionsSuppressedIgnoreFocus()

bool KisShortcutMatcher::actionsSuppressedIgnoreFocus ( ) const

inline

Definition at line 209 of file kis_shortcut_matcher.cpp.

                                                     {
        return suppressAllActions;
    }

addShortcut() [1/5]

void KisShortcutMatcher::addShortcut

(

KisNativeGestureShortcut *

shortcut

)

Definition at line 257 of file kis_shortcut_matcher.cpp.

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

References m_d.

addShortcut() [2/5]

void KisShortcutMatcher::addShortcut

(

KisSingleActionShortcut *

shortcut

)

Definition at line 242 of file kis_shortcut_matcher.cpp.

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

References m_d.

addShortcut() [3/5]

void KisShortcutMatcher::addShortcut

(

KisStrokeShortcut *

shortcut

)

Definition at line 247 of file kis_shortcut_matcher.cpp.

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

References m_d.

addShortcut() [4/5]

void KisShortcutMatcher::addShortcut

(

KisTouchpadScrollShortcut *

shortcut

)

Definition at line 262 of file kis_shortcut_matcher.cpp.

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

References m_d.

addShortcut() [5/5]

void KisShortcutMatcher::addShortcut

(

KisTouchShortcut *

shortcut

)

Definition at line 252 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 304 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 350 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
    DEBUG_BUTTON_ACTION("entered", button);
 
    // the tablet actions have the priority over any existing
    // touch action, so we should cancel them first
    tryCancelAllCurrentTouchActionsImpl();
 
    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(), tryCancelAllCurrentTouchActionsImpl(), 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 380 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 1101 of file kis_shortcut_matcher.cpp.

{
    reset("Clearing shortcuts");
 
    qDeleteAll(m_d->singleActionShortcuts);
    m_d->singleActionShortcuts.clear();
    m_d->suppressedSingleActionShortcuts.clear();
 
    qDeleteAll(m_d->strokeShortcuts);
    m_d->strokeShortcuts.clear();
 
    qDeleteAll(m_d->touchShortcuts);
    m_d->touchShortcuts.clear();
 
    qDeleteAll(m_d->nativeGestureShortcuts);
    m_d->nativeGestureShortcuts.clear();
 
    qDeleteAll(m_d->touchpadScrollShortcuts);
    m_d->touchpadScrollShortcuts.clear();
 
    m_d->candidateShortcuts.clear();
    m_d->runningShortcut = 0;
    m_d->readyShortcut = 0;
    m_d->touchShortcut = 0;
    m_d->nativeGestureShortcut = 0;
    m_d->touchpadScrollShortcut = 0;
}

References m_d, and reset().

debugPressedKeys()

QVector< Qt::Key > KisShortcutMatcher::debugPressedKeys

(

)

const

Return the internal state of the tracked modifiers.

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

forceDeactivateAllActions()

void KisShortcutMatcher::forceDeactivateAllActions ( )

private

Definition at line 1359 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 1334 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 975 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 1022 of file kis_shortcut_matcher.cpp.

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

References m_d.

hasRunningShortcut()

bool KisShortcutMatcher::hasRunningShortcut

(

)

const

Definition at line 227 of file kis_shortcut_matcher.cpp.

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

References m_d.

hasTouchHoldShortcut()

bool KisShortcutMatcher::hasTouchHoldShortcut

(

)

const

Definition at line 232 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.

hasTouchpadScrollShortcuts()

bool KisShortcutMatcher::hasTouchpadScrollShortcuts

(

)

const

Definition at line 874 of file kis_shortcut_matcher.cpp.

{
    return !m_d->touchpadScrollShortcuts.isEmpty();
}

References m_d.

ignoreMultiFingerCancelWorkaroundEnalbed()

bool KisShortcutMatcher::ignoreMultiFingerCancelWorkaroundEnalbed

(

)

const

See also

setIgnoreMultiFingerCancelWorkaroundEnalbed()

Definition at line 1612 of file kis_shortcut_matcher.cpp.

{
    return m_d->ignoreMultiFingerCancelWorkaround.has_value();
}

References m_d.

KeyboardActionsSuppressed()

bool KisShortcutMatcher::KeyboardActionsSuppressed ( ) const

inline

Definition at line 213 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 279 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 329 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 454 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 1027 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, Qt::TouchPointStates allowedStates, TouchShortcutMode mode )

private

Definition at line 1411 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, allowedStates, mode)
            && (!goodCandidate || shortcut->priority() > goodCandidate->priority())) {
 
            goodCandidate = shortcut;
        }
    }
    return goodCandidate;
}

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

matchTouchShortcutBasedOnState()

bool KisShortcutMatcher::matchTouchShortcutBasedOnState ( QTouchEvent * event, KisTouchShortcut * shortcut, Qt::TouchPointStates allowedStates, TouchShortcutMode mode )

private

Definition at line 1425 of file kis_shortcut_matcher.cpp.

{
    switch (mode) {
    case TouchShortcutMode::Hold:
        return shortcut->matchHoldType(event, allowedStates);
        break;
    case TouchShortcutMode::Drag:
        return shortcut->matchDragType(event, allowedStates);
        break;
    case TouchShortcutMode::Tap:
        return shortcut->matchTapType(event, allowedStates);
        break;
    }
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
    return false;
#else
    Q_UNREACHABLE_RETURN(false);
#endif
}

References Drag, Hold, KisTouchShortcut::matchDragType(), KisTouchShortcut::matchHoldType(), KisTouchShortcut::matchTapType(), and Tap.

nativeGestureBeginEvent()

bool KisShortcutMatcher::nativeGestureBeginEvent

(

QNativeGestureEvent *

event

)

Definition at line 826 of file kis_shortcut_matcher.cpp.

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

References DEBUG_EVENT_ACTION.

nativeGestureEndEvent()

bool KisShortcutMatcher::nativeGestureEndEvent

(

QNativeGestureEvent *

event

)

Definition at line 854 of file kis_shortcut_matcher.cpp.

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

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

nativeGestureEvent()

bool KisShortcutMatcher::nativeGestureEvent

(

QNativeGestureEvent *

event

)

Definition at line 837 of file kis_shortcut_matcher.cpp.

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

References DEBUG_EVENT_ACTION, 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 421 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 1171 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 92 of file kis_shortcut_matcher.cpp.

        : runningShortcut(0)
        , readyShortcut(0)
        , touchShortcut(0)
        , nativeGestureShortcut(0)
        , touchpadScrollShortcut(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 945 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 960 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 1062 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 1070 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 1002 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.

setIgnoreMultiFingerCancelWorkaroundEnalbed()

void KisShortcutMatcher::setIgnoreMultiFingerCancelWorkaroundEnalbed

(

bool

value

)

Enabled a workaround that allows processing 3+ finger tap shortcuts, even when the system sends QEvent::TouchCancel for them. Need on some Android devices.

Definition at line 1603 of file kis_shortcut_matcher.cpp.

{
    if (value) {
        m_d->ignoreMultiFingerCancelWorkaround = Private::IgnoreMultiFingerCancelWorkaround();
    } else {
        m_d->ignoreMultiFingerCancelWorkaround = std::nullopt;
    }
}

References m_d, and value().

setInputActionGroupsMaskCallback()

void KisShortcutMatcher::setInputActionGroupsMaskCallback

(

std::function< KisInputActionGroupsMask()>

func

)

Definition at line 1129 of file kis_shortcut_matcher.cpp.

{
    m_d->actionGroupMask = func;
}

References m_d.

setMaxTouchPointEvent()

void KisShortcutMatcher::setMaxTouchPointEvent ( QTouchEvent * event )

private

Definition at line 1368 of file kis_shortcut_matcher.cpp.

{
    int previousNumTouchPoints = -1;
 
    if (m_d->bestCandidateForTapTouchEvent) {
        QTouchEvent *bestTouchEvent = static_cast<QTouchEvent*>(m_d->bestCandidateForTapTouchEvent.data());
        previousNumTouchPoints = KisTouchShortcut::countTouchPoints(bestTouchEvent, KisTouchShortcut::pressedOnlyTouchStates());
    }
 
    const int newNumTouchPoints = KisTouchShortcut::countTouchPoints(event, KisTouchShortcut::pressedOnlyTouchStates());;
 
    if (newNumTouchPoints >= previousNumTouchPoints) {
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
        KoPointerEvent::copyQtPointerEvent(event, m_d->bestCandidateForTapTouchEvent);
#else
        m_d->bestCandidateForTapTouchEvent.reset(event->clone());
#endif
    }
}

References KisTouchShortcut::countTouchPoints(), m_d, and KisTouchShortcut::pressedOnlyTouchStates().

setTouchHoldDelay()

void KisShortcutMatcher::setTouchHoldDelay

(

int

value

)

Returns

the currently set delay for the touch-hold actions (milliseconds)

Definition at line 1598 of file kis_shortcut_matcher.cpp.

{
    m_d->touchHoldDelayMs = value;
}

References m_d, and value().

slotTouchHoldCompleted()

void KisShortcutMatcher::slotTouchHoldCompleted ( )

private

Definition at line 558 of file kis_shortcut_matcher.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->touchHoldEventPostponer);
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->touchHoldEventPostponer->state() == KisTouchHoldEventsPostponer::HoldCompleted);
 
    // Can happen when multiple shortcut sources interact
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_d->runningShortcut);
 
    // take the very first begin event to start the action
    QTouchEvent *event = m_d->touchHoldEventPostponer->postponedEvents().front();
    KIS_SAFE_ASSERT_RECOVER_RETURN(event->type() == QEvent::TouchBegin);
 
    m_d->isTouchHeld = true; // Must be set first, used in tryRunTouchShortcut.
 
    DEBUG_TOUCH_ACTION("entered", event);
 
    if (tryRunTouchShortcut(event, KisTouchShortcut::pressedOnlyTouchStates(), TouchShortcutMode::Hold)) {
        // noop, all is fine!
    } else {
        KIS_SAFE_ASSERT_RECOVER(0 && "should not happen")
        {
            // Shouldn't really happen, since KisInputManager checks whether a touch
            // hold shortcut exists beforehand. We'll just handle this though.
            m_d->isTouchHeld = false;
        }
    }
 
    // remove the postponer to continue processing events in-place
    m_d->touchHoldEventPostponer.reset();
}

References DEBUG_TOUCH_ACTION, Hold, KisTouchHoldEventsPostponer::HoldCompleted, KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisTouchShortcut::pressedOnlyTouchStates(), and tryRunTouchShortcut().

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 267 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()))
        || (m_d->touchpadScrollShortcut && m_d->touchpadScrollShortcut->action()
            && m_d->touchpadScrollShortcut->action()->supportsHiResInputEvents(m_d->touchpadScrollShortcut->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 1083 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 1048 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 468 of file kis_shortcut_matcher.cpp.

{
    DEBUG_TOUCH_ACTION("entered", event)
 
    Private::RecursionNotifier notifier(this);
 
    if (hasRunningShortcut()) {
        DEBUG_ACTION("touch action rejected by a running shortcut");
 
        // touch has been triggered while some tablet action is in progress,
        // just consume and ignore it
        return !notifier.isInRecursion();
    }
 
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QScopedPointer<QEvent> tmp;
    KoPointerEvent::copyQtPointerEvent(event, tmp);
    m_d->lastProcessedTouchEvent.reset(static_cast<QTouchEvent*>(tmp.take()));
#else
    m_d->lastProcessedTouchEvent.reset(event->clone());
#endif
 
    // reset state
    m_d->maxTouchPoints = KisTouchShortcut::countTouchPoints(event, KisTouchShortcut::pressedOnlyTouchStates());
    if (m_d->ignoreMultiFingerCancelWorkaround) {
        m_d->ignoreMultiFingerCancelWorkaround->lastRawTouchPointsCount = m_d->maxTouchPoints;
    }
    m_d->matchingIteration = 1;
    m_d->isTouchDragDetected = false;
    m_d->isTouchHeld = false;
    m_d->touchActionTracked = true;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    KoPointerEvent::copyQtPointerEvent(event, m_d->bestCandidateForTapTouchEvent);
#else
    m_d->bestCandidateForTapTouchEvent.reset(event->clone());
#endif
 
    // TODO: also check if the first point actually qualifies
    if (hasTouchHoldShortcut()) {
        m_d->touchHoldEventPostponer.emplace(TOUCH_SLOP, m_d->touchHoldDelayMs);
        QObject::connect(&m_d->touchHoldEventPostponer.value(),
                         &KisTouchHoldEventsPostponer::sigHoldCompleted,
                         [this]() {
                             slotTouchHoldCompleted();
                         });
        m_d->touchHoldEventPostponer->pushThrough(event);
        if (m_d->touchHoldEventPostponer->state() == KisTouchHoldEventsPostponer::HoldCancelled) {
            m_d->touchHoldEventPostponer.reset();
        } else {
            DEBUG_ACTION("thouch-hold timer is set up");
        }
    }
 
    return !notifier.isInRecursion();
}

References KisTouchShortcut::countTouchPoints(), DEBUG_ACTION, DEBUG_TOUCH_ACTION, hasRunningShortcut(), hasTouchHoldShortcut(), KisTouchHoldEventsPostponer::HoldCancelled, m_d, KisTouchShortcut::pressedOnlyTouchStates(), KisTouchHoldEventsPostponer::sigHoldCompleted(), and TOUCH_SLOP.

touchCancelEvent()

void KisShortcutMatcher::touchCancelEvent

(

QTouchEvent *

event

)

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 772 of file kis_shortcut_matcher.cpp.

{
    Q_UNUSED(event)
 
    // The design requirement of touch-cancel handling is the following:
    //
    // 1) If drag-action has already been started, it is finished normally
    // 2) If tap-action is pending, it is cancelled
    // 3) If hold-action is pending, it is cancelled
    // 4) If hold-action has already been started, it is ended normally
 
    // On some Android devices, such as Xiaomi Pads, the system always eats
    // multitouch inputs with more than two fingers, even if the user
    // disables all gestures related to them in their system settings or
    // uses the game boost mode that is supposed to disable gestures. So we
    // handle those inputs even when they are cancelled, if the user wants
    // to use it for a system gesture, they can disable the Krita shortcut.
    if (m_d->ignoreMultiFingerCancelWorkaround) {
        // NOTE: we cannot use the number of touch points from the actual
        // cancel event, since Qt sets touch points as empty for the cancel
        // event
        if (m_d->ignoreMultiFingerCancelWorkaround->lastRawTouchPointsCount >= 3) {
            DEBUG_ACTION("IgnoreMultiFingerCancelWorkaround: converting a cancelled action into a normally finished action")
            touchEndEvent(event);
            return;
        }
    }
 
    Private::RecursionNotifier notifier(this);
 
    DEBUG_TOUCH_ACTION("enter", event);
 
    // the touch action has been overridden by some tablet action,
    // consume and ignore it.
    if (!m_d->touchActionTracked) {
        KIS_SAFE_ASSERT_RECOVER(!m_d->touchHoldEventPostponer.has_value()) {
            m_d->touchHoldEventPostponer->cancelHoldWait();
            m_d->touchHoldEventPostponer.reset();
        }
        return;
    }
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->runningShortcut || !m_d->touchShortcut);
 
    tryCancelAllCurrentTouchActionsImpl();
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
}

References DEBUG_ACTION, DEBUG_TOUCH_ACTION, forceDeactivateAllActions(), hasRunningShortcut(), KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, prepareReadyShortcuts(), touchEndEvent(), tryActivateReadyShortcut(), and tryCancelAllCurrentTouchActionsImpl().

touchEndEvent()

bool KisShortcutMatcher::touchEndEvent

(

QTouchEvent *

event

)

Definition at line 686 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    DEBUG_TOUCH_ACTION("enter", event);
 
    // the touch action has been overridden by some tablet action,
    // consume and ignore it.
    if (!m_d->touchActionTracked) {
        DEBUG_ACTION("touch was not tracked");
        KIS_SAFE_ASSERT_RECOVER(!m_d->touchHoldEventPostponer.has_value()) {
            m_d->touchHoldEventPostponer->cancelHoldWait();
            m_d->touchHoldEventPostponer.reset();
        }
        return true;
    }
 
    // flush all the touch-hold postiponed events if they were present
    if (m_d->touchHoldEventPostponer) {
        DEBUG_ACTION("flushing all postponed hold events");
 
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->touchHoldEventPostponer->state() == KisTouchHoldEventsPostponer::WaitingForHold);
        m_d->touchHoldEventPostponer->cancelHoldWait();
        // process all the postponed **update** events,
        // the very first begin event is only used in
        // the hold-completion operation
        Q_FOREACH (QTouchEvent *event, m_d->touchHoldEventPostponer->postponedEvents()) {
            if (event->type() == QEvent::TouchUpdate) {
                (void) touchUpdateEventImpl(event);
            }
        }
        m_d->touchHoldEventPostponer.reset();
    }
 
    m_d->touchActionTracked = false;
 
    bool retval = false;
 
    if (!m_d->isTouchDragDetected && m_d->bestCandidateForTapTouchEvent && !hasRunningShortcut()) {
        retval = tryFireTapTouchShortcut(static_cast<QTouchEvent *>(m_d->bestCandidateForTapTouchEvent.data()),
                                         KisTouchShortcut::allTouchStates());
    }
 
    // we should try and end the shortcut too (it might be that there is none? (sketch))
    retval |= tryEndTouchShortcut(event);
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return retval;
}

References KisTouchShortcut::allTouchStates(), DEBUG_ACTION, DEBUG_TOUCH_ACTION, forceDeactivateAllActions(), hasRunningShortcut(), KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, prepareReadyShortcuts(), touchUpdateEventImpl(), tryActivateReadyShortcut(), tryEndTouchShortcut(), tryFireTapTouchShortcut(), void(), and KisTouchHoldEventsPostponer::WaitingForHold.

touchHoldDelay()

int KisShortcutMatcher::touchHoldDelay

(

)

const

Returns

the currently set delay for the touch-hold actions (milliseconds)

Definition at line 1593 of file kis_shortcut_matcher.cpp.

{
    return m_d->touchHoldDelayMs;
}

References m_d.

touchpadScrollBeginEvent()

bool KisShortcutMatcher::touchpadScrollBeginEvent

(

QWheelEvent *

event

)

Definition at line 879 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    if (notifier.isInRecursion()) return false;
 
    DEBUG_EVENT_ACTION("entered", event);
 
    if (!hasRunningShortcut()) {
        tryRunTouchpadScrollShortcut(event);
    }
 
    if (m_d->touchpadScrollShortcut) {
        m_d->touchpadScrollShortcut->action()->inputEvent(event);
    }
 
    return bool(m_d->touchpadScrollShortcut);
}

References DEBUG_EVENT_ACTION, hasRunningShortcut(), m_d, and tryRunTouchpadScrollShortcut().

touchpadScrollEndEvent()

bool KisShortcutMatcher::touchpadScrollEndEvent

(

QWheelEvent *

event

)

Definition at line 913 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    if (notifier.isInRecursion()) return false;
 
    DEBUG_EVENT_ACTION("entered", event);
 
    bool retval = false;
 
    if (m_d->touchpadScrollShortcut) {
        retval = tryEndTouchpadScrollShortcut(event);
    }
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return retval;
}

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

touchpadScrollEvent()

bool KisShortcutMatcher::touchpadScrollEvent

(

QWheelEvent *

event

)

Definition at line 898 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    if (notifier.isInRecursion()) return false;
 
    DEBUG_EVENT_ACTION("entered", event);
 
    if (m_d->touchpadScrollShortcut) {
        m_d->touchpadScrollShortcut->action()->inputEvent(event);
    }
 
    return bool(m_d->touchpadScrollShortcut);
}

References DEBUG_EVENT_ACTION, and m_d.

touchUpdateEvent()

bool KisShortcutMatcher::touchUpdateEvent

(

QTouchEvent *

event

)

Definition at line 524 of file kis_shortcut_matcher.cpp.

{
    // the touch action has been overridden by some tablet action,
    // consume and ignore it.
    if (!m_d->touchActionTracked) return false;
 
    if (m_d->ignoreMultiFingerCancelWorkaround) {
        m_d->ignoreMultiFingerCancelWorkaround->lastRawTouchPointsCount =
            KisTouchShortcut::countTouchPoints(event, KisTouchShortcut::pressedOnlyTouchStates());
    }
 
    if (m_d->touchHoldEventPostponer) {
        m_d->touchHoldEventPostponer->pushThrough(event);
        if (m_d->touchHoldEventPostponer->state() == KisTouchHoldEventsPostponer::HoldCancelled) {
            // process all the postponed **update** events,
            // the very first begin event is only used in
            // the hold-completion operation
            Q_FOREACH (QTouchEvent *event, m_d->touchHoldEventPostponer->postponedEvents()) {
                if (event->type() == QEvent::TouchUpdate) {
                    (void) touchUpdateEventImpl(event);
                }
            }
            m_d->touchHoldEventPostponer.reset();
        } else {
            // noop, we are waiting for hold
        }
    } else {
        // TODO: don't enter for hold-drag events
        return touchUpdateEventImpl(event);
    }
 
    return true;
}

References KisTouchShortcut::countTouchPoints(), KisTouchHoldEventsPostponer::HoldCancelled, m_d, KisTouchShortcut::pressedOnlyTouchStates(), touchUpdateEventImpl(), and void().

touchUpdateEventImpl()

bool KisShortcutMatcher::touchUpdateEventImpl ( QTouchEvent * event )

private

Definition at line 589 of file kis_shortcut_matcher.cpp.

{
    if (_41020().isDebugEnabled()) {
        const int oldNumPressedPoints = KisTouchShortcut::countTouchPoints(m_d->lastProcessedTouchEvent.data(), KisTouchShortcut::pressedOnlyTouchStates());
        const int newNumPressedPoints = KisTouchShortcut::countTouchPoints(event, KisTouchShortcut::pressedOnlyTouchStates());
        if (oldNumPressedPoints != newNumPressedPoints) {
            DEBUG_TOUCH_ACTION("touch point state changed", event)
        }
    }
 
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QScopedPointer<QEvent> tmp;
    KoPointerEvent::copyQtPointerEvent(event, tmp);
    m_d->lastProcessedTouchEvent.reset(static_cast<QTouchEvent*>(tmp.take()));
#else
    m_d->lastProcessedTouchEvent.reset(event->clone());
#endif
 
    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;
 
    // Check whether the touchpoints are relatively stationary or have
    // been moved for dragging. If the drag is detected, until the next
    // TouchBegin event, we'll be assuming the gesture to be of
    // dragging type.
    if (!m_d->isTouchDragDetected) {
        if (KisTouchShortcut::touchDragDistance(event, KisTouchShortcut::allTouchStates()) > TOUCH_SLOP) {
            m_d->isTouchDragDetected = true;
        }
    }
 
    // Different drag shortcuts can have different drag thresholds. E.g.
    // touch-painting shortcut will have much lower threshold value. The
    // shortcuts will calculate the distance themselves in
    // KisTouchShortcut::matchDragType, so we should just ask them to do that.
    const int numStillDraggedPoints =
        KisTouchShortcut::countTouchPoints(event, KisTouchShortcut::pressedOnlyTouchStates());
    if (!hasRunningShortcut() && numStillDraggedPoints >= m_d->maxTouchPoints) {
        m_d->maxTouchPoints = numStillDraggedPoints;
        if (tryRunTouchShortcut(event, KisTouchShortcut::pressedOnlyTouchStates(), TouchShortcutMode::Drag)) {
            m_d->isTouchDragDetected = true;
            return true;
        }
    }
 
    // 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);
        return matchTouchShortcut((QTouchEvent *)m_d->bestCandidateForTapTouchEvent.data(),
                                  KisTouchShortcut::allTouchStates(),
                                  TouchShortcutMode::Tap);
    }
 
    if (m_d->isTouchDragDetected) {
        if (m_d->touchShortcut
            // TODO: use a different check without threshold! split into match() and matchBegin()
            && !m_d->touchShortcut->matchDragType(event, KisTouchShortcut::pressedOnlyTouchStates())) {
            // we should end the event as an event with more touchpoints was received
            retval = tryEndTouchShortcut(event);
        } else if (m_d->touchShortcut) {
            m_d->touchShortcut->action()->inputEvent(event);
            retval = true;
        }
    } else { // !m_d->isTouchDragDetected
        // triggered if a new finger was added, which might result in shortcut not matching the action
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
        const auto FlagReleased = Qt::TouchPointReleased;
#else
        const auto FlagReleased = QEventPoint::Released;
#endif
        if (event->touchPointStates().testFlag(FlagReleased) && !hasRunningShortcut()) {
            const int previousNumPoints = KisTouchShortcut::countTouchPoints(event, KisTouchShortcut::allTouchStates());
 
            // we should end the event as an event with more touchpoints was received
            if (previousNumPoints >= m_d->maxTouchPoints) {
                m_d->maxTouchPoints = previousNumPoints;
                if (tryFireTapTouchShortcut(event, KisTouchShortcut::allTouchStates())) {
                    m_d->bestCandidateForTapTouchEvent.reset();
                    retval = true;
                }
            }
        }
    }
    // TODO: update maxTouchPoints
 
    return retval;
}

References _41020(), KisTouchShortcut::allTouchStates(), KisTouchShortcut::countTouchPoints(), DEBUG_TOUCH_ACTION, Drag, hasRunningShortcut(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, matchTouchShortcut(), KisTouchShortcut::pressedOnlyTouchStates(), setMaxTouchPointEvent(), Tap, TOUCH_SLOP, KisTouchShortcut::touchDragDistance(), tryEndTouchShortcut(), tryFireTapTouchShortcut(), 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 1248 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) {
            if (goodCandidate->action() == m_d->readyShortcut->action() &&
                goodCandidate->action()->trySwitchShortcut(
                    m_d->readyShortcut->shortcutIndex(), goodCandidate->shortcutIndex())) {
                DEBUG_SHORTCUT("Switched previous shortcut action", m_d->readyShortcut);
                m_d->readyShortcut = goodCandidate;
            } else {
                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(), KisAbstractShortcut::shortcutIndex, and KisAbstractInputAction::trySwitchShortcut().

tryCancelAllCurrentTouchActionsImpl()

void KisShortcutMatcher::tryCancelAllCurrentTouchActionsImpl ( )

private

Definition at line 742 of file kis_shortcut_matcher.cpp.

{
    // discard all the postponed touch-hold events
    if (m_d->touchHoldEventPostponer) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->touchHoldEventPostponer->state() == KisTouchHoldEventsPostponer::WaitingForHold);
        m_d->touchHoldEventPostponer->cancelHoldWait();
        m_d->touchHoldEventPostponer.reset();
    }
 
    // end the touch action if present
    if (m_d->touchShortcut) {
        DEBUG_ACTION("force-cancel touch action")
 
        KisTouchShortcut *touchShortcut = m_d->touchShortcut;
        m_d->touchShortcut = 0;
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->lastProcessedTouchEvent);
 
        // on some platforms touch-cancel event may have **no**
        // touch points, which would greatly confuse our KoPointerEvent
        // class, so we should just generate a normal touch-end from the
        // last known event
        QTouchEvent touchEvent = generateFakeTouchEndEvent(m_d->lastProcessedTouchEvent.data());
        touchShortcut->action()->end(&touchEvent);
        touchShortcut->action()->deactivate(touchShortcut->shortcutIndex());
    }
 
    m_d->touchActionTracked = false;
}

References KisAbstractShortcut::action, KisAbstractInputAction::deactivate(), DEBUG_ACTION, KisAbstractInputAction::end(), KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisAbstractShortcut::shortcutIndex, touchShortcut, and KisTouchHoldEventsPostponer::WaitingForHold.

tryEndGestureBasedShortcutImpl()

template<typename EventType , typename ShortcutType >

bool KisShortcutMatcher::tryEndGestureBasedShortcutImpl ( EventType * event, ShortcutType ** resultShortcutPtr )

private

Definition at line 1546 of file kis_shortcut_matcher.cpp.

{
    Private::RecursionNotifier notifier(this);
 
    if (*resultShortcutPtr) {
        // first reset running shortcut to avoid infinite recursion via end()
        ShortcutType *runningShortcut = *resultShortcutPtr;
        *resultShortcutPtr = nullptr;
 
        DEBUG_SHORTCUT("ending", runningShortcut)
 
        runningShortcut->action()->end(event);
        runningShortcut->action()->deactivate(runningShortcut->shortcutIndex());
 
        return true;
    }
 
    if (notifier.isInRecursion()) {
        forceDeactivateAllActions();
    } else if (!hasRunningShortcut()) {
        prepareReadyShortcuts();
        tryActivateReadyShortcut();
    }
 
    return false;
}

References KisAbstractShortcut::action, KisAbstractInputAction::deactivate(), DEBUG_SHORTCUT, KisAbstractInputAction::end(), forceDeactivateAllActions(), hasRunningShortcut(), prepareReadyShortcuts(), runningShortcut, KisAbstractShortcut::shortcutIndex, and tryActivateReadyShortcut().

tryEndNativeGestureShortcut()

bool KisShortcutMatcher::tryEndNativeGestureShortcut ( QNativeGestureEvent * event )

private

Definition at line 1578 of file kis_shortcut_matcher.cpp.

{
    return tryEndGestureBasedShortcutImpl(event, &m_d->nativeGestureShortcut);
}

References m_d, and tryEndGestureBasedShortcutImpl().

tryEndRunningShortcut()

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

private

Definition at line 1292 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();
 
            // Keep keyed stroke shortcuts in ready state between repeated
            // button strokes while their activation keys are still held.
            QSet<Qt::MouseButton> buttonsAfterRelease = m_d->buttons;
            buttonsAfterRelease.remove(button);
            const bool keepReadyShortcut =
                !m_d->keys.isEmpty() &&
                runningShortcut->isAvailable(m_d->actionGroupMask()) &&
                runningShortcut->matchReady(m_d->keys, buttonsAfterRelease);
 
            action->end(event);
 
            if (keepReadyShortcut) {
                m_d->readyShortcut = runningShortcut;
            } else {
                action->deactivate(shortcutIndex);
            }
        }
    }
 
    return !m_d->runningShortcut;
}

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

tryEndTouchpadScrollShortcut()

bool KisShortcutMatcher::tryEndTouchpadScrollShortcut ( QWheelEvent * event )

private

Definition at line 1588 of file kis_shortcut_matcher.cpp.

{
    return tryEndGestureBasedShortcutImpl(event, &m_d->touchpadScrollShortcut);
}

References m_d, and tryEndGestureBasedShortcutImpl().

tryEndTouchShortcut()

bool KisShortcutMatcher::tryEndTouchShortcut ( QTouchEvent * event )

private

Definition at line 1485 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.

tryFireTapTouchShortcut()

bool KisShortcutMatcher::tryFireTapTouchShortcut ( QTouchEvent * event, Qt::TouchPointStates allowedStates )

private

Touch actions don't usually send focus events, since they have no hover functionality, so they should be triggered unrelated to the current focus state.

Definition at line 1388 of file kis_shortcut_matcher.cpp.

{
    if (m_d->actionsSuppressedIgnoreFocus())
        return false;
 
    KisTouchShortcut *goodCandidate = matchTouchShortcut(event, allowedStates, TouchShortcutMode::Tap);
    if (goodCandidate) {
        DEBUG_SHORTCUT("Starting new touch-tap action", goodCandidate);
        goodCandidate->action()->activate(goodCandidate->shortcutIndex());
        goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
 
        goodCandidate->action()->end(event);
        goodCandidate->action()->deactivate(goodCandidate->shortcutIndex());
    }
 
    return goodCandidate;
}

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

tryRunGestureBasedShortcutImpl()

template<typename EventType , typename ShortcutType >

bool KisShortcutMatcher::tryRunGestureBasedShortcutImpl ( EventType * event, ShortcutType ** resultShortcutPtr, const QList< ShortcutType * > allTypedShortcuts )

private

Definition at line 1504 of file kis_shortcut_matcher.cpp.

{
    ShortcutType *goodCandidate = 0;
 
    if (m_d->actionsSuppressed())
        return false;
 
    Q_FOREACH (ShortcutType* shortcut, allTypedShortcuts) {
        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();
 
        *resultShortcutPtr = goodCandidate;
 
        Private::RecursionGuard guard(this);
 
        DEBUG_SHORTCUT("starting", 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);
            *resultShortcutPtr = 0;
 
            forceDeactivateAllActions();
        }
    }
 
    return bool(*resultShortcutPtr);
}

References DEBUG_SHORTCUT, forceDeactivateAllActions(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and m_d.

tryRunNativeGestureShortcut()

bool KisShortcutMatcher::tryRunNativeGestureShortcut ( QNativeGestureEvent * event )

private

Definition at line 1573 of file kis_shortcut_matcher.cpp.

{
    return tryRunGestureBasedShortcutImpl(event, &m_d->nativeGestureShortcut, m_d->nativeGestureShortcuts);
}

References m_d, and tryRunGestureBasedShortcutImpl().

tryRunReadyShortcut()

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

private

Definition at line 1197 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) {
                if (goodCandidate->action() == m_d->readyShortcut->action() &&
                    goodCandidate->action()->trySwitchShortcut(
                        m_d->readyShortcut->shortcutIndex(), goodCandidate->shortcutIndex())) {
                    m_d->readyShortcut = goodCandidate;
                } else {
                    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(), KisAbstractShortcut::shortcutIndex, and KisAbstractInputAction::trySwitchShortcut().

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 1141 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.

tryRunTouchpadScrollShortcut()

bool KisShortcutMatcher::tryRunTouchpadScrollShortcut ( QWheelEvent * event )

private

Definition at line 1583 of file kis_shortcut_matcher.cpp.

{
    return tryRunGestureBasedShortcutImpl(event, &m_d->touchpadScrollShortcut, m_d->touchpadScrollShortcuts);
}

References m_d, and tryRunGestureBasedShortcutImpl().

tryRunTouchShortcut()

bool KisShortcutMatcher::tryRunTouchShortcut ( QTouchEvent * event, Qt::TouchPointStates allowedStates, TouchShortcutMode mode )

private

Touch actions don't usually send focus events, since they have no hover functionality, so they should be triggered unrelated to the current focus state.

Definition at line 1446 of file kis_shortcut_matcher.cpp.

{
    KisTouchShortcut *goodCandidate = matchTouchShortcut(event, allowedStates, mode);
 
    if (m_d->actionsSuppressedIgnoreFocus())
        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 new touch action", 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 1134 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 408 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 315 of file kis_shortcut_matcher.h.

Member Data Documentation

actionGroupMask

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

Definition at line 155 of file kis_shortcut_matcher.cpp.

bestCandidateForTapTouchEvent

QScopedPointer<QEvent> KisShortcutMatcher::bestCandidateForTapTouchEvent

Definition at line 137 of file kis_shortcut_matcher.cpp.

brokenByRecursion

int KisShortcutMatcher::brokenByRecursion = 0

Definition at line 161 of file kis_shortcut_matcher.cpp.

buttons

QSet<Qt::MouseButton> KisShortcutMatcher::buttons

Definition at line 119 of file kis_shortcut_matcher.cpp.

candidateShortcuts

QList<KisStrokeShortcut*> KisShortcutMatcher::candidateShortcuts

Definition at line 125 of file kis_shortcut_matcher.cpp.

cursorEntered

bool KisShortcutMatcher::cursorEntered

Definition at line 158 of file kis_shortcut_matcher.cpp.

ignoreMultiFingerCancelWorkaround

std::optional<IgnoreMultiFingerCancelWorkaround> KisShortcutMatcher::ignoreMultiFingerCancelWorkaround

Definition at line 153 of file kis_shortcut_matcher.cpp.

isTouchDragDetected

bool KisShortcutMatcher::isTouchDragDetected {false}

Definition at line 135 of file kis_shortcut_matcher.cpp.

{false};

isTouchHeld

bool KisShortcutMatcher::isTouchHeld {false}

Definition at line 136 of file kis_shortcut_matcher.cpp.

{false};

keys

QSet<Qt::Key> KisShortcutMatcher::keys

Definition at line 118 of file kis_shortcut_matcher.cpp.

lastProcessedTouchEvent

QScopedPointer<QTouchEvent> KisShortcutMatcher::lastProcessedTouchEvent

Definition at line 138 of file kis_shortcut_matcher.cpp.

m_d

Private* const KisShortcutMatcher::m_d

private

Definition at line 361 of file kis_shortcut_matcher.h.

matchingIteration

int KisShortcutMatcher::matchingIteration {0}

Definition at line 134 of file kis_shortcut_matcher.cpp.

{0};

maxTouchPoints

int KisShortcutMatcher::maxTouchPoints {0}

Definition at line 133 of file kis_shortcut_matcher.cpp.

{0};

nativeGestureShortcut

KisNativeGestureShortcut* KisShortcutMatcher::nativeGestureShortcut

Definition at line 128 of file kis_shortcut_matcher.cpp.

nativeGestureShortcuts

QList<KisNativeGestureShortcut*> KisShortcutMatcher::nativeGestureShortcuts

Definition at line 115 of file kis_shortcut_matcher.cpp.

polledKeys

QSet<Qt::Key> KisShortcutMatcher::polledKeys

Definition at line 121 of file kis_shortcut_matcher.cpp.

readyShortcut

KisStrokeShortcut* KisShortcutMatcher::readyShortcut

Definition at line 124 of file kis_shortcut_matcher.cpp.

recursiveCounter

int KisShortcutMatcher::recursiveCounter = 0

Definition at line 160 of file kis_shortcut_matcher.cpp.

runningShortcut

KisStrokeShortcut* KisShortcutMatcher::runningShortcut

Definition at line 123 of file kis_shortcut_matcher.cpp.

singleActionShortcuts

QList<KisSingleActionShortcut*> KisShortcutMatcher::singleActionShortcuts

Definition at line 111 of file kis_shortcut_matcher.cpp.

strokeShortcuts

QList<KisStrokeShortcut*> KisShortcutMatcher::strokeShortcuts

Definition at line 113 of file kis_shortcut_matcher.cpp.

suppressAllActions

void KisShortcutMatcher::suppressAllActions

Definition at line 156 of file kis_shortcut_matcher.cpp.

suppressAllKeyboardActions

void KisShortcutMatcher::suppressAllKeyboardActions

Definition at line 157 of file kis_shortcut_matcher.cpp.

suppressedSingleActionShortcuts

QSet<KisSingleActionShortcut*> KisShortcutMatcher::suppressedSingleActionShortcuts

Definition at line 112 of file kis_shortcut_matcher.cpp.

TOUCH_SLOP

constexpr qreal KisShortcutMatcher::TOUCH_SLOP = 16

staticconstexpr

Definition at line 79 of file kis_shortcut_matcher.h.

TOUCH_SLOP_SQUARED

constexpr int KisShortcutMatcher::TOUCH_SLOP_SQUARED = 16 * 16

staticconstexpr

Definition at line 78 of file kis_shortcut_matcher.h.

touchActionTracked

bool KisShortcutMatcher::touchActionTracked {false}

Definition at line 139 of file kis_shortcut_matcher.cpp.

{false};

touchHoldDelayMs

int KisShortcutMatcher::touchHoldDelayMs {400}

Definition at line 140 of file kis_shortcut_matcher.cpp.

{400};

touchHoldEventPostponer

std::optional<KisTouchHoldEventsPostponer> KisShortcutMatcher::touchHoldEventPostponer

Definition at line 130 of file kis_shortcut_matcher.cpp.

touchpadScrollShortcut

KisTouchpadScrollShortcut* KisShortcutMatcher::touchpadScrollShortcut

Definition at line 129 of file kis_shortcut_matcher.cpp.

touchpadScrollShortcuts

QList<KisTouchpadScrollShortcut*> KisShortcutMatcher::touchpadScrollShortcuts

Definition at line 116 of file kis_shortcut_matcher.cpp.

touchShortcut

KisTouchShortcut* KisShortcutMatcher::touchShortcut

Definition at line 127 of file kis_shortcut_matcher.cpp.

touchShortcuts

QList<KisTouchShortcut*> KisShortcutMatcher::touchShortcuts

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