Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-09-16 09:04:59 

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 };
0514 
0515 class Q_GUI_EXPORT QExposeEvent : public QEvent
0516 {
0517     Q_DECL_EVENT_COMMON(QExposeEvent)
0518 public:
0519     explicit QExposeEvent(const QRegion &m_region);
0520 
0521 #if QT_DEPRECATED_SINCE(6, 0)
0522     QT_DEPRECATED_VERSION_X_6_0("Handle QPaintEvent instead")
0523     inline const QRegion &region() const { return m_region; }
0524 #endif
0525 
0526 protected:
0527     QRegion m_region;
0528     friend class QWidgetWindow;
0529 };
0530 
0531 class Q_GUI_EXPORT QPlatformSurfaceEvent : public QEvent
0532 {
0533     Q_DECL_EVENT_COMMON(QPlatformSurfaceEvent)
0534 public:
0535     enum SurfaceEventType {
0536         SurfaceCreated,
0537         SurfaceAboutToBeDestroyed
0538     };
0539 
0540     explicit QPlatformSurfaceEvent(SurfaceEventType surfaceEventType);
0541 
0542     inline SurfaceEventType surfaceEventType() const { return m_surfaceEventType; }
0543 
0544 protected:
0545     SurfaceEventType m_surfaceEventType;
0546 };
0547 
0548 class Q_GUI_EXPORT QResizeEvent : public QEvent
0549 {
0550     Q_DECL_EVENT_COMMON(QResizeEvent)
0551 public:
0552     QResizeEvent(const QSize &size, const QSize &oldSize);
0553 
0554     inline const QSize &size() const { return m_size; }
0555     inline const QSize &oldSize()const { return m_oldSize;}
0556 protected:
0557     QSize m_size, m_oldSize;
0558     friend class QApplication;
0559 };
0560 
0561 
0562 class Q_GUI_EXPORT QCloseEvent : public QEvent
0563 {
0564     Q_DECL_EVENT_COMMON(QCloseEvent)
0565 public:
0566     QCloseEvent();
0567 };
0568 
0569 
0570 class Q_GUI_EXPORT QIconDragEvent : public QEvent
0571 {
0572     Q_DECL_EVENT_COMMON(QIconDragEvent)
0573 public:
0574     QIconDragEvent();
0575 };
0576 
0577 
0578 class Q_GUI_EXPORT QShowEvent : public QEvent
0579 {
0580     Q_DECL_EVENT_COMMON(QShowEvent)
0581 public:
0582     QShowEvent();
0583 };
0584 
0585 
0586 class Q_GUI_EXPORT QHideEvent : public QEvent
0587 {
0588     Q_DECL_EVENT_COMMON(QHideEvent)
0589 public:
0590     QHideEvent();
0591 };
0592 
0593 #ifndef QT_NO_CONTEXTMENU
0594 class Q_GUI_EXPORT QContextMenuEvent : public QInputEvent
0595 {
0596     Q_DECL_EVENT_COMMON(QContextMenuEvent)
0597 public:
0598     enum Reason { Mouse, Keyboard, Other };
0599 
0600     QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos,
0601                       Qt::KeyboardModifiers modifiers = Qt::NoModifier);
0602 #if QT_DEPRECATED_SINCE(6, 4)
0603     QT_DEPRECATED_VERSION_X_6_4("Use the other constructor")
0604     QContextMenuEvent(Reason reason, const QPoint &pos);
0605 #endif
0606 
0607     inline int x() const { return m_pos.x(); }
0608     inline int y() const { return m_pos.y(); }
0609     inline int globalX() const { return m_globalPos.x(); }
0610     inline int globalY() const { return m_globalPos.y(); }
0611 
0612     inline const QPoint& pos() const { return m_pos; }
0613     inline const QPoint& globalPos() const { return m_globalPos; }
0614 
0615     inline Reason reason() const { return Reason(m_reason); }
0616 
0617 protected:
0618     QPoint m_pos;
0619     QPoint m_globalPos;
0620     uint m_reason : 8;
0621 };
0622 #endif // QT_NO_CONTEXTMENU
0623 
0624 #ifndef QT_NO_INPUTMETHOD
0625 class Q_GUI_EXPORT QInputMethodEvent : public QEvent
0626 {
0627     Q_DECL_EVENT_COMMON(QInputMethodEvent)
0628 public:
0629     enum AttributeType {
0630        TextFormat,
0631        Cursor,
0632        Language,
0633        Ruby,
0634        Selection
0635     };
0636     class Attribute {
0637     public:
0638         Attribute(AttributeType typ, int s, int l, QVariant val) : type(typ), start(s), length(l), value(std::move(val)) {}
0639         Attribute(AttributeType typ, int s, int l) : type(typ), start(s), length(l), value() {}
0640 
0641         AttributeType type;
0642         int start;
0643         int length;
0644         QVariant value;
0645     };
0646     QInputMethodEvent();
0647     QInputMethodEvent(const QString &preeditText, const QList<Attribute> &attributes);
0648 
0649     void setCommitString(const QString &commitString, int replaceFrom = 0, int replaceLength = 0);
0650     inline const QList<Attribute> &attributes() const { return m_attributes; }
0651     inline const QString &preeditString() const { return m_preedit; }
0652 
0653     inline const QString &commitString() const { return m_commit; }
0654     inline int replacementStart() const { return m_replacementStart; }
0655     inline int replacementLength() const { return m_replacementLength; }
0656 
0657     inline friend bool operator==(const QInputMethodEvent::Attribute &lhs,
0658                                   const QInputMethodEvent::Attribute &rhs)
0659     {
0660         return lhs.type == rhs.type && lhs.start == rhs.start
0661                 && lhs.length == rhs.length && lhs.value == rhs.value;
0662     }
0663 
0664     inline friend bool operator!=(const QInputMethodEvent::Attribute &lhs,
0665                                   const QInputMethodEvent::Attribute &rhs)
0666     {
0667         return !(lhs == rhs);
0668     }
0669 
0670 private:
0671     QString m_preedit;
0672     QString m_commit;
0673     QList<Attribute> m_attributes;
0674     int m_replacementStart;
0675     int m_replacementLength;
0676 };
0677 Q_DECLARE_TYPEINFO(QInputMethodEvent::Attribute, Q_RELOCATABLE_TYPE);
0678 
0679 class Q_GUI_EXPORT QInputMethodQueryEvent : public QEvent
0680 {
0681     Q_DECL_EVENT_COMMON(QInputMethodQueryEvent)
0682 public:
0683     explicit QInputMethodQueryEvent(Qt::InputMethodQueries queries);
0684 
0685     Qt::InputMethodQueries queries() const { return m_queries; }
0686 
0687     void setValue(Qt::InputMethodQuery query, const QVariant &value);
0688     QVariant value(Qt::InputMethodQuery query) const;
0689 private:
0690     Qt::InputMethodQueries m_queries;
0691     struct QueryPair {
0692         Qt::InputMethodQuery query;
0693         QVariant value;
0694     };
0695     friend QTypeInfo<QueryPair>;
0696     QList<QueryPair> m_values;
0697 };
0698 Q_DECLARE_TYPEINFO(QInputMethodQueryEvent::QueryPair, Q_RELOCATABLE_TYPE);
0699 
0700 #endif // QT_NO_INPUTMETHOD
0701 
0702 #if QT_CONFIG(draganddrop)
0703 
0704 class QMimeData;
0705 
0706 class Q_GUI_EXPORT QDropEvent : public QEvent
0707 {
0708     Q_DECL_EVENT_COMMON(QDropEvent)
0709 public:
0710     QDropEvent(const QPointF& pos, Qt::DropActions actions, const QMimeData *data,
0711                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop);
0712 
0713 #if QT_DEPRECATED_SINCE(6, 0)
0714     QT_DEPRECATED_VERSION_X_6_0("Use position().toPoint()")
0715     inline QPoint pos() const { return position().toPoint(); }
0716     QT_DEPRECATED_VERSION_X_6_0("Use position()")
0717     inline QPointF posF() const { return position(); }
0718     QT_DEPRECATED_VERSION_X_6_0("Use buttons()")
0719     inline Qt::MouseButtons mouseButtons() const { return buttons(); }
0720     QT_DEPRECATED_VERSION_X_6_0("Use modifiers()")
0721     inline Qt::KeyboardModifiers keyboardModifiers() const { return modifiers(); }
0722 #endif // QT_DEPRECATED_SINCE(6, 0)
0723 
0724     QPointF position() const { return m_pos; }
0725     inline Qt::MouseButtons buttons() const { return m_mouseState; }
0726     inline Qt::KeyboardModifiers modifiers() const { return m_modState; }
0727 
0728     inline Qt::DropActions possibleActions() const { return m_actions; }
0729     inline Qt::DropAction proposedAction() const { return m_defaultAction; }
0730     inline void acceptProposedAction() { m_dropAction = m_defaultAction; accept(); }
0731 
0732     inline Qt::DropAction dropAction() const { return m_dropAction; }
0733     void setDropAction(Qt::DropAction action);
0734 
0735     QObject* source() const;
0736     inline const QMimeData *mimeData() const { return m_data; }
0737 
0738 protected:
0739     friend class QApplication;
0740     QPointF m_pos;
0741     Qt::MouseButtons m_mouseState;
0742     Qt::KeyboardModifiers m_modState;
0743     Qt::DropActions m_actions;
0744     Qt::DropAction m_dropAction;
0745     Qt::DropAction m_defaultAction;
0746     const QMimeData *m_data;
0747 };
0748 
0749 
0750 class Q_GUI_EXPORT QDragMoveEvent : public QDropEvent
0751 {
0752     Q_DECL_EVENT_COMMON(QDragMoveEvent)
0753 public:
0754     QDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data,
0755                    Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove);
0756 
0757     inline QRect answerRect() const { return m_rect; }
0758 
0759     inline void accept() { QDropEvent::accept(); }
0760     inline void ignore() { QDropEvent::ignore(); }
0761 
0762     inline void accept(const QRect & r) { accept(); m_rect = r; }
0763     inline void ignore(const QRect & r) { ignore(); m_rect = r; }
0764 
0765 protected:
0766     QRect m_rect;
0767 };
0768 
0769 
0770 class Q_GUI_EXPORT QDragEnterEvent : public QDragMoveEvent
0771 {
0772     Q_DECL_EVENT_COMMON(QDragEnterEvent)
0773 public:
0774     QDragEnterEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data,
0775                     Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
0776 };
0777 
0778 
0779 class Q_GUI_EXPORT QDragLeaveEvent : public QEvent
0780 {
0781     Q_DECL_EVENT_COMMON(QDragLeaveEvent)
0782 public:
0783     QDragLeaveEvent();
0784 };
0785 #endif // QT_CONFIG(draganddrop)
0786 
0787 
0788 class Q_GUI_EXPORT QHelpEvent : public QEvent
0789 {
0790     Q_DECL_EVENT_COMMON(QHelpEvent)
0791 public:
0792     QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos);
0793 
0794     inline int x() const { return m_pos.x(); }
0795     inline int y() const { return m_pos.y(); }
0796     inline int globalX() const { return m_globalPos.x(); }
0797     inline int globalY() const { return m_globalPos.y(); }
0798 
0799     inline const QPoint& pos()  const { return m_pos; }
0800     inline const QPoint& globalPos() const { return m_globalPos; }
0801 
0802 private:
0803     QPoint m_pos;
0804     QPoint m_globalPos;
0805 };
0806 
0807 #ifndef QT_NO_STATUSTIP
0808 class Q_GUI_EXPORT QStatusTipEvent : public QEvent
0809 {
0810     Q_DECL_EVENT_COMMON(QStatusTipEvent)
0811 public:
0812     explicit QStatusTipEvent(const QString &tip);
0813 
0814     inline QString tip() const { return m_tip; }
0815 private:
0816     QString m_tip;
0817 };
0818 #endif
0819 
0820 #if QT_CONFIG(whatsthis)
0821 class Q_GUI_EXPORT QWhatsThisClickedEvent : public QEvent
0822 {
0823     Q_DECL_EVENT_COMMON(QWhatsThisClickedEvent)
0824 public:
0825     explicit QWhatsThisClickedEvent(const QString &href);
0826 
0827     inline QString href() const { return m_href; }
0828 private:
0829     QString m_href;
0830 };
0831 #endif
0832 
0833 #if QT_CONFIG(action)
0834 class Q_GUI_EXPORT QActionEvent : public QEvent
0835 {
0836     Q_DECL_EVENT_COMMON(QActionEvent)
0837 public:
0838     QActionEvent(int type, QAction *action, QAction *before = nullptr);
0839 
0840     inline QAction *action() const { return m_action; }
0841     inline QAction *before() const { return m_before; }
0842 private:
0843     QAction *m_action;
0844     QAction *m_before;
0845 };
0846 #endif // QT_CONFIG(action)
0847 
0848 class Q_GUI_EXPORT QFileOpenEvent : public QEvent
0849 {
0850     Q_DECL_EVENT_COMMON(QFileOpenEvent)
0851 public:
0852     explicit QFileOpenEvent(const QString &file);
0853     explicit QFileOpenEvent(const QUrl &url);
0854 
0855     inline QString file() const { return m_file; }
0856     QUrl url() const { return m_url; }
0857 #if QT_DEPRECATED_SINCE(6, 6)
0858     QT_DEPRECATED_VERSION_X_6_6("Interpret the string returned by file()")
0859     bool openFile(QFile &file, QIODevice::OpenMode flags) const;
0860 #endif
0861 private:
0862     QString m_file;
0863     QUrl m_url;
0864 };
0865 
0866 #ifndef QT_NO_TOOLBAR
0867 class Q_GUI_EXPORT QToolBarChangeEvent : public QEvent
0868 {
0869     Q_DECL_EVENT_COMMON(QToolBarChangeEvent)
0870 public:
0871     explicit QToolBarChangeEvent(bool t);
0872 
0873     inline bool toggle() const { return m_toggle; }
0874 private:
0875     bool m_toggle;
0876 };
0877 #endif
0878 
0879 #if QT_CONFIG(shortcut)
0880 class Q_GUI_EXPORT QShortcutEvent : public QEvent
0881 {
0882     Q_DECL_EVENT_COMMON(QShortcutEvent)
0883 public:
0884     // Note this is publicly deprecated, but should remain as internal constructor:
0885     QShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false);
0886     QShortcutEvent(const QKeySequence &key, const QShortcut *shortcut = nullptr, bool ambiguous = false);
0887 
0888     inline const QKeySequence &key() const { return m_sequence; }
0889     // Note this is publicly deprecated, but should remain as internal getter:
0890     inline int shortcutId() const { return m_shortcutId; }
0891     inline bool isAmbiguous() const { return m_ambiguous; }
0892 protected:
0893     QKeySequence m_sequence;
0894     int  m_shortcutId;
0895     bool m_ambiguous;
0896 };
0897 #endif
0898 
0899 class Q_GUI_EXPORT QWindowStateChangeEvent: public QEvent
0900 {
0901     Q_DECL_EVENT_COMMON(QWindowStateChangeEvent)
0902 public:
0903     explicit QWindowStateChangeEvent(Qt::WindowStates oldState, bool isOverride = false);
0904 
0905     inline Qt::WindowStates oldState() const { return m_oldStates; }
0906     bool isOverride() const;
0907 
0908 private:
0909     Qt::WindowStates m_oldStates;
0910     bool m_override;
0911 };
0912 
0913 #ifndef QT_NO_DEBUG_STREAM
0914 // ### Qt 7: move this to Qt Core and add a hook to allow GUI events to be printed: QTBUG-127680
0915 Q_GUI_EXPORT QDebug operator<<(QDebug, const QEvent *);
0916 #endif
0917 
0918 class Q_GUI_EXPORT QTouchEvent : public QPointerEvent
0919 {
0920     Q_DECL_EVENT_COMMON(QTouchEvent)
0921 public:
0922     using TouchPoint = QEventPoint; // source compat
0923 
0924     explicit QTouchEvent(QEvent::Type eventType,
0925                          const QPointingDevice *device = nullptr,
0926                          Qt::KeyboardModifiers modifiers = Qt::NoModifier,
0927                          const QList<QEventPoint> &touchPoints = {});
0928 #if QT_DEPRECATED_SINCE(6, 0)
0929     QT_DEPRECATED_VERSION_X_6_0("Use another constructor")
0930     explicit QTouchEvent(QEvent::Type eventType,
0931                          const QPointingDevice *device,
0932                          Qt::KeyboardModifiers modifiers,
0933                          QEventPoint::States touchPointStates,
0934                          const QList<QEventPoint> &touchPoints = {});
0935 #endif
0936 
0937     inline QObject *target() const { return m_target; }
0938     inline QEventPoint::States touchPointStates() const { return m_touchPointStates; }
0939 #if QT_DEPRECATED_SINCE(6, 0)
0940     QT_DEPRECATED_VERSION_X_6_0("Use points()")
0941     const QList<QEventPoint> &touchPoints() const { return points(); }
0942 #endif
0943     bool isBeginEvent() const override;
0944     bool isUpdateEvent() const override;
0945     bool isEndEvent() const override;
0946 
0947 protected:
0948     friend class QMutableTouchEvent;
0949     QObject *m_target = nullptr;
0950     QEventPoint::States m_touchPointStates = QEventPoint::State::Unknown;
0951     quint32 m_reserved : 24;
0952 };
0953 
0954 class Q_GUI_EXPORT QScrollPrepareEvent : public QEvent
0955 {
0956     Q_DECL_EVENT_COMMON(QScrollPrepareEvent)
0957 public:
0958     explicit QScrollPrepareEvent(const QPointF &startPos);
0959 
0960     QPointF startPos() const { return m_startPos; }
0961 
0962     QSizeF viewportSize() const { return m_viewportSize; }
0963     QRectF contentPosRange() const { return m_contentPosRange; }
0964     QPointF contentPos() const { return m_contentPos; }
0965 
0966     void setViewportSize(const QSizeF &size);
0967     void setContentPosRange(const QRectF &rect);
0968     void setContentPos(const QPointF &pos);
0969 
0970 private:
0971     QRectF m_contentPosRange;
0972     QSizeF m_viewportSize;
0973     QPointF m_startPos;
0974     QPointF m_contentPos;
0975 };
0976 
0977 
0978 class Q_GUI_EXPORT QScrollEvent : public QEvent
0979 {
0980     Q_DECL_EVENT_COMMON(QScrollEvent)
0981 public:
0982     enum ScrollState
0983     {
0984         ScrollStarted,
0985         ScrollUpdated,
0986         ScrollFinished
0987     };
0988 
0989     QScrollEvent(const QPointF &contentPos, const QPointF &overshoot, ScrollState scrollState);
0990 
0991     QPointF contentPos() const { return m_contentPos; }
0992     QPointF overshootDistance() const { return m_overshoot; }
0993     ScrollState scrollState() const { return m_state; }
0994 
0995 private:
0996     QPointF m_contentPos;
0997     QPointF m_overshoot;
0998     QScrollEvent::ScrollState m_state;
0999 };
1000 
1001 class Q_GUI_EXPORT QScreenOrientationChangeEvent : public QEvent
1002 {
1003     Q_DECL_EVENT_COMMON(QScreenOrientationChangeEvent)
1004 public:
1005     QScreenOrientationChangeEvent(QScreen *screen, Qt::ScreenOrientation orientation);
1006 
1007     QScreen *screen() const { return m_screen; }
1008     Qt::ScreenOrientation orientation() const { return m_orientation; }
1009 
1010 private:
1011     QScreen *m_screen;
1012     Qt::ScreenOrientation m_orientation;
1013 };
1014 
1015 class Q_GUI_EXPORT QApplicationStateChangeEvent : public QEvent
1016 {
1017     Q_DECL_EVENT_COMMON(QApplicationStateChangeEvent)
1018 public:
1019     explicit QApplicationStateChangeEvent(Qt::ApplicationState state);
1020 
1021     Qt::ApplicationState applicationState() const { return m_applicationState; }
1022 
1023 private:
1024     Qt::ApplicationState m_applicationState;
1025 };
1026 
1027 class Q_GUI_EXPORT QChildWindowEvent : public QEvent
1028 {
1029     Q_DECL_EVENT_COMMON(QChildWindowEvent)
1030 public:
1031     explicit QChildWindowEvent(Type type, QWindow *childWindow);
1032     QWindow *child() const { return c; }
1033 
1034 private:
1035     QWindow *c;
1036 };
1037 
1038 QT_END_NAMESPACE
1039 
1040 #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!