qquickmousearea.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 "qquickmousearea_p.h"
#include "qquickmousearea_p_p.h"
#include "qquickwindow.h"
#if QT_CONFIG(quick_draganddrop)
#include "qquickdrag_p.h"
#endif
 
#include <private/qqmldata_p.h>
#include <private/qsgadaptationlayer_p.h>
 
#include <QtGui/private/qguiapplication_p.h>
#include <QtGui/qevent.h>
#include <QtGui/qstylehints.h>
 
#include <float.h>
 
QT_BEGIN_NAMESPACE
 
DEFINE_BOOL_CONFIG_OPTION(qmlMaVisualTouchDebugging, QML_VISUAL_TOUCH_DEBUGGING)
 
Q_DECLARE_LOGGING_CATEGORY(lcHoverTrace)
 
QQuickMouseAreaPrivate::QQuickMouseAreaPrivate()
: enabled(true), hoverEnabled(false), scrollGestureEnabled(true), hovered(false), longPress(false),
  moved(false), stealMouse(false), doubleClick(false), preventStealing(false),
  propagateComposedEvents(false), overThreshold(false),
  pressAndHoldInterval(-1)
#if QT_CONFIG(quick_draganddrop)
  , drag(nullptr)
#endif
#if QT_CONFIG(cursor)
  , cursor(nullptr)
#endif
{
}
 
QQuickMouseAreaPrivate::~QQuickMouseAreaPrivate()
{
#if QT_CONFIG(quick_draganddrop)
    delete drag;
#endif
#if QT_CONFIG(cursor)
    delete cursor;
#endif
}
 
void QQuickMouseAreaPrivate::init()
{
    Q_Q(QQuickMouseArea);
    q->setAcceptedMouseButtons(Qt::LeftButton);
    q->setAcceptTouchEvents(false); // rely on mouse events synthesized from touch
    q->setFiltersChildMouseEvents(true);
    if (qmlMaVisualTouchDebugging()) {
        q->setFlag(QQuickItem::ItemHasContents);
    }
}
 
void QQuickMouseAreaPrivate::saveEvent(QMouseEvent *event)
{
    lastPos = event->position();
    lastScenePos = event->scenePosition();
    lastButton = event->button();
    lastButtons = event->buttons();
    lastModifiers = event->modifiers();
    lastFlags = event->flags();
}
 
bool QQuickMouseAreaPrivate::isPressAndHoldConnected()
{
    Q_Q(QQuickMouseArea);
    IS_SIGNAL_CONNECTED(q, QQuickMouseArea, pressAndHold, (QQuickMouseEvent *));
}
 
bool QQuickMouseAreaPrivate::isDoubleClickConnected()
{
    Q_Q(QQuickMouseArea);
    IS_SIGNAL_CONNECTED(q, QQuickMouseArea, doubleClicked, (QQuickMouseEvent *));
}
 
bool QQuickMouseAreaPrivate::isClickConnected()
{
    Q_Q(QQuickMouseArea);
    IS_SIGNAL_CONNECTED(q, QQuickMouseArea, clicked, (QQuickMouseEvent *));
}
 
#if QT_CONFIG(wheelevent)
bool QQuickMouseAreaPrivate::isWheelConnected()
{
    Q_Q(QQuickMouseArea);
    IS_SIGNAL_CONNECTED(q, QQuickMouseArea, wheel, (QQuickWheelEvent *));
}
#endif
 
void QQuickMouseAreaPrivate::propagate(QQuickMouseEvent* event, PropagateType t)
{
    Q_Q(QQuickMouseArea);
    if (!window || !propagateComposedEvents)
        return;
    QPointF scenePos = q->mapToScene(QPointF(event->x(), event->y()));
    propagateHelper(event, window->contentItem(), scenePos, t);
}
 
