KisInputManager Class Reference

Central object to manage canvas input. More...

#include <kis_input_manager.h>

Inheritance diagram for KisInputManager:

Classes
class	Private

Public Member Functions
void	addTrackedCanvas (KisCanvas2 *canvas)
void	attachPriorityEventFilter (QObject *filter, int priority=0)
	attachPriorityEventFilter
KisCanvas2 *	canvas () const
KisToolInvocationAction *	defaultInputAction () const
void	detachPriorityEventFilter (QObject *filter)
	detachPriorityEventFilter
bool	eventFilter (QObject *object, QEvent *event) override
	KisInputManager (QObject *parent)
void	registerPopupWidget (KisPopupWidgetInterface *popupWidget)
void	removeTrackedCanvas (KisCanvas2 *canvas)
void	setupAsEventFilter (QObject *receiver)
void	toggleTabletLogger ()
QPointer< KisToolProxy >	toolProxy () const
	~KisInputManager () override

Private Slots
void	deregisterPopupWidget ()
void	profileChanged ()
void	slotAboutToChangeTool ()
void	slotCompressedMoveEvent ()
void	slotConfigChanged ()
void	slotTextModeChanged ()
void	slotToolChanged ()

Private Member Functions
template<class Event >
bool	compressMoveEventCommon (Event *event)
bool	eventFilterImpl (QEvent *event)

Private Attributes
Private *const	d

Detailed Description

Central object to manage canvas input.

The Input Manager class manages all canvas input. It is created by KisCanvas2 and processes all events related to input sent to the canvas.

The Input Manager keeps track of a set of actions and a set of shortcuts. The actions are pre-defined while the shortcuts are set from configuration.

For each event, it will try to determine if there is a shortcut that matches the input. It will then activate this action and pass all consecutive events on to this action.

See also

KisAbstractInputAction

Definition at line 38 of file kis_input_manager.h.

Constructor & Destructor Documentation

KisInputManager()

KisInputManager::KisInputManager

(

QObject *

parent

)

Constructor.

Definition at line 58 of file kis_input_manager.cpp.

    : QObject(parent), d(new Private(this))
{
    d->setupActions();
 
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
    slotConfigChanged();
 
    connect(KoToolManager::instance(), SIGNAL(aboutToChangeTool(KoCanvasController*)), SLOT(slotAboutToChangeTool()));
    connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*)), SLOT(slotToolChanged()));
    connect(KoToolManager::instance(), SIGNAL(textModeChanged(bool)), SLOT(slotTextModeChanged()));
    connect(&d->moveEventCompressor, SIGNAL(timeout()), SLOT(slotCompressedMoveEvent()));
 
 
    QApplication::instance()->
            installEventFilter(new Private::ProximityNotifier(d, this));
 
    // on macos global Monitor listen to keypresses when krita is not in focus
    // and local monitor listen presses when krita is in focus.
#ifdef Q_OS_MACOS
    KisExtendedModifiersMapper::setLocalMonitor(true, &d->matcher);
#endif
}

References d, KoToolManager::instance(), KisConfigNotifier::instance(), KisInputManager::Private::matcher, KisInputManager::Private::moveEventCompressor, KisInputManager::Private::setupActions(), slotAboutToChangeTool(), slotCompressedMoveEvent(), slotConfigChanged(), slotTextModeChanged(), and slotToolChanged().

~KisInputManager()

KisInputManager::~KisInputManager ( )

override

Destructor.

Definition at line 82 of file kis_input_manager.cpp.

{
#ifdef Q_OS_MACOS
    KisExtendedModifiersMapper::setLocalMonitor(false);
#endif
    delete d;
}

References d.

Member Function Documentation

addTrackedCanvas()

void KisInputManager::addTrackedCanvas

(

KisCanvas2 *

canvas

)

Definition at line 90 of file kis_input_manager.cpp.

{
    d->canvasSwitcher.addCanvas(canvas);
}

References KisInputManager::Private::CanvasSwitcher::addCanvas(), canvas(), KisInputManager::Private::canvasSwitcher, and d.

attachPriorityEventFilter()

void KisInputManager::attachPriorityEventFilter	(	QObject *	filter,
		int	priority = 0 )

attachPriorityEventFilter

Parameters

filter
priority

Definition at line 137 of file kis_input_manager.cpp.

{
    Private::PriorityList::iterator begin = d->priorityEventFilter.begin();
    Private::PriorityList::iterator it = begin;
    Private::PriorityList::iterator end = d->priorityEventFilter.end();
 
    it = std::find_if(begin, end,
                      kismpl::mem_equal_to(&Private::PriorityPair::second, filter));
 
    if (it != end) return;
 
    it = std::find_if(begin, end,
                      kismpl::mem_greater(&Private::PriorityPair::first, priority));
 
    d->priorityEventFilter.insert(it, qMakePair(priority, filter));
    d->priorityEventFilterSeqNo++;
}

