diff options
Diffstat (limited to 'src/quick/items/qquickevents_p_p.h')
-rw-r--r-- | src/quick/items/qquickevents_p_p.h | 258 |
1 files changed, 258 insertions, 0 deletions
diff --git a/src/quick/items/qquickevents_p_p.h b/src/quick/items/qquickevents_p_p.h index 39c5a060b5..979d6e441a 100644 --- a/src/quick/items/qquickevents_p_p.h +++ b/src/quick/items/qquickevents_p_p.h @@ -222,10 +222,268 @@ private: bool _accepted; }; +// ### Qt 6: move this to qtbase, replace QTouchDevice and the enums in QTabletEvent +class Q_QUICK_PRIVATE_EXPORT QQuickPointerDevice : public QObject +{ + Q_OBJECT + Q_PROPERTY(DeviceType type READ type CONSTANT) + Q_PROPERTY(PointerType pointerType READ pointerType CONSTANT) + Q_PROPERTY(Capabilities capabilities READ capabilities CONSTANT) + Q_PROPERTY(int maximumTouchPoints READ maximumTouchPoints CONSTANT) + Q_PROPERTY(int buttonCount READ buttonCount CONSTANT) + Q_PROPERTY(QString name READ name CONSTANT) + Q_PROPERTY(qint64 uniqueId READ uniqueId CONSTANT) + +public: + enum DeviceType { + UnknownDevice = 0x0000, + Mouse = 0x0001, + TouchScreen = 0x0002, + TouchPad = 0x0004, + Puck = 0x0008, + Stylus = 0x0010, + Airbrush = 0x0020, + AllDevices = 0x003F + }; + Q_DECLARE_FLAGS(DeviceTypes, DeviceType) + Q_ENUM(DeviceType) + Q_FLAG(DeviceTypes) + + enum PointerType { + GenericPointer = 0x0001, + Finger = 0x0002, + Pen = 0x0004, + Eraser = 0x0008, + Cursor = 0x0010, + AllPointerTypes = 0x001F + }; + Q_DECLARE_FLAGS(PointerTypes, PointerType) + Q_ENUM(PointerType) + Q_FLAG(PointerTypes) + + enum CapabilityFlag { + Position = 0x0001, + Area = 0x0002, + Pressure = 0x0004, + Velocity = 0x0008, + // some bits reserved in case we need more of QTouchDevice::Capabilities + Scroll = 0x0100, // mouse has a wheel, or there is OS-level scroll gesture recognition (dubious?) + Hover = 0x0200, + Rotation = 0x0400, + XTilt = 0x0800, + YTilt = 0x1000 + }; + Q_DECLARE_FLAGS(Capabilities, CapabilityFlag) + Q_ENUM(CapabilityFlag) + Q_FLAG(Capabilities) + + QQuickPointerDevice(DeviceType devType, PointerType pType, Capabilities caps, int maxPoints, int buttonCount, const QString &name, qint64 uniqueId = 0) + : m_deviceType(devType), m_pointerType(pType), m_capabilities(caps) + , m_maximumTouchPoints(maxPoints), m_buttonCount(buttonCount), m_name(name), m_uniqueId(uniqueId) + {} + + ~QQuickPointerDevice() { } + DeviceType type() const { return m_deviceType; } + PointerType pointerType() const { return m_pointerType; } + Capabilities capabilities() const { return m_capabilities; } + bool hasCapability(CapabilityFlag cap) { return m_capabilities & cap; } + int maximumTouchPoints() const { return m_maximumTouchPoints; } + int buttonCount() const { return m_buttonCount; } + QString name() const { return m_name; } + qint64 uniqueId() const { return m_uniqueId; } + +private: + DeviceType m_deviceType; + PointerType m_pointerType; + Capabilities m_capabilities; + int m_maximumTouchPoints; + int m_buttonCount; + QString m_name; + qint64 m_uniqueId; + + Q_DISABLE_COPY(QQuickPointerDevice) +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickPointerDevice::DeviceTypes) +Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickPointerDevice::PointerTypes) +Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickPointerDevice::Capabilities) + +class Q_QUICK_PRIVATE_EXPORT QQuickEventPoint : public QObject +{ + Q_OBJECT + Q_PROPERTY(QPointF scenePos READ scenePos) + Q_PROPERTY(Qt::TouchPointState state READ state) + Q_PROPERTY(quint64 pointId READ pointId) + Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted) + +public: + QQuickEventPoint() : QObject(), m_pointId(0), m_valid(false), m_accept(false), m_state(Qt::TouchPointReleased) + { + Q_UNUSED(m_reserved); + } + + void reset(Qt::TouchPointState state, QPointF scenePos, quint64 pointId) + { + m_scenePos = scenePos; + m_pointId = pointId; + m_valid = true; + m_accept = false; + m_state = state; + } + + void invalidate() { m_valid = false; } + + QPointF scenePos() const { return m_scenePos; } + Qt::TouchPointState state() const { return m_state; } + quint64 pointId() const { return m_pointId; } + bool isValid() const { return m_valid; } + bool isAccepted() const { return m_accept; } + void setAccepted(bool accepted) { m_accept = accepted; } + +private: + QPointF m_scenePos; + quint64 m_pointId; + bool m_valid : 1; + bool m_accept : 1; + Qt::TouchPointState m_state : 4; + int m_reserved : 26; +}; + +class Q_QUICK_PRIVATE_EXPORT QQuickEventTouchPoint : public QQuickEventPoint +{ + Q_OBJECT + Q_PROPERTY(qreal rotation READ rotation) + Q_PROPERTY(qreal pressure READ pressure) + Q_PROPERTY(QPointerUniqueId uniqueId READ uniqueId) + +public: + QQuickEventTouchPoint() : QQuickEventPoint(), m_rotation(0), m_pressure(0) { } + + void reset(const QTouchEvent::TouchPoint &tp) + { + QQuickEventPoint::reset(tp.state(), tp.scenePos(), tp.id()); + // TODO times and velocity + m_rotation = tp.rotation(); + m_pressure = tp.pressure(); + m_uniqueId = tp.uniqueId(); + } + + qreal rotation() const { return m_rotation; } + qreal pressure() const { return m_pressure; } + QPointerUniqueId uniqueId() const { return m_uniqueId; } + +private: + qreal m_rotation; + qreal m_pressure; + QPointerUniqueId m_uniqueId; +}; + +class Q_QUICK_PRIVATE_EXPORT QQuickPointerEvent : public QObject +{ + Q_OBJECT + Q_PROPERTY(const QQuickPointerDevice *device READ device) + Q_PROPERTY(Qt::KeyboardModifiers modifiers READ modifiers) + Q_PROPERTY(Qt::MouseButtons button READ button) + Q_PROPERTY(Qt::MouseButtons buttons READ buttons) + +public: + QQuickPointerEvent(QObject *parent = nullptr) + : QObject(parent) + , m_device(nullptr) + , m_event(nullptr) + , m_button(Qt::NoButton) + , m_pressedButtons(Qt::NoButton) + , m_mousePoint(nullptr) { } + + void reset(const QQuickPointerDevice* dev, const QMouseEvent *ev) { + m_device = dev; + m_event = ev; + m_button = ev->button(); + m_pressedButtons = ev->buttons(); + Qt::TouchPointState state = Qt::TouchPointStationary; + switch (ev->type()) { + case QEvent::MouseButtonPress: + state = Qt::TouchPointPressed; + break; + case QEvent::MouseButtonRelease: + state = Qt::TouchPointReleased; + break; + case QEvent::MouseMove: + state = Qt::TouchPointMoved; + break; + default: + break; + } + + if (!m_mousePoint) + m_mousePoint = new QQuickEventPoint; + m_mousePoint->reset(state, ev->windowPos(), 0); // mouse is 0 + } + + void reset(const QQuickPointerDevice* dev, const QTouchEvent *ev) { + m_device = dev; + m_event = ev; + m_button = Qt::NoButton; + m_pressedButtons = Qt::NoButton; + + const QList<QTouchEvent::TouchPoint> &tps = ev->touchPoints(); + const int pointCount = tps.count(); + while (pointCount > m_touchPoints.count()) + m_touchPoints.append(new QQuickEventTouchPoint); + + for (int i = 0; i < pointCount; ++i) + m_touchPoints.at(i)->reset(tps.at(i)); + } + + const QQuickPointerDevice *device() const { return m_device; } + Qt::KeyboardModifiers modifiers() const { return m_event ? m_event->modifiers() : Qt::NoModifier; } + Qt::MouseButton button() const { return m_button; } + Qt::MouseButtons buttons() const { return m_pressedButtons; } + + const QTouchEvent *asTouchEvent() const { + if (!m_event) + return nullptr; + switch (m_event->type()) { + case QEvent::TouchBegin: + case QEvent::TouchCancel: + case QEvent::TouchUpdate: + case QEvent::TouchEnd: + return static_cast<const QTouchEvent *>(m_event); + default: + break; + } + return nullptr; + } + + // helpers for C++ event delivery, not for QML properties + int pointCount() const { return asTouchEvent() ? m_touchPoints.count() : 1; } + const QQuickEventPoint *point(int i) const { + if (asTouchEvent()) + return m_touchPoints.at(i); + return i == 0 ? m_mousePoint : nullptr; + } + +protected: + bool isValid() const { return m_event != nullptr; } + +protected: + const QQuickPointerDevice *m_device; + const QInputEvent *m_event; // original event as received by QQuickWindow + Qt::MouseButton m_button; + Qt::MouseButtons m_pressedButtons; + QVector<QQuickEventTouchPoint *> m_touchPoints; + QQuickEventPoint *m_mousePoint; + + Q_DISABLE_COPY(QQuickPointerEvent) +}; + QT_END_NAMESPACE QML_DECLARE_TYPE(QQuickKeyEvent) QML_DECLARE_TYPE(QQuickMouseEvent) QML_DECLARE_TYPE(QQuickWheelEvent) +QML_DECLARE_TYPE(QQuickPointerDevice) +QML_DECLARE_TYPE(QPointerUniqueId) +QML_DECLARE_TYPE(QQuickPointerEvent) #endif // QQUICKEVENTS_P_P_H |