bool QQuickMouseAreaPrivate::propagateHelper(QQuickMouseEvent *ev, QQuickItem *item,const QPointF &sp, PropagateType sig)
{
    //Based off of QQuickWindow::deliverInitialMousePressEvent
    //But specific to MouseArea, so doesn't belong in window
    Q_Q(const QQuickMouseArea);
    QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
 
    if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
        QPointF p = item->mapFromScene(sp);
        if (!item->contains(p))
            return false;
    }
 
    QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
    for (int ii = children.size() - 1; ii >= 0; --ii) {
        QQuickItem *child = children.at(ii);
        if (!child->isVisible() || !child->isEnabled())
            continue;
        if (propagateHelper(ev, child, sp, sig))
            return true;
    }
 
    QQuickMouseArea* ma = qobject_cast<QQuickMouseArea*>(item);
    if (ma && ma != q && ma->isEnabled() && itemPrivate->acceptedMouseButtons() & ev->button()) {
        switch (sig) {
        case Click:
            if (!ma->d_func()->isClickConnected())
                return false;
            break;
        case DoubleClick:
            if (!ma->d_func()->isDoubleClickConnected())
                return false;
            break;
        case PressAndHold:
            if (!ma->d_func()->isPressAndHoldConnected())
                return false;
            break;
        }
        QPointF p = item->mapFromScene(sp);
        if (item->contains(p)) {
            ev->setX(p.x());
            ev->setY(p.y());
            ev->setAccepted(true);//It is connected, they have to explicitly ignore to let it slide
            switch (sig) {
            case Click: emit ma->clicked(ev); break;
            case DoubleClick: emit ma->doubleClicked(ev); break;
            case PressAndHold: emit ma->pressAndHold(ev); break;
            }
            if (ev->isAccepted())
                return true;
        }
    }
    return false;
 
}
 
QQuickMouseArea::QQuickMouseArea(QQuickItem *parent)
  : QQuickItem(*(new QQuickMouseAreaPrivate), parent)
{
    Q_D(QQuickMouseArea);
    d->init();
#if QT_CONFIG(cursor)
    // Explcitly call setCursor on QQuickItem since
    // it internally keeps a boolean hasCursor that doesn't
    // get set to true unless you call setCursor
    setCursor(Qt::ArrowCursor);
#endif
}
 
QQuickMouseArea::~QQuickMouseArea()
{
}
 
qreal QQuickMouseArea::mouseX() const
{
    Q_D(const QQuickMouseArea);
    return d->lastPos.x();
}
 
qreal QQuickMouseArea::mouseY() const
{
    Q_D(const QQuickMouseArea);
    return d->lastPos.y();
}
 
bool QQuickMouseArea::isEnabled() const
{
    Q_D(const QQuickMouseArea);
    return d->enabled;
}
 
void QQuickMouseArea::setEnabled(bool a)
{
    Q_D(QQuickMouseArea);
    if (a != d->enabled) {
        d->enabled = a;
        setAcceptHoverEvents(a && d->hoverEnabled);
        emit enabledChanged();
    }
}
 
bool QQuickMouseArea::isScrollGestureEnabled() const
{
    Q_D(const QQuickMouseArea);
    return d->scrollGestureEnabled;
}
 
void QQuickMouseArea::setScrollGestureEnabled(bool e)
{
    Q_D(QQuickMouseArea);
    if (e != d->scrollGestureEnabled) {
        d->scrollGestureEnabled = e;
        emit scrollGestureEnabledChanged();
    }
}
 
bool QQuickMouseArea::preventStealing() const
{
    Q_D(const QQuickMouseArea);
    return d->preventStealing;
}
 
void QQuickMouseArea::setPreventStealing(bool prevent)
{
    Q_D(QQuickMouseArea);
    if (prevent != d->preventStealing) {
        d->preventStealing = prevent;
        setKeepMouseGrab(d->preventStealing && d->enabled);
        emit preventStealingChanged();
    }
}
 
 
bool QQuickMouseArea::propagateComposedEvents() const
{
    Q_D(const QQuickMouseArea);
    return d->propagateComposedEvents;
}
 