References d, kismpl::mem_equal_to(), kismpl::mem_greater(), KisInputManager::Private::priorityEventFilter, and KisInputManager::Private::priorityEventFilterSeqNo.

canvas()

KisCanvas2 * KisInputManager::canvas

(

)

const

Return the canvas this input manager is associated with.

Definition at line 805 of file kis_input_manager.cpp.

{
    return d->canvas;
}

References KisInputManager::Private::canvas, and d.

compressMoveEventCommon()

template<class Event >

bool KisInputManager::compressMoveEventCommon ( Event * event )

private

We construct a copy of this event object, so we must ensure it has a correct type.

Compress the events if the tool doesn't need high resolution input

On Linux Qt eats the rest of unneeded events if we ignore the first of the chunk of tablet events. So generally we should never activate this feature. Only for testing purposes!

Definition at line 233 of file kis_input_manager.cpp.

{
    static_assert(std::is_same<Event, QMouseEvent>::value ||
                  std::is_same<Event, QTabletEvent>::value,
                  "event should be a mouse or a tablet event");
 
 
    bool retval = false;
 
    if ((event->type() == QEvent::MouseMove ||
         event->type() == QEvent::TabletMove) &&
            (!d->matcher.supportsHiResInputEvents() ||
             d->testingCompressBrushEvents)) {
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
        KoPointerEvent::copyQtPointerEvent(event, d->compressedMoveEvent);
#else
        d->compressedMoveEvent.reset(event->clone());
#endif
        d->moveEventCompressor.start();
 
        if (d->testingAcceptCompressedTabletEvents) {
            event->setAccepted(true);
        }
 
        retval = true;
    } else {
        slotCompressedMoveEvent();
        retval = d->handleCompressedTabletEvent(event);
    }
 
    return retval;
}

References KisInputManager::Private::compressedMoveEvent, d, KisInputManager::Private::handleCompressedTabletEvent(), KisInputManager::Private::matcher, KisInputManager::Private::moveEventCompressor, slotCompressedMoveEvent(), KisSignalCompressor::start(), KisShortcutMatcher::supportsHiResInputEvents(), KisInputManager::Private::testingAcceptCompressedTabletEvents, and KisInputManager::Private::testingCompressBrushEvents.

defaultInputAction()

KisToolInvocationAction * KisInputManager::defaultInputAction

(

)

const

The built-in action that forwards primary strokes to the active tool.

Definition at line 815 of file kis_input_manager.cpp.

{
    return d->defaultInputAction;
}

References d, and KisInputManager::Private::defaultInputAction.

deregisterPopupWidget

void KisInputManager::deregisterPopupWidget ( )

privateslot

Definition at line 110 of file kis_input_manager.cpp.

{
    if (d->popupWidget->onScreen()) {
        d->popupWidget->dismiss();
    }
 
    // FUNKY!
    auto popupObject = dynamic_cast<QObject*>(d->popupWidget);
    KIS_ASSERT(popupObject);
    disconnect(popupObject, nullptr, this, nullptr); // Disconnect all.
 
    d->popupWidget = nullptr;
}

References d, KisPopupWidgetInterface::dismiss(), KIS_ASSERT, KisPopupWidgetInterface::onScreen(), and KisInputManager::Private::popupWidget.

detachPriorityEventFilter()

void KisInputManager::detachPriorityEventFilter

(

QObject *

filter

)

detachPriorityEventFilter

Parameters

filter

Definition at line 155 of file kis_input_manager.cpp.

{
    Private::PriorityList::iterator it = d->priorityEventFilter.begin();
    Private::PriorityList::iterator end = d->priorityEventFilter.end();
 
    it = std::find_if(it, end,
                      kismpl::mem_equal_to(&Private::PriorityPair::second, filter));
 
    if (it != end) {
        d->priorityEventFilter.erase(it);
    }
}

References d, kismpl::mem_equal_to(), and KisInputManager::Private::priorityEventFilter.

eventFilter()

bool KisInputManager::eventFilter ( QObject * object, QEvent * event )

override

Event filter method. Overridden from QObject.

If the filter removed itself from the filters list or added something there, just exit the loop

Definition at line 185 of file kis_input_manager.cpp.

{
    if (object != d->eventsReceiver) return false;
 
    if (d->eventEater.eventFilter(object, event)) return false;
 
    if (!d->matcher.hasRunningShortcut()) {
 
        int savedPriorityEventFilterSeqNo = d->priorityEventFilterSeqNo;
 
        for (auto it = d->priorityEventFilter.begin(); it != d->priorityEventFilter.end(); /*noop*/) {
            const QPointer<QObject> &filter = it->second;
 
            if (filter.isNull()) {
                it = d->priorityEventFilter.erase(it);
 
                d->priorityEventFilterSeqNo++;
                savedPriorityEventFilterSeqNo++;
                continue;
            }
 
            if (filter->eventFilter(object, event)) return true;
 
            if (d->priorityEventFilterSeqNo != savedPriorityEventFilterSeqNo) {
                return true;
            }
 
            ++it;
        }
 
        // KoToolProxy needs to pre-process some events to ensure the
        // global shortcuts (not the input manager's ones) are not
        // executed, in particular, this line will accept events when the
        // tool is in text editing, preventing shortcut triggering
        if (d->toolProxy) {
            d->toolProxy->processEvent(event);
        }
    }
 
    // Continue with the actual switch statement...
    return eventFilterImpl(event);
}

