KisInputEventsEater Class Reference

#include <KisInputEventsEater.h>

Public Types
enum	EventBlockingReason {   NotBlocked = 0x0 , BlockedByTabletProximity = 0x01 , BlockedByTabletHover = 0x02 , BlockedByTabletPress = 0x04 ,   BlockedByTouchPress = 0x08 , BlockedByNextPressSuppression = 0x10 , BlockedByButtonsWorkaround = 0x20 , BlockedBySynthetic = 0x40 }

Public Member Functions
void	eatOneMousePress ()
bool	eventFilter (QObject *target, QEvent *event)
	KisInputEventsEater ()
void	notifyTabletEnterProximity ()
void	notifyTabletLeaveProximity ()

Static Public Member Functions
template<class Event >
static void	debugEvent (QEvent *event, EventBlockingReasons reasons=NotBlocked)

Private Member Functions
void	debugEaterStateTransition (const QLatin1String &stateName, bool newValue, QEvent::Type eventType, const QLatin1String &comment=QLatin1String())

Private Attributes
bool	activateSecondaryButtonsWorkaround {false}
bool	eatOneMousePressEvent {false}
bool	tabletIsHovering {false}
bool	tabletIsInProximity {false}
bool	tabletIsPressed {false}
bool	touchIsActive {false}

Detailed Description

Definition at line 24 of file KisInputEventsEater.h.

Member Enumeration Documentation

EventBlockingReason

enum KisInputEventsEater::EventBlockingReason

Enumerator
NotBlocked
BlockedByTabletProximity
BlockedByTabletHover
BlockedByTabletPress
BlockedByTouchPress
BlockedByNextPressSuppression
BlockedByButtonsWorkaround
BlockedBySynthetic

Definition at line 27 of file KisInputEventsEater.h.

                             {
        NotBlocked = 0x0,
        BlockedByTabletProximity = 0x01,
        BlockedByTabletHover = 0x02,
        BlockedByTabletPress = 0x04,
        BlockedByTouchPress = 0x08,
        BlockedByNextPressSuppression = 0x10,
        BlockedByButtonsWorkaround = 0x20,
        BlockedBySynthetic = 0x40
    };

Constructor & Destructor Documentation

KisInputEventsEater()

KisInputEventsEater::KisInputEventsEater

(

)

Definition at line 75 of file KisInputEventsEater.cpp.

{
    KisConfig cfg(true);
    activateSecondaryButtonsWorkaround = cfg.useRightMiddleTabletButtonWorkaround();
}

References activateSecondaryButtonsWorkaround, and KisConfig::useRightMiddleTabletButtonWorkaround().

Member Function Documentation

debugEaterStateTransition()

void KisInputEventsEater::debugEaterStateTransition ( const QLatin1String & stateName, bool newValue, QEvent::Type eventType, const QLatin1String & comment = QLatin1String() )

private

Definition at line 81 of file KisInputEventsEater.cpp.

{
    if (comment.isEmpty()) {
        dbgInputEater.noquote().nospace() << stateName << " <- " << newValue << " by " << eventType;
    } else {
        dbgInputEater.noquote().nospace() << stateName << " <- " << newValue << " by " << eventType << " (" << comment << ")";
    }
}

References dbgInputEater.

debugEvent()

template<class Event >

static void KisInputEventsEater::debugEvent ( QEvent * event, EventBlockingReasons reasons = NotBlocked )

inlinestatic

Definition at line 50 of file KisInputEventsEater.h.

    {
        if (!KisTabletDebugger::instance()->debugEnabled())
            return;
 
        QString reasonsString;
 
        if (reasons.testFlag(BlockedByTabletProximity)) {
            reasonsString += "Prx";
        }
 
        if (reasons.testFlag(BlockedByTabletHover)) {
            reasonsString += "Hov";
        }
 
        if (reasons.testFlag(BlockedByTabletPress)) {
            reasonsString += "Prs";
        }
 
        if (reasons.testFlag(BlockedByNextPressSuppression)) {
            reasonsString += "Nxt";
        }
 
        if (reasons.testFlag(BlockedByTouchPress)) {
            reasonsString += "Tch";
        }
 
        if (reasons.testFlag(BlockedBySynthetic)) {
            reasonsString += "Syn";
        }
 
        QString msg1 = QString("[%1] ").arg(reasonsString, 15);
        Event *specificEvent = static_cast<Event *>(event);
        dbgTablet << KisTabletDebugger::instance()->eventToString(*specificEvent, msg1);
    }

