Rename QQEventPoint::GrabState to GrabTransition

This enum represents a transient state transition, and only sometimes
corresponds to the current grab state of an event point.  For example
after exclusive grab has been canceled, the current state is that
there is no exclusive grab: it doesn't make sense to remember that the
way it got there was by cancellation.  There was an idea to add a
grabState property, but not all values would be eligible.  An
EventPoint can be exclusively grabbed by one item or handler at a
time, and by multiple passive grabbers at the same time, so even a
Q_FLAG would not fully express all possible states.  Besides, there is
already an exclusiveGrabber property, and we could add a
passiveGrabbers list property if we had a real need.  So adding a
grabState property seems unlikely, and therefore is not a good enough
reason to keep this enum named as GrabState.

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

13 files changed, 43 insertions, 43 deletions

diff --git a/src/quick/handlers/qquickdraghandler.cpp b/src/quick/handlers/qquickdraghandler.cpp
index ffdaa909dd..b8f08639ef 100644
--- a/src/quick/handlers/qquickdraghandler.cpp
+++ b/src/quick/handlers/qquickdraghandler.cpp
@@ -109,10 +109,10 @@ QPointF QQuickDragHandler::targetCentroidPosition()
     return pos;
 }
 
-void QQuickDragHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point)
+void QQuickDragHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point)
 {
-    QQuickMultiPointHandler::onGrabChanged(grabber, stateChange, point);
-    if (grabber == this && stateChange == QQuickEventPoint::GrabExclusive) {
+    QQuickMultiPointHandler::onGrabChanged(grabber, transition, point);
+    if (grabber == this && transition == QQuickEventPoint::GrabExclusive) {
         // In case the grab got handed over from another grabber, we might not get the Press.
         if (!m_pressedInsideTarget) {
             if (target())
diff --git a/src/quick/handlers/qquickdraghandler_p.h b/src/quick/handlers/qquickdraghandler_p.h
index 25101a98c4..3b8d2ef254 100644
--- a/src/quick/handlers/qquickdraghandler_p.h
+++ b/src/quick/handlers/qquickdraghandler_p.h
@@ -82,7 +82,7 @@ Q_SIGNALS:
 
 protected:
     void onActiveChanged() override;
-    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override;
+    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point) override;
 
 private:
     void ungrab();
diff --git a/src/quick/handlers/qquickmultipointhandler.cpp b/src/quick/handlers/qquickmultipointhandler.cpp
index cb3becaa2d..859a9135b7 100644
--- a/src/quick/handlers/qquickmultipointhandler.cpp
+++ b/src/quick/handlers/qquickmultipointhandler.cpp
@@ -143,13 +143,13 @@ void QQuickMultiPointHandler::onActiveChanged()
     }
 }
 
-void QQuickMultiPointHandler::onGrabChanged(QQuickPointerHandler *, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *)
+void QQuickMultiPointHandler::onGrabChanged(QQuickPointerHandler *, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *)
 {
     // If another handler or item takes over this set of points, assume it has
     // decided that it's the better fit for them. Don't immediately re-grab
     // at the next opportunity. This should help to avoid grab cycles
     // (e.g. between DragHandler and PinchHandler).
-    if (stateChange == QQuickEventPoint::UngrabExclusive || stateChange == QQuickEventPoint::CancelGrabExclusive)
+    if (transition == QQuickEventPoint::UngrabExclusive || transition == QQuickEventPoint::CancelGrabExclusive)
         m_currentPoints.clear();
 }
 
diff --git a/src/quick/handlers/qquickmultipointhandler_p.h b/src/quick/handlers/qquickmultipointhandler_p.h
index 199ea7cd10..94142013cc 100644
--- a/src/quick/handlers/qquickmultipointhandler_p.h
+++ b/src/quick/handlers/qquickmultipointhandler_p.h
@@ -93,7 +93,7 @@ protected:
     bool wantsPointerEvent(QQuickPointerEvent *event) override;
     void handlePointerEventImpl(QQuickPointerEvent *event) override;
     void onActiveChanged() override;
-    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override;
+    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point) override;
     bool hasCurrentPoints(QQuickPointerEvent *event);
     QVector<QQuickEventPoint *> eligiblePoints(QQuickPointerEvent *event);
     qreal averageTouchPointDistance(const QPointF &ref);
