qquicktaphandler.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquicktaphandler_p.h"
#include "qquicksinglepointhandler_p_p.h"
#include <QtQuick/private/qquickdeliveryagent_p_p.h>
#include <QtQuick/qquickwindow.h>
#include <qpa/qplatformtheme.h>
#include <private/qguiapplication_p.h>
#include <QtGui/qstylehints.h>
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcTapHandler, "qt.quick.handler.tap")
 
quint64 QQuickTapHandler::m_multiTapInterval(0);
// single tap distance is the same as the drag threshold
int QQuickTapHandler::m_mouseMultiClickDistanceSquared(-1);
int QQuickTapHandler::m_touchMultiTapDistanceSquared(-1);
 
QQuickTapHandler::QQuickTapHandler(QQuickItem *parent)
    : QQuickSinglePointHandler(parent)
    , m_longPressThreshold(QGuiApplication::styleHints()->mousePressAndHoldInterval())
{
    if (m_mouseMultiClickDistanceSquared < 0) {
        m_multiTapInterval = qApp->styleHints()->mouseDoubleClickInterval();
        m_mouseMultiClickDistanceSquared = qApp->styleHints()->mouseDoubleClickDistance();
        m_mouseMultiClickDistanceSquared *= m_mouseMultiClickDistanceSquared;
        m_touchMultiTapDistanceSquared = qApp->styleHints()->touchDoubleTapDistance();
        m_touchMultiTapDistanceSquared *= m_touchMultiTapDistanceSquared;
    }
}
 
bool QQuickTapHandler::wantsEventPoint(const QPointerEvent *event, const QEventPoint &point)
{
    if (!QQuickDeliveryAgentPrivate::isMouseEvent(event) &&
            !QQuickDeliveryAgentPrivate::isTouchEvent(event) &&
            !QQuickDeliveryAgentPrivate::isTabletEvent(event))
        return false;
    // If the user has not violated any constraint, it could be a tap.
    // Otherwise we want to give up the grab so that a competing handler
    // (e.g. DragHandler) gets a chance to take over.
    // Don't forget to emit released in case of a cancel.
    bool ret = false;
    bool overThreshold = d_func()->dragOverThreshold(point);
    if (overThreshold && m_gesturePolicy != DragWithinBounds) {
        if (m_longPressTimer.isActive())
            qCDebug(lcTapHandler) << objectName() << "drag threshold exceeded";
        m_longPressTimer.stop();
        m_holdTimer.invalidate();
    }
    switch (point.state()) {
    case QEventPoint::Pressed:
    case QEventPoint::Released:
        ret = parentContains(point);
        break;
    case QEventPoint::Updated:
        ret = point.id() == this->point().id();
        switch (m_gesturePolicy) {
        case DragThreshold:
            ret = ret && !overThreshold && parentContains(point);
            break;
        case WithinBounds:
        case DragWithinBounds:
            ret = ret && parentContains(point);
            break;
        case ReleaseWithinBounds:
            // no change to ret: depends only whether it's the already-tracking point ID
            break;
        }
        break;
    case QEventPoint::Stationary:
        // If the point hasn't moved since last time, the return value should be the same as last time.
        // If we return false here, QQuickPointerHandler::handlePointerEvent() will call setActive(false).
        ret = point.id() == this->point().id();
        break;
    case QEventPoint::Unknown:
        break;
    }
    // If this is the grabber, returning false from this function will cancel the grab,
    // so onGrabChanged(this, CancelGrabExclusive, point) and setPressed(false) will be called.
    // But when m_gesturePolicy is DragThreshold, we don't get an exclusive grab, but
    // we still don't want to be pressed anymore.
    if (!ret && point.id() == this->point().id())
        setPressed(false, true, const_cast<QPointerEvent *>(event), const_cast<QEventPoint &>(point));
    return ret;
}
 
