KisInputManager::Private Class Reference

#include <kis_input_manager_p.h>

Classes
class	CanvasSwitcher
class	ProximityNotifier
class	TabletLatencyTracker

Public Types
typedef QList< PriorityPair >	PriorityList
typedef QPair< int, QPointer< QObject > >	PriorityPair

Public Member Functions
void	addKeyShortcut (KisAbstractInputAction *action, int index, const QList< Qt::Key > &keys)
bool	addNativeGestureShortcut (KisAbstractInputAction *action, int index, KisShortcutConfiguration::NativeGestureAction gesture)
void	addStrokeShortcut (KisAbstractInputAction *action, int index, const QList< Qt::Key > &modifiers, Qt::MouseButtons buttons)
void	addTouchShortcut (KisAbstractInputAction *action, int index, KisShortcutConfiguration::TouchGestureAction gesture, bool isTouchPainting=false)
void	addWheelShortcut (KisAbstractInputAction *action, int index, const QList< Qt::Key > &modifiers, KisShortcutConfiguration::MouseWheelMovement wheelAction)
void	fixShortcutMatcherModifiersState ()
void	fixShortcutMatcherModifiersState (QVector< Qt::Key > newKeys, Qt::KeyboardModifiers modifiers)
bool	handleCompressedTabletEvent (QEvent *event)
	Private (KisInputManager *qq)
bool	processUnhandledEvent (QEvent *event)
void	resetCompressor ()
void	setMaskSyntheticEvents (bool value)
void	setupActions ()

Public Attributes
QPoint	accumulatedScrollDelta
QPointer< KisCanvas2 >	canvas
CanvasSwitcher	canvasSwitcher
QScopedPointer< QEvent >	compressedMoveEvent
KisToolInvocationAction *	defaultInputAction = 0
KisInputEventsEater	eventEater
QObject *	eventsReceiver = 0
bool	forwardAllEventsToTool = false
KisShortcutMatcher	matcher
KisSignalCompressor	moveEventCompressor
bool	popupWasActive = false
KisPopupWidgetInterface *	popupWidget
PriorityList	priorityEventFilter
int	priorityEventFilterSeqNo
KisInputManager *	q
bool	shouldSynchronizeOnNextKeyPress = false
KisSharedPtr< TabletLatencyTracker >	tabletLatencyTracker
bool	testingAcceptCompressedTabletEvents = false
bool	testingCompressBrushEvents = false
QPointer< KisToolProxy >	toolProxy
bool	useUnbalancedKeyPressEventWorkaround = false

Detailed Description

Definition at line 26 of file kis_input_manager_p.h.

Member Typedef Documentation

PriorityList

typedef QList<PriorityPair> KisInputManager::Private::PriorityList

Definition at line 59 of file kis_input_manager_p.h.

PriorityPair

typedef QPair<int, QPointer<QObject> > KisInputManager::Private::PriorityPair

Definition at line 58 of file kis_input_manager_p.h.

Constructor & Destructor Documentation

Private()

KisInputManager::Private::Private

(

KisInputManager *

qq

)

On Windows and Linux we have a proper fix for this bug patched into our local version of Qt. We don't have a fix for macOS

In Linux distributions Qt is not patched, so we should use workaround for them