diff --git a/src/quick/handlers/qquickpointerhandler.cpp b/src/quick/handlers/qquickpointerhandler.cpp
index db58046e81..9b8281b519 100644
--- a/src/quick/handlers/qquickpointerhandler.cpp
+++ b/src/quick/handlers/qquickpointerhandler.cpp
@@ -116,7 +116,7 @@ void QQuickPointerHandler::setMargin(qreal pointDistanceThreshold)
     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.
-    The \a stateChange (verb) tells what happened.
+    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 Input Handler must react in whatever way is appropriate, and must
@@ -125,13 +125,13 @@ void QQuickPointerHandler::setMargin(qreal pointDistanceThreshold)
     call its parent class's implementation in addition to (usually after)
     whatever custom behavior it implements.
 */
-void QQuickPointerHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point)
+void QQuickPointerHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point)
 {
-    qCDebug(lcPointerHandlerGrab) << point << stateChange << grabber;
+    qCDebug(lcPointerHandlerGrab) << point << transition << grabber;
     Q_ASSERT(point);
     if (grabber == this) {
         bool wasCanceled = false;
-        switch (stateChange) {
+        switch (transition) {
         case QQuickEventPoint::GrabPassive:
         case QQuickEventPoint::GrabExclusive:
             break;
@@ -156,7 +156,7 @@ void QQuickPointerHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEv
         }
         if (wasCanceled)
             emit canceled(point);
-        emit grabChanged(stateChange, point);
+        emit grabChanged(transition, point);
     }
 }
 
@@ -500,12 +500,12 @@ void QQuickPointerHandler::handlePointerEventImpl(QQuickPointerEvent *event)
 */
 
 /*!
-    \qmlsignal QtQuick::PointerHandler::grabChanged(GrabState stateChange, EventPoint point)
+    \qmlsignal QtQuick::PointerHandler::grabChanged(GrabTransition transition, EventPoint point)
 
     This signal is emitted when the grab has changed in some way which is
     relevant to this handler.
 
-    The \a stateChange (verb) tells what happened.
+    The \a transition (verb) tells what happened.
     The \a point (object) is the point that was grabbed or ungrabbed.
 */
 
diff --git a/src/quick/handlers/qquickpointerhandler_p.h b/src/quick/handlers/qquickpointerhandler_p.h
index 69a38706b3..c600e42491 100644
--- a/src/quick/handlers/qquickpointerhandler_p.h
+++ b/src/quick/handlers/qquickpointerhandler_p.h
@@ -115,7 +115,7 @@ Q_SIGNALS:
     void activeChanged();
     void targetChanged();
     void marginChanged();
-    void grabChanged(QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point);
+    void grabChanged(QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point);
     void grabPermissionChanged();
     void canceled(QQuickEventPoint *point);
 
@@ -132,7 +132,7 @@ protected:
     void setActive(bool active);
     virtual void onTargetChanged(QQuickItem *oldTarget) { Q_UNUSED(oldTarget); }
     virtual void onActiveChanged() { }
-    virtual void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point);
+    virtual void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point);
     virtual bool canGrab(QQuickEventPoint *point);
     virtual bool approveGrabTransition(QQuickEventPoint *point, QObject *proposedGrabber);
     void setPassiveGrab(QQuickEventPoint *point, bool grab = true);
diff --git a/src/quick/handlers/qquicksinglepointhandler.cpp b/src/quick/handlers/qquicksinglepointhandler.cpp
index 177ad21079..2e264ec5b6 100644
--- a/src/quick/handlers/qquicksinglepointhandler.cpp
+++ b/src/quick/handlers/qquicksinglepointhandler.cpp
@@ -138,19 +138,19 @@ void QQuickSinglePointHandler::handlePointerEventImpl(QQuickPointerEvent *event)
     emit pointChanged();
 }
 
