| /**************************************************************************** |
| ** |
| ** 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 QWINDOWSYSTEMINTERFACE_P_H |
| #define QWINDOWSYSTEMINTERFACE_P_H |
| |
| // |
| // W A R N I N G |
| // ------------- |
| // |
| // This file is not part of the Qt API. It exists purely as an |
| // implementation detail. This header file may change from version to |
| // version without notice, or even be removed. |
| // |
| // We mean it. |
| // |
| |
| #include <QtGui/private/qtguiglobal_p.h> |
| #include "qwindowsysteminterface.h" |
| |
| #include <QElapsedTimer> |
| #include <QPointer> |
| #include <QMutex> |
| #include <QList> |
| #include <QWaitCondition> |
| #include <QAtomicInt> |
| |
| QT_BEGIN_NAMESPACE |
| |
| class QWindowSystemEventHandler; |
| |
| class Q_GUI_EXPORT QWindowSystemInterfacePrivate { |
| public: |
| enum EventType { |
| UserInputEvent = 0x100, |
| Close = UserInputEvent | 0x01, |
| GeometryChange = 0x02, |
| Enter = UserInputEvent | 0x03, |
| Leave = UserInputEvent | 0x04, |
| ActivatedWindow = 0x05, |
| WindowStateChanged = 0x06, |
| Mouse = UserInputEvent | 0x07, |
| FrameStrutMouse = UserInputEvent | 0x08, // ### Qt6 remove |
| Wheel = UserInputEvent | 0x09, |
| Key = UserInputEvent | 0x0a, |
| Touch = UserInputEvent | 0x0b, |
| ScreenOrientation = 0x0c, |
| ScreenGeometry = 0x0d, |
| ScreenAvailableGeometry = 0x0e, |
| ScreenLogicalDotsPerInch = 0x0f, |
| ScreenRefreshRate = 0x10, |
| ThemeChange = 0x11, |
| Expose = 0x12, |
| FileOpen = UserInputEvent | 0x13, |
| Tablet = UserInputEvent | 0x14, |
| TabletEnterProximity = UserInputEvent | 0x15, |
| TabletLeaveProximity = UserInputEvent | 0x16, |
| PlatformPanel = UserInputEvent | 0x17, |
| ContextMenu = UserInputEvent | 0x18, |
| EnterWhatsThisMode = UserInputEvent | 0x19, |
| #ifndef QT_NO_GESTURES |
| Gesture = UserInputEvent | 0x1a, |
| #endif |
| ApplicationStateChanged = 0x19, |
| FlushEvents = 0x20, |
| WindowScreenChanged = 0x21, |
| SafeAreaMarginsChanged = 0x22, |
| ApplicationTermination = 0x23 |
| }; |
| |
| class WindowSystemEvent { |
| public: |
| enum { |
| Synthetic = 0x1, |
| NullWindow = 0x2 |
| }; |
| |
| explicit WindowSystemEvent(EventType t) |
| : type(t), flags(0), eventAccepted(true) { } |
| virtual ~WindowSystemEvent() { } |
| |
| bool synthetic() const { return flags & Synthetic; } |
| bool nullWindow() const { return flags & NullWindow; } |
| |
| EventType type; |
| int flags; |
| bool eventAccepted; |
| }; |
| |
| class CloseEvent : public WindowSystemEvent { |
| public: |
| explicit CloseEvent(QWindow *w) |
| : WindowSystemEvent(Close), window(w) |
| { } |
| QPointer<QWindow> window; |
| }; |
| |
| class GeometryChangeEvent : public WindowSystemEvent { |
| public: |
| GeometryChangeEvent(QWindow *window, const QRect &newGeometry); |
| QPointer<QWindow> window; |
| QRect requestedGeometry; |
| QRect newGeometry; |
| }; |
| |
| class EnterEvent : public WindowSystemEvent { |
| public: |
| explicit EnterEvent(QWindow *enter, const QPointF &local, const QPointF &global) |
| : WindowSystemEvent(Enter), enter(enter), localPos(local), globalPos(global) |
| { } |
| QPointer<QWindow> enter; |
| const QPointF localPos; |
| const QPointF globalPos; |
| }; |
| |
| class LeaveEvent : public WindowSystemEvent { |
| public: |
| explicit LeaveEvent(QWindow *leave) |
| : WindowSystemEvent(Leave), leave(leave) |
| { } |
| QPointer<QWindow> leave; |
| }; |
| |
| class ActivatedWindowEvent : public WindowSystemEvent { |
| public: |
| explicit ActivatedWindowEvent(QWindow *activatedWindow, Qt::FocusReason r) |
| : WindowSystemEvent(ActivatedWindow), activated(activatedWindow), reason(r) |
| { } |
| QPointer<QWindow> activated; |
| Qt::FocusReason reason; |
| }; |
| |
| class WindowStateChangedEvent : public WindowSystemEvent { |
| public: |
| WindowStateChangedEvent(QWindow *_window, Qt::WindowStates _newState, Qt::WindowStates _oldState) |
| : WindowSystemEvent(WindowStateChanged), window(_window), newState(_newState), oldState(_oldState) |
| { } |
| |
| QPointer<QWindow> window; |
| Qt::WindowStates newState; |
| Qt::WindowStates oldState; |
| }; |
| |
| class WindowScreenChangedEvent : public WindowSystemEvent { |
| public: |
| WindowScreenChangedEvent(QWindow *w, QScreen *s) |
| : WindowSystemEvent(WindowScreenChanged), window(w), screen(s) |
| { } |
| |
| QPointer<QWindow> window; |
| QPointer<QScreen> screen; |
| }; |
| |
| class SafeAreaMarginsChangedEvent : public WindowSystemEvent { |
| public: |
| SafeAreaMarginsChangedEvent(QWindow *w) |
| : WindowSystemEvent(SafeAreaMarginsChanged), window(w) |
| { } |
| |
| QPointer<QWindow> window; |
| }; |
| |
| class ApplicationStateChangedEvent : public WindowSystemEvent { |
| public: |
| ApplicationStateChangedEvent(Qt::ApplicationState newState, bool forcePropagate = false) |
| : WindowSystemEvent(ApplicationStateChanged), newState(newState), forcePropagate(forcePropagate) |
| { } |
| |
| Qt::ApplicationState newState; |
| bool forcePropagate; |
| }; |
| |
| class FlushEventsEvent : public WindowSystemEvent { |
| public: |
| FlushEventsEvent(QEventLoop::ProcessEventsFlags f = QEventLoop::AllEvents) |
| : WindowSystemEvent(FlushEvents) |
| , flags(f) |
| { } |
| QEventLoop::ProcessEventsFlags flags; |
| }; |
| |
| class UserEvent : public WindowSystemEvent { |
| public: |
| UserEvent(QWindow * w, ulong time, EventType t) |
| : WindowSystemEvent(t), window(w), timestamp(time) |
| { |
| if (!w) |
| flags |= NullWindow; |
| } |
| QPointer<QWindow> window; |
| unsigned long timestamp; |
| }; |
| |
| class InputEvent: public UserEvent { |
| public: |
| InputEvent(QWindow * w, ulong time, EventType t, Qt::KeyboardModifiers mods) |
| : UserEvent(w, time, t), modifiers(mods) {} |
| Qt::KeyboardModifiers modifiers; |
| }; |
| |
| class MouseEvent : public InputEvent { |
| public: |
| MouseEvent(QWindow *w, ulong time, const QPointF &local, const QPointF &global, |
| Qt::MouseButtons state, Qt::KeyboardModifiers mods, |
| Qt::MouseButton b, QEvent::Type type, |
| Qt::MouseEventSource src = Qt::MouseEventNotSynthesized, bool frame = false) |
| : InputEvent(w, time, Mouse, mods), localPos(local), globalPos(global), buttons(state), |
| source(src), nonClientArea(frame), button(b), buttonType(type) { } |
| |
| // ### In Qt6 this method can be removed as there won't be need for compatibility code path |
| bool enhancedMouseEvent() const |
| { |
| static const bool disableEnhanced = qEnvironmentVariableIsSet("QT_QPA_DISABLE_ENHANCED_MOUSE"); |
| return !disableEnhanced && buttonType != QEvent::None; |
| } |
| |
| QPointF localPos; |
| QPointF globalPos; |
| Qt::MouseButtons buttons; |
| Qt::MouseEventSource source; |
| bool nonClientArea; |
| Qt::MouseButton button; |
| QEvent::Type buttonType; |
| }; |
| |
| class WheelEvent : public InputEvent { |
| public: |
| WheelEvent(QWindow *w, ulong time, const QPointF &local, const QPointF &global, QPoint pixelD, QPoint angleD, int qt4D, Qt::Orientation qt4O, |
| Qt::KeyboardModifiers mods, Qt::ScrollPhase phase = Qt::NoScrollPhase, Qt::MouseEventSource src = Qt::MouseEventNotSynthesized, bool inverted = false); |
| QPoint pixelDelta; |
| QPoint angleDelta; |
| int qt4Delta; |
| Qt::Orientation qt4Orientation; |
| QPointF localPos; |
| QPointF globalPos; |
| Qt::ScrollPhase phase; |
| Qt::MouseEventSource source; |
| bool inverted; |
| }; |
| |
| class KeyEvent : public InputEvent { |
| public: |
| KeyEvent(QWindow *w, ulong time, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1) |
| :InputEvent(w, time, Key, mods), key(k), unicode(text), repeat(autorep), |
| repeatCount(count), keyType(t), |
| nativeScanCode(0), nativeVirtualKey(0), nativeModifiers(0) { } |
| KeyEvent(QWindow *w, ulong time, QEvent::Type t, int k, Qt::KeyboardModifiers mods, |
| quint32 nativeSC, quint32 nativeVK, quint32 nativeMods, |
| const QString & text = QString(), bool autorep = false, ushort count = 1) |
| :InputEvent(w, time, Key, mods), key(k), unicode(text), repeat(autorep), |
| repeatCount(count), keyType(t), |
| nativeScanCode(nativeSC), nativeVirtualKey(nativeVK), nativeModifiers(nativeMods) { } |
| int key; |
| QString unicode; |
| bool repeat; |
| ushort repeatCount; |
| QEvent::Type keyType; |
| quint32 nativeScanCode; |
| quint32 nativeVirtualKey; |
| quint32 nativeModifiers; |
| }; |
| |
| class TouchEvent : public InputEvent { |
| public: |
| TouchEvent(QWindow *w, ulong time, QEvent::Type t, QTouchDevice *dev, |
| const QList<QTouchEvent::TouchPoint> &p, Qt::KeyboardModifiers mods) |
| :InputEvent(w, time, Touch, mods), device(dev), points(p), touchType(t) { } |
| QTouchDevice *device; |
| QList<QTouchEvent::TouchPoint> points; |
| QEvent::Type touchType; |
| }; |
| |
| class ScreenOrientationEvent : public WindowSystemEvent { |
| public: |
| ScreenOrientationEvent(QScreen *s, Qt::ScreenOrientation o) |
| : WindowSystemEvent(ScreenOrientation), screen(s), orientation(o) { } |
| QPointer<QScreen> screen; |
| Qt::ScreenOrientation orientation; |
| }; |
| |
| class ScreenGeometryEvent : public WindowSystemEvent { |
| public: |
| ScreenGeometryEvent(QScreen *s, const QRect &g, const QRect &ag) |
| : WindowSystemEvent(ScreenGeometry), screen(s), geometry(g), availableGeometry(ag) { } |
| QPointer<QScreen> screen; |
| QRect geometry; |
| QRect availableGeometry; |
| }; |
| |
| class ScreenLogicalDotsPerInchEvent : public WindowSystemEvent { |
| public: |
| ScreenLogicalDotsPerInchEvent(QScreen *s, qreal dx, qreal dy) |
| : WindowSystemEvent(ScreenLogicalDotsPerInch), screen(s), dpiX(dx), dpiY(dy) { } |
| QPointer<QScreen> screen; |
| qreal dpiX; |
| qreal dpiY; |
| }; |
| |
| class ScreenRefreshRateEvent : public WindowSystemEvent { |
| public: |
| ScreenRefreshRateEvent(QScreen *s, qreal r) |
| : WindowSystemEvent(ScreenRefreshRate), screen(s), rate(r) { } |
| QPointer<QScreen> screen; |
| qreal rate; |
| }; |
| |
| class ThemeChangeEvent : public WindowSystemEvent { |
| public: |
| explicit ThemeChangeEvent(QWindow * w) |
| : WindowSystemEvent(ThemeChange), window(w) { } |
| QPointer<QWindow> window; |
| }; |
| |
| class ExposeEvent : public WindowSystemEvent { |
| public: |
| ExposeEvent(QWindow *window, const QRegion ®ion); |
| QPointer<QWindow> window; |
| bool isExposed; |
| QRegion region; |
| }; |
| |
| class FileOpenEvent : public WindowSystemEvent { |
| public: |
| FileOpenEvent(const QString& fileName) |
| : WindowSystemEvent(FileOpen), url(QUrl::fromLocalFile(fileName)) |
| { } |
| FileOpenEvent(const QUrl &url) |
| : WindowSystemEvent(FileOpen), url(url) |
| { } |
| QUrl url; |
| }; |
| |
| class Q_GUI_EXPORT TabletEvent : public InputEvent { |
| public: |
| static void handleTabletEvent(QWindow *w, const QPointF &local, const QPointF &global, |
| int device, int pointerType, Qt::MouseButtons buttons, qreal pressure, int xTilt, int yTilt, |
| qreal tangentialPressure, qreal rotation, int z, qint64 uid, |
| Qt::KeyboardModifiers modifiers = Qt::NoModifier); |
| static void setPlatformSynthesizesMouse(bool v); |
| |
| TabletEvent(QWindow *w, ulong time, const QPointF &local, const QPointF &global, |
| int device, int pointerType, Qt::MouseButtons b, qreal pressure, int xTilt, int yTilt, qreal tpressure, |
| qreal rotation, int z, qint64 uid, Qt::KeyboardModifiers mods) |
| : InputEvent(w, time, Tablet, mods), |
| buttons(b), local(local), global(global), device(device), pointerType(pointerType), |
| pressure(pressure), xTilt(xTilt), yTilt(yTilt), tangentialPressure(tpressure), |
| rotation(rotation), z(z), uid(uid) { } |
| Qt::MouseButtons buttons; |
| QPointF local; |
| QPointF global; |
| int device; |
| int pointerType; |
| qreal pressure; |
| int xTilt; |
| int yTilt; |
| qreal tangentialPressure; |
| qreal rotation; |
| int z; |
| qint64 uid; |
| static bool platformSynthesizesMouse; |
| }; |
| |
| class TabletEnterProximityEvent : public InputEvent { |
| public: |
| TabletEnterProximityEvent(ulong time, int device, int pointerType, qint64 uid) |
| : InputEvent(nullptr, time, TabletEnterProximity, Qt::NoModifier), |
| device(device), pointerType(pointerType), uid(uid) { } |
| int device; |
| int pointerType; |
| qint64 uid; |
| }; |
| |
| class TabletLeaveProximityEvent : public InputEvent { |
| public: |
| TabletLeaveProximityEvent(ulong time, int device, int pointerType, qint64 uid) |
| : InputEvent(nullptr, time, TabletLeaveProximity, Qt::NoModifier), |
| device(device), pointerType(pointerType), uid(uid) { } |
| int device; |
| int pointerType; |
| qint64 uid; |
| }; |
| |
| class PlatformPanelEvent : public WindowSystemEvent { |
| public: |
| explicit PlatformPanelEvent(QWindow *w) |
| : WindowSystemEvent(PlatformPanel), window(w) { } |
| QPointer<QWindow> window; |
| }; |
| |
| #ifndef QT_NO_CONTEXTMENU |
| class ContextMenuEvent : public WindowSystemEvent { |
| public: |
| explicit ContextMenuEvent(QWindow *w, bool mouseTriggered, const QPoint &pos, |
| const QPoint &globalPos, Qt::KeyboardModifiers modifiers) |
| : WindowSystemEvent(ContextMenu), window(w), mouseTriggered(mouseTriggered), pos(pos), |
| globalPos(globalPos), modifiers(modifiers) { } |
| QPointer<QWindow> window; |
| bool mouseTriggered; |
| QPoint pos; // Only valid if triggered by mouse |
| QPoint globalPos; // Only valid if triggered by mouse |
| Qt::KeyboardModifiers modifiers; |
| }; |
| #endif |
| |
| #ifndef QT_NO_GESTURES |
| class GestureEvent : public InputEvent { |
| public: |
| GestureEvent(QWindow *window, ulong time, Qt::NativeGestureType type, QTouchDevice *dev, QPointF pos, QPointF globalPos) |
| : InputEvent(window, time, Gesture, Qt::NoModifier), type(type), pos(pos), globalPos(globalPos), |
| realValue(0), sequenceId(0), intValue(0), device(dev) { } |
| Qt::NativeGestureType type; |
| QPointF pos; |
| QPointF globalPos; |
| // Mac |
| qreal realValue; |
| // Windows |
| ulong sequenceId; |
| quint64 intValue; |
| QTouchDevice *device; |
| }; |
| #endif |
| |
| class WindowSystemEventList { |
| QList<WindowSystemEvent *> impl; |
| mutable QMutex mutex; |
| public: |
| WindowSystemEventList() : impl(), mutex() {} |
| ~WindowSystemEventList() { clear(); } |
| |
| void clear() |
| { const QMutexLocker locker(&mutex); qDeleteAll(impl); impl.clear(); } |
| void prepend(WindowSystemEvent *e) |
| { const QMutexLocker locker(&mutex); impl.prepend(e); } |
| WindowSystemEvent *takeFirstOrReturnNull() |
| { const QMutexLocker locker(&mutex); return impl.empty() ? 0 : impl.takeFirst(); } |
| WindowSystemEvent *takeFirstNonUserInputOrReturnNull() |
| { |
| const QMutexLocker locker(&mutex); |
| for (int i = 0; i < impl.size(); ++i) |
| if (!(impl.at(i)->type & QWindowSystemInterfacePrivate::UserInputEvent)) |
| return impl.takeAt(i); |
| return nullptr; |
| } |
| bool nonUserInputEventsQueued() |
| { |
| const QMutexLocker locker(&mutex); |
| for (int i = 0; i < impl.size(); ++i) |
| if (!(impl.at(i)->type & QWindowSystemInterfacePrivate::UserInputEvent)) |
| return true; |
| return false; |
| } |
| void append(WindowSystemEvent *e) |
| { const QMutexLocker locker(&mutex); impl.append(e); } |
| int count() const |
| { const QMutexLocker locker(&mutex); return impl.count(); } |
| WindowSystemEvent *peekAtFirstOfType(EventType t) const |
| { |
| const QMutexLocker locker(&mutex); |
| for (int i = 0; i < impl.size(); ++i) { |
| if (impl.at(i)->type == t) |
| return impl.at(i); |
| } |
| return nullptr; |
| } |
| void remove(const WindowSystemEvent *e) |
| { |
| const QMutexLocker locker(&mutex); |
| for (int i = 0; i < impl.size(); ++i) { |
| if (impl.at(i) == e) { |
| delete impl.takeAt(i); |
| break; |
| } |
| } |
| } |
| private: |
| Q_DISABLE_COPY_MOVE(WindowSystemEventList) |
| }; |
| |
| static WindowSystemEventList windowSystemEventQueue; |
| |
| static int windowSystemEventsQueued(); |
| static bool nonUserInputEventsQueued(); |
| static WindowSystemEvent *getWindowSystemEvent(); |
| static WindowSystemEvent *getNonUserInputWindowSystemEvent(); |
| static WindowSystemEvent *peekWindowSystemEvent(EventType t); |
| static void removeWindowSystemEvent(WindowSystemEvent *event); |
| template<typename Delivery = QWindowSystemInterface::DefaultDelivery> |
| static bool handleWindowSystemEvent(WindowSystemEvent *ev); |
| |
| public: |
| static QElapsedTimer eventTime; |
| static bool synchronousWindowSystemEvents; |
| static bool platformFiltersEvents; |
| |
| static QWaitCondition eventsFlushed; |
| static QMutex flushEventMutex; |
| static QAtomicInt eventAccepted; |
| |
| static QList<QTouchEvent::TouchPoint> |
| fromNativeTouchPoints(const QList<QWindowSystemInterface::TouchPoint> &points, |
| const QWindow *window, quint8 deviceId, QEvent::Type *type = nullptr); |
| static QList<QWindowSystemInterface::TouchPoint> |
| toNativeTouchPoints(const QList<QTouchEvent::TouchPoint>& pointList, |
| const QWindow *window); |
| static void clearPointIdMap(); |
| |
| static void installWindowSystemEventHandler(QWindowSystemEventHandler *handler); |
| static void removeWindowSystemEventhandler(QWindowSystemEventHandler *handler); |
| static QWindowSystemEventHandler *eventHandler; |
| }; |
| |
| class Q_GUI_EXPORT QWindowSystemEventHandler |
| { |
| public: |
| virtual ~QWindowSystemEventHandler(); |
| virtual bool sendEvent(QWindowSystemInterfacePrivate::WindowSystemEvent *event); |
| }; |
| |
| QT_END_NAMESPACE |
| |
| #endif // QWINDOWSYSTEMINTERFACE_P_H |