diff options
Diffstat (limited to 'src/quick/items/qquickevents_p_p.h')
| -rw-r--r-- | src/quick/items/qquickevents_p_p.h | 402 |
1 files changed, 386 insertions, 16 deletions
diff --git a/src/quick/items/qquickevents_p_p.h b/src/quick/items/qquickevents_p_p.h index b28ab555b0..61bbb4ecda 100644 --- a/src/quick/items/qquickevents_p_p.h +++ b/src/quick/items/qquickevents_p_p.h @@ -55,12 +55,20 @@ #include <qqml.h> #include <QtCore/qobject.h> +#include <QtCore/qpointer.h> #include <QtGui/qvector2d.h> #include <QtGui/qevent.h> #include <QtGui/qkeysequence.h> +#include <QtQuick/qquickitem.h> QT_BEGIN_NAMESPACE +class QQuickPointerDevice; +class QQuickPointerEvent; +class QQuickPointerMouseEvent; +class QQuickPointerTabletEvent; +class QQuickPointerTouchEvent; + class QQuickKeyEvent : public QObject { Q_OBJECT @@ -73,10 +81,22 @@ class QQuickKeyEvent : public QObject Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted) public: - QQuickKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, const QString &text=QString(), bool autorep=false, ushort count=1) - : event(type, key, modifiers, text, autorep, count) { event.setAccepted(false); } - QQuickKeyEvent(const QKeyEvent &ke) - : event(ke) { event.setAccepted(false); } + QQuickKeyEvent() + : event(QEvent::None, 0, 0) + {} + + void reset(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, + const QString &text = QString(), bool autorep = false, ushort count = 1) + { + event = QKeyEvent(type, key, modifiers, text, autorep, count); + event.setAccepted(false); + } + + void reset(const QKeyEvent &ke) + { + event = ke; + event.setAccepted(false); + } int key() const { return event.key(); } QString text() const { return event.text(); } @@ -109,10 +129,24 @@ class Q_QUICK_PRIVATE_EXPORT QQuickMouseEvent : public QObject Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted) public: - QQuickMouseEvent(qreal x, qreal y, Qt::MouseButton button, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers - , bool isClick=false, bool wasHeld=false) - : _x(x), _y(y), _button(button), _buttons(buttons), _modifiers(modifiers) - , _source(Qt::MouseEventNotSynthesized), _wasHeld(wasHeld), _isClick(isClick), _accepted(true) {} + QQuickMouseEvent() + : _x(0), _y(0), _button(Qt::NoButton), _buttons(Qt::NoButton), _modifiers(Qt::NoModifier) + , _source(Qt::MouseEventNotSynthesized), _wasHeld(false), _isClick(false), _accepted(false) + {} + + void reset(qreal x, qreal y, Qt::MouseButton button, Qt::MouseButtons buttons, + Qt::KeyboardModifiers modifiers, bool isClick = false, bool wasHeld = false) + { + _x = x; + _y = y; + _button = button; + _buttons = buttons; + _modifiers = modifiers; + _source = Qt::MouseEventNotSynthesized; + _wasHeld = wasHeld; + _isClick = isClick; + _accepted = true; + } qreal x() const { return _x; } qreal y() const { return _y; } @@ -139,9 +173,9 @@ private: Qt::MouseButtons _buttons; Qt::KeyboardModifiers _modifiers; Qt::MouseEventSource _source; - bool _wasHeld; - bool _isClick; - bool _accepted; + bool _wasHeld : 1; + bool _isClick : 1; + bool _accepted : 1; }; class QQuickWheelEvent : public QObject @@ -153,13 +187,27 @@ class QQuickWheelEvent : public QObject Q_PROPERTY(QPoint pixelDelta READ pixelDelta) Q_PROPERTY(int buttons READ buttons) Q_PROPERTY(int modifiers READ modifiers) + Q_PROPERTY(bool inverted READ inverted) Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted) public: - QQuickWheelEvent(qreal x, qreal y, const QPoint& angleDelta, const QPoint& pixelDelta, - Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers) - : _x(x), _y(y), _angleDelta(angleDelta), _pixelDelta(pixelDelta), _buttons(buttons), - _modifiers(modifiers), _accepted(true) {} + QQuickWheelEvent() + : _x(0), _y(0), _buttons(Qt::NoButton), _modifiers(Qt::NoModifier) + , _inverted(false), _accepted(false) + {} + + void reset(qreal x, qreal y, const QPoint &angleDelta, const QPoint &pixelDelta, + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, bool inverted) + { + _x = x; + _y = y; + _angleDelta = angleDelta; + _pixelDelta = pixelDelta; + _buttons = buttons; + _modifiers = modifiers; + _accepted = true; + _inverted = inverted; + } qreal x() const { return _x; } qreal y() const { return _y; } @@ -167,7 +215,7 @@ public: QPoint pixelDelta() const { return _pixelDelta; } int buttons() const { return _buttons; } int modifiers() const { return _modifiers; } - + bool inverted() const { return _inverted; } bool isAccepted() { return _accepted; } void setAccepted(bool accepted) { _accepted = accepted; } @@ -178,13 +226,335 @@ private: QPoint _pixelDelta; Qt::MouseButtons _buttons; Qt::KeyboardModifiers _modifiers; + bool _inverted; + bool _accepted; +}; + +class Q_QUICK_PRIVATE_EXPORT QQuickCloseEvent : public QObject +{ + Q_OBJECT + Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted) + +public: + QQuickCloseEvent() + : _accepted(true) {} + + bool isAccepted() { return _accepted; } + void setAccepted(bool accepted) { _accepted = accepted; } + +private: bool _accepted; }; +class Q_QUICK_PRIVATE_EXPORT QQuickEventPoint : public QObject +{ + Q_OBJECT + Q_PROPERTY(QPointF scenePos READ scenePos) + Q_PROPERTY(State state READ state) + Q_PROPERTY(quint64 pointId READ pointId) + Q_PROPERTY(qreal timeHeld READ timeHeld) + Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted) + Q_PROPERTY(QQuickItem *grabber READ grabber WRITE setGrabber) + +public: + enum State { + Pressed = Qt::TouchPointPressed, + Updated = Qt::TouchPointMoved, + Stationary = Qt::TouchPointStationary, + Released = Qt::TouchPointReleased + // Canceled = Qt::TouchPointReleased << 1 // 0x10 // TODO maybe + }; + Q_ENUM(State) + + QQuickEventPoint(QQuickPointerEvent *parent); + + void reset(Qt::TouchPointState state, QPointF scenePos, quint64 pointId, ulong timestamp); + + void invalidate() { m_valid = false; } + + QQuickPointerEvent *pointerEvent() const; + QPointF scenePos() const { return m_scenePos; } + State state() const { return m_state; } + quint64 pointId() const { return m_pointId; } + bool isValid() const { return m_valid; } + qreal timeHeld() const { return (m_timestamp - m_pressTimestamp) / 1000.0; } + bool isAccepted() const { return m_accept; } + void setAccepted(bool accepted = true); + QQuickItem *grabber() const; + void setGrabber(QQuickItem *grabber); + +private: + QPointF m_scenePos; + quint64 m_pointId; + QPointer<QQuickItem> m_grabber; + ulong m_timestamp; + ulong m_pressTimestamp; + State m_state; + bool m_valid : 1; + bool m_accept : 1; + int m_reserved : 30; + + Q_DISABLE_COPY(QQuickEventPoint) +}; + +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(QQuickPointerTouchEvent *parent); + + void reset(const QTouchEvent::TouchPoint &tp, ulong timestamp); + + 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; + + Q_DISABLE_COPY(QQuickEventTouchPoint) +}; + +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) + { } + + virtual ~QQuickPointerEvent(); + +public: // property accessors + 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; } + +public: // helpers for C++ only (during event delivery) + virtual QQuickPointerEvent *reset(QEvent *ev) = 0; + + virtual bool isPressEvent() const = 0; + virtual QQuickPointerMouseEvent *asPointerMouseEvent() { return nullptr; } + virtual QQuickPointerTouchEvent *asPointerTouchEvent() { return nullptr; } + virtual QQuickPointerTabletEvent *asPointerTabletEvent() { return nullptr; } + virtual const QQuickPointerMouseEvent *asPointerMouseEvent() const { return nullptr; } + virtual const QQuickPointerTouchEvent *asPointerTouchEvent() const { return nullptr; } + virtual const QQuickPointerTabletEvent *asPointerTabletEvent() const { return nullptr; } + bool isValid() const { return m_event != nullptr; } + virtual bool allPointsAccepted() const = 0; + bool isAccepted() { return m_event->isAccepted(); } + void setAccepted(bool accepted) { m_event->setAccepted(accepted); } + QVector<QPointF> unacceptedPressedPointScenePositions() const; + + virtual int pointCount() const = 0; + virtual QQuickEventPoint *point(int i) const = 0; + virtual QQuickEventPoint *pointById(quint64 pointId) const = 0; + virtual QVector<QQuickItem *> grabbers() const = 0; + virtual void clearGrabbers() const = 0; + + ulong timestamp() const { return m_event->timestamp(); } + +protected: + QQuickPointerDevice *m_device; + QInputEvent *m_event; // original event as received by QQuickWindow + Qt::MouseButton m_button; + Qt::MouseButtons m_pressedButtons; + + Q_DISABLE_COPY(QQuickPointerEvent) +}; + +class Q_QUICK_PRIVATE_EXPORT QQuickPointerMouseEvent : public QQuickPointerEvent +{ + Q_OBJECT +public: + QQuickPointerMouseEvent(QObject *parent = nullptr) + : QQuickPointerEvent(parent), m_mousePoint(new QQuickEventPoint(this)) { } + + QQuickPointerEvent *reset(QEvent *) override; + bool isPressEvent() const override; + QQuickPointerMouseEvent *asPointerMouseEvent() override { return this; } + const QQuickPointerMouseEvent *asPointerMouseEvent() const override { return this; } + int pointCount() const override { return 1; } + QQuickEventPoint *point(int i) const override; + QQuickEventPoint *pointById(quint64 pointId) const override; + bool allPointsAccepted() const override; + QVector<QQuickItem *> grabbers() const override; + void clearGrabbers() const override; + + QMouseEvent *asMouseEvent(const QPointF& localPos) const; + +private: + QQuickEventPoint *m_mousePoint; + + Q_DISABLE_COPY(QQuickPointerMouseEvent) +}; + +class Q_QUICK_PRIVATE_EXPORT QQuickPointerTouchEvent : public QQuickPointerEvent +{ + Q_OBJECT +public: + QQuickPointerTouchEvent(QObject *parent = nullptr) + : QQuickPointerEvent(parent) + , m_pointCount(0) + , m_synthMouseEvent(QEvent::MouseMove, QPointF(), Qt::NoButton, Qt::NoButton, Qt::NoModifier) + { } + + QQuickPointerEvent *reset(QEvent *) override; + bool isPressEvent() const override; + QQuickPointerTouchEvent *asPointerTouchEvent() override { return this; } + const QQuickPointerTouchEvent *asPointerTouchEvent() const override { return this; } + int pointCount() const override { return m_pointCount; } + QQuickEventPoint *point(int i) const override; + QQuickEventPoint *pointById(quint64 pointId) const override; + const QTouchEvent::TouchPoint *touchPointById(int pointId) const; + bool allPointsAccepted() const override; + QVector<QQuickItem *> grabbers() const override; + void clearGrabbers() const override; + + QMouseEvent *syntheticMouseEvent(int pointID, QQuickItem *relativeTo) const; + QTouchEvent *touchEventForItem(QQuickItem *item, bool isFiltering = false) const; + + QTouchEvent *asTouchEvent() const; + +private: + int m_pointCount; + QVector<QQuickEventTouchPoint *> m_touchPoints; + mutable QMouseEvent m_synthMouseEvent; + + Q_DISABLE_COPY(QQuickPointerTouchEvent) +}; + +// ### 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 = QTouchDevice::Position, + Area = QTouchDevice::Area, + Pressure = QTouchDevice::Pressure, + Velocity = QTouchDevice::Velocity, + // 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), m_event(nullptr) + { + if (m_deviceType == Mouse) { + m_event = new QQuickPointerMouseEvent; + } else if (m_deviceType == TouchScreen || m_deviceType == TouchPad) { + m_event = new QQuickPointerTouchEvent; + } else { + Q_ASSERT(false); + } + } + + ~QQuickPointerDevice() { delete m_event; } + 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; } + QQuickPointerEvent *pointerEvent() const { return m_event; } + + static QQuickPointerDevice *touchDevice(QTouchDevice *d); + static QList<QQuickPointerDevice *> touchDevices(); + static QQuickPointerDevice *genericMouseDevice(); + static QQuickPointerDevice *tabletDevice(qint64); + +private: + DeviceType m_deviceType; + PointerType m_pointerType; + Capabilities m_capabilities; + int m_maximumTouchPoints; + int m_buttonCount; + QString m_name; + qint64 m_uniqueId; + // the device-specific event instance which is reused during event delivery + QQuickPointerEvent *m_event; + + 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) + +Q_QUICK_PRIVATE_EXPORT QDebug operator<<(QDebug, const QQuickPointerDevice *); +Q_QUICK_PRIVATE_EXPORT QDebug operator<<(QDebug, const QQuickPointerEvent *); +Q_QUICK_PRIVATE_EXPORT QDebug operator<<(QDebug, const QQuickEventPoint *); +//Q_QUICK_PRIVATE_EXPORT QDebug operator<<(QDebug, const QQuickEventTouchPoint *); TODO maybe + QT_END_NAMESPACE QML_DECLARE_TYPE(QQuickKeyEvent) QML_DECLARE_TYPE(QQuickMouseEvent) QML_DECLARE_TYPE(QQuickWheelEvent) +QML_DECLARE_TYPE(QQuickCloseEvent) +QML_DECLARE_TYPE(QQuickPointerDevice) +QML_DECLARE_TYPE(QPointerUniqueId) +QML_DECLARE_TYPE(QQuickPointerEvent) #endif // QQUICKEVENTS_P_P_H |