-void QQuickSinglePointHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point)
+void QQuickSinglePointHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point)
 {
     if (grabber != this)
         return;
-    switch (stateChange) {
+    switch (transition) {
     case QQuickEventPoint::GrabExclusive:
         m_pointInfo.m_sceneGrabPosition = point->sceneGrabPosition();
         setActive(true);
-        QQuickPointerHandler::onGrabChanged(grabber, stateChange, point);
+        QQuickPointerHandler::onGrabChanged(grabber, transition, point);
         break;
     case QQuickEventPoint::GrabPassive:
         m_pointInfo.m_sceneGrabPosition = point->sceneGrabPosition();
-        QQuickPointerHandler::onGrabChanged(grabber, stateChange, point);
+        QQuickPointerHandler::onGrabChanged(grabber, transition, point);
         break;
     case QQuickEventPoint::OverrideGrabPassive:
         return; // don't emit
@@ -159,7 +159,7 @@ void QQuickSinglePointHandler::onGrabChanged(QQuickPointerHandler *grabber, QQui
     case QQuickEventPoint::CancelGrabPassive:
     case QQuickEventPoint::CancelGrabExclusive:
         // the grab is lost or relinquished, so the point is no longer relevant
-        QQuickPointerHandler::onGrabChanged(grabber, stateChange, point);
+        QQuickPointerHandler::onGrabChanged(grabber, transition, point);
         reset();
         break;
     }
diff --git a/src/quick/handlers/qquicksinglepointhandler_p.h b/src/quick/handlers/qquicksinglepointhandler_p.h
index 6caf4294b8..028839ac04 100644
--- a/src/quick/handlers/qquicksinglepointhandler_p.h
+++ b/src/quick/handlers/qquicksinglepointhandler_p.h
@@ -75,7 +75,7 @@ protected:
     virtual void handleEventPoint(QQuickEventPoint *point) = 0;
 
     QQuickEventPoint *currentPoint(QQuickPointerEvent *ev) { return ev->pointById(m_pointInfo.m_id); }
-    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override;
+    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point) override;
 
     void setIgnoreAdditionalPoints(bool v = true);
 
diff --git a/src/quick/handlers/qquicktaphandler.cpp b/src/quick/handlers/qquicktaphandler.cpp
index 45240a62ab..e97722d6b7 100644
--- a/src/quick/handlers/qquicktaphandler.cpp
+++ b/src/quick/handlers/qquicktaphandler.cpp
@@ -313,10 +313,10 @@ void QQuickTapHandler::setPressed(bool press, bool cancel, QQuickEventPoint *poi
     }
 }
 
-void QQuickTapHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point)
+void QQuickTapHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point)
 {
-    QQuickSinglePointHandler::onGrabChanged(grabber, stateChange, point);
-    bool isCanceled = stateChange == QQuickEventPoint::CancelGrabExclusive || stateChange == QQuickEventPoint::CancelGrabPassive;
+    QQuickSinglePointHandler::onGrabChanged(grabber, transition, point);
+    bool isCanceled = transition == QQuickEventPoint::CancelGrabExclusive || transition == QQuickEventPoint::CancelGrabPassive;
     if (grabber == this && (isCanceled || point->state() == QQuickEventPoint::Released))
         setPressed(false, isCanceled, point);
 }
diff --git a/src/quick/handlers/qquicktaphandler_p.h b/src/quick/handlers/qquicktaphandler_p.h
index 954175f161..6ec5d55227 100644
--- a/src/quick/handlers/qquicktaphandler_p.h
+++ b/src/quick/handlers/qquicktaphandler_p.h
@@ -100,7 +100,7 @@ Q_SIGNALS:
     void longPressed();
 
 protected:
-    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override;
+    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabTransition transition, QQuickEventPoint *point) override;
     void timerEvent(QTimerEvent *event) override;
     bool wantsEventPoint(QQuickEventPoint *point) override;
     void handleEventPoint(QQuickEventPoint *point) override;