void QQuickMouseArea::setPropagateComposedEvents(bool prevent)
{
    Q_D(QQuickMouseArea);
    if (prevent != d->propagateComposedEvents) {
        d->propagateComposedEvents = prevent;
        setKeepMouseGrab(d->propagateComposedEvents && d->enabled);
        emit propagateComposedEventsChanged();
    }
}
 
Qt::MouseButtons QQuickMouseArea::pressedButtons() const
{
    Q_D(const QQuickMouseArea);
    return d->pressed;
}
 
void QQuickMouseArea::mousePressEvent(QMouseEvent *event)
{
    Q_D(QQuickMouseArea);
    d->moved = false;
    d->stealMouse = d->preventStealing;
    d->overThreshold = false;
    if (!d->enabled || !(event->button() & acceptedMouseButtons())) {
        QQuickItem::mousePressEvent(event);
    } else {
        d->longPress = false;
        d->saveEvent(event);
#if QT_CONFIG(quick_draganddrop)
        if (d->drag)
            d->drag->setActive(false);
#endif
        setHovered(true);
        d->startScene = event->scenePosition();
        setKeepMouseGrab(d->stealMouse);
        event->setAccepted(setPressed(event->button(), true, event->source()));
        if (event->isAccepted())
            d->pressAndHoldTimer.start(pressAndHoldInterval(), this);
    }
}
 
void QQuickMouseArea::mouseMoveEvent(QMouseEvent *event)
{
    Q_D(QQuickMouseArea);
    if (!d->enabled && !d->pressed) {
        QQuickItem::mouseMoveEvent(event);
        return;
    }
 
    // ### we should skip this if these signals aren't used
    // ### can GV handle this for us?
    setHovered(contains(event->position()));
 
    if ((event->buttons() & acceptedMouseButtons()) == 0) {
        QQuickItem::mouseMoveEvent(event);
        return;
    }
 
    d->saveEvent(event);
 
 
#if QT_CONFIG(quick_draganddrop)
    if (d->drag && d->drag->target()) {
        if (!d->moved) {
            d->targetStartPos = d->drag->target()->parentItem()
                    ? d->drag->target()->parentItem()->mapToScene(d->drag->target()->position())
                    : d->drag->target()->position();
        }
 
        QPointF startLocalPos;
        QPointF curLocalPos;
        if (drag()->target()->parentItem()) {
            startLocalPos = drag()->target()->parentItem()->mapFromScene(d->startScene);
            curLocalPos = drag()->target()->parentItem()->mapFromScene(event->scenePosition());
        } else {
            startLocalPos = d->startScene;
            curLocalPos = event->scenePosition();
        }
 
        if (keepMouseGrab() && d->stealMouse && d->overThreshold && !d->drag->active())
            d->drag->setActive(true);
 
        QPointF startPos = d->drag->target()->parentItem()
                ? d->drag->target()->parentItem()->mapFromScene(d->targetStartPos)
                : d->targetStartPos;
 
        bool dragX = drag()->axis() & QQuickDrag::XAxis;
        bool dragY = drag()->axis() & QQuickDrag::YAxis;
 
        QPointF dragPos = d->drag->target()->position();
        QPointF boundedDragPos = dragPos;
        if (dragX) {
            dragPos.setX(startPos.x() + curLocalPos.x() - startLocalPos.x());
            boundedDragPos.setX(qBound(
                    d->drag->xmin(),
                    dragPos.x(),
                    d->drag->xmax()));
        }
        if (dragY) {
            dragPos.setY(startPos.y() + curLocalPos.y() - startLocalPos.y());
            boundedDragPos.setY(qBound(
                    d->drag->ymin(),
                    dragPos.y(),
                    d->drag->ymax()));
        }
 
        QPointF targetPos = d->drag->target()->position();
 
        if (d->drag->active()) {
            d->drag->target()->setPosition(boundedDragPos);
            d->lastPos = mapFromScene(d->lastScenePos);
        }
 
        bool dragOverThresholdX = QQuickDeliveryAgentPrivate::dragOverThreshold(dragPos.x() - startPos.x(),
                                                                                Qt::XAxis, event, d->drag->threshold());
        bool dragOverThresholdY = QQuickDeliveryAgentPrivate::dragOverThreshold(dragPos.y() - startPos.y(),
                                                                                Qt::YAxis, event, d->drag->threshold());
 
        if (!d->overThreshold && (((targetPos.x() != boundedDragPos.x()) && dragOverThresholdX) ||
                                  ((targetPos.y() != boundedDragPos.y()) && dragOverThresholdY)))
        {
            d->overThreshold = true;
            if (d->drag->smoothed())
                d->startScene = event->scenePosition();
        }
 
        if (!keepMouseGrab() && d->overThreshold) {
            setKeepMouseGrab(true);
            d->stealMouse = true;
        }
 
        d->moved = true;
    }
#endif
 
    QQuickMouseEvent &me = d->quickMouseEvent;
    me.reset(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, false, d->longPress, event->flags());
#if QT_DEPRECATED_SINCE(6, 6)
    me.setSource(event->source());
#endif
    emit mouseXChanged(&me);
    me.setPosition(d->lastPos);
    emit mouseYChanged(&me);
    me.setPosition(d->lastPos);
    emit positionChanged(&me);
}
 