void QQuickTapHandler::handleEventPoint(QPointerEvent *event, QEventPoint &point)
{
    const bool isTouch = QQuickDeliveryAgentPrivate::isTouchEvent(event);
    switch (point.state()) {
    case QEventPoint::Pressed:
        setPressed(true, false, event, point);
        break;
    case QEventPoint::Released: {
        if (isTouch || (static_cast<const QSinglePointEvent *>(event)->buttons() & acceptedButtons()) == Qt::NoButton)
            setPressed(false, false, event, point);
        break;
    }
    default:
        break;
    }
 
    QQuickSinglePointHandler::handleEventPoint(event, point);
 
    // If TapHandler only needs a passive grab, it should not block other items and handlers from reacting.
    // If the point is accepted, QQuickItemPrivate::localizedTouchEvent() would skip it.
    if (isTouch && m_gesturePolicy == DragThreshold)
        point.setAccepted(false);
}
 
qreal QQuickTapHandler::longPressThreshold() const
{
    return m_longPressThreshold / qreal(1000);
}
 
void QQuickTapHandler::setLongPressThreshold(qreal longPressThreshold)
{
    if (longPressThreshold < 0) {
        resetLongPressThreshold();
        return;
    }
    int ms = qRound(longPressThreshold * 1000);
    if (m_longPressThreshold == ms)
        return;
 
    m_longPressThreshold = ms;
    emit longPressThresholdChanged();
}
 
void QQuickTapHandler::resetLongPressThreshold()
{
    int ms = QGuiApplication::styleHints()->mousePressAndHoldInterval();
    if (m_longPressThreshold == ms)
        return;
 
    m_longPressThreshold = ms;
    emit longPressThresholdChanged();
}
 
void QQuickTapHandler::timerEvent(QTimerEvent *event)
{
    if (event->timerId() == m_longPressTimer.timerId()) {
        m_longPressTimer.stop();
        qCDebug(lcTapHandler) << objectName() << "longPressed";
        m_longPressed = true;
        emit longPressed();
    } else if (event->timerId() == m_doubleTapTimer.timerId()) {
        m_doubleTapTimer.stop();
        qCDebug(lcTapHandler) << objectName() << "double-tap timer expired; taps:" << m_tapCount;
        Q_ASSERT(m_exclusiveSignals == (SingleTap | DoubleTap));
        if (m_tapCount == 1)
            emit singleTapped(m_singleTapReleasedPoint, m_singleTapReleasedButton);
        else if (m_tapCount == 2)
            emit doubleTapped(m_singleTapReleasedPoint, m_singleTapReleasedButton);
    }
}
 
void QQuickTapHandler::setGesturePolicy(QQuickTapHandler::GesturePolicy gesturePolicy)
{
    if (m_gesturePolicy == gesturePolicy)
        return;
 
    m_gesturePolicy = gesturePolicy;
    emit gesturePolicyChanged();
}
 
void QQuickTapHandler::setExclusiveSignals(QQuickTapHandler::ExclusiveSignals exc)
{
    if (m_exclusiveSignals == exc)
        return;
 
    m_exclusiveSignals = exc;
    emit exclusiveSignalsChanged();
}
 
