Add PointerHandler.cursorShape property

Also, QQuickItemPrivate::setHasCursorInChild() was unable to check
the QQuickItemPrivate::hasCursor variable, because the function
argument hasCursor was shadowing that, even though the comment
"nope! sorry, I have a cursor myself" hints that the intention
was to check that.  So this change exposed a problem there, and
we have to fix that too, in order to keep the tst_qquickwindow::cursor()
test passing.

[ChangeLog][Event Handlers] Pointer Handlers now have a cursorShape
property to set the cursor when the handler is active and the mouse is
hovering, and restore to the previous cursor when the mouse leaves.

Fixes: QTBUG-68073
Change-Id: Ib5c66bd59c4691c4210ee5465e1c95e7bdcf5ae1
Reviewed-by: Jan Arve Sæther <jan-arve.saether@qt.io>

14 files changed, 331 insertions, 31 deletions

diff --git a/src/quick/handlers/qquickhoverhandler.cpp b/src/quick/handlers/qquickhoverhandler.cpp
index 79cb288af8..1216eda477 100644
--- a/src/quick/handlers/qquickhoverhandler.cpp
+++ b/src/quick/handlers/qquickhoverhandler.cpp
@@ -64,6 +64,9 @@ Q_LOGGING_CATEGORY(lcHoverHandler, "qt.quick.handler.hover")
     properties can be used to narrow the behavior to detect hovering of
     specific kinds of devices or while holding a modifier key.
 
+    The \l cursorShape property allows changing the cursor whenever
+    \l hovered changes to \c true.
+
     \sa MouseArea, PointHandler
 */
 
@@ -125,4 +128,52 @@ void QQuickHoverHandler::setHovered(bool hovered)
     }
 }
 
+/*!
+    \since 5.15
+    \qmlproperty Qt::CursorShape QtQuick::HoverHandler::cursorShape
+    This property holds the cursor shape that will appear whenever
+    \l hovered is \c true and no other handler is overriding it.
+
+    The available cursor shapes are:
+    \list
+    \li Qt.ArrowCursor
+    \li Qt.UpArrowCursor
+    \li Qt.CrossCursor
+    \li Qt.WaitCursor
+    \li Qt.IBeamCursor
+    \li Qt.SizeVerCursor
+    \li Qt.SizeHorCursor
+    \li Qt.SizeBDiagCursor
+    \li Qt.SizeFDiagCursor
+    \li Qt.SizeAllCursor
+    \li Qt.BlankCursor
+    \li Qt.SplitVCursor
+    \li Qt.SplitHCursor
+    \li Qt.PointingHandCursor
+    \li Qt.ForbiddenCursor
+    \li Qt.WhatsThisCursor
+    \li Qt.BusyCursor
+    \li Qt.OpenHandCursor
+    \li Qt.ClosedHandCursor
+    \li Qt.DragCopyCursor
+    \li Qt.DragMoveCursor
+    \li Qt.DragLinkCursor
+    \endlist
+
+    The default value of this property is not set, which allows any active
+    handler on the same \l parentItem to determine the cursor shape.
+    This property can be reset to the initial condition by setting it to
+    \c undefined.
+
+    If any handler with defined \c cursorShape is
+    \l {PointerHandler::active}{active}, that cursor will appear.
+    Else if the HoverHandler has a defined \c cursorShape, that cursor will appear.
+    Otherwise, the \l {QQuickItem::cursor()}{cursor} of \l parentItem will appear.
+
+    \note When this property has not been set, or has been set to \c undefined,
+    if you read the value it will return \c Qt.ArrowCursor.
+
+    \sa Qt::CursorShape, QQuickItem::cursor()
+*/
+
 QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquickpointerhandler.cpp b/src/quick/handlers/qquickpointerhandler.cpp
index c498c96454..adb753e000 100644
--- a/src/quick/handlers/qquickpointerhandler.cpp
+++ b/src/quick/handlers/qquickpointerhandler.cpp
@@ -51,7 +51,6 @@ Q_LOGGING_CATEGORY(lcPointerHandlerActive, "qt.quick.handler.active")
     \qmltype PointerHandler
     \qmlabstract
     \since 5.10
-    \preliminary
     \instantiates QQuickPointerHandler
     \inqmlmodule QtQuick
     \brief Abstract handler for pointer events.