void QQuickMouseArea::mouseReleaseEvent(QMouseEvent *event)
{
    Q_D(QQuickMouseArea);
    d->stealMouse = false;
    d->overThreshold = false;
    if (!d->enabled && !d->pressed) {
        QQuickItem::mouseReleaseEvent(event);
    } else {
        d->saveEvent(event);
        setPressed(event->button(), false, event->source());
        if (!d->pressed) {
            // no other buttons are pressed
#if QT_CONFIG(quick_draganddrop)
            if (d->drag)
                d->drag->setActive(false);
#endif
            // If we don't accept hover, we need to reset containsMouse.
            if (!hoverEnabled())
                setHovered(false);
            QQuickWindow *w = window();
            if (w && w->mouseGrabberItem() == this)
                ungrabMouse();
            if (!d->preventStealing)
                setKeepMouseGrab(false);
        }
    }
    d->doubleClick = false;
}
 
void QQuickMouseArea::mouseDoubleClickEvent(QMouseEvent *event)
{
    Q_D(QQuickMouseArea);
    if (d->enabled) {
        d->saveEvent(event);
        QQuickMouseEvent &me = d->quickMouseEvent;
        me.reset(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, true,
                 false, event->flags());
#if QT_DEPRECATED_SINCE(6, 6)
        me.setSource(event->source());
#endif
        me.setAccepted(d->isDoubleClickConnected());
        emit this->doubleClicked(&me);
        if (!me.isAccepted())
            d->propagate(&me, QQuickMouseAreaPrivate::DoubleClick);
        if (d->pressed)
            d->doubleClick = d->isDoubleClickConnected() || me.isAccepted();
 
        // Do not call the base implementation: we don't want to call event->ignore().
        return;
    }
    QQuickItem::mouseDoubleClickEvent(event);
}
 
void QQuickMouseArea::hoverEnterEvent(QHoverEvent *event)
{
    Q_D(QQuickMouseArea);
    if (!d->enabled && !d->pressed) {
        // Note: The fact that MouseArea doesn't update 'containsMouse' when it's disabled, is a
        // legacy behavior that is different from how hover events are supposed to work; Hover
        // events are always delivered to both enabled and disabled items (when they explicitly
        // subscribe for them), to open up for hover effects, like showing tooltips. Because of
        // this difference, you cannot use a MouseArea to e.g trigger a tooltop on a parent that
        // is disabled. But since MouseArea has always worked this way, it should (probably) stay
        // that way to avoid regressions. HoverHandlers do not suffer from this limitation, and
        // can therefore be used as a replacement to solve such cases.
        QQuickItem::hoverEnterEvent(event);
    } else {
        d->lastPos = event->position();
        d->lastModifiers = event->modifiers();
        setHovered(true);
        QQuickMouseEvent &me = d->quickMouseEvent;
        me.reset(d->lastPos.x(), d->lastPos.y(), Qt::NoButton, Qt::NoButton, d->lastModifiers, false, false);
        emit mouseXChanged(&me);
        me.setPosition(d->lastPos);
        emit mouseYChanged(&me);
        me.setPosition(d->lastPos);
    }
 
    // A MouseArea should not block hover events
    event->ignore();
}
 