Definition at line 38 of file kis_input_manager_p.cpp.

    : q(qq)
    , moveEventCompressor(10 /* ms */,
                          KisSignalCompressor::FIRST_ACTIVE,
                          KisSignalCompressor::ADDITIVE_INTERVAL)
    , priorityEventFilterSeqNo(0)
    , popupWidget(nullptr)
    , canvasSwitcher(this, qq)
{
    KisConfig cfg(true);
 
    moveEventCompressor.setDelay(cfg.tabletEventsDelay());
    testingAcceptCompressedTabletEvents = cfg.testingAcceptCompressedTabletEvents();
    testingCompressBrushEvents = cfg.testingCompressBrushEvents();
 
    if (cfg.trackTabletEventLatency()) {
        tabletLatencyTracker = new TabletLatencyTracker();
    }
 
    matcher.setInputActionGroupsMaskCallback(
        [this] () {
            return this->canvas ? this->canvas->inputActionGroupsMaskInterface()->inputActionGroupsMask() : AllActionGroup;
        });
 
#ifdef Q_OS_ANDROID
    // a workaround for Xiaomi tablets
    matcher.setIgnoreMultiFingerCancelWorkaroundEnalbed(true);
#endif
 
#ifdef Q_OS_MACOS
    useUnbalancedKeyPressEventWorkaround = true;
#endif
 
#if defined Q_OS_LINUX &&  !KRITA_QT_HAS_UNBALANCED_KEY_PRESS_RELEASE_PATCH
    useUnbalancedKeyPressEventWorkaround = true;
#endif
 
    if (qEnvironmentVariableIsSet("KRITA_FIX_UNBALANCED_KEY_EVENTS")) {
        useUnbalancedKeyPressEventWorkaround = qEnvironmentVariableIntValue("KRITA_FIX_UNBALANCED_KEY_EVENTS");
    }
}

References AllActionGroup, canvas, matcher, moveEventCompressor, KisSignalCompressor::setDelay(), KisShortcutMatcher::setIgnoreMultiFingerCancelWorkaroundEnalbed(), KisShortcutMatcher::setInputActionGroupsMaskCallback(), KisConfig::tabletEventsDelay(), tabletLatencyTracker, testingAcceptCompressedTabletEvents, KisConfig::testingAcceptCompressedTabletEvents(), testingCompressBrushEvents, KisConfig::testingCompressBrushEvents(), KisConfig::trackTabletEventLatency(), and useUnbalancedKeyPressEventWorkaround.

Member Function Documentation

addKeyShortcut()

void KisInputManager::Private::addKeyShortcut	(	KisAbstractInputAction *	action,
		int	index,
		const QList< Qt::Key > &	keys )

Definition at line 339 of file kis_input_manager_p.cpp.

{
    if (keys.size() == 0) return;
 
    KisSingleActionShortcut *keyShortcut =
        new KisSingleActionShortcut(action, index);
 
    //Note: Ordering is important here, Shift + V is different from V + Shift,
    //which is the reason we use the last key here since most users will enter
    //shortcuts as "Shift + V". Ideally this should not happen, but this is
    //the way the shortcut matcher is currently implemented.
    QList<Qt::Key> allKeys = keys;
    Qt::Key key = allKeys.takeLast();
    QSet<Qt::Key> modifiers = QSet<Qt::Key>(allKeys.begin(), allKeys.end());
    keyShortcut->setKey(modifiers, key);
    matcher.addShortcut(keyShortcut);
}

References KisShortcutMatcher::addShortcut(), matcher, and KisSingleActionShortcut::setKey().

addNativeGestureShortcut()

bool KisInputManager::Private::addNativeGestureShortcut	(	KisAbstractInputAction *	action,
		int	index,
		KisShortcutConfiguration::NativeGestureAction	gesture )

Definition at line 430 of file kis_input_manager_p.cpp.

{
    auto addNativeGesture = [&] (KisNativeGestureShortcut::Type type) {
        KisNativeGestureShortcut *shortcut = new KisNativeGestureShortcut(action, index, type);
        matcher.addShortcut(shortcut);
    };
 
    // Native gestures:
    // Qt5 only implements QNativeGestureEvent for macOS
    // Qt6 implements QNativeGestureEvent for macOS and Wayland
    //
    // Touchpad pixel scrolling:
    // Qt5 only implements touchpad pixel scrolling for macOS
    // Qt6 implements touchpad pixel scrolling for macOS and Wayland
 
    switch (gesture) {
        case KisShortcutConfiguration::PinchGesture:
            addNativeGesture(KisNativeGestureShortcut::PinchNavigation);
            break;
        case KisShortcutConfiguration::SmartZoomGesture:
            addNativeGesture(KisNativeGestureShortcut::SmartZoomNativeGesture);
            break;
        case KisShortcutConfiguration::TouchpadScroll:
            matcher.addShortcut(new KisTouchpadScrollShortcut(action, index));
            break;
        default:
            return false;
    }
 
    return true;
}