@@ -154,6 +153,87 @@ void QQuickPointerHandler::resetDragThreshold()
 }
 
 /*!
+    \since 5.15
+    \qmlproperty Qt::CursorShape PointerHandler::cursorShape
+    This property holds the cursor shape that will appear whenever the mouse is
+    hovering over the \l parentItem while \l active is \c true.
+
+    The available cursor shapes are:
+    \list
+    \li Qt.ArrowCursor
+    \li Qt.UpArrowCursor
+    \li Qt.CrossCursor
+    \li Qt.WaitCursor
+    \li Qt.IBeamCursor
+    \li Qt.SizeVerCursor
+    \li Qt.SizeHorCursor
+    \li Qt.SizeBDiagCursor
+    \li Qt.SizeFDiagCursor
+    \li Qt.SizeAllCursor
+    \li Qt.BlankCursor
+    \li Qt.SplitVCursor
+    \li Qt.SplitHCursor
+    \li Qt.PointingHandCursor
+    \li Qt.ForbiddenCursor
+    \li Qt.WhatsThisCursor
+    \li Qt.BusyCursor
+    \li Qt.OpenHandCursor
+    \li Qt.ClosedHandCursor
+    \li Qt.DragCopyCursor
+    \li Qt.DragMoveCursor
+    \li Qt.DragLinkCursor
+    \endlist
+
+    The default value is not set, which allows the \l {QQuickItem::cursor()}{cursor}
+    of \l parentItem to appear. This property can be reset to the same initial
+    condition by setting it to undefined.
+
+    \note When this property has not been set, or has been set to \c undefined,
+    if you read the value it will return \c Qt.ArrowCursor.
+
+    \sa Qt::CursorShape, QQuickItem::cursor(), HoverHandler::cursorShape
+*/
+#if QT_CONFIG(cursor)
+Qt::CursorShape QQuickPointerHandler::cursorShape() const
+{
+    Q_D(const QQuickPointerHandler);
+    return d->cursorShape;
+}
+
+void QQuickPointerHandler::setCursorShape(Qt::CursorShape shape)
+{
+    Q_D(QQuickPointerHandler);
+    if (d->cursorSet && shape == d->cursorShape)
+        return;
+    d->cursorShape = shape;
+    d->cursorSet = true;
+    QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parentItem());
+    itemPriv->hasCursorHandler = true;
+    itemPriv->setHasCursorInChild(true);
+    emit cursorShapeChanged();
+}
+
+void QQuickPointerHandler::resetCursorShape()
+{
+    Q_D(QQuickPointerHandler);
+    if (!d->cursorSet)
+        return;
+    d->cursorShape = Qt::ArrowCursor;
+    d->cursorSet = false;
+    QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parentItem());
+    itemPriv->hasCursorHandler = false;
+    itemPriv->setHasCursorInChild(itemPriv->hasCursor);
+    emit cursorShapeChanged();
+}
+
+bool QQuickPointerHandler::isCursorShapeExplicitlySet() const
+{
+    Q_D(const QQuickPointerHandler);
+    return d->cursorSet;
+}
+#endif
+
+/*!
     Notification that the grab has changed in some way which is relevant to this handler.
     The \a grabber (subject) will be the Input Handler whose state is changing,
     or null if the state change regards an Item.
@@ -597,11 +677,13 @@ QQuickPointerHandlerPrivate::QQuickPointerHandlerPrivate()
   : grabPermissions(QQuickPointerHandler::CanTakeOverFromItems |
                       QQuickPointerHandler::CanTakeOverFromHandlersOfDifferentType |
                       QQuickPointerHandler::ApprovesTakeOverByAnything)
+  , cursorShape(Qt::ArrowCursor)
   , enabled(true)
   , active(false)
   , targetExplicitlySet(false)
   , hadKeepMouseGrab(false)
   , hadKeepTouchGrab(false)
+  , cursorSet(false)
 {
 }
 
diff --git a/src/quick/handlers/qquickpointerhandler_p.h b/src/quick/handlers/qquickpointerhandler_p.h
index 34ae9ce2c2..7262f4bcd3 100644
--- a/src/quick/handlers/qquickpointerhandler_p.h
+++ b/src/quick/handlers/qquickpointerhandler_p.h
@@ -72,6 +72,9 @@ class Q_QUICK_PRIVATE_EXPORT QQuickPointerHandler : public QObject, public QQmlP
     Q_PROPERTY(GrabPermissions grabPermissions READ grabPermissions WRITE setGrabPermissions NOTIFY grabPermissionChanged)
     Q_PROPERTY(qreal margin READ margin WRITE setMargin NOTIFY marginChanged)
     Q_PROPERTY(int dragThreshold READ dragThreshold WRITE setDragThreshold RESET resetDragThreshold NOTIFY dragThresholdChanged REVISION 15)
+#if QT_CONFIG(cursor)
+    Q_PROPERTY(Qt::CursorShape cursorShape READ cursorShape WRITE setCursorShape RESET resetCursorShape NOTIFY cursorShapeChanged REVISION 15)
+#endif
 
     QML_NAMED_ELEMENT(PointerHandler)
     QML_UNCREATABLE("PointerHandler is an abstract base class.")
@@ -119,6 +122,13 @@ public:
     void setDragThreshold(int t);
     void resetDragThreshold();
 
+#if QT_CONFIG(cursor)
+    Qt::CursorShape cursorShape() const;
+    void setCursorShape(Qt::CursorShape shape);
+    void resetCursorShape();
+    bool isCursorShapeExplicitlySet() const;
+#endif
+
 Q_SIGNALS:
     void enabledChanged();
     void activeChanged();
@@ -128,6 +138,9 @@ Q_SIGNALS:
     void grabChanged(QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point);
     void grabPermissionChanged();
     void canceled(QQuickEventPoint *point);
+#if QT_CONFIG(cursor)
+    Q_REVISION(15) void cursorShapeChanged();
+#endif
 
 protected:
     QQuickPointerHandler(QQuickPointerHandlerPrivate &dd, QQuickItem *parent);
diff --git a/src/quick/handlers/qquickpointerhandler_p_p.h b/src/quick/handlers/qquickpointerhandler_p_p.h
index 5727b1ef55..db053fb6b4 100644
--- a/src/quick/handlers/qquickpointerhandler_p_p.h
+++ b/src/quick/handlers/qquickpointerhandler_p_p.h
@@ -79,11 +79,13 @@ public:
     qreal m_margin = 0;
     qint16 dragThreshold = -1;   // -1 means use the platform default
     uint8_t grabPermissions : 8;
+    Qt::CursorShape cursorShape : 6;
     bool enabled : 1;
     bool active : 1;
     bool targetExplicitlySet : 1;
     bool hadKeepMouseGrab : 1;    // some handlers override target()->setKeepMouseGrab(); this remembers previous state
     bool hadKeepTouchGrab : 1;    // some handlers override target()->setKeepTouchGrab(); this remembers previous state
+    bool cursorSet : 1;
 };
 
 QT_END_NAMESPACE
diff --git a/src/quick/items/qquickitem.cpp b/src/quick/items/qquickitem.cpp
index 03cdeb5bef..fe8df6fb64 100644
--- a/src/quick/items/qquickitem.cpp
+++ b/src/quick/items/qquickitem.cpp
@@ -3244,6 +3244,7 @@ QQuickItemPrivate::QQuickItemPrivate()
 #else
     , touchEnabled(false)
 #endif
+    , hasCursorHandler(false)
     , dirtyAttributes(0)
     , nextDirtyItem(nullptr)
     , prevDirtyItem(nullptr)
@@ -7472,14 +7473,14 @@ void QQuickItem::setAcceptTouchEvents(bool enabled)
     d->touchEnabled = enabled;
 }
 
-void QQuickItemPrivate::setHasCursorInChild(bool hasCursor)
+void QQuickItemPrivate::setHasCursorInChild(bool hc)
 {
 #if QT_CONFIG(cursor)
     Q_Q(QQuickItem);
 
     // if we're asked to turn it off (because of an unsetcursor call, or a node
     // removal) then we should make sure it's really ok to turn it off.
-    if (!hasCursor && subtreeCursorEnabled) {
+    if (!hc && subtreeCursorEnabled) {
         if (hasCursor)
             return; // nope! sorry, I have a cursor myself
         for (QQuickItem *otherChild : qAsConst(childItems)) {
@@ -7489,14 +7490,14 @@ void QQuickItemPrivate::setHasCursorInChild(bool hasCursor)
         }
     }
 
-    subtreeCursorEnabled = hasCursor;
+    subtreeCursorEnabled = hc;
     QQuickItem *parent = q->parentItem();
     if (parent) {
         QQuickItemPrivate *parentPrivate = QQuickItemPrivate::get(parent);
-        parentPrivate->setHasCursorInChild(hasCursor);
+        parentPrivate->setHasCursorInChild(hc);
     }
 #else
-    Q_UNUSED(hasCursor);
+    Q_UNUSED(hc);
 #endif
 }
 
@@ -7573,17 +7574,20 @@ void QQuickItem::setCursor(const QCursor &cursor)
         }
     }
 
+    QPointF updateCursorPos;
     if (!d->hasCursor) {
-        d->setHasCursorInChild(true);
         d->hasCursor = true;
         if (d->window) {
             QWindow *renderWindow = QQuickRenderControl::renderWindowFor(d->window);
             QWindow *window = renderWindow ? renderWindow : d->window;
             QPointF pos = window->mapFromGlobal(QGuiApplicationPrivate::lastCursorPosition.toPoint());
             if (contains(mapFromScene(pos)))
-                QQuickWindowPrivate::get(d->window)->updateCursor(pos);
+                updateCursorPos = pos;
         }
     }
+    d->setHasCursorInChild(d->hasCursor || d->hasCursorHandler);
+    if (!updateCursorPos.isNull())
+        QQuickWindowPrivate::get(d->window)->updateCursor(updateCursorPos);
 }
 
 /*!
@@ -7597,8 +7601,8 @@ void QQuickItem::unsetCursor()
     Q_D(QQuickItem);
     if (!d->hasCursor)
         return;
-    d->setHasCursorInChild(false);
     d->hasCursor = false;
+    d->setHasCursorInChild(d->hasCursorHandler);
     if (d->extra.isAllocated())
         d->extra->cursor = QCursor();
 
@@ -7611,6 +7615,64 @@ void QQuickItem::unsetCursor()
     }
 }
 
+/*!
+    \internal
+    Returns the cursor that should actually be shown, allowing the given
+    \handler to override the Item cursor if it is active or hovered.
+
+    \sa cursor(), setCursor(), QtQuick::PointerHandler::cursor
+*/
+QCursor QQuickItemPrivate::effectiveCursor(const QQuickPointerHandler *handler) const
+{
+    Q_Q(const QQuickItem);
+    if (!handler)
+        return q->cursor();
+    bool hoverCursorSet = false;
+    QCursor hoverCursor;
+    bool activeCursorSet = false;
+    QCursor activeCursor;
+    if (const QQuickHoverHandler *hoverHandler = qobject_cast<const QQuickHoverHandler *>(handler)) {
+        hoverCursorSet = hoverHandler->isCursorShapeExplicitlySet();
+        hoverCursor = hoverHandler->cursorShape();
+    } else if (handler->active()) {
+        activeCursorSet = handler->isCursorShapeExplicitlySet();
+        activeCursor = handler->cursorShape();
+    }
+    if (activeCursorSet)
+        return activeCursor;
+    if (hoverCursorSet)
+        return hoverCursor;
+    return q->cursor();
+}
+
+/*!
+    \internal
+    Returns the Pointer Handler that is currently attempting to set the cursor shape,
+    or null if there is no such handler.
+
+    \sa QtQuick::PointerHandler::cursor
+*/
+QQuickPointerHandler *QQuickItemPrivate::effectiveCursorHandler() const
+{
+    if (!hasPointerHandlers())
+        return nullptr;
+    QQuickPointerHandler *retHoverHandler = nullptr;
+    for (QQuickPointerHandler *h : extra->pointerHandlers) {
+        if (!h->isCursorShapeExplicitlySet())
+            continue;
+        QQuickHoverHandler *hoverHandler = qmlobject_cast<QQuickHoverHandler *>(h);
+        // For now, we don't expect multiple hover handlers in one Item, so we choose the first one found;
+        // but a future use case could be to have different cursors for different tablet stylus devices.
+        // In that case, this function needs more information: which device did the event come from.
+        // TODO Qt 6: add QPointerDevice* as argument to this function? (it doesn't exist yet in Qt 5)
+        if (!retHoverHandler && hoverHandler)
+            retHoverHandler = hoverHandler;
+        if (!hoverHandler && h->active())
+            return h;
+    }
+    return retHoverHandler;
+}
+
 #endif
 
 /*!
diff --git a/src/quick/items/qquickitem_p.h b/src/quick/items/qquickitem_p.h
index 3c0517cb3b..841d91bb40 100644
--- a/src/quick/items/qquickitem_p.h
+++ b/src/quick/items/qquickitem_p.h
@@ -471,6 +471,7 @@ public:
     bool isTabFence:1;
     bool replayingPressEvent:1;
     bool touchEnabled:1;
+    bool hasCursorHandler:1;
 
     enum DirtyType {
         TransformOrigin         = 0x00000001,
@@ -651,6 +652,10 @@ public:
 
     void setHasCursorInChild(bool hasCursor);
     void setHasHoverInChild(bool hasHover);
+#if QT_CONFIG(cursor)
+    QCursor effectiveCursor(const QQuickPointerHandler *handler) const;
+    QQuickPointerHandler *effectiveCursorHandler() const;
+#endif
 
     virtual void updatePolish() { }
 };
diff --git a/src/quick/items/qquickwindow.cpp b/src/quick/items/qquickwindow.cpp
index ceea8fc78f..9ab3f2d8c2 100644
--- a/src/quick/items/qquickwindow.cpp
+++ b/src/quick/items/qquickwindow.cpp
@@ -560,6 +560,7 @@ QQuickWindowPrivate::QQuickWindowPrivate()
     , activeFocusItem(nullptr)
 #if QT_CONFIG(cursor)
     , cursorItem(nullptr)
+    , cursorHandler(nullptr)
 #endif
 #if QT_CONFIG(quick_draganddrop)
     , dragGrabber(nullptr)
@@ -2967,26 +2968,27 @@ void QQuickWindowPrivate::updateCursor(const QPointF &scenePos)
 {
     Q_Q(QQuickWindow);
 
-    QQuickItem *oldCursorItem = cursorItem;
-    cursorItem = findCursorItem(contentItem, scenePos);
+    auto cursorItemAndHandler = findCursorItemAndHandler(contentItem, scenePos);
 
-    if (cursorItem != oldCursorItem) {
+    if (cursorItem != cursorItemAndHandler.first || cursorHandler != cursorItemAndHandler.second) {
         QWindow *renderWindow = QQuickRenderControl::renderWindowFor(q);
         QWindow *window = renderWindow ? renderWindow : q;
+        cursorItem = cursorItemAndHandler.first;
+        cursorHandler = cursorItemAndHandler.second;
         if (cursorItem)
-            window->setCursor(cursorItem->cursor());
+            window->setCursor(QQuickItemPrivate::get(cursorItem)->effectiveCursor(cursorHandler));
         else
             window->unsetCursor();
     }
 }
 
-QQuickItem *QQuickWindowPrivate::findCursorItem(QQuickItem *item, const QPointF &scenePos)
+QPair<QQuickItem*, QQuickPointerHandler*> QQuickWindowPrivate::findCursorItemAndHandler(QQuickItem *item, const QPointF &scenePos) const
 {
     QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
     if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
         QPointF p = item->mapFromScene(scenePos);
         if (!item->contains(p))
-            return nullptr;
+            return {nullptr, nullptr};
     }
 
     if (itemPrivate->subtreeCursorEnabled) {
@@ -2995,17 +2997,24 @@ QQuickItem *QQuickWindowPrivate::findCursorItem(QQuickItem *item, const QPointF
             QQuickItem *child = children.at(ii);
             if (!child->isVisible() || !child->isEnabled() || QQuickItemPrivate::get(child)->culled)
                 continue;
-            if (QQuickItem *cursorItem = findCursorItem(child, scenePos))
-                return cursorItem;
+            auto ret = findCursorItemAndHandler(child, scenePos);
+            if (ret.first)
+                return ret;
+        }
+        if (itemPrivate->hasCursor || itemPrivate->hasCursorHandler) {
+            QPointF p = item->mapFromScene(scenePos);
+            if (!item->contains(p))
+                return {nullptr, nullptr};
+            if (itemPrivate->hasCursorHandler) {
+                if (auto handler = itemPrivate->effectiveCursorHandler())
+                    return {item, handler};
+            }
+            if (itemPrivate->hasCursor)
+                return {item, nullptr};
         }
     }
 
-    if (itemPrivate->hasCursor) {
-        QPointF p = item->mapFromScene(scenePos);
-        if (item->contains(p))
-            return item;
-    }
-    return nullptr;
+    return {nullptr, nullptr};
 }
 #endif
 
diff --git a/src/quick/items/qquickwindow_p.h b/src/quick/items/qquickwindow_p.h
index ef10ba3fe8..6e6dc7a400 100644
--- a/src/quick/items/qquickwindow_p.h
+++ b/src/quick/items/qquickwindow_p.h
@@ -134,6 +134,7 @@ public:
     // Keeps track of the item currently receiving mouse events
 #if QT_CONFIG(cursor)
     QQuickItem *cursorItem;
+    QQuickPointerHandler *cursorHandler;
 #endif
 #if QT_CONFIG(quick_draganddrop)
     QQuickDragGrabber *dragGrabber;
@@ -197,7 +198,7 @@ public:
 #endif
 #if QT_CONFIG(cursor)
     void updateCursor(const QPointF &scenePos);
-    QQuickItem *findCursorItem(QQuickItem *item, const QPointF &scenePos);
+    QPair<QQuickItem*, QQuickPointerHandler*> findCursorItemAndHandler(QQuickItem *item, const QPointF &scenePos) const;
 #endif
 
     QList<QQuickItem*> hoverItems;
diff --git a/tests/auto/quick/pointerhandlers/qquickdraghandler/data/draggables.qml b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/draggables.qml
index 7b3601bea0..81fa20f3bb 100644
--- a/tests/auto/quick/pointerhandlers/qquickdraghandler/data/draggables.qml
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/draggables.qml
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2020 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the manual tests of the Qt Toolkit.
@@ -26,7 +26,7 @@
 **
 ****************************************************************************/
 