References d, KisInputManager::Private::eventEater, KisInputEventsEater::eventFilter(), eventFilterImpl(), KisInputManager::Private::eventsReceiver, KisShortcutMatcher::hasRunningShortcut(), KisInputManager::Private::matcher, KisInputManager::Private::priorityEventFilter, KisInputManager::Private::priorityEventFilterSeqNo, and KisInputManager::Private::toolProxy.

eventFilterImpl()

bool KisInputManager::eventFilterImpl ( QEvent * event )

private

When Krita (as an application) has no input focus, we cannot handle key events. But at the same time, when the user hovers Krita canvas, we should still show him the correct cursor.

So here we just add a simple workaround to resync shortcut matcher's state at least against the basic modifiers, like Shift, Control and Alt.

On Windows, when the user presses some global window manager shortcuts, e.g. Alt+Space (to show window title menu), events for these key presses and releases are not delivered (see bug 424319). This code is a workaround for this problem. It checks consistency of standard modifiers and resets shortcut's matcher state in case of a trouble.

Re-check the native platform key API against keys we are unsure about, and fix them in case they now show as released.

The other part of the fix is placed in the handler of ShortcutOverride, because it needs a custom set of the presset keys.

See a comment in the handler of KeyRelease event for shouldSynchronizeOnNextKeyPress explanation

There is also a case when Krita gets focus via Win+1 key, then the polled key '1' gets into the matcher, but OS does not deliver any signals for it (see bug 451424)

On some systems Qt fails to generate a correct sequence of events when the user releases a modifier key while some other key is pressed.

In such cases Qt doesn't understand that the key has changed its name in the meantime and sends incorrect key-release event for it (or an auto- repeated key-release/key-press pair).

Example (on en-US keyboard):

1) Press Shift (Key_Shift-press is delivered) 2) Press '2' (Key_At-press is delivered) 3) Release Shift (Key_Shift-release is delivered) 4) Release '2' (Key_2-release is delivered, which is unbalanced)

The same issue happens with non-latin keyboards, where Qt does auto-key-replace routines when Control modifier is pressed.

https://bugs.kde.org/show_bug.cgi?id=454256 https://bugreports.qt.io/browse/QTBUG-103868

Wayland sends us a duplicated ScrollBegin event (one for every axis), so we cannot rely just on status of the running stroke and should use hasTouchpadScrollShortcuts() instead.

When wheelEvent->phase() is not Qt::NoScrollPhase, the delta can be easily null, so we should ignore these events.

We don't try to pass unhandled events to the tool proxy (via toolProxy->forwardHoverEvent(event)) because of the following reasons:

On Windows and Linux touch evetns are generated for touch screens only. And touch screens have no "hover" state.

On MacOS touch events are also generated for the Apple's trackpad. Though, for single-finger movements, these touch events are usually unbalanced, i.e. they don't have a corresponding TouchBegin event.

We could theoretically pass these events to the tool on MacOS only, but it seems like the system-generated mouse events are more precise and granular. That is why we just allow these mouse events in EventEater when we detect they are coming from a touchpad/trackpad outside of TouchBegin/TouchEnd guards.

Definition at line 298 of file kis_input_manager.cpp.

