KisLongPressEventFilter Class Reference

#include <KisLongPressEventFilter.h>

Inheritance diagram for KisLongPressEventFilter:

Public Member Functions
bool	eventFilter (QObject *watched, QEvent *event) override
	KisLongPressEventFilter (QObject *parent=nullptr)

Static Public Attributes
static constexpr char	ENABLED_PROPERTY [] = "KRITA_LONG_PRESS"

Private Member Functions
void	cancel ()
void	flush ()
int	getKineticScrollDelay (QWidget *target) const
bool	handleMouseMove (const QMouseEvent *me)
bool	handleMousePress (QWidget *target, const QMouseEvent *me)
bool	isWithinDistance (const QPoint &globalPos) const
void	triggerLongPress ()

Static Private Member Functions
static bool	isContextMenuTarget (QWidget *target)
static bool	isLongPressableWidget (QWidget *target)
static const QScroller *	searchScroller (QWidget *target)

Private Attributes
long long	m_distanceSquared = 0LL
bool	m_handlingEvent = false
QPoint	m_pressGlobalPos
QPoint	m_pressLocalPos
QPointer< QWidget >	m_target
QTimer *	m_timer

Static Private Attributes
static constexpr int	MINIMUM_DELAY = 100
static constexpr int	MINIMUM_DISTANCE = 0

Detailed Description

Definition at line 13 of file KisLongPressEventFilter.h.

Constructor & Destructor Documentation

KisLongPressEventFilter()

KisLongPressEventFilter::KisLongPressEventFilter ( QObject * parent = nullptr )

explicit

Definition at line 24 of file KisLongPressEventFilter.cpp.

    : QObject(parent)
{
    m_timer = new QTimer(this);
    m_timer->setTimerType(Qt::CoarseTimer);
    m_timer->setSingleShot(true);
    connect(m_timer, &QTimer::timeout, this, &KisLongPressEventFilter::triggerLongPress);
#ifdef Q_OS_ANDROID
    m_longPressTimeout =
        QAndroidJniObject::callStaticMethod<jint>("org/krita/android/MainActivity", "getLongPressTimeout", "()I");
#endif
}

References m_timer, and triggerLongPress().

Member Function Documentation

cancel()

void KisLongPressEventFilter::cancel ( )

private

Definition at line 137 of file KisLongPressEventFilter.cpp.

{
    m_timer->stop();
    m_target.clear();
}

References m_target, and m_timer.

eventFilter()

bool KisLongPressEventFilter::eventFilter ( QObject * watched, QEvent * event )

override

Definition at line 37 of file KisLongPressEventFilter.cpp.

{
    if (!m_handlingEvent) {
        QScopedValueRollback rollback(m_handlingEvent, true);
        switch (event->type()) {
        case QEvent::MouseButtonPress:
            if (handleMousePress(qobject_cast<QWidget *>(watched), static_cast<QMouseEvent *>(event))) {
                event->setAccepted(true);
                return true;
            }
            break;
        case QEvent::MouseMove:
            if (handleMouseMove(static_cast<QMouseEvent *>(event))) {
                return true;
            }
            break;
        case QEvent::MouseButtonDblClick:
        case QEvent::MouseButtonRelease:
            flush();
            break;
        default:
            break;
        }
    }
    return QObject::eventFilter(watched, event);
}

References flush(), handleMouseMove(), handleMousePress(), and m_handlingEvent.

flush()

void KisLongPressEventFilter::flush ( )

private

Definition at line 122 of file KisLongPressEventFilter.cpp.

{
    QWidget *target = m_target.data();
    cancel();
    if (target && target->isVisible()) {
        QMouseEvent event(QEvent::MouseButtonPress,
                          m_pressLocalPos,
                          m_pressGlobalPos,
                          Qt::LeftButton,
                          Qt::LeftButton,
                          Qt::NoModifier);
        qApp->sendEvent(target, &event);
    }
}

References cancel(), m_pressGlobalPos, m_pressLocalPos, m_target, and target().

getKineticScrollDelay()

int KisLongPressEventFilter::getKineticScrollDelay ( QWidget * target ) const

private

Definition at line 182 of file KisLongPressEventFilter.cpp.

{
    if (KisKineticScroller::getConfiguredGestureType() != QScroller::LeftMouseButtonGesture) {
        return 0;
    }
 
    const QScroller *scroller = searchScroller(target);
    if (!scroller) {
        return 0;
    }
 
    qreal pressDelay = scroller->scrollerProperties().scrollMetric(QScrollerProperties::MousePressEventDelay).toReal();
    if (pressDelay < 0.0) {
        return 0;
    }
 
    return int(pressDelay * 1000.0);
}