-import QtQuick 2.12
+import QtQuick 2.15
 
 Item {
     id: root
@@ -47,6 +47,7 @@ Item {
             DragHandler {
                 id: dragHandler
                 objectName: "DragHandler " + (index + 1)
+                cursorShape: Qt.ClosedHandCursor
             }
 
             Text {
diff --git a/tests/auto/quick/pointerhandlers/qquickdraghandler/tst_qquickdraghandler.cpp b/tests/auto/quick/pointerhandlers/qquickdraghandler/tst_qquickdraghandler.cpp
index 65c5ac9ef4..47cfd27817 100644
--- a/tests/auto/quick/pointerhandlers/qquickdraghandler/tst_qquickdraghandler.cpp
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/tst_qquickdraghandler.cpp
@@ -249,8 +249,11 @@ void tst_DragHandler::mouseDrag()
     QPointF ballCenter = ball->clipRect().center();
     QPointF scenePressPos = ball->mapToScene(ballCenter);
     QPoint p1 = scenePressPos.toPoint();
-    QTest::mousePress(window, static_cast<Qt::MouseButton>(int(dragButton)), Qt::NoModifier, p1);
+    QTest::mousePress(window, static_cast<Qt::MouseButton>(int(dragButton)), Qt::NoModifier, p1, 500);
     QVERIFY(!dragHandler->active());
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
     if (shouldDrag) {
         QCOMPARE(dragHandler->centroid().position(), ballCenter);
         QCOMPARE(dragHandler->centroid().pressPosition(), ballCenter);
@@ -265,6 +268,9 @@ void tst_DragHandler::mouseDrag()
         QTRY_VERIFY(dragHandler->centroid().velocity().x() > 0);
         QCOMPARE(centroidChangedSpy.count(), 2);
         QVERIFY(!dragHandler->active());
+#if QT_CONFIG(cursor)
+        QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
     }
     p1 += QPoint(1, 0);
     QTest::mouseMove(window, p1);
@@ -292,6 +298,9 @@ void tst_DragHandler::mouseDrag()
         QCOMPARE(dragHandler->translation().y(), 0.0);
         QVERIFY(dragHandler->centroid().velocity().x() > 0);
         QCOMPARE(centroidChangedSpy.count(), 4);
+#if QT_CONFIG(cursor)
+        QCOMPARE(window->cursor().shape(), Qt::ClosedHandCursor);
+#endif
     }
     QTest::mouseRelease(window, static_cast<Qt::MouseButton>(int(dragButton)), Qt::NoModifier, p1);
     QTRY_VERIFY(!dragHandler->active());
@@ -300,6 +309,10 @@ void tst_DragHandler::mouseDrag()
         QCOMPARE(ball->mapToScene(ballCenter).toPoint(), p1);
     QCOMPARE(translationChangedSpy.count(), shouldDrag ? 1 : 0);
     QCOMPARE(centroidChangedSpy.count(), shouldDrag ? 5 : 0);
+#if QT_CONFIG(cursor)
+    QTest::mouseMove(window, p1 + QPoint(1, 0)); // TODO after fixing QTBUG-53987, don't send mouseMove
+    QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
 }
 
 void tst_DragHandler::mouseDragThreshold_data()
diff --git a/tests/auto/quick/pointerhandlers/qquickhoverhandler/data/lesHoverables.qml b/tests/auto/quick/pointerhandlers/qquickhoverhandler/data/lesHoverables.qml
index 011dc4e75f..38a19c57c5 100644
--- a/tests/auto/quick/pointerhandlers/qquickhoverhandler/data/lesHoverables.qml
+++ b/tests/auto/quick/pointerhandlers/qquickhoverhandler/data/lesHoverables.qml
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2018 The Qt Company Ltd.
+** Copyright (C) 2020 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the test suite of the Qt Toolkit.
@@ -26,7 +26,7 @@
 **
 ****************************************************************************/
 
-import QtQuick 2.12
+import QtQuick 2.15
 
 Rectangle {
     id: root
@@ -52,6 +52,7 @@ Rectangle {
                     id: buttonMA
                     objectName: "buttonMA"
                     hoverEnabled: true
+                    cursorShape: Qt.UpArrowCursor
                     anchors.fill: parent
                     onClicked: console.log("clicked MA")
                 }
@@ -74,9 +75,12 @@ Rectangle {
                     id: buttonHH
                     objectName: "buttonHH"
                     acceptedDevices: PointerDevice.AllDevices
+                    cursorShape: tapHandler.pressed ? Qt.BusyCursor : Qt.PointingHandCursor
                 }
 
-                TapHandler { }
+                TapHandler {
+                    id: tapHandler
+                }
 
                 Text {
                     anchors.centerIn: parent
@@ -127,6 +131,7 @@ Rectangle {
         HoverHandler {
             id: topSidebarHH
             objectName: "topSidebarHH"
+            cursorShape: Qt.OpenHandCursor
         }
 
         Loader {
@@ -152,6 +157,7 @@ Rectangle {
             id: bottomSidebarMA
             objectName: "bottomSidebarMA"
             hoverEnabled: true
+            cursorShape: Qt.ClosedHandCursor
             anchors.fill: parent
         }
 
diff --git a/tests/auto/quick/pointerhandlers/qquickhoverhandler/tst_qquickhoverhandler.cpp b/tests/auto/quick/pointerhandlers/qquickhoverhandler/tst_qquickhoverhandler.cpp
index 575139f851..61f2752dd2 100644
--- a/tests/auto/quick/pointerhandlers/qquickhoverhandler/tst_qquickhoverhandler.cpp
+++ b/tests/auto/quick/pointerhandlers/qquickhoverhandler/tst_qquickhoverhandler.cpp
@@ -104,30 +104,45 @@ void tst_HoverHandler::hoverHandlerAndUnderlyingHoverHandler()
     QCOMPARE(sidebarHoveredSpy.count(), 0);
     QCOMPARE(buttonHH->isHovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 0);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
 
     QTest::mouseMove(window, rightOfButton);
     QCOMPARE(topSidebarHH->isHovered(), true);
     QCOMPARE(sidebarHoveredSpy.count(), 1);
     QCOMPARE(buttonHH->isHovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 0);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::OpenHandCursor);
+#endif
 
     QTest::mouseMove(window, buttonCenter);
     QCOMPARE(topSidebarHH->isHovered(), true);
     QCOMPARE(sidebarHoveredSpy.count(), 1);
     QCOMPARE(buttonHH->isHovered(), true);
     QCOMPARE(buttonHoveredSpy.count(), 1);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::PointingHandCursor);
+#endif
 
     QTest::mouseMove(window, rightOfButton);
     QCOMPARE(topSidebarHH->isHovered(), true);
     QCOMPARE(sidebarHoveredSpy.count(), 1);
     QCOMPARE(buttonHH->isHovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 2);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::OpenHandCursor);
+#endif
 
     QTest::mouseMove(window, outOfSidebar);
     QCOMPARE(topSidebarHH->isHovered(), false);
     QCOMPARE(sidebarHoveredSpy.count(), 2);
     QCOMPARE(buttonHH->isHovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 2);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
 }
 
 void tst_HoverHandler::mouseAreaAndUnderlyingHoverHandler()
@@ -153,30 +168,45 @@ void tst_HoverHandler::mouseAreaAndUnderlyingHoverHandler()
     QCOMPARE(sidebarHoveredSpy.count(), 0);
     QCOMPARE(buttonMA->hovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 0);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
 
     QTest::mouseMove(window, rightOfButton);
     QCOMPARE(topSidebarHH->isHovered(), true);
     QCOMPARE(sidebarHoveredSpy.count(), 1);
     QCOMPARE(buttonMA->hovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 0);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::OpenHandCursor);