{
    bool retval = false;
 
    // Try closing any open popup widget and
    // consume input if possible.
    if (d->popupWidget) {
        QEvent::Type type = event->type();
 
        if (type == QEvent::MouseButtonPress
         || type == QEvent::MouseButtonDblClick
         || type == QEvent::TabletPress
         || type == QEvent::TouchBegin
         || type == QEvent::NativeGesture) {
            bool wasVisible = d->popupWidget->onScreen();
            deregisterPopupWidget();
 
            if (wasVisible) {
                d->popupWasActive = true;
                event->setAccepted(true);
                return true; // Event consumed.
            }
        }
    }
 
    if (shouldResetWheelDelta(event)) {
        d->accumulatedScrollDelta = {};
    }
 
    if (event->type() == QEvent::MouseMove ||
        event->type() == QEvent::MouseButtonPress ||
        event->type() == QEvent::MouseButtonRelease ||
        event->type() == QEvent::TabletMove ||
        event->type() == QEvent::TabletPress ||
        event->type() == QEvent::TabletRelease ||
        event->type() == QEvent::Wheel) {
 
        QWidget *receivingWidget = dynamic_cast<QWidget*>(d->eventsReceiver);
        if (receivingWidget && !receivingWidget->hasFocus()) {
            d->fixShortcutMatcherModifiersState();
        } else {
            QInputEvent *inputEvent = static_cast<QInputEvent*>(event);
            if (event->type() != QEvent::ShortcutOverride &&
                !d->matcher.sanityCheckModifiersCorrectness(inputEvent->modifiers())) {
 
                d->fixShortcutMatcherModifiersState();
            } else if (d->matcher.hasPolledKeys()) {
                d->fixShortcutMatcherModifiersState();
            }
        }
    }
 
    switch (event->type()) {
    case QEvent::MouseButtonPress:
    case QEvent::MouseButtonDblClick: {
        QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
 
        if (d->popupWidget) {
            retval = true;
        } else {
            //Make sure the input actions know we are active.
            KisAbstractInputAction::setInputManager(this);
            retval = d->matcher.buttonPressed(mouseEvent->button(), mouseEvent);
        }
        //Reset signal compressor to prevent processing events before press late
        d->resetCompressor();
        event->setAccepted(retval);
        break;
    }
    case QEvent::MouseButtonRelease: {
        QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
        retval = d->matcher.buttonReleased(mouseEvent->button(), mouseEvent);
        event->setAccepted(retval);
        break;
    }
    case QEvent::ShortcutOverride: {
        KisInputEventsEater::debugEvent<QKeyEvent>(event);
        QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 
        Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(keyEvent);
 
        if (d->shouldSynchronizeOnNextKeyPress || d->matcher.hasPolledKeys()) {
            QVector<Qt::Key> guessedKeys;
            KisExtendedModifiersMapper mapper;
            Qt::KeyboardModifiers modifiers = mapper.queryStandardModifiers();
            Q_FOREACH (Qt::Key key, mapper.queryExtendedModifiers()) {
                QKeyEvent kevent(QEvent::ShortcutOverride, key, modifiers);
                guessedKeys << KisExtendedModifiersMapper::workaroundShiftAltMetaHell(&kevent);
            }
 
            if (!d->matcher.debugPressedKeys().contains(key)) {
                guessedKeys.removeOne(key);
            }
 
            d->fixShortcutMatcherModifiersState(guessedKeys, modifiers);
            d->shouldSynchronizeOnNextKeyPress = false;
        }
 
        if (!keyEvent->isAutoRepeat()) {
            retval = d->matcher.keyPressed(key);
        } else {
            retval = d->matcher.autoRepeatedKeyPressed(key);
        }
 
        // In case we matched a shortcut we should accept the event to
        // notify Qt that it shouldn't try to trigger its partially matched
        // shortcuts.
        if (retval) {
            keyEvent->setAccepted(true);
        }
 
        break;
    }
    case QEvent::KeyRelease: {
        KisInputEventsEater::debugEvent<QKeyEvent>(event);
        QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 
        if (!keyEvent->isAutoRepeat()) {
            Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(keyEvent);
            retval = d->matcher.keyReleased(key);
 
            if (d->useUnbalancedKeyPressEventWorkaround &&
                !d->matcher.debugPressedKeys().isEmpty() &&
                (key == Qt::Key_Shift || key == Qt::Key_Alt ||
                 key == Qt::Key_Control || key == Qt::Key_Meta)) {
 
                d->shouldSynchronizeOnNextKeyPress = true;
            }
        }
        break;
    }
    case QEvent::MouseMove: {
        QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
        retval = compressMoveEventCommon(mouseEvent);
 
        break;
    }
    case QEvent::Wheel: {
        KisInputEventsEater::debugEvent<QWheelEvent>(event);
        QWheelEvent *wheelEvent = static_cast<QWheelEvent*>(event);
 
        if (wheelEvent->phase() != Qt::NoScrollPhase && d->matcher.hasTouchpadScrollShortcuts()) {
            if (wheelEvent->phase() == Qt::ScrollBegin) {
                d->matcher.touchpadScrollBeginEvent(wheelEvent);
            } else if (wheelEvent->phase() == Qt::ScrollEnd) {
                d->matcher.touchpadScrollEndEvent(wheelEvent);
            } else {
                 d->matcher.touchpadScrollEvent(wheelEvent);
            }
 
            break;
        }
 
        d->accumulatedScrollDelta += wheelEvent->angleDelta();
 
        if (wheelEvent->angleDelta().isNull()) {
            retval = true;
            break;
        }
 
        bool wasScrolled = false;
 
        {
            KisSingleActionShortcut::WheelAction yAction;
 
            if (wheelEvent->angleDelta().y() < 0) {
                yAction = KisSingleActionShortcut::WheelDown;
            } else if (wheelEvent->angleDelta().y() > 0) {
                yAction = KisSingleActionShortcut::WheelUp;
            }
 
            while (qAbs(d->accumulatedScrollDelta.y()) >= QWheelEvent::DefaultDeltasPerStep) {
                // Make sure the input actions know we are active.
                KisAbstractInputAction::setInputManager(this);
                retval = d->matcher.wheelEvent(yAction, wheelEvent);
                d->accumulatedScrollDelta.ry() -=
                    KisAlgebra2D::signPZ(d->accumulatedScrollDelta.y()) * QWheelEvent::DefaultDeltasPerStep;
                wasScrolled = true;
            }
        }
 
        {
            KisSingleActionShortcut::WheelAction xAction;
 
            if (wheelEvent->angleDelta().x() < 0) {
                xAction = KisSingleActionShortcut::WheelRight;
            } else if (wheelEvent->angleDelta().x() > 0) {
                xAction = KisSingleActionShortcut::WheelLeft;
            }
 
            while (qAbs(d->accumulatedScrollDelta.x()) >= QWheelEvent::DefaultDeltasPerStep) {
                // Make sure the input actions know we are active.
                KisAbstractInputAction::setInputManager(this);
                retval = d->matcher.wheelEvent(xAction, wheelEvent);
                d->accumulatedScrollDelta.rx() -=
                    KisAlgebra2D::signPZ(d->accumulatedScrollDelta.x()) * QWheelEvent::DefaultDeltasPerStep;
                wasScrolled = true;
            }
        }
 
        retval = !wasScrolled;
        break;
    }
#ifndef Q_OS_ANDROID
    case QEvent::Enter:
        KisInputEventsEater::debugEvent<QEvent>(event);
        //Make sure the input actions know we are active.
        KisAbstractInputAction::setInputManager(this);
        d->matcher.enterEvent();
        break;
    case QEvent::Leave:
        KisInputEventsEater::debugEvent<QEvent>(event);
        d->matcher.leaveEvent();
        break;
#endif
    case QEvent::FocusIn:
        KisInputEventsEater::debugEvent<QEvent>(event);
        KisAbstractInputAction::setInputManager(this);
 
        d->fixShortcutMatcherModifiersState();
        d->matcher.reinitializeButtons();
        break;
 
    case QEvent::FocusOut: {
        KisInputEventsEater::debugEvent<QEvent>(event);
        KisAbstractInputAction::setInputManager(this);
 
        QPointF currentLocalPos =
                canvas()->canvasWidget()->mapFromGlobal(QCursor::pos());
 
        d->matcher.lostFocusEvent(currentLocalPos);
 
        break;
    }
    case QEvent::TabletPress: {
        QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
 
        {
            //Make sure the input actions know we are active.
            KisAbstractInputAction::setInputManager(this);
            retval = d->matcher.buttonPressed(tabletEvent->button(), tabletEvent);
        }
 
        event->setAccepted(true);
        retval = true;
 
        //Reset signal compressor to prevent processing events before press late
        d->resetCompressor();
 
#if defined Q_OS_LINUX && !KRITA_QT_HAS_ENTER_LEAVE_PATCH
        // remove this hack when this patch is integrated:
        // https://codereview.qt-project.org/#/c/255384/
        event->setAccepted(false);
        d->eventEater.eatOneMousePress();
#elif defined Q_OS_WIN32
        d->eventEater.eatOneMousePress();
#endif
 
        break;
    }
    case QEvent::TabletMove: {
        QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
        retval = compressMoveEventCommon(tabletEvent);
 
        if (d->tabletLatencyTracker) {
            d->tabletLatencyTracker->push(tabletEvent->timestamp());
        }
 
#if defined Q_OS_LINUX && !KRITA_QT_HAS_ENTER_LEAVE_PATCH
        // remove this hack when this patch is integrated:
        // https://codereview.qt-project.org/#/c/255384/
        event->setAccepted(false);
#endif
 
        break;
    }
    case QEvent::TabletRelease: {
        QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
        retval = d->matcher.buttonReleased(tabletEvent->button(), tabletEvent);
        retval = true;
        event->setAccepted(true);
 
#if defined Q_OS_LINUX && !KRITA_QT_HAS_ENTER_LEAVE_PATCH
        // remove this hack when this patch is integrated:
        // https://codereview.qt-project.org/#/c/255384/
        event->setAccepted(false);
#endif
 
        break;
    }
 
    case QEvent::TouchBegin:
    {
        // The popup was dismissed in previous TouchBegin->TouchEnd sequence. We now have a new TouchBegin.
        d->popupWasActive = false;
        QTouchEvent *touchEvent = static_cast<QTouchEvent *>(event);
        KisAbstractInputAction::setInputManager(this);
 
        retval = d->matcher.touchBeginEvent(touchEvent);
 
        d->resetCompressor();
        // we accept touch events unconditionally to disable
        // system-wide gesture on the canvas
        event->accept();
        break;
    }
 
    case QEvent::TouchUpdate:
    {
        if (d->popupWasActive) {
            event->setAccepted(true);
            return true;
        }
        QTouchEvent *touchEvent = static_cast<QTouchEvent*>(event);
 
#ifdef Q_OS_MAC
        const int pressedCount = KisTouchShortcut::countTouchPoints(touchEvent, KisTouchShortcut::pressedOnlyTouchStates());
        const int totalPointCount = KisTouchShortcut::countTouchPoints(touchEvent, KisTouchShortcut::allTouchStates());
 
        if (pressedCount < 2 && totalPointCount > pressedCount) {
            d->matcher.touchEndEvent(touchEvent);
            retval = true;
        } else {
#endif
            KisAbstractInputAction::setInputManager(this);
            d->matcher.touchUpdateEvent(touchEvent);
            retval = true;
 
#ifdef Q_OS_MACOS
        }
#endif
 
        // we accept touch events unconditionally to disable
        // system-wide gesture on the canvas
        event->accept();
        break;
    }
 
    case QEvent::TouchEnd:
    {
        if (d->popupWasActive) {
            event->setAccepted(true);
            return true;
        }
        QTouchEvent *touchEvent = static_cast<QTouchEvent*>(event);
 
        retval = d->matcher.touchEndEvent(touchEvent);
 
        // we accept touch events unconditionally to disable
        // system-wide gesture on the canvas
        event->accept();
        break;
    }
    case QEvent::TouchCancel:
    {
        if (d->popupWasActive) {
            event->setAccepted(true);
            return true;
        }
        QTouchEvent *touchEvent = static_cast<QTouchEvent*>(event);
        d->matcher.touchCancelEvent(touchEvent);
 
        retval = true;
 
        // we accept tablet events unconditionally to disable
        // system-wide gesture on the canvas
        event->accept();
        break;
    }
 
    case QEvent::NativeGesture:
    {
        QNativeGestureEvent *gevent = static_cast<QNativeGestureEvent*>(event);
        switch (gevent->gestureType()) {
            case Qt::BeginNativeGesture:
            {
                KisAbstractInputAction::setInputManager(this);
                retval = d->matcher.nativeGestureBeginEvent(gevent);
                event->accept();
                break;
            }
            case Qt::EndNativeGesture:
            {
                retval = d->matcher.nativeGestureEndEvent(gevent);
                event->accept();
                break;
            }
            default:
            {
                KisAbstractInputAction::setInputManager(this);
                retval = d->matcher.nativeGestureEvent(gevent);
                event->accept();
                break;
            }
        }
        retval = true;
        event->accept();
        break;
    }
 
    default:
        break;
    }
 
    return !retval ? d->processUnhandledEvent(event) : true;
}