References KisShortcutMatcher::addShortcut(), matcher, KisShortcutConfiguration::PinchGesture, KisNativeGestureShortcut::PinchNavigation, KisShortcutConfiguration::SmartZoomGesture, KisNativeGestureShortcut::SmartZoomNativeGesture, and KisShortcutConfiguration::TouchpadScroll.

addStrokeShortcut()

void KisInputManager::Private::addStrokeShortcut	(	KisAbstractInputAction *	action,
		int	index,
		const QList< Qt::Key > &	modifiers,
		Qt::MouseButtons	buttons )

Definition at line 310 of file kis_input_manager_p.cpp.

{
    KisStrokeShortcut *strokeShortcut =
        new KisStrokeShortcut(action, index);
 
    QSet<Qt::MouseButton> buttonSet;
    if(buttons & Qt::LeftButton) {
        buttonSet << Qt::LeftButton;
    }
    if(buttons & Qt::RightButton) {
        buttonSet << Qt::RightButton;
    }
    if(buttons & Qt::MiddleButton) {
        buttonSet << Qt::MiddleButton;
    }
 
BOOST_PP_REPEAT_FROM_TO(1, 25, EXTRA_BUTTON, _)
 
    if (!buttonSet.empty()) {
        strokeShortcut->setButtons(QSet<Qt::Key>(modifiers.cbegin(), modifiers.cend()), buttonSet);
        matcher.addShortcut(strokeShortcut);
    }
    else {
        delete strokeShortcut;
    }
}

References KisShortcutMatcher::addShortcut(), buttons(), EXTRA_BUTTON, matcher, and KisStrokeShortcut::setButtons().

addTouchShortcut()

void KisInputManager::Private::addTouchShortcut	(	KisAbstractInputAction *	action,
		int	index,
		KisShortcutConfiguration::TouchGestureAction	gesture,
		bool	isTouchPainting = false )

Definition at line 390 of file kis_input_manager_p.cpp.

{
    KisTouchShortcut *shortcut = new KisTouchShortcut(action, index, gesture);
    if (isTouchPainting) {
        shortcut->setIsTouchPainting(true);
        shortcut->setMinDragThreshold(1.5); // min threshold for touch painting is 1.5 px
    }
    dbgKrita << "TouchAction:" << action->name() << (isTouchPainting ? "touch-painting" : "");
    switch(gesture) {
    case KisShortcutConfiguration::OneFingerTap:
    case KisShortcutConfiguration::OneFingerDrag:
    case KisShortcutConfiguration::OneFingerHold:
        shortcut->setMinimumTouchPoints(1);
        shortcut->setMaximumTouchPoints(1);
        break;
    case KisShortcutConfiguration::TwoFingerTap:
    case KisShortcutConfiguration::TwoFingerDrag:
        shortcut->setMinimumTouchPoints(2);
        shortcut->setMaximumTouchPoints(2);
        break;
    case KisShortcutConfiguration::ThreeFingerTap:
    case KisShortcutConfiguration::ThreeFingerDrag:
        shortcut->setMinimumTouchPoints(3);
        shortcut->setMaximumTouchPoints(3);
        break;
    case KisShortcutConfiguration::FourFingerTap:
    case KisShortcutConfiguration::FourFingerDrag:
        shortcut->setMinimumTouchPoints(4);
        shortcut->setMaximumTouchPoints(4);
        break;
    case KisShortcutConfiguration::FiveFingerTap:
    case KisShortcutConfiguration::FiveFingerDrag:
        shortcut->setMinimumTouchPoints(5);
        shortcut->setMaximumTouchPoints(5);
    default:
        break;
    }
    matcher.addShortcut(shortcut);
}