diff --git a/src/quick/items/qquickevents_p_p.h b/src/quick/items/qquickevents_p_p.h
index 4dec23d3ae..3623dcdf3a 100644
--- a/src/quick/items/qquickevents_p_p.h
+++ b/src/quick/items/qquickevents_p_p.h
@@ -281,7 +281,7 @@ public:
     Q_DECLARE_FLAGS(States, State)
     Q_FLAG(States)
 
-    enum GrabState {
+    enum GrabTransition {
         GrabPassive = 0x01,
         UngrabPassive = 0x02,
         CancelGrabPassive = 0x03,
@@ -290,7 +290,7 @@ public:
         UngrabExclusive = 0x20,
         CancelGrabExclusive = 0x30,
     };
-    Q_ENUM(GrabState)
+    Q_ENUM(GrabTransition)
 
     QQuickEventPoint(QQuickPointerEvent *parent);
 
diff --git a/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp b/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp
index 2a9ec272fa..e8b076052a 100644
--- a/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp
+++ b/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp
@@ -51,14 +51,14 @@ public:
     };
     Q_ENUM(Destination)
 
-    Event(Destination d, QEvent::Type t, Qt::TouchPointState s, int grabState, QPointF item, QPointF scene)
-        : destination(d), type(t), state(s), grabState(grabState), posWrtItem(item), posWrtScene(scene)
+    Event(Destination d, QEvent::Type t, Qt::TouchPointState s, int grabTransition, QPointF item, QPointF scene)
+        : destination(d), type(t), state(s), grabTransition(grabTransition), posWrtItem(item), posWrtScene(scene)
     {}
 
     Destination destination;
     QEvent::Type type;                      // if this represents a QEvent that was received
     Qt::TouchPointState state;              // if this represents an event (pointer, touch or mouse)
-    int grabState;                          // if this represents an onGrabChanged() notification (QQuickEventPoint::GrabState)
+    int grabTransition;                     // if this represents an onGrabChanged() notification (QQuickEventPoint::GrabTransition)
     QPointF posWrtItem;
     QPointF posWrtScene;
 };
@@ -73,9 +73,9 @@ QDebug operator<<(QDebug dbg, const class Event &event) {
     QtDebugUtils::formatQEnum(dbg, event.type);
     dbg << ' ';
     QtDebugUtils::formatQEnum(dbg, event.state);
-    if (event.grabState) {
+    if (event.grabTransition) {
         dbg << ' ';
-        QtDebugUtils::formatQEnum(dbg, QQuickEventPoint::GrabState(event.grabState));
+        QtDebugUtils::formatQEnum(dbg, QQuickEventPoint::GrabTransition(event.grabTransition));
     }
     dbg << " @ ";
     QtDebugUtils::formatQPoint(dbg, event.posWrtItem);
@@ -98,7 +98,7 @@ public:
         : QQuickItem(parent), acceptPointer(false), grabPointer(false), acceptMouse(false), acceptTouch(false), filterTouch(false)
     {}
 
-    inline int grabState(bool accept, Qt::TouchPointState state) {
+    inline int grabTransition(bool accept, Qt::TouchPointState state) {
         return (accept && (state != Qt::TouchPointReleased)) ? (int)QQuickEventPoint::GrabExclusive : (int)NoGrab;
     }
 
@@ -106,31 +106,31 @@ public:
     {
         qCDebug(lcPointerTests) << event << "will accept?" << acceptTouch;
         for (const QTouchEvent::TouchPoint &tp : event->touchPoints())
-            eventList.append(Event(Event::TouchDestination, event->type(), tp.state(), grabState(acceptTouch, tp.state()), tp.pos(), tp.scenePos()));
+            eventList.append(Event(Event::TouchDestination, event->type(), tp.state(), grabTransition(acceptTouch, tp.state()), tp.pos(), tp.scenePos()));
         event->setAccepted(acceptTouch);
     }
     void mousePressEvent(QMouseEvent *event)
     {
         qCDebug(lcPointerTests) << event;
-        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointPressed, grabState(acceptMouse, Qt::TouchPointPressed), event->pos(), event->windowPos()));
+        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointPressed, grabTransition(acceptMouse, Qt::TouchPointPressed), event->pos(), event->windowPos()));
         event->setAccepted(acceptMouse);
     }
     void mouseMoveEvent(QMouseEvent *event)
     {
         qCDebug(lcPointerTests) << event;
-        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointMoved, grabState(acceptMouse, Qt::TouchPointMoved), event->pos(), event->windowPos()));
+        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointMoved, grabTransition(acceptMouse, Qt::TouchPointMoved), event->pos(), event->windowPos()));
         event->setAccepted(acceptMouse);
     }
     void mouseReleaseEvent(QMouseEvent *event)
     {
         qCDebug(lcPointerTests) << event;
-        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointReleased, grabState(acceptMouse, Qt::TouchPointReleased), event->pos(), event->windowPos()));
+        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointReleased, grabTransition(acceptMouse, Qt::TouchPointReleased), event->pos(), event->windowPos()));
         event->setAccepted(acceptMouse);
     }
     void mouseDoubleClickEvent(QMouseEvent *event)
     {
         qCDebug(lcPointerTests) << event;
-        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointPressed, grabState(acceptMouse, Qt::TouchPointPressed), event->pos(), event->windowPos()));
+        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointPressed, grabTransition(acceptMouse, Qt::TouchPointPressed), event->pos(), event->windowPos()));
         event->setAccepted(acceptMouse);
     }
 
