KisInputManager::Private Class Reference

#include <kis_input_manager_p.h>

Classes
class	CanvasSwitcher
struct	EventEater
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::GestureAction gesture)
void	addStrokeShortcut (KisAbstractInputAction *action, int index, const QList< Qt::Key > &modifiers, Qt::MouseButtons buttons)
void	addTouchShortcut (KisAbstractInputAction *action, int index, KisShortcutConfiguration::GestureAction gesture)
void	addWheelShortcut (KisAbstractInputAction *action, int index, const QList< Qt::Key > &modifiers, KisShortcutConfiguration::MouseWheelMovement wheelAction)
void	allowMouseEvents ()
void	blockMouseEvents ()
void	bufferTouchEvent (QTouchEvent *event)
void	cancelTouchHoldTimer ()
void	clearBufferedTouchEvents ()
template<class Event , bool useBlocking>
void	debugEvent (QEvent *event)
void	eatOneMousePress ()
void	fixShortcutMatcherModifiersState ()
void	fixShortcutMatcherModifiersState (QVector< Qt::Key > newKeys, Qt::KeyboardModifiers modifiers)
void	flushBufferedTouchEvents ()
bool	handleCompressedTabletEvent (QEvent *event)
bool	ignoringQtCursorEvents ()
bool	isPendingTouchHold () const
bool	isWithinTouchHoldSlopRange (const QPointF &currentPos) const
	Private (KisInputManager *qq)
bool	processUnhandledEvent (QEvent *event)
void	resetCompressor ()
void	restartTouchHoldTimer ()
void	setMaskSyntheticEvents (bool value)
void	setupActions ()
void	startBlockingTouch ()
void	stopBlockingTouch ()

Public Attributes
int	accumulatedScrollDelta = 0
QVector< QTouchEvent * >	bufferedTouchEvents
QPointer< KisCanvas2 >	canvas
CanvasSwitcher	canvasSwitcher
QScopedPointer< QEvent >	compressedMoveEvent
bool	containsPointer = false
KisToolInvocationAction *	defaultInputAction = 0
EventEater	eventEater
QObject *	eventsReceiver = 0
bool	forwardAllEventsToTool = false
int	lastPointCount = 0
KisShortcutMatcher	matcher
KisSignalCompressor	moveEventCompressor
QScopedPointer< QEvent >	originatingTouchBeginEvent
bool	popupWasActive = false
KisPopupWidgetInterface *	popupWidget
QPointF	previousPos
PriorityList	priorityEventFilter
int	priorityEventFilterSeqNo
KisInputManager *	q
bool	shouldSynchronizeOnNextKeyPress = false
QPointF	startingPos
KisSharedPtr< TabletLatencyTracker >	tabletLatencyTracker
bool	testingAcceptCompressedTabletEvents = false
bool	testingCompressBrushEvents = false
QPointer< KisToolProxy >	toolProxy
bool	touchHasBlockedPressEvents = false
QTimer *	touchHoldTimer
bool	touchStrokeBlocked = false
bool	touchStrokeStarted = false
bool	useUnbalancedKeyPressEventWorkaround = false

Static Public Attributes
static constexpr int	TOUCH_HOLD_DELAY_MS = 400

Detailed Description

Definition at line 29 of file kis_input_manager_p.h.

Member Typedef Documentation

PriorityList

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

Definition at line 67 of file kis_input_manager_p.h.

PriorityPair

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

Definition at line 66 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 200 of file kis_input_manager_p.cpp.

    : q(qq)
    , moveEventCompressor(10 /* ms */,
                          KisSignalCompressor::FIRST_ACTIVE,
                          KisSignalCompressor::ADDITIVE_INTERVAL)
    , priorityEventFilterSeqNo(0)
    , popupWidget(nullptr)
    , touchHoldTimer(new QTimer(qq))
    , 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_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");
    }
 
    touchHoldTimer->setTimerType(Qt::CoarseTimer);
    touchHoldTimer->setSingleShot(true);
    touchHoldTimer->setInterval(TOUCH_HOLD_DELAY_MS);
    connect(touchHoldTimer, &QTimer::timeout, qq, &KisInputManager::slotTouchHoldTriggered);
}

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

Member Function Documentation

addKeyShortcut()

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

Definition at line 511 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::GestureAction	gesture )

Definition at line 605 of file kis_input_manager_p.cpp.