References KisInputManager::Private::accumulatedScrollDelta, KisTouchShortcut::allTouchStates(), KisShortcutMatcher::autoRepeatedKeyPressed(), KisShortcutMatcher::buttonPressed(), KisShortcutMatcher::buttonReleased(), canvas(), KisCanvas2::canvasWidget, compressMoveEventCommon(), KisTouchShortcut::countTouchPoints(), d, KisShortcutMatcher::debugPressedKeys(), deregisterPopupWidget(), KisInputEventsEater::eatOneMousePress(), KisShortcutMatcher::enterEvent(), KisInputManager::Private::eventEater, KisInputManager::Private::eventsReceiver, KisInputManager::Private::fixShortcutMatcherModifiersState(), KisShortcutMatcher::hasPolledKeys(), KisShortcutMatcher::hasTouchpadScrollShortcuts(), KisShortcutMatcher::keyPressed(), KisShortcutMatcher::keyReleased(), KisShortcutMatcher::leaveEvent(), KisShortcutMatcher::lostFocusEvent(), KisInputManager::Private::matcher, KisShortcutMatcher::nativeGestureBeginEvent(), KisShortcutMatcher::nativeGestureEndEvent(), KisShortcutMatcher::nativeGestureEvent(), KisPopupWidgetInterface::onScreen(), KisInputManager::Private::popupWasActive, KisInputManager::Private::popupWidget, KisTouchShortcut::pressedOnlyTouchStates(), KisInputManager::Private::processUnhandledEvent(), KisExtendedModifiersMapper::queryExtendedModifiers(), KisExtendedModifiersMapper::queryStandardModifiers(), KisShortcutMatcher::reinitializeButtons(), KisInputManager::Private::resetCompressor(), KisShortcutMatcher::sanityCheckModifiersCorrectness(), KisAbstractInputAction::setInputManager(), shouldResetWheelDelta(), KisInputManager::Private::shouldSynchronizeOnNextKeyPress, KisAlgebra2D::signPZ(), KisInputManager::Private::tabletLatencyTracker, KisShortcutMatcher::touchBeginEvent(), KisShortcutMatcher::touchCancelEvent(), KisShortcutMatcher::touchEndEvent(), KisShortcutMatcher::touchpadScrollBeginEvent(), KisShortcutMatcher::touchpadScrollEndEvent(), KisShortcutMatcher::touchpadScrollEvent(), KisShortcutMatcher::touchUpdateEvent(), KisInputManager::Private::useUnbalancedKeyPressEventWorkaround, KisSingleActionShortcut::WheelDown, KisShortcutMatcher::wheelEvent(), KisSingleActionShortcut::WheelLeft, KisSingleActionShortcut::WheelRight, KisSingleActionShortcut::WheelUp, and KisExtendedModifiersMapper::workaroundShiftAltMetaHell().