+#endif
 
     QTest::mouseMove(window, buttonCenter);
     QCOMPARE(topSidebarHH->isHovered(), true);
     QCOMPARE(sidebarHoveredSpy.count(), 1);
     QCOMPARE(buttonMA->hovered(), true);
     QCOMPARE(buttonHoveredSpy.count(), 1);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::UpArrowCursor);
+#endif
 
     QTest::mouseMove(window, rightOfButton);
     QCOMPARE(topSidebarHH->isHovered(), true);
     QCOMPARE(sidebarHoveredSpy.count(), 1);
     QCOMPARE(buttonMA->hovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 2);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::OpenHandCursor);
+#endif
 
     QTest::mouseMove(window, outOfSidebar);
     QCOMPARE(topSidebarHH->isHovered(), false);
     QCOMPARE(sidebarHoveredSpy.count(), 2);
     QCOMPARE(buttonMA->hovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 2);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
 }
 
 void tst_HoverHandler::hoverHandlerAndUnderlyingMouseArea()
@@ -204,30 +234,45 @@ void tst_HoverHandler::hoverHandlerAndUnderlyingMouseArea()
     QCOMPARE(sidebarHoveredSpy.count(), 0);
     QCOMPARE(buttonHH->isHovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 0);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
 
     QTest::mouseMove(window, rightOfButton);
     QCOMPARE(bottomSidebarMA->hovered(), true);
     QCOMPARE(sidebarHoveredSpy.count(), 1);
     QCOMPARE(buttonHH->isHovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 0);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ClosedHandCursor);