void QQuickMouseArea::hoverMoveEvent(QHoverEvent *event)
{
    Q_D(QQuickMouseArea);
    if (!d->enabled && !d->pressed) {
        QQuickItem::hoverMoveEvent(event);
    } else if (d->lastPos != event->position()) {
        d->lastPos = event->position();
        d->lastModifiers = event->modifiers();
        QQuickMouseEvent &me = d->quickMouseEvent;
        me.reset(d->lastPos.x(), d->lastPos.y(), Qt::NoButton, Qt::NoButton, d->lastModifiers, false, false);
        emit mouseXChanged(&me);
        me.setPosition(d->lastPos);
        emit mouseYChanged(&me);
        me.setPosition(d->lastPos);
        emit positionChanged(&me);
    }
 
    // A MouseArea should not block hover events
    event->ignore();
}
 
void QQuickMouseArea::hoverLeaveEvent(QHoverEvent *event)
{
    Q_D(QQuickMouseArea);
    if (!d->enabled && !d->pressed && !d->hovered)
        QQuickItem::hoverLeaveEvent(event);
    else
        setHovered(false);
 
    // A MouseArea should not block hover events
    event->ignore();
}
 
#if QT_CONFIG(wheelevent)
void QQuickMouseArea::wheelEvent(QWheelEvent *event)
{
    Q_D(QQuickMouseArea);
    if (!d->enabled || (!isScrollGestureEnabled() && event->source() != Qt::MouseEventNotSynthesized)) {
        QQuickItem::wheelEvent(event);
        return;
    }
 
    QQuickWheelEvent &we = d->quickWheelEvent;
    we.reset(event);
    we.setAccepted(d->isWheelConnected());
    emit wheel(&we);
    if (!we.isAccepted())
        QQuickItem::wheelEvent(event);
}
#endif
 
void QQuickMouseArea::ungrabMouse()
{
    Q_D(QQuickMouseArea);
    if (d->pressed) {
        // if our mouse grab has been removed (probably by Flickable), fix our
        // state
        d->pressed = Qt::NoButton;
        d->stealMouse = false;
        d->doubleClick = false;
        d->overThreshold = false;
        setKeepMouseGrab(false);
 
#if QT_CONFIG(quick_draganddrop)
        if (d->drag)
            d->drag->setActive(false);
#endif
 
        emit canceled();
        emit pressedChanged();
        emit containsPressChanged();
        emit pressedButtonsChanged();
 
        if (d->hovered && !isUnderMouse()) {
            qCDebug(lcHoverTrace) << "losing hover: not under the mouse";
            d->hovered = false;
            emit hoveredChanged();
        }
    }
}
 
void QQuickMouseArea::mouseUngrabEvent()
{
    ungrabMouse();
}
 
void QQuickMouseArea::touchUngrabEvent()
{
    // allow a Pointer Handler to steal the grab from MouseArea
    ungrabMouse();
}
 