profileChanged

void KisInputManager::profileChanged ( )

privateslot

Definition at line 871 of file kis_input_manager.cpp.

{
    d->matcher.clearShortcuts();
 
    KisInputProfile *profile = KisInputProfileManager::instance()->currentProfile();
    if (profile) {
        const QList<KisShortcutConfiguration*> shortcuts = profile->allShortcuts();
 
        for (KisShortcutConfiguration * const shortcut : shortcuts) {
            dbgUI << "Adding shortcut" << shortcut->keys() << "for action" << shortcut->action()->name();
            switch(shortcut->type()) {
            case KisShortcutConfiguration::KeyCombinationType:
                d->addKeyShortcut(shortcut->action(), shortcut->mode(), shortcut->keys());
                break;
            case KisShortcutConfiguration::MouseButtonType:
                d->addStrokeShortcut(shortcut->action(), shortcut->mode(), shortcut->keys(), shortcut->buttons());
                break;
            case KisShortcutConfiguration::MouseWheelType:
                d->addWheelShortcut(shortcut->action(), shortcut->mode(), shortcut->keys(), shortcut->wheel());
                break;
            case KisShortcutConfiguration::TouchGestureType:
                d->addTouchShortcut(shortcut->action(), shortcut->mode(), shortcut->touchGesture());
                break;
            case KisShortcutConfiguration::NativeGestureType:
                d->addNativeGestureShortcut(shortcut->action(), shortcut->mode(), shortcut->nativeGesture());
                break;
            default:
                break;
            }
        }
 
        {
            KisAbstractInputAction *action = profile->actionForId("Tool Invocation");
            if (action) {
                // Touch painting shortcuts
                d->addTouchShortcut(action, KisToolInvocationAction::ActivateShortcut, KisShortcutConfiguration::OneFingerDrag, true);
                d->addTouchShortcut(action, KisToolInvocationAction::ActivateShortcut, KisShortcutConfiguration::OneFingerTap, true);
            }
        }
    }
    else {
        warnUI << "No Input Profile Found: canvas interaction will be impossible";
    }
}

