diff options
Diffstat (limited to 'src/gui/kernel/qevent.h')
| -rw-r--r-- | src/gui/kernel/qevent.h | 879 |
1 files changed, 430 insertions, 449 deletions
diff --git a/src/gui/kernel/qevent.h b/src/gui/kernel/qevent.h index baf39439df..a24f0c471c 100644 --- a/src/gui/kernel/qevent.h +++ b/src/gui/kernel/qevent.h @@ -1,45 +1,13 @@ -/**************************************************************************** -** -** Copyright (C) 2020 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtGui module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #ifndef QEVENT_H #define QEVENT_H +#if 0 +#pragma qt_class(QtEvents) +#endif + #include <QtGui/qtguiglobal.h> #include <QtCore/qcoreevent.h> @@ -49,58 +17,156 @@ #include <QtCore/qstring.h> #include <QtCore/qurl.h> #include <QtCore/qvariant.h> +#include <QtGui/qeventpoint.h> #include <QtGui/qpointingdevice.h> #include <QtGui/qregion.h> -#include <QtGui/qvector2d.h> #include <QtGui/qwindowdefs.h> #if QT_CONFIG(shortcut) # include <QtGui/qkeysequence.h> #endif +class tst_QEvent; + QT_BEGIN_NAMESPACE class QFile; class QAction; -class QInputDevice; -class QPointingDevice; +class QMouseEvent; +template <typename T> class QPointer; +class QPointerEvent; class QScreen; +#if QT_CONFIG(shortcut) +class QShortcut; +#endif +class QTabletEvent; +class QTouchEvent; #if QT_CONFIG(gestures) class QGesture; #endif class Q_GUI_EXPORT QInputEvent : public QEvent { + Q_DECL_EVENT_COMMON(QInputEvent) public: explicit QInputEvent(Type type, const QInputDevice *m_dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier); - ~QInputEvent(); + const QInputDevice *device() const { return m_dev; } QInputDevice::DeviceType deviceType() const { return m_dev ? m_dev->type() : QInputDevice::DeviceType::Unknown; } - inline Qt::KeyboardModifiers modifiers() const { return modState; } - inline void setModifiers(Qt::KeyboardModifiers amodifiers) { modState = amodifiers; } - inline ulong timestamp() const { return ts; } - inline void setTimestamp(ulong atimestamp) { ts = atimestamp; } + inline Qt::KeyboardModifiers modifiers() const { return m_modState; } + inline void setModifiers(Qt::KeyboardModifiers modifiers) { m_modState = modifiers; } + inline quint64 timestamp() const { return m_timeStamp; } + virtual void setTimestamp(quint64 timestamp) { m_timeStamp = timestamp; } + protected: + QInputEvent(Type type, PointerEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier); + QInputEvent(Type type, SinglePointEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier); + const QInputDevice *m_dev = nullptr; - Qt::KeyboardModifiers modState; - ulong ts; + quint64 m_timeStamp = 0; + Qt::KeyboardModifiers m_modState = Qt::NoModifier; + // fill up to the closest 8-byte aligned size: 48 + quint32 m_reserved = 0; }; class Q_GUI_EXPORT QPointerEvent : public QInputEvent { + Q_GADGET + Q_DECL_EVENT_COMMON(QPointerEvent) public: - explicit QPointerEvent(Type type, const QPointingDevice *dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier); + explicit QPointerEvent(Type type, const QPointingDevice *dev, + Qt::KeyboardModifiers modifiers = Qt::NoModifier, const QList<QEventPoint> &points = {}); + const QPointingDevice *pointingDevice() const; QPointingDevice::PointerType pointerType() const { return pointingDevice() ? pointingDevice()->pointerType() : QPointingDevice::PointerType::Unknown; } + void setTimestamp(quint64 timestamp) override; + qsizetype pointCount() const { return m_points.size(); } + QEventPoint &point(qsizetype i); + const QList<QEventPoint> &points() const { return m_points; } + QEventPoint *pointById(int id); + bool allPointsGrabbed() const; + virtual bool isBeginEvent() const { return false; } + virtual bool isUpdateEvent() const { return false; } + virtual bool isEndEvent() const { return false; } + bool allPointsAccepted() const; + virtual void setAccepted(bool accepted) override; + QObject *exclusiveGrabber(const QEventPoint &point) const; + void setExclusiveGrabber(const QEventPoint &point, QObject *exclusiveGrabber); + QList<QPointer <QObject>> passiveGrabbers(const QEventPoint &point) const; + void clearPassiveGrabbers(const QEventPoint &point); + bool addPassiveGrabber(const QEventPoint &point, QObject *grabber); + bool removePassiveGrabber(const QEventPoint &point, QObject *grabber); + +protected: + QPointerEvent(Type type, SinglePointEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier); + + QList<QEventPoint> m_points; }; -class Q_GUI_EXPORT QEnterEvent : public QEvent +class Q_GUI_EXPORT QSinglePointEvent : public QPointerEvent { + Q_GADGET + Q_PROPERTY(QObject *exclusivePointGrabber READ exclusivePointGrabber + WRITE setExclusivePointGrabber) + + Q_DECL_EVENT_COMMON(QSinglePointEvent) public: - QEnterEvent(const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos); - ~QEnterEvent(); + inline Qt::MouseButton button() const { return m_button; } + inline Qt::MouseButtons buttons() const { return m_mouseState; } + + inline QPointF position() const + { Q_ASSERT(!m_points.isEmpty()); return m_points.first().position(); } + inline QPointF scenePosition() const + { Q_ASSERT(!m_points.isEmpty()); return m_points.first().scenePosition(); } + inline QPointF globalPosition() const + { Q_ASSERT(!m_points.isEmpty()); return m_points.first().globalPosition(); } + + bool isBeginEvent() const override; + bool isUpdateEvent() const override; + bool isEndEvent() const override; + + QObject *exclusivePointGrabber() const + { return QPointerEvent::exclusiveGrabber(points().first()); } + void setExclusivePointGrabber(QObject *exclusiveGrabber) + { QPointerEvent::setExclusiveGrabber(points().first(), exclusiveGrabber); } + +protected: + friend class ::tst_QEvent; + QSinglePointEvent(Type type, const QPointingDevice *dev, const QEventPoint &point, + Qt::MouseButton button, Qt::MouseButtons buttons, + Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source); + QSinglePointEvent(Type type, const QPointingDevice *dev, const QPointF &localPos, + const QPointF &scenePos, const QPointF &globalPos, + Qt::MouseButton button, Qt::MouseButtons buttons, + Qt::KeyboardModifiers modifiers, + Qt::MouseEventSource source = Qt::MouseEventNotSynthesized); + + Qt::MouseButton m_button = Qt::NoButton; + Qt::MouseButtons m_mouseState = Qt::NoButton; + Qt::MouseEventSource m_source; + /* + Fill up to the next 8-byte aligned size: 88 + We have 32bits left, use some for QSinglePointEvent subclasses so that + we don't end up with gaps. + */ + // split this in two quint16; with a quint32, MSVC would 32-bit align it + quint16 m_reserved; + quint16 m_reserved2 : 11; + // for QMouseEvent + quint16 m_doubleClick : 1; + // for QWheelEvent + quint16 m_phase : 3; + quint16 m_invertedScrolling : 1; +}; + +class Q_GUI_EXPORT QEnterEvent : public QSinglePointEvent +{ + Q_DECL_EVENT_COMMON(QEnterEvent) +public: + QEnterEvent(const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos, + const QPointingDevice *device = QPointingDevice::primaryPointingDevice()); #if QT_DEPRECATED_SINCE(6, 0) #ifndef QT_NO_INTEGER_EVENT_COORDINATES @@ -124,30 +190,30 @@ public: QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()") QPointF screenPos() const { return globalPosition(); } #endif // QT_DEPRECATED_SINCE(6, 0) - - QPointF position() const { return l; } - QPointF scenePosition() const { return s; } - QPointF globalPosition() const { return g; } - -protected: - QPointF l, s, g; }; -class Q_GUI_EXPORT QMouseEvent : public QPointerEvent +class Q_GUI_EXPORT QMouseEvent : public QSinglePointEvent { + Q_DECL_EVENT_COMMON(QMouseEvent) public: +#if QT_DEPRECATED_SINCE(6, 4) + QT_DEPRECATED_VERSION_X_6_4("Use another constructor") QMouseEvent(Type type, const QPointF &localPos, Qt::MouseButton button, - Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers); + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, + const QPointingDevice *device = QPointingDevice::primaryPointingDevice()); +#endif QMouseEvent(Type type, const QPointF &localPos, const QPointF &globalPos, Qt::MouseButton button, Qt::MouseButtons buttons, - Qt::KeyboardModifiers modifiers); + Qt::KeyboardModifiers modifiers, + const QPointingDevice *device = QPointingDevice::primaryPointingDevice()); QMouseEvent(Type type, const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos, Qt::MouseButton button, Qt::MouseButtons buttons, - Qt::KeyboardModifiers modifiers); + Qt::KeyboardModifiers modifiers, + const QPointingDevice *device = QPointingDevice::primaryPointingDevice()); QMouseEvent(Type type, const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos, Qt::MouseButton button, Qt::MouseButtons buttons, - Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source); - ~QMouseEvent(); + Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source, + const QPointingDevice *device = QPointingDevice::primaryPointingDevice()); #ifndef QT_NO_INTEGER_EVENT_COORDINATES inline QPoint pos() const { return position().toPoint(); } @@ -172,34 +238,23 @@ public: QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()") QPointF screenPos() const { return globalPosition(); } #endif // QT_DEPRECATED_SINCE(6, 0) - - QPointF position() const { return l; } - QPointF scenePosition() const { return w; } - QPointF globalPosition() const { return g; } - - inline Qt::MouseButton button() const { return b; } - inline Qt::MouseButtons buttons() const { return mouseState; } - - inline void setLocalPos(const QPointF &localPosition) { l = localPosition; } - Qt::MouseEventSource source() const; Qt::MouseEventFlags flags() const; - -protected: - QPointF l, w, g; - Qt::MouseButton b; - Qt::MouseButtons mouseState; - int caps; - QVector2D velocity; - - friend class QGuiApplicationPrivate; }; -class Q_GUI_EXPORT QHoverEvent : public QInputEvent +class Q_GUI_EXPORT QHoverEvent : public QSinglePointEvent { + Q_DECL_EVENT_COMMON(QHoverEvent) public: - QHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos, Qt::KeyboardModifiers modifiers = Qt::NoModifier); - ~QHoverEvent(); + QHoverEvent(Type type, const QPointF &scenePos, const QPointF &globalPos, const QPointF &oldPos, + Qt::KeyboardModifiers modifiers = Qt::NoModifier, + const QPointingDevice *device = QPointingDevice::primaryPointingDevice()); +#if QT_DEPRECATED_SINCE(6, 3) + QT_DEPRECATED_VERSION_X_6_3("Use the other constructor") + QHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos, + Qt::KeyboardModifiers modifiers = Qt::NoModifier, + const QPointingDevice *device = QPointingDevice::primaryPointingDevice()); +#endif #if QT_DEPRECATED_SINCE(6, 0) #ifndef QT_NO_INTEGER_EVENT_COORDINATES @@ -211,72 +266,65 @@ public: inline QPointF posF() const { return position(); } #endif // QT_DEPRECATED_SINCE(6, 0) - // TODO deprecate when we figure out an actual replacement (point history?) - inline QPoint oldPos() const { return op.toPoint(); } - inline QPointF oldPosF() const { return op; } + bool isUpdateEvent() const override { return true; } - QPointF position() const { return p; } + // TODO deprecate when we figure out an actual replacement (point history?) + inline QPoint oldPos() const { return m_oldPos.toPoint(); } + inline QPointF oldPosF() const { return m_oldPos; } protected: - QPointF p, op; + QPointF m_oldPos; // TODO remove? }; #if QT_CONFIG(wheelevent) -class Q_GUI_EXPORT QWheelEvent : public QPointerEvent +class Q_GUI_EXPORT QWheelEvent : public QSinglePointEvent { + Q_GADGET + Q_PROPERTY(const QPointingDevice *device READ pointingDevice) + Q_PROPERTY(QPoint pixelDelta READ pixelDelta) + Q_PROPERTY(QPoint angleDelta READ angleDelta) + Q_PROPERTY(Qt::ScrollPhase phase READ phase) + Q_PROPERTY(bool inverted READ inverted) + + Q_DECL_EVENT_COMMON(QWheelEvent) public: enum { DefaultDeltasPerStep = 120 }; - QWheelEvent(QPointF pos, QPointF globalPos, QPoint pixelDelta, QPoint angleDelta, + QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, - bool inverted, Qt::MouseEventSource source = Qt::MouseEventNotSynthesized); - ~QWheelEvent(); - - - inline QPoint pixelDelta() const { return pixelD; } - inline QPoint angleDelta() const { return angleD; } - - inline QPointF position() const { return p; } - inline QPointF globalPosition() const { return g; } + bool inverted, Qt::MouseEventSource source = Qt::MouseEventNotSynthesized, + const QPointingDevice *device = QPointingDevice::primaryPointingDevice()); - inline Qt::MouseButtons buttons() const { return mouseState; } + inline QPoint pixelDelta() const { return m_pixelDelta; } + inline QPoint angleDelta() const { return m_angleDelta; } - inline Qt::ScrollPhase phase() const { return Qt::ScrollPhase(ph); } - inline bool inverted() const { return invertedScrolling; } + inline Qt::ScrollPhase phase() const { return Qt::ScrollPhase(m_phase); } + inline bool inverted() const { return m_invertedScrolling; } + inline bool isInverted() const { return m_invertedScrolling; } + inline bool hasPixelDelta() const { return !m_pixelDelta.isNull(); } - Qt::MouseEventSource source() const { return Qt::MouseEventSource(src); } + bool isBeginEvent() const override; + bool isUpdateEvent() const override; + bool isEndEvent() const override; + Qt::MouseEventSource source() const { return Qt::MouseEventSource(m_source); } protected: - QPointF p; - QPointF g; - QPoint pixelD; - QPoint angleD; - Qt::MouseButtons mouseState; - uint src: 2; - uint ph : 3; - bool invertedScrolling : 1; - int reserved : 26; - - friend class QApplication; + QPoint m_pixelDelta; + QPoint m_angleDelta; }; #endif #if QT_CONFIG(tabletevent) -class Q_GUI_EXPORT QTabletEvent : public QPointerEvent +class Q_GUI_EXPORT QTabletEvent : public QSinglePointEvent { - Q_GADGET + Q_DECL_EVENT_COMMON(QTabletEvent) public: - QTabletEvent(Type t, const QPointF &pos, const QPointF &globalPos, - int deviceType, int pointerType, qreal pressure, int xTilt, int yTilt, - qreal tangentialPressure, qreal rotation, int z, - Qt::KeyboardModifiers keyState, qint64 uniqueID, - Qt::MouseButton button, Qt::MouseButtons buttons); - QTabletEvent(Type t, const QPointingDevice *dev, const QPointF &pos, const QPointF &globalPos, - qreal pressure, int xTilt, int yTilt, - qreal tangentialPressure, qreal rotation, int z, + QTabletEvent(Type t, const QPointingDevice *device, + const QPointF &pos, const QPointF &globalPos, + qreal pressure, float xTilt, float yTilt, + float tangentialPressure, qreal rotation, float z, Qt::KeyboardModifiers keyState, Qt::MouseButton button, Qt::MouseButtons buttons); - ~QTabletEvent(); #if QT_DEPRECATED_SINCE(6, 0) QT_DEPRECATED_VERSION_X_6_0("Use position()") @@ -300,38 +348,48 @@ public: inline qreal hiResGlobalX() const { return globalPosition().x(); } QT_DEPRECATED_VERSION_X_6_0("use globalPosition().y()") inline qreal hiResGlobalY() const { return globalPosition().y(); } -#endif - inline QPointF position() const { return mPos; } - inline QPointF globalPosition() const { return mGPos; } + QT_DEPRECATED_VERSION_X_6_0("use pointingDevice().uniqueId()") inline qint64 uniqueId() const { return pointingDevice() ? pointingDevice()->uniqueId().numericId() : -1; } - inline qreal pressure() const { return mPress; } - inline int z() const { return mZ; } - inline qreal tangentialPressure() const { return mTangential; } - inline qreal rotation() const { return mRot; } - inline int xTilt() const { return mXT; } - inline int yTilt() const { return mYT; } - inline Qt::MouseButton button() const { return mButton; } - inline Qt::MouseButtons buttons() const { return mButtons; } +#endif + inline qreal pressure() const { Q_ASSERT(!points().isEmpty()); return points().first().pressure(); } + inline qreal rotation() const { Q_ASSERT(!points().isEmpty()); return points().first().rotation(); } + inline qreal z() const { return m_z; } + inline qreal tangentialPressure() const { return m_tangential; } + inline qreal xTilt() const { return m_xTilt; } + inline qreal yTilt() const { return m_yTilt; } protected: - QPointF mPos, mGPos; - int mXT, mYT, mZ; - qreal mPress, mTangential, mRot; - // TODO refactor to parent class along with QMouseEvent's button storage - Qt::MouseButton mButton; - Qt::MouseButtons mButtons; + float m_tangential; + float m_xTilt; + float m_yTilt; + float m_z; }; #endif // QT_CONFIG(tabletevent) #if QT_CONFIG(gestures) -class Q_GUI_EXPORT QNativeGestureEvent : public QPointerEvent +class Q_GUI_EXPORT QNativeGestureEvent : public QSinglePointEvent { + Q_DECL_EVENT_COMMON(QNativeGestureEvent) public: +#if QT_DEPRECATED_SINCE(6, 2) + QT_DEPRECATED_VERSION_X_6_2("Use the other constructor") QNativeGestureEvent(Qt::NativeGestureType type, const QPointingDevice *dev, const QPointF &localPos, const QPointF &scenePos, - const QPointF &globalPos, qreal value, ulong sequenceId, quint64 intArgument); - ~QNativeGestureEvent(); - Qt::NativeGestureType gestureType() const { return mGestureType; } - qreal value() const { return mRealValue; } + const QPointF &globalPos, qreal value, quint64 sequenceId, quint64 intArgument); +#endif + QNativeGestureEvent(Qt::NativeGestureType type, const QPointingDevice *dev, int fingerCount, + const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos, + qreal value, const QPointF &delta, quint64 sequenceId = UINT64_MAX); + + Qt::NativeGestureType gestureType() const { return m_gestureType; } + int fingerCount() const { return m_fingerCount; } + qreal value() const { return m_realValue; } + QPointF delta() const { +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) + return m_delta.toPointF(); +#else + return m_delta; +#endif + } #if QT_DEPRECATED_SINCE(6, 0) #ifndef QT_NO_INTEGER_EVENT_COORDINATES @@ -348,61 +406,71 @@ public: QPointF screenPos() const { return globalPosition(); } #endif - QPointF position() const { return mLocalPos; } - QPointF scenePosition() const { return mScenePos; } - QPointF globalPosition() const { return mGlobalPos; } - protected: - Qt::NativeGestureType mGestureType; - QPointF mLocalPos; - QPointF mScenePos; - QPointF mGlobalPos; - qreal mRealValue; - ulong mSequenceId; - quint64 mIntValue; + quint64 m_sequenceId; +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) + QVector2D m_delta; +#else + QPointF m_delta; +#endif + qreal m_realValue; + Qt::NativeGestureType m_gestureType; + quint32 m_fingerCount : 4; + quint32 m_reserved : 28; }; #endif // QT_CONFIG(gestures) class Q_GUI_EXPORT QKeyEvent : public QInputEvent { + Q_DECL_EVENT_COMMON(QKeyEvent) public: QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text = QString(), - bool autorep = false, ushort count = 1); + bool autorep = false, quint16 count = 1); QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers, - const QString &text = QString(), bool autorep = false, ushort count = 1); - ~QKeyEvent(); + const QString &text = QString(), bool autorep = false, quint16 count = 1, + const QInputDevice *device = QInputDevice::primaryKeyboard()); - int key() const { return k; } + int key() const { return m_key; } #if QT_CONFIG(shortcut) bool matches(QKeySequence::StandardKey key) const; #endif Qt::KeyboardModifiers modifiers() const; - inline QString text() const { return txt; } - inline bool isAutoRepeat() const { return autor; } - inline int count() const { return int(c); } + QKeyCombination keyCombination() const + { + return QKeyCombination(modifiers(), Qt::Key(m_key)); + } + inline QString text() const { return m_text; } + inline bool isAutoRepeat() const { return m_autoRepeat; } + inline int count() const { return int(m_count); } + + inline quint32 nativeScanCode() const { return m_scanCode; } + inline quint32 nativeVirtualKey() const { return m_virtualKey; } + inline quint32 nativeModifiers() const { return m_nativeModifiers; } - inline quint32 nativeScanCode() const { return nScanCode; } - inline quint32 nativeVirtualKey() const { return nVirtualKey; } - inline quint32 nativeModifiers() const { return nModifiers; } +#if QT_CONFIG(shortcut) + friend inline bool operator==(QKeyEvent *e, QKeySequence::StandardKey key) + { return (e ? e->matches(key) : false); } + friend inline bool operator==(QKeySequence::StandardKey key, QKeyEvent *e) + { return (e ? e->matches(key) : false); } +#endif // QT_CONFIG(shortcut) protected: - QString txt; - int k; - quint32 nScanCode; - quint32 nVirtualKey; - quint32 nModifiers; - ushort c; - ushort autor:1; - // ushort reserved:15; + QString m_text; + int m_key; + quint32 m_scanCode; + quint32 m_virtualKey; + quint32 m_nativeModifiers; + quint16 m_count : 15; + quint16 m_autoRepeat : 1; }; class Q_GUI_EXPORT QFocusEvent : public QEvent { + Q_DECL_EVENT_COMMON(QFocusEvent) public: explicit QFocusEvent(Type type, Qt::FocusReason reason=Qt::OtherFocusReason); - ~QFocusEvent(); inline bool gotFocus() const { return type() == FocusIn; } inline bool lostFocus() const { return type() == FocusOut; } @@ -416,10 +484,10 @@ private: class Q_GUI_EXPORT QPaintEvent : public QEvent { + Q_DECL_EVENT_COMMON(QPaintEvent) public: explicit QPaintEvent(const QRegion& paintRegion); explicit QPaintEvent(const QRect &paintRect); - ~QPaintEvent(); inline const QRect &rect() const { return m_rect; } inline const QRegion ®ion() const { return m_region; } @@ -432,31 +500,36 @@ protected: class Q_GUI_EXPORT QMoveEvent : public QEvent { + Q_DECL_EVENT_COMMON(QMoveEvent) public: QMoveEvent(const QPoint &pos, const QPoint &oldPos); - ~QMoveEvent(); - inline const QPoint &pos() const { return p; } - inline const QPoint &oldPos() const { return oldp;} + inline const QPoint &pos() const { return m_pos; } + inline const QPoint &oldPos() const { return m_oldPos;} protected: - QPoint p, oldp; + QPoint m_pos, m_oldPos; friend class QApplication; }; class Q_GUI_EXPORT QExposeEvent : public QEvent { + Q_DECL_EVENT_COMMON(QExposeEvent) public: - explicit QExposeEvent(const QRegion &rgn); - ~QExposeEvent(); + explicit QExposeEvent(const QRegion &m_region); - inline const QRegion ®ion() const { return rgn; } +#if QT_DEPRECATED_SINCE(6, 0) + QT_DEPRECATED_VERSION_X_6_0("Handle QPaintEvent instead") + inline const QRegion ®ion() const { return m_region; } +#endif protected: - QRegion rgn; + QRegion m_region; + friend class QWidgetWindow; }; class Q_GUI_EXPORT QPlatformSurfaceEvent : public QEvent { + Q_DECL_EVENT_COMMON(QPlatformSurfaceEvent) public: enum SurfaceEventType { SurfaceCreated, @@ -464,7 +537,6 @@ public: }; explicit QPlatformSurfaceEvent(SurfaceEventType surfaceEventType); - ~QPlatformSurfaceEvent(); inline SurfaceEventType surfaceEventType() const { return m_surfaceEventType; } @@ -474,81 +546,84 @@ protected: class Q_GUI_EXPORT QResizeEvent : public QEvent { + Q_DECL_EVENT_COMMON(QResizeEvent) public: QResizeEvent(const QSize &size, const QSize &oldSize); - ~QResizeEvent(); - inline const QSize &size() const { return s; } - inline const QSize &oldSize()const { return olds;} + inline const QSize &size() const { return m_size; } + inline const QSize &oldSize()const { return m_oldSize;} protected: - QSize s, olds; + QSize m_size, m_oldSize; friend class QApplication; }; class Q_GUI_EXPORT QCloseEvent : public QEvent { + Q_DECL_EVENT_COMMON(QCloseEvent) public: QCloseEvent(); - ~QCloseEvent(); }; class Q_GUI_EXPORT QIconDragEvent : public QEvent { + Q_DECL_EVENT_COMMON(QIconDragEvent) public: QIconDragEvent(); - ~QIconDragEvent(); }; class Q_GUI_EXPORT QShowEvent : public QEvent { + Q_DECL_EVENT_COMMON(QShowEvent) public: QShowEvent(); - ~QShowEvent(); }; class Q_GUI_EXPORT QHideEvent : public QEvent { + Q_DECL_EVENT_COMMON(QHideEvent) public: QHideEvent(); - ~QHideEvent(); }; #ifndef QT_NO_CONTEXTMENU class Q_GUI_EXPORT QContextMenuEvent : public QInputEvent { + Q_DECL_EVENT_COMMON(QContextMenuEvent) public: enum Reason { Mouse, Keyboard, Other }; QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos, - Qt::KeyboardModifiers modifiers); - QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos); + Qt::KeyboardModifiers modifiers = Qt::NoModifier); +#if QT_DEPRECATED_SINCE(6, 4) + QT_DEPRECATED_VERSION_X_6_4("Use the other constructor") QContextMenuEvent(Reason reason, const QPoint &pos); - ~QContextMenuEvent(); +#endif - inline int x() const { return p.x(); } - inline int y() const { return p.y(); } - inline int globalX() const { return gp.x(); } - inline int globalY() const { return gp.y(); } + inline int x() const { return m_pos.x(); } + inline int y() const { return m_pos.y(); } + inline int globalX() const { return m_globalPos.x(); } + inline int globalY() const { return m_globalPos.y(); } - inline const QPoint& pos() const { return p; } - inline const QPoint& globalPos() const { return gp; } + inline const QPoint& pos() const { return m_pos; } + inline const QPoint& globalPos() const { return m_globalPos; } - inline Reason reason() const { return Reason(reas); } + inline Reason reason() const { return Reason(m_reason); } protected: - QPoint p; - QPoint gp; - uint reas : 8; + QPoint m_pos; + QPoint m_globalPos; + uint m_reason : 8; }; #endif // QT_NO_CONTEXTMENU #ifndef QT_NO_INPUTMETHOD class Q_GUI_EXPORT QInputMethodEvent : public QEvent { + Q_DECL_EVENT_COMMON(QInputMethodEvent) public: enum AttributeType { TextFormat, @@ -569,32 +644,42 @@ public: }; QInputMethodEvent(); QInputMethodEvent(const QString &preeditText, const QList<Attribute> &attributes); - ~QInputMethodEvent(); void setCommitString(const QString &commitString, int replaceFrom = 0, int replaceLength = 0); - inline const QList<Attribute> &attributes() const { return attrs; } - inline const QString &preeditString() const { return preedit; } + inline const QList<Attribute> &attributes() const { return m_attributes; } + inline const QString &preeditString() const { return m_preedit; } - inline const QString &commitString() const { return commit; } - inline int replacementStart() const { return replace_from; } - inline int replacementLength() const { return replace_length; } + inline const QString &commitString() const { return m_commit; } + inline int replacementStart() const { return m_replacementStart; } + inline int replacementLength() const { return m_replacementLength; } - QInputMethodEvent(const QInputMethodEvent &other); + inline friend bool operator==(const QInputMethodEvent::Attribute &lhs, + const QInputMethodEvent::Attribute &rhs) + { + return lhs.type == rhs.type && lhs.start == rhs.start + && lhs.length == rhs.length && lhs.value == rhs.value; + } + + inline friend bool operator!=(const QInputMethodEvent::Attribute &lhs, + const QInputMethodEvent::Attribute &rhs) + { + return !(lhs == rhs); + } private: - QString preedit; - QList<Attribute> attrs; - QString commit; - int replace_from; - int replace_length; + QString m_preedit; + QString m_commit; + QList<Attribute> m_attributes; + int m_replacementStart; + int m_replacementLength; }; -Q_DECLARE_TYPEINFO(QInputMethodEvent::Attribute, Q_MOVABLE_TYPE); +Q_DECLARE_TYPEINFO(QInputMethodEvent::Attribute, Q_RELOCATABLE_TYPE); class Q_GUI_EXPORT QInputMethodQueryEvent : public QEvent { + Q_DECL_EVENT_COMMON(QInputMethodQueryEvent) public: explicit QInputMethodQueryEvent(Qt::InputMethodQueries queries); - ~QInputMethodQueryEvent(); Qt::InputMethodQueries queries() const { return m_queries; } @@ -609,7 +694,7 @@ private: friend QTypeInfo<QueryPair>; QList<QueryPair> m_values; }; -Q_DECLARE_TYPEINFO(QInputMethodQueryEvent::QueryPair, Q_MOVABLE_TYPE); +Q_DECLARE_TYPEINFO(QInputMethodQueryEvent::QueryPair, Q_RELOCATABLE_TYPE); #endif // QT_NO_INPUTMETHOD @@ -619,10 +704,10 @@ class QMimeData; class Q_GUI_EXPORT QDropEvent : public QEvent { + Q_DECL_EVENT_COMMON(QDropEvent) public: QDropEvent(const QPointF& pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop); - ~QDropEvent(); #if QT_DEPRECATED_SINCE(6, 0) QT_DEPRECATED_VERSION_X_6_0("Use position().toPoint()") @@ -635,184 +720,192 @@ public: inline Qt::KeyboardModifiers keyboardModifiers() const { return modifiers(); } #endif // QT_DEPRECATED_SINCE(6, 0) - QPointF position() const { return p; } - inline Qt::MouseButtons buttons() const { return mouseState; } - inline Qt::KeyboardModifiers modifiers() const { return modState; } + QPointF position() const { return m_pos; } + inline Qt::MouseButtons buttons() const { return m_mouseState; } + inline Qt::KeyboardModifiers modifiers() const { return m_modState; } - inline Qt::DropActions possibleActions() const { return act; } - inline Qt::DropAction proposedAction() const { return default_action; } - inline void acceptProposedAction() { drop_action = default_action; accept(); } + inline Qt::DropActions possibleActions() const { return m_actions; } + inline Qt::DropAction proposedAction() const { return m_defaultAction; } + inline void acceptProposedAction() { m_dropAction = m_defaultAction; accept(); } - inline Qt::DropAction dropAction() const { return drop_action; } + inline Qt::DropAction dropAction() const { return m_dropAction; } void setDropAction(Qt::DropAction action); QObject* source() const; - inline const QMimeData *mimeData() const { return mdata; } + inline const QMimeData *mimeData() const { return m_data; } protected: friend class QApplication; - QPointF p; - Qt::MouseButtons mouseState; - Qt::KeyboardModifiers modState; - Qt::DropActions act; - Qt::DropAction drop_action; - Qt::DropAction default_action; - const QMimeData *mdata; + QPointF m_pos; + Qt::MouseButtons m_mouseState; + Qt::KeyboardModifiers m_modState; + Qt::DropActions m_actions; + Qt::DropAction m_dropAction; + Qt::DropAction m_defaultAction; + const QMimeData *m_data; }; class Q_GUI_EXPORT QDragMoveEvent : public QDropEvent { + Q_DECL_EVENT_COMMON(QDragMoveEvent) public: QDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove); - ~QDragMoveEvent(); - inline QRect answerRect() const { return rect; } + inline QRect answerRect() const { return m_rect; } inline void accept() { QDropEvent::accept(); } inline void ignore() { QDropEvent::ignore(); } - inline void accept(const QRect & r) { accept(); rect = r; } - inline void ignore(const QRect & r) { ignore(); rect = r; } + inline void accept(const QRect & r) { accept(); m_rect = r; } + inline void ignore(const QRect & r) { ignore(); m_rect = r; } protected: - QRect rect; + QRect m_rect; }; class Q_GUI_EXPORT QDragEnterEvent : public QDragMoveEvent { + Q_DECL_EVENT_COMMON(QDragEnterEvent) public: QDragEnterEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers); - ~QDragEnterEvent(); }; class Q_GUI_EXPORT QDragLeaveEvent : public QEvent { + Q_DECL_EVENT_COMMON(QDragLeaveEvent) public: QDragLeaveEvent(); - ~QDragLeaveEvent(); }; #endif // QT_CONFIG(draganddrop) class Q_GUI_EXPORT QHelpEvent : public QEvent { + Q_DECL_EVENT_COMMON(QHelpEvent) public: QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos); - ~QHelpEvent(); - inline int x() const { return p.x(); } - inline int y() const { return p.y(); } - inline int globalX() const { return gp.x(); } - inline int globalY() const { return gp.y(); } + inline int x() const { return m_pos.x(); } + inline int y() const { return m_pos.y(); } + inline int globalX() const { return m_globalPos.x(); } + inline int globalY() const { return m_globalPos.y(); } - inline const QPoint& pos() const { return p; } - inline const QPoint& globalPos() const { return gp; } + inline const QPoint& pos() const { return m_pos; } + inline const QPoint& globalPos() const { return m_globalPos; } private: - QPoint p; - QPoint gp; + QPoint m_pos; + QPoint m_globalPos; }; #ifndef QT_NO_STATUSTIP class Q_GUI_EXPORT QStatusTipEvent : public QEvent { + Q_DECL_EVENT_COMMON(QStatusTipEvent) public: explicit QStatusTipEvent(const QString &tip); - ~QStatusTipEvent(); - inline QString tip() const { return s; } + inline QString tip() const { return m_tip; } private: - QString s; + QString m_tip; }; #endif #if QT_CONFIG(whatsthis) class Q_GUI_EXPORT QWhatsThisClickedEvent : public QEvent { + Q_DECL_EVENT_COMMON(QWhatsThisClickedEvent) public: explicit QWhatsThisClickedEvent(const QString &href); - ~QWhatsThisClickedEvent(); - inline QString href() const { return s; } + inline QString href() const { return m_href; } private: - QString s; + QString m_href; }; #endif #if QT_CONFIG(action) class Q_GUI_EXPORT QActionEvent : public QEvent { - QAction *act, *bef; + Q_DECL_EVENT_COMMON(QActionEvent) public: QActionEvent(int type, QAction *action, QAction *before = nullptr); - ~QActionEvent(); - inline QAction *action() const { return act; } - inline QAction *before() const { return bef; } + inline QAction *action() const { return m_action; } + inline QAction *before() const { return m_before; } +private: + QAction *m_action; + QAction *m_before; }; #endif // QT_CONFIG(action) class Q_GUI_EXPORT QFileOpenEvent : public QEvent { + Q_DECL_EVENT_COMMON(QFileOpenEvent) public: explicit QFileOpenEvent(const QString &file); explicit QFileOpenEvent(const QUrl &url); - ~QFileOpenEvent(); - inline QString file() const { return f; } + inline QString file() const { return m_file; } QUrl url() const { return m_url; } +#if QT_DEPRECATED_SINCE(6, 6) + QT_DEPRECATED_VERSION_X_6_6("Interpret the string returned by file()") bool openFile(QFile &file, QIODevice::OpenMode flags) const; +#endif private: - QString f; + QString m_file; QUrl m_url; }; #ifndef QT_NO_TOOLBAR class Q_GUI_EXPORT QToolBarChangeEvent : public QEvent { + Q_DECL_EVENT_COMMON(QToolBarChangeEvent) public: explicit QToolBarChangeEvent(bool t); - ~QToolBarChangeEvent(); - inline bool toggle() const { return tog; } + inline bool toggle() const { return m_toggle; } private: - uint tog : 1; + bool m_toggle; }; #endif #if QT_CONFIG(shortcut) class Q_GUI_EXPORT QShortcutEvent : public QEvent { + Q_DECL_EVENT_COMMON(QShortcutEvent) public: + // Note this is publicly deprecated, but should remain as internal constructor: QShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false); - ~QShortcutEvent(); + QShortcutEvent(const QKeySequence &key, const QShortcut *shortcut = nullptr, bool ambiguous = false); - inline const QKeySequence &key() const { return sequence; } - inline int shortcutId() const { return sid; } - inline bool isAmbiguous() const { return ambig; } + inline const QKeySequence &key() const { return m_sequence; } + // Note this is publicly deprecated, but should remain as internal getter: + inline int shortcutId() const { return m_shortcutId; } + inline bool isAmbiguous() const { return m_ambiguous; } protected: - QKeySequence sequence; - bool ambig; - int sid; + QKeySequence m_sequence; + int m_shortcutId; + bool m_ambiguous; }; #endif class Q_GUI_EXPORT QWindowStateChangeEvent: public QEvent { + Q_DECL_EVENT_COMMON(QWindowStateChangeEvent) public: - explicit QWindowStateChangeEvent(Qt::WindowStates aOldState, bool isOverride = false); - ~QWindowStateChangeEvent(); + explicit QWindowStateChangeEvent(Qt::WindowStates oldState, bool isOverride = false); - inline Qt::WindowStates oldState() const { return ostate; } + inline Qt::WindowStates oldState() const { return m_oldStates; } bool isOverride() const; private: - Qt::WindowStates ostate; + Qt::WindowStates m_oldStates; bool m_override; }; @@ -820,192 +913,68 @@ private: Q_GUI_EXPORT QDebug operator<<(QDebug, const QEvent *); #endif -#if QT_CONFIG(shortcut) -inline bool operator==(QKeyEvent *e, QKeySequence::StandardKey key){return (e ? e->matches(key) : false);} -inline bool operator==(QKeySequence::StandardKey key, QKeyEvent *e){return (e ? e->matches(key) : false);} -#endif // QT_CONFIG(shortcut) - -class QTouchEventTouchPointPrivate; class Q_GUI_EXPORT QTouchEvent : public QPointerEvent { + Q_DECL_EVENT_COMMON(QTouchEvent) public: - class Q_GUI_EXPORT TouchPoint - { - public: - enum InfoFlag { - Pen = 0x0001, - Token = 0x0002 - }; -#ifndef Q_MOC_RUN - // otherwise moc gives - // Error: Meta object features not supported for nested classes - Q_DECLARE_FLAGS(InfoFlags, InfoFlag) -#endif - - explicit TouchPoint(int id = -1); - TouchPoint(const TouchPoint &other); - TouchPoint(TouchPoint &&other) noexcept - : d(nullptr) - { qSwap(d, other.d); } - TouchPoint &operator=(TouchPoint &&other) noexcept - { qSwap(d, other.d); return *this; } - ~TouchPoint(); - - TouchPoint &operator=(const TouchPoint &other) - { if ( d != other.d ) { TouchPoint copy(other); swap(copy); } return *this; } - - void swap(TouchPoint &other) noexcept - { qSwap(d, other.d); } - - int id() const; - QPointingDeviceUniqueId uniqueId() const; - - Qt::TouchPointState state() const; - -#if QT_DEPRECATED_SINCE(6, 0) - QT_DEPRECATED_VERSION_X_6_0("Use position()") - QPointF pos() const { return position(); } - QT_DEPRECATED_VERSION_X_6_0("Use pressPosition()") - QPointF startPos() const { return pressPosition(); } - - QT_DEPRECATED_VERSION_X_6_0("Use scenePosition()") - QPointF scenePos() const { return scenePosition(); } - QT_DEPRECATED_VERSION_X_6_0("Use scenePressPosition()") - QPointF startScenePos() const { return scenePressPosition(); } - - QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()") - QPointF screenPos() const { return globalPosition(); } - QT_DEPRECATED_VERSION_X_6_0("Use globalPressPosition()") - QPointF startScreenPos() const { return globalPressPosition(); } -#endif // QT_DEPRECATED_SINCE(6, 0) - - // TODO deprecate these after finding good replacements (use QPointingDevice::globalArea?) - QPointF normalizedPos() const; - QPointF startNormalizedPos() const; - - // TODO deprecate these after finding good replacements (store longer history perhaps?) - QPointF lastPos() const; - QPointF lastScenePos() const; - QPointF lastScreenPos() const; - QPointF lastNormalizedPos() const; - - QPointF position() const; - QPointF pressPosition() const; - QPointF scenePosition() const; - QPointF scenePressPosition() const; - QPointF globalPosition() const; - QPointF globalPressPosition() const; - - qreal pressure() const; - qreal rotation() const; - QSizeF ellipseDiameters() const; - - QVector2D velocity() const; - InfoFlags flags() const; - QList<QPointF> rawScreenPositions() const; - - // internal - // ### Qt 6: move private, rename appropriately, only friends can call them -#if QT_DEPRECATED_SINCE(6, 0) - void setId(int id); - void setUniqueId(qint64 uid); - void setState(Qt::TouchPointStates state); - void setPos(const QPointF &pos); - void setScenePos(const QPointF &scenePos); - void setScreenPos(const QPointF &screenPos); - void setNormalizedPos(const QPointF &normalizedPos); - void setStartPos(const QPointF &startPos); - void setStartScenePos(const QPointF &startScenePos); - void setStartScreenPos(const QPointF &startScreenPos); - void setStartNormalizedPos(const QPointF &startNormalizedPos); - void setLastPos(const QPointF &lastPos); - void setLastScenePos(const QPointF &lastScenePos); - void setLastScreenPos(const QPointF &lastScreenPos); - void setLastNormalizedPos(const QPointF &lastNormalizedPos); - void setPressure(qreal pressure); - void setRotation(qreal angle); - void setEllipseDiameters(const QSizeF &dia); - void setVelocity(const QVector2D &v); - void setFlags(InfoFlags flags); - void setRawScreenPositions(const QList<QPointF> &positions); -#endif // QT_DEPRECATED_SINCE(6, 0) - - private: - QTouchEventTouchPointPrivate *d; - friend class QGuiApplication; - friend class QGuiApplicationPrivate; - friend class QApplication; - friend class QApplicationPrivate; - friend class QQuickPointerTouchEvent; - friend class QQuickMultiPointTouchArea; - }; + using TouchPoint = QEventPoint; // source compat explicit QTouchEvent(QEvent::Type eventType, - const QPointingDevice *source = nullptr, + const QPointingDevice *device = nullptr, Qt::KeyboardModifiers modifiers = Qt::NoModifier, - Qt::TouchPointStates touchPointStates = Qt::TouchPointStates(), - const QList<QTouchEvent::TouchPoint> &touchPoints = QList<QTouchEvent::TouchPoint>()); - ~QTouchEvent(); - - inline QWindow *window() const { return _window; } - inline QObject *target() const { return _target; } - inline Qt::TouchPointStates touchPointStates() const { return _touchPointStates; } - inline const QList<QTouchEvent::TouchPoint> &touchPoints() const { return _touchPoints; } + const QList<QEventPoint> &touchPoints = {}); +#if QT_DEPRECATED_SINCE(6, 0) + QT_DEPRECATED_VERSION_X_6_0("Use another constructor") + explicit QTouchEvent(QEvent::Type eventType, + const QPointingDevice *device, + Qt::KeyboardModifiers modifiers, + QEventPoint::States touchPointStates, + const QList<QEventPoint> &touchPoints = {}); +#endif - // ### Qt 6: move private, rename appropriately, only friends can call them; or just let friends modify variables directly + inline QObject *target() const { return m_target; } + inline QEventPoint::States touchPointStates() const { return m_touchPointStates; } #if QT_DEPRECATED_SINCE(6, 0) - inline void setWindow(QWindow *awindow) { _window = awindow; } - inline void setTarget(QObject *atarget) { _target = atarget; } - inline void setTouchPoints(const QList<QTouchEvent::TouchPoint> &atouchPoints) { _touchPoints = atouchPoints; } -#endif // QT_DEPRECATED_SINCE(6, 0) + QT_DEPRECATED_VERSION_X_6_0("Use points()") + const QList<QEventPoint> &touchPoints() const { return points(); } +#endif + bool isBeginEvent() const override; + bool isUpdateEvent() const override; + bool isEndEvent() const override; protected: - QWindow *_window; - QObject *_target; - Qt::TouchPointStates _touchPointStates; - QList<QTouchEvent::TouchPoint> _touchPoints; - - friend class QGuiApplication; - friend class QGuiApplicationPrivate; - friend class QApplication; - friend class QApplicationPrivate; -#ifndef QT_NO_GRAPHICSVIEW - friend class QGraphicsScenePrivate; // direct access to _touchPoints -#endif + QObject *m_target = nullptr; + QEventPoint::States m_touchPointStates = QEventPoint::State::Unknown; + quint32 m_reserved : 24; }; -Q_DECLARE_TYPEINFO(QTouchEvent::TouchPoint, Q_MOVABLE_TYPE); -Q_DECLARE_OPERATORS_FOR_FLAGS(QTouchEvent::TouchPoint::InfoFlags) - -#ifndef QT_NO_DEBUG_STREAM -Q_GUI_EXPORT QDebug operator<<(QDebug, const QTouchEvent::TouchPoint &); -#endif class Q_GUI_EXPORT QScrollPrepareEvent : public QEvent { + Q_DECL_EVENT_COMMON(QScrollPrepareEvent) public: explicit QScrollPrepareEvent(const QPointF &startPos); - ~QScrollPrepareEvent(); - QPointF startPos() const; + QPointF startPos() const { return m_startPos; } - QSizeF viewportSize() const; - QRectF contentPosRange() const; - QPointF contentPos() const; + QSizeF viewportSize() const { return m_viewportSize; } + QRectF contentPosRange() const { return m_contentPosRange; } + QPointF contentPos() const { return m_contentPos; } void setViewportSize(const QSizeF &size); void setContentPosRange(const QRectF &rect); void setContentPos(const QPointF &pos); private: - QPointF m_startPos; - QSizeF m_viewportSize; QRectF m_contentPosRange; + QSizeF m_viewportSize; + QPointF m_startPos; QPointF m_contentPos; }; class Q_GUI_EXPORT QScrollEvent : public QEvent { + Q_DECL_EVENT_COMMON(QScrollEvent) public: enum ScrollState { @@ -1015,11 +984,10 @@ public: }; QScrollEvent(const QPointF &contentPos, const QPointF &overshoot, ScrollState scrollState); - ~QScrollEvent(); - QPointF contentPos() const; - QPointF overshootDistance() const; - ScrollState scrollState() const; + QPointF contentPos() const { return m_contentPos; } + QPointF overshootDistance() const { return m_overshoot; } + ScrollState scrollState() const { return m_state; } private: QPointF m_contentPos; @@ -1029,12 +997,12 @@ private: class Q_GUI_EXPORT QScreenOrientationChangeEvent : public QEvent { + Q_DECL_EVENT_COMMON(QScreenOrientationChangeEvent) public: QScreenOrientationChangeEvent(QScreen *screen, Qt::ScreenOrientation orientation); - ~QScreenOrientationChangeEvent(); - QScreen *screen() const; - Qt::ScreenOrientation orientation() const; + QScreen *screen() const { return m_screen; } + Qt::ScreenOrientation orientation() const { return m_orientation; } private: QScreen *m_screen; @@ -1043,14 +1011,27 @@ private: class Q_GUI_EXPORT QApplicationStateChangeEvent : public QEvent { + Q_DECL_EVENT_COMMON(QApplicationStateChangeEvent) public: explicit QApplicationStateChangeEvent(Qt::ApplicationState state); - Qt::ApplicationState applicationState() const; + + Qt::ApplicationState applicationState() const { return m_applicationState; } private: Qt::ApplicationState m_applicationState; }; +class Q_GUI_EXPORT QChildWindowEvent : public QEvent +{ + Q_DECL_EVENT_COMMON(QChildWindowEvent) +public: + explicit QChildWindowEvent(Type type, QWindow *childWindow); + QWindow *child() const { return c; } + +private: + QWindow *c; +}; + QT_END_NAMESPACE #endif // QEVENT_H |