1 files changed, 35 insertions, 18 deletions

diff --git a/src/quick/handlers/qquickpointerhandler.cpp b/src/quick/handlers/qquickpointerhandler.cpp
index 597ce17c35..ec3c972af3 100644
--- a/src/quick/handlers/qquickpointerhandler.cpp
+++ b/src/quick/handlers/qquickpointerhandler.cpp
@@ -92,7 +92,7 @@ QQuickPointerHandler::~QQuickPointerHandler()
      \qmlproperty real PointerHandler::margin
 
      The margin beyond the bounds of the \l {PointerHandler::parent}{parent}
-     item within which an event point can activate this handler. For example, on
+     item within which an \l eventPoint can activate this handler. For example, on
      a PinchHandler where the \l {PointerHandler::target}{target} is also the
      \c parent, it's useful to set this to a distance at least half the width
      of a typical user's finger, so that if the \c parent has been scaled down
@@ -125,7 +125,7 @@ void QQuickPointerHandler::setMargin(qreal pointDistanceThreshold)
     \qmlproperty int PointerHandler::dragThreshold
     \since 5.15
 
-    The distance in pixels that the user must drag an event point in order to
+    The distance in pixels that the user must drag an \l eventPoint in order to
     have it treated as a drag gesture.
 
     The default value depends on the platform and screen resolution.
@@ -217,9 +217,11 @@ void QQuickPointerHandler::setCursorShape(Qt::CursorShape shape)
         return;
     d->cursorShape = shape;
     d->cursorSet = true;
-    QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parentItem());
-    itemPriv->hasCursorHandler = true;
-    itemPriv->setHasCursorInChild(true);
+    if (auto *parent = parentItem()) {
+        QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parent);
+        itemPriv->hasCursorHandler = true;
+        itemPriv->setHasCursorInChild(true);
+    }
     emit cursorShapeChanged();
 }
 
@@ -230,9 +232,11 @@ void QQuickPointerHandler::resetCursorShape()
         return;
     d->cursorShape = Qt::ArrowCursor;
     d->cursorSet = false;
-    QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parentItem());
-    itemPriv->hasCursorHandler = false;
-    itemPriv->setHasCursorInChild(itemPriv->hasCursor);
+    if (auto *parent = parentItem()) {
+        QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parent);
+        itemPriv->hasCursorHandler = false;
+        itemPriv->setHasCursorInChild(itemPriv->hasCursor);
+    }
     emit cursorShapeChanged();
 }
 
@@ -248,8 +252,8 @@ bool QQuickPointerHandler::isCursorShapeExplicitlySet() const
     The \a grabber (subject) will be the Input Handler whose state is changing,
     or null if the state change regards an Item.
     The \a transition (verb) tells what happened.
-    The \a point (object) is the point that was grabbed or ungrabbed.
-    EventPoint has the sole responsibility to call this function.
+    The \a point (object) is the \l eventPoint that was grabbed or ungrabbed.
+    QQuickDeliveryAgent calls this function.
     The Input Handler must react in whatever way is appropriate, and must
     emit the relevant signals (for the benefit of QML code).
     A subclass is allowed to override this virtual function, but must always
@@ -432,6 +436,8 @@ bool QQuickPointerHandler::approveGrabTransition(QPointerEvent *event, const QEv
            This handler can take the exclusive grab from another handler of the same class.
     \value PointerHandler.CanTakeOverFromHandlersOfDifferentType
            This handler can take the exclusive grab from any kind of handler.
+    \value PointerHandler.CanTakeOverFromItems
+           This handler can take the exclusive grab from any type of Item.
     \value PointerHandler.CanTakeOverFromAnything
            This handler can take the exclusive grab from any type of Item or Handler.
     \value PointerHandler.ApprovesTakeOverByHandlersOfSameType
@@ -472,6 +478,14 @@ void QQuickPointerHandler::classBegin()
 
 void QQuickPointerHandler::componentComplete()
 {
+    Q_D(const QQuickPointerHandler);
+    if (d->cursorSet) {
+        if (auto *parent = parentItem()) {
+            QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parent);
+            itemPriv->hasCursorHandler = true;
+            itemPriv->setHasCursorInChild(true);
+        }
+    }
 }
 
 QPointerEvent *QQuickPointerHandler::currentEvent()
@@ -646,10 +660,12 @@ bool QQuickPointerHandler::event(QEvent *e)
 
 void QQuickPointerHandler::handlePointerEvent(QPointerEvent *event)
 {
+    Q_D(QQuickPointerHandler);
     bool wants = wantsPointerEvent(event);
     qCDebug(lcPointerHandlerDispatch) << metaObject()->className() << objectName()
                                       << "on" << parent()->metaObject()->className() << parent()->objectName()
                                       << (wants ? "WANTS" : "DECLINES") << event;
+    d->currentEvent = event;
     if (wants) {
         handlePointerEventImpl(event);
     } else {
@@ -665,6 +681,7 @@ void QQuickPointerHandler::handlePointerEvent(QPointerEvent *event)
             }
         }
     }
+    d->currentEvent = nullptr;
     QQuickPointerHandlerPrivate::deviceDeliveryTargets(event->device()).append(this);
 }
 
@@ -690,9 +707,9 @@ bool QQuickPointerHandler::wantsEventPoint(const QPointerEvent *event, const QEv
     \qmlproperty bool QtQuick::PointerHandler::active
 
     This holds true whenever this Input Handler has taken sole responsibility
-    for handing one or more EventPoints, by successfully taking an exclusive
-    grab of those points. This means that it is keeping its properties
-    up-to-date according to the movements of those Event Points and actively
+    for handing one or more \l {eventPoint}{eventPoints}, by successfully taking an
+    exclusive grab of those points. This means that it is keeping its properties
+    up-to-date according to the movements of those eventPoints and actively
     manipulating its \l target (if any).
 */
 void QQuickPointerHandler::setActive(bool active)
@@ -706,10 +723,8 @@ void QQuickPointerHandler::setActive(bool active)
     }
 }
 
-void QQuickPointerHandler::handlePointerEventImpl(QPointerEvent *event)
+void QQuickPointerHandler::handlePointerEventImpl(QPointerEvent *)
 {
-    Q_D(QQuickPointerHandler);
-    d->currentEvent = event;
 }
 
 /*!
@@ -718,7 +733,7 @@ void QQuickPointerHandler::handlePointerEventImpl(QPointerEvent *event)
 
     The \l Item which is the scope of the handler; the Item in which it was declared.
     The handler will handle events on behalf of this Item, which means a
-    pointer event is relevant if at least one of its event points occurs within
+    pointer event is relevant if at least one of its \l {eventPoint}{eventPoints} occurs within
     the Item's interior.  Initially \l [QML] {target} {target()} is the same, but it
     can be reassigned.
 
@@ -729,7 +744,7 @@ void QQuickPointerHandler::handlePointerEventImpl(QPointerEvent *event)
 */
 
 /*!
-    \qmlsignal QtQuick::PointerHandler::grabChanged(GrabTransition transition, EventPoint point)
+    \qmlsignal QtQuick::PointerHandler::grabChanged(PointerDevice::GrabTransition transition, eventPoint point)
 
     This signal is emitted when the grab has changed in some way which is
     relevant to this handler.
@@ -793,3 +808,5 @@ QVector<QObject *> &QQuickPointerHandlerPrivate::deviceDeliveryTargets(const QIn
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qquickpointerhandler_p.cpp"