References KisShortcutMatcher::addShortcut(), dbgKrita, KisShortcutConfiguration::FiveFingerDrag, KisShortcutConfiguration::FiveFingerTap, KisShortcutConfiguration::FourFingerDrag, KisShortcutConfiguration::FourFingerTap, matcher, KisAbstractInputAction::name, KisShortcutConfiguration::OneFingerDrag, KisShortcutConfiguration::OneFingerHold, KisShortcutConfiguration::OneFingerTap, KisTouchShortcut::setIsTouchPainting(), KisTouchShortcut::setMaximumTouchPoints(), KisTouchShortcut::setMinDragThreshold(), KisTouchShortcut::setMinimumTouchPoints(), KisShortcutConfiguration::ThreeFingerDrag, KisShortcutConfiguration::ThreeFingerTap, KisShortcutConfiguration::TwoFingerDrag, and KisShortcutConfiguration::TwoFingerTap.

addWheelShortcut()

void KisInputManager::Private::addWheelShortcut	(	KisAbstractInputAction *	action,
		int	index,
		const QList< Qt::Key > &	modifiers,
		KisShortcutConfiguration::MouseWheelMovement	wheelAction )

Definition at line 358 of file kis_input_manager_p.cpp.

{
 
 
    auto addSingleActionShortcut = [&] (KisSingleActionShortcut::WheelAction a) {
        std::unique_ptr<KisSingleActionShortcut> keyShortcut(
            new KisSingleActionShortcut(action, index));
        keyShortcut->setWheel(QSet<Qt::Key>(modifiers.begin(), modifiers.end()), a);
        matcher.addShortcut(keyShortcut.release());
    };
 
    switch(wheelAction) {
    case KisShortcutConfiguration::WheelUp:
        addSingleActionShortcut(KisSingleActionShortcut::WheelUp);
        break;
    case KisShortcutConfiguration::WheelDown:
        addSingleActionShortcut(KisSingleActionShortcut::WheelDown);
        break;
    case KisShortcutConfiguration::WheelLeft:
        addSingleActionShortcut(KisSingleActionShortcut::WheelLeft);
        break;
    case KisShortcutConfiguration::WheelRight:
        addSingleActionShortcut(KisSingleActionShortcut::WheelRight);
        break;
    case KisShortcutConfiguration::WheelReserved_0:
    case KisShortcutConfiguration::NoMovement:
        break;
    }
}

References KisShortcutMatcher::addShortcut(), matcher, KisShortcutConfiguration::NoMovement, KisShortcutConfiguration::WheelDown, KisSingleActionShortcut::WheelDown, KisShortcutConfiguration::WheelLeft, KisSingleActionShortcut::WheelLeft, KisShortcutConfiguration::WheelReserved_0, KisShortcutConfiguration::WheelRight, KisSingleActionShortcut::WheelRight, KisShortcutConfiguration::WheelUp, and KisSingleActionShortcut::WheelUp.

fixShortcutMatcherModifiersState() [1/2]

void KisInputManager::Private::fixShortcutMatcherModifiersState

(

)

Definition at line 513 of file kis_input_manager_p.cpp.

{
    KisExtendedModifiersMapper mapper;
 
    QVector<Qt::Key> newKeys;
    Qt::KeyboardModifiers modifiers = mapper.queryStandardModifiers();
    Q_FOREACH (Qt::Key key, mapper.queryExtendedModifiers()) {
        QKeyEvent kevent(QEvent::ShortcutOverride, key, modifiers);
        newKeys << KisExtendedModifiersMapper::workaroundShiftAltMetaHell(&kevent);
    }
 
    fixShortcutMatcherModifiersState(newKeys, modifiers);
}

