#include <kis_input_manager_p.h>

Public Member Functions
void	activate ()

void	deactivate ()

void	eatOneMousePress ()

	EventEater ()

bool	eventFilter (QObject target, QEvent event)

void	startBlockingTouch ()

void	stopBlockingTouch ()

Public Attributes
bool	activateSecondaryButtonsWorkaround {false}

bool	eatSyntheticEvents {false}

bool	eatTouchEvents {false}

bool	hungry {false}

bool	peckish {false}

Detailed Description

Definition at line 127 of file kis_input_manager_p.h.

Constructor & Destructor Documentation

◆ EventEater()

KisInputManager::Private::EventEater::EventEater ( )

Definition at line 68 of file kis_input_manager_p.cpp.

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

References activateSecondaryButtonsWorkaround, and KisConfig::useRightMiddleTabletButtonWorkaround().

Member Function Documentation

◆ activate()

void KisInputManager::Private::EventEater::activate ( )

Definition at line 155 of file kis_input_manager_p.cpp.

{
    if (!hungry && (KisTabletDebugger::instance()->debugEnabled())) {
        dbgTablet << "Start blocking mouse events";
    }
    hungry = true;
}

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

◆ deactivate()

void KisInputManager::Private::EventEater::deactivate ( )

Definition at line 163 of file kis_input_manager_p.cpp.

{
    if (hungry && (KisTabletDebugger::instance()->debugEnabled())) {
        dbgTablet << "Stop blocking mouse events";
    }
    hungry = false;
}

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

◆ eatOneMousePress()

void KisInputManager::Private::EventEater::eatOneMousePress ( )

Definition at line 171 of file kis_input_manager_p.cpp.

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

◆ eventFilter()

bool KisInputManager::Private::EventEater::eventFilter	(	QObject *	target,
		QEvent *	event )

Definition at line 74 of file kis_input_manager_p.cpp.

{
    Q_UNUSED(target);
 
    auto debugEvent = [&](int i) {
        if (KisTabletDebugger::instance()->debugEnabled()) {
            QString pre = QString("[BLOCKED %1:]").arg(i);
            QMouseEvent *ev = static_cast<QMouseEvent*>(event);
            dbgTablet << KisTabletDebugger::instance()->eventToString(*ev, pre);
        }
    };
 
    auto debugTabletEvent = [&](int i) {
        if (KisTabletDebugger::instance()->debugEnabled()) {
            QString pre = QString("[BLOCKED %1:]").arg(i);
            QTabletEvent *ev = static_cast<QTabletEvent*>(event);
            dbgTablet << KisTabletDebugger::instance()->eventToString(*ev, pre);
        }
    };
 
    auto debugTouchEvent = [&](int i) {
        if (KisTabletDebugger::instance()->debugEnabled()) {
            QString pre = QString("[BLOCKED %1:]").arg(i);
            QTouchEvent *ev = static_cast<QTouchEvent*>(event);
            dbgTablet << KisTabletDebugger::instance()->eventToString(*ev, pre);
        }
    };
 
    if (peckish && event->type() == QEvent::MouseButtonPress
        // Drop one mouse press following tabletPress or touchBegin
        && (static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)) {
        peckish = false;
        debugEvent(1);
        return true;
    }
 
    if (activateSecondaryButtonsWorkaround) {
        if (event->type() == QEvent::TabletPress ||
                event->type() == QEvent::TabletRelease) {
 
            QTabletEvent *te = static_cast<QTabletEvent*>(event);
            if (te->button() != Qt::LeftButton) {
                debugTabletEvent(3);
                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;
            }
        }
    }
 
    if (isMouseEventType(event->type()) &&
               (hungry
            // 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
                || (eatSyntheticEvents && static_cast<QMouseEvent*>(event)->source() != Qt::MouseEventNotSynthesized)
            #endif
                )) {
        // Drop mouse events if enabled or event was synthetic & synthetic events are disabled
        debugEvent(2);
        return true;
    }
 
    if (eatTouchEvents && event->type() == QEvent::TouchBegin) {
        // Drop touch events. If QEvent::TouchBegin is ignored, we won't
        // receive further touch events until the next TouchBegin.
        debugTouchEvent(3);
        event->ignore();
        return true;
    }
 
    return false; // All clear - let this one through!
}

References dbgTablet, KisTabletDebugger::debugEnabled(), KisInputManager::Private::debugEvent(), KisTabletDebugger::eventToString(), KisTabletDebugger::instance(), isMouseEventType(), source(), and target().

◆ startBlockingTouch()

void KisInputManager::Private::EventEater::startBlockingTouch ( )

Definition at line 177 of file kis_input_manager_p.cpp.

{
    eatTouchEvents = true;
}

◆ stopBlockingTouch()

void KisInputManager::Private::EventEater::stopBlockingTouch ( )

Definition at line 182 of file kis_input_manager_p.cpp.

{
    eatTouchEvents = false;
}

Member Data Documentation

◆ activateSecondaryButtonsWorkaround

bool KisInputManager::Private::EventEater::activateSecondaryButtonsWorkaround {false}

Definition at line 149 of file kis_input_manager_p.h.

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

◆ eatSyntheticEvents

bool KisInputManager::Private::EventEater::eatSyntheticEvents {false}

Definition at line 148 of file kis_input_manager_p.h.

148{false}; // Mask all synthetic events

◆ eatTouchEvents

bool KisInputManager::Private::EventEater::eatTouchEvents {false}

Definition at line 150 of file kis_input_manager_p.h.

150{false}; // Eat touch interactions

◆ hungry

bool KisInputManager::Private::EventEater::hungry {false}

Definition at line 146 of file kis_input_manager_p.h.

146{false}; // Continue eating mouse strokes

◆ peckish

bool KisInputManager::Private::EventEater::peckish {false}

Definition at line 147 of file kis_input_manager_p.h.

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

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

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

Public Member Functions

Public Attributes