bool QQuickMouseArea::sendMouseEvent(QMouseEvent *event)
{
    Q_D(QQuickMouseArea);
    QPointF localPos = mapFromScene(event->scenePosition());
 
    QQuickWindow *c = window();
    QQuickItem *grabber = c ? c->mouseGrabberItem() : nullptr;
    bool stealThisEvent = d->stealMouse;
    if ((stealThisEvent || contains(localPos)) && (!grabber || !grabber->keepMouseGrab())) {
        QMouseEvent mouseEvent(event->type(), localPos, event->scenePosition(), event->globalPosition(),
                               event->button(), event->buttons(), event->modifiers());
        mouseEvent.setAccepted(false);
 
        switch (event->type()) {
        case QEvent::MouseMove:
            mouseMoveEvent(&mouseEvent);
            break;
        case QEvent::MouseButtonPress:
            mousePressEvent(&mouseEvent);
            break;
        case QEvent::MouseButtonRelease:
            mouseReleaseEvent(&mouseEvent);
            stealThisEvent = d->stealMouse;
            break;
        default:
            break;
        }
        grabber = c ? c->mouseGrabberItem() : nullptr;
        if (grabber && stealThisEvent && !grabber->keepMouseGrab() && grabber != this)
            grabMouse();
 
        return stealThisEvent;
    }
    if (event->type() == QEvent::MouseButtonRelease) {
        if (d->pressed) {
            d->pressed &= ~event->button();
            emit pressedButtonsChanged();
            if (!d->pressed) {
                // no other buttons are pressed
                d->stealMouse = false;
                d->overThreshold = false;
                if (c && c->mouseGrabberItem() == this)
                    ungrabMouse();
                emit canceled();
                emit pressedChanged();
                emit containsPressChanged();
                if (d->hovered) {
                    qCDebug(lcHoverTrace) << "losing hover: button released";
                    d->hovered = false;
                    emit hoveredChanged();
                }
            }
        }
    }
    return false;
}
 
bool QQuickMouseArea::childMouseEventFilter(QQuickItem *i, QEvent *e)
{
    Q_D(QQuickMouseArea);
    if (!d->pressed &&
            (!d->enabled || !isVisible()
#if QT_CONFIG(quick_draganddrop)
             || !d->drag || !d->drag->filterChildren()
#endif
            )
       )
        return QQuickItem::childMouseEventFilter(i, e);
    switch (e->type()) {
    case QEvent::MouseButtonPress:
    case QEvent::MouseMove:
    case QEvent::MouseButtonRelease:
        return sendMouseEvent(static_cast<QMouseEvent *>(e));
    default:
        break;
    }
 
    return QQuickItem::childMouseEventFilter(i, e);
}
 
void QQuickMouseArea::timerEvent(QTimerEvent *event)
{
    Q_D(QQuickMouseArea);
    if (event->timerId() == d->pressAndHoldTimer.timerId()) {
        d->pressAndHoldTimer.stop();
#if QT_CONFIG(quick_draganddrop)
        bool dragged = d->drag && d->drag->active();
#else
        bool dragged = false;
#endif
        if (d->pressed && dragged == false && d->hovered == true) {
            d->longPress = true;
            QQuickMouseEvent &me = d->quickMouseEvent;
            me.reset(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, false, d->longPress, d->lastFlags);
#if QT_DEPRECATED_SINCE(6, 6)
            me.setSource(Qt::MouseEventSynthesizedByQt);
#endif
            me.setAccepted(d->isPressAndHoldConnected());
            emit pressAndHold(&me);
            if (!me.isAccepted())
                d->propagate(&me, QQuickMouseAreaPrivate::PressAndHold);
            if (!me.isAccepted()) // no one handled the long press - allow click
                d->longPress = false;
        }
    }
}
 
void QQuickMouseArea::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
    Q_D(QQuickMouseArea);
    QQuickItem::geometryChange(newGeometry, oldGeometry);
 
    if (!d->lastScenePos.isValid())
        d->lastScenePos = mapToScene(d->lastPos);
    else if (newGeometry.x() != oldGeometry.x() || newGeometry.y() != oldGeometry.y())
        d->lastPos = mapFromScene(d->lastScenePos);
}
 