References dbgTablet, debugEnabled(), KisTabletDebugger::eventToString(), and KisTabletDebugger::instance().

eatOneMousePress()

void KisInputEventsEater::eatOneMousePress

(

)

Definition at line 350 of file KisInputEventsEater.cpp.

{
    // Enable on other platforms if getting full-pressure splotches
    eatOneMousePressEvent = true;
}

References eatOneMousePressEvent.

eventFilter()

bool KisInputEventsEater::eventFilter	(	QObject *	target,
		QEvent *	event )

Tablet events have higher priority over the touch events, so, if a touch has been started before the tablet stroke, then TouchUpdate events will no cause the EventEater to perform state transitions to the tablet state (on Windows, the streams of touch and tablet event come in parallel independently).

Please note that the actual cancellation of the already started touch action is performed inside KisShortcutMatcher, not in the event eater. Here we just allow all the TouchUpdate events pass firther and block synthesized mouse events only.

Definition at line 89 of file KisInputEventsEater.cpp.

{
    using namespace Qt::StringLiterals;
 
    Q_UNUSED(target);
 
    {
        // handle `newTabletIsHovering` and `tabletIsPressed` state transitions
 
        if (isTabletEventType(event->type())) {
 
            QTabletEvent *ev = static_cast<QTabletEvent*>(event);
            const bool newTabletIsHovering = ev->buttons() == Qt::NoButton;
            const bool newTabletIsPressed = !newTabletIsHovering;
 
            if (newTabletIsHovering != tabletIsHovering) {
                tabletIsHovering = newTabletIsHovering;
                debugEaterStateTransition("tabletIsHovering"_L1, newTabletIsHovering, event->type());
            }
 
            if (newTabletIsPressed != tabletIsPressed) {
                tabletIsPressed = newTabletIsPressed;
                debugEaterStateTransition("tabletIsPressed"_L1, newTabletIsPressed, event->type());
            }
 
#ifdef KRITA_ENABLE_MISSING_PROXIMITY_ENTER_WORKAROUND
            if (!tabletIsInProximity && !missingTabletProximityEventsWorkaround) {
                warnInputEater << "WARNING: received a tablet event while the tablet is not in proximity! Activating a workaround...";
                missingTabletProximityEventsWorkaround = MissingTabletProximityEnterWorkaround();
            } else if (tabletIsInProximity && missingTabletProximityEventsWorkaround) {
                warnInputEater << "WARNING: received a delayed tablet proximity event, disabling the workaround...";
                missingTabletProximityEventsWorkaround = std::nullopt;
            } else if (missingTabletProximityEventsWorkaround) {
                missingTabletProximityEventsWorkaround->notifyTabletEventArrived();
            }
#endif /* KRITA_ENABLE_MISSING_PROXIMITY_ENTER_WORKAROUND */
        }
 
#ifdef KRITA_ENABLE_MISSING_PROXIMITY_ENTER_WORKAROUND
        if (missingTabletProximityEventsWorkaround && !tabletIsPressed && isMouseEventType(event->type())) {
            missingTabletProximityEventsWorkaround->notifyMouseEventArrived();
            if (missingTabletProximityEventsWorkaround->shouldForgetAboutTabletInProximity()) {
                if (tabletIsHovering) {
                    tabletIsHovering = false;
                    debugEaterStateTransition("tabletIsHovering"_L1, false, event->type(), "missing proximity workaround"_L1);
                }
                missingTabletProximityEventsWorkaround = std::nullopt;
            }
        }
#endif /* KRITA_ENABLE_MISSING_PROXIMITY_ENTER_WORKAROUND */
 
        if (event->type() == QEvent::FocusOut ||
            event->type() == QEvent::Leave ||
            (event->type() == QEvent::TouchBegin && !tabletIsInProximity)) {
 
            if (tabletIsHovering) {
                tabletIsHovering = false;
                debugEaterStateTransition("tabletIsHovering"_L1, false, event->type());
            }
            if (tabletIsPressed) {
                tabletIsPressed = false;
                debugEaterStateTransition("tabletIsPressed"_L1, false, event->type());
            }
 
#ifdef KRITA_ENABLE_MISSING_PROXIMITY_ENTER_WORKAROUND
            missingTabletProximityEventsWorkaround = std::nullopt;
#endif /* KRITA_ENABLE_MISSING_PROXIMITY_ENTER_WORKAROUND */
        }
 
        // also proximity-leave in a corresponding function...
    }
 
    {
        // handle `touchIsActive` state transitions
 
        bool assumeTouchStarted = event->type() == QEvent::TouchBegin;
 
        if (!assumeTouchStarted && event->type() == QEvent::TouchUpdate) {
            QTouchEvent *touchEvent = static_cast<QTouchEvent*>(event);
 
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
            using DeviceType = QInputDevice::DeviceType;
#else
            using DeviceType = QTouchDevice::DeviceType;
#endif
 
            if (touchEvent->device()->type() == DeviceType::TouchPad) {
#ifdef Q_OS_MACOS
                 // noop, keep assumeTouchStarted false
#else
                dbgInputEater << "Received a TouchUpdate for a touchpad device on a non-MacOS system!";
#endif
            } else {
                assumeTouchStarted = true;
            }
        }
 
        if (assumeTouchStarted) {
            if (!touchIsActive) {
                touchIsActive = true;
                debugEaterStateTransition("touchIsActive"_L1, true, event->type());
            }
        }
 
        if (event->type() == QEvent::TouchEnd ||
            event->type() == QEvent::TouchCancel) {
            if (touchIsActive) {
                touchIsActive = false;
                debugEaterStateTransition("touchIsActive"_L1, false, event->type());
            }
        }
    }
 
    if (eatOneMousePressEvent && event->type() == QEvent::MouseButtonPress
        // Drop one mouse press following tabletPress or touchBegin
        && (static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)) {
        eatOneMousePressEvent = false;
        debugEvent<QMouseEvent>(event, BlockedByNextPressSuppression);
        return true;
    }
 
    if (activateSecondaryButtonsWorkaround) {
        if (event->type() == QEvent::TabletPress ||
                event->type() == QEvent::TabletRelease) {
 
            QTabletEvent *te = static_cast<QTabletEvent*>(event);
            if (te->button() != Qt::LeftButton) {
                debugEvent<QTabletEvent>(te, BlockedByButtonsWorkaround);
                return true;
            }
        } else if (event->type() == QEvent::MouseButtonPress ||
                   event->type() == QEvent::MouseButtonRelease ||
                   event->type() == QEvent::MouseButtonDblClick) {
 
            QMouseEvent *me = static_cast<QMouseEvent*>(event);
            if (me->button() != Qt::LeftButton) {
                return false;
            }
        }
    }
 
    const bool shouldEatMouseEvents =
        // On MacOS Qt sends fake mouse events instead of hover events,
        // so we should not block mouse events when the tablet just hovers
        // the canvas. The real TabletMove events will arrive only when
        // the user touches the surface of the tablet, i.e. after a TabletPress.
#ifndef Q_OS_MACOS
        tabletIsInProximity ||
        tabletIsHovering ||
#endif
        tabletIsPressed ||
        touchIsActive;
 
    if (isMouseEventType(event->type()) &&
               (shouldEatMouseEvents
            // On Mac, we need mouse events when the tablet is in proximity, but not pressed down
            // since tablet move events are not generated until after tablet press.
            #ifndef Q_OS_MAC
                || (static_cast<QMouseEvent*>(event)->source() != Qt::MouseEventNotSynthesized)
            #endif
                )) {
 
        EventBlockingReasons reasons = NotBlocked;
#ifndef Q_OS_MACOS
        reasons.setFlag(BlockedByTabletProximity, tabletIsInProximity);
        reasons.setFlag(BlockedByTabletHover, tabletIsHovering);
        reasons.setFlag(BlockedBySynthetic, static_cast<QMouseEvent*>(event)->source() != Qt::MouseEventNotSynthesized);
#endif
        reasons.setFlag(BlockedByTabletPress, tabletIsPressed);
        reasons.setFlag(BlockedByTouchPress, touchIsActive);
 
        debugEvent<QMouseEvent>(event, reasons);
 
        // Drop mouse events if enabled or event was synthetic & synthetic events are disabled
        return true;
    }
 
    if (event->type() == QEvent::TouchBegin &&
        (tabletIsInProximity || tabletIsHovering || tabletIsPressed)) {
 
        EventBlockingReasons reasons = NotBlocked;
        reasons.setFlag(BlockedByTabletProximity, tabletIsInProximity);
        reasons.setFlag(BlockedByTabletHover, tabletIsHovering);
        reasons.setFlag(BlockedByTabletPress, tabletIsPressed);
 
        debugEvent<QTouchEvent>(event, reasons);
 
        if (touchIsActive) {
            // don't forget to reset the touch active state, since we are
            // not going to receive the res of the events
            touchIsActive = false;
            debugEaterStateTransition("touchIsActive"_L1, false, event->type(), "cancelled by tablet"_L1);
        }
 
        // Drop touch-begin event. It will prevent KisShortcutMatcher to
        // start any touch action, while letting it complete any existing
        // actions. We explicitly accept the event to make sure OS will
        // not trigger any global gestures (works on WinInk only).
        event->accept();
        return true;
    }
 
    if (isMouseEventType(event->type())) {
        debugEvent<QMouseEvent>(event, NotBlocked);
    } else if (isTabletEventType(event->type())) {
        debugEvent<QTabletEvent>(event, NotBlocked);
    } else if (isTouchEventType(event->type())) {
        debugEvent<QTouchEvent>(event, NotBlocked);
    } else if (isNativeGestureEventType(event->type())) {
        debugEvent<QNativeGestureEvent>(event, NotBlocked);
    }
 
    return false; // All clear - let this one through!
}