+#endif
 
     QTest::mouseMove(window, buttonCenter);
     QCOMPARE(bottomSidebarMA->hovered(), false);
     QCOMPARE(sidebarHoveredSpy.count(), 2);
     QCOMPARE(buttonHH->isHovered(), true);
     QCOMPARE(buttonHoveredSpy.count(), 1);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::PointingHandCursor);
+#endif
 
     QTest::mouseMove(window, rightOfButton);
     QCOMPARE(bottomSidebarMA->hovered(), true);
     QCOMPARE(sidebarHoveredSpy.count(), 3);
     QCOMPARE(buttonHH->isHovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 2);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ClosedHandCursor);
+#endif
 
     QTest::mouseMove(window, outOfSidebar);
     QCOMPARE(bottomSidebarMA->hovered(), false);
     QCOMPARE(sidebarHoveredSpy.count(), 4);
     QCOMPARE(buttonHH->isHovered(), false);
     QCOMPARE(buttonHoveredSpy.count(), 2);
+#if QT_CONFIG(cursor)
+    QCOMPARE(window->cursor().shape(), Qt::ArrowCursor);
+#endif
 }
 
 void tst_HoverHandler::movingItemWithHoverHandler()
@@ -255,6 +300,7 @@ void tst_HoverHandler::movingItemWithHoverHandler()
     QVERIFY(QTest::qWaitForWindowExposed(window));
 
     QTRY_COMPARE(paddleHH->isHovered(), true);