void QQuickMouseArea::itemChange(ItemChange change, const ItemChangeData &value)
{
    Q_D(QQuickMouseArea);
    switch (change) {
    case ItemEnabledHasChanged:
        // If MouseArea becomes effectively disabled by disabling a parent
        // (for example, onPressed: parent.enabled = false), cancel the pressed state.
        if (d->pressed && !d->effectiveEnable)
            ungrabMouse();
        break;
    case ItemVisibleHasChanged:
        if (d->effectiveEnable && d->enabled && hoverEnabled()
            && d->hovered != (isVisible() && isUnderMouse())) {
            if (d->hovered) {
                // If hovered but no longer under the mouse then un-hover.
                setHovered(false);
            } else {
                // If under the mouse but not hovered then hover the QQuickMouseArea if it is
                // marked as a hovered item under the windows QQuickDeliveryAgentPrivate instance.
                // This is required as this QQuickMouseArea may be masked by another hoverable
                // QQuickMouseArea higher up in the scenes z-index ordering.
                QPointF globalPos{ QGuiApplicationPrivate::lastCursorPosition.toPoint() };
                QPointF scenePos{ d->window->mapFromGlobal(globalPos) };
 
                QQuickWindowPrivate *wd = QQuickWindowPrivate::get(d->window);
                QQuickDeliveryAgentPrivate *dap = wd->deliveryAgentPrivate();
 
                // If the QQuickDeliveryAgentPrivate has not already found a hovered leaf
                // item then attempt to find one.
                if (!dap->hoveredLeafItemFound) {
                    dap->deliverHoverEvent(scenePos, scenePos, Qt::NoModifier,
                                           QDateTime::currentSecsSinceEpoch());
                }
 
                // Now if the QQuickDeliveryAgentPrivate has found a hovered leaf item check
                // that this QQuickMouseArea item was one of the hovered items.
                if (dap->hoveredLeafItemFound) {
                    for (auto hoverItem : dap->hoverItems) {
                        if (hoverItem.first == this) {
                            // Found a match so update the hover state.
                            d->lastScenePos = scenePos;
                            d->lastPos = mapFromScene(d->lastScenePos);
                            setHovered(true);
                            break;
                        }
                    }
                }
            }
        }
        if (d->pressed && (!isVisible())) {
            // This happens when the mouse area hides itself
            // inside the press handler. In that case we should not keep the internal
            // state as pressed, since we never became the mouse grabber.
            ungrabMouse();
        }
        break;
    default:
        break;
    }
 
    QQuickItem::itemChange(change, value);
}
 
bool QQuickMouseArea::hoverEnabled() const
{
    return d_func()->hoverEnabled;
}
 
void QQuickMouseArea::setHoverEnabled(bool h)
{
    Q_D(QQuickMouseArea);
    if (h == d->hoverEnabled)
        return;
 
    d->hoverEnabled = h;
    setAcceptHoverEvents(h && d->enabled);
 
    emit hoverEnabledChanged();
}
 
 
bool QQuickMouseArea::hovered() const
{
    Q_D(const QQuickMouseArea);
    return d->hovered;
}
 
bool QQuickMouseArea::isPressed() const
{
    Q_D(const QQuickMouseArea);
    return d->pressed;
}
 
bool QQuickMouseArea::containsPress() const
{
    Q_D(const QQuickMouseArea);
    return d->pressed && d->hovered;
}
 
void QQuickMouseArea::setHovered(bool h)
{
    Q_D(QQuickMouseArea);
    if (d->hovered != h) {
        qCDebug(lcHoverTrace) << this << d->hovered <<  "->" << h;
        d->hovered = h;
        emit hoveredChanged();
        d->hovered ? emit entered() : emit exited();
        if (d->pressed)
            emit containsPressChanged();
    }
}
 
Qt::MouseButtons QQuickMouseArea::acceptedButtons() const
{
    return acceptedMouseButtons();
}
 
void QQuickMouseArea::setAcceptedButtons(Qt::MouseButtons buttons)
{
    if (buttons != acceptedMouseButtons()) {
        setAcceptedMouseButtons(buttons);
        emit acceptedButtonsChanged();
    }
}
 
