mirror of
https://github.com/Retropex/dolphin.git
synced 2025-05-29 05:22:30 +02:00
1121 lines
37 KiB
C++
1121 lines
37 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 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$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#ifndef QEVENT_H
|
|
#define QEVENT_H
|
|
|
|
#include <QtGui/qtguiglobal.h>
|
|
#include <QtGui/qwindowdefs.h>
|
|
#include <QtGui/qregion.h>
|
|
#include <QtCore/qnamespace.h>
|
|
#include <QtCore/qstring.h>
|
|
#include <QtGui/qkeysequence.h>
|
|
#include <QtCore/qcoreevent.h>
|
|
#include <QtCore/qvariant.h>
|
|
#include <QtCore/qmap.h> // ### Qt 6: Remove
|
|
#include <QtCore/qvector.h>
|
|
#include <QtCore/qset.h> // ### Qt 6: Remove
|
|
#include <QtCore/qurl.h>
|
|
#include <QtCore/qfile.h> // ### Qt 6: Replace by <QtCore/qiodevice.h> and forward declare QFile
|
|
#include <QtGui/qvector2d.h>
|
|
#include <QtGui/qtouchdevice.h> // ### Qt 6: Replace by forward declaration
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
|
|
class QAction;
|
|
#ifndef QT_NO_GESTURES
|
|
class QGesture;
|
|
#endif
|
|
class QScreen;
|
|
|
|
class Q_GUI_EXPORT QInputEvent : public QEvent
|
|
{
|
|
public:
|
|
explicit QInputEvent(Type type, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
|
|
~QInputEvent();
|
|
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; }
|
|
protected:
|
|
Qt::KeyboardModifiers modState;
|
|
ulong ts;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QEnterEvent : public QEvent
|
|
{
|
|
public:
|
|
QEnterEvent(const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos);
|
|
~QEnterEvent();
|
|
|
|
#ifndef QT_NO_INTEGER_EVENT_COORDINATES
|
|
inline QPoint pos() const { return l.toPoint(); }
|
|
inline QPoint globalPos() const { return s.toPoint(); }
|
|
inline int x() const { return qRound(l.x()); }
|
|
inline int y() const { return qRound(l.y()); }
|
|
inline int globalX() const { return qRound(s.x()); }
|
|
inline int globalY() const { return qRound(s.y()); }
|
|
#endif
|
|
const QPointF &localPos() const { return l; }
|
|
const QPointF &windowPos() const { return w; }
|
|
const QPointF &screenPos() const { return s; }
|
|
|
|
protected:
|
|
QPointF l, w, s;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QMouseEvent : public QInputEvent
|
|
{
|
|
public:
|
|
QMouseEvent(Type type, const QPointF &localPos, Qt::MouseButton button,
|
|
Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
|
|
QMouseEvent(Type type, const QPointF &localPos, const QPointF &screenPos,
|
|
Qt::MouseButton button, Qt::MouseButtons buttons,
|
|
Qt::KeyboardModifiers modifiers);
|
|
QMouseEvent(Type type, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos,
|
|
Qt::MouseButton button, Qt::MouseButtons buttons,
|
|
Qt::KeyboardModifiers modifiers);
|
|
QMouseEvent(Type type, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos,
|
|
Qt::MouseButton button, Qt::MouseButtons buttons,
|
|
Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source);
|
|
~QMouseEvent();
|
|
|
|
#ifndef QT_NO_INTEGER_EVENT_COORDINATES
|
|
inline QPoint pos() const { return l.toPoint(); }
|
|
inline QPoint globalPos() const { return s.toPoint(); }
|
|
inline int x() const { return qRound(l.x()); }
|
|
inline int y() const { return qRound(l.y()); }
|
|
inline int globalX() const { return qRound(s.x()); }
|
|
inline int globalY() const { return qRound(s.y()); }
|
|
#endif
|
|
const QPointF &localPos() const { return l; }
|
|
const QPointF &windowPos() const { return w; }
|
|
const QPointF &screenPos() const { return s; }
|
|
|
|
inline Qt::MouseButton button() const { return b; }
|
|
inline Qt::MouseButtons buttons() const { return mouseState; }
|
|
|
|
inline void setLocalPos(const QPointF &localPosition) { l = localPosition; }
|
|
|
|
#if QT_DEPRECATED_SINCE(5, 0)
|
|
QT_DEPRECATED inline QPointF posF() const { return l; }
|
|
#endif
|
|
|
|
Qt::MouseEventSource source() const;
|
|
Qt::MouseEventFlags flags() const;
|
|
|
|
protected:
|
|
QPointF l, w, s;
|
|
Qt::MouseButton b;
|
|
Qt::MouseButtons mouseState;
|
|
int caps;
|
|
QVector2D velocity;
|
|
|
|
friend class QGuiApplicationPrivate;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QHoverEvent : public QInputEvent
|
|
{
|
|
public:
|
|
QHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
|
|
~QHoverEvent();
|
|
|
|
#ifndef QT_NO_INTEGER_EVENT_COORDINATES
|
|
inline QPoint pos() const { return p.toPoint(); }
|
|
inline QPoint oldPos() const { return op.toPoint(); }
|
|
#endif
|
|
|
|
inline const QPointF &posF() const { return p; }
|
|
inline const QPointF &oldPosF() const { return op; }
|
|
|
|
protected:
|
|
QPointF p, op;
|
|
};
|
|
|
|
#if QT_CONFIG(wheelevent)
|
|
class Q_GUI_EXPORT QWheelEvent : public QInputEvent
|
|
{
|
|
public:
|
|
enum { DefaultDeltasPerStep = 120 };
|
|
|
|
#if QT_DEPRECATED_SINCE(5, 15)
|
|
// Actually deprecated since 5.0, in docs
|
|
QT_DEPRECATED_VERSION_X_5_15("Use the last QWheelEvent constructor taking pixelDelta, angleDelta, phase, and inverted")
|
|
QWheelEvent(const QPointF &pos, int delta,
|
|
Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
|
|
Qt::Orientation orient = Qt::Vertical);
|
|
// Actually deprecated since 5.0, in docs
|
|
QT_DEPRECATED_VERSION_X_5_15("Use the last QWheelEvent constructor taking pixelDelta, angleDelta, phase, and inverted")
|
|
QWheelEvent(const QPointF &pos, const QPointF& globalPos, int delta,
|
|
Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
|
|
Qt::Orientation orient = Qt::Vertical);
|
|
QT_DEPRECATED_VERSION_X_5_15("Use the last QWheelEvent constructor taking pixelDelta, angleDelta, phase, and inverted")
|
|
QWheelEvent(const QPointF &pos, const QPointF& globalPos,
|
|
QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation,
|
|
Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
|
|
QT_DEPRECATED_VERSION_X_5_15("Use the last QWheelEvent constructor taking pixelDelta, angleDelta, phase, and inverted")
|
|
QWheelEvent(const QPointF &pos, const QPointF& globalPos,
|
|
QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation,
|
|
Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase);
|
|
QT_DEPRECATED_VERSION_X_5_15("Use the last QWheelEvent constructor taking pixelDelta, angleDelta, phase, and inverted")
|
|
QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta,
|
|
int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons,
|
|
Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source);
|
|
QT_DEPRECATED_VERSION_X_5_15("Use the last QWheelEvent constructor taking pixelDelta, angleDelta, phase, and inverted")
|
|
QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta,
|
|
int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons,
|
|
Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source, bool inverted);
|
|
#endif
|
|
|
|
QWheelEvent(QPointF pos, 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; }
|
|
|
|
#if QT_DEPRECATED_SINCE(5, 15)
|
|
// Actually deprecated since 5.0, in docs
|
|
QT_DEPRECATED_VERSION_X_5_15("Use angleDelta()")
|
|
inline int delta() const { return qt4D; }
|
|
// Actually deprecated since 5.0, in docs
|
|
QT_DEPRECATED_VERSION_X_5_15("Use angleDelta()")
|
|
inline Qt::Orientation orientation() const { return qt4O; }
|
|
#ifndef QT_NO_INTEGER_EVENT_COORDINATES
|
|
QT_DEPRECATED_VERSION_X_5_15("Use position()")
|
|
inline QPoint pos() const { return p.toPoint(); }
|
|
QT_DEPRECATED_VERSION_X_5_15("Use globalPosition()")
|
|
inline QPoint globalPos() const { return g.toPoint(); }
|
|
QT_DEPRECATED_VERSION_X_5_15("Use position()")
|
|
inline int x() const { return int(p.x()); }
|
|
QT_DEPRECATED_VERSION_X_5_15("Use position()")
|
|
inline int y() const { return int(p.y()); }
|
|
QT_DEPRECATED_VERSION_X_5_15("Use globalPosition()")
|
|
inline int globalX() const { return int(g.x()); }
|
|
QT_DEPRECATED_VERSION_X_5_15("Use globalPosition()")
|
|
inline int globalY() const { return int(g.y()); }
|
|
#endif
|
|
QT_DEPRECATED_VERSION_X_5_15("Use position()")
|
|
inline const QPointF &posF() const { return p; }
|
|
QT_DEPRECATED_VERSION_X_5_15("Use globalPosition()")
|
|
inline const QPointF &globalPosF() const { return g; }
|
|
#endif // QT_DEPRECATED_SINCE(5, 15)
|
|
|
|
inline QPointF position() const { return p; }
|
|
inline QPointF globalPosition() const { return g; }
|
|
|
|
inline Qt::MouseButtons buttons() const { return mouseState; }
|
|
|
|
inline Qt::ScrollPhase phase() const { return Qt::ScrollPhase(ph); }
|
|
inline bool inverted() const { return invertedScrolling; }
|
|
|
|
Qt::MouseEventSource source() const { return Qt::MouseEventSource(src); }
|
|
|
|
protected:
|
|
QPointF p;
|
|
QPointF g;
|
|
QPoint pixelD;
|
|
QPoint angleD;
|
|
int qt4D = 0;
|
|
Qt::Orientation qt4O = Qt::Vertical;
|
|
Qt::MouseButtons mouseState = Qt::NoButton;
|
|
uint _unused_ : 2; // Kept for binary compatibility
|
|
uint src: 2;
|
|
bool invertedScrolling : 1;
|
|
uint ph : 3;
|
|
int reserved : 24;
|
|
|
|
friend class QApplication;
|
|
};
|
|
#endif
|
|
|
|
#if QT_CONFIG(tabletevent)
|
|
class Q_GUI_EXPORT QTabletEvent : public QInputEvent
|
|
{
|
|
Q_GADGET
|
|
public:
|
|
enum TabletDevice { NoDevice, Puck, Stylus, Airbrush, FourDMouse,
|
|
XFreeEraser /*internal*/, RotationStylus };
|
|
Q_ENUM(TabletDevice)
|
|
enum PointerType { UnknownPointer, Pen, Cursor, Eraser };
|
|
Q_ENUM(PointerType)
|
|
|
|
#if QT_DEPRECATED_SINCE(5, 15)
|
|
// Actually deprecated since 5.4, in docs
|
|
QT_DEPRECATED_VERSION_X_5_15("Use the other QTabletEvent constructor")
|
|
QTabletEvent(Type t, const QPointF &pos, const QPointF &globalPos,
|
|
int device, int pointerType, qreal pressure, int xTilt, int yTilt,
|
|
qreal tangentialPressure, qreal rotation, int z,
|
|
Qt::KeyboardModifiers keyState, qint64 uniqueID); // ### remove in Qt 6
|
|
#endif
|
|
QTabletEvent(Type t, const QPointF &pos, const QPointF &globalPos,
|
|
int device, 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();
|
|
|
|
inline QPoint pos() const { return mPos.toPoint(); }
|
|
inline QPoint globalPos() const { return mGPos.toPoint(); }
|
|
#if QT_DEPRECATED_SINCE(5,0)
|
|
QT_DEPRECATED inline const QPointF &hiResGlobalPos() const { return mPos; }
|
|
#endif
|
|
|
|
inline const QPointF &posF() const { return mPos; }
|
|
inline const QPointF &globalPosF() const { return mGPos; }
|
|
|
|
inline int x() const { return qRound(mPos.x()); }
|
|
inline int y() const { return qRound(mPos.y()); }
|
|
inline int globalX() const { return qRound(mGPos.x()); }
|
|
inline int globalY() const { return qRound(mGPos.y()); }
|
|
#if QT_DEPRECATED_SINCE(5, 15)
|
|
QT_DEPRECATED_VERSION_X_5_15("use globalPosF().x()")
|
|
inline qreal hiResGlobalX() const { return mGPos.x(); }
|
|
QT_DEPRECATED_VERSION_X_5_15("use globalPosF().y()")
|
|
inline qreal hiResGlobalY() const { return mGPos.y(); }
|
|
QT_DEPRECATED_VERSION_X_5_15("Use deviceType()")
|
|
inline TabletDevice device() const { return TabletDevice(mDev); }
|
|
#endif
|
|
inline TabletDevice deviceType() const { return TabletDevice(mDev); }
|
|
inline PointerType pointerType() const { return PointerType(mPointerType); }
|
|
inline qint64 uniqueId() const { return mUnique; }
|
|
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; }
|
|
Qt::MouseButton button() const;
|
|
Qt::MouseButtons buttons() const;
|
|
|
|
protected:
|
|
QPointF mPos, mGPos;
|
|
int mDev, mPointerType, mXT, mYT, mZ;
|
|
qreal mPress, mTangential, mRot;
|
|
qint64 mUnique;
|
|
|
|
// QTabletEventPrivate for extra storage.
|
|
// ### Qt 6: QPointingEvent will have Buttons, QTabletEvent will inherit
|
|
void *mExtra;
|
|
};
|
|
#endif // QT_CONFIG(tabletevent)
|
|
|
|
#ifndef QT_NO_GESTURES
|
|
class Q_GUI_EXPORT QNativeGestureEvent : public QInputEvent
|
|
{
|
|
public:
|
|
#if QT_DEPRECATED_SINCE(5, 10)
|
|
QT_DEPRECATED QNativeGestureEvent(Qt::NativeGestureType type, const QPointF &localPos, const QPointF &windowPos,
|
|
const QPointF &screenPos, qreal value, ulong sequenceId, quint64 intArgument);
|
|
#endif
|
|
QNativeGestureEvent(Qt::NativeGestureType type, const QTouchDevice *dev, const QPointF &localPos, const QPointF &windowPos,
|
|
const QPointF &screenPos, qreal value, ulong sequenceId, quint64 intArgument);
|
|
~QNativeGestureEvent();
|
|
Qt::NativeGestureType gestureType() const { return mGestureType; }
|
|
qreal value() const { return mRealValue; }
|
|
|
|
#ifndef QT_NO_INTEGER_EVENT_COORDINATES
|
|
inline const QPoint pos() const { return mLocalPos.toPoint(); }
|
|
inline const QPoint globalPos() const { return mScreenPos.toPoint(); }
|
|
#endif
|
|
const QPointF &localPos() const { return mLocalPos; }
|
|
const QPointF &windowPos() const { return mWindowPos; }
|
|
const QPointF &screenPos() const { return mScreenPos; }
|
|
|
|
const QTouchDevice *device() const;
|
|
|
|
protected:
|
|
Qt::NativeGestureType mGestureType;
|
|
QPointF mLocalPos;
|
|
QPointF mWindowPos;
|
|
QPointF mScreenPos;
|
|
qreal mRealValue;
|
|
ulong mSequenceId;
|
|
quint64 mIntValue;
|
|
};
|
|
#endif // QT_NO_GESTURES
|
|
|
|
class Q_GUI_EXPORT QKeyEvent : public QInputEvent
|
|
{
|
|
public:
|
|
QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text = QString(),
|
|
bool autorep = false, ushort 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();
|
|
|
|
int key() const { return k; }
|
|
#ifndef QT_NO_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); }
|
|
|
|
inline quint32 nativeScanCode() const { return nScanCode; }
|
|
inline quint32 nativeVirtualKey() const { return nVirtualKey; }
|
|
inline quint32 nativeModifiers() const { return nModifiers; }
|
|
|
|
// Functions for the extended key event information
|
|
#if QT_DEPRECATED_SINCE(5, 0)
|
|
static inline QKeyEvent *createExtendedKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers,
|
|
quint32 nativeScanCode, quint32 nativeVirtualKey,
|
|
quint32 nativeModifiers,
|
|
const QString& text = QString(), bool autorep = false,
|
|
ushort count = 1)
|
|
{
|
|
return new QKeyEvent(type, key, modifiers,
|
|
nativeScanCode, nativeVirtualKey, nativeModifiers,
|
|
text, autorep, count);
|
|
}
|
|
|
|
inline bool hasExtendedInfo() const { return true; }
|
|
#endif
|
|
|
|
protected:
|
|
QString txt;
|
|
int k;
|
|
quint32 nScanCode;
|
|
quint32 nVirtualKey;
|
|
quint32 nModifiers;
|
|
ushort c;
|
|
ushort autor:1;
|
|
// ushort reserved:15;
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QFocusEvent : public QEvent
|
|
{
|
|
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; }
|
|
|
|
Qt::FocusReason reason() const;
|
|
|
|
private:
|
|
Qt::FocusReason m_reason;
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QPaintEvent : public QEvent
|
|
{
|
|
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; }
|
|
|
|
protected:
|
|
QRect m_rect;
|
|
QRegion m_region;
|
|
bool m_erased;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QMoveEvent : public QEvent
|
|
{
|
|
public:
|
|
QMoveEvent(const QPoint &pos, const QPoint &oldPos);
|
|
~QMoveEvent();
|
|
|
|
inline const QPoint &pos() const { return p; }
|
|
inline const QPoint &oldPos() const { return oldp;}
|
|
protected:
|
|
QPoint p, oldp;
|
|
friend class QApplication;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QExposeEvent : public QEvent
|
|
{
|
|
public:
|
|
explicit QExposeEvent(const QRegion &rgn);
|
|
~QExposeEvent();
|
|
|
|
inline const QRegion ®ion() const { return rgn; }
|
|
|
|
protected:
|
|
QRegion rgn;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QPlatformSurfaceEvent : public QEvent
|
|
{
|
|
public:
|
|
enum SurfaceEventType {
|
|
SurfaceCreated,
|
|
SurfaceAboutToBeDestroyed
|
|
};
|
|
|
|
explicit QPlatformSurfaceEvent(SurfaceEventType surfaceEventType);
|
|
~QPlatformSurfaceEvent();
|
|
|
|
inline SurfaceEventType surfaceEventType() const { return m_surfaceEventType; }
|
|
|
|
protected:
|
|
SurfaceEventType m_surfaceEventType;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QResizeEvent : public QEvent
|
|
{
|
|
public:
|
|
QResizeEvent(const QSize &size, const QSize &oldSize);
|
|
~QResizeEvent();
|
|
|
|
inline const QSize &size() const { return s; }
|
|
inline const QSize &oldSize()const { return olds;}
|
|
protected:
|
|
QSize s, olds;
|
|
friend class QApplication;
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QCloseEvent : public QEvent
|
|
{
|
|
public:
|
|
QCloseEvent();
|
|
~QCloseEvent();
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QIconDragEvent : public QEvent
|
|
{
|
|
public:
|
|
QIconDragEvent();
|
|
~QIconDragEvent();
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QShowEvent : public QEvent
|
|
{
|
|
public:
|
|
QShowEvent();
|
|
~QShowEvent();
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QHideEvent : public QEvent
|
|
{
|
|
public:
|
|
QHideEvent();
|
|
~QHideEvent();
|
|
};
|
|
|
|
#ifndef QT_NO_CONTEXTMENU
|
|
class Q_GUI_EXPORT QContextMenuEvent : public QInputEvent
|
|
{
|
|
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);
|
|
QContextMenuEvent(Reason reason, const QPoint &pos);
|
|
~QContextMenuEvent();
|
|
|
|
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 const QPoint& pos() const { return p; }
|
|
inline const QPoint& globalPos() const { return gp; }
|
|
|
|
inline Reason reason() const { return Reason(reas); }
|
|
|
|
protected:
|
|
QPoint p;
|
|
QPoint gp;
|
|
uint reas : 8;
|
|
};
|
|
#endif // QT_NO_CONTEXTMENU
|
|
|
|
#ifndef QT_NO_INPUTMETHOD
|
|
class Q_GUI_EXPORT QInputMethodEvent : public QEvent
|
|
{
|
|
public:
|
|
enum AttributeType {
|
|
TextFormat,
|
|
Cursor,
|
|
Language,
|
|
Ruby,
|
|
Selection
|
|
};
|
|
class Attribute {
|
|
public:
|
|
Attribute(AttributeType typ, int s, int l, QVariant val) : type(typ), start(s), length(l), value(std::move(val)) {}
|
|
Attribute(AttributeType typ, int s, int l) : type(typ), start(s), length(l), value() {}
|
|
|
|
AttributeType type;
|
|
int start;
|
|
int length;
|
|
QVariant value;
|
|
};
|
|
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 QString &commitString() const { return commit; }
|
|
inline int replacementStart() const { return replace_from; }
|
|
inline int replacementLength() const { return replace_length; }
|
|
|
|
QInputMethodEvent(const QInputMethodEvent &other);
|
|
|
|
private:
|
|
QString preedit;
|
|
QList<Attribute> attrs;
|
|
QString commit;
|
|
int replace_from;
|
|
int replace_length;
|
|
};
|
|
Q_DECLARE_TYPEINFO(QInputMethodEvent::Attribute, Q_MOVABLE_TYPE);
|
|
|
|
class Q_GUI_EXPORT QInputMethodQueryEvent : public QEvent
|
|
{
|
|
public:
|
|
explicit QInputMethodQueryEvent(Qt::InputMethodQueries queries);
|
|
~QInputMethodQueryEvent();
|
|
|
|
Qt::InputMethodQueries queries() const { return m_queries; }
|
|
|
|
void setValue(Qt::InputMethodQuery query, const QVariant &value);
|
|
QVariant value(Qt::InputMethodQuery query) const;
|
|
private:
|
|
Qt::InputMethodQueries m_queries;
|
|
struct QueryPair {
|
|
Qt::InputMethodQuery query;
|
|
QVariant value;
|
|
};
|
|
friend QTypeInfo<QueryPair>;
|
|
QVector<QueryPair> m_values;
|
|
};
|
|
Q_DECLARE_TYPEINFO(QInputMethodQueryEvent::QueryPair, Q_MOVABLE_TYPE);
|
|
|
|
#endif // QT_NO_INPUTMETHOD
|
|
|
|
#if QT_CONFIG(draganddrop)
|
|
|
|
class QMimeData;
|
|
|
|
class Q_GUI_EXPORT QDropEvent : public QEvent
|
|
{
|
|
public:
|
|
QDropEvent(const QPointF& pos, Qt::DropActions actions, const QMimeData *data,
|
|
Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop);
|
|
~QDropEvent();
|
|
|
|
inline QPoint pos() const { return p.toPoint(); }
|
|
inline const QPointF &posF() const { return p; }
|
|
inline Qt::MouseButtons mouseButtons() const { return mouseState; }
|
|
inline Qt::KeyboardModifiers keyboardModifiers() const { return 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::DropAction dropAction() const { return drop_action; }
|
|
void setDropAction(Qt::DropAction action);
|
|
|
|
QObject* source() const;
|
|
inline const QMimeData *mimeData() const { return mdata; }
|
|
|
|
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;
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QDragMoveEvent : public QDropEvent
|
|
{
|
|
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 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; }
|
|
|
|
protected:
|
|
QRect rect;
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QDragEnterEvent : public QDragMoveEvent
|
|
{
|
|
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
|
|
{
|
|
public:
|
|
QDragLeaveEvent();
|
|
~QDragLeaveEvent();
|
|
};
|
|
#endif // QT_CONFIG(draganddrop)
|
|
|
|
|
|
class Q_GUI_EXPORT QHelpEvent : public QEvent
|
|
{
|
|
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 const QPoint& pos() const { return p; }
|
|
inline const QPoint& globalPos() const { return gp; }
|
|
|
|
private:
|
|
QPoint p;
|
|
QPoint gp;
|
|
};
|
|
|
|
#ifndef QT_NO_STATUSTIP
|
|
class Q_GUI_EXPORT QStatusTipEvent : public QEvent
|
|
{
|
|
public:
|
|
explicit QStatusTipEvent(const QString &tip);
|
|
~QStatusTipEvent();
|
|
|
|
inline QString tip() const { return s; }
|
|
private:
|
|
QString s;
|
|
};
|
|
#endif
|
|
|
|
#if QT_CONFIG(whatsthis)
|
|
class Q_GUI_EXPORT QWhatsThisClickedEvent : public QEvent
|
|
{
|
|
public:
|
|
explicit QWhatsThisClickedEvent(const QString &href);
|
|
~QWhatsThisClickedEvent();
|
|
|
|
inline QString href() const { return s; }
|
|
private:
|
|
QString s;
|
|
};
|
|
#endif
|
|
|
|
#ifndef QT_NO_ACTION
|
|
class Q_GUI_EXPORT QActionEvent : public QEvent
|
|
{
|
|
QAction *act, *bef;
|
|
public:
|
|
QActionEvent(int type, QAction *action, QAction *before = nullptr);
|
|
~QActionEvent();
|
|
|
|
inline QAction *action() const { return act; }
|
|
inline QAction *before() const { return bef; }
|
|
};
|
|
#endif
|
|
|
|
class Q_GUI_EXPORT QFileOpenEvent : public QEvent
|
|
{
|
|
public:
|
|
explicit QFileOpenEvent(const QString &file);
|
|
explicit QFileOpenEvent(const QUrl &url);
|
|
~QFileOpenEvent();
|
|
|
|
inline QString file() const { return f; }
|
|
QUrl url() const { return m_url; }
|
|
bool openFile(QFile &file, QIODevice::OpenMode flags) const;
|
|
private:
|
|
QString f;
|
|
QUrl m_url;
|
|
};
|
|
|
|
#ifndef QT_NO_TOOLBAR
|
|
class Q_GUI_EXPORT QToolBarChangeEvent : public QEvent
|
|
{
|
|
public:
|
|
explicit QToolBarChangeEvent(bool t);
|
|
~QToolBarChangeEvent();
|
|
|
|
inline bool toggle() const { return tog; }
|
|
private:
|
|
uint tog : 1;
|
|
};
|
|
#endif
|
|
|
|
#ifndef QT_NO_SHORTCUT
|
|
class Q_GUI_EXPORT QShortcutEvent : public QEvent
|
|
{
|
|
public:
|
|
QShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false);
|
|
~QShortcutEvent();
|
|
|
|
inline const QKeySequence &key() const { return sequence; }
|
|
inline int shortcutId() const { return sid; }
|
|
inline bool isAmbiguous() const { return ambig; }
|
|
protected:
|
|
QKeySequence sequence;
|
|
bool ambig;
|
|
int sid;
|
|
};
|
|
#endif
|
|
|
|
class Q_GUI_EXPORT QWindowStateChangeEvent: public QEvent
|
|
{
|
|
public:
|
|
explicit QWindowStateChangeEvent(Qt::WindowStates aOldState, bool isOverride = false);
|
|
~QWindowStateChangeEvent();
|
|
|
|
inline Qt::WindowStates oldState() const { return ostate; }
|
|
bool isOverride() const;
|
|
|
|
private:
|
|
Qt::WindowStates ostate;
|
|
bool m_override;
|
|
};
|
|
|
|
#ifndef QT_NO_DEBUG_STREAM
|
|
Q_GUI_EXPORT QDebug operator<<(QDebug, const QEvent *);
|
|
#endif
|
|
|
|
#ifndef QT_NO_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_NO_SHORTCUT
|
|
|
|
class Q_GUI_EXPORT QPointingDeviceUniqueId
|
|
{
|
|
Q_GADGET
|
|
Q_PROPERTY(qint64 numericId READ numericId CONSTANT)
|
|
public:
|
|
Q_ALWAYS_INLINE
|
|
Q_DECL_CONSTEXPR QPointingDeviceUniqueId() noexcept : m_numericId(-1) {}
|
|
// compiler-generated copy/move ctor/assignment operators are ok!
|
|
// compiler-generated dtor is ok!
|
|
|
|
static QPointingDeviceUniqueId fromNumericId(qint64 id);
|
|
|
|
Q_ALWAYS_INLINE Q_DECL_CONSTEXPR bool isValid() const noexcept { return m_numericId != -1; }
|
|
qint64 numericId() const noexcept;
|
|
|
|
private:
|
|
// TODO: for TUIO 2, or any other type of complex token ID, an internal
|
|
// array (or hash) can be added to hold additional properties.
|
|
// In this case, m_numericId will then turn into an index into that array (or hash).
|
|
qint64 m_numericId;
|
|
};
|
|
Q_DECLARE_TYPEINFO(QPointingDeviceUniqueId, Q_MOVABLE_TYPE);
|
|
|
|
#if 0
|
|
#pragma qt_sync_suspend_processing
|
|
#endif
|
|
template <> class QList<QPointingDeviceUniqueId> {}; // to prevent instantiation: use QVector instead
|
|
#if 0
|
|
#pragma qt_sync_resume_processing
|
|
#endif
|
|
|
|
Q_GUI_EXPORT bool operator==(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs) noexcept;
|
|
inline bool operator!=(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs) noexcept
|
|
{ return !operator==(lhs, rhs); }
|
|
Q_GUI_EXPORT uint qHash(QPointingDeviceUniqueId key, uint seed = 0) noexcept;
|
|
|
|
|
|
|
|
class QTouchEventTouchPointPrivate;
|
|
class Q_GUI_EXPORT QTouchEvent : public QInputEvent
|
|
{
|
|
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;
|
|
|
|
QPointF pos() const;
|
|
QPointF startPos() const;
|
|
QPointF lastPos() const;
|
|
|
|
QPointF scenePos() const;
|
|
QPointF startScenePos() const;
|
|
QPointF lastScenePos() const;
|
|
|
|
QPointF screenPos() const;
|
|
QPointF startScreenPos() const;
|
|
QPointF lastScreenPos() const;
|
|
|
|
QPointF normalizedPos() const;
|
|
QPointF startNormalizedPos() const;
|
|
QPointF lastNormalizedPos() const;
|
|
|
|
#if QT_DEPRECATED_SINCE(5, 15)
|
|
// All these are actually deprecated since 5.9, in docs
|
|
QT_DEPRECATED_VERSION_X_5_15("Use pos() and ellipseDiameters()")
|
|
QRectF rect() const;
|
|
QT_DEPRECATED_VERSION_X_5_15("Use scenePos() and ellipseDiameters()")
|
|
QRectF sceneRect() const;
|
|
QT_DEPRECATED_VERSION_X_5_15("Use screenPos() and ellipseDiameters()")
|
|
QRectF screenRect() const;
|
|
|
|
// internal
|
|
QT_DEPRECATED_VERSION_X_5_15("Use setPos() and setEllipseDiameters()")
|
|
void setRect(const QRectF &rect); // deprecated
|
|
QT_DEPRECATED_VERSION_X_5_15("Use setScenePos() and setEllipseDiameters()")
|
|
void setSceneRect(const QRectF &sceneRect); // deprecated
|
|
QT_DEPRECATED_VERSION_X_5_15("Use setScreenPos() and setEllipseDiameters()")
|
|
void setScreenRect(const QRectF &screenRect); // deprecated
|
|
#endif
|
|
qreal pressure() const;
|
|
qreal rotation() const;
|
|
QSizeF ellipseDiameters() const;
|
|
|
|
QVector2D velocity() const;
|
|
InfoFlags flags() const;
|
|
QVector<QPointF> rawScreenPositions() const;
|
|
|
|
// internal
|
|
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 QVector<QPointF> &positions);
|
|
|
|
private:
|
|
QTouchEventTouchPointPrivate *d;
|
|
friend class QGuiApplication;
|
|
friend class QGuiApplicationPrivate;
|
|
friend class QApplication;
|
|
friend class QApplicationPrivate;
|
|
friend class QQuickPointerTouchEvent;
|
|
friend class QQuickMultiPointTouchArea;
|
|
};
|
|
|
|
#if QT_DEPRECATED_SINCE(5, 0)
|
|
enum DeviceType {
|
|
TouchScreen,
|
|
TouchPad
|
|
};
|
|
#endif
|
|
|
|
explicit QTouchEvent(QEvent::Type eventType,
|
|
QTouchDevice *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; }
|
|
#if QT_DEPRECATED_SINCE(5, 0)
|
|
QT_DEPRECATED inline QTouchEvent::DeviceType deviceType() const { return static_cast<DeviceType>(int(_device->type())); }
|
|
#endif
|
|
inline Qt::TouchPointStates touchPointStates() const { return _touchPointStates; }
|
|
inline const QList<QTouchEvent::TouchPoint> &touchPoints() const { return _touchPoints; }
|
|
inline QTouchDevice *device() const { return _device; }
|
|
|
|
// internal
|
|
inline void setWindow(QWindow *awindow) { _window = awindow; }
|
|
inline void setTarget(QObject *atarget) { _target = atarget; }
|
|
inline void setTouchPointStates(Qt::TouchPointStates aTouchPointStates) { _touchPointStates = aTouchPointStates; }
|
|
inline void setTouchPoints(const QList<QTouchEvent::TouchPoint> &atouchPoints) { _touchPoints = atouchPoints; }
|
|
inline void setDevice(QTouchDevice *adevice) { _device = adevice; }
|
|
|
|
protected:
|
|
QWindow *_window;
|
|
QObject *_target;
|
|
QTouchDevice *_device;
|
|
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
|
|
};
|
|
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
|
|
{
|
|
public:
|
|
explicit QScrollPrepareEvent(const QPointF &startPos);
|
|
~QScrollPrepareEvent();
|
|
|
|
QPointF startPos() const;
|
|
|
|
QSizeF viewportSize() const;
|
|
QRectF contentPosRange() const;
|
|
QPointF contentPos() const;
|
|
|
|
void setViewportSize(const QSizeF &size);
|
|
void setContentPosRange(const QRectF &rect);
|
|
void setContentPos(const QPointF &pos);
|
|
|
|
private:
|
|
QObject* m_target; // Qt 6 remove.
|
|
QPointF m_startPos;
|
|
QSizeF m_viewportSize;
|
|
QRectF m_contentPosRange;
|
|
QPointF m_contentPos;
|
|
};
|
|
|
|
|
|
class Q_GUI_EXPORT QScrollEvent : public QEvent
|
|
{
|
|
public:
|
|
enum ScrollState
|
|
{
|
|
ScrollStarted,
|
|
ScrollUpdated,
|
|
ScrollFinished
|
|
};
|
|
|
|
QScrollEvent(const QPointF &contentPos, const QPointF &overshoot, ScrollState scrollState);
|
|
~QScrollEvent();
|
|
|
|
QPointF contentPos() const;
|
|
QPointF overshootDistance() const;
|
|
ScrollState scrollState() const;
|
|
|
|
private:
|
|
QPointF m_contentPos;
|
|
QPointF m_overshoot;
|
|
QScrollEvent::ScrollState m_state;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QScreenOrientationChangeEvent : public QEvent
|
|
{
|
|
public:
|
|
QScreenOrientationChangeEvent(QScreen *screen, Qt::ScreenOrientation orientation);
|
|
~QScreenOrientationChangeEvent();
|
|
|
|
QScreen *screen() const;
|
|
Qt::ScreenOrientation orientation() const;
|
|
|
|
private:
|
|
QScreen *m_screen;
|
|
Qt::ScreenOrientation m_orientation;
|
|
};
|
|
|
|
class Q_GUI_EXPORT QApplicationStateChangeEvent : public QEvent
|
|
{
|
|
public:
|
|
explicit QApplicationStateChangeEvent(Qt::ApplicationState state);
|
|
Qt::ApplicationState applicationState() const;
|
|
|
|
private:
|
|
Qt::ApplicationState m_applicationState;
|
|
};
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
#endif // QEVENT_H
|