+    // TODO check the cursor shape after fixing QTBUG-53987
 
     paddle->setX(100);
     QTRY_COMPARE(paddleHH->isHovered(), false);
diff --git a/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp b/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp
index 5b6b11c746..bf58ce961c 100644
--- a/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp
+++ b/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp
@@ -1797,22 +1797,26 @@ void tst_qquickwindow::cursor()
     window.resize(320, 290);
 
     QQuickItem parentItem;
+    parentItem.setObjectName("parentItem");
     parentItem.setPosition(QPointF(0, 0));
     parentItem.setSize(QSizeF(180, 180));
     parentItem.setParentItem(window.contentItem());
 
     QQuickItem childItem;
+    childItem.setObjectName("childItem");
     childItem.setPosition(QPointF(60, 90));
     childItem.setSize(QSizeF(120, 120));
     childItem.setParentItem(&parentItem);
 
     QQuickItem clippingItem;
+    clippingItem.setObjectName("clippingItem");
     clippingItem.setPosition(QPointF(120, 120));
     clippingItem.setSize(QSizeF(180, 180));
     clippingItem.setClip(true);
     clippingItem.setParentItem(window.contentItem());
 
     QQuickItem clippedItem;
+    clippedItem.setObjectName("clippedItem");
     clippedItem.setPosition(QPointF(-30, -30));
     clippedItem.setSize(QSizeF(120, 120));
     clippedItem.setParentItem(&clippingItem);