bool QQuickMouseArea::setPressed(Qt::MouseButton button, bool p, Qt::MouseEventSource source)
{
    Q_D(QQuickMouseArea);
 
#if QT_CONFIG(quick_draganddrop)
    bool dragged = d->drag && d->drag->active();
#else
    bool dragged = false;
#endif
    bool wasPressed = d->pressed & button;
    bool isclick = wasPressed && p == false && dragged == false && d->hovered == true;
    Qt::MouseButtons oldPressed = d->pressed;
 
    if (wasPressed != p) {
        QQuickMouseEvent &me = d->quickMouseEvent;
        me.reset(d->lastPos.x(), d->lastPos.y(), d->lastButton, d->lastButtons, d->lastModifiers, isclick, d->longPress, d->lastFlags);
#if QT_DEPRECATED_SINCE(6, 6)
        me.setSource(source);
#endif
        if (p) {
            d->pressed |= button;
            if (!d->doubleClick)
                emit pressed(&me);
            me.setPosition(d->lastPos);
            emit mouseXChanged(&me);
            me.setPosition(d->lastPos);
            emit mouseYChanged(&me);
 
            if (!me.isAccepted()) {
                d->pressed = Qt::NoButton;
                if (!hoverEnabled())
                    setHovered(false);
            }
 
            if (!oldPressed) {
                emit pressedChanged();
                emit containsPressChanged();
            }
            emit pressedButtonsChanged();
        } else {
            d->pressed &= ~button;
            emit released(&me);
            me.setPosition(d->lastPos);
            if (!d->pressed) {
                emit pressedChanged();
                emit containsPressChanged();
            }
            emit pressedButtonsChanged();
            if (isclick && !d->longPress && !d->doubleClick){
                me.setAccepted(d->isClickConnected());
                emit clicked(&me);
                if (!me.isAccepted())
                    d->propagate(&me, QQuickMouseAreaPrivate::Click);
            }
        }
 
        return me.isAccepted();
    }
    Q_UNUSED(source)
    return false;
}
 
 
#if QT_CONFIG(cursor)
Qt::CursorShape QQuickMouseArea::cursorShape() const
{
    return cursor().shape();
}
 
void QQuickMouseArea::setCursorShape(Qt::CursorShape shape)
{
    if (cursor().shape() == shape)
        return;
 
    setCursor(shape);
 
    emit cursorShapeChanged();
}
 
#endif
 
 
int QQuickMouseArea::pressAndHoldInterval() const
{
    Q_D(const QQuickMouseArea);
    return d->pressAndHoldInterval > -1 ?
        d->pressAndHoldInterval : QGuiApplication::styleHints()->mousePressAndHoldInterval();
}
 
void QQuickMouseArea::setPressAndHoldInterval(int interval)
{
    Q_D(QQuickMouseArea);
    if (interval != d->pressAndHoldInterval) {
        d->pressAndHoldInterval = interval;
        emit pressAndHoldIntervalChanged();
    }
}
 
void QQuickMouseArea::resetPressAndHoldInterval()
{
    Q_D(QQuickMouseArea);
    if (d->pressAndHoldInterval > -1) {
        d->pressAndHoldInterval = -1;
        emit pressAndHoldIntervalChanged();
    }
}
 
#if QT_CONFIG(quick_draganddrop)
QQuickDrag *QQuickMouseArea::drag()
{
    Q_D(QQuickMouseArea);
    if (!d->drag)
        d->drag = new QQuickDrag;
    return d->drag;
}
#endif
 
QSGNode *QQuickMouseArea::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *data)
{
    Q_UNUSED(data);
    Q_D(QQuickMouseArea);
 
    if (!qmlMaVisualTouchDebugging())
        return nullptr;
 
    QSGInternalRectangleNode *rectangle = static_cast<QSGInternalRectangleNode *>(oldNode);
    if (!rectangle) rectangle = d->sceneGraphContext()->createInternalRectangleNode();
 
    rectangle->setRect(QRectF(0, 0, width(), height()));
    rectangle->setColor(QColor(255, 0, 0, 50));
    rectangle->update();
    return rectangle;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickmousearea_p.cpp"