References KisInputProfile::actionForId(), KisToolInvocationAction::ActivateShortcut, KisInputManager::Private::addKeyShortcut(), KisInputManager::Private::addNativeGestureShortcut(), KisInputManager::Private::addStrokeShortcut(), KisInputManager::Private::addTouchShortcut(), KisInputManager::Private::addWheelShortcut(), KisInputProfile::allShortcuts(), KisShortcutMatcher::clearShortcuts(), KisInputProfileManager::currentProfile, d, dbgUI, KisInputProfileManager::instance(), KisShortcutConfiguration::KeyCombinationType, KisInputManager::Private::matcher, KisShortcutConfiguration::MouseButtonType, KisShortcutConfiguration::MouseWheelType, KisShortcutConfiguration::NativeGestureType, KisShortcutConfiguration::OneFingerDrag, KisShortcutConfiguration::OneFingerTap, KisShortcutConfiguration::TouchGestureType, and warnUI.

registerPopupWidget()

void KisInputManager::registerPopupWidget

(

KisPopupWidgetInterface *

popupWidget

)

Definition at line 100 of file kis_input_manager.cpp.

{
    d->popupWidget = popupWidget;
 
    // FUNKY!
    auto popupObject = dynamic_cast<QObject*>(d->popupWidget);
    KIS_ASSERT(popupObject);
    connect(popupObject, SIGNAL(finished()), this, SLOT(deregisterPopupWidget()));
}

References d, deregisterPopupWidget(), KIS_ASSERT, and KisInputManager::Private::popupWidget.

removeTrackedCanvas()

void KisInputManager::removeTrackedCanvas

(

KisCanvas2 *

canvas

)

Definition at line 95 of file kis_input_manager.cpp.

{
    d->canvasSwitcher.removeCanvas(canvas);
}

References canvas(), KisInputManager::Private::canvasSwitcher, d, and KisInputManager::Private::CanvasSwitcher::removeCanvas().

setupAsEventFilter()

void KisInputManager::setupAsEventFilter

(

QObject *

receiver

)

Installs the input manager as an event filter for receiver. Please note that KisInputManager is supposed to handle events for a single receiver only. This is defined by the fact that it resends some of the events back through the Qt's queue to the receiver. That is why the input manager will assert when it gets an event with wrong destination.

Definition at line 168 of file kis_input_manager.cpp.

{
    if (d->eventsReceiver) {
        d->eventsReceiver->removeEventFilter(this);
    }
 
    d->eventsReceiver = receiver;
 
    if (d->eventsReceiver) {
        d->eventsReceiver->installEventFilter(this);
    }
}

References d, and KisInputManager::Private::eventsReceiver.

slotAboutToChangeTool

void KisInputManager::slotAboutToChangeTool ( )

