qquickhoverhandler.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 "qquickhoverhandler_p.h"
#include <private/qquicksinglepointhandler_p_p.h>
#include <private/qquickdeliveryagent_p.h>
#include <private/qquickitem_p.h>
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcHoverHandler, "qt.quick.handler.hover")
 
 
class QQuickHoverHandlerPrivate : public QQuickSinglePointHandlerPrivate
{
    Q_DECLARE_PUBLIC(QQuickHoverHandler)
 
public:
    void onEnabledChanged() override;
    void onParentChanged(QQuickItem *oldParent, QQuickItem *newParent) override;
 
    void updateHasHoverInChild(QQuickItem *item, bool hasHover);
};
 
void QQuickHoverHandlerPrivate::onEnabledChanged()
{
    Q_Q(QQuickHoverHandler);
 
    if (auto parent = q->parentItem())
        updateHasHoverInChild(parent, enabled);
    if (!enabled)
        q->setHovered(false);
 
    QQuickSinglePointHandlerPrivate::onEnabledChanged();
}
 
void QQuickHoverHandlerPrivate::onParentChanged(QQuickItem *oldParent, QQuickItem *newParent)
{
    if (oldParent)
        updateHasHoverInChild(oldParent, false);
    if (newParent)
        updateHasHoverInChild(newParent, true);
 
    QQuickSinglePointHandlerPrivate::onParentChanged(oldParent, newParent);
}
 
void QQuickHoverHandlerPrivate::updateHasHoverInChild(QQuickItem *item, bool hasHover)
{
    QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(item);
    itemPriv->setHasHoverInChild(hasHover);
    // The DA needs to resolve which items and handlers should now be hovered or unhovered.
    // Marking the parent item dirty ensures that flushFrameSynchronousEvents() will be called from the render loop,
    // even if this change is not in response to a mouse event and no item has already marked itself dirty.
    itemPriv->dirty(QQuickItemPrivate::Content);
}
 
QQuickHoverHandler::QQuickHoverHandler(QQuickItem *parent)
    : QQuickSinglePointHandler(*(new QQuickHoverHandlerPrivate), parent)
{
    Q_D(QQuickHoverHandler);
    // Tell QQuickPointerDeviceHandler::wantsPointerEvent() to ignore button state
    d->acceptedButtons = Qt::NoButton;
    if (parent)
        d->updateHasHoverInChild(parent, true);
}
 
QQuickHoverHandler::~QQuickHoverHandler()
{
    Q_D(QQuickHoverHandler);
    if (auto parent = parentItem())
        d->updateHasHoverInChild(parent, false);
}
 
void QQuickHoverHandler::setBlocking(bool blocking)
{
    if (m_blocking == blocking)
        return;
 
    m_blocking = blocking;
    emit blockingChanged();
}
 
bool QQuickHoverHandler::event(QEvent *event)
{
    switch (event->type())
    {
    case QEvent::HoverLeave:
        setHovered(false);
        setActive(false);
        break;
    default:
        return QQuickSinglePointHandler::event(event);
        break;
    }
 
    return true;
}
 
void QQuickHoverHandler::componentComplete()
{
    Q_D(QQuickHoverHandler);
    QQuickSinglePointHandler::componentComplete();
 
    if (d->enabled) {
        if (auto parent = parentItem())
            d->updateHasHoverInChild(parent, true);
    }
}
 
bool QQuickHoverHandler::wantsPointerEvent(QPointerEvent *event)
{
    // No state change should occur if a button is being pressed or released.
    if (event->isSinglePointEvent() && static_cast<QSinglePointEvent *>(event)->button())
        return false;
    auto &point = event->point(0);
    const bool inside = parentContains(point);
    if (QQuickPointerDeviceHandler::wantsPointerEvent(event) && wantsEventPoint(event, point) && inside) {
        // assume this is a mouse or tablet event, so there's only one point
        setPointId(point.id());
        return true;
    }
 
    // Some hover events come from QQuickWindow::tabletEvent(). In between,
    // some hover events come from QQuickDeliveryAgentPrivate::flushFrameSynchronousEvents(),
    // but those look like mouse events. If a particular HoverHandler instance
    // is filtering for tablet events only (e.g. by setting
    // acceptedDevices:PointerDevice.Stylus), those events should not cause
    // the hovered property to transition to false prematurely.
    // If a QQuickPointerTabletEvent caused the hovered property to become true,
    // then only another QQuickPointerTabletEvent can make it become false.
    // But after kCursorOverrideTimeout ms, QQuickItemPrivate::effectiveCursorHandler()
    // will ignore it, just in case there is no QQuickPointerTabletEvent to unset it.
    // For example, a tablet proximity leave event could occur, but we don't deliver it to the window.
    if (!inside || !(m_hoveredTablet && QQuickDeliveryAgentPrivate::isMouseEvent(event)))
        setHovered(false);
 
    return false;
}
 
void QQuickHoverHandler::handleEventPoint(QPointerEvent *ev, QEventPoint &point)
{
    bool hovered = true;
    if (point.state() == QEventPoint::Released &&
            ev->pointingDevice()->pointerType() == QPointingDevice::PointerType::Finger)
        hovered = false;
    else if (QQuickDeliveryAgentPrivate::isTabletEvent(ev))
        m_hoveredTablet = true;
    setHovered(hovered);
}
 
void QQuickHoverHandler::setHovered(bool hovered)
{
    if (m_hovered != hovered) {
        qCDebug(lcHoverHandler) << objectName() << "hovered" << m_hovered << "->" << hovered;
        m_hovered = hovered;
        if (!hovered)
            m_hoveredTablet = false;
        emit hoveredChanged();
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qquickhoverhandler_p.cpp"