Extend touch events.

The capability flags indicate which information is valid in the touch
points. Previously there was no way to tell if e.g. the value returned
by pressure() is actually the value provided by the driver/device or
it is just something bogus due to pressure not being supported.

The points' flags return information about the individual touch
points. One use case is to differentiate between touches made by
finger and pen.

Velocity, if available, is now also exposed.

Each touch point can now contain an additional list of "raw"
positions. These points are not reported individually but are taken
into account in some way by the underlying device and drivers to
generate the final, "accurate" touch point. In case the underlying
drivers expose these additional positions, they are made available in
the lists returned by the touch points' rawScreenPosition().

The raw positions are only available in screen coordinates to prevent
wasting time with mapping from global positions in applications that
do not use this data. Instead, apps can query the QWindow to which the
touch event was sent via QTouchEvent::window() and can call
mapFromGlobal() manually if they need local raw positions.

The capability and device type information is now held in a new
QTouchDevice class. Each touch event will contain only a pointer to
one of the global QTouchDevice instances. On top of type and
capability, the new class also contains a name which can be used to
differentiate between multiple touch input devices (i.e. to tell from
which one a given QTouchEvent originates from).

The introduction of QTouchDevice has three implications: The
QTouchEvent constructor and QWindowSystemInterface::handleTouchEvent
need to be changed (to pass a QTouchDevice pointer instead of merely a
device type value), and each platform or generic plug-in is now
responsible for registering one or more devices using the new API
QWindowSystemInterface::registerTouchDevice.

Change-Id: Ic1468d3e43933d8b5691d75aa67c43e1bc7ffe3e
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>

1 files changed, 23 insertions, 6 deletions

diff --git a/src/gui/kernel/qevent.h b/src/gui/kernel/qevent.h
index a79a56b771..6a0442509c 100644
--- a/src/gui/kernel/qevent.h
+++ b/src/gui/kernel/qevent.h
@@ -54,7 +54,8 @@
 #include <QtCore/qvector.h>
 #include <QtCore/qset.h>
 #include <QtCore/qfile.h>
-
+#include <QtGui/qvector2d.h>
+#include <QtGui/qtouchdevice.h>
 
 QT_BEGIN_HEADER
 
@@ -692,6 +693,11 @@ public:
     class Q_GUI_EXPORT TouchPoint
     {
     public:
+        enum InfoFlag {
+            Pen = 0x0001
+        };
+        Q_DECLARE_FLAGS(InfoFlags, InfoFlag)
+
         TouchPoint(int id = -1);
         TouchPoint(const QTouchEvent::TouchPoint &other);
         ~TouchPoint();
@@ -722,6 +728,9 @@ public:
         QRectF screenRect() const;
 
         qreal pressure() const;
+        QVector2D velocity() const;
+        InfoFlags flags() const;
+        QList<QPointF> rawScreenPositions() const;
 
         // internal
         void setId(int id);
@@ -742,6 +751,9 @@ public:
         void setSceneRect(const QRectF &sceneRect);
         void setScreenRect(const QRectF &screenRect);
         void setPressure(qreal pressure);
+        void setVelocity(const QVector2D &v);
+        void setFlags(InfoFlags flags);
+        void setRawScreenPositions(const QList<QPointF> &positions);
         QTouchEvent::TouchPoint &operator=(const QTouchEvent::TouchPoint &other);
 
     private:
@@ -752,32 +764,36 @@ public:
         friend class QApplicationPrivate;
     };
 
-    enum DeviceType {
+    QT_DEPRECATED enum DeviceType {
         TouchScreen,
         TouchPad
     };
 
     QTouchEvent(QEvent::Type eventType,
-                QTouchEvent::DeviceType deviceType = TouchScreen,
+                QTouchDevice *device = 0,
                 Qt::KeyboardModifiers modifiers = Qt::NoModifier,
                 Qt::TouchPointStates touchPointStates = 0,
                 const QList<QTouchEvent::TouchPoint> &touchPoints = QList<QTouchEvent::TouchPoint>());
     ~QTouchEvent();
 
     inline QWidget *widget() const { return _widget; }
-    inline QTouchEvent::DeviceType deviceType() const { return _deviceType; }
+    inline QWindow *window() const { return _window; }
+    QT_DEPRECATED inline QTouchEvent::DeviceType deviceType() const { return static_cast<DeviceType>(int(_device->type())); }
     inline Qt::TouchPointStates touchPointStates() const { return _touchPointStates; }
     inline const QList<QTouchEvent::TouchPoint> &touchPoints() const { return _touchPoints; }
+    inline QTouchDevice *device() const { return _device; }
 
     // internal
     inline void setWidget(QWidget *awidget) { _widget = awidget; }
-    inline void setDeviceType(DeviceType adeviceType) { _deviceType = adeviceType; }
+    inline void setWindow(QWindow *awindow) { _window = awindow; }
     inline void setTouchPointStates(Qt::TouchPointStates aTouchPointStates) { _touchPointStates = aTouchPointStates; }
     inline void setTouchPoints(const QList<QTouchEvent::TouchPoint> &atouchPoints) { _touchPoints = atouchPoints; }
+    inline void setDevice(QTouchDevice *device) { _device = device; }
 
 protected:
     QWidget *_widget;
-    QTouchEvent::DeviceType _deviceType;
+    QWindow *_window;
+    QTouchDevice *_device;
     Qt::TouchPointStates _touchPointStates;
     QList<QTouchEvent::TouchPoint> _touchPoints;
 
@@ -787,6 +803,7 @@ protected:
     friend class QApplicationPrivate;
 };
 
+Q_DECLARE_OPERATORS_FOR_FLAGS(QTouchEvent::TouchPoint::InfoFlags)
 
 class QScrollPrepareEventPrivate;
 class Q_GUI_EXPORT QScrollPrepareEvent : public QEvent