References fixShortcutMatcherModifiersState(), KisExtendedModifiersMapper::queryExtendedModifiers(), KisExtendedModifiersMapper::queryStandardModifiers(), and KisExtendedModifiersMapper::workaroundShiftAltMetaHell().

fixShortcutMatcherModifiersState() [2/2]

void KisInputManager::Private::fixShortcutMatcherModifiersState	(	QVector< Qt::Key >	newKeys,
		Qt::KeyboardModifiers	modifiers )

This function may be called from slotConfigChanged() from the constructor of KisInputManager. It may theoretically happen that we haven't recieved any sensible events to set up the link to the input manager.

Definition at line 527 of file kis_input_manager_p.cpp.

{
    QVector<Qt::Key> danglingKeys = matcher.debugPressedKeys();
 
    matcher.handlePolledKeys(newKeys);
 
    for (auto it = danglingKeys.begin(); it != danglingKeys.end();) {
        if (newKeys.contains(*it)) {
            newKeys.removeOne(*it);
            it = danglingKeys.erase(it);
        } else {
            ++it;
        }
    }
 
    KisAbstractInputAction::setInputManager(q);
 
    Q_FOREACH (Qt::Key key, danglingKeys) {
        QKeyEvent kevent(QEvent::KeyRelease, key, modifiers);
        processUnhandledEvent(&kevent);
    }
 
    Q_FOREACH (Qt::Key key, newKeys) {
        // just replay the whole sequence
        {
            QKeyEvent kevent(QEvent::ShortcutOverride, key, modifiers);
            processUnhandledEvent(&kevent);
        }
        {
            QKeyEvent kevent(QEvent::KeyPress, key, modifiers);
            processUnhandledEvent(&kevent);
        }
    }
}

References KisShortcutMatcher::debugPressedKeys(), KisShortcutMatcher::handlePolledKeys(), matcher, processUnhandledEvent(), q, and KisAbstractInputAction::setInputManager().

handleCompressedTabletEvent()

bool KisInputManager::Private::handleCompressedTabletEvent

(

QEvent *

event

)

Definition at line 500 of file kis_input_manager_p.cpp.

{
    bool retval = false;
 
    if (!matcher.pointerMoved(event) && toolProxy) {
        toolProxy->forwardHoverEvent(event);
    }
    retval = true;
    event->setAccepted(true);
 
    return retval;
}

References matcher, KisShortcutMatcher::pointerMoved(), and toolProxy.

processUnhandledEvent()

bool KisInputManager::Private::processUnhandledEvent

(

QEvent *

event

)

Definition at line 480 of file kis_input_manager_p.cpp.

{
    bool retval = false;
 
    if (forwardAllEventsToTool ||
        event->type() == QEvent::KeyPress ||
        event->type() == QEvent::KeyRelease) {
 
        defaultInputAction->processUnhandledEvent(event);
        retval = true;
    }
 
    return retval && !forwardAllEventsToTool;
}

References defaultInputAction, forwardAllEventsToTool, and KisToolInvocationAction::processUnhandledEvent().

resetCompressor()

void KisInputManager::Private::resetCompressor

(

)

Definition at line 495 of file kis_input_manager_p.cpp.

                                             {
    compressedMoveEvent.reset();
    moveEventCompressor.stop();
}

References compressedMoveEvent, moveEventCompressor, and KisSignalCompressor::stop().

setMaskSyntheticEvents()

void KisInputManager::Private::setMaskSyntheticEvents

(

bool

value

)

Definition at line 32 of file kis_input_manager_p.cpp.

{
    Q_UNUSED(value)
    // TODO: remove
}

References value().

setupActions()

void KisInputManager::Private::setupActions

(

)

Definition at line 462 of file kis_input_manager_p.cpp.