References KisKineticScroller::getConfiguredGestureType(), searchScroller(), and target().

handleMouseMove()

bool KisLongPressEventFilter::handleMouseMove ( const QMouseEvent * me )

private

Definition at line 105 of file KisLongPressEventFilter.cpp.

{
    if (m_timer->isActive()) {
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
        QPoint globalPos = me->globalPos();
#else
        QPoint globalPos = me->globalPosition().toPoint();
#endif
        if (isWithinDistance(globalPos)) {
            return true;
        } else {
            flush();
        }
    }
    return false;
}

References flush(), isWithinDistance(), and m_timer.

handleMousePress()

bool KisLongPressEventFilter::handleMousePress ( QWidget * target, const QMouseEvent * me )

private

Definition at line 64 of file KisLongPressEventFilter.cpp.

{
    if (me->buttons() == Qt::LeftButton && me->modifiers() == Qt::NoModifier && isContextMenuTarget(target)) {
        const QStyleHints *sh = qApp->styleHints();
        long long distance = qMax(MINIMUM_DISTANCE, sh->startDragDistance());
        m_distanceSquared = distance * distance;
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
        m_pressLocalPos = me->pos();
        m_pressGlobalPos = me->globalPos();
#else
        m_pressLocalPos = me->position().toPoint();
        m_pressGlobalPos = me->globalPosition().toPoint();
#endif
        // Kinetic scrolling may have already delayed the input, so subtract
        // that from the intended delay to avoid waiting for it twice. This may
        // end up with a delay of zero, but that's okay. Also, the user may have
        // already dragged far enough for the cursor to be outside of the
        // long-press distance (it only checks the axes that are scrollable), in
        // which case we bail out here.
        int kineticScrollDelay = getKineticScrollDelay(target);
        if (kineticScrollDelay == 0 || isWithinDistance(QCursor::pos())) {
            m_target = target;
#ifdef Q_OS_ANDROID
            int longPressInterval = m_longPressTimeout;
#else
            int longPressInterval = sh->mousePressAndHoldInterval();
#endif
            if (longPressInterval < MINIMUM_DELAY) {
                longPressInterval = MINIMUM_DELAY;
            }
            // Kinetic scrolling may have already delayed the input, so subtract
            // that from the intended delay to avoid waiting for it twice. This
            // may end up with a delay of zero, but that's okay.
            m_timer->start(qMax(0, longPressInterval - kineticScrollDelay));
            return true;
        }
    }
    cancel();
    return false;
}

References cancel(), distance(), getKineticScrollDelay(), isContextMenuTarget(), isWithinDistance(), m_distanceSquared, m_pressGlobalPos, m_pressLocalPos, m_target, m_timer, MINIMUM_DELAY, MINIMUM_DISTANCE, and target().

isContextMenuTarget()

bool KisLongPressEventFilter::isContextMenuTarget ( QWidget * target )

staticprivate

Definition at line 213 of file KisLongPressEventFilter.cpp.

{
    while (target && target->isVisible() && isLongPressableWidget(target)) {
        switch (target->contextMenuPolicy()) {
        case Qt::NoContextMenu:
            target = target->parentWidget();
            break;
        case Qt::PreventContextMenu:
            return false;
        default:
            return true;
        }
    }
    return false;
}

References isLongPressableWidget(), and target().

isLongPressableWidget()

bool KisLongPressEventFilter::isLongPressableWidget ( QWidget * target )

staticprivate

Definition at line 229 of file KisLongPressEventFilter.cpp.

{
    QVariant prop = target->property(ENABLED_PROPERTY);
    if (prop.isValid()) {
        return prop.toBool();
    }
 
    // Several widget types don't have desirable long-press behavior. If they're
    // our own widgets, we should just fix that in the widget, but we can"t
    // really sensibly do that to Qt's widgets. Luckily however, those widgets
    // really shouldn't have context menus in the first place, so we can just
    // disregard them as long-press targets and be done with it.
 
    // Buttons get depressed when you click and hold on them and won't pop back
    // up if a context menu is opened during that. They may also have a menu
    // attached to them that the user operates like a context menu.
    if (qobject_cast<QAbstractButton *>(target)) {
        return false;
    }
 
    // Slightly non-obvious, but this thing has many child classes, like text
    // areas or the canvas, none of which have sensible context menus.
    if (qobject_cast<QAbstractScrollArea *>(target)) {
        return false;
    }
 
    // Sliders (including scrollbars) may get dragged slowly.
    if (qobject_cast<QAbstractSlider *>(target)) {
        return false;
    }
 
    // Spinners may get held down to keep a number spinning.
    if (qobject_cast<QAbstractSpinBox *>(target)) {
        return false;
    }
 
    // Combo boxes get held down to pick an item.
    if (qobject_cast<QComboBox *>(target)) {
        return false;
    }
 
    // Text editing will have its own long-press handling.
    if (qobject_cast<QLineEdit *>(target)) {
        return false;
    }
 
    // Menus don't have context menus.
    if (qobject_cast<QMenu *>(target)) {
        return false;
    }
 
    // Menu bars don't have context menus either.
    if (qobject_cast<QMenuBar *>(target)) {
        return false;
    }
 
    return true;
}

