Refactor pointer event hierarchy

Some goals that have hopefully been achieved are:
- make QPointerEvent and QEventPoint resemble their Qt Quick
  counterparts to such an extent that we can remove those wrappers
  and go back to delivering the original events in Qt Quick
- make QEventPoint much smaller than QTouchEvent::TouchPoint, with no pimpl
- remove most public setters
- reduce the usage of complex constructors that take many arguments
- don't repeat ourselves: move accessors and storage upwards
  rather than having redundant ones in subclasses
- standardize the set of accessors in QPointerEvent
- maintain source compatibility as much as possible: do not require
  modifying event-handling code in any QWidget subclass

To avoid public setters we now introduce a few QMutable* subclasses.
This is a bit like the Builder pattern except that it doesn't involve
constructing a separate disposable object: the main event type can be
cast to the mutable type at any time to enable modifications, iff the
code is linked with gui-private. Therefore event classes can have
less-"complete" constructors, because internal Qt code can use setters
the same way it could use the ones in QTouchEvent before; and the event
classes don't need many friends. Even some read-accessors can be kept
private unless we are sure we want to expose them.

Task-number: QTBUG-46266
Fixes: QTBUG-72173
Change-Id: I740e4e40165b7bc41223d38b200bbc2b403e07b6
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

2 files changed, 50 insertions, 45 deletions

diff --git a/src/testlib/qtestmouse.h b/src/testlib/qtestmouse.h
index e3e446577d..4848462be6 100644
--- a/src/testlib/qtestmouse.h
+++ b/src/testlib/qtestmouse.h
@@ -211,20 +211,20 @@ namespace QTest
 
         stateKey &= static_cast<unsigned int>(Qt::KeyboardModifierMask);
 
-        QMouseEvent me(QEvent::User, QPoint(), Qt::LeftButton, button, stateKey);
+        QMouseEvent me(QEvent::User, QPointF(), Qt::LeftButton, QTestPrivate::qtestMouseButtons, stateKey, QPointingDevice::primaryPointingDevice());
         switch (action)
         {
             case MousePress:
-                me = QMouseEvent(QEvent::MouseButtonPress, pos, widget->mapToGlobal(pos), button, button, stateKey);
+                me = QMouseEvent(QEvent::MouseButtonPress, pos, widget->mapToGlobal(pos), button, button, stateKey, QPointingDevice::primaryPointingDevice());
                 me.setTimestamp(++lastMouseTimestamp);
                 break;
             case MouseRelease:
-                me = QMouseEvent(QEvent::MouseButtonRelease, pos, widget->mapToGlobal(pos), button, Qt::MouseButton(), stateKey);
+                me = QMouseEvent(QEvent::MouseButtonRelease, pos, widget->mapToGlobal(pos), button, Qt::MouseButton(), stateKey, QPointingDevice::primaryPointingDevice());
                 me.setTimestamp(++lastMouseTimestamp);
                 lastMouseTimestamp += mouseDoubleClickInterval; // avoid double clicks being generated
                 break;
             case MouseDClick:
-                me = QMouseEvent(QEvent::MouseButtonDblClick, pos, widget->mapToGlobal(pos), button, button, stateKey);
+                me = QMouseEvent(QEvent::MouseButtonDblClick, pos, widget->mapToGlobal(pos), button, button, stateKey, QPointingDevice::primaryPointingDevice());
                 me.setTimestamp(++lastMouseTimestamp);
                 break;
             case MouseMove:
diff --git a/src/testlib/qtesttouch.h b/src/testlib/qtesttouch.h
index 6db7fb52ec..f976a6ef0a 100644
--- a/src/testlib/qtesttouch.h
+++ b/src/testlib/qtesttouch.h
@@ -61,7 +61,7 @@
 QT_BEGIN_NAMESPACE
 
 Q_GUI_EXPORT  void qt_handleTouchEvent(QWindow *w, const QPointingDevice *device,
-                                const QList<QTouchEvent::TouchPoint> &points,
+                                const QList<QEventPoint> &points,
                                 Qt::KeyboardModifiers mods = Qt::NoModifier);
 
 
@@ -81,52 +81,52 @@ namespace QTest
         }
         QTouchEventSequence& press(int touchId, const QPoint &pt, QWindow *window = nullptr)
         {
-            QTouchEvent::TouchPoint &p = point(touchId);
-            p.setScreenPos(mapToScreen(window, pt));
-            p.setState(Qt::TouchPointPressed);
+            QEventPoint &p = point(touchId);
+            p.m_globalPos = mapToScreen(window, pt);
+            p.m_state = QEventPoint::State::Pressed;
             return *this;
         }
         QTouchEventSequence& move(int touchId, const QPoint &pt, QWindow *window = nullptr)
         {
-            QTouchEvent::TouchPoint &p = point(touchId);
-            p.setScreenPos(mapToScreen(window, pt));
-            p.setState(Qt::TouchPointMoved);
+            QEventPoint &p = point(touchId);
+            p.m_globalPos = mapToScreen(window, pt);
+            p.m_state = QEventPoint::State::Updated;
             return *this;
         }
         QTouchEventSequence& release(int touchId, const QPoint &pt, QWindow *window = nullptr)
         {
-            QTouchEvent::TouchPoint &p = point(touchId);
-            p.setScreenPos(mapToScreen(window, pt));
-            p.setState(Qt::TouchPointReleased);
+            QEventPoint &p = point(touchId);
+            p.m_globalPos = mapToScreen(window, pt);
+            p.m_state = QEventPoint::State::Released;
             return *this;
         }
         QTouchEventSequence& stationary(int touchId)
         {
-            QTouchEvent::TouchPoint &p = pointOrPreviousPoint(touchId);
-            p.setState(Qt::TouchPointStationary);
+            QEventPoint &p = pointOrPreviousPoint(touchId);
+            p.m_state = QEventPoint::State::Stationary;
             return *this;
         }
 
 #ifdef QT_WIDGETS_LIB
         QTouchEventSequence& press(int touchId, const QPoint &pt, QWidget *widget = nullptr)
         {
-            QTouchEvent::TouchPoint &p = point(touchId);
-            p.setScreenPos(mapToScreen(widget, pt));
-            p.setState(Qt::TouchPointPressed);
+            QEventPoint &p = point(touchId);
+            p.m_globalPos = mapToScreen(widget, pt);
+            p.m_state = QEventPoint::State::Pressed;
             return *this;
         }
         QTouchEventSequence& move(int touchId, const QPoint &pt, QWidget *widget = nullptr)
         {
-            QTouchEvent::TouchPoint &p = point(touchId);
-            p.setScreenPos(mapToScreen(widget, pt));
-            p.setState(Qt::TouchPointMoved);
+            QEventPoint &p = point(touchId);
+            p.m_globalPos = mapToScreen(widget, pt);
+            p.m_state = QEventPoint::State::Updated;
             return *this;
         }
         QTouchEventSequence& release(int touchId, const QPoint &pt, QWidget *widget = nullptr)
         {
-            QTouchEvent::TouchPoint &p = point(touchId);
-            p.setScreenPos(mapToScreen(widget, pt));
-            p.setState(Qt::TouchPointReleased);
+            QEventPoint &p = point(touchId);
+            p.m_globalPos = mapToScreen(widget, pt);
+            p.m_state = QEventPoint::State::Released;
             return *this;
         }
 #endif