References activateSecondaryButtonsWorkaround, BlockedByButtonsWorkaround, BlockedByNextPressSuppression, BlockedBySynthetic, BlockedByTabletHover, BlockedByTabletPress, BlockedByTabletProximity, BlockedByTouchPress, dbgInputEater, debugEaterStateTransition(), eatOneMousePressEvent, isMouseEventType(), isNativeGestureEventType(), isTabletEventType(), isTouchEventType(), NotBlocked, source(), tabletIsHovering, tabletIsInProximity, tabletIsPressed, target(), touchIsActive, and warnInputEater.

notifyTabletEnterProximity()

void KisInputEventsEater::notifyTabletEnterProximity

(

)

Definition at line 329 of file KisInputEventsEater.cpp.

{
    using namespace Qt::StringLiterals;
 
    tabletIsInProximity = true;
    debugEaterStateTransition("tabletIsInProximity"_L1, true, QEvent::TabletEnterProximity);
}

References debugEaterStateTransition(), and tabletIsInProximity.

notifyTabletLeaveProximity()

void KisInputEventsEater::notifyTabletLeaveProximity

(

)

Definition at line 337 of file KisInputEventsEater.cpp.

{
    using namespace Qt::StringLiterals;
 
    tabletIsInProximity = false;
    debugEaterStateTransition("tabletIsInProximity"_L1, false, QEvent::TabletLeaveProximity);
 
    if (tabletIsHovering) {
        tabletIsHovering = false;
        debugEaterStateTransition("tabletIsHovering"_L1, false, QEvent::TabletLeaveProximity);
    }
}

References debugEaterStateTransition(), tabletIsHovering, and tabletIsInProximity.

Member Data Documentation

activateSecondaryButtonsWorkaround

bool KisInputEventsEater::activateSecondaryButtonsWorkaround {false}

private

Definition at line 89 of file KisInputEventsEater.h.

{false}; // Use mouse events for right- and middle-clicks

eatOneMousePressEvent

bool KisInputEventsEater::eatOneMousePressEvent {false}

private

Definition at line 88 of file KisInputEventsEater.h.

{false}; // Eat a single mouse press event

tabletIsHovering

bool KisInputEventsEater::tabletIsHovering {false}

private

Definition at line 92 of file KisInputEventsEater.h.

{false};

tabletIsInProximity

bool KisInputEventsEater::tabletIsInProximity {false}

private

Definition at line 91 of file KisInputEventsEater.h.

{false};

tabletIsPressed

bool KisInputEventsEater::tabletIsPressed {false}

private

Definition at line 93 of file KisInputEventsEater.h.

{false};

touchIsActive

bool KisInputEventsEater::touchIsActive {false}

private

Definition at line 94 of file KisInputEventsEater.h.

{false};

---

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

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