References ENABLED_PROPERTY, and target().

isWithinDistance()

bool KisLongPressEventFilter::isWithinDistance ( const QPoint & globalPos ) const

private

Definition at line 143 of file KisLongPressEventFilter.cpp.

{
    long long x = globalPos.x() - m_pressGlobalPos.x();
    long long y = globalPos.y() - m_pressGlobalPos.y();
    return (x * x) + (y * y) <= m_distanceSquared;
}

References m_distanceSquared, and m_pressGlobalPos.

searchScroller()

const QScroller * KisLongPressEventFilter::searchScroller ( QWidget * target )

staticprivate

Definition at line 201 of file KisLongPressEventFilter.cpp.

{
    while (target) {
        if (QScroller::hasScroller(target)) {
            return QScroller::scroller(target);
        } else {
            target = target->parentWidget();
        }
    }
    return nullptr;
}

References target().

triggerLongPress()

void KisLongPressEventFilter::triggerLongPress ( )

private

Definition at line 150 of file KisLongPressEventFilter.cpp.

{
    QWidget *target = m_target.data();
    cancel();
    if (!m_handlingEvent && isContextMenuTarget(target)) {
        QScopedValueRollback rollback(m_handlingEvent, true);
        // First we synchronously send a right click press and release so that
        // the target widget can update its state correctly. Afterwards we post
        // the context menu event to it so that'll open. As far as I can tell,
        // that's what Qt does when you right-click on a widget as well.
        {
            QMouseEvent pressEvent(QEvent::MouseButtonPress,
                                   m_pressLocalPos,
                                   m_pressGlobalPos,
                                   Qt::RightButton,
                                   Qt::RightButton,
                                   Qt::NoModifier);
            qApp->sendEvent(target, &pressEvent);
        }
        {
            QMouseEvent releaseEvent(QEvent::MouseButtonRelease,
                                     m_pressLocalPos,
                                     m_pressGlobalPos,
                                     Qt::RightButton,
                                     Qt::NoButton,
                                     Qt::NoModifier);
            qApp->sendEvent(target, &releaseEvent);
        }
        qApp->postEvent(target, new QContextMenuEvent(QContextMenuEvent::Mouse, m_pressLocalPos, m_pressGlobalPos));
    }
}

References cancel(), isContextMenuTarget(), m_handlingEvent, m_pressGlobalPos, m_pressLocalPos, m_target, and target().

Member Data Documentation

ENABLED_PROPERTY

constexpr char KisLongPressEventFilter::ENABLED_PROPERTY[] = "KRITA_LONG_PRESS"

staticconstexpr

Definition at line 17 of file KisLongPressEventFilter.h.

m_distanceSquared

long long KisLongPressEventFilter::m_distanceSquared = 0LL

private

Definition at line 43 of file KisLongPressEventFilter.h.

m_handlingEvent

bool KisLongPressEventFilter::m_handlingEvent = false

private

Definition at line 50 of file KisLongPressEventFilter.h.

m_pressGlobalPos

QPoint KisLongPressEventFilter::m_pressGlobalPos

private

Definition at line 45 of file KisLongPressEventFilter.h.

m_pressLocalPos

QPoint KisLongPressEventFilter::m_pressLocalPos

private

Definition at line 44 of file KisLongPressEventFilter.h.

m_target

QPointer<QWidget> KisLongPressEventFilter::m_target

private

Definition at line 46 of file KisLongPressEventFilter.h.

m_timer

QTimer* KisLongPressEventFilter::m_timer

private

Definition at line 42 of file KisLongPressEventFilter.h.

MINIMUM_DELAY

constexpr int KisLongPressEventFilter::MINIMUM_DELAY = 100

staticconstexprprivate

Definition at line 24 of file KisLongPressEventFilter.h.

MINIMUM_DISTANCE

constexpr int KisLongPressEventFilter::MINIMUM_DISTANCE = 0

staticconstexprprivate

Definition at line 25 of file KisLongPressEventFilter.h.

---

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

• libs/ui/KisLongPressEventFilter.h
• libs/ui/KisLongPressEventFilter.cpp