void QQuickTapHandler::setPressed(bool press, bool cancel, QPointerEvent *event, QEventPoint &point)
{
    if (m_pressed != press) {
        qCDebug(lcTapHandler) << objectName() << "pressed" << m_pressed << "->" << press
                              << (cancel ? "CANCEL" : "") << point << "gp" << m_gesturePolicy;
        m_pressed = press;
        connectPreRenderSignal(press);
        updateTimeHeld();
        if (press) {
            if (m_longPressThreshold > 0)
                m_longPressTimer.start(m_longPressThreshold, this);
            m_holdTimer.start();
        } else {
            m_longPressTimer.stop();
            m_holdTimer.invalidate();
        }
        if (press) {
            // on press, grab before emitting changed signals
            if (m_gesturePolicy == DragThreshold)
                setPassiveGrab(event, point, press);
            else
                setExclusiveGrab(event, point, press);
        }
        if (!cancel && !press && parentContains(point)) {
            if (m_longPressed) {
                qCDebug(lcTapHandler) << objectName() << "long press threshold" << longPressThreshold() << "exceeded:" << point.timeHeld();
            } else {
                // Assuming here that pointerEvent()->timestamp() is in ms.
                const quint64 ts = event->timestamp();
                const quint64 interval = ts - m_lastTapTimestamp;
                const auto distanceSquared = QVector2D(point.scenePosition() - m_lastTapPos).lengthSquared();
                const auto singleTapReleasedButton = event->isSinglePointEvent() ? static_cast<QSinglePointEvent *>(event)->button() : Qt::NoButton;
                if ((interval < m_multiTapInterval && distanceSquared <
                        (event->device()->type() == QInputDevice::DeviceType::Mouse ?
                         m_mouseMultiClickDistanceSquared : m_touchMultiTapDistanceSquared))
                      && m_singleTapReleasedButton == singleTapReleasedButton) {
                    ++m_tapCount;
                } else {
                    m_singleTapReleasedButton = singleTapReleasedButton;
                    m_singleTapReleasedPoint = point;
                    m_tapCount = 1;
                }
                qCDebug(lcTapHandler) << objectName() << "tapped" << m_tapCount << "times; interval since last:" << interval
                                      << "sec; distance since last:" << qSqrt(distanceSquared);
                auto button = event->isSinglePointEvent() ? static_cast<QSinglePointEvent *>(event)->button() : Qt::NoButton;
                emit tapped(point, button);
                emit tapCountChanged();
                switch (m_exclusiveSignals) {
                case NotExclusive:
                    if (m_tapCount == 1)
                        emit singleTapped(point, button);
                    else if (m_tapCount == 2)
                        emit doubleTapped(point, button);
                    break;
                case SingleTap:
                    if (m_tapCount == 1)
                        emit singleTapped(point, button);
                    break;
                case DoubleTap:
                    if (m_tapCount == 2)
                        emit doubleTapped(point, button);
                    break;
                case (SingleTap | DoubleTap):
                    if (m_tapCount == 1) {
                        qCDebug(lcTapHandler) << objectName() << "waiting to emit singleTapped:" << m_multiTapInterval << "ms";
                        m_doubleTapTimer.start(m_multiTapInterval, this);
                    }
                }
                qCDebug(lcTapHandler) << objectName() << "tap" << m_tapCount << "after" << event->timestamp() - m_lastTapTimestamp << "ms";
 
                m_lastTapTimestamp = ts;
                m_lastTapPos = point.scenePosition();
            }
        }
        m_longPressed = false;
        emit pressedChanged();
        if (!press && m_gesturePolicy != DragThreshold) {
            // on release, ungrab after emitting changed signals
            setExclusiveGrab(event, point, press);
        }
        if (cancel) {
            emit canceled(point);
            setExclusiveGrab(event, point, false);
            // In case there is a filtering parent (Flickable), we should not give up the passive grab,
            // so that it can continue to filter future events.
            d_func()->reset();
            emit pointChanged();
        }
    }
}
 
void QQuickTapHandler::onGrabChanged(QQuickPointerHandler *grabber, QPointingDevice::GrabTransition transition,
                                     QPointerEvent *ev, QEventPoint &point)
{
    QQuickSinglePointHandler::onGrabChanged(grabber, transition, ev, point);
    bool isCanceled = transition == QPointingDevice::CancelGrabExclusive || transition == QPointingDevice::CancelGrabPassive;
    if (grabber == this && (isCanceled || point.state() == QEventPoint::Released))
        setPressed(false, isCanceled, ev, point);
}
 
void QQuickTapHandler::connectPreRenderSignal(bool conn)
{
    // disconnect pre-existing connection, if any
    disconnect(m_preRenderSignalConnection);
 
    auto par = parentItem();
    if (!par || !par->window())
        return;
 
    /*
        Note: beforeSynchronizing is emitted from the SG thread, and the
        timeHeldChanged signal can be used to do arbitrary things in user QML.
 
        But the docs say the GUI thread is blockd, and "Therefore, it is safe
        to access GUI thread thread data in a slot or lambda that is connected
        with Qt::DirectConnection." We use the default AutoConnection just in case.
    */
    if (conn) {
        m_preRenderSignalConnection = connect(par->window(), &QQuickWindow::beforeSynchronizing,
                                              this, &QQuickTapHandler::updateTimeHeld);
    }
}
 
void QQuickTapHandler::updateTimeHeld()
{
    emit timeHeldChanged();
}
 
QT_END_NAMESPACE
 
#include "moc_qquicktaphandler_p.cpp"