Revision control
++ // Copyright (C) 2021 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
++ // Qt-Security score:significant reason:default
++
++ #include <QtCore/qdebug.h>
++ #include <QtGui/private/qevent_p.h>
++ #include <QtGui/private/qeventpoint_p.h>
++ #include <QtGui/private/qguiapplication_p.h>
++ #include <QtGui/qpa/qplatformtheme.h>
++ #include <QtQml/private/qabstractanimationjob_p.h>
++ #include <QtQuick/private/qquickdeliveryagent_p_p.h>
++ #include <QtQuick/private/qquickhoverhandler_p.h>
++ #include <QtQuick/private/qquickpointerhandler_p_p.h>
++ #if QT_CONFIG(quick_draganddrop)
++ #include <QtQuick/private/qquickdrag_p.h>
++ #endif
++ #include <QtQuick/private/qquickitem_p.h>
++ #include <QtQuick/private/qquickprofiler_p.h>
++ #include <QtQuick/private/qquickrendercontrol_p.h>
++ #include <QtQuick/private/qquickwindow_p.h>
++
++ #include <QtCore/qpointer.h>
++ #include <QtCore/qvarlengtharray.h>
++
++ #include <algorithm>
++ #include <memory>
++
++ QT_BEGIN_NAMESPACE
++
++ Q_LOGGING_CATEGORY(lcTouch, "qt.quick.touch")
++ Q_STATIC_LOGGING_CATEGORY(lcTouchCmprs, "qt.quick.touch.compression")
++ Q_LOGGING_CATEGORY(lcTouchTarget, "qt.quick.touch.target")
++ Q_LOGGING_CATEGORY(lcMouse, "qt.quick.mouse")
++ Q_STATIC_LOGGING_CATEGORY(lcMouseTarget, "qt.quick.mouse.target")
++ Q_STATIC_LOGGING_CATEGORY(lcTablet, "qt.quick.tablet")
++ Q_LOGGING_CATEGORY(lcPtr, "qt.quick.pointer")
++ Q_STATIC_LOGGING_CATEGORY(lcPtrLoc, "qt.quick.pointer.localization")
++ Q_STATIC_LOGGING_CATEGORY(lcWheelTarget, "qt.quick.wheel.target")
++ Q_LOGGING_CATEGORY(lcHoverTrace, "qt.quick.hover.trace")
++ Q_LOGGING_CATEGORY(lcHoverCursor, "qt.quick.hover.cursor")
++ Q_LOGGING_CATEGORY(lcFocus, "qt.quick.focus")
++ Q_STATIC_LOGGING_CATEGORY(lcContextMenu, "qt.quick.contextmenu")
++
++ extern Q_GUI_EXPORT bool qt_sendShortcutOverrideEvent(QObject *o, ulong timestamp, int k, Qt::KeyboardModifiers mods, const QString &text = QString(), bool autorep = false, ushort count = 1);
++
++ bool QQuickDeliveryAgentPrivate::subsceneAgentsExist(false);
++ QQuickDeliveryAgent *QQuickDeliveryAgentPrivate::currentEventDeliveryAgent(nullptr);
++
++ static bool allowSyntheticRightClick()
++ {
++ static int allowRightClick = -1;
++ if (allowRightClick < 0) {
++ bool ok = false;
++ allowRightClick = qEnvironmentVariableIntValue("QT_QUICK_ALLOW_SYNTHETIC_RIGHT_CLICK", &ok);
++ if (!ok)
++ allowRightClick = 1; // user didn't opt out
++ }
++ return allowRightClick != 0;
++ }
++
++ static QQuickDeliveryAgentPrivate::HoverItems::iterator findHoverStateByItem(QQuickDeliveryAgentPrivate::HoverItems &hoverItems, QQuickItem *item)
++ {
++ return std::find_if(hoverItems.begin(), hoverItems.end(),
++ [item](const QQuickDeliveryAgentPrivate::HoverItemState &hoverState) {
++ return hoverState.item == item;
++ });
++ }
++
++ static QQuickDeliveryAgentPrivate::HoverItems::const_iterator findHoverStateByItem(const QQuickDeliveryAgentPrivate::HoverItems &hoverItems, const QQuickItem *item)
++ {
++ return std::find_if(hoverItems.cbegin(), hoverItems.cend(),
++ [item](const QQuickDeliveryAgentPrivate::HoverItemState &hoverState) {
++ return hoverState.item == item;
++ });
++ }
++
++ /*! \internal
++ Marks \a state as hovered, by a device that is a fingertip if \a fromTouch is \c true.
++
++ fromTouch is refreshed only if the entry is not hovered right now: an entry whose
++ hoverId is 0 is a leftover from a hover that has already ended (it stays in
++ hoverItems until deliverHoverEvent() prunes it), so hovering it again belongs to
++ whichever device is establishing hover now. As long as the entry is hovered it keeps
++ the flag it got when hover began, so that a finger tapping an item that a cursor
++ already hovers cannot turn the cursor's hover into touch hover - which
++ clearTouchHover() would then take away when the contact ends.
++ */
++ static void markHovered(QQuickDeliveryAgentPrivate::HoverItemState &state, uint hoverId, bool fromTouch)
++ {
++ if (state.hoverId == 0)
++ state.fromTouch = fromTouch;
++ state.hoverId = hoverId;
++ }
++
++ void QQuickDeliveryAgentPrivate::touchToMouseEvent(QEvent::Type type, const QEventPoint &p, const QTouchEvent *touchEvent, QMutableSinglePointEvent *mouseEvent)
++ {
++ Q_ASSERT(QCoreApplication::testAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents));
++ QMutableSinglePointEvent ret(type, touchEvent->pointingDevice(), p,
++ (type == QEvent::MouseMove ? Qt::NoButton : Qt::LeftButton),
++ (type == QEvent::MouseButtonRelease ? Qt::NoButton : Qt::LeftButton),
++ touchEvent->modifiers(), Qt::MouseEventSynthesizedByQt);
++ ret.setAccepted(true); // this now causes the persistent touchpoint to be accepted too
++ ret.setTimestamp(touchEvent->timestamp());
++ *mouseEvent = ret;
++ // It's very important that the recipient of the event shall be able to see that
++ // this "mouse" event actually comes from a touch device.
++ Q_ASSERT(mouseEvent->device() == touchEvent->device());
++ if (Q_UNLIKELY(mouseEvent->device()->type() == QInputDevice::DeviceType::Mouse))
++ qWarning() << "Unexpected: synthesized an indistinguishable mouse event" << mouseEvent;
++ }
++
++ /*!
++ Returns \c false if the time constraint for detecting a double-click is violated.
++ */
++ bool QQuickDeliveryAgentPrivate::isWithinDoubleClickInterval(ulong timeInterval)
++ {
++ return timeInterval < static_cast<ulong>(QGuiApplication::styleHints()->mouseDoubleClickInterval());
++ }
++
++ /*!
++ Returns \c false if the spatial constraint for detecting a touchscreen double-tap is violated.
++ */
++ bool QQuickDeliveryAgentPrivate::isWithinDoubleTapDistance(const QPoint &distanceBetweenPresses)
++ {
++ auto square = [](qint64 v) { return v * v; };
++ return square(distanceBetweenPresses.x()) + square(distanceBetweenPresses.y()) <
++ square(QGuiApplication::styleHints()->touchDoubleTapDistance());
++ }
++
++ bool QQuickDeliveryAgentPrivate::checkIfDoubleTapped(ulong newPressEventTimestamp, const QPoint &newPressPos)
++ {
++ const bool doubleClicked = isDeliveringTouchAsMouse() &&
++ isWithinDoubleTapDistance(newPressPos - touchMousePressPos) &&
++ isWithinDoubleClickInterval(newPressEventTimestamp - touchMousePressTimestamp);
++ if (doubleClicked) {
++ touchMousePressTimestamp = 0;
++ } else {
++ touchMousePressTimestamp = newPressEventTimestamp;
++ touchMousePressPos = newPressPos;
++ }
++ return doubleClicked;
++ }
++
++ void QQuickDeliveryAgentPrivate::resetIfDoubleTapPrevented(const QEventPoint &pressedPoint)
++ {
++ if (touchMousePressTimestamp > 0 &&
++ (!isWithinDoubleTapDistance(pressedPoint.globalPosition().toPoint() - touchMousePressPos) ||
++ !isWithinDoubleClickInterval(pressedPoint.timestamp() - touchMousePressTimestamp))) {
++ touchMousePressTimestamp = 0;
++ touchMousePressPos = QPoint();
++ }
++ }
++
++ /*! \internal
++ \deprecated events are handled by methods in which the event is an argument.
++
++ Accessor for use by legacy methods such as QQuickItem::grabMouse(),
++ QQuickItem::ungrabMouse(), and QQuickItem::grabTouchPoints() which
++ are not given sufficient context to do the grabbing.
++ We should remove eventsInDelivery in Qt 7.
++ */
++ QPointerEvent *QQuickDeliveryAgentPrivate::eventInDelivery() const
++ {
++ if (eventsInDelivery.isEmpty())
++ return nullptr;
++ return eventsInDelivery.top();
++ }
++
++ /*! \internal
++ A helper function for the benefit of obsolete APIs like QQuickItem::grabMouse()
++ that don't have the currently-being-delivered event in context.
++ Returns the point that acts as the mouse on the device of the currently-being-delivered
++ event, or \nullptr if there is no such event or the device has no such point.
++ */
++ QPointingDevicePrivate::EventPointData *QQuickDeliveryAgentPrivate::mousePointData()
++ {
++ if (eventsInDelivery.isEmpty())
++ return nullptr;
++ auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice*>(eventsInDelivery.top()->pointingDevice()));
++ return devPriv->queryPointById(isDeliveringTouchAsMouse() ? touchMouseId : 0);
++ }
++
++ void QQuickDeliveryAgentPrivate::cancelTouchMouseSynthesis()
++ {
++ qCDebug(lcTouchTarget) << "id" << touchMouseId << "on" << touchMouseDevice;
++ touchMouseId = -1;
++ touchMouseDevice = nullptr;
++ }
++
++ bool QQuickDeliveryAgentPrivate::deliverTouchAsMouse(QQuickItem *item, QTouchEvent *pointerEvent)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ Q_ASSERT(QCoreApplication::testAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents));
++ auto device = pointerEvent->pointingDevice();
++
++ // A touch event from a trackpad is likely to be followed by a mouse or gesture event, so mouse event synth is redundant
++ if (isTouchPadWithMouseEmulation(pointerEvent->device())) {
++ qCDebug(lcTouchTarget) << q << "skipping delivery of synth-mouse event from" << device;
++ return false;
++ }
++
++ // FIXME: make this work for mouse events too and get rid of the asTouchEvent in here.
++ QMutableTouchEvent event;
++ QQuickItemPrivate::get(item)->localizedTouchEvent(pointerEvent, false, &event);
++ if (!event.points().size())
++ return false;
++
++ // For each point, check if it is accepted, if not, try the next point.
++ // Any of the fingers can become the mouse one.
++ // This can happen because a mouse area might not accept an event at some point but another.
++ for (auto &p : event.points()) {
++ // A new touch point
++ if (touchMouseId == -1 && p.state() & QEventPoint::State::Pressed) {
++ QPointF pos = item->mapFromScene(p.scenePosition());
++
++ // probably redundant, we check bounds in the calling function (matchingNewPoints)
++ if (!item->contains(pos))
++ break;
++
++ qCDebug(lcTouchTarget) << q << device << "TP (mouse)" << Qt::hex << p.id() << "->" << item;
++ QMutableSinglePointEvent mousePress;
++ touchToMouseEvent(QEvent::MouseButtonPress, p, &event, &mousePress);
++
++ // Send a single press and see if that's accepted
++ QCoreApplication::sendEvent(item, &mousePress);
++ event.setAccepted(mousePress.isAccepted());
++ if (mousePress.isAccepted()) {
++ touchMouseDevice = device;
++ touchMouseId = p.id();
++ const auto &pt = mousePress.point(0);
++ if (!mousePress.exclusiveGrabber(pt))
++ mousePress.setExclusiveGrabber(pt, item);
++
++ if (checkIfDoubleTapped(event.timestamp(), p.globalPosition().toPoint())) {
++ // since we synth the mouse event from from touch, we respect the
++ // QPlatformTheme::TouchDoubleTapDistance instead of QPlatformTheme::MouseDoubleClickDistance
++ QMutableSinglePointEvent mouseDoubleClick;
++ touchToMouseEvent(QEvent::MouseButtonDblClick, p, &event, &mouseDoubleClick);
++ QCoreApplication::sendEvent(item, &mouseDoubleClick);
++ event.setAccepted(mouseDoubleClick.isAccepted());
++ if (!mouseDoubleClick.isAccepted())
++ cancelTouchMouseSynthesis();
++ }
++
++ return true;
++ }
++ // try the next point
++
++ // Touch point was there before and moved
++ } else if (touchMouseDevice == device && p.id() == touchMouseId) {
++ if (p.state() & QEventPoint::State::Updated) {
++ if (touchMousePressTimestamp != 0) {
++ if (!isWithinDoubleTapDistance(p.globalPosition().toPoint() - touchMousePressPos))
++ touchMousePressTimestamp = 0; // Got dragged too far, dismiss the double tap
++ }
++ if (QQuickItem *mouseGrabberItem = qmlobject_cast<QQuickItem *>(pointerEvent->exclusiveGrabber(p))) {
++ QMutableSinglePointEvent me;
++ touchToMouseEvent(QEvent::MouseMove, p, &event, &me);
++ QCoreApplication::sendEvent(item, &me);
++ event.setAccepted(me.isAccepted());
++ if (me.isAccepted())
++ qCDebug(lcTouchTarget) << q << device << "TP (mouse)" << Qt::hex << p.id() << "->" << mouseGrabberItem;
++ return event.isAccepted();
++ } else {
++ // no grabber, check if we care about mouse hover
++ // FIXME: this should only happen once, not recursively... I'll ignore it just ignore hover now.
++ // hover for touch???
++ QMutableSinglePointEvent me;
++ touchToMouseEvent(QEvent::MouseMove, p, &event, &me);
++ if (lastMousePosition.isNull())
++ lastMousePosition = me.scenePosition();
++ QPointF last = lastMousePosition;
++ lastMousePosition = me.scenePosition();
++
++ deliverHoverEvent(me.scenePosition(), last, me.modifiers(), me.timestamp());
++ break;
++ }
++ } else if (p.state() & QEventPoint::State::Released) {
++ // currently handled point was released
++ if (QQuickItem *mouseGrabberItem = qmlobject_cast<QQuickItem *>(pointerEvent->exclusiveGrabber(p))) {
++ QMutableSinglePointEvent me;
++ touchToMouseEvent(QEvent::MouseButtonRelease, p, &event, &me);
++ QCoreApplication::sendEvent(item, &me);
++
++ if (pointerEvent->exclusiveGrabber(p) == mouseGrabberItem) // might have ungrabbed due to event
++ pointerEvent->setExclusiveGrabber(p, nullptr);
++
++ cancelTouchMouseSynthesis();
++ return me.isAccepted();
++ }
++ }
++ break;
++ }
++ }
++ return false;
++ }
++
++ /*!
++ Ungrabs all touchpoint grabs and/or the mouse grab from the given item \a grabber.
++ This should not be called when processing a release event - that's redundant.
++ It is called in other cases, when the points may not be released, but the item
++ nevertheless must lose its grab due to becoming disabled, invisible, etc.
++ QPointerEvent::setExclusiveGrabber() calls touchUngrabEvent() when all points are released,
++ but if not all points are released, it cannot be sure whether to call touchUngrabEvent()
++ or not; so we have to do it here.
++ */
++ void QQuickDeliveryAgentPrivate::removeGrabber(QQuickItem *grabber, bool mouse, bool touch, bool cancel)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ if (eventsInDelivery.isEmpty()) {
++ // do it the expensive way
++ for (auto dev : knownPointingDevices) {
++ auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(dev));
++ devPriv->removeGrabber(grabber, cancel);
++ }
++ return;
++ }
++ auto eventInDelivery = eventsInDelivery.top();
++ if (Q_LIKELY(mouse) && eventInDelivery) {
++ auto epd = mousePointData();
++ if (epd && epd->exclusiveGrabber == grabber && epd->exclusiveGrabberContext.data() == q) {
++ QQuickItem *oldGrabber = qobject_cast<QQuickItem *>(epd->exclusiveGrabber);
++ qCDebug(lcMouseTarget) << "removeGrabber" << oldGrabber << "-> null";
++ eventInDelivery->setExclusiveGrabber(epd->eventPoint, nullptr);
++ }
++ }
++ if (Q_LIKELY(touch)) {
++ bool ungrab = false;
++ const auto touchDevices = QPointingDevice::devices();
++ for (auto device : touchDevices) {
++ if (device->type() != QInputDevice::DeviceType::TouchScreen)
++ continue;
++ if (QPointingDevicePrivate::get(const_cast<QPointingDevice *>(static_cast<const QPointingDevice *>(device)))->
++ removeExclusiveGrabber(eventInDelivery, grabber))
++ ungrab = true;
++ }
++ if (ungrab)
++ grabber->touchUngrabEvent();
++ }
++ }
++
++ /*!
++ \internal
++
++ Clears all exclusive and passive grabs for the points in \a pointerEvent.
++
++ We never allow any kind of grab to persist after release, unless we're waiting
++ for a synth event from QtGui (as with most tablet events), so for points that
++ are fully released, the grab is cleared.
++
++ Called when QQuickWindow::event dispatches events, or when the QQuickOverlay
++ has filtered an event so that it bypasses normal delivery.
++ */
++ void QQuickDeliveryAgentPrivate::clearGrabbers(QPointerEvent *pointerEvent)
++ {
++ if (pointerEvent->isEndEvent()
++ && !(isTabletEvent(pointerEvent)
++ && (qApp->testAttribute(Qt::AA_SynthesizeMouseForUnhandledTabletEvents)
++ || QWindowSystemInterfacePrivate::TabletEvent::platformSynthesizesMouse))) {
++ if (pointerEvent->isSinglePointEvent()) {
++ if (static_cast<QSinglePointEvent *>(pointerEvent)->buttons() == Qt::NoButton) {
++ auto &firstPt = pointerEvent->point(0);
++ pointerEvent->setExclusiveGrabber(firstPt, nullptr);
++ pointerEvent->clearPassiveGrabbers(firstPt);
++ }
++ } else {
++ for (auto &point : pointerEvent->points()) {
++ if (point.state() == QEventPoint::State::Released) {
++ pointerEvent->setExclusiveGrabber(point, nullptr);
++ pointerEvent->clearPassiveGrabbers(point);
++ }
++ }
++ }
++ }
++ }
++
++ /*! \internal
++ Translates QEventPoint::scenePosition() in \a touchEvent to this window.
++
++ The item-local QEventPoint::position() is updated later, not here.
++ */
++ void QQuickDeliveryAgentPrivate::translateTouchEvent(QTouchEvent *touchEvent)
++ {
++ for (qsizetype i = 0; i != touchEvent->pointCount(); ++i) {
++ auto &pt = touchEvent->point(i);
++ QMutableEventPoint::setScenePosition(pt, pt.position());
++ }
++ }
++
++
++ static inline bool windowHasFocus(QQuickWindow *win)
++ {
++ const QWindow *focusWindow = QGuiApplication::focusWindow();
++ if (!focusWindow || win == focusWindow)
++ return true;
++ return QQuickRenderControlPrivate::isFocusWindowFor(win, focusWindow);
++ }
++
++ static QQuickItem *findFurthestFocusScopeAncestor(QQuickItem *item)
++ {
++ QQuickItem *parentItem = item->parentItem();
++
++ if (parentItem && parentItem->flags() & QQuickItem::ItemIsFocusScope)
++ return findFurthestFocusScopeAncestor(parentItem);
++
++ return item;
++ }
++
++ #ifdef Q_OS_WEBOS
++ // Temporary fix for webOS until multi-seat is implemented see QTBUG-85272
++ static inline bool singleWindowOnScreen(QQuickWindow *win)
++ {
++ const QWindowList windowList = QGuiApplication::allWindows();
++ for (int i = 0; i < windowList.count(); i++) {
++ QWindow *ii = windowList.at(i);
++ if (ii == win)
++ continue;
++ if (ii->screen() == win->screen())
++ return false;
++ }
++
++ return true;
++ }
++ #endif
++
++ /*!
++ Set the focus inside \a scope to be \a item.
++ If the scope contains the active focus item, it will be changed to \a item.
++ Calls notifyFocusChangesRecur for all changed items.
++ */
++ void QQuickDeliveryAgentPrivate::setFocusInScope(QQuickItem *scope, QQuickItem *item,
++ Qt::FocusReason reason, FocusOptions options)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ Q_ASSERT(item);
++ Q_ASSERT(scope || item == rootItem);
++
++ qCDebug(lcFocus) << q << "focus" << item << "in scope" << scope;
++ if (scope)
++ qCDebug(lcFocus) << " scopeSubFocusItem:" << QQuickItemPrivate::get(scope)->subFocusItem;
++
++ QQuickItemPrivate *scopePrivate = scope ? QQuickItemPrivate::get(scope) : nullptr;
++ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++
++ QQuickItem *oldActiveFocusItem = nullptr;
++ QQuickItem *currentActiveFocusItem = activeFocusItem;
++ QQuickItem *newActiveFocusItem = nullptr;
++ bool sendFocusIn = false;
++
++ lastFocusReason = reason;
++
++ QVarLengthArray<QQuickItem *, 20> changed;
++
++ // Does this change the active focus?
++ if (item == rootItem || scopePrivate->activeFocus) {
++ oldActiveFocusItem = activeFocusItem;
++ if (item->isEnabled()) {
++ newActiveFocusItem = item;
++ while (newActiveFocusItem->isFocusScope()
++ && newActiveFocusItem->scopedFocusItem()
++ && newActiveFocusItem->scopedFocusItem()->isEnabled()) {
++ newActiveFocusItem = newActiveFocusItem->scopedFocusItem();
++ }
++ } else {
++ newActiveFocusItem = scope;
++ }
++
++ if (oldActiveFocusItem) {
++ #if QT_CONFIG(im)
++ QGuiApplication::inputMethod()->commit();
++ #endif
++
++ activeFocusItem = nullptr;
++
++ QQuickItem *afi = oldActiveFocusItem;
++ while (afi && afi != scope) {
++ if (QQuickItemPrivate::get(afi)->activeFocus) {
++ QQuickItemPrivate::get(afi)->activeFocus = false;
++ changed << afi;
++ }
++ afi = afi->parentItem();
++ }
++ }
++ }
++
++ if (item != rootItem && !(options & DontChangeSubFocusItem)) {
++ QQuickItem *oldSubFocusItem = scopePrivate->subFocusItem;
++ if (oldSubFocusItem) {
++ QQuickItemPrivate *priv = QQuickItemPrivate::get(oldSubFocusItem);
++ priv->focus = false;
++ priv->notifyChangeListeners(QQuickItemPrivate::Focus, &QQuickItemChangeListener::itemFocusChanged, oldSubFocusItem, reason);
++ changed << oldSubFocusItem;
++ }
++
++ QQuickItemPrivate::get(item)->updateSubFocusItem(scope, true);
++ }
++
++ if (!(options & DontChangeFocusProperty)) {
++ if (item != rootItem || windowHasFocus(rootItem->window())
++ #ifdef Q_OS_WEBOS
++ // Allow focused if there is only one window in the screen where it belongs.
++ // Temporary fix for webOS until multi-seat is implemented see QTBUG-85272
++ || singleWindowOnScreen(rootItem->window())
++ #endif
++ ) {
++ itemPrivate->focus = true;
++ itemPrivate->notifyChangeListeners(QQuickItemPrivate::Focus, &QQuickItemChangeListener::itemFocusChanged, item, reason);
++ changed << item;
++ }
++ }
++
++ if (newActiveFocusItem && (rootItem->hasFocus() || (rootItem->window()->type() == Qt::Popup))) {
++ activeFocusItem = newActiveFocusItem;
++
++ QQuickItemPrivate::get(newActiveFocusItem)->activeFocus = true;
++ changed << newActiveFocusItem;
++
++ QQuickItem *afi = newActiveFocusItem->parentItem();
++ while (afi && afi != scope) {
++ if (afi->isFocusScope()) {
++ QQuickItemPrivate::get(afi)->activeFocus = true;
++ changed << afi;
++ }
++ afi = afi->parentItem();
++ }
++ updateFocusItemTransform();
++ sendFocusIn = true;
++ }
++
++ // Now that all the state is changed, emit signals & events
++ // We must do this last, as this process may result in further changes to focus.
++ if (oldActiveFocusItem) {
++ QFocusEvent event(QEvent::FocusOut, reason);
++ QCoreApplication::sendEvent(oldActiveFocusItem, &event);
++ }
++
++ // Make sure that the FocusOut didn't result in another focus change.
++ if (sendFocusIn && activeFocusItem == newActiveFocusItem) {
++ QFocusEvent event(QEvent::FocusIn, reason);
++ QCoreApplication::sendEvent(newActiveFocusItem, &event);
++ }
++
++ if (activeFocusItem != currentActiveFocusItem)
++ emit rootItem->window()->focusObjectChanged(activeFocusItem);
++
++ if (!changed.isEmpty())
++ notifyFocusChangesRecur(changed.data(), changed.size() - 1, reason);
++ if (isSubsceneAgent) {
++ auto da = QQuickWindowPrivate::get(rootItem->window())->deliveryAgent;
++ qCDebug(lcFocus) << " delegating setFocusInScope to" << da;
++
++ // When setting subFocusItem, hierarchy is important. Each focus ancestor's
++ // subFocusItem must be its nearest descendant with focus. Changing the rootItem's
++ // subFocusItem to 'item' here would make 'item' the subFocusItem of all ancestor
++ // focus scopes up until root item.
++ // That is why we should avoid altering subFocusItem until having traversed
++ // all the focus hierarchy.
++ QQuickItem *ancestorFS = findFurthestFocusScopeAncestor(item);
++ if (ancestorFS != item)
++ options |= QQuickDeliveryAgentPrivate::DontChangeSubFocusItem;
++ QQuickWindowPrivate::get(rootItem->window())->deliveryAgentPrivate()->setFocusInScope(da->rootItem(), item, reason, options);
++ }
++ if (oldActiveFocusItem == activeFocusItem)
++ qCDebug(lcFocus) << " activeFocusItem remains" << activeFocusItem << "in" << q;
++ else
++ qCDebug(lcFocus) << " activeFocusItem" << oldActiveFocusItem << "->" << activeFocusItem << "in" << q;
++ }
++
++ void QQuickDeliveryAgentPrivate::clearFocusInScope(QQuickItem *scope, QQuickItem *item, Qt::FocusReason reason, FocusOptions options)
++ {
++ Q_ASSERT(item);
++ Q_ASSERT(scope || item == rootItem);
++ Q_Q(QQuickDeliveryAgent);
++ qCDebug(lcFocus) << q << "clear focus" << item << "in scope" << scope;
++
++ QQuickItemPrivate *scopePrivate = nullptr;
++ if (scope) {
++ scopePrivate = QQuickItemPrivate::get(scope);
++ if ( !scopePrivate->subFocusItem )
++ return; // No focus, nothing to do.
++ }
++
++ QQuickItem *currentActiveFocusItem = activeFocusItem;
++ QQuickItem *oldActiveFocusItem = nullptr;
++ QQuickItem *newActiveFocusItem = nullptr;
++
++ lastFocusReason = reason;
++
++ QVarLengthArray<QQuickItem *, 20> changed;
++
++ Q_ASSERT(item == rootItem || item == scopePrivate->subFocusItem);
++
++ // Does this change the active focus?
++ if (item == rootItem || scopePrivate->activeFocus) {
++ oldActiveFocusItem = activeFocusItem;
++ newActiveFocusItem = scope;
++
++ #if QT_CONFIG(im)
++ QGuiApplication::inputMethod()->commit();
++ #endif
++
++ activeFocusItem = nullptr;
++
++ if (oldActiveFocusItem) {
++ QQuickItem *afi = oldActiveFocusItem;
++ while (afi && afi != scope) {
++ if (QQuickItemPrivate::get(afi)->activeFocus) {
++ QQuickItemPrivate::get(afi)->activeFocus = false;
++ changed << afi;
++ }
++ afi = afi->parentItem();
++ }
++ }
++ }
++
++ if (item != rootItem && !(options & DontChangeSubFocusItem)) {
++ QQuickItem *oldSubFocusItem = scopePrivate->subFocusItem;
++ if (oldSubFocusItem && !(options & DontChangeFocusProperty)) {
++ QQuickItemPrivate *priv = QQuickItemPrivate::get(oldSubFocusItem);
++ priv->focus = false;
++ priv->notifyChangeListeners(QQuickItemPrivate::Focus, &QQuickItemChangeListener::itemFocusChanged, oldSubFocusItem, reason);
++ changed << oldSubFocusItem;
++ }
++
++ QQuickItemPrivate::get(item)->updateSubFocusItem(scope, false);
++
++ } else if (!(options & DontChangeFocusProperty)) {
++ QQuickItemPrivate *priv = QQuickItemPrivate::get(item);
++ priv->focus = false;
++ priv->notifyChangeListeners(QQuickItemPrivate::Focus, &QQuickItemChangeListener::itemFocusChanged, item, reason);
++ changed << item;
++ }
++
++ if (newActiveFocusItem) {
++ Q_ASSERT(newActiveFocusItem == scope);
++ activeFocusItem = scope;
++ updateFocusItemTransform();
++ }
++
++ // Now that all the state is changed, emit signals & events
++ // We must do this last, as this process may result in further changes to focus.
++ if (oldActiveFocusItem) {
++ QFocusEvent event(QEvent::FocusOut, reason);
++ QCoreApplication::sendEvent(oldActiveFocusItem, &event);
++ }
++
++ // Make sure that the FocusOut didn't result in another focus change.
++ if (newActiveFocusItem && activeFocusItem == newActiveFocusItem) {
++ QFocusEvent event(QEvent::FocusIn, reason);
++ QCoreApplication::sendEvent(newActiveFocusItem, &event);
++ }
++
++ QQuickWindow *rootItemWindow = rootItem->window();
++ if (activeFocusItem != currentActiveFocusItem && rootItemWindow)
++ emit rootItemWindow->focusObjectChanged(activeFocusItem);
++
++ if (!changed.isEmpty())
++ notifyFocusChangesRecur(changed.data(), changed.size() - 1, reason);
++ if (isSubsceneAgent && rootItemWindow) {
++ auto da = QQuickWindowPrivate::get(rootItemWindow)->deliveryAgent;
++ qCDebug(lcFocus) << " delegating clearFocusInScope to" << da;
++ QQuickWindowPrivate::get(rootItemWindow)->deliveryAgentPrivate()->clearFocusInScope(da->rootItem(), item, reason, options);
++ }
++ if (oldActiveFocusItem == activeFocusItem)
++ qCDebug(lcFocus) << "activeFocusItem remains" << activeFocusItem << "in" << q;
++ else
++ qCDebug(lcFocus) << " activeFocusItem" << oldActiveFocusItem << "->" << activeFocusItem << "in" << q;
++ }
++
++ void QQuickDeliveryAgentPrivate::clearFocusObject()
++ {
++ if (activeFocusItem == rootItem)
++ return;
++
++ clearFocusInScope(rootItem, QQuickItemPrivate::get(rootItem)->subFocusItem, Qt::OtherFocusReason);
++ }
++
++ void QQuickDeliveryAgentPrivate::notifyFocusChangesRecur(QQuickItem **items, int remaining, Qt::FocusReason reason)
++ {
++ QPointer<QQuickItem> item(*items);
++
++ if (item) {
++ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++
++ if (itemPrivate->notifiedFocus != itemPrivate->focus) {
++ itemPrivate->notifiedFocus = itemPrivate->focus;
++ itemPrivate->notifyChangeListeners(QQuickItemPrivate::Focus, &QQuickItemChangeListener::itemFocusChanged, item, reason);
++ emit item->focusChanged(itemPrivate->focus);
++ }
++
++ if (item && itemPrivate->notifiedActiveFocus != itemPrivate->activeFocus) {
++ itemPrivate->notifiedActiveFocus = itemPrivate->activeFocus;
++ itemPrivate->itemChange(QQuickItem::ItemActiveFocusHasChanged, bool(itemPrivate->activeFocus));
++ itemPrivate->notifyChangeListeners(QQuickItemPrivate::Focus, &QQuickItemChangeListener::itemFocusChanged, item, reason);
++ emit item->activeFocusChanged(itemPrivate->activeFocus);
++ }
++ }
++
++ if (remaining)
++ notifyFocusChangesRecur(items + 1, remaining - 1, reason);
++ }
++
++ bool QQuickDeliveryAgentPrivate::clearHover(ulong timestamp)
++ {
++ if (hoverItems.isEmpty())
++ return false;
++
++ QQuickWindow *window = rootItem->window();
++ if (!window)
++ return false;
++
++ const auto globalPos = QGuiApplicationPrivate::lastCursorPosition;
++ const QPointF lastPos = window->mapFromGlobal(globalPos);
++ const auto modifiers = QGuiApplication::keyboardModifiers();
++
++ // while we don't modify hoveritems directly in the loop, the delivery of the event
++ // is expected to reset the stored ID for each cleared item, and items might also
++ // be removed from the list in response to event delivery.
++ // So we don't want to iterate over a const version of hoverItems here (it would be
++ // misleading), but still use const_iterators to avoid premature detach and constant
++ // ref-count-checks.
++ for (auto it = hoverItems.cbegin(); it != hoverItems.cend(); ++it) {
++ if (QQuickItem *item = it->item) {
++ deliverHoverEventToItem(item, item->mapFromScene(lastPos), lastPos, lastPos,
++ globalPos, modifiers, timestamp, HoverChange::Clear);
++ Q_ASSERT(([this, item]{
++ const auto it2 = findHoverStateByItem(std::as_const(hoverItems), item);
++ return it2 == hoverItems.cend() || it2->hoverId == 0;
++ }()));
++ }
++ }
++
++ return true;
++ }
++
++ /*! \internal
++ Returns \c true if \a item is currently hovered by a device that hovers (mouse,
++ or stylus in proximity) rather than only because a fingertip is touching it.
++
++ An item that sets its own hover state outside deliverHoverEvent()'s bookkeeping
++ (see QQuickMouseArea::mousePressEvent()) needs this to tell whether lifting a
++ finger should end its hover, or whether a cursor is still resting on it.
++ */
++ bool QQuickDeliveryAgentPrivate::isHoveredByHoveringDevice(const QQuickItem *item) const
++ {
++ const auto it = findHoverStateByItem(hoverItems, item);
++ if (it != hoverItems.cend() && it->hoverId != 0 && !it->fromTouch)
++ return true;
++
++ // deliverHoverEvent() erases an item's entry as soon as the finger moves off,
++ // so a cursor-established entry can be replaced by a touch-established hover
++ // while the cursor has not moved at all. Fall back to where the cursor is.
++ // On a platform with no cursor, lastCursorPosition is never written; this returns false.
++ if (!item->window())
++ return false;
++ const QPointF cursorScenePos =
++ item->window()->mapFromGlobal(QPointF(QGuiApplicationPrivate::lastCursorPosition));
++ return item->contains(item->mapFromScene(cursorScenePos));
++ }
++
++ /*! \internal
++ Clears hover on those items whose hover was established by a fingertip touching
++ them, and leaves alone any item that a hovering device - a mouse cursor, or a
++ stylus in proximity - is hovering.
++
++ Called when the last finger is lifted: a fingertip has no hover state that
++ outlives contact, so its hover has to end with the contact (QTBUG-62912). But a
++ cursor resting on an item goes on hovering it regardless of what the fingers do,
++ which is why this is not simply clearHover().
++ */
++ void QQuickDeliveryAgentPrivate::clearTouchHover(ulong timestamp)
++ {
++ if (hoverItems.isEmpty())
++ return;
++
++ QQuickWindow *window = rootItem->window();
++ if (!window)
++ return;
++
++ const auto globalPos = QGuiApplicationPrivate::lastCursorPosition;
++ const QPointF lastPos = window->mapFromGlobal(globalPos);
++ const auto modifiers = QGuiApplication::keyboardModifiers();
++
++ // Take a copy of the items to clear before delivering anything: delivery can both
++ // reset the stored ids and remove entries from hoverItems (see clearHover()).
++ QVarLengthArray<QPointer<QQuickItem>, 4> toClear;
++ for (auto it = hoverItems.cbegin(); it != hoverItems.cend(); ++it) {
++ if (it->item && it->fromTouch && !isHoveredByHoveringDevice(it->item))
++ toClear.append(it->item);
++ }
++
++ for (const auto &item : toClear) {
++ if (!item)
++ continue;
++ // The position is only carried in the QHoverEvent for the benefit of anything
++ // that reads it in hoverLeaveEvent(); HoverChange::Clear un-hovers regardless of
++ // whether the position is inside the item, which matters because on a
++ // touch-only platform lastCursorPosition was never set by any real cursor.
++ deliverHoverEventToItem(item, item->mapFromScene(lastPos), lastPos, lastPos,
++ globalPos, modifiers, timestamp, HoverChange::Clear);
++ }
++ }
++
++ void QQuickDeliveryAgentPrivate::updateFocusItemTransform()
++ {
++ #if QT_CONFIG(im)
++ if (activeFocusItem && QGuiApplication::focusObject() == activeFocusItem) {
++ QQuickItemPrivate *focusPrivate = QQuickItemPrivate::get(activeFocusItem);
++ QGuiApplication::inputMethod()->setInputItemTransform(focusPrivate->itemToWindowTransform());
++ QGuiApplication::inputMethod()->setInputItemRectangle(QRectF(0, 0, focusPrivate->width, focusPrivate->height));
++ activeFocusItem->updateInputMethod(Qt::ImInputItemClipRectangle);
++ }
++ #endif
++ }
++
++ /*!
++ Returns the item that should get active focus when the
++ root focus scope gets active focus.
++ */
++ QQuickItem *QQuickDeliveryAgentPrivate::focusTargetItem() const
++ {
++ if (activeFocusItem)
++ return activeFocusItem;
++
++ Q_ASSERT(rootItem);
++ QQuickItem *targetItem = rootItem;
++
++ while (targetItem->isFocusScope()
++ && targetItem->scopedFocusItem()
++ && targetItem->scopedFocusItem()->isEnabled()) {
++ targetItem = targetItem->scopedFocusItem();
++ }
++
++ return targetItem;
++ }
++
++ /*! \internal
++ If called during event delivery, returns the agent that is delivering the
++ event, without checking whether \a item is reachable from there.
++ Otherwise returns QQuickItemPrivate::deliveryAgent() (the delivery agent for
++ the narrowest subscene containing \a item), or \c null if \a item is \c null.
++ */
++ QQuickDeliveryAgent *QQuickDeliveryAgentPrivate::currentOrItemDeliveryAgent(const QQuickItem *item)
++ {
++ if (currentEventDeliveryAgent)
++ return currentEventDeliveryAgent;
++ if (item)
++ return QQuickItemPrivate::get(const_cast<QQuickItem *>(item))->deliveryAgent();
++ return nullptr;
++ }
++
++ /*! \internal
++ QQuickDeliveryAgent delivers events to a tree of Qt Quick Items, beginning
++ with the given root item, which is usually QQuickWindow::rootItem() but
++ may alternatively be embedded into a Qt Quick 3D scene or something else.
++ */
++ QQuickDeliveryAgent::QQuickDeliveryAgent(QQuickItem *rootItem)
++ : QObject(*new QQuickDeliveryAgentPrivate(rootItem), rootItem)
++ {
++ }
++
++ QQuickDeliveryAgent::~QQuickDeliveryAgent()
++ {
++ }
++
++ QQuickDeliveryAgent::Transform::~Transform()
++ {
++ }
++
++ /*! \internal
++ Get the QQuickRootItem or subscene root item on behalf of which
++ this delivery agent was constructed to handle events.
++ */
++ QQuickItem *QQuickDeliveryAgent::rootItem() const
++ {
++ Q_D(const QQuickDeliveryAgent);
++ return d->rootItem;
++ }
++
++ /*! \internal
++ Returns the object that was set in setSceneTransform(): a functor that
++ transforms from scene coordinates in the parent scene to scene coordinates
++ within this DA's subscene, or \c null if none was set.
++ */
++ QQuickDeliveryAgent::Transform *QQuickDeliveryAgent::sceneTransform() const
++ {
++ Q_D(const QQuickDeliveryAgent);
++ return d->sceneTransform;
++ }
++
++ /*! \internal
++ QQuickDeliveryAgent takes ownership of the given \a transform, which
++ encapsulates the ability to transform parent scene coordinates to rootItem
++ (subscene) coordinates.
++ */
++ void QQuickDeliveryAgent::setSceneTransform(QQuickDeliveryAgent::Transform *transform)
++ {
++ Q_D(QQuickDeliveryAgent);
++ if (d->sceneTransform == transform)
++ return;
++ qCDebug(lcPtr) << this << d->sceneTransform << "->" << transform;
++ if (d->sceneTransform)
++ delete d->sceneTransform;
++ d->sceneTransform = transform;
++ }
++
++ /*!
++ Handle \a ev on behalf of this delivery agent's window or subscene.
++
++ This is the usual main entry point for every incoming event:
++ QQuickWindow::event() and QQuick3DViewport::forwardEventToSubscenes()
++ both call this function.
++ */
++ bool QQuickDeliveryAgent::event(QEvent *ev)
++ {
++ Q_D(QQuickDeliveryAgent);
++ d->currentEventDeliveryAgent = this;
++ auto cleanup = qScopeGuard([d] { d->currentEventDeliveryAgent = nullptr; });
++
++ switch (ev->type()) {
++ case QEvent::MouseButtonPress:
++ case QEvent::MouseButtonRelease:
++ case QEvent::MouseButtonDblClick:
++ case QEvent::MouseMove: {
++ QMouseEvent *me = static_cast<QMouseEvent*>(ev);
++ d->handleMouseEvent(me);
++ break;
++ }
++ case QEvent::HoverEnter:
++ case QEvent::HoverLeave:
++ case QEvent::HoverMove: {
++ QHoverEvent *he = static_cast<QHoverEvent*>(ev);
++ // A QHoverEvent comes from a device that hovers, so any hover established below
++ // belongs to it and not to a fingertip.
++ d->lastMousePositionFromTouch = false;
++ bool accepted = d->deliverHoverEvent(he->scenePosition(),
++ he->points().first().sceneLastPosition(),
++ he->modifiers(), he->timestamp());
++ d->lastMousePosition = he->scenePosition();
++ he->setAccepted(accepted);
++ #if QT_CONFIG(cursor)
++ QQuickWindowPrivate::get(d->rootItem->window())->updateCursor(d->sceneTransform ?
++ d->sceneTransform->map(he->scenePosition()) : he->scenePosition(), d->rootItem);
++ #endif
++ return accepted;
++ }
++ case QEvent::TouchBegin:
++ case QEvent::TouchUpdate:
++ case QEvent::TouchEnd: {
++ QTouchEvent *touch = static_cast<QTouchEvent*>(ev);
++ d->handleTouchEvent(touch);
++ if (Q_LIKELY(QCoreApplication::testAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents))) {
++ // we consume all touch events ourselves to avoid duplicate
++ // mouse delivery by QtGui mouse synthesis
++ ev->accept();
++ }
++ break;
++ }
++ case QEvent::TouchCancel:
++ // return in order to avoid the QWindow::event below
++ return d->deliverTouchCancelEvent(static_cast<QTouchEvent*>(ev));
++ break;
++ case QEvent::Enter: {
++ if (!d->rootItem)
++ return false;
++ QEnterEvent *enter = static_cast<QEnterEvent*>(ev);
++ const auto scenePos = enter->scenePosition();
++ d->lastMousePositionFromTouch = false;
++ bool accepted = d->deliverHoverEvent(scenePos,
++ enter->points().first().sceneLastPosition(),
++ enter->modifiers(), enter->timestamp());
++ d->lastMousePosition = scenePos;
++ // deliverHoverEvent() constructs QHoverEvents: check that EPD didn't end up with corrupted scenePos
++ Q_ASSERT(enter->scenePosition() == scenePos);
++ enter->setAccepted(accepted);
++ #if QT_CONFIG(cursor)
++ QQuickWindowPrivate::get(d->rootItem->window())->updateCursor(enter->scenePosition(), d->rootItem);
++ #endif
++ return accepted;
++ }
++ case QEvent::Leave:
++ d->clearHover();
++ d->lastMousePosition = QPointF();
++ d->lastMousePositionFromTouch = false;
++ break;
++ #if QT_CONFIG(quick_draganddrop)
++ case QEvent::DragEnter:
++ case QEvent::DragLeave:
++ case QEvent::DragMove:
++ case QEvent::Drop:
++ d->deliverDragEvent(d->dragGrabber, ev);
++ break;
++ #endif
++ case QEvent::FocusAboutToChange:
++ #if QT_CONFIG(im)
++ if (d->activeFocusItem)
++ qGuiApp->inputMethod()->commit();
++ #endif
++ break;
++ #if QT_CONFIG(gestures)
++ case QEvent::NativeGesture:
++ d->deliverSinglePointEventUntilAccepted(static_cast<QPointerEvent *>(ev));
++ break;
++ #endif
++ case QEvent::ShortcutOverride:
++ d->deliverKeyEvent(static_cast<QKeyEvent *>(ev));
++ break;
++ case QEvent::InputMethod:
++ case QEvent::InputMethodQuery:
++ {
++ QQuickItem *target = d->focusTargetItem();
++ if (target)
++ QCoreApplication::sendEvent(target, ev);
++ }
++ break;
++ #if QT_CONFIG(wheelevent)
++ case QEvent::Wheel: {
++ auto event = static_cast<QWheelEvent *>(ev);
++ qCDebug(lcMouse) << event;
++
++ //if the actual wheel event was accepted, accept the compatibility wheel event and return early
++ if (d->lastWheelEventAccepted && event->angleDelta().isNull() && event->phase() == Qt::ScrollUpdate)
++ return true;
++
++ event->ignore();
++ Q_QUICK_INPUT_PROFILE(QQuickProfiler::Mouse, QQuickProfiler::InputMouseWheel,
++ event->angleDelta().x(), event->angleDelta().y());
++ d->deliverSinglePointEventUntilAccepted(event);
++ d->lastWheelEventAccepted = event->isAccepted();
++ break;
++ }
++ #endif
++ #if QT_CONFIG(tabletevent)
++ case QEvent::TabletPress:
++ case QEvent::TabletMove:
++ case QEvent::TabletRelease:
++ {
++ auto *tabletEvent = static_cast<QTabletEvent *>(ev);
++ d->deliverPointerEvent(tabletEvent); // visits HoverHandlers too (unlike the mouse event case)
++ #if QT_CONFIG(cursor)
++ QQuickWindowPrivate::get(d->rootItem->window())->updateCursor(tabletEvent->scenePosition(), d->rootItem);
++ #endif
++ }
++ break;
++ #endif
++ #ifndef QT_NO_CONTEXTMENU
++ case QEvent::ContextMenu:
++ d->deliverContextMenuEvent(static_cast<QContextMenuEvent *>(ev));
++ break;
++ #endif
++ case QEvent::Timer:
++ Q_ASSERT(static_cast<QTimerEvent *>(ev)->timerId() == d->frameSynchronousDelayTimer.timerId());
++ d->frameSynchronousDelayTimer.stop();
++ d->flushFrameSynchronousEvents(d->rootItem->window());
++ break;
++ default:
++ return false;
++ }
++
++ return true;
++ }
++
++ void QQuickDeliveryAgentPrivate::deliverKeyEvent(QKeyEvent *e)
++ {
++ if (activeFocusItem) {
++ const bool keyPress = (e->type() == QEvent::KeyPress);
++ switch (e->type()) {
++ case QEvent::KeyPress:
++ Q_QUICK_INPUT_PROFILE(QQuickProfiler::Key, QQuickProfiler::InputKeyPress, e->key(), e->modifiers());
++ break;
++ case QEvent::KeyRelease:
++ Q_QUICK_INPUT_PROFILE(QQuickProfiler::Key, QQuickProfiler::InputKeyRelease, e->key(), e->modifiers());
++ break;
++ default:
++ break;
++ }
++
++ QQuickItem *item = activeFocusItem;
++
++ // In case of generated event, trigger ShortcutOverride event
++ if (keyPress && e->spontaneous() == false)
++ qt_sendShortcutOverrideEvent(item, e->timestamp(),
++ e->key(), e->modifiers(), e->text(),
++ e->isAutoRepeat(), e->count());
++
++ do {
++ Q_ASSERT(e->type() != QEvent::ShortcutOverride || !e->isAccepted());
++ if (e->type() != QEvent::ShortcutOverride)
++ e->accept();
++ QCoreApplication::sendEvent(item, e);
++ } while (!e->isAccepted() && (item = item->parentItem()));
++ }
++ }
++
++ QQuickDeliveryAgentPrivate::QQuickDeliveryAgentPrivate(QQuickItem *root) :
++ QObjectPrivate(),
++ rootItem(root),
++ // a plain QQuickItem can be a subscene root; a QQuickRootItem always belongs directly to a QQuickWindow
++ isSubsceneAgent(!qmlobject_cast<QQuickRootItem *>(rootItem))
++ {
++ #if QT_CONFIG(quick_draganddrop)
++ dragGrabber = new QQuickDragGrabber;
++ #endif
++ if (isSubsceneAgent)
++ subsceneAgentsExist = true;
++ const auto interval = qEnvironmentVariableIntegerValue("QT_QUICK_FRAME_SYNCHRONOUS_HOVER_INTERVAL");
++ if (interval.has_value()) {
++ qCDebug(lcHoverTrace) << "frame-synchronous hover interval" << interval;
++ frameSynchronousHoverInterval = int(interval.value());
++ }
++ if (frameSynchronousHoverInterval > 0)
++ frameSynchronousHoverTimer.start();
++ }
++
++ QQuickDeliveryAgentPrivate::~QQuickDeliveryAgentPrivate()
++ {
++ #if QT_CONFIG(quick_draganddrop)
++ delete dragGrabber;
++ dragGrabber = nullptr;
++ #endif
++ delete sceneTransform;
++ }
++
++ /*! \internal
++ Make a copy of any type of QPointerEvent, and optionally localize it
++ by setting its first point's local position() if \a transformedLocalPos is given.
++
++ \note some subclasses of QSinglePointEvent, such as QWheelEvent, add extra storage.
++ This function doesn't yet support cloning all of those; it can be extended if needed.
++ */
++ QPointerEvent *QQuickDeliveryAgentPrivate::clonePointerEvent(QPointerEvent *event, std::optional<QPointF> transformedLocalPos)
++ {
++ QPointerEvent *ret = event->clone();
++ QEventPoint &point = ret->point(0);
++ QMutableEventPoint::detach(point);
++ QMutableEventPoint::setTimestamp(point, event->timestamp());
++ if (transformedLocalPos)
++ QMutableEventPoint::setPosition(point, *transformedLocalPos);
++
++ return ret;
++ }
++
++ void QQuickDeliveryAgentPrivate::deliverToPassiveGrabbers(const QList<QPointer <QObject> > &passiveGrabbers,
++ QPointerEvent *pointerEvent)
++ {
++ const QList<QObject *> &eventDeliveryTargets =
++ QQuickPointerHandlerPrivate::deviceDeliveryTargets(pointerEvent->device());
++ QVarLengthArray<std::pair<QQuickItem *, bool>, 4> sendFilteredPointerEventResult;
++ hasFiltered.clear();
++ for (QObject *grabberObject : passiveGrabbers) {
++ // a null pointer in passiveGrabbers is unlikely, unless the grabbing handler was deleted dynamically
++ if (Q_UNLIKELY(!grabberObject))
++ continue;
++ // a passiveGrabber might be an item or a handler
++ if (QQuickPointerHandler *handler = qobject_cast<QQuickPointerHandler *>(grabberObject)) {
++ if (handler && !eventDeliveryTargets.contains(handler)) {
++ bool alreadyFiltered = false;
++ QQuickItem *par = handler->parentItem();
++
++ // see if we already have sent a filter event to the parent
++ auto it = std::find_if(sendFilteredPointerEventResult.begin(), sendFilteredPointerEventResult.end(),
++ [par](const std::pair<QQuickItem *, bool> &pair) { return pair.first == par; });
++ if (it != sendFilteredPointerEventResult.end()) {
++ // Yes, the event was sent to that parent for filtering: do not call it again, but use
++ // the result of the previous call to determine whether we should call the handler.
++ alreadyFiltered = it->second;
++ } else if (par) {
++ alreadyFiltered = sendFilteredPointerEvent(pointerEvent, par);
++ sendFilteredPointerEventResult << std::make_pair(par, alreadyFiltered);
++ }
++ if (!alreadyFiltered) {
++ if (par)
++ localizePointerEvent(pointerEvent, par);
++ handler->handlePointerEvent(pointerEvent);
++ }
++ }
++ } else if (QQuickItem *grabberItem = static_cast<QQuickItem *>(grabberObject)) {
++ // don't steal the grab if input should remain with the exclusive grabber only
++ if (QQuickItem *excGrabber = static_cast<QQuickItem *>(pointerEvent->exclusiveGrabber(pointerEvent->point(0)))) {
++ if ((isMouseEvent(pointerEvent) && excGrabber->keepMouseGrab())
++ || (isTouchEvent(pointerEvent) && excGrabber->keepTouchGrab())) {
++ return;
++ }
++ }
++ localizePointerEvent(pointerEvent, grabberItem);
++ QCoreApplication::sendEvent(grabberItem, pointerEvent);
++ pointerEvent->accept();
++ }
++ }
++ }
++
++ bool QQuickDeliveryAgentPrivate::sendHoverEvent(QEvent::Type type, QQuickItem *item,
++ const QPointF &localPos, const QPointF &scenePos, const QPointF &lastScenePos,
++ const QPointF &globalPos, Qt::KeyboardModifiers modifiers, ulong timestamp)
++ {
++ QHoverEvent hoverEvent(type, scenePos, globalPos, lastScenePos, modifiers);
++ hoverEvent.setTimestamp(timestamp);
++ hoverEvent.setAccepted(true);
++ QEventPoint &point = hoverEvent.point(0);
++ QMutableEventPoint::setPosition(point, localPos);
++ if (Q_LIKELY(item->window()))
++ QMutableEventPoint::setGlobalLastPosition(point, item->window()->mapToGlobal(lastScenePos));
++
++ hasFiltered.clear();
++ if (sendFilteredMouseEvent(&hoverEvent, item, item->parentItem()))
++ return true;
++
++ QCoreApplication::sendEvent(item, &hoverEvent);
++
++ return hoverEvent.isAccepted();
++ }
++
++ /*! \internal
++ Delivers a hover event at \a scenePos to the whole scene or subscene
++ that this DeliveryAgent is responsible for. Returns \c true if
++ delivery is "done".
++ */
++ // TODO later: specify the device in case of multi-mouse scenario, or mouse and tablet both in use
++ bool QQuickDeliveryAgentPrivate::deliverHoverEvent(
++ const QPointF &scenePos, const QPointF &lastScenePos,
++ Qt::KeyboardModifiers modifiers, ulong timestamp)
++ {
++ // The first time this function is called, hoverItems is empty.
++ // We then call deliverHoverEventRecursive from the rootItem, and
++ // populate the list with all the children and grandchildren that
++ // we find that should receive hover events (in addition to sending
++ // hover events to them and their HoverHandlers). We also set the
++ // hoverId for each item to the currentHoverId.
++ // The next time this function is called, we bump currentHoverId,
++ // and call deliverHoverEventRecursive once more.
++ // When that call returns, the list will contain the items that
++ // were hovered the first time, as well as the items that were hovered
++ // this time. But only the items that were hovered this time
++ // will have their hoverId equal to currentHoverId; the ones we didn't
++ // visit will still have an old hoverId. We can therefore go through the
++ // list at the end of this function and look for items with an old hoverId,
++ // remove them from the list, and update their state accordingly.
++
++ const bool subtreeHoverEnabled = QQuickItemPrivate::get(rootItem)->subtreeHoverEnabled;
++ const bool itemsWasHovered = !hoverItems.isEmpty();
++
++ if (!subtreeHoverEnabled && !itemsWasHovered)
++ return false;
++
++ currentHoverId++;
++
++ if (subtreeHoverEnabled) {
++ hoveredLeafItemFound = false;
++ QQuickPointerHandlerPrivate::deviceDeliveryTargets(QPointingDevice::primaryPointingDevice()).clear();
++ deliverHoverEventRecursive(rootItem, scenePos, scenePos, lastScenePos,
++ rootItem->mapToGlobal(scenePos), modifiers, timestamp);
++ }
++
++ // Prune the list for items that are no longer hovered
++ for (auto it = hoverItems.begin(); it != hoverItems.end();) {
++ const auto &[item, hoverId, fromFinger] = *it;
++ if (hoverId == currentHoverId) {
++ // Still being hovered
++ it++;
++ } else {
++ // No longer hovered. If hoverId is 0, it means that we have sent a HoverLeave
++ // event to the item already, and it can just be removed from the list. Note that
++ // the item can have been deleted as well.
++ if (item && hoverId != 0)
++ deliverHoverEventToItem(item, item->mapFromScene(scenePos), scenePos, lastScenePos,
++ QGuiApplicationPrivate::lastCursorPosition, modifiers, timestamp, HoverChange::Clear);
++ it = hoverItems.erase(it);
++ }
++ }
++
++ const bool itemsAreHovered = !hoverItems.isEmpty();
++ return itemsWasHovered || itemsAreHovered;
++ }
++
++ /*! \internal
++ Delivers a hover event at \a scenePos to \a item and all its children.
++ The children get it first. As soon as any item allows the event to remain
++ accepted, recursion stops. Returns \c true in that case, or \c false if the
++ event is rejected.
++
++ Each item that has hover enabled (from setAcceptHoverEvents()) has the
++ QQuickItemPrivate::hoverEnabled flag set. This only controls whether we
++ should send hover events to the item itself. (HoverHandlers no longer set
++ this flag.) When an item has hoverEnabled set, all its ancestors have the
++ QQuickItemPrivate::subtreeHoverEnabled set. This function will
++ follow the subtrees that have subtreeHoverEnabled by recursing into each
++ child with that flag set. And for each child (in addition to the item
++ itself) that also has hoverEnabled set, we call deliverHoverEventToItem()
++ to actually deliver the event to it. The item can then choose to accept or
++ reject the event. This is only for control over whether we stop propagation
++ or not: an item can reject the event, but at the same time be hovered (and
++ therefore in hoverItems). By accepting the event, the item will effectivly
++ end up as the only one hovered. Any other HoverHandler that may be a child
++ of an item that is stacked underneath, will not. Note that since siblings
++ can overlap, there can be more than one leaf item under the mouse.
++
++ Note that HoverHandler doesn't set the hoverEnabled flag on the parent item.
++ But still, adding a HoverHandler to an item will set its subtreeHoverEnabled flag.
++ So all the propagation logic described above will otherwise be the same.
++ But the hoverEnabled flag can be used to resolve if subtreeHoverEnabled is on
++ because the application explicitly requested it (setAcceptHoverEvents()), or
++ indirectly, because the item has HoverHandlers.
++
++ For legacy reasons (Qt 6.1), as soon as we find a leaf item that has hover
++ enabled, and therefore receives the event, we stop recursing into the remaining
++ siblings (even if the event was ignored). This means that we only allow hover
++ events to propagate up the direct parent-child hierarchy, and not to siblings.
++ However, if the first candidate HoverHandler is disabled, delivery continues
++ to the next one, which may be a sibling (QTBUG-106548).
++ */
++ bool QQuickDeliveryAgentPrivate::deliverHoverEventRecursive(QQuickItem *item,
++ const QPointF &localPos, const QPointF &scenePos, const QPointF &lastScenePos, const QPointF &globalPos,
++ Qt::KeyboardModifiers modifiers, ulong timestamp)
++ {
++ const QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++ const QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
++ const bool hadChildrenChanged = itemPrivate->dirtyAttributes & QQuickItemPrivate::ChildrenChanged;
++
++ for (int ii = children.size() - 1; ii >= 0; --ii) {
++ // If the children had not changed before we started the loop, but now they have changed,
++ // stop looping to avoid potentially dereferencing a dangling pointer.
++ // This is unusual, and hover delivery occurs frequently anyway, so just wait until next time.
++ if (!hadChildrenChanged && Q_UNLIKELY(itemPrivate->dirtyAttributes & QQuickItemPrivate::ChildrenChanged))
++ break;
++ QQuickItem *child = children.at(ii);
++ const QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(child);
++
++ if (!child->isVisible() || childPrivate->culled)
++ continue;
++ if (!childPrivate->subtreeHoverEnabled)
++ continue;
++
++ QTransform childToParent;
++ childPrivate->itemToParentTransform(&childToParent);
++ const QPointF childLocalPos = childToParent.inverted().map(localPos);
++
++ // If the child clips, or all children are inside, and scenePos is
++ // outside its rectangular bounds, we can skip this item and all its
++ // children, to save time.
++ if (childPrivate->effectivelyClipsEventHandlingChildren() &&
++ !childPrivate->eventHandlingBounds().contains(childLocalPos)) {
++ #ifdef QT_BUILD_INTERNAL
++ ++QQuickItemPrivate::effectiveClippingSkips_counter;
++ #endif
++ continue;
++ }
++
++ // Recurse into the child
++ const bool accepted = deliverHoverEventRecursive(child, childLocalPos, scenePos, lastScenePos, globalPos, modifiers, timestamp);
++ if (accepted) {
++ // Stop propagation / recursion
++ return true;
++ }
++ if (hoveredLeafItemFound) {
++ // Don't propagate to siblings, only to ancestors
++ break;
++ }
++ }
++
++ // All decendants have been visited.
++ // Now deliver the event to the item
++ return deliverHoverEventToItem(item, localPos, scenePos, lastScenePos, globalPos, modifiers, timestamp, HoverChange::Set);
++ }
++
++ /*! \internal
++ Delivers a hover event at \a scenePos to \a item and its HoverHandlers if any.
++ Returns \c true if the event remains accepted, \c false if rejected.
++
++ If \a clearHover is \c true, it will be sent as a QEvent::HoverLeave event,
++ and the item and its handlers are expected to transition into their non-hovered
++ states even if the position still indicates that the mouse is inside.
++ */
++ bool QQuickDeliveryAgentPrivate::deliverHoverEventToItem(
++ QQuickItem *item, const QPointF &localPos, const QPointF &scenePos, const QPointF &lastScenePos,
++ const QPointF &globalPos, Qt::KeyboardModifiers modifiers, ulong timestamp, HoverChange hoverChange)
++ {
++ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++ const bool isHovering = item->contains(localPos);
++ auto hoverItemIterator = findHoverStateByItem(hoverItems, item);
++ const bool wasHovering = hoverItemIterator != hoverItems.end() && hoverItemIterator->hoverId != 0;
++
++ qCDebug(lcHoverTrace) << "item:" << item << "scene pos:" << scenePos << "localPos:" << localPos
++ << "wasHovering:" << wasHovering << "isHovering:" << isHovering;
++
++ bool accepted = false;
++
++ // Start by sending out enter/move/leave events to the item.
++ // Note that hoverEnabled only controls if we should send out hover events to the
++ // item itself. HoverHandlers are not included, and are dealt with separately below.
++ if (itemPrivate->hoverEnabled && isHovering && hoverChange == HoverChange::Set) {
++ // Add the item to the list of hovered items (if it doesn't exist there
++ // from before), and update hoverId to mark that it's (still) hovered.
++ // Also set hoveredLeafItemFound, so that only propagate in a straight
++ // line towards the root from now on.
++ hoveredLeafItemFound = true;
++ if (hoverItemIterator != hoverItems.end())
++ markHovered(*hoverItemIterator, currentHoverId, lastMousePositionFromTouch);
++ else
++ hoverItems.append({item, currentHoverId, lastMousePositionFromTouch});
++
++ if (wasHovering)
++ accepted = sendHoverEvent(QEvent::HoverMove, item, localPos, scenePos, lastScenePos, globalPos, modifiers, timestamp);
++ else
++ accepted = sendHoverEvent(QEvent::HoverEnter, item, localPos, scenePos, lastScenePos, globalPos, modifiers, timestamp);
++ } else if (wasHovering) {
++ // A leave should never stop propagation
++ hoverItemIterator->hoverId = 0;
++ sendHoverEvent(QEvent::HoverLeave, item, localPos, scenePos, lastScenePos, globalPos, modifiers, timestamp);
++ }
++
++ if (!itemPrivate->hasPointerHandlers())
++ return accepted;
++
++ // Next, send out hover events to the hover handlers.
++ // If the item didn't accept the hover event, 'accepted' is now false.
++ // Otherwise it's true, and then it should stay the way regardless of
++ // whether or not the hoverhandlers themselves are hovered.
++ // Note that since a HoverHandler can have a margin, a HoverHandler
++ // can be hovered even if the item itself is not.
++
++ if (hoverChange == HoverChange::Clear) {
++ // Note: a leave should never stop propagation
++ QHoverEvent hoverEvent(QEvent::HoverLeave, scenePos, globalPos, lastScenePos, modifiers);
++ hoverEvent.setTimestamp(timestamp);
++
++ for (QQuickPointerHandler *h : itemPrivate->extra->pointerHandlers) {
++ if (QQuickHoverHandler *hh = qmlobject_cast<QQuickHoverHandler *>(h)) {
++ if (!hh->isHovered())
++ continue;
++ hoverEvent.setAccepted(true);
++ QCoreApplication::sendEvent(hh, &hoverEvent);
++ }
++ }
++ } else {
++ QMouseEvent hoverEvent(QEvent::MouseMove, localPos, scenePos, globalPos, Qt::NoButton, Qt::NoButton, modifiers);
++ hoverEvent.setTimestamp(timestamp);
++
++ for (QQuickPointerHandler *h : itemPrivate->extra->pointerHandlers) {
++ if (QQuickHoverHandler *hh = qmlobject_cast<QQuickHoverHandler *>(h)) {
++ if (!hh->enabled())
++ continue;
++ hoverEvent.setAccepted(true);
++ hh->handlePointerEvent(&hoverEvent);
++ if (hh->isHovered()) {
++ // Mark the whole item as updated, even if only the handler is
++ // actually in a hovered state (because of HoverHandler.margins)
++ hoveredLeafItemFound = true;
++ hoverItemIterator = findHoverStateByItem(hoverItems, item);
++ if (hoverItemIterator != hoverItems.end())
++ markHovered(*hoverItemIterator, currentHoverId, lastMousePositionFromTouch);
++ else
++ hoverItems.append({item, currentHoverId, lastMousePositionFromTouch});
++ if (hh->isBlocking()) {
++ qCDebug(lcHoverTrace) << "skipping rest of hover delivery due to blocking" << hh;
++ accepted = true;
++ break;
++ }
++ }
++ }
++ }
++ }
++
++ return accepted;
++ }
++
++ // Simple delivery of non-mouse, non-touch Pointer Events: visit the items and handlers
++ // in the usual reverse-paint-order until propagation is stopped
++ bool QQuickDeliveryAgentPrivate::deliverSinglePointEventUntilAccepted(QPointerEvent *event)
++ {
++ Q_ASSERT(event->points().size() == 1);
++ QQuickPointerHandlerPrivate::deviceDeliveryTargets(event->pointingDevice()).clear();
++ QEventPoint &point = event->point(0);
++ QList<QQuickItem *> targetItems = pointerTargets(rootItem, event, point, false, false);
++ point.setAccepted(false);
++
++ // Let passive grabbers see the event. This must be done before we deliver the
++ // event to the target and to handlers that might stop event propagation.
++ // Passive grabbers cannot stop event delivery.
++ for (const auto &passiveGrabber : event->passiveGrabbers(point)) {
++ if (auto *grabberItem = qobject_cast<QQuickItem *>(passiveGrabber)) {
++ if (targetItems.contains(grabberItem))
++ continue;
++ localizePointerEvent(event, grabberItem);
++ QCoreApplication::sendEvent(grabberItem, event);
++ }
++ }
++ // Maintain the invariant that items receive input events in accepted state.
++ // A passive grabber might have explicitly ignored the event.
++ event->accept();
++
++ for (QQuickItem *item : targetItems) {
++ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++ localizePointerEvent(event, item);
++ // Let Pointer Handlers have the first shot
++ itemPrivate->handlePointerEvent(event);
++ if (point.isAccepted())
++ return true;
++ event->accept();
++ QCoreApplication::sendEvent(item, event);
++ if (event->isAccepted()) {
++ qCDebug(lcWheelTarget) << event << "->" << item;
++ return true;
++ }
++ }
++
++ return false; // it wasn't handled
++ }
++
++ bool QQuickDeliveryAgentPrivate::deliverTouchCancelEvent(QTouchEvent *event)
++ {
++ qCDebug(lcTouch) << event;
++
++ // An incoming TouchCancel event will typically not contain any points,
++ // but sendTouchCancelEvent() adds the points that have grabbers to the event.
++ // Deliver it to all items and handlers that have active touches.
++ const_cast<QPointingDevicePrivate *>(QPointingDevicePrivate::get(event->pointingDevice()))->
++ sendTouchCancelEvent(event);
++
++ cancelTouchMouseSynthesis();
++
++ // A cancelled sequence ends just as definitely as a released one,
++ // so hover that the fingers established has to go too.
++ if (event->pointerType() == QPointingDevice::PointerType::Finger)
++ clearTouchHover(event->timestamp());
++ // Whatever the pointer type, a cancelled sequence must not leave frame-synchronous
++ // hover delivery running at the position where contact was lost.
++ lastMousePosition = {};
++ lastMousePositionFromTouch = false;
++
++ return true;
++ }
++
++ void QQuickDeliveryAgentPrivate::deliverDelayedTouchEvent()
++ {
++ // Deliver and delete delayedTouch.
++ // Set delayedTouch to nullptr before delivery to avoid redelivery in case of
++ // event loop recursions (e.g if it the touch starts a dnd session).
++ std::unique_ptr<QTouchEvent> e(std::move(delayedTouch));
++ qCDebug(lcTouchCmprs) << "delivering" << e.get();
++ compressedTouchCount = 0;
++ deliverPointerEvent(e.get());
++ }
++
++ /*! \internal
++ The handler for the QEvent::WindowDeactivate event, and also when
++ Qt::ApplicationState tells us the application is no longer active.
++ It clears all exclusive grabs of items and handlers whose window is this one,
++ for all known pointing devices.
++
++ The QEvent is not passed into this function because in the first case it's
++ just a plain QEvent with no extra data, and because the application state
++ change is delivered via a signal rather than an event.
++ */
++ void QQuickDeliveryAgentPrivate::handleWindowDeactivate(QQuickWindow *win)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ qCDebug(lcFocus) << "deactivated" << win->title();
++ const auto inputDevices = QInputDevice::devices();
++ for (auto device : inputDevices) {
++ if (auto pointingDevice = qobject_cast<const QPointingDevice *>(device)) {
++ auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice));
++ for (auto epd : devPriv->activePoints.values()) {
++ if (!epd.exclusiveGrabber.isNull()) {
++ bool relevant = false;
++ if (QQuickItem *item = qmlobject_cast<QQuickItem *>(epd.exclusiveGrabber.data()))
++ relevant = (item->window() == win);
++ else if (QQuickPointerHandler *handler = qmlobject_cast<QQuickPointerHandler *>(epd.exclusiveGrabber.data())) {
++ if (handler->parentItem())
++ relevant = (handler->parentItem()->window() == win && epd.exclusiveGrabberContext.data() == q);
++ else
++ // a handler with no Item parent probably has a 3D Model parent.
++ // TODO actually check the window somehow
++ relevant = true;
++ }
++ if (relevant)
++ devPriv->setExclusiveGrabber(nullptr, epd.eventPoint, nullptr);
++ }
++ // For now, we don't clearPassiveGrabbers(), just in case passive grabs
++ // can be useful to keep monitoring the mouse even after window deactivation.
++ }
++ }
++ }
++ }
++
++ void QQuickDeliveryAgentPrivate::handleWindowHidden(QQuickWindow *win)
++ {
++ qCDebug(lcFocus) << "hidden" << win->title();
++ clearHover();
++ lastMousePosition = QPointF();
++ lastMousePositionFromTouch = false;
++ }
++
++ bool QQuickDeliveryAgentPrivate::allUpdatedPointsAccepted(const QPointerEvent *ev)
++ {
++ for (auto &point : ev->points()) {
++ if (point.state() != QEventPoint::State::Pressed && !point.isAccepted())
++ return false;
++ }
++ return true;
++ }
++
++ /*! \internal
++ Localize \a ev for delivery to \a dest.
++
++ Unlike QMutableTouchEvent::localized(), this modifies the QEventPoint
++ instances in \a ev, which is more efficient than making a copy.
++ */
++ void QQuickDeliveryAgentPrivate::localizePointerEvent(QPointerEvent *ev, const QQuickItem *dest)
++ {
++ for (int i = 0; i < ev->pointCount(); ++i) {
++ auto &point = ev->point(i);
++ QMutableEventPoint::setPosition(point, dest->mapFromScene(point.scenePosition()));
++ qCDebug(lcPtrLoc) << ev->type() << "@" << point.scenePosition() << "to"
++ << dest << "@" << dest->mapToScene(QPointF()) << "->" << point;
++ }
++ }
++
++ QList<QObject *> QQuickDeliveryAgentPrivate::exclusiveGrabbers(QPointerEvent *ev)
++ {
++ QList<QObject *> result;
++ for (const QEventPoint &point : ev->points()) {
++ if (QObject *grabber = ev->exclusiveGrabber(point)) {
++ if (!result.contains(grabber))
++ result << grabber;
++ }
++ }
++ return result;
++ }
++
++ bool QQuickDeliveryAgentPrivate::anyPointGrabbed(const QPointerEvent *ev)
++ {
++ for (const QEventPoint &point : ev->points()) {
++ if (ev->exclusiveGrabber(point) || !ev->passiveGrabbers(point).isEmpty())
++ return true;
++ }
++ return false;
++ }
++
++ bool QQuickDeliveryAgentPrivate::allPointsGrabbed(const QPointerEvent *ev)
++ {
++ for (const auto &point : ev->points()) {
++ if (!ev->exclusiveGrabber(point) && ev->passiveGrabbers(point).isEmpty())
++ return false;
++ }
++ return true;
++ }
++
++ bool QQuickDeliveryAgentPrivate::isMouseEvent(const QPointerEvent *ev)
++ {
++ switch (ev->type()) {
++ case QEvent::MouseButtonPress:
++ case QEvent::MouseButtonRelease:
++ case QEvent::MouseButtonDblClick:
++ case QEvent::MouseMove:
++ return true;
++ default:
++ return false;
++ }
++ }
++
++ bool QQuickDeliveryAgentPrivate::isMouseOrWheelEvent(const QPointerEvent *ev)
++ {
++ return isMouseEvent(ev) || ev->type() == QEvent::Wheel;
++ }
++
++ bool QQuickDeliveryAgentPrivate::isHoverEvent(const QPointerEvent *ev)
++ {
++ switch (ev->type()) {
++ case QEvent::HoverEnter:
++ case QEvent::HoverMove:
++ case QEvent::HoverLeave:
++ return true;
++ default:
++ return false;
++ }
++ }
++
++ bool QQuickDeliveryAgentPrivate::isTouchEvent(const QPointerEvent *ev)
++ {
++ switch (ev->type()) {
++ case QEvent::TouchBegin:
++ case QEvent::TouchUpdate:
++ case QEvent::TouchEnd:
++ case QEvent::TouchCancel:
++ return true;
++ default:
++ return false;
++ }
++ }
++
++ bool QQuickDeliveryAgentPrivate::isTabletEvent(const QPointerEvent *ev)
++ {
++ #if QT_CONFIG(tabletevent)
++ switch (ev->type()) {
++ case QEvent::TabletPress:
++ case QEvent::TabletMove:
++ case QEvent::TabletRelease:
++ case QEvent::TabletEnterProximity:
++ case QEvent::TabletLeaveProximity:
++ return true;
++ default:
++ break;
++ }
++ #else
++ Q_UNUSED(ev);
++ #endif // tabletevent
++ return false;
++ }
++
++ bool QQuickDeliveryAgentPrivate::isEventFromMouseOrTouchpad(const QPointerEvent *ev)
++ {
++ const auto devType = ev->device()->type();
++ return devType == QInputDevice::DeviceType::Mouse ||
++ devType == QInputDevice::DeviceType::TouchPad;
++ }
++
++ bool QQuickDeliveryAgentPrivate::isSynthMouse(const QPointerEvent *ev)
++ {
++ return (!isEventFromMouseOrTouchpad(ev) && isMouseEvent(ev));
++ }
++
++ /*!
++ Returns \c true if \a dev is a type of device that only sends
++ QSinglePointEvents.
++ */
++ bool QQuickDeliveryAgentPrivate::isSinglePointDevice(const QInputDevice *dev)
++ {
++ switch (dev->type()) {
++ case QInputDevice::DeviceType::Mouse:
++ case QInputDevice::DeviceType::TouchPad:
++ case QInputDevice::DeviceType::Puck:
++ case QInputDevice::DeviceType::Stylus:
++ case QInputDevice::DeviceType::Airbrush:
++ return true;
++ case QInputDevice::DeviceType::TouchScreen:
++ case QInputDevice::DeviceType::Keyboard:
++ case QInputDevice::DeviceType::Unknown:
++ case QInputDevice::DeviceType::AllDevices:
++ return false;
++ }
++ return false;
++ }
++
++ /*!
++ Returns \c true if \a dev is a touch/track pad that will emulate mouse events.
++ */
++ bool QQuickDeliveryAgentPrivate::isTouchPadWithMouseEmulation(const QInputDevice *device)
++ {
++ return device->type() == QInputDevice::DeviceType::TouchPad
++ && device->capabilities().testFlag(QInputDevice::Capability::MouseEmulation);
++ }
++
++ QQuickPointingDeviceExtra *QQuickDeliveryAgentPrivate::deviceExtra(const QInputDevice *device)
++ {
++ QInputDevicePrivate *devPriv = QInputDevicePrivate::get(const_cast<QInputDevice *>(device));
++ if (devPriv->qqExtra)
++ return static_cast<QQuickPointingDeviceExtra *>(devPriv->qqExtra);
++ auto extra = new QQuickPointingDeviceExtra;
++ devPriv->qqExtra = extra;
++ QObject::connect(device, &QObject::destroyed, device, [devPriv]() {
++ delete static_cast<QQuickPointingDeviceExtra *>(devPriv->qqExtra);
++ devPriv->qqExtra = nullptr;
++ });
++ return extra;
++ }
++
++ /*!
++ \internal
++ This function is called from handleTouchEvent() in case a series of touch
++ events containing only \c Updated and \c Stationary points arrives within a
++ short period of time. (Some touchscreens are more "jittery" than others.)
++
++ It would be a waste of CPU time to deliver events and have items in the
++ scene getting modified more often than once per frame; so here we try to
++ coalesce the series of updates into a single event containing all updates
++ that occur within one frame period, and deliverDelayedTouchEvent() is
++ called from flushFrameSynchronousEvents() to send that single event. This
++ is the reason why touch compression lives here so far, instead of in a
++ lower layer: the render loop updates the scene in sync with the screen's
++ vsync, and flushFrameSynchronousEvents() is called from there (for example
++ from QSGThreadedRenderLoop::polishAndSync(), and equivalent places in other
++ render loops). It would be preferable to move this code down to a lower
++ level eventually, though, because it's not fundamentally a Qt Quick concern.
++
++ This optimization can be turned off by setting the environment variable
++ \c QML_NO_TOUCH_COMPRESSION.
++
++ Returns \c true if "done", \c false if the caller needs to finish the
++ \a event delivery.
++ */
++ bool QQuickDeliveryAgentPrivate::compressTouchEvent(QTouchEvent *event)
++ {
++ // If this is a subscene agent, don't store any events, because
++ // flushFrameSynchronousEvents() is only called on the window's DA.
++ if (isSubsceneAgent)
++ return false;
++
++ QEventPoint::States states = event->touchPointStates();
++ if (states.testFlag(QEventPoint::State::Pressed) || states.testFlag(QEventPoint::State::Released)) {
++ qCDebug(lcTouchCmprs) << "no compression" << event;
++ // we can only compress an event that doesn't include any pressed or released points
++ return false;
++ }
++
++ if (!delayedTouch) {
++ delayedTouch.reset(new QMutableTouchEvent(event->type(), event->pointingDevice(), event->modifiers(), event->points()));
++ delayedTouch->setTimestamp(event->timestamp());
++ for (qsizetype i = 0; i < delayedTouch->pointCount(); ++i) {
++ auto &tp = delayedTouch->point(i);
++ QMutableEventPoint::detach(tp);
++ }
++ ++compressedTouchCount;
++ qCDebug(lcTouchCmprs) << "delayed" << compressedTouchCount << delayedTouch.get();
++ if (QQuickWindow *window = rootItem->window())
++ window->maybeUpdate();
++ return true;
++ }
++
++ // check if this looks like the last touch event
++ if (delayedTouch->type() == event->type() &&
++ delayedTouch->device() == event->device() &&
++ delayedTouch->modifiers() == event->modifiers() &&
++ delayedTouch->pointCount() == event->pointCount())
++ {
++ // possible match.. is it really the same?
++ bool mismatch = false;
++
++ auto tpts = event->points();
++ for (qsizetype i = 0; i < event->pointCount(); ++i) {
++ const auto &tp = tpts.at(i);
++ const auto &tpDelayed = delayedTouch->point(i);
++ if (tp.id() != tpDelayed.id()) {
++ mismatch = true;
++ break;
++ }
++
++ if (tpDelayed.state() == QEventPoint::State::Updated && tp.state() == QEventPoint::State::Stationary)
++ QMutableEventPoint::setState(tpts[i], QEventPoint::State::Updated);
++ }
++
++ // matching touch event? then give delayedTouch a merged set of touchpoints
++ if (!mismatch) {
++ // have to create a new event because QMutableTouchEvent::setTouchPoints() is missing
++ // TODO optimize, or move event compression elsewhere
++ delayedTouch.reset(new QMutableTouchEvent(event->type(), event->pointingDevice(), event->modifiers(), tpts));
++ delayedTouch->setTimestamp(event->timestamp());
++ for (qsizetype i = 0; i < delayedTouch->pointCount(); ++i) {
++ auto &tp = delayedTouch->point(i);
++ QMutableEventPoint::detach(tp);
++ }
++ ++compressedTouchCount;
++ qCDebug(lcTouchCmprs) << "coalesced" << compressedTouchCount << delayedTouch.get();
++ if (QQuickWindow *window = rootItem->window())
++ window->maybeUpdate();
++ return true;
++ }
++ }
++
++ // merging wasn't possible, so deliver the delayed event first, and then delay this one
++ deliverDelayedTouchEvent();
++ delayedTouch.reset(new QMutableTouchEvent(event->type(), event->pointingDevice(),
++ event->modifiers(), event->points()));
++ delayedTouch->setTimestamp(event->timestamp());
++ return true;
++ }
++
++ /*!
++ \internal
++ Returns \c true if \a event ends a finger touch sequence: that is,
++ of one or more touchpoints, every point has been released,
++ and we are sure that they came from fingers, not synthesized.
++
++ Finger touch has no hover state of its own (until we support hover-detecting touchscreens).
++ Stylus-proximity hover must not be cleared here.
++
++ This mirrors the rule in QQuickHoverHandler::handleEventPoint().
++ */
++ static bool isEndOfFingerTouchSequence(const QTouchEvent *event)
++ {
++ if (!event->isEndEvent())
++ return false;
++ if (!event->pointCount())
++ return false;
++ // in case of AA_SynthesizeTouchForUnhandledMouseEvents, for example (unusual)
++ if (Q_UNLIKELY(event->pointerType() != QPointingDevice::PointerType::Finger))
++ return false;
++ // Ask the device to be sure, since some don't report every still-down contact in every event:
++ // e.g. the Stationary points that QWindowsPointerHandler::translateTouchEvent()
++ // synthesizes for digitizers that send one message per finger.
++ const auto *devPriv = QPointingDevicePrivate::get(event->pointingDevice());
++ for (const auto &activePoint : devPriv->activePoints) {
++ if (activePoint.second.eventPoint.state() != QEventPoint::State::Released)
++ return false;
++ }
++ return true;
++ }
++
++ // entry point for touch event delivery:
++ // - translate the event to window coordinates
++ // - compress the event instead of delivering it if applicable
++ // - call deliverTouchPoints to actually dispatch the points
++ void QQuickDeliveryAgentPrivate::handleTouchEvent(QTouchEvent *event)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ translateTouchEvent(event);
++ // TODO remove: touch and mouse should be independent until we come to touch->mouse synth
++ if (event->pointCount() && !isTouchPadWithMouseEmulation(event->device())) {
++ auto &point = event->point(0);
++ if (point.state() == QEventPoint::State::Released) {
++ // Clearing lastMousePosition here switches off the frame-synchronous hover delivery
++ // in flushFrameSynchronousEvents(), which would otherwise notice that
++ // hoverItems holds entries with stale hoverIds. Hence clearTouchHover() below.
++ lastMousePosition = QPointF();
++ lastMousePositionFromTouch = false;
++ } else {
++ lastMousePosition = point.position();
++ lastMousePositionFromTouch =
++ event->pointerType() == QPointingDevice::PointerType::Finger;
++ }
++ }
++
++ // After delivery of the last touchpoint release, hover that the fingertips established
++ // has to go with it. It's not the platform plugin's job to synthesize a LeaveEvent
++ // on touch release. And not every device has a mouse to change hover state, either.
++ const bool fingerHoverEnded = isEndOfFingerTouchSequence(event);
++
++ qCDebug(lcTouch) << q << event;
++
++ static bool qquickwindow_no_touch_compression = qEnvironmentVariableIsSet("QML_NO_TOUCH_COMPRESSION");
++
++ if (qquickwindow_no_touch_compression || pointerEventRecursionGuard) {
++ deliverPointerEvent(event);
++ } else if (!compressTouchEvent(event)) {
++ if (delayedTouch) {
++ deliverDelayedTouchEvent();
++ qCDebug(lcTouchCmprs) << "resuming delivery" << event;
++ }
++ deliverPointerEvent(event);
++ }
++
++ // compressTouchEvent() never compresses an event that carries a released point,
++ // so an ended sequence is always delivered by one of the branches above first.
++ if (fingerHoverEnded)
++ clearTouchHover(event->timestamp());
++ }
++
++ /*!
++ Handle \a event on behalf of this delivery agent's window or subscene.
++ */
++ void QQuickDeliveryAgentPrivate::handleMouseEvent(QMouseEvent *event)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ // We generally don't want OS-synthesized mouse events, because Qt Quick does its own touch->mouse synthesis.
++ // But if the platform converts long-press to right-click, it's ok to react to that,
++ // unless the user has opted out by setting QT_QUICK_ALLOW_SYNTHETIC_RIGHT_CLICK=0.
++ if (event->source() == Qt::MouseEventSynthesizedBySystem &&
++ !(event->button() == Qt::RightButton && allowSyntheticRightClick())) {
++ event->accept();
++ return;
++ }
++ qCDebug(lcMouse) << q << event;
++
++ switch (event->type()) {
++ case QEvent::MouseButtonPress:
++ Q_QUICK_INPUT_PROFILE(QQuickProfiler::Mouse, QQuickProfiler::InputMousePress, event->button(),
++ event->buttons());
++ deliverPointerEvent(event);
++ break;
++ case QEvent::MouseButtonRelease:
++ Q_QUICK_INPUT_PROFILE(QQuickProfiler::Mouse, QQuickProfiler::InputMouseRelease, event->button(),
++ event->buttons());
++ deliverPointerEvent(event);
++ #if QT_CONFIG(cursor)
++ QQuickWindowPrivate::get(rootItem->window())->updateCursor(event->scenePosition());
++ #endif
++ break;
++ case QEvent::MouseButtonDblClick:
++ Q_QUICK_INPUT_PROFILE(QQuickProfiler::Mouse, QQuickProfiler::InputMouseDoubleClick,
++ event->button(), event->buttons());
++ deliverPointerEvent(event);
++ break;
++ case QEvent::MouseMove: {
++ Q_QUICK_INPUT_PROFILE(QQuickProfiler::Mouse, QQuickProfiler::InputMouseMove,
++ event->position().x(), event->position().y());
++
++ const QPointF last = lastMousePosition.isNull() ? event->scenePosition() : lastMousePosition;
++ lastMousePosition = event->scenePosition();
++ // A real mouse move takes the position back from any fingertip that had claimed
++ // it, so hover established from here on belongs to the cursor.
++ lastMousePositionFromTouch = false;
++ qCDebug(lcHoverTrace) << q << "mouse pos" << last << "->" << lastMousePosition;
++ if (!event->points().size() || !event->exclusiveGrabber(event->point(0))) {
++ bool accepted = deliverHoverEvent(event->scenePosition(), last, event->modifiers(), event->timestamp());
++ event->setAccepted(accepted);
++ }
++ deliverPointerEvent(event);
++ #if QT_CONFIG(cursor)
++ // The pointer event could result in a cursor change (reaction), so update it afterwards.
++ QQuickWindowPrivate::get(rootItem->window())->updateCursor(event->scenePosition());
++ #endif
++ break;
++ }
++ default:
++ Q_ASSERT(false);
++ break;
++ }
++ }
++
++ /*! \internal
++ Flush events before a frame is rendered in \a win.
++
++ This is here because of compressTouchEvent(): we need to ensure that
++ coalesced touch events are actually delivered in time to cause the desired
++ reactions of items and their handlers. And then since it was introduced
++ because of that, we started using this function for once-per-frame hover
++ events too, to take care of changing hover state when an item animates
++ under the mouse cursor at a time that the mouse cursor is not moving.
++
++ This is done before QQuickItem::updatePolish() is called on all the items
++ that requested polishing.
++ */
++ void QQuickDeliveryAgentPrivate::flushFrameSynchronousEvents(QQuickWindow *win)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ QQuickDeliveryAgent *deliveringAgent = QQuickDeliveryAgentPrivate::currentEventDeliveryAgent;
++ QQuickDeliveryAgentPrivate::currentEventDeliveryAgent = q;
++
++ if (delayedTouch) {
++ deliverDelayedTouchEvent();
++
++ // Touch events which constantly start animations (such as a behavior tracking
++ // the mouse point) need animations to start.
++ QQmlAnimationTimer *ut = QQmlAnimationTimer::instance();
++ if (ut && ut->hasStartAnimationPending())
++ ut->startAnimations();
++ }
++
++ // In webOS we already have the alternative to the issue that this
++ // wanted to address and thus skipping this part won't break anything.
++ #if !defined(Q_OS_WEBOS)
++ // Periodically, if any items are dirty, send a synthetic hover,
++ // in case items have changed position, visibility, etc.
++ // For instance, during animation (including the case of a ListView
++ // whose delegates contain MouseAreas), a MouseArea needs to know
++ // whether it has moved into a position where it is now under the cursor.
++ // We do this once per frame if frameSynchronousHoverInterval == 0, or
++ // skip some frames until elapsed time > frameSynchronousHoverInterval,
++ // or skip it altogether if frameSynchronousHoverInterval < 0.
++ // TODO do this for each known mouse device or come up with a different strategy
++ if (frameSynchronousHoverInterval >= 0) {
++ const bool timerActive = frameSynchronousHoverInterval > 0;
++ const bool timerMature = frameSynchronousHoverTimer.elapsed() >= frameSynchronousHoverInterval;
++ if (timerActive && !timerMature) {
++ qCDebug(lcHoverTrace) << q << "frame-sync hover delivery delayed: elapsed"
++ << frameSynchronousHoverTimer.elapsed() << "<" << frameSynchronousHoverInterval;
++ if (!frameSynchronousDelayTimer.isActive())
++ frameSynchronousDelayTimer.start(frameSynchronousHoverInterval - frameSynchronousHoverTimer.elapsed(), q);
++ } else if (!win->mouseGrabberItem() && !lastMousePosition.isNull() &&
++ (timerMature || QQuickWindowPrivate::get(win)->dirtyItemList)) {
++ frameSynchronousDelayTimer.stop();
++ qCDebug(lcHoverTrace) << q << "delivering frame-sync hover to root @" << lastMousePosition
++ << "after elapsed time" << frameSynchronousHoverTimer.elapsed();
++ if (deliverHoverEvent(lastMousePosition, lastMousePosition, QGuiApplication::keyboardModifiers(), 0)) {
++ #if QT_CONFIG(cursor)
++ QQuickWindowPrivate::get(rootItem->window())->updateCursor(
++ sceneTransform ? sceneTransform->map(lastMousePosition) : lastMousePosition, rootItem);
++ #endif
++ }
++
++ if (timerActive)
++ frameSynchronousHoverTimer.restart();
++ ++frameSynchronousHover_counter;
++ qCDebug(lcHoverTrace) << q << "frame-sync hover delivery done: round" << frameSynchronousHover_counter;
++ }
++ }
++ #else
++ Q_UNUSED(win);
++ #endif
++ if (Q_UNLIKELY(QQuickDeliveryAgentPrivate::currentEventDeliveryAgent &&
++ QQuickDeliveryAgentPrivate::currentEventDeliveryAgent != q))
++ qCWarning(lcPtr, "detected interleaved frame-sync and actual events");
++ QQuickDeliveryAgentPrivate::currentEventDeliveryAgent = deliveringAgent;
++ }
++
++ /*! \internal
++ React to the fact that \a grabber underwent a grab \a transition
++ while an item or handler was handling \a point from \a event.
++ I.e. handle the QPointingDevice::grabChanged() signal.
++
++ This notifies the relevant items and/or pointer handlers, and
++ does cleanup when grabs are lost or relinquished.
++ */
++ void QQuickDeliveryAgentPrivate::onGrabChanged(QObject *grabber, QPointingDevice::GrabTransition transition,
++ const QPointerEvent *event, const QEventPoint &point)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ const bool grabGained = (transition == QPointingDevice::GrabTransition::GrabExclusive ||
++ transition == QPointingDevice::GrabTransition::GrabPassive);
++
++ // note: event can be null, if the signal was emitted from QPointingDevicePrivate::removeGrabber(grabber)
++ if (auto *handler = qmlobject_cast<QQuickPointerHandler *>(grabber)) {
++ if (handler->parentItem()) {
++ auto itemPriv = QQuickItemPrivate::get(handler->parentItem());
++ if (itemPriv->deliveryAgent() == q) {
++ if (grabGained) {
++ handler->onGrabChanged(handler, transition, const_cast<QPointerEvent *>(event),
++ const_cast<QEventPoint &>(point));
++ } else {
++ // When a grab is relinquished/lost, the event point is localized to the new grabber
++ // or not localized at all (QTBUG-146781, QTBUG-147003). Thus, we must re-localize it
++ // for the old grabber's onGrabChanged() handler.
++ QEventPoint lostPoint(point);
++ QMutableEventPoint::setPosition(lostPoint, handler->parentItem()->mapFromScene(point.scenePosition()));
++ handler->onGrabChanged(handler, transition, const_cast<QPointerEvent *>(event),
++ lostPoint);
++ qCDebug(lcPtrLoc) << event->type() << "@" << point.scenePosition()
++ << "to old handler" << grabber << "->" << lostPoint;
++ }
++ }
++ if (grabGained) {
++ // An item that is NOT a subscene root needs to track whether it got a grab via a subscene delivery agent,
++ // whereas the subscene root item already knows it has its own DA.
++ if (isSubsceneAgent && (!itemPriv->extra.isAllocated() || !itemPriv->extra->subsceneDeliveryAgent))
++ itemPriv->maybeHasSubsceneDeliveryAgent = true;
++ }
++ } else if (!isSubsceneAgent) {
++ handler->onGrabChanged(handler, transition, const_cast<QPointerEvent *>(event),
++ const_cast<QEventPoint &>(point));
++ }
++ } else if (auto *grabberItem = qmlobject_cast<QQuickItem *>(grabber)) {
++ switch (transition) {
++ case QPointingDevice::CancelGrabExclusive:
++ case QPointingDevice::UngrabExclusive:
++ if (isDeliveringTouchAsMouse() || isSinglePointDevice(point.device())) {
++ // If an EventPoint from the mouse or the synth-mouse or from any
++ // mouse-like device is ungrabbed, call QQuickItem::mouseUngrabEvent().
++ QMutableSinglePointEvent e(QEvent::UngrabMouse, point.device(), point);
++ hasFiltered.clear();
++ if (!sendFilteredMouseEvent(&e, grabberItem, grabberItem->parentItem())) {
++ lastUngrabbed = grabberItem;
++ grabberItem->mouseUngrabEvent();
++ }
++ } else {
++ // Multi-point event: call QQuickItem::touchUngrabEvent() only if
++ // all eventpoints are released or cancelled.
++ bool allReleasedOrCancelled = true;
++ if (transition == QPointingDevice::UngrabExclusive && event) {
++ for (const auto &pt : event->points()) {
++ if (pt.state() != QEventPoint::State::Released) {
++ allReleasedOrCancelled = false;
++ break;
++ }
++ }
++ }
++ if (allReleasedOrCancelled)
++ grabberItem->touchUngrabEvent();
++ }
++ break;
++ default:
++ break;
++ }
++ auto *itemPriv = QQuickItemPrivate::get(grabberItem);
++ // An item that is NOT a subscene root needs to track whether it got a grab via a subscene delivery agent,
++ // whereas the subscene root item already knows it has its own DA.
++ if (isSubsceneAgent && grabGained && (!itemPriv->extra.isAllocated() || !itemPriv->extra->subsceneDeliveryAgent))
++ itemPriv->maybeHasSubsceneDeliveryAgent = true;
++ }
++
++ if (currentEventDeliveryAgent == q && event && event->device()) {
++ switch (transition) {
++ case QPointingDevice::GrabPassive: {
++ auto epd = QPointingDevicePrivate::get(const_cast<QPointingDevice*>(event->pointingDevice()))->queryPointById(point.id());
++ Q_ASSERT(epd);
++ QPointingDevicePrivate::setPassiveGrabberContext(epd, grabber, q);
++ qCDebug(lcPtr) << "remembering that" << q << "handles point" << point.id() << "after" << transition;
++ } break;
++ case QPointingDevice::GrabExclusive: {
++ auto epd = QPointingDevicePrivate::get(const_cast<QPointingDevice*>(event->pointingDevice()))->queryPointById(point.id());
++ Q_ASSERT(epd);
++ epd->exclusiveGrabberContext = q;
++ qCDebug(lcPtr) << "remembering that" << q << "handles point" << point.id() << "after" << transition;
++ } break;
++ case QPointingDevice::CancelGrabExclusive:
++ case QPointingDevice::UngrabExclusive:
++ // taken care of in QPointingDevicePrivate::setExclusiveGrabber(,,nullptr), removeExclusiveGrabber()
++ break;
++ case QPointingDevice::UngrabPassive:
++ case QPointingDevice::CancelGrabPassive:
++ // taken care of in QPointingDevicePrivate::removePassiveGrabber(), clearPassiveGrabbers()
++ break;
++ case QPointingDevice::OverrideGrabPassive:
++ // not in use at this time
++ break;
++ }
++ }
++ }
++
++ /*! \internal
++ Called when a QPointingDevice is detected, to ensure that the
++ QPointingDevice::grabChanged() signal is connected to
++ QQuickDeliveryAgentPrivate::onGrabChanged().
++
++ \c knownPointingDevices is maintained only to track signal connections, and
++ should not be used for other purposes. The usual place to get a list of all
++ devices is QInputDevice::devices().
++ */
++ void QQuickDeliveryAgentPrivate::ensureDeviceConnected(const QPointingDevice *dev)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ if (knownPointingDevices.contains(dev))
++ return;
++ knownPointingDevices.append(dev);
++ connect(dev, &QPointingDevice::grabChanged, this, &QQuickDeliveryAgentPrivate::onGrabChanged);
++ QObject::connect(dev, &QObject::destroyed, q, [this, dev] {this->knownPointingDevices.removeAll(dev);});
++ }
++
++ /*! \internal
++ The entry point for delivery of \a event after determining that it \e is a
++ pointer event, and either does not need to be coalesced in
++ compressTouchEvent(), or already has been.
++
++ When it returns, event delivery is done.
++ */
++ void QQuickDeliveryAgentPrivate::deliverPointerEvent(QPointerEvent *event)
++ {
++ Q_Q(QQuickDeliveryAgent);
++ if (isTabletEvent(event))
++ qCDebug(lcTablet) << q << event;
++
++ // If users spin the eventloop as a result of event delivery, we disable
++ // event compression and send events directly. This is because we consider
++ // the usecase a bit evil, but we at least don't want to lose events.
++ ++pointerEventRecursionGuard;
++ eventsInDelivery.push(event);
++
++ // So far this is for use in Qt Quick 3D: if a QEventPoint is grabbed,
++ // updates get delivered here pretty directly, bypassing picking; but we need to
++ // be able to map the 2D viewport coordinate to a 2D coordinate within
++ // d->rootItem, a 2D scene that has been arbitrarily mapped onto a 3D object.
++ QVarLengthArray<QPointF, 16> originalScenePositions;
++ if (sceneTransform) {
++ originalScenePositions.resize(event->pointCount());
++ for (int i = 0; i < event->pointCount(); ++i) {
++ auto &pt = event->point(i);
++ originalScenePositions[i] = pt.scenePosition();
++ QMutableEventPoint::setScenePosition(pt, sceneTransform->map(pt.scenePosition()));
++ qCDebug(lcPtrLoc) << q << event->type() << pt.id() << "transformed scene pos" << pt.scenePosition();
++ }
++ } else if (isSubsceneAgent) {
++ qCDebug(lcPtrLoc) << q << event->type() << "no scene transform set";
++ }
++
++ skipDelivery.clear();
++ QQuickPointerHandlerPrivate::deviceDeliveryTargets(event->pointingDevice()).clear();
++ if (sceneTransform)
++ qCDebug(lcPtr) << q << "delivering with" << sceneTransform << event;
++ else
++ qCDebug(lcPtr) << q << "delivering" << event;
++ for (int i = 0; i < event->pointCount(); ++i)
++ event->point(i).setAccepted(false);
++
++ if (event->isBeginEvent()) {
++ ensureDeviceConnected(event->pointingDevice());
++ if (event->type() == QEvent::MouseButtonPress && rootItem->window()
++ && static_cast<QSinglePointEvent *>(event)->button() == Qt::RightButton) {
++ QQuickWindowPrivate::get(rootItem->window())->rmbContextMenuEventEnabled = true;
++ }
++ if (!deliverPressOrReleaseEvent(event))
++ event->setAccepted(false);
++ }
++
++ auto isHoveringMoveEvent = [](QPointerEvent *event) -> bool {
++ if (event->type() == QEvent::MouseMove) {
++ const auto *spe = static_cast<const QSinglePointEvent *>(event);
++ if (spe->button() == Qt::NoButton && spe->buttons() == Qt::NoButton)
++ return true;
++ }
++ return false;
++ };
++
++ /*
++ If some QEventPoints were not yet handled, deliver to existing grabbers,
++ and then non-grabbing pointer handlers.
++ But don't deliver stray mouse moves in which no buttons are pressed:
++ stray mouse moves risk deactivating handlers that don't expect them;
++ for mouse hover tracking, we rather use deliverHoverEvent().
++ But do deliver TabletMove events, in case there is a HoverHandler that
++ changes its cursorShape depending on stylus type.
++ */
++ if (!allUpdatedPointsAccepted(event) && !isHoveringMoveEvent(event))
++ deliverUpdatedPoints(event);
++ if (event->isEndEvent())
++ deliverPressOrReleaseEvent(event, true);
++
++ // failsafe: never allow touch->mouse synthesis to persist after all touchpoints are released,
++ // or after the touchmouse is released
++ if (isTouchEvent(event) && touchMouseId >= 0) {
++ if (static_cast<QTouchEvent *>(event)->touchPointStates() == QEventPoint::State::Released) {
++ cancelTouchMouseSynthesis();
++ } else {
++ auto touchMousePoint = event->pointById(touchMouseId);
++ if (touchMousePoint && touchMousePoint->state() == QEventPoint::State::Released)
++ cancelTouchMouseSynthesis();
++ }
++ }
++
++ eventsInDelivery.pop();
++ if (sceneTransform) {
++ for (int i = 0; i < event->pointCount(); ++i)
++ QMutableEventPoint::setScenePosition(event->point(i), originalScenePositions.at(i));
++ }
++ --pointerEventRecursionGuard;
++ lastUngrabbed = nullptr;
++ }
++
++ /*! \internal
++ Returns a list of all items that are spatially relevant to receive \a event
++ occurring at \a scenePos, starting with \a item and recursively
++ checking all the children.
++
++ \a localPos is the same as \a scenePos mapped to \a item (given as an
++ optimization, to avoid mapping it again). If \a pointId is given (if
++ pointId >= 0), the event is a QPointerEvent: so the expectation is that
++ this function must map the position to each child, during recursion.
++ The reason we need to do it is that \a predicate may expect the QEventPoint
++ to be localized already. eventTargets() is able to do the mapping using
++ only QQuickItemPrivate::itemToParentTransform(), which is cheaper than
++ calling windowToItemTransform() at each step.
++
++ \a event could alternatively be a QContextMenuEvent: then there is no
++ QEventPoint available, so pointId is given as -1 to indicate that
++ this function does \e not have responsibility to remap it to each child.
++
++ \list
++ \li If QQuickItemPrivate::effectivelyClipsEventHandlingChildren() is
++ \c true \e and \a scenePos is outside of QQuickItem::clipRect(), and
++ \a item is \e not the root item, its children are also omitted.
++ (We stop the recursion, because any clipped-off portions of children
++ under \a scenePos are invisible; or, because we know that all children
++ are fully inside the parent.)
++ \li Ignore any item in a subscene that "belongs to" a different
++ DeliveryAgent. (In current practice, this only happens in 2D scenes in
++ Qt Quick 3D.)
++ \li Ignore any item for which the given \a predicate returns \c false;
++ include any item for which the predicate returns \c true.
++ \endlist
++
++ \note If \c {QQuickView::resizeMode() == SizeViewToRootObject} (the default),
++ the root item might not fill the window: so we don't check
++ effectivelyClipsEventHandlingChildren() on it. It could even be 0 x 0 if
++ width and height aren't declared.)
++ */
++ QList<QQuickItem *> QQuickDeliveryAgentPrivate::eventTargets(QQuickItem *item, const QEvent *event, int pointId,
++ QPointF localPos, QPointF scenePos, qxp::function_ref<std::optional<bool> (QQuickItem *, const QEvent *)> predicate) const
++ {
++ QList<QQuickItem *> targets;
++ eventTargetsAppend(item, event, pointId, localPos, scenePos, predicate, targets);
++ return targets;
++ }
++
++ /*!
++ \internal
++ Recursively collects event-target items into \a targets in reverse
++ paint order (highest stacking order first), interleaving \a item
++ among its children according to z-order.
++ */
++ // FIXME: should this be iterative instead of recursive?
++ void QQuickDeliveryAgentPrivate::eventTargetsAppend(QQuickItem *item, const QEvent *event, int pointId,
++ QPointF localPos, QPointF scenePos, qxp::function_ref<std::optional<bool> (QQuickItem *, const QEvent *)> predicate,
++ QList<QQuickItem *> &targets) const
++ {
++ auto itemPrivate = QQuickItemPrivate::get(item);
++
++ // If the item clips, or all children are inside, and it's not the root item,
++ // and scenePos is outside its rectangular bounds, we can skip this item
++ // and all its children, to save time. (This check is performance-sensitive!)
++ if (item != rootItem && !itemPrivate->eventHandlingBounds().contains(localPos) &&
++ itemPrivate->effectivelyClipsEventHandlingChildren()) {
++ qCDebug(lcPtrLoc) << "skipping because" << localPos << "is outside rectangular bounds of" << item;
++ return;
++ }
++
++ // If we didn't return early: check containment more thoroughly, then build
++ // a list of children in paint order, modified to respect z property adjustments.
++ const QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
++ if (pointId >= 0) {
++ // If pointId is set, it's meant to indicate that this is a QPointerEvent, not e.g. a QContextMenuEvent.
++ // Localize the relevant QEventPoint before calling the predicate: if it calls anyPointerHandlerWants(),
++ // position() must be correct.
++ Q_ASSERT(event->isPointerEvent());
++ QPointerEvent *pev = const_cast<QPointerEvent *>(static_cast<const QPointerEvent *>(event));
++ QEventPoint *point = pev->pointById(pointId);
++ Q_ASSERT(point);
++ QMutableEventPoint::setPosition(*point, localPos);
++ }
++ const std::optional<bool> override = predicate(item, event);
++ const bool relevant = override.has_value() ? override.value()
++ : item == rootItem || item->contains(localPos);
++
++ // Iterate in reverse paint order (highest stacking order first).
++ // Emit self before the first child with z < 0 (i.e. between children
++ // painted above and below self).
++ bool selfEmitted = !relevant;
++ for (int ii = children.size() - 1; ii >= 0; --ii) {
++ QQuickItem *child = children.at(ii);
++ if (!selfEmitted && child->z() < 0) {
++ targets.append(item);
++ selfEmitted = true;
++ }
++
++ auto childPrivate = QQuickItemPrivate::get(child);
++ if (!child->isVisible() || !child->isEnabled() || childPrivate->culled ||
++ (childPrivate->extra.isAllocated() && childPrivate->extra->subsceneDeliveryAgent))
++ continue;
++
++ QTransform childToParent;
++ childPrivate->itemToParentTransform(&childToParent);
++ const QPointF childLocalPos = childToParent.inverted().map(localPos);
++ eventTargetsAppend(child, event, pointId, childLocalPos, scenePos, predicate, targets);
++ }
++
++ // If all children have z >= 0, self goes last in reverse order
++ if (!selfEmitted)
++ targets.append(item);
++ }
++
++ /*! \internal
++ Returns a list of all items that are spatially relevant to receive \a event
++ occurring at \a point, starting with \a item and recursively checking all
++ the children.
++ \list
++ \li If an item has pointer handlers, call
++ QQuickPointerHandler::wantsEventPoint()
++ on every handler to decide whether the item is eligible.
++ \li Otherwise, if \a checkMouseButtons is \c true, it means we are
++ finding targets for a mouse event, so no item for which
++ acceptedMouseButtons() is NoButton will be added.
++ \li Otherwise, if \a checkAcceptsTouch is \c true, it means we are
++ finding targets for a touch event, so either acceptTouchEvents() must
++ return true \e or it must accept a synthesized mouse event. I.e. if
++ acceptTouchEvents() returns false, it gets added only if
++ acceptedMouseButtons() is true.
++ \li If QQuickItem::clip() is \c true \e and the \a point is outside of
++ QQuickItem::clipRect(), its children are also omitted. (We stop the
++ recursion, because any clipped-off portions of children under \a point
++ are invisible.)
++ \li Ignore any item in a subscene that "belongs to" a different
++ DeliveryAgent. (In current practice, this only happens in 2D scenes in
++ Qt Quick 3D.)
++ \endlist
++
++ The list returned from this function is the list of items that will be
++ "visited" when delivering any event for which QPointerEvent::isBeginEvent()
++ is \c true.
++ */
++ QList<QQuickItem *> QQuickDeliveryAgentPrivate::pointerTargets(QQuickItem *item, const QPointerEvent *event, const QEventPoint &point,
++ bool checkMouseButtons, bool checkAcceptsTouch) const
++ {
++ auto predicate = [point, checkMouseButtons, checkAcceptsTouch](QQuickItem *item, const QEvent *ev) -> std::optional<bool> {
++ const QPointerEvent *event = static_cast<const QPointerEvent *>(ev);
++ auto itemPrivate = QQuickItemPrivate::get(item);
++ if (itemPrivate->hasPointerHandlers()) {
++ if (itemPrivate->anyPointerHandlerWants(event, point))
++ return true;
++ } else {
++ if (checkMouseButtons && item->acceptedMouseButtons() == Qt::NoButton)
++ return false;
++ if (checkAcceptsTouch && !(item->acceptTouchEvents() || item->acceptedMouseButtons()))
++ return false;
++ }
++
++ return std::nullopt;
++ };
++
++ return eventTargets(item, event, point.id(), item->mapFromScene(point.scenePosition()), point.scenePosition(), predicate);
++ }
++
++ /*! \internal
++ Returns a joined list consisting of the items in \a list1 and \a list2.
++ \a list1 has priority; common items come last.
++ */
++ QList<QQuickItem *> QQuickDeliveryAgentPrivate::mergePointerTargets(const QList<QQuickItem *> &list1, const QList<QQuickItem *> &list2) const
++ {
++ QList<QQuickItem *> targets = list1;
++ // start at the end of list2
++ // if item not in list, append it
++ // if item found, move to next one, inserting before the last found one
++ int insertPosition = targets.size();
++ for (int i = list2.size() - 1; i >= 0; --i) {
++ int newInsertPosition = targets.lastIndexOf(list2.at(i), insertPosition);
++ if (newInsertPosition >= 0) {
++ Q_ASSERT(newInsertPosition <= insertPosition);
++ insertPosition = newInsertPosition;
++ }
++ // check for duplicates, only insert if the item isn't there already
++ if (insertPosition == targets.size() || list2.at(i) != targets.at(insertPosition))
++ targets.insert(insertPosition, list2.at(i));
++ }
++ return targets;
++ }
++
++ /*! \internal
++ Deliver updated points to existing grabbers.
++ */
++ void QQuickDeliveryAgentPrivate::deliverUpdatedPoints(QPointerEvent *event)
++ {
++ Q_Q(const QQuickDeliveryAgent);
++ bool done = false;
++ const auto grabbers = exclusiveGrabbers(event);
++ hasFiltered.clear();
++ for (auto grabber : grabbers) {
++ // The grabber is guaranteed to be either an item or a handler.
++ QQuickItem *receiver = qmlobject_cast<QQuickItem *>(grabber);
++ if (!receiver) {
++ // The grabber is not an item? It's a handler then. Let it have the event first.
++ QQuickPointerHandler *handler = static_cast<QQuickPointerHandler *>(grabber);
++ receiver = static_cast<QQuickPointerHandler *>(grabber)->parentItem();
++ // Filtering via QQuickItem::childMouseEventFilter() is only possible
++ // if the handler's parent is an Item. It could be a QQ3D object.
++ if (receiver) {
++ hasFiltered.clear();
++ if (sendFilteredPointerEvent(event, receiver))
++ done = true;
++ localizePointerEvent(event, receiver);
++ }
++ handler->handlePointerEvent(event);
++ }
++ if (done)
++ break;
++ // If the grabber is an item or the grabbing handler didn't handle it,
++ // then deliver the event to the item (which may have multiple handlers).
++ hasFiltered.clear();
++ if (receiver)
++ deliverMatchingPointsToItem(receiver, true, event);
++ }
++
++ // Deliver to each eventpoint's passive grabbers (but don't visit any handler more than once)
++ for (auto &point : event->points()) {
++ auto epd = QPointingDevicePrivate::get(event->pointingDevice())->queryPointById(point.id());
++ if (Q_UNLIKELY(!epd)) {
++ qWarning() << "point is not in activePoints" << point;
++ continue;
++ }
++ QList<QPointer<QObject>> relevantPassiveGrabbers;
++ for (int i = 0; i < epd->passiveGrabbersContext.size(); ++i) {
++ if (epd->passiveGrabbersContext.at(i).data() == q)
++ relevantPassiveGrabbers << epd->passiveGrabbers.at(i);
++ }
++ if (!relevantPassiveGrabbers.isEmpty())
++ deliverToPassiveGrabbers(relevantPassiveGrabbers, event);
++
++ // Ensure that HoverHandlers are updated, in case no items got dirty so far and there's no update request
++ if (event->type() == QEvent::TouchUpdate && !isTouchPadWithMouseEmulation(event->device())) {
++ for (const auto &[item, id, fromFinger] : hoverItems) {
++ if (item) {
++ bool res = deliverHoverEventToItem(item, item->mapFromScene(point.scenePosition()), point.scenePosition(), point.sceneLastPosition(),
++ point.globalPosition(), event->modifiers(), event->timestamp(), HoverChange::Set);
++ // if the event was accepted, then the item's ID must be valid
++ Q_ASSERT(([this, item = item.get(), res]{
++ const auto it2 = findHoverStateByItem(std::as_const(hoverItems), item);
++ return !res || it2->hoverId != 0;
++ }()));
++ }
++ }
++ }
++ }
++
++ if (done)
++ return;
++
++ // If some points weren't grabbed, deliver only to non-grabber PointerHandlers in reverse paint order
++ if (!allPointsGrabbed(event)) {
++ QList<QQuickItem *> targetItems;
++ for (auto &point : event->points()) {
++ // Presses were delivered earlier; not the responsibility of deliverUpdatedTouchPoints.
++ // Don't find handlers for points that are already grabbed by an Item (such as Flickable).
++ if (point.state() == QEventPoint::Pressed || qmlobject_cast<QQuickItem *>(event->exclusiveGrabber(point)))
++ continue;
++ QList<QQuickItem *> targetItemsForPoint = pointerTargets(rootItem, event, point, false, false);
++ if (targetItems.size()) {
++ targetItems = mergePointerTargets(targetItems, targetItemsForPoint);
++ } else {
++ targetItems = targetItemsForPoint;
++ }
++ }
++ for (QQuickItem *item : targetItems) {
++ if (grabbers.contains(item))
++ continue;
++ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++ localizePointerEvent(event, item);
++ itemPrivate->handlePointerEvent(event, true); // avoid re-delivering to grabbers
++ if (allPointsGrabbed(event))
++ break;
++ }
++ }
++ }
++
++ /*! \internal
++ Deliver a pointer \a event containing newly pressed or released QEventPoints.
++ If \a handlersOnly is \c true, skip the items and just deliver to Pointer Handlers
++ (via QQuickItemPrivate::handlePointerEvent()).
++
++ For the sake of determinism, this function first builds the list
++ \c targetItems by calling pointerTargets() on the root item. That is, the
++ list of items to "visit" is determined at the beginning, and will not be
++ affected if items reparent, hide, or otherwise try to make themselves
++ eligible or ineligible during delivery. (Avoid bugs due to ugly
++ just-in-time tricks in JS event handlers, filters etc.)
++
++ Whenever a touch gesture is in progress, and another touchpoint is pressed,
++ or an existing touchpoint is released, we "start over" with delivery:
++ that's why this function is called whenever the event \e contains newly
++ pressed or released points. It's not necessary for a handler or an item to
++ greedily grab all touchpoints just in case a valid gesture might start.
++ QQuickMultiPointHandler::wantsPointerEvent() can calmly return \c false if
++ the number of points is less than QQuickMultiPointHandler::minimumPointCount(),
++ because it knows it will be asked again if the number of points increases.
++
++ When \a handlersOnly is \c false, \a event visits the items in \c targetItems
++ via QQuickItem::event(). We have to call sendFilteredPointerEvent()
++ before visiting each item, just in case a Flickable (or some other
++ parent-filter) will decide to intercept the event. But we also have to be
++ very careful never to let the same Flickable filter the same event twice,
++ because when Flickable decides to intercept, it lets the child item have
++ that event, and then grabs the next event. That allows you to drag a
++ Slider, DragHandler or whatever inside a ListView delegate: if you're
++ dragging in the correct direction for the draggable child, it can use
++ QQuickItem::setKeepMouseGrab(), QQuickItem::setKeepTouchGrab() or
++ QQuickPointerHandler::grabPermissions() to prevent Flickable from
++ intercepting during filtering, only if it actually \e has the exclusive
++ grab already when Flickable attempts to take it. Typically, both the
++ Flickable and the child are checking the same drag threshold, so the
++ child must have a chance to grab and \e keep the grab before Flickable
++ gets a chance to steal it, even though Flickable actually sees the
++ event first during filtering.
++ */
++ bool QQuickDeliveryAgentPrivate::deliverPressOrReleaseEvent(QPointerEvent *event, bool handlersOnly)
++ {
++ QList<QQuickItem *> targetItems;
++ const bool isTouch = isTouchEvent(event);
++ if (isTouch && event->isBeginEvent() && isDeliveringTouchAsMouse()) {
++ if (auto point = const_cast<QPointingDevicePrivate *>(QPointingDevicePrivate::get(touchMouseDevice))->queryPointById(touchMouseId)) {
++ // When a second point is pressed, if the first point's existing
++ // grabber was a pointer handler while a filtering parent is filtering
++ // the same first point _as mouse_: we're starting over with delivery,
++ // so we need to allow the second point to now be sent as a synth-mouse
++ // instead of the first one, so that filtering parents (maybe even the
++ // same one) can get a chance to see the second touchpoint as a
++ // synth-mouse and perhaps grab it. Ideally we would always do this
++ // when a new touchpoint is pressed, but this compromise fixes
++ // QTBUG-70998 and avoids breaking tst_FlickableInterop::touchDragSliderAndFlickable
++ if (qobject_cast<QQuickPointerHandler *>(event->exclusiveGrabber(point->eventPoint)))
++ cancelTouchMouseSynthesis();
++ } else {
++ qCWarning(lcTouchTarget) << "during delivery of touch press, synth-mouse ID" << Qt::hex << touchMouseId << "is missing from" << event;
++ }
++ }
++ for (int i = 0; i < event->pointCount(); ++i) {
++ auto &point = event->point(i);
++ // Regardless whether a touchpoint could later result in a synth-mouse event:
++ // if the double-tap time or space constraint has been violated,
++ // reset state to prevent a double-click event.
++ if (isTouch && point.state() == QEventPoint::Pressed)
++ resetIfDoubleTapPrevented(point);
++ QList<QQuickItem *> targetItemsForPoint = pointerTargets(rootItem, event, point, !isTouch, isTouch);
++ if (targetItems.size()) {
++ targetItems = mergePointerTargets(targetItems, targetItemsForPoint);
++ } else {
++ targetItems = targetItemsForPoint;
++ }
++ }
++
++ QList<QPointer<QQuickItem>> safeTargetItems(targetItems.begin(), targetItems.end());
++
++ for (auto &item : safeTargetItems) {
++ if (item.isNull())
++ continue;
++ // failsafe: when items get into a subscene somehow, ensure that QQuickItemPrivate::deliveryAgent() can find it
++ if (isSubsceneAgent)
++ QQuickItemPrivate::get(item)->maybeHasSubsceneDeliveryAgent = true;
++
++ hasFiltered.clear();
++ if (!handlersOnly && sendFilteredPointerEvent(event, item)) {
++ if (event->isAccepted())
++ return true;
++ skipDelivery.append(item);
++ }
++
++ // Do not deliverMatchingPointsTo any item for which the filtering parent already intercepted the event,
++ // nor to any item which already had a chance to filter.
++ if (skipDelivery.contains(item))
++ continue;
++
++ // sendFilteredPointerEvent() changed the QEventPoint::accepted() state,
++ // but per-point acceptance is opt-in during normal delivery to items.
++ for (int i = 0; i < event->pointCount(); ++i)
++ event->point(i).setAccepted(false);
++
++ deliverMatchingPointsToItem(item, false, event, handlersOnly);
++ if (event->allPointsAccepted())
++ handlersOnly = true;
++ }
++
++ // Return this because it's true if all events were accepted, rather than
++ // event->allPointsAccepted(), which can be false even if the event was accepted, because the
++ // event points' accepted states are set to false before delivery.
++ return handlersOnly;
++ }
++
++ /*! \internal
++ Deliver \a pointerEvent to \a item and its handlers, if any.
++ If \a handlersOnly is \c true, skip QQuickItem::event() and just visit its
++ handlers via QQuickItemPrivate::handlePointerEvent().
++
++ This function exists just to de-duplicate the common code between
++ deliverPressOrReleaseEvent() and deliverUpdatedPoints().
++ */
++ void QQuickDeliveryAgentPrivate::deliverMatchingPointsToItem(QQuickItem *item, bool isGrabber, QPointerEvent *pointerEvent, bool handlersOnly)
++ {
++ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++ #if defined(Q_OS_ANDROID) && QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
++ // QTBUG-85379
++ // In QT_VERSION below 6.0.0 touchEnabled for QtQuickItems is set by default to true
++ // It causes delivering touch events to Items which are not interested
++ // In some cases (like using Material Style in Android) it may cause a crash
++ if (itemPrivate->wasDeleted)
++ return;
++ #endif
++ localizePointerEvent(pointerEvent, item);
++ bool isMouse = isMouseEvent(pointerEvent);
++
++ // Let the Item's handlers (if any) have the event first.
++ // However, double click should never be delivered to handlers.
++ if (pointerEvent->type() != QEvent::MouseButtonDblClick)
++ itemPrivate->handlePointerEvent(pointerEvent);
++
++ if (handlersOnly)
++ return;
++
++ // If all points are released and the item is not the grabber, it doesn't get the event.
++ // But if at least one point is still pressed, we might be in a potential gesture-takeover scenario.
++ if (pointerEvent->isEndEvent() && !pointerEvent->isUpdateEvent()
++ && !exclusiveGrabbers(pointerEvent).contains(item))
++ return;
++
++ // If any parent filters the event, we're done.
++ if (sendFilteredPointerEvent(pointerEvent, item))
++ return;
++
++ // TODO: unite this mouse point delivery with the synthetic mouse event below
++ // TODO: remove isGrabber then?
++ if (isMouse) {
++ auto button = static_cast<QSinglePointEvent *>(pointerEvent)->button();
++ if ((isGrabber && button == Qt::NoButton) || item->acceptedMouseButtons().testFlag(button)) {
++ // The only reason to already have a mouse grabber here is
++ // synthetic events - flickable sends one when setPressDelay is used.
++ auto oldMouseGrabber = pointerEvent->exclusiveGrabber(pointerEvent->point(0));
++ pointerEvent->accept();
++ if (isGrabber && sendFilteredPointerEvent(pointerEvent, item))
++ return;
++ localizePointerEvent(pointerEvent, item);
++ QCoreApplication::sendEvent(item, pointerEvent);
++ if (pointerEvent->isAccepted()) {
++ auto &point = pointerEvent->point(0);
++ auto mouseGrabber = pointerEvent->exclusiveGrabber(point);
++ if (mouseGrabber && mouseGrabber != item && mouseGrabber != oldMouseGrabber) {
++ // Normally we don't need item->mouseUngrabEvent() here, because QQuickDeliveryAgentPrivate::onGrabChanged does it.
++ // However, if one item accepted the mouse event, it expects to have the grab and be in "pressed" state,
++ // because accepting implies grabbing. But before it actually gets the grab, another item could steal it.
++ // In that case, onGrabChanged() does NOT notify the item that accepted the event that it's not getting the grab after all.
++ // So after ensuring that it's not redundant, we send a notification here, for that case (QTBUG-55325).
++ if (item != lastUngrabbed) {
++ item->mouseUngrabEvent();
++ lastUngrabbed = item;
++ }
++ } else if (item->isEnabled() && item->isVisible() && point.state() == QEventPoint::State::Pressed) {
++ pointerEvent->setExclusiveGrabber(point, item);
++ }
++ point.setAccepted(true);
++ }
++ return;
++ }
++ }
++
++ if (!isTouchEvent(pointerEvent))
++ return;
++
++ bool eventAccepted = false;
++ QMutableTouchEvent touchEvent;
++ itemPrivate->localizedTouchEvent(static_cast<QTouchEvent *>(pointerEvent), false, &touchEvent);
++ if (touchEvent.type() == QEvent::None)
++ return; // no points inside this item
++
++ if (item->acceptTouchEvents()) {
++ qCDebug(lcTouch) << "considering delivering" << &touchEvent << " to " << item;
++
++ // Deliver the touch event to the given item
++ qCDebug(lcTouch) << "actually delivering" << &touchEvent << " to " << item;
++ QCoreApplication::sendEvent(item, &touchEvent);
++ eventAccepted = touchEvent.isAccepted();
++ } else {
++ // If the touch event wasn't accepted, synthesize a mouse event and see if the item wants it.
++ if (Q_LIKELY(QCoreApplication::testAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents)) &&
++ !eventAccepted && (itemPrivate->acceptedMouseButtons() & Qt::LeftButton))
++ deliverTouchAsMouse(item, &touchEvent);
++ return;
++ }
++
++ Q_ASSERT(item->acceptTouchEvents()); // else we would've returned early above
++ if (eventAccepted) {
++ bool isPressOrRelease = pointerEvent->isBeginEvent() || pointerEvent->isEndEvent();
++ for (int i = 0; i < touchEvent.pointCount(); ++i) {
++ auto &point = touchEvent.point(i);
++ // legacy-style delivery: if the item doesn't reject the event, that means it handled ALL the points
++ point.setAccepted();
++ // but don't let the root of a subscene implicitly steal the grab from some other item (such as one of its children)
++ if (isPressOrRelease && !(itemPrivate->deliveryAgent() && pointerEvent->exclusiveGrabber(point)))
++ pointerEvent->setExclusiveGrabber(point, item);
++ }
++ } else {
++ // But if the event was not accepted then we know this item
++ // will not be interested in further updates for those touchpoint IDs either.
++ for (const auto &point: touchEvent.points()) {
++ if (point.state() == QEventPoint::State::Pressed) {
++ if (pointerEvent->exclusiveGrabber(point) == item) {
++ qCDebug(lcTouchTarget) << "TP" << Qt::hex << point.id() << "disassociated";
++ pointerEvent->setExclusiveGrabber(point, nullptr);
++ }
++ }
++ }
++ }
++ }
++
++ #if QT_CONFIG(quick_draganddrop)
++ void QQuickDeliveryAgentPrivate::deliverDragEvent(QQuickDragGrabber *grabber, QEvent *event)
++ {
++ QObject *formerTarget = grabber->target();
++ grabber->resetTarget();
++ QQuickDragGrabber::iterator grabItem = grabber->begin();
++ if (grabItem != grabber->end()) {
++ Q_ASSERT(event->type() != QEvent::DragEnter);
++ if (event->type() == QEvent::Drop) {
++ QDropEvent *e = static_cast<QDropEvent *>(event);
++ for (e->setAccepted(false); !e->isAccepted() && grabItem != grabber->end(); grabItem = grabber->release(grabItem)) {
++ QPointF p = (**grabItem)->mapFromScene(e->position().toPoint());
++ QDropEvent translatedEvent(
++ p.toPoint(),
++ e->possibleActions(),
++ e->mimeData(),
++ e->buttons(),
++ e->modifiers());
++ QQuickDropEventEx::copyActions(&translatedEvent, *e);
++ QCoreApplication::sendEvent(**grabItem, &translatedEvent);
++ e->setAccepted(translatedEvent.isAccepted());
++ e->setDropAction(translatedEvent.dropAction());
++ grabber->setTarget(**grabItem);
++ }
++ }
++ if (event->type() != QEvent::DragMove) { // Either an accepted drop or a leave.
++ QDragLeaveEvent leaveEvent;
++ for (; grabItem != grabber->end(); grabItem = grabber->release(grabItem))
++ QCoreApplication::sendEvent(**grabItem, &leaveEvent);
++ grabber->ignoreList().clear();
++ return;
++ } else {
++ QDragMoveEvent *moveEvent = static_cast<QDragMoveEvent *>(event);
++
++ // Used to ensure we don't send DragEnterEvents to current drop targets,
++ // and to detect which current drop targets we have left
++ QVarLengthArray<QQuickItem*, 64> currentGrabItems;
++ for (; grabItem != grabber->end(); grabItem = grabber->release(grabItem))
++ currentGrabItems.append(**grabItem);
++
++ // Look for any other potential drop targets that are higher than the current ones
++ QDragEnterEvent enterEvent(
++ moveEvent->position(),
++ moveEvent->possibleActions(),
++ moveEvent->mimeData(),
++ moveEvent->buttons(),
++ moveEvent->modifiers());
++ QQuickDropEventEx::copyActions(&enterEvent, *moveEvent);
++ event->setAccepted(deliverDragEvent(grabber, rootItem, &enterEvent, ¤tGrabItems,
++ formerTarget));
++
++ for (grabItem = grabber->begin(); grabItem != grabber->end(); ++grabItem) {
++ int i = currentGrabItems.indexOf(**grabItem);
++ if (i >= 0) {
++ currentGrabItems.remove(i);
++ // Still grabbed: send move event
++ QDragMoveEvent translatedEvent(
++ (**grabItem)->mapFromScene(moveEvent->position()),
++ moveEvent->possibleActions(),
++ moveEvent->mimeData(),
++ moveEvent->buttons(),
++ moveEvent->modifiers());
++ QQuickDropEventEx::copyActions(&translatedEvent, *moveEvent);
++ QCoreApplication::sendEvent(**grabItem, &translatedEvent);
++ event->setAccepted(translatedEvent.isAccepted());
++ QQuickDropEventEx::copyActions(moveEvent, translatedEvent);
++ }
++ }
++
++ // Anything left in currentGrabItems is no longer a drop target and should be sent a DragLeaveEvent
++ QDragLeaveEvent leaveEvent;
++ for (QQuickItem *i : currentGrabItems)
++ QCoreApplication::sendEvent(i, &leaveEvent);
++
++ return;
++ }
++ }
++ if (event->type() == QEvent::DragEnter || event->type() == QEvent::DragMove) {
++ QDragMoveEvent *e = static_cast<QDragMoveEvent *>(event);
++ QDragEnterEvent enterEvent(
++ e->position(),
++ e->possibleActions(),
++ e->mimeData(),
++ e->buttons(),
++ e->modifiers());
++ QQuickDropEventEx::copyActions(&enterEvent, *e);
++ event->setAccepted(deliverDragEvent(grabber, rootItem, &enterEvent));
++ } else {
++ grabber->ignoreList().clear();
++ }
++ }
++
++ bool QQuickDeliveryAgentPrivate::deliverDragEvent(
++ QQuickDragGrabber *grabber, QQuickItem *item, QDragMoveEvent *event,
++ QVarLengthArray<QQuickItem *, 64> *currentGrabItems, QObject *formerTarget)
++ {
++ QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
++ if (!item->isVisible() || !item->isEnabled() || QQuickItemPrivate::get(item)->culled)
++ return false;
++ QPointF p = item->mapFromScene(event->position().toPoint());
++ bool itemContained = item->contains(p);
++
++ const int itemIndex = grabber->ignoreList().indexOf(item);
++ if (!itemContained) {
++ if (itemIndex >= 0)
++ grabber->ignoreList().remove(itemIndex);
++
++ if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape)
++ return false;
++ }
++
++ QDragEnterEvent enterEvent(
++ event->position(),
++ event->possibleActions(),
++ event->mimeData(),
++ event->buttons(),
++ event->modifiers());
++ QQuickDropEventEx::copyActions(&enterEvent, *event);
++ QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
++
++ // Check children in front of this item first
++ for (int ii = children.size() - 1; ii >= 0; --ii) {
++ if (children.at(ii)->z() < 0)
++ continue;
++ if (deliverDragEvent(grabber, children.at(ii), &enterEvent, currentGrabItems, formerTarget))
++ return true;
++ }
++
++ if (itemContained) {
++ // If this item is currently grabbed, don't send it another DragEnter,
++ // just grab it again if it's still contained.
++ if (currentGrabItems && currentGrabItems->contains(item)) {
++ grabber->grab(item);
++ grabber->setTarget(item);
++ return true;
++ }
++
++ if (event->type() == QEvent::DragMove || itemPrivate->flags & QQuickItem::ItemAcceptsDrops) {
++ if (event->type() == QEvent::DragEnter) {
++ if (formerTarget) {
++ QQuickItem *formerTargetItem = qobject_cast<QQuickItem *>(formerTarget);
++ if (formerTargetItem && currentGrabItems) {
++ QDragLeaveEvent leaveEvent;
++ QCoreApplication::sendEvent(formerTarget, &leaveEvent);
++
++ // Remove the item from the currentGrabItems so a leave event won't be generated
++ // later on
++ currentGrabItems->removeAll(formerTarget);
++ }
++ } else if (itemIndex >= 0) {
++ return false;
++ }
++ }
++
++ QDragMoveEvent translatedEvent(p, event->possibleActions(), event->mimeData(),
++ event->buttons(), event->modifiers(), event->type());
++ QQuickDropEventEx::copyActions(&translatedEvent, *event);
++ translatedEvent.setAccepted(event->isAccepted());
++ QCoreApplication::sendEvent(item, &translatedEvent);
++ event->setAccepted(translatedEvent.isAccepted());
++ event->setDropAction(translatedEvent.dropAction());
++ if (event->type() == QEvent::DragEnter) {
++ if (translatedEvent.isAccepted()) {
++ grabber->grab(item);
++ grabber->setTarget(item);
++ return true;
++ } else if (itemIndex < 0) {
++ grabber->ignoreList().append(item);
++ }
++ } else {
++ return true;
++ }
++ }
++ }
++
++ // Check children behind this item if this item or any higher children have not accepted
++ for (int ii = children.size() - 1; ii >= 0; --ii) {
++ if (children.at(ii)->z() >= 0)
++ continue;
++ if (deliverDragEvent(grabber, children.at(ii), &enterEvent, currentGrabItems, formerTarget))
++ return true;
++ }
++
++ return false;
++ }
++ #endif // quick_draganddrop
++
++ /*! \internal
++ Allow \a filteringParent to filter \a event on behalf of \a receiver, via
++ QQuickItem::childMouseEventFilter(). This happens right \e before we would
++ send \a event to \a receiver.
++
++ Returns \c true only if \a event has been intercepted (by \a filteringParent
++ or some other filtering ancestor) and should \e not be sent to \a receiver.
++ */
++ bool QQuickDeliveryAgentPrivate::sendFilteredPointerEvent(QPointerEvent *event, QQuickItem *receiver, QQuickItem *filteringParent)
++ {
++ return sendFilteredPointerEventImpl(event, receiver, filteringParent ? filteringParent : receiver->parentItem());
++ }
++
++ /*! \internal
++ The recursive implementation of sendFilteredPointerEvent().
++ */
++ bool QQuickDeliveryAgentPrivate::sendFilteredPointerEventImpl(QPointerEvent *event, QQuickItem *receiver, QQuickItem *filteringParent)
++ {
++ if (!allowChildEventFiltering)
++ return false;
++ if (!filteringParent)
++ return false;
++ bool filtered = false;
++ const bool hasHandlers = QQuickItemPrivate::get(receiver)->hasPointerHandlers();
++ if (filteringParent->filtersChildMouseEvents() && !hasFiltered.contains(filteringParent)) {
++ hasFiltered.append(filteringParent);
++ if (isMouseEvent(event)) {
++ if (receiver->acceptedMouseButtons()) {
++ const bool wasAccepted = event->allPointsAccepted();
++ Q_ASSERT(event->pointCount());
++ localizePointerEvent(event, receiver);
++ event->setAccepted(true);
++ auto oldMouseGrabber = event->exclusiveGrabber(event->point(0));
++ if (filteringParent->childMouseEventFilter(receiver, event)) {
++ qCDebug(lcMouse) << "mouse event intercepted by childMouseEventFilter of " << filteringParent;
++ skipDelivery.append(filteringParent);
++ filtered = true;
++ if (event->isAccepted() && event->isBeginEvent()) {
++ auto &point = event->point(0);
++ auto mouseGrabber = event->exclusiveGrabber(point);
++ if (mouseGrabber && mouseGrabber != receiver && mouseGrabber != oldMouseGrabber) {
++ receiver->mouseUngrabEvent();
++ } else {
++ event->setExclusiveGrabber(point, receiver);
++ }
++ }
++ } else {
++ // Restore accepted state if the event was not filtered.
++ event->setAccepted(wasAccepted);
++ }
++ }
++ } else if (isTouchEvent(event)) {
++ const bool acceptsTouchEvents = receiver->acceptTouchEvents() || hasHandlers;
++ auto device = event->device();
++ if (isTouchPadWithMouseEmulation(event->device())) {
++ qCDebug(lcTouchTarget) << "skipping filtering of synth-mouse event from" << device;
++ } else if (acceptsTouchEvents || receiver->acceptedMouseButtons()) {
++ // get a touch event customized for delivery to filteringParent
++ // TODO should not be necessary? because QQuickDeliveryAgentPrivate::deliverMatchingPointsToItem() does it
++ QMutableTouchEvent filteringParentTouchEvent;
++ QQuickItemPrivate::get(receiver)->localizedTouchEvent(static_cast<QTouchEvent *>(event), true, &filteringParentTouchEvent);
++ if (filteringParentTouchEvent.type() != QEvent::None) {
++ qCDebug(lcTouch) << "letting parent" << filteringParent << "filter for" << receiver << &filteringParentTouchEvent;
++ filtered = filteringParent->childMouseEventFilter(receiver, &filteringParentTouchEvent);
++ if (filtered) {
++ qCDebug(lcTouch) << "touch event intercepted by childMouseEventFilter of " << filteringParent;
++ event->setAccepted(filteringParentTouchEvent.isAccepted());
++ skipDelivery.append(filteringParent);
++ if (event->isAccepted()) {
++ for (auto point : filteringParentTouchEvent.points()) {
++ const QQuickItem *exclusiveGrabber = qobject_cast<const QQuickItem *>(event->exclusiveGrabber(point));
++ // Transfer the grab to the filtering parent unless the current exclusive grabber has
++ // keepTouchGrab set AND the filtering parent is not an ancestor of that grabber.
++ // If filteringParent is an ancestor of exclusiveGrabber (e.g. PinchArea wrapping a Flickable),
++ // allow the transfer: presumably the user intended the parent to intercept multi-touch gestures.
++ // But only if the grabber itself accepts touch events — meaning it set keepTouchGrab
++ // on its own behalf (like Flickable). If the grabber doesn't accept touch events
++ // (like a passive QQuickText), keepTouchGrab was set by the filtering parent's
++ // childMouseEventFilter to maintain the filter-based event routing pattern
++ // (e.g. SplitView sets a handle child as grabber to keep receiving filter calls).
++ const bool grabberInsideFilteringParent = exclusiveGrabber &&
++ exclusiveGrabber->acceptTouchEvents() &&
++ filteringParent->isAncestorOf(const_cast<QQuickItem *>(exclusiveGrabber));
++ if (!exclusiveGrabber || !exclusiveGrabber->keepTouchGrab() || grabberInsideFilteringParent)
++ event->setExclusiveGrabber(point, filteringParent);
++ }
++ // QPointerEvent::setAccepted(true) marks all individual QEventPoints as accepted,
++ // which causes localizedTouchEvent() to skip them (line 9577: if (p.isAccepted()) continue).
++ // This would prevent any ancestor filtering parent (e.g. PinchArea wrapping this Flickable)
++ // from seeing the points in the recursive sendFilteredPointerEventImpl() call below.
++ // Reset per-point accepted state so ancestor filters can still see all relevant points.
++ // The overall event->isAccepted() remains true to stop non-filter item delivery.
++ for (int i = 0; i < event->pointCount(); ++i)
++ event->point(i).setAccepted(false);
++ }
++ } else if (Q_LIKELY(QCoreApplication::testAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents)) &&
++ !filteringParent->acceptTouchEvents()) {
++ qCDebug(lcTouch) << "touch event NOT intercepted by childMouseEventFilter of " << filteringParent
++ << "; accepts touch?" << filteringParent->acceptTouchEvents()
++ << "receiver accepts touch?" << acceptsTouchEvents
++ << "so, letting parent filter a synth-mouse event";
++ // filteringParent didn't filter the touch event. Give it a chance to filter a synthetic mouse event.
++ for (auto &tp : filteringParentTouchEvent.points()) {
++ QEvent::Type t;
++ switch (tp.state()) {
++ case QEventPoint::State::Pressed:
++ t = QEvent::MouseButtonPress;
++ break;
++ case QEventPoint::State::Released:
++ t = QEvent::MouseButtonRelease;
++ break;
++ case QEventPoint::State::Stationary:
++ continue;
++ default:
++ t = QEvent::MouseMove;
++ break;
++ }
++
++ bool touchMouseUnset = (touchMouseId == -1);
++ // Only deliver mouse event if it is the touchMouseId or it could become the touchMouseId
++ if (touchMouseUnset || touchMouseId == tp.id()) {
++ // convert filteringParentTouchEvent (which is already transformed wrt local position, velocity, etc.)
++ // into a synthetic mouse event, and let childMouseEventFilter() have another chance with that
++ QMutableSinglePointEvent mouseEvent;
++ touchToMouseEvent(t, tp, &filteringParentTouchEvent, &mouseEvent);
++ // If a filtering item calls QQuickWindow::mouseGrabberItem(), it should
++ // report the touchpoint's grabber. Whenever we send a synthetic mouse event,
++ // touchMouseId and touchMouseDevice must be set, even if it's only temporarily and isn't grabbed.
++ touchMouseId = tp.id();
++ touchMouseDevice = event->pointingDevice();
++ filtered = filteringParent->childMouseEventFilter(receiver, &mouseEvent);
++ if (filtered) {
++ qCDebug(lcTouch) << "touch event intercepted as synth mouse event by childMouseEventFilter of " << filteringParent;
++ event->setAccepted(mouseEvent.isAccepted());
++ skipDelivery.append(filteringParent);
++ if (event->isAccepted() && event->isBeginEvent()) {
++ qCDebug(lcTouchTarget) << "TP (mouse)" << Qt::hex << tp.id() << "->" << filteringParent;
++ filteringParentTouchEvent.setExclusiveGrabber(tp, filteringParent);
++ touchMouseUnset = false; // We want to leave touchMouseId and touchMouseDevice set
++ filteringParent->grabMouse();
++ }
++ }
++ if (touchMouseUnset)
++ // Now that we're done sending a synth mouse event, and it wasn't grabbed,
++ // the touchpoint is no longer acting as a synthetic mouse. Restore previous state.
++ cancelTouchMouseSynthesis();
++ mouseEvent.point(0).setAccepted(false); // because touchToMouseEvent() set it true
++ // Only one touchpoint can be treated as a synthetic mouse, so after childMouseEventFilter
++ // has been called once, we're done with this loop over the touchpoints.
++ break;
++ }
++ }
++ }
++ }
++ }
++ }
++ }
++ return sendFilteredPointerEventImpl(event, receiver, filteringParent->parentItem()) || filtered;
++ }
++
++ /*! \internal
++ Allow \a filteringParent to filter \a event on behalf of \a receiver, via
++ QQuickItem::childMouseEventFilter(). This happens right \e before we would
++ send \a event to \a receiver.
++
++ Returns \c true only if \a event has been intercepted (by \a filteringParent
++ or some other filtering ancestor) and should \e not be sent to \a receiver.
++
++ Unlike sendFilteredPointerEvent(), this version does not synthesize a
++ mouse event from touch (presumably it's already an actual mouse event).
++ */
++ bool QQuickDeliveryAgentPrivate::sendFilteredMouseEvent(QEvent *event, QQuickItem *receiver, QQuickItem *filteringParent)
++ {
++ if (!filteringParent)
++ return false;
++
++ QQuickItemPrivate *filteringParentPrivate = QQuickItemPrivate::get(filteringParent);
++ if (filteringParentPrivate->replayingPressEvent)
++ return false;
++
++ bool filtered = false;
++ if (filteringParentPrivate->filtersChildMouseEvents && !hasFiltered.contains(filteringParent)) {
++ hasFiltered.append(filteringParent);
++ if (filteringParent->childMouseEventFilter(receiver, event)) {
++ filtered = true;
++ skipDelivery.append(filteringParent);
++ }
++ qCDebug(lcMouseTarget) << "for" << receiver << filteringParent << "childMouseEventFilter ->" << filtered;
++ }
++
++ return sendFilteredMouseEvent(event, receiver, filteringParent->parentItem()) || filtered;
++ }
++
++ /*! \internal
++ Returns \c true if the movement delta \a d in pixels along the \a axis
++ exceeds \a startDragThreshold if it is set, or QStyleHints::startDragDistance();
++ \e or, if QEventPoint::velocity() of \a event exceeds QStyleHints::startDragVelocity().
++
++ \sa QQuickPointerHandlerPrivate::dragOverThreshold()
++ */
++ bool QQuickDeliveryAgentPrivate::dragOverThreshold(qreal d, Qt::Axis axis, QMouseEvent *event, int startDragThreshold)
++ {
++ QStyleHints *styleHints = QGuiApplication::styleHints();
++ bool dragVelocityLimitAvailable = event->device()->capabilities().testFlag(QInputDevice::Capability::Velocity)
++ && styleHints->startDragVelocity();
++ bool overThreshold = qAbs(d) > (startDragThreshold >= 0 ? startDragThreshold : styleHints->startDragDistance());
++ if (dragVelocityLimitAvailable) {
++ QVector2D velocityVec = event->point(0).velocity();
++ qreal velocity = axis == Qt::XAxis ? velocityVec.x() : velocityVec.y();
++ overThreshold |= qAbs(velocity) > styleHints->startDragVelocity();
++ }
++ return overThreshold;
++ }
++
++ /*! \internal
++ Returns \c true if the movement delta \a d in pixels along the \a axis
++ exceeds \a startDragThreshold if it is set, or QStyleHints::startDragDistance();
++ \e or, if QEventPoint::velocity() of \a tp exceeds QStyleHints::startDragVelocity().
++
++ \sa QQuickPointerHandlerPrivate::dragOverThreshold()
++ */
++ bool QQuickDeliveryAgentPrivate::dragOverThreshold(qreal d, Qt::Axis axis, const QEventPoint &tp, int startDragThreshold)
++ {
++ QStyleHints *styleHints = qApp->styleHints();
++ bool overThreshold = qAbs(d) > (startDragThreshold >= 0 ? startDragThreshold : styleHints->startDragDistance());
++ const bool dragVelocityLimitAvailable = (styleHints->startDragVelocity() > 0);
++ if (!overThreshold && dragVelocityLimitAvailable) {
++ qreal velocity = axis == Qt::XAxis ? tp.velocity().x() : tp.velocity().y();
++ overThreshold |= qAbs(velocity) > styleHints->startDragVelocity();
++ }
++ return overThreshold;
++ }
++
++ /*! \internal
++ Returns \c true if the movement \a delta in pixels exceeds QStyleHints::startDragDistance().
++
++ \sa QQuickDeliveryAgentPrivate::dragOverThreshold()
++ */
++ bool QQuickDeliveryAgentPrivate::dragOverThreshold(QVector2D delta)
++ {
++ int threshold = qApp->styleHints()->startDragDistance();
++ return qAbs(delta.x()) > threshold || qAbs(delta.y()) > threshold;
++ }
++
++ /*!
++ \internal
++ Returns all items that could potentially want \a event.
++
++ (Similar to \l pointerTargets(), necessary because QContextMenuEvent is not
++ a QPointerEvent.)
++ */
++ QList<QQuickItem *> QQuickDeliveryAgentPrivate::contextMenuTargets(QQuickItem *item, const QContextMenuEvent *event) const
++ {
++ auto predicate = [](QQuickItem *, const QEvent *) -> std::optional<bool> {
++ return std::nullopt;
++ };
++
++ const auto pos = event->pos().isNull() ? activeFocusItem->mapToScene({}).toPoint() : event->pos();
++ if (event->pos().isNull())
++ qCDebug(lcContextMenu) << "for QContextMenuEvent, active focus item is" << activeFocusItem << "@" << pos;
++ return eventTargets(item, event, -1, pos, pos, predicate);
++ }
++
++ /*!
++ \internal
++
++ Based on \l deliverPointerEvent().
++ */
++ void QQuickDeliveryAgentPrivate::deliverContextMenuEvent(QContextMenuEvent *event)
++ {
++ skipDelivery.clear();
++ QList<QQuickItem *> targetItems = contextMenuTargets(rootItem, event);
++ qCDebug(lcContextMenu) << "delivering context menu event" << event << "to" << targetItems.size() << "target item(s)";
++ QList<QPointer<QQuickItem>> safeTargetItems(targetItems.begin(), targetItems.end());
++ for (auto &item : safeTargetItems) {
++ qCDebug(lcContextMenu) << "- attempting to deliver to" << item;
++ if (item.isNull())
++ continue;
++ // failsafe: when items get into a subscene somehow, ensure that QQuickItemPrivate::deliveryAgent() can find it
++ if (isSubsceneAgent)
++ QQuickItemPrivate::get(item)->maybeHasSubsceneDeliveryAgent = true;
++
++ QCoreApplication::sendEvent(item, event);
++ if (event->isAccepted())
++ return;
++ }
++ }
++
++ #ifndef QT_NO_DEBUG_STREAM
++ QDebug operator<<(QDebug debug, const QQuickDeliveryAgent *da)
++ {
++ QDebugStateSaver saver(debug);
++ debug.nospace();
++ if (!da) {
++ debug << "QQuickDeliveryAgent(0)";
++ return debug;
++ }
++
++ debug << "QQuickDeliveryAgent(";
++ if (!da->objectName().isEmpty())
++ debug << da->objectName() << ' ';
++ auto root = da->rootItem();
++ if (Q_LIKELY(root)) {
++ debug << "root=" << root->metaObject()->className();
++ if (!root->objectName().isEmpty())
++ debug << ' ' << root->objectName();
++ } else {
++ debug << "root=0";
++ }
++ debug << ')';
++ return debug;
++ }
++ #endif
++
++ QT_END_NAMESPACE
++
++ #include "moc_qquickdeliveryagent_p.cpp"