{
    QList<KisAbstractInputAction*> actions = KisInputProfileManager::instance()->actions();
    Q_FOREACH (KisAbstractInputAction *action, actions) {
        KisToolInvocationAction *toolAction =
            dynamic_cast<KisToolInvocationAction*>(action);
 
        if(toolAction) {
            defaultInputAction = toolAction;
        }
    }
 
    connect(KisInputProfileManager::instance(), SIGNAL(currentProfileChanged()), q, SLOT(profileChanged()));
    if(KisInputProfileManager::instance()->currentProfile()) {
        q->profileChanged();
    }
}

References KisInputProfileManager::actions, defaultInputAction, KisInputProfileManager::instance(), KisInputManager::profileChanged(), and q.

Member Data Documentation

accumulatedScrollDelta

QPoint KisInputManager::Private::accumulatedScrollDelta

Definition at line 104 of file kis_input_manager_p.h.

canvas

QPointer<KisCanvas2> KisInputManager::Private::canvas

Definition at line 43 of file kis_input_manager_p.h.

canvasSwitcher

CanvasSwitcher KisInputManager::Private::canvasSwitcher

Definition at line 100 of file kis_input_manager_p.h.

compressedMoveEvent

QScopedPointer<QEvent> KisInputManager::Private::compressedMoveEvent

Definition at line 54 of file kis_input_manager_p.h.

defaultInputAction

KisToolInvocationAction* KisInputManager::Private::defaultInputAction = 0

Definition at line 50 of file kis_input_manager_p.h.

eventEater

KisInputEventsEater KisInputManager::Private::eventEater

Definition at line 102 of file kis_input_manager_p.h.

eventsReceiver

QObject* KisInputManager::Private::eventsReceiver = 0

Definition at line 52 of file kis_input_manager_p.h.

forwardAllEventsToTool

bool KisInputManager::Private::forwardAllEventsToTool = false

Definition at line 46 of file kis_input_manager_p.h.

matcher

KisShortcutMatcher KisInputManager::Private::matcher

Definition at line 48 of file kis_input_manager_p.h.

moveEventCompressor

KisSignalCompressor KisInputManager::Private::moveEventCompressor

Definition at line 53 of file kis_input_manager_p.h.

popupWasActive

bool KisInputManager::Private::popupWasActive = false

Definition at line 63 of file kis_input_manager_p.h.

popupWidget

KisPopupWidgetInterface* KisInputManager::Private::popupWidget

Definition at line 68 of file kis_input_manager_p.h.

priorityEventFilter

PriorityList KisInputManager::Private::priorityEventFilter

Definition at line 60 of file kis_input_manager_p.h.

priorityEventFilterSeqNo

int KisInputManager::Private::priorityEventFilterSeqNo

Definition at line 61 of file kis_input_manager_p.h.

q

KisInputManager* KisInputManager::Private::q

Definition at line 41 of file kis_input_manager_p.h.

shouldSynchronizeOnNextKeyPress

bool KisInputManager::Private::shouldSynchronizeOnNextKeyPress = false

Definition at line 66 of file kis_input_manager_p.h.

tabletLatencyTracker

KisSharedPtr<TabletLatencyTracker> KisInputManager::Private::tabletLatencyTracker

Definition at line 112 of file kis_input_manager_p.h.

testingAcceptCompressedTabletEvents

bool KisInputManager::Private::testingAcceptCompressedTabletEvents = false

Definition at line 55 of file kis_input_manager_p.h.

testingCompressBrushEvents

bool KisInputManager::Private::testingCompressBrushEvents = false

Definition at line 56 of file kis_input_manager_p.h.

toolProxy

QPointer<KisToolProxy> KisInputManager::Private::toolProxy

Definition at line 44 of file kis_input_manager_p.h.

useUnbalancedKeyPressEventWorkaround

bool KisInputManager::Private::useUnbalancedKeyPressEventWorkaround = false

Definition at line 65 of file kis_input_manager_p.h.

---

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

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