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 ()
template<class Event , bool useBlocking>
void	debugEvent (QEvent *event)
void	eatOneMousePress ()
void	fixShortcutMatcherModifiersState ()
void	fixShortcutMatcherModifiersState (QVector< Qt::Key > newKeys, Qt::KeyboardModifiers modifiers)
bool	handleCompressedTabletEvent (QEvent *event)
bool	ignoringQtCursorEvents ()
	Private (KisInputManager *qq)
bool	processUnhandledEvent (QEvent *event)
void	resetCompressor ()
void	setMaskSyntheticEvents (bool value)
void	setupActions ()
void	startBlockingTouch ()
void	stopBlockingTouch ()

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

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 65 of file kis_input_manager_p.h.

PriorityPair

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

Definition at line 64 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 197 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_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::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 502 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 592 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 473 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 552 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.
        shortcut->setDisableOnTouchPainting(true);
        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::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 521 of file kis_input_manager_p.cpp.

{
    QScopedPointer<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.take());
}

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 668 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 663 of file kis_input_manager_p.cpp.

{
    eventEater.activate();
}

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

debugEvent()

template<class Event , bool useBlocking>

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

inline

Definition at line 89 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 694 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 729 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 )

Definition at line 743 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;
        }
    }
 
    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, and processUnhandledEvent().

handleCompressedTabletEvent()

bool KisInputManager::Private::handleCompressedTabletEvent

(

QEvent *

event

)

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

{
    return eventEater.hungry;
}

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

processUnhandledEvent()

bool KisInputManager::Private::processUnhandledEvent

(

QEvent *

event

)

Definition at line 638 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 699 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 192 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 620 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, connect(), defaultInputAction, KisInputProfileManager::instance(), KisInputManager::profileChanged(), and q.

startBlockingTouch()

void KisInputManager::Private::startBlockingTouch

(

)

Definition at line 704 of file kis_input_manager_p.cpp.

{
    eventEater.startBlockingTouch();
}

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

stopBlockingTouch()

void KisInputManager::Private::stopBlockingTouch

(

)

Definition at line 709 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 156 of file kis_input_manager_p.h.

canvas

QPointer<KisCanvas2> KisInputManager::Private::canvas

Definition at line 46 of file kis_input_manager_p.h.

canvasSwitcher

CanvasSwitcher KisInputManager::Private::canvasSwitcher

Definition at line 125 of file kis_input_manager_p.h.

compressedMoveEvent

QScopedPointer<QEvent> KisInputManager::Private::compressedMoveEvent

Definition at line 60 of file kis_input_manager_p.h.

containsPointer

bool KisInputManager::Private::containsPointer = false

Definition at line 154 of file kis_input_manager_p.h.

defaultInputAction

KisToolInvocationAction* KisInputManager::Private::defaultInputAction = 0

Definition at line 56 of file kis_input_manager_p.h.

eventEater

EventEater KisInputManager::Private::eventEater

Definition at line 152 of file kis_input_manager_p.h.

eventsReceiver

QObject* KisInputManager::Private::eventsReceiver = 0

Definition at line 58 of file kis_input_manager_p.h.

forwardAllEventsToTool

bool KisInputManager::Private::forwardAllEventsToTool = false

Definition at line 49 of file kis_input_manager_p.h.

matcher

KisShortcutMatcher KisInputManager::Private::matcher

Definition at line 54 of file kis_input_manager_p.h.

moveEventCompressor

KisSignalCompressor KisInputManager::Private::moveEventCompressor

Definition at line 59 of file kis_input_manager_p.h.

originatingTouchBeginEvent

QScopedPointer<QEvent> KisInputManager::Private::originatingTouchBeginEvent

Definition at line 73 of file kis_input_manager_p.h.

popupWasActive

bool KisInputManager::Private::popupWasActive = false

Definition at line 70 of file kis_input_manager_p.h.

popupWidget

KisPopupWidgetInterface* KisInputManager::Private::popupWidget

Definition at line 78 of file kis_input_manager_p.h.

previousPos

QPointF KisInputManager::Private::previousPos

Definition at line 72 of file kis_input_manager_p.h.

priorityEventFilter

PriorityList KisInputManager::Private::priorityEventFilter

Definition at line 66 of file kis_input_manager_p.h.

priorityEventFilterSeqNo

int KisInputManager::Private::priorityEventFilterSeqNo

Definition at line 67 of file kis_input_manager_p.h.

q

KisInputManager* KisInputManager::Private::q

Definition at line 44 of file kis_input_manager_p.h.

shouldSynchronizeOnNextKeyPress

bool KisInputManager::Private::shouldSynchronizeOnNextKeyPress = false

Definition at line 76 of file kis_input_manager_p.h.

tabletLatencyTracker

KisSharedPtr<TabletLatencyTracker> KisInputManager::Private::tabletLatencyTracker

Definition at line 164 of file kis_input_manager_p.h.

testingAcceptCompressedTabletEvents

bool KisInputManager::Private::testingAcceptCompressedTabletEvents = false

Definition at line 61 of file kis_input_manager_p.h.

testingCompressBrushEvents

bool KisInputManager::Private::testingCompressBrushEvents = false

Definition at line 62 of file kis_input_manager_p.h.

toolProxy

QPointer<KisToolProxy> KisInputManager::Private::toolProxy

Definition at line 47 of file kis_input_manager_p.h.

touchHasBlockedPressEvents

bool KisInputManager::Private::touchHasBlockedPressEvents = false

Definition at line 52 of file kis_input_manager_p.h.

touchStrokeStarted

bool KisInputManager::Private::touchStrokeStarted = false

Definition at line 69 of file kis_input_manager_p.h.

useUnbalancedKeyPressEventWorkaround

bool KisInputManager::Private::useUnbalancedKeyPressEventWorkaround = false

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