@@ -168,24 +168,6 @@ private:
         {
         }
 
-        QTouchEvent::TouchPoint &point(int touchId)
-        {
-            if (!points.contains(touchId))
-                points[touchId] = QTouchEvent::TouchPoint(touchId);
-            return points[touchId];
-        }
-
-        QTouchEvent::TouchPoint &pointOrPreviousPoint(int touchId)
-        {
-            if (!points.contains(touchId)) {
-                if (previousPoints.contains(touchId))
-                    points[touchId] = previousPoints.value(touchId);
-                else
-                    points[touchId] = QTouchEvent::TouchPoint(touchId);
-            }
-            return points[touchId];
-        }
-
 #ifdef QT_WIDGETS_LIB
         QPoint mapToScreen(QWidget *widget, const QPoint &pt)
         {
@@ -201,8 +183,8 @@ private:
             return targetWindow ? targetWindow->mapToGlobal(pt) : pt;
         }
 
-        QMap<int, QTouchEvent::TouchPoint> previousPoints;
-        QMap<int, QTouchEvent::TouchPoint> points;
+        QMap<int, QEventPoint> previousPoints;
+        QMap<int, QEventPoint> points;
 #ifdef QT_WIDGETS_LIB
         QWidget *targetWidget;
 #endif
@@ -213,6 +195,29 @@ private:
         friend QTouchEventSequence touchEvent(QWidget *widget, QPointingDevice *device, bool autoCommit);
 #endif
         friend QTouchEventSequence touchEvent(QWindow *window, QPointingDevice *device, bool autoCommit);
+
+    protected:
+        // These don't make sense for public testing API,
+        // because we are getting rid of most public setters in QEventPoint.
+        // Each of these constructs a QEventPoint with null parent; in normal usage,
+        // the QTouchEvent constructor will set the points' parents to itself, later on.
+        QEventPoint &point(int touchId)
+        {
+            if (!points.contains(touchId))
+                points[touchId] = QEventPoint(touchId);
+            return points[touchId];
+        }
+
+        QEventPoint &pointOrPreviousPoint(int touchId)
+        {
+            if (!points.contains(touchId)) {
+                if (previousPoints.contains(touchId))
+                    points[touchId] = previousPoints.value(touchId);
+                else
+                    points[touchId] = QEventPoint(touchId);
+            }
+            return points[touchId];
+        }
     };
 
 #if defined(QT_WIDGETS_LIB) || defined(Q_CLANG_QDOC)