{
    // Qt5 only implements QNativeGestureEvent for macOS
    Qt::NativeGestureType type;
    switch (gesture) {
#ifdef Q_OS_MACOS
        case KisShortcutConfiguration::PinchGesture:
            type = Qt::ZoomNativeGesture;
            break;
        case KisShortcutConfiguration::PanGesture:
            type = Qt::PanNativeGesture;
            break;
        case KisShortcutConfiguration::RotateGesture:
            type = Qt::RotateNativeGesture;
            break;
        case KisShortcutConfiguration::SmartZoomGesture:
            type = Qt::SmartZoomNativeGesture;
            break;
#endif
        default:
            return false;
    }
 
    KisNativeGestureShortcut *shortcut = new KisNativeGestureShortcut(action, index, type);
    matcher.addShortcut(shortcut);
    return true;
}

References KisShortcutMatcher::addShortcut(), and matcher.

addStrokeShortcut()

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

Definition at line 482 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::GestureAction	gesture )

Definition at line 561 of file kis_input_manager_p.cpp.

{
    KisTouchShortcut *shortcut = new KisTouchShortcut(action, index, gesture);
    dbgKrita << "TouchAction:" << action->name();
    switch(gesture) {
#ifndef Q_OS_MACOS
    case KisShortcutConfiguration::OneFingerTap:
    case KisShortcutConfiguration::OneFingerDrag:
        // Touch painting takes precedence over one-finger touch shortcuts, so
        // disable this type of shortcut when touch painting is active. Except
        // touch hold shortcuts, since touching and holding in one spot does
        // nothing otherwise and is therefore unambiguous.
        shortcut->setDisableOnTouchPainting(true);
        Q_FALLTHROUGH();
    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);
#endif
    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::setDisableOnTouchPainting(), KisTouchShortcut::setMaximumTouchPoints(), 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 530 of file kis_input_manager_p.cpp.

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

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

allowMouseEvents()

void KisInputManager::Private::allowMouseEvents

(

)

On Windows tablet events may arrive asynchronously to the mouse events (in WinTab mode). The problem is that Qt generates Enter/Leave and FocusIn/Out events via mouse events only. It means that TabletPress may come much before Enter and FocusIn event and start the stroke. In such a case we shouldn't unblock mouse events.

See https://bugs.kde.org/show_bug.cgi?id=417040

PS: Ideally, we should fix Qt to generate Enter/Leave and FocusIn/Out events based on tablet events as well, but it is a lot of work.

Definition at line 681 of file kis_input_manager_p.cpp.

{
#ifdef Q_OS_WIN32
    if (eventEater.hungry && matcher.hasRunningShortcut()) {
        return;
    }
#endif
 
    eventEater.deactivate();
}

References KisInputManager::Private::EventEater::deactivate(), eventEater, KisShortcutMatcher::hasRunningShortcut(), KisInputManager::Private::EventEater::hungry, and matcher.

blockMouseEvents()

void KisInputManager::Private::blockMouseEvents

(

)

Definition at line 676 of file kis_input_manager_p.cpp.

{
    eventEater.activate();
}

References KisInputManager::Private::EventEater::activate(), and eventEater.

bufferTouchEvent()

void KisInputManager::Private::bufferTouchEvent

(

QTouchEvent *

event

)

Definition at line 749 of file kis_input_manager_p.cpp.

{
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QScopedPointer<QEvent> dst;
    KoPointerEvent::copyQtPointerEvent(touchEvent, dst);
    bufferedTouchEvents.append(static_cast<QTouchEvent *>(dst.take()));
#else
    bufferedTouchEvents.append(touchEvent->clone());
#endif
}

References bufferedTouchEvents.

cancelTouchHoldTimer()

void KisInputManager::Private::cancelTouchHoldTimer

(

)

Definition at line 732 of file kis_input_manager_p.cpp.

{
    touchHoldTimer->stop();
}

References touchHoldTimer.

clearBufferedTouchEvents()

void KisInputManager::Private::clearBufferedTouchEvents

(

)

Definition at line 779 of file kis_input_manager_p.cpp.

{
    for (QTouchEvent *event : bufferedTouchEvents) {
        delete event;
    }
    bufferedTouchEvents.clear();
}

References bufferedTouchEvents.

debugEvent()

template<class Event , bool useBlocking>

void KisInputManager::Private::debugEvent ( QEvent * event )

inline

Definition at line 104 of file kis_input_manager_p.h.

    {
      if (!KisTabletDebugger::instance()->debugEnabled()) return;
 
      QString msg1 = useBlocking && ignoringQtCursorEvents() ? "[BLOCKED] " : "[       ]";
      Event *specificEvent = static_cast<Event*>(event);
      dbgTablet << KisTabletDebugger::instance()->eventToString(*specificEvent, msg1);
    }

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

eatOneMousePress()

void KisInputManager::Private::eatOneMousePress

(

)

Definition at line 707 of file kis_input_manager_p.cpp.

{
    eventEater.eatOneMousePress();
}

References KisInputManager::Private::EventEater::eatOneMousePress(), and eventEater.

fixShortcutMatcherModifiersState() [1/2]

void KisInputManager::Private::fixShortcutMatcherModifiersState

(

)

Definition at line 802 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 816 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().

flushBufferedTouchEvents()

void KisInputManager::Private::flushBufferedTouchEvents

(

)

Definition at line 760 of file kis_input_manager_p.cpp.

{
    for (QTouchEvent *touchEvent : bufferedTouchEvents) {
        switch (touchEvent->type()) {
        case QEvent::TouchBegin:
            q->handleTouchBegin(touchEvent);
            break;
        case QEvent::TouchUpdate:
            q->handleTouchUpdate(touchEvent);
            break;
        default:
            qWarning("Unhandled buffered touch event type %d", int(touchEvent->type()));
            break;
        }
        delete touchEvent;
    }
    bufferedTouchEvents.clear();
}

References bufferedTouchEvents, KisInputManager::handleTouchBegin(), KisInputManager::handleTouchUpdate(), and q.

handleCompressedTabletEvent()

bool KisInputManager::Private::handleCompressedTabletEvent

(

QEvent *

event

)

Definition at line 787 of file kis_input_manager_p.cpp.

{
    bool retval = false;
 
    if (event->type() == QTouchEvent::TouchUpdate && touchHasBlockedPressEvents) {
        matcher.touchUpdateEvent((QTouchEvent *)event);
    } else if (!matcher.pointerMoved(event) && toolProxy && event->type() != QTouchEvent::TouchUpdate) {
        toolProxy->forwardHoverEvent(event);
    }
    retval = true;
    event->setAccepted(true);
 
    return retval;
}

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

ignoringQtCursorEvents()

bool KisInputManager::Private::ignoringQtCursorEvents

(

)

Definition at line 190 of file kis_input_manager_p.cpp.

{
    return eventEater.hungry;
}

References eventEater, and KisInputManager::Private::EventEater::hungry.

isPendingTouchHold()

bool KisInputManager::Private::isPendingTouchHold

(

)

const

Definition at line 737 of file kis_input_manager_p.cpp.

{
    return touchHoldTimer->isActive();
}

References touchHoldTimer.

isWithinTouchHoldSlopRange()

bool KisInputManager::Private::isWithinTouchHoldSlopRange

(

const QPointF &

currentPos

)

const

Definition at line 742 of file kis_input_manager_p.cpp.

{
    QPointF d = startingPos - currentPos;
    qreal distanceSquared = (d.x() * d.x()) + (d.y() * d.y());
    return distanceSquared <= KisShortcutMatcher::TOUCH_SLOP_SQUARED;
}

References KisInputManager::d, startingPos, and KisShortcutMatcher::TOUCH_SLOP_SQUARED.

processUnhandledEvent()

bool KisInputManager::Private::processUnhandledEvent

(

QEvent *

event

)

Definition at line 651 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 712 of file kis_input_manager_p.cpp.

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

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

restartTouchHoldTimer()

void KisInputManager::Private::restartTouchHoldTimer

(

)

Definition at line 727 of file kis_input_manager_p.cpp.

{
    touchHoldTimer->start();
}

References touchHoldTimer.

setMaskSyntheticEvents()

void KisInputManager::Private::setMaskSyntheticEvents

(

bool

value

)

Definition at line 195 of file kis_input_manager_p.cpp.

{
    eventEater.eatSyntheticEvents = value;
}

References KisInputManager::Private::EventEater::eatSyntheticEvents, eventEater, and value().

setupActions()

void KisInputManager::Private::setupActions

(

)

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

startBlockingTouch()

void KisInputManager::Private::startBlockingTouch

(

)

Definition at line 717 of file kis_input_manager_p.cpp.

{
    eventEater.startBlockingTouch();
}

References eventEater, and KisInputManager::Private::EventEater::startBlockingTouch().

stopBlockingTouch()

void KisInputManager::Private::stopBlockingTouch

(

)

Definition at line 722 of file kis_input_manager_p.cpp.

{
    eventEater.stopBlockingTouch();
}

References eventEater, and KisInputManager::Private::EventEater::stopBlockingTouch().

Member Data Documentation

accumulatedScrollDelta

int KisInputManager::Private::accumulatedScrollDelta = 0

Definition at line 171 of file kis_input_manager_p.h.

bufferedTouchEvents

QVector<QTouchEvent *> KisInputManager::Private::bufferedTouchEvents

Definition at line 86 of file kis_input_manager_p.h.

canvas

QPointer<KisCanvas2> KisInputManager::Private::canvas

Definition at line 48 of file kis_input_manager_p.h.

canvasSwitcher

CanvasSwitcher KisInputManager::Private::canvasSwitcher

Definition at line 140 of file kis_input_manager_p.h.

compressedMoveEvent

QScopedPointer<QEvent> KisInputManager::Private::compressedMoveEvent

Definition at line 62 of file kis_input_manager_p.h.

containsPointer

bool KisInputManager::Private::containsPointer = false

Definition at line 169 of file kis_input_manager_p.h.

defaultInputAction

KisToolInvocationAction* KisInputManager::Private::defaultInputAction = 0

Definition at line 58 of file kis_input_manager_p.h.

eventEater

EventEater KisInputManager::Private::eventEater

Definition at line 167 of file kis_input_manager_p.h.

eventsReceiver

QObject* KisInputManager::Private::eventsReceiver = 0

Definition at line 60 of file kis_input_manager_p.h.

forwardAllEventsToTool

bool KisInputManager::Private::forwardAllEventsToTool = false

Definition at line 51 of file kis_input_manager_p.h.

lastPointCount

int KisInputManager::Private::lastPointCount = 0

Definition at line 74 of file kis_input_manager_p.h.

matcher

KisShortcutMatcher KisInputManager::Private::matcher

Definition at line 56 of file kis_input_manager_p.h.

moveEventCompressor

KisSignalCompressor KisInputManager::Private::moveEventCompressor

Definition at line 61 of file kis_input_manager_p.h.

originatingTouchBeginEvent

QScopedPointer<QEvent> KisInputManager::Private::originatingTouchBeginEvent

Definition at line 78 of file kis_input_manager_p.h.

popupWasActive

bool KisInputManager::Private::popupWasActive = false

Definition at line 73 of file kis_input_manager_p.h.

popupWidget

KisPopupWidgetInterface* KisInputManager::Private::popupWidget

Definition at line 83 of file kis_input_manager_p.h.

previousPos

QPointF KisInputManager::Private::previousPos

Definition at line 77 of file kis_input_manager_p.h.

priorityEventFilter

PriorityList KisInputManager::Private::priorityEventFilter

Definition at line 68 of file kis_input_manager_p.h.

priorityEventFilterSeqNo

int KisInputManager::Private::priorityEventFilterSeqNo

Definition at line 69 of file kis_input_manager_p.h.

q

KisInputManager* KisInputManager::Private::q

Definition at line 46 of file kis_input_manager_p.h.

shouldSynchronizeOnNextKeyPress

bool KisInputManager::Private::shouldSynchronizeOnNextKeyPress = false

Definition at line 81 of file kis_input_manager_p.h.

startingPos

QPointF KisInputManager::Private::startingPos

Definition at line 76 of file kis_input_manager_p.h.

tabletLatencyTracker

KisSharedPtr<TabletLatencyTracker> KisInputManager::Private::tabletLatencyTracker

Definition at line 179 of file kis_input_manager_p.h.

testingAcceptCompressedTabletEvents

bool KisInputManager::Private::testingAcceptCompressedTabletEvents = false

Definition at line 63 of file kis_input_manager_p.h.

testingCompressBrushEvents

bool KisInputManager::Private::testingCompressBrushEvents = false

Definition at line 64 of file kis_input_manager_p.h.

toolProxy

QPointer<KisToolProxy> KisInputManager::Private::toolProxy

Definition at line 49 of file kis_input_manager_p.h.

TOUCH_HOLD_DELAY_MS

constexpr int KisInputManager::Private::TOUCH_HOLD_DELAY_MS = 400

staticconstexpr

Definition at line 32 of file kis_input_manager_p.h.

touchHasBlockedPressEvents

bool KisInputManager::Private::touchHasBlockedPressEvents = false

Definition at line 54 of file kis_input_manager_p.h.

touchHoldTimer

QTimer* KisInputManager::Private::touchHoldTimer

Definition at line 85 of file kis_input_manager_p.h.

touchStrokeBlocked

bool KisInputManager::Private::touchStrokeBlocked = false

Definition at line 72 of file kis_input_manager_p.h.

touchStrokeStarted

bool KisInputManager::Private::touchStrokeStarted = false

Definition at line 71 of file kis_input_manager_p.h.

useUnbalancedKeyPressEventWorkaround

bool KisInputManager::Private::useUnbalancedKeyPressEventWorkaround = false

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