Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-01-08 10:24:39 

0001 // Copyright (C) 2020 The Qt Company Ltd.
0002 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
0003 
0004 #ifndef QEVENT_H
0005 #define QEVENT_H
0006 
0007 #if 0
0008 #pragma qt_class(QtEvents)
0009 #endif
0010 
0011 #include <QtGui/qtguiglobal.h>
0012 
0013 #include <QtCore/qcoreevent.h>
0014 #include <QtCore/qiodevice.h>
0015 #include <QtCore/qlist.h>
0016 #include <QtCore/qnamespace.h>
0017 #include <QtCore/qstring.h>
0018 #include <QtCore/qurl.h>
0019 #include <QtCore/qvariant.h>
0020 #include <QtGui/qeventpoint.h>
0021 #include <QtGui/qpointingdevice.h>
0022 #include <QtGui/qregion.h>
0023 #include <QtGui/qwindowdefs.h>
0024 
0025 #if QT_CONFIG(shortcut)
0026 #  include <QtGui/qkeysequence.h>
0027 #endif
0028 
0029 class tst_QEvent;
0030 
0031 QT_BEGIN_NAMESPACE
0032 
0033 class QFile;
0034 class QAction;
0035 class QMouseEvent;
0036 template <typename T> class QPointer;
0037 class QPointerEvent;
0038 class QScreen;
0039 #if QT_CONFIG(shortcut)
0040 class QShortcut;
0041 #endif
0042 class QTabletEvent;
0043 class QTouchEvent;
0044 #if QT_CONFIG(gestures)
0045 class QGesture;
0046 #endif
0047 
0048 class Q_GUI_EXPORT QInputEvent : public QEvent
0049 {
0050     Q_DECL_EVENT_COMMON(QInputEvent)
0051 public:
0052     explicit QInputEvent(Type type, const QInputDevice *m_dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
0053 
0054     const QInputDevice *device() const { return m_dev; }
0055     QInputDevice::DeviceType deviceType() const { return m_dev ? m_dev->type() : QInputDevice::DeviceType::Unknown; }
0056     inline Qt::KeyboardModifiers modifiers() const { return m_modState; }
0057     inline void setModifiers(Qt::KeyboardModifiers modifiers) { m_modState = modifiers; }
0058     inline quint64 timestamp() const { return m_timeStamp; }
0059     virtual void setTimestamp(quint64 timestamp) { m_timeStamp = timestamp; }
0060 
0061 protected:
0062     QInputEvent(Type type, PointerEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
0063     QInputEvent(Type type, SinglePointEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
0064 
0065     const QInputDevice *m_dev = nullptr;
0066     quint64 m_timeStamp = 0;
0067     Qt::KeyboardModifiers m_modState = Qt::NoModifier;
0068     // fill up to the closest 8-byte aligned size: 48
0069     quint32 m_reserved = 0;
0070 };
0071 
0072 class Q_GUI_EXPORT QPointerEvent : public QInputEvent
0073 {
0074     Q_GADGET
0075     Q_DECL_EVENT_COMMON(QPointerEvent)
0076 public:
0077     explicit QPointerEvent(Type type, const QPointingDevice *dev,
0078                            Qt::KeyboardModifiers modifiers = Qt::NoModifier, const QList<QEventPoint> &points = {});
0079 
0080     const QPointingDevice *pointingDevice() const;
0081     QPointingDevice::PointerType pointerType() const {
0082         return pointingDevice() ? pointingDevice()->pointerType() : QPointingDevice::PointerType::Unknown;
0083     }
0084     void setTimestamp(quint64 timestamp) override;
0085     qsizetype pointCount() const { return m_points.size(); }
0086     QEventPoint &point(qsizetype i);
0087     const QList<QEventPoint> &points() const { return m_points; }
0088     QEventPoint *pointById(int id);
0089     bool allPointsGrabbed() const;
0090     virtual bool isBeginEvent() const { return false; }
0091     virtual bool isUpdateEvent() const { return false; }
0092     virtual bool isEndEvent() const { return false; }
0093     bool allPointsAccepted() const;
0094     virtual void setAccepted(bool accepted) override;
0095     QObject *exclusiveGrabber(const QEventPoint &point) const;
0096     void setExclusiveGrabber(const QEventPoint &point, QObject *exclusiveGrabber);
0097     QList<QPointer <QObject>> passiveGrabbers(const QEventPoint &point) const;
0098     void clearPassiveGrabbers(const QEventPoint &point);
0099     bool addPassiveGrabber(const QEventPoint &point, QObject *grabber);
0100     bool removePassiveGrabber(const QEventPoint &point, QObject *grabber);
0101 
0102 protected:
0103     QPointerEvent(Type type, SinglePointEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
0104 
0105     QList<QEventPoint> m_points;
0106 };
0107 
0108 class Q_GUI_EXPORT QSinglePointEvent : public QPointerEvent
0109 {
0110     Q_GADGET
0111     Q_PROPERTY(QObject *exclusivePointGrabber READ exclusivePointGrabber
0112                WRITE setExclusivePointGrabber)
0113 
0114     Q_DECL_EVENT_COMMON(QSinglePointEvent)
0115 public:
0116     inline Qt::MouseButton button() const { return m_button; }
0117     inline Qt::MouseButtons buttons() const { return m_mouseState; }
0118 
0119     inline QPointF position() const
0120     { Q_ASSERT(!m_points.isEmpty()); return m_points.first().position(); }
0121     inline QPointF scenePosition() const
0122     { Q_ASSERT(!m_points.isEmpty()); return m_points.first().scenePosition(); }
0123     inline QPointF globalPosition() const
0124     { Q_ASSERT(!m_points.isEmpty()); return m_points.first().globalPosition(); }
0125 
0126     bool isBeginEvent() const override;
0127     bool isUpdateEvent() const override;
0128     bool isEndEvent() const override;
0129 
0130     QObject *exclusivePointGrabber() const
0131     { return QPointerEvent::exclusiveGrabber(points().first()); }
0132     void setExclusivePointGrabber(QObject *exclusiveGrabber)
0133     { QPointerEvent::setExclusiveGrabber(points().first(), exclusiveGrabber); }
0134 
0135 protected:
0136     friend class ::tst_QEvent;
0137     friend class QMutableSinglePointEvent;
0138     QSinglePointEvent(Type type, const QPointingDevice *dev, const QEventPoint &point,
0139                       Qt::MouseButton button, Qt::MouseButtons buttons,
0140                       Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source);
0141     QSinglePointEvent(Type type, const QPointingDevice *dev, const QPointF &localPos,
0142                       const QPointF &scenePos, const QPointF &globalPos,
0143                       Qt::MouseButton button, Qt::MouseButtons buttons,
0144                       Qt::KeyboardModifiers modifiers,
0145                       Qt::MouseEventSource source = Qt::MouseEventNotSynthesized);
0146 
0147     Qt::MouseButton m_button = Qt::NoButton;
0148     Qt::MouseButtons m_mouseState = Qt::NoButton;
0149     Qt::MouseEventSource m_source;
0150     /*
0151         Fill up to the next 8-byte aligned size: 88
0152         We have 32bits left, use some for QSinglePointEvent subclasses so that
0153         we don't end up with gaps.
0154     */
0155     // split this in two quint16; with a quint32, MSVC would 32-bit align it
0156     quint16 m_reserved;
0157     quint16 m_reserved2  : 11;
0158     // for QMouseEvent
0159     quint16 m_doubleClick : 1;
0160     // for QWheelEvent
0161     quint16 m_phase : 3;
0162     quint16 m_invertedScrolling : 1;
0163 };
0164 
0165 class Q_GUI_EXPORT QEnterEvent : public QSinglePointEvent
0166 {
0167     Q_DECL_EVENT_COMMON(QEnterEvent)
0168 public:
0169     QEnterEvent(const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos,
0170                 const QPointingDevice *device = QPointingDevice::primaryPointingDevice());
0171 
0172 #if QT_DEPRECATED_SINCE(6, 0)
0173 #ifndef QT_NO_INTEGER_EVENT_COORDINATES
0174     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0175     inline QPoint pos() const { return position().toPoint(); }
0176     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0177     inline QPoint globalPos() const { return globalPosition().toPoint(); }
0178     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0179     inline int x() const { return qRound(position().x()); }
0180     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0181     inline int y() const { return qRound(position().y()); }
0182     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0183     inline int globalX() const { return qRound(globalPosition().x()); }
0184     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0185     inline int globalY() const { return qRound(globalPosition().y()); }
0186 #endif
0187     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0188     QPointF localPos() const { return position(); }
0189     QT_DEPRECATED_VERSION_X_6_0("Use scenePosition()")
0190     QPointF windowPos() const { return scenePosition(); }
0191     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0192     QPointF screenPos() const { return globalPosition(); }
0193 #endif // QT_DEPRECATED_SINCE(6, 0)
0194 };
0195 
0196 class Q_GUI_EXPORT QMouseEvent : public QSinglePointEvent
0197 {
0198     Q_DECL_EVENT_COMMON(QMouseEvent)
0199 public:
0200 #if QT_DEPRECATED_SINCE(6, 4)
0201     QT_DEPRECATED_VERSION_X_6_4("Use another constructor")
0202     QMouseEvent(Type type, const QPointF &localPos, Qt::MouseButton button,
0203                 Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
0204                 const QPointingDevice *device = QPointingDevice::primaryPointingDevice());
0205 #endif
0206     QMouseEvent(Type type, const QPointF &localPos, const QPointF &globalPos,
0207                 Qt::MouseButton button, Qt::MouseButtons buttons,
0208                 Qt::KeyboardModifiers modifiers,
0209                 const QPointingDevice *device = QPointingDevice::primaryPointingDevice());
0210     QMouseEvent(Type type, const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos,
0211                 Qt::MouseButton button, Qt::MouseButtons buttons,
0212                 Qt::KeyboardModifiers modifiers,
0213                 const QPointingDevice *device = QPointingDevice::primaryPointingDevice());
0214     QMouseEvent(Type type, const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos,
0215                 Qt::MouseButton button, Qt::MouseButtons buttons,
0216                 Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source,
0217                 const QPointingDevice *device = QPointingDevice::primaryPointingDevice());
0218 
0219 #ifndef QT_NO_INTEGER_EVENT_COORDINATES
0220     inline QPoint pos() const { return position().toPoint(); }
0221 #endif
0222 #if QT_DEPRECATED_SINCE(6, 0)
0223 #ifndef QT_NO_INTEGER_EVENT_COORDINATES
0224     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0225     inline QPoint globalPos() const { return globalPosition().toPoint(); }
0226     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0227     inline int x() const { return qRound(position().x()); }
0228     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0229     inline int y() const { return qRound(position().y()); }
0230     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0231     inline int globalX() const { return qRound(globalPosition().x()); }
0232     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0233     inline int globalY() const { return qRound(globalPosition().y()); }
0234 #endif // QT_NO_INTEGER_EVENT_COORDINATES
0235     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0236     QPointF localPos() const { return position(); }
0237     QT_DEPRECATED_VERSION_X_6_0("Use scenePosition()")
0238     QPointF windowPos() const { return scenePosition(); }
0239     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0240     QPointF screenPos() const { return globalPosition(); }
0241 #endif // QT_DEPRECATED_SINCE(6, 0)
0242     Qt::MouseEventSource source() const;
0243     Qt::MouseEventFlags flags() const;
0244 };
0245 
0246 class Q_GUI_EXPORT QHoverEvent : public QSinglePointEvent
0247 {
0248     Q_DECL_EVENT_COMMON(QHoverEvent)
0249 public:
0250     QHoverEvent(Type type, const QPointF &scenePos, const QPointF &globalPos, const QPointF &oldPos,
0251                 Qt::KeyboardModifiers modifiers = Qt::NoModifier,
0252                 const QPointingDevice *device = QPointingDevice::primaryPointingDevice());
0253 #if QT_DEPRECATED_SINCE(6, 3)
0254     QT_DEPRECATED_VERSION_X_6_3("Use the other constructor")
0255     QHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos,
0256                 Qt::KeyboardModifiers modifiers = Qt::NoModifier,
0257                 const QPointingDevice *device = QPointingDevice::primaryPointingDevice());
0258 #endif
0259 
0260 #if QT_DEPRECATED_SINCE(6, 0)
0261 #ifndef QT_NO_INTEGER_EVENT_COORDINATES
0262     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0263     inline QPoint pos() const { return position().toPoint(); }
0264 #endif
0265 
0266     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0267     inline QPointF posF() const { return position(); }
0268 #endif // QT_DEPRECATED_SINCE(6, 0)
0269 
0270     bool isUpdateEvent() const override  { return true; }
0271 
0272     // TODO deprecate when we figure out an actual replacement (point history?)
0273     inline QPoint oldPos() const { return m_oldPos.toPoint(); }
0274     inline QPointF oldPosF() const { return m_oldPos; }
0275 
0276 protected:
0277     QPointF m_oldPos; // TODO remove?
0278 };
0279 
0280 #if QT_CONFIG(wheelevent)
0281 class Q_GUI_EXPORT QWheelEvent : public QSinglePointEvent
0282 {
0283     Q_GADGET
0284     Q_PROPERTY(const QPointingDevice *device READ pointingDevice)
0285     Q_PROPERTY(QPoint pixelDelta READ pixelDelta)
0286     Q_PROPERTY(QPoint angleDelta READ angleDelta)
0287     Q_PROPERTY(Qt::ScrollPhase phase READ phase)
0288     Q_PROPERTY(bool inverted READ inverted)
0289 
0290     Q_DECL_EVENT_COMMON(QWheelEvent)
0291 public:
0292     enum { DefaultDeltasPerStep = 120 };
0293 
0294     QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta,
0295                 Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase,
0296                 bool inverted, Qt::MouseEventSource source = Qt::MouseEventNotSynthesized,
0297                 const QPointingDevice *device = QPointingDevice::primaryPointingDevice());
0298 
0299     inline QPoint pixelDelta() const { return m_pixelDelta; }
0300     inline QPoint angleDelta() const { return m_angleDelta; }
0301 
0302     inline Qt::ScrollPhase phase() const { return Qt::ScrollPhase(m_phase); }
0303     inline bool inverted() const { return m_invertedScrolling; }
0304     inline bool isInverted() const { return m_invertedScrolling; }
0305     inline bool hasPixelDelta() const { return !m_pixelDelta.isNull(); }
0306 
0307     bool isBeginEvent() const override;
0308     bool isUpdateEvent() const override;
0309     bool isEndEvent() const override;
0310     Qt::MouseEventSource source() const { return Qt::MouseEventSource(m_source); }
0311 
0312 protected:
0313     QPoint m_pixelDelta;
0314     QPoint m_angleDelta;
0315 };
0316 #endif
0317 
0318 #if QT_CONFIG(tabletevent)
0319 class Q_GUI_EXPORT QTabletEvent : public QSinglePointEvent
0320 {
0321     Q_DECL_EVENT_COMMON(QTabletEvent)
0322 public:
0323     QTabletEvent(Type t, const QPointingDevice *device,
0324                  const QPointF &pos, const QPointF &globalPos,
0325                  qreal pressure, float xTilt, float yTilt,
0326                  float tangentialPressure, qreal rotation, float z,
0327                  Qt::KeyboardModifiers keyState,
0328                  Qt::MouseButton button, Qt::MouseButtons buttons);
0329 
0330 #if QT_DEPRECATED_SINCE(6, 0)
0331     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0332     inline QPoint pos() const { return position().toPoint(); }
0333     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0334     inline QPoint globalPos() const { return globalPosition().toPoint(); }
0335 
0336     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0337     inline const QPointF posF() const { return position(); }
0338     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0339     inline const QPointF globalPosF() const { return globalPosition(); }
0340     QT_DEPRECATED_VERSION_X_6_0("Use position().x()")
0341     inline int x() const { return qRound(position().x()); }
0342     QT_DEPRECATED_VERSION_X_6_0("Use position().y()")
0343     inline int y() const { return qRound(position().y()); }
0344     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition().x()")
0345     inline int globalX() const { return qRound(globalPosition().x()); }
0346     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition().y()")
0347     inline int globalY() const { return qRound(globalPosition().y()); }
0348     QT_DEPRECATED_VERSION_X_6_0("use globalPosition().x()")
0349     inline qreal hiResGlobalX() const { return globalPosition().x(); }
0350     QT_DEPRECATED_VERSION_X_6_0("use globalPosition().y()")
0351     inline qreal hiResGlobalY() const { return globalPosition().y(); }
0352     QT_DEPRECATED_VERSION_X_6_0("use pointingDevice().uniqueId()")
0353     inline qint64 uniqueId() const { return pointingDevice() ? pointingDevice()->uniqueId().numericId() : -1; }
0354 #endif
0355     inline qreal pressure() const { Q_ASSERT(!points().isEmpty()); return points().first().pressure(); }
0356     inline qreal rotation() const { Q_ASSERT(!points().isEmpty()); return points().first().rotation(); }
0357     inline qreal z() const { return m_z; }
0358     inline qreal tangentialPressure() const { return m_tangential; }
0359     inline qreal xTilt() const { return m_xTilt; }
0360     inline qreal yTilt() const { return m_yTilt; }
0361 
0362 protected:
0363     float m_tangential;
0364     float m_xTilt;
0365     float m_yTilt;
0366     float m_z;
0367 };
0368 #endif // QT_CONFIG(tabletevent)
0369 
0370 #if QT_CONFIG(gestures)
0371 class Q_GUI_EXPORT QNativeGestureEvent : public QSinglePointEvent
0372 {
0373     Q_DECL_EVENT_COMMON(QNativeGestureEvent)
0374 public:
0375 #if QT_DEPRECATED_SINCE(6, 2)
0376     QT_DEPRECATED_VERSION_X_6_2("Use the other constructor")
0377     QNativeGestureEvent(Qt::NativeGestureType type, const QPointingDevice *dev, const QPointF &localPos, const QPointF &scenePos,
0378                         const QPointF &globalPos, qreal value, quint64 sequenceId, quint64 intArgument);
0379 #endif
0380     QNativeGestureEvent(Qt::NativeGestureType type, const QPointingDevice *dev, int fingerCount,
0381                         const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos,
0382                         qreal value, const QPointF &delta, quint64 sequenceId = UINT64_MAX);
0383 
0384     Qt::NativeGestureType gestureType() const { return m_gestureType; }
0385     int fingerCount() const { return m_fingerCount; }
0386     qreal value() const { return m_realValue; }
0387     QPointF delta() const {
0388 #if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
0389         return m_delta.toPointF();
0390 #else
0391         return m_delta;
0392 #endif
0393     }
0394 
0395 #if QT_DEPRECATED_SINCE(6, 0)
0396 #ifndef QT_NO_INTEGER_EVENT_COORDINATES
0397     QT_DEPRECATED_VERSION_X_6_0("Use position().toPoint()")
0398     inline const QPoint pos() const { return position().toPoint(); }
0399     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition().toPoint()")
0400     inline const QPoint globalPos() const { return globalPosition().toPoint(); }
0401 #endif
0402     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0403     QPointF localPos() const { return position(); }
0404     QT_DEPRECATED_VERSION_X_6_0("Use scenePosition()")
0405     QPointF windowPos() const { return scenePosition(); }
0406     QT_DEPRECATED_VERSION_X_6_0("Use globalPosition()")
0407     QPointF screenPos() const { return globalPosition(); }
0408 #endif
0409 
0410 protected:
0411     quint64 m_sequenceId;
0412 #if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
0413     QVector2D m_delta;
0414 #else
0415     QPointF m_delta;
0416 #endif
0417     qreal m_realValue;
0418     Qt::NativeGestureType m_gestureType;
0419     quint32 m_fingerCount : 4;
0420     quint32 m_reserved : 28;
0421 };
0422 #endif // QT_CONFIG(gestures)
0423 
0424 class Q_GUI_EXPORT QKeyEvent : public QInputEvent
0425 {
0426     Q_DECL_EVENT_COMMON(QKeyEvent)
0427 public:
0428     QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text = QString(),
0429               bool autorep = false, quint16 count = 1);
0430     QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers,
0431               quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers,
0432               const QString &text = QString(), bool autorep = false, quint16 count = 1,
0433               const QInputDevice *device = QInputDevice::primaryKeyboard());
0434 
0435     int key() const { return m_key; }
0436 #if QT_CONFIG(shortcut)
0437     bool matches(QKeySequence::StandardKey key) const;
0438 #endif
0439     Qt::KeyboardModifiers modifiers() const;
0440     QKeyCombination keyCombination() const
0441     {
0442         return QKeyCombination(modifiers(), Qt::Key(m_key));
0443     }
0444     inline QString text() const { return m_text; }
0445     inline bool isAutoRepeat() const { return m_autoRepeat; }
0446     inline int count() const { return int(m_count); }
0447 
0448     inline quint32 nativeScanCode() const { return m_scanCode; }
0449     inline quint32 nativeVirtualKey() const { return m_virtualKey; }
0450     inline quint32 nativeModifiers() const { return m_nativeModifiers; }
0451 
0452 #if QT_CONFIG(shortcut)
0453     friend inline bool operator==(QKeyEvent *e, QKeySequence::StandardKey key)
0454     { return (e ? e->matches(key) : false); }
0455     friend inline bool operator==(QKeySequence::StandardKey key, QKeyEvent *e)
0456     { return (e ? e->matches(key) : false); }
0457 #endif // QT_CONFIG(shortcut)
0458 
0459 protected:
0460     QString m_text;
0461     int m_key;
0462     quint32 m_scanCode;
0463     quint32 m_virtualKey;
0464     quint32 m_nativeModifiers;
0465     quint16 m_count      : 15;
0466     quint16 m_autoRepeat : 1;
0467 };
0468 
0469 
0470 class Q_GUI_EXPORT QFocusEvent : public QEvent
0471 {
0472     Q_DECL_EVENT_COMMON(QFocusEvent)
0473 public:
0474     explicit QFocusEvent(Type type, Qt::FocusReason reason=Qt::OtherFocusReason);
0475 
0476     inline bool gotFocus() const { return type() == FocusIn; }
0477     inline bool lostFocus() const { return type() == FocusOut; }
0478 
0479     Qt::FocusReason reason() const;
0480 
0481 private:
0482     Qt::FocusReason m_reason;
0483 };
0484 
0485 
0486 class Q_GUI_EXPORT QPaintEvent : public QEvent
0487 {
0488     Q_DECL_EVENT_COMMON(QPaintEvent)
0489 public:
0490     explicit QPaintEvent(const QRegion& paintRegion);
0491     explicit QPaintEvent(const QRect &paintRect);
0492 
0493     inline const QRect &rect() const { return m_rect; }
0494     inline const QRegion &region() const { return m_region; }
0495 
0496 protected:
0497     QRect m_rect;
0498     QRegion m_region;
0499     bool m_erased;
0500 };
0501 
0502 class Q_GUI_EXPORT QMoveEvent : public QEvent
0503 {
0504     Q_DECL_EVENT_COMMON(QMoveEvent)
0505 public:
0506     QMoveEvent(const QPoint &pos, const QPoint &oldPos);
0507 
0508     inline const QPoint &pos() const { return m_pos; }
0509     inline const QPoint &oldPos() const { return m_oldPos;}
0510 protected:
0511     QPoint m_pos, m_oldPos;
0512     friend class QApplication;
0513     friend class QApplicationPrivate;
0514 };
0515 
0516 class Q_GUI_EXPORT QExposeEvent : public QEvent
0517 {
0518     Q_DECL_EVENT_COMMON(QExposeEvent)
0519 public:
0520     explicit QExposeEvent(const QRegion &m_region);
0521 
0522 #if QT_DEPRECATED_SINCE(6, 0)
0523     QT_DEPRECATED_VERSION_X_6_0("Handle QPaintEvent instead")
0524     inline const QRegion &region() const { return m_region; }
0525 #endif
0526 
0527 protected:
0528     QRegion m_region;
0529     friend class QWidgetWindow;
0530 };
0531 
0532 class Q_GUI_EXPORT QPlatformSurfaceEvent : public QEvent
0533 {
0534     Q_DECL_EVENT_COMMON(QPlatformSurfaceEvent)
0535 public:
0536     enum SurfaceEventType {
0537         SurfaceCreated,
0538         SurfaceAboutToBeDestroyed
0539     };
0540 
0541     explicit QPlatformSurfaceEvent(SurfaceEventType surfaceEventType);
0542 
0543     inline SurfaceEventType surfaceEventType() const { return m_surfaceEventType; }
0544 
0545 protected:
0546     SurfaceEventType m_surfaceEventType;
0547 };
0548 
0549 class Q_GUI_EXPORT QResizeEvent : public QEvent
0550 {
0551     Q_DECL_EVENT_COMMON(QResizeEvent)
0552 public:
0553     QResizeEvent(const QSize &size, const QSize &oldSize);
0554 
0555     inline const QSize &size() const { return m_size; }
0556     inline const QSize &oldSize()const { return m_oldSize;}
0557 protected:
0558     QSize m_size, m_oldSize;
0559     friend class QApplication;
0560     friend class QApplicationPrivate;
0561 };
0562 
0563 
0564 class Q_GUI_EXPORT QCloseEvent : public QEvent
0565 {
0566     Q_DECL_EVENT_COMMON(QCloseEvent)
0567 public:
0568     QCloseEvent();
0569 };
0570 
0571 
0572 class Q_GUI_EXPORT QIconDragEvent : public QEvent
0573 {
0574     Q_DECL_EVENT_COMMON(QIconDragEvent)
0575 public:
0576     QIconDragEvent();
0577 };
0578 
0579 
0580 class Q_GUI_EXPORT QShowEvent : public QEvent
0581 {
0582     Q_DECL_EVENT_COMMON(QShowEvent)
0583 public:
0584     QShowEvent();
0585 };
0586 
0587 
0588 class Q_GUI_EXPORT QHideEvent : public QEvent
0589 {
0590     Q_DECL_EVENT_COMMON(QHideEvent)
0591 public:
0592     QHideEvent();
0593 };
0594 
0595 #ifndef QT_NO_CONTEXTMENU
0596 class Q_GUI_EXPORT QContextMenuEvent : public QInputEvent
0597 {
0598     Q_DECL_EVENT_COMMON(QContextMenuEvent)
0599 public:
0600     enum Reason { Mouse, Keyboard, Other };
0601 
0602     QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos,
0603                       Qt::KeyboardModifiers modifiers = Qt::NoModifier);
0604 #if QT_DEPRECATED_SINCE(6, 4)
0605     QT_DEPRECATED_VERSION_X_6_4("Use the other constructor")
0606     QContextMenuEvent(Reason reason, const QPoint &pos);
0607 #endif
0608 
0609     inline int x() const { return m_pos.x(); }
0610     inline int y() const { return m_pos.y(); }
0611     inline int globalX() const { return m_globalPos.x(); }
0612     inline int globalY() const { return m_globalPos.y(); }
0613 
0614     inline const QPoint& pos() const { return m_pos; }
0615     inline const QPoint& globalPos() const { return m_globalPos; }
0616 
0617     inline Reason reason() const { return Reason(m_reason); }
0618 
0619 protected:
0620     QPoint m_pos;
0621     QPoint m_globalPos;
0622     uint m_reason : 8;
0623 };
0624 #endif // QT_NO_CONTEXTMENU
0625 
0626 #ifndef QT_NO_INPUTMETHOD
0627 class Q_GUI_EXPORT QInputMethodEvent : public QEvent
0628 {
0629     Q_DECL_EVENT_COMMON(QInputMethodEvent)
0630 public:
0631     enum AttributeType {
0632        TextFormat,
0633        Cursor,
0634        Language,
0635        Ruby,
0636        Selection,
0637        MimeData
0638     };
0639     class Attribute {
0640     public:
0641         Attribute(AttributeType typ, int s, int l, QVariant val) : type(typ), start(s), length(l), value(std::move(val)) {}
0642         Attribute(AttributeType typ, int s, int l) : type(typ), start(s), length(l), value() {}
0643 
0644         AttributeType type;
0645         int start;
0646         int length;
0647         QVariant value;
0648     };
0649     QInputMethodEvent();
0650     QInputMethodEvent(const QString &preeditText, const QList<Attribute> &attributes);
0651 
0652     void setCommitString(const QString &commitString, int replaceFrom = 0, int replaceLength = 0);
0653     inline const QList<Attribute> &attributes() const { return m_attributes; }
0654     inline const QString &preeditString() const { return m_preedit; }
0655 
0656     inline const QString &commitString() const { return m_commit; }
0657     inline int replacementStart() const { return m_replacementStart; }
0658     inline int replacementLength() const { return m_replacementLength; }
0659 
0660     inline friend bool operator==(const QInputMethodEvent::Attribute &lhs,
0661                                   const QInputMethodEvent::Attribute &rhs)
0662     {
0663         return lhs.type == rhs.type && lhs.start == rhs.start
0664                 && lhs.length == rhs.length && lhs.value == rhs.value;
0665     }
0666 
0667     inline friend bool operator!=(const QInputMethodEvent::Attribute &lhs,
0668                                   const QInputMethodEvent::Attribute &rhs)
0669     {
0670         return !(lhs == rhs);
0671     }
0672 
0673 private:
0674     QString m_preedit;
0675     QString m_commit;
0676     QList<Attribute> m_attributes;
0677     int m_replacementStart;
0678     int m_replacementLength;
0679 };
0680 Q_DECLARE_TYPEINFO(QInputMethodEvent::Attribute, Q_RELOCATABLE_TYPE);
0681 
0682 class Q_GUI_EXPORT QInputMethodQueryEvent : public QEvent
0683 {
0684     Q_DECL_EVENT_COMMON(QInputMethodQueryEvent)
0685 public:
0686     explicit QInputMethodQueryEvent(Qt::InputMethodQueries queries);
0687 
0688     Qt::InputMethodQueries queries() const { return m_queries; }
0689 
0690     void setValue(Qt::InputMethodQuery query, const QVariant &value);
0691     QVariant value(Qt::InputMethodQuery query) const;
0692 private:
0693     Qt::InputMethodQueries m_queries;
0694     struct QueryPair {
0695         Qt::InputMethodQuery query;
0696         QVariant value;
0697     };
0698     friend QTypeInfo<QueryPair>;
0699     QList<QueryPair> m_values;
0700 };
0701 Q_DECLARE_TYPEINFO(QInputMethodQueryEvent::QueryPair, Q_RELOCATABLE_TYPE);
0702 
0703 #endif // QT_NO_INPUTMETHOD
0704 
0705 #if QT_CONFIG(draganddrop)
0706 
0707 class QMimeData;
0708 
0709 class Q_GUI_EXPORT QDropEvent : public QEvent
0710 {
0711     Q_DECL_EVENT_COMMON(QDropEvent)
0712 public:
0713     QDropEvent(const QPointF& pos, Qt::DropActions actions, const QMimeData *data,
0714                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop);
0715 
0716 #if QT_DEPRECATED_SINCE(6, 0)
0717     QT_DEPRECATED_VERSION_X_6_0("Use position().toPoint()")
0718     inline QPoint pos() const { return position().toPoint(); }
0719     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0720     inline QPointF posF() const { return position(); }
0721     QT_DEPRECATED_VERSION_X_6_0("Use buttons()")
0722     inline Qt::MouseButtons mouseButtons() const { return buttons(); }
0723     QT_DEPRECATED_VERSION_X_6_0("Use modifiers()")
0724     inline Qt::KeyboardModifiers keyboardModifiers() const { return modifiers(); }
0725 #endif // QT_DEPRECATED_SINCE(6, 0)
0726 
0727     QPointF position() const { return m_pos; }
0728     inline Qt::MouseButtons buttons() const { return m_mouseState; }
0729     inline Qt::KeyboardModifiers modifiers() const { return m_modState; }
0730 
0731     inline Qt::DropActions possibleActions() const { return m_actions; }
0732     inline Qt::DropAction proposedAction() const { return m_defaultAction; }
0733     inline void acceptProposedAction() { m_dropAction = m_defaultAction; accept(); }
0734 
0735     inline Qt::DropAction dropAction() const { return m_dropAction; }
0736     void setDropAction(Qt::DropAction action);
0737 
0738     QObject* source() const;
0739     inline const QMimeData *mimeData() const { return m_data; }
0740 
0741 protected:
0742     friend class QApplication;
0743     QPointF m_pos;
0744     Qt::MouseButtons m_mouseState;
0745     Qt::KeyboardModifiers m_modState;
0746     Qt::DropActions m_actions;
0747     Qt::DropAction m_dropAction;
0748     Qt::DropAction m_defaultAction;
0749     const QMimeData *m_data;
0750 };
0751 
0752 
0753 class Q_GUI_EXPORT QDragMoveEvent : public QDropEvent
0754 {
0755     Q_DECL_EVENT_COMMON(QDragMoveEvent)
0756 public:
0757     QDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data,
0758                    Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove);
0759 
0760     inline QRect answerRect() const { return m_rect; }
0761 
0762     inline void accept() { QDropEvent::accept(); }
0763     inline void ignore() { QDropEvent::ignore(); }
0764 
0765     inline void accept(const QRect & r) { accept(); m_rect = r; }
0766     inline void ignore(const QRect & r) { ignore(); m_rect = r; }
0767 
0768 protected:
0769     QRect m_rect;
0770 };
0771 
0772 
0773 class Q_GUI_EXPORT QDragEnterEvent : public QDragMoveEvent
0774 {
0775     Q_DECL_EVENT_COMMON(QDragEnterEvent)
0776 public:
0777     QDragEnterEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data,
0778                     Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
0779 };
0780 
0781 
0782 class Q_GUI_EXPORT QDragLeaveEvent : public QEvent
0783 {
0784     Q_DECL_EVENT_COMMON(QDragLeaveEvent)
0785 public:
0786     QDragLeaveEvent();
0787 };
0788 #endif // QT_CONFIG(draganddrop)
0789 
0790 
0791 class Q_GUI_EXPORT QHelpEvent : public QEvent
0792 {
0793     Q_DECL_EVENT_COMMON(QHelpEvent)
0794 public:
0795     QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos);
0796 
0797     inline int x() const { return m_pos.x(); }
0798     inline int y() const { return m_pos.y(); }
0799     inline int globalX() const { return m_globalPos.x(); }
0800     inline int globalY() const { return m_globalPos.y(); }
0801 
0802     inline const QPoint& pos()  const { return m_pos; }
0803     inline const QPoint& globalPos() const { return m_globalPos; }
0804 
0805 private:
0806     QPoint m_pos;
0807     QPoint m_globalPos;
0808 };
0809 
0810 #ifndef QT_NO_STATUSTIP
0811 class Q_GUI_EXPORT QStatusTipEvent : public QEvent
0812 {
0813     Q_DECL_EVENT_COMMON(QStatusTipEvent)
0814 public:
0815     explicit QStatusTipEvent(const QString &tip);
0816 
0817     inline QString tip() const { return m_tip; }
0818 private:
0819     QString m_tip;
0820 };
0821 #endif
0822 
0823 #if QT_CONFIG(whatsthis)
0824 class Q_GUI_EXPORT QWhatsThisClickedEvent : public QEvent
0825 {
0826     Q_DECL_EVENT_COMMON(QWhatsThisClickedEvent)
0827 public:
0828     explicit QWhatsThisClickedEvent(const QString &href);
0829 
0830     inline QString href() const { return m_href; }
0831 private:
0832     QString m_href;
0833 };
0834 #endif
0835 
0836 #if QT_CONFIG(action)
0837 class Q_GUI_EXPORT QActionEvent : public QEvent
0838 {
0839     Q_DECL_EVENT_COMMON(QActionEvent)
0840 public:
0841     QActionEvent(int type, QAction *action, QAction *before = nullptr);
0842 
0843     inline QAction *action() const { return m_action; }
0844     inline QAction *before() const { return m_before; }
0845 private:
0846     QAction *m_action;
0847     QAction *m_before;
0848 };
0849 #endif // QT_CONFIG(action)
0850 
0851 class Q_GUI_EXPORT QFileOpenEvent : public QEvent
0852 {
0853     Q_DECL_EVENT_COMMON(QFileOpenEvent)
0854 public:
0855     explicit QFileOpenEvent(const QString &file);
0856     explicit QFileOpenEvent(const QUrl &url);
0857 
0858     inline QString file() const { return m_file; }
0859     QUrl url() const { return m_url; }
0860 #if QT_DEPRECATED_SINCE(6, 6)
0861     QT_DEPRECATED_VERSION_X_6_6("Interpret the string returned by file()")
0862     bool openFile(QFile &file, QIODevice::OpenMode flags) const;
0863 #endif
0864 private:
0865     QString m_file;
0866     QUrl m_url;
0867 };
0868 
0869 #ifndef QT_NO_TOOLBAR
0870 class Q_GUI_EXPORT QToolBarChangeEvent : public QEvent
0871 {
0872     Q_DECL_EVENT_COMMON(QToolBarChangeEvent)
0873 public:
0874     explicit QToolBarChangeEvent(bool t);
0875 
0876     inline bool toggle() const { return m_toggle; }
0877 private:
0878     bool m_toggle;
0879 };
0880 #endif
0881 
0882 #if QT_CONFIG(shortcut)
0883 class Q_GUI_EXPORT QShortcutEvent : public QEvent
0884 {
0885     Q_DECL_EVENT_COMMON(QShortcutEvent)
0886 public:
0887     // Note this is publicly deprecated, but should remain as internal constructor:
0888     QShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false);
0889     QShortcutEvent(const QKeySequence &key, const QShortcut *shortcut = nullptr, bool ambiguous = false);
0890 
0891     inline const QKeySequence &key() const { return m_sequence; }
0892     // Note this is publicly deprecated, but should remain as internal getter:
0893     inline int shortcutId() const { return m_shortcutId; }
0894     inline bool isAmbiguous() const { return m_ambiguous; }
0895 protected:
0896     QKeySequence m_sequence;
0897     int  m_shortcutId;
0898     bool m_ambiguous;
0899 };
0900 #endif
0901 
0902 class Q_GUI_EXPORT QWindowStateChangeEvent: public QEvent
0903 {
0904     Q_DECL_EVENT_COMMON(QWindowStateChangeEvent)
0905 public:
0906     explicit QWindowStateChangeEvent(Qt::WindowStates oldState, bool isOverride = false);
0907 
0908     inline Qt::WindowStates oldState() const { return m_oldStates; }
0909     bool isOverride() const;
0910 
0911 private:
0912     Qt::WindowStates m_oldStates;
0913     bool m_override;
0914 };
0915 
0916 #ifndef QT_NO_DEBUG_STREAM
0917 // ### Qt 7: move this to Qt Core and add a hook to allow GUI events to be printed: QTBUG-127680
0918 Q_GUI_EXPORT QDebug operator<<(QDebug, const QEvent *);
0919 #endif
0920 
0921 class Q_GUI_EXPORT QTouchEvent : public QPointerEvent
0922 {
0923     Q_DECL_EVENT_COMMON(QTouchEvent)
0924 public:
0925     using TouchPoint = QEventPoint; // source compat
0926 
0927     explicit QTouchEvent(QEvent::Type eventType,
0928                          const QPointingDevice *device = nullptr,
0929                          Qt::KeyboardModifiers modifiers = Qt::NoModifier,
0930                          const QList<QEventPoint> &touchPoints = {});
0931 #if QT_DEPRECATED_SINCE(6, 0)
0932     QT_DEPRECATED_VERSION_X_6_0("Use another constructor")
0933     explicit QTouchEvent(QEvent::Type eventType,
0934                          const QPointingDevice *device,
0935                          Qt::KeyboardModifiers modifiers,
0936                          QEventPoint::States touchPointStates,
0937                          const QList<QEventPoint> &touchPoints = {});
0938 #endif
0939 
0940     inline QObject *target() const { return m_target; }
0941     inline QEventPoint::States touchPointStates() const { return m_touchPointStates; }
0942 #if QT_DEPRECATED_SINCE(6, 0)
0943     QT_DEPRECATED_VERSION_X_6_0("Use points()")
0944     const QList<QEventPoint> &touchPoints() const { return points(); }
0945 #endif
0946     bool isBeginEvent() const override;
0947     bool isUpdateEvent() const override;
0948     bool isEndEvent() const override;
0949 
0950 protected:
0951     friend class QMutableTouchEvent;
0952     QObject *m_target = nullptr;
0953     QEventPoint::States m_touchPointStates = QEventPoint::State::Unknown;
0954     quint32 m_reserved : 24;
0955 };
0956 
0957 class Q_GUI_EXPORT QScrollPrepareEvent : public QEvent
0958 {
0959     Q_DECL_EVENT_COMMON(QScrollPrepareEvent)
0960 public:
0961     explicit QScrollPrepareEvent(const QPointF &startPos);
0962 
0963     QPointF startPos() const { return m_startPos; }
0964 
0965     QSizeF viewportSize() const { return m_viewportSize; }
0966     QRectF contentPosRange() const { return m_contentPosRange; }
0967     QPointF contentPos() const { return m_contentPos; }
0968 
0969     void setViewportSize(const QSizeF &size);
0970     void setContentPosRange(const QRectF &rect);
0971     void setContentPos(const QPointF &pos);
0972 
0973 private:
0974     QRectF m_contentPosRange;
0975     QSizeF m_viewportSize;
0976     QPointF m_startPos;
0977     QPointF m_contentPos;
0978 };
0979 
0980 
0981 class Q_GUI_EXPORT QScrollEvent : public QEvent
0982 {
0983     Q_DECL_EVENT_COMMON(QScrollEvent)
0984 public:
0985     enum ScrollState
0986     {
0987         ScrollStarted,
0988         ScrollUpdated,
0989         ScrollFinished
0990     };
0991 
0992     QScrollEvent(const QPointF &contentPos, const QPointF &overshoot, ScrollState scrollState);
0993 
0994     QPointF contentPos() const { return m_contentPos; }
0995     QPointF overshootDistance() const { return m_overshoot; }
0996     ScrollState scrollState() const { return m_state; }
0997 
0998 private:
0999     QPointF m_contentPos;
1000     QPointF m_overshoot;
1001     QScrollEvent::ScrollState m_state;
1002 };
1003 
1004 class Q_GUI_EXPORT QScreenOrientationChangeEvent : public QEvent
1005 {
1006     Q_DECL_EVENT_COMMON(QScreenOrientationChangeEvent)
1007 public:
1008     QScreenOrientationChangeEvent(QScreen *screen, Qt::ScreenOrientation orientation);
1009 
1010     QScreen *screen() const { return m_screen; }
1011     Qt::ScreenOrientation orientation() const { return m_orientation; }
1012 
1013 private:
1014     QScreen *m_screen;
1015     Qt::ScreenOrientation m_orientation;
1016 };
1017 
1018 class Q_GUI_EXPORT QApplicationStateChangeEvent : public QEvent
1019 {
1020     Q_DECL_EVENT_COMMON(QApplicationStateChangeEvent)
1021 public:
1022     explicit QApplicationStateChangeEvent(Qt::ApplicationState state);
1023 
1024     Qt::ApplicationState applicationState() const { return m_applicationState; }
1025 
1026 private:
1027     Qt::ApplicationState m_applicationState;
1028 };
1029 
1030 class Q_GUI_EXPORT QChildWindowEvent : public QEvent
1031 {
1032     Q_DECL_EVENT_COMMON(QChildWindowEvent)
1033 public:
1034     explicit QChildWindowEvent(Type type, QWindow *childWindow);
1035     QWindow *child() const { return c; }
1036 
1037 private:
1038     QWindow *c;
1039 };
1040 
1041 QT_END_NAMESPACE
1042 
1043 #endif // QEVENT_H
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!