@@ -177,7 +177,7 @@ public:
         QCOMPARE(event.destination, d);\
         QCOMPARE(event.type, t);\
         QCOMPARE(event.state, s);\
-        QCOMPARE(event.grabState, g);\
+        QCOMPARE(event.grabTransition, g);\
     }\
 
 class EventHandler : public QQuickPointerHandler
@@ -204,7 +204,7 @@ class EventHandler : public QQuickPointerHandler
         }
     }
 
-    void onGrabChanged(QQuickPointerHandler *, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override
+    void onGrabChanged(QQuickPointerHandler *, QQuickEventPoint::GrabTransition stateChange, QQuickEventPoint *point) override
     {
         EventItem *item = static_cast<EventItem *>(target());
         item->eventList.append(Event(Event::HandlerDestination, QEvent::None,
diff --git a/tests/auto/quick/pointerhandlers/qquicktaphandler/tst_qquicktaphandler.cpp b/tests/auto/quick/pointerhandlers/qquicktaphandler/tst_qquicktaphandler.cpp
index f9970df9f0..467c964001 100644
--- a/tests/auto/quick/pointerhandlers/qquicktaphandler/tst_qquicktaphandler.cpp
+++ b/tests/auto/quick/pointerhandlers/qquicktaphandler/tst_qquicktaphandler.cpp
@@ -600,8 +600,8 @@ void tst_TapHandler::componentUserBehavioralOverride()
     QQuickTapHandler *userTapHandler = button->findChild<QQuickTapHandler*>("override");
     QVERIFY(userTapHandler);
     QSignalSpy tappedSpy(button, SIGNAL(tapped()));
-    QSignalSpy innerGrabChangedSpy(innerTapHandler, SIGNAL(grabChanged(QQuickEventPoint::GrabState, QQuickEventPoint *)));
-    QSignalSpy userGrabChangedSpy(userTapHandler, SIGNAL(grabChanged(QQuickEventPoint::GrabState, QQuickEventPoint *)));
+    QSignalSpy innerGrabChangedSpy(innerTapHandler, SIGNAL(grabChanged(QQuickEventPoint::GrabTransition, QQuickEventPoint *)));
+    QSignalSpy userGrabChangedSpy(userTapHandler, SIGNAL(grabChanged(QQuickEventPoint::GrabTransition, QQuickEventPoint *)));
     QSignalSpy innerPressedChangedSpy(innerTapHandler, SIGNAL(pressedChanged()));
     QSignalSpy userPressedChangedSpy(userTapHandler, SIGNAL(pressedChanged()));