diff --git a/tests/manual/pointer/sidebar.qml b/tests/manual/pointer/sidebar.qml
index 827dbd1980..b7370a4fb7 100644
--- a/tests/manual/pointer/sidebar.qml
+++ b/tests/manual/pointer/sidebar.qml
@@ -26,7 +26,7 @@
 **
 ****************************************************************************/
 
-import QtQuick 2.12
+import QtQuick 2.15
 import "content"
 
 Rectangle {
@@ -53,6 +53,7 @@ Rectangle {
                     id: buttonMA
                     objectName: "buttonMA"
                     hoverEnabled: true
+                    cursorShape: Qt.UpArrowCursor
                     anchors.fill: parent
                     onClicked: console.log("clicked MA")
                 }
@@ -75,9 +76,11 @@ Rectangle {
                     id: buttonHH
                     objectName: "buttonHH"
                     acceptedDevices: PointerDevice.AllDevices
+                    cursorShape: tapHandler.pressed ? Qt.BusyCursor : Qt.PointingHandCursor
                 }
 
                 TapHandler {
+                    id: tapHandler
                     onTapped: tapFlash.start()
                 }
 
@@ -148,6 +151,7 @@ Rectangle {
         HoverHandler {
             id: topSidebarHH
             objectName: "topSidebarHH"
+            cursorShape: Qt.OpenHandCursor
         }
 
         Loader {
@@ -173,6 +177,7 @@ Rectangle {
             id: bottomSidebarMA
             objectName: "bottomSidebarMA"
             hoverEnabled: true
+            cursorShape: Qt.ClosedHandCursor
             anchors.fill: parent
         }