privateslot

Definition at line 820 of file kis_input_manager.cpp.

{
    QPointF currentLocalPos;
    if (canvas() && canvas()->canvasWidget()) {
        currentLocalPos = canvas()->canvasWidget()->mapFromGlobal(QCursor::pos());
    }
    // once more, don't forget the global state whenever matcher may trigger a KisAbstractInputAction
    KisAbstractInputAction::setInputManager(this);
 
    d->matcher.lostFocusEvent(currentLocalPos);
}

References canvas(), KisCanvas2::canvasWidget, d, KisShortcutMatcher::lostFocusEvent(), KisInputManager::Private::matcher, and KisAbstractInputAction::setInputManager().

slotCompressedMoveEvent

void KisInputManager::slotCompressedMoveEvent ( )

privateslot

Definition at line 797 of file kis_input_manager.cpp.

{
    if (d->compressedMoveEvent) {
        (void) d->handleCompressedTabletEvent(d->compressedMoveEvent.data());
        d->compressedMoveEvent.reset();
    }
}

References KisInputManager::Private::compressedMoveEvent, d, KisInputManager::Private::handleCompressedTabletEvent(), and void().

slotConfigChanged

void KisInputManager::slotConfigChanged ( )

privateslot

Definition at line 124 of file kis_input_manager.cpp.

{
#ifdef Q_OS_WIN
    d->ignoreHighFunctionKeys = KisConfig(true).ignoreHighFunctionKeys();
    d->fixShortcutMatcherModifiersState();
#endif
}

References d, KisInputManager::Private::fixShortcutMatcherModifiersState(), and KisConfig::ignoreHighFunctionKeys().

slotTextModeChanged

void KisInputManager::slotTextModeChanged ( )

privateslot

Definition at line 855 of file kis_input_manager.cpp.

{
    if (!d->canvas) return;
    KoToolManager *toolManager = KoToolManager::instance();
    KoToolBase *tool = toolManager->toolById(canvas(), toolManager->activeToolId());
    if (tool) {
        if (tool->isInTextMode()) {
            d->forwardAllEventsToTool = true;
            d->matcher.suppressAllKeyboardActions(true);
        } else {
            d->forwardAllEventsToTool = false;
            d->matcher.suppressAllKeyboardActions(false);
        }
    }
}

References KoToolManager::activeToolId(), canvas(), KisInputManager::Private::canvas, d, KisInputManager::Private::forwardAllEventsToTool, KoToolManager::instance(), KoToolBase::isInTextMode(), KisInputManager::Private::matcher, KisShortcutMatcher::suppressAllKeyboardActions, and KoToolManager::toolById().

slotToolChanged

void KisInputManager::slotToolChanged ( )

privateslot

Definition at line 832 of file kis_input_manager.cpp.

{
    if (!d->canvas) return;
    KoToolManager *toolManager = KoToolManager::instance();
    KoToolBase *tool = toolManager->toolById(canvas(), toolManager->activeToolId());
    if (tool) {
        // once more, don't forget the global state whenever matcher may trigger a KisAbstractInputAction
        KisAbstractInputAction::setInputManager(this);
 
        d->setMaskSyntheticEvents(tool->maskSyntheticEvents());
        if (tool->isInTextMode()) {
            d->forwardAllEventsToTool = true;
            d->matcher.suppressAllKeyboardActions(true);
        } else {
            d->forwardAllEventsToTool = false;
            d->matcher.suppressAllKeyboardActions(false);
        }
 
        d->matcher.suppressConflictingKeyActions(toolProxy()->toolPriorityShortcuts());
        d->matcher.toolHasBeenActivated();
    }
}

References KoToolManager::activeToolId(), canvas(), KisInputManager::Private::canvas, d, KisInputManager::Private::forwardAllEventsToTool, KoToolManager::instance(), KoToolBase::isInTextMode(), KoToolBase::maskSyntheticEvents(), KisInputManager::Private::matcher, KisAbstractInputAction::setInputManager(), KisInputManager::Private::setMaskSyntheticEvents(), KisShortcutMatcher::suppressAllKeyboardActions, KisShortcutMatcher::suppressConflictingKeyActions(), KoToolManager::toolById(), KisShortcutMatcher::toolHasBeenActivated(), and toolProxy().

toggleTabletLogger()

void KisInputManager::toggleTabletLogger

(

)

Definition at line 132 of file kis_input_manager.cpp.

{
    KisTabletDebugger::instance()->toggleDebugging();
}

References KisTabletDebugger::instance(), and KisTabletDebugger::toggleDebugging().

toolProxy()

QPointer< KisToolProxy > KisInputManager::toolProxy

(

)

const

The tool proxy of the current application.

Definition at line 810 of file kis_input_manager.cpp.

{
    return d->toolProxy;
}

References d, and KisInputManager::Private::toolProxy.

Member Data Documentation

d

Private* const KisInputManager::d

private

Definition at line 119 of file kis_input_manager.h.

---

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

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