Ticket #58226: qevent.h

File qevent.h, 30.5 KB (added by SenileFelineS, 6 years ago)

The qt5 file that defines pos() but apparently not posF()

Line 
1/****************************************************************************
2**
3** Copyright (C) 2015 The Qt Company Ltd.
4** Contact: http://www.qt.io/licensing/
5**
6** This file is part of the QtGui module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL21$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see http://www.qt.io/terms-conditions. For further
15** information use the contact form at http://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 2.1 or version 3 as published by the Free
20** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22** following information to ensure the GNU Lesser General Public License
23** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25**
26** As a special exception, The Qt Company gives you certain additional
27** rights. These rights are described in The Qt Company LGPL Exception
28** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29**
30** $QT_END_LICENSE$
31**
32****************************************************************************/
33
34#ifndef QEVENT_H
35#define QEVENT_H
36
37#include <QtGui/qwindowdefs.h>
38#include <QtCore/qobject.h>
39#include <QtGui/qregion.h>
40#include <QtCore/qnamespace.h>
41#include <QtCore/qstring.h>
42#include <QtGui/qkeysequence.h>
43#include <QtCore/qcoreevent.h>
44#include <QtCore/qvariant.h>
45#include <QtCore/qmap.h>
46#include <QtCore/qvector.h>
47#include <QtCore/qset.h>
48#include <QtCore/qurl.h>
49#include <QtCore/qfile.h>
50#include <QtGui/qvector2d.h>
51#include <QtGui/qtouchdevice.h>
52
53QT_BEGIN_NAMESPACE
54
55
56class QAction;
57#ifndef QT_NO_GESTURES
58class QGesture;
59#endif
60class QScreen;
61
62class Q_GUI_EXPORT QInputEvent : public QEvent
63{
64public:
65    explicit QInputEvent(Type type, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
66    ~QInputEvent();
67    inline Qt::KeyboardModifiers modifiers() const { return modState; }
68    inline void setModifiers(Qt::KeyboardModifiers amodifiers) { modState = amodifiers; }
69    inline ulong timestamp() const { return ts; }
70    inline void setTimestamp(ulong atimestamp) { ts = atimestamp; }
71protected:
72    Qt::KeyboardModifiers modState;
73    ulong ts;
74};
75
76class Q_GUI_EXPORT QEnterEvent : public QEvent
77{
78public:
79    QEnterEvent(const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos);
80    ~QEnterEvent();
81
82#ifndef QT_NO_INTEGER_EVENT_COORDINATES
83    inline QPoint pos() const { return l.toPoint(); }
84    inline QPoint globalPos() const { return s.toPoint(); }
85    inline int x() const { return qRound(l.x()); }
86    inline int y() const { return qRound(l.y()); }
87    inline int globalX() const { return qRound(s.x()); }
88    inline int globalY() const { return qRound(s.y()); }
89#endif
90    const QPointF &localPos() const { return l; }
91    const QPointF &windowPos() const { return w; }
92    const QPointF &screenPos() const { return s; }
93
94protected:
95    QPointF l, w, s;
96};
97
98class Q_GUI_EXPORT QMouseEvent : public QInputEvent
99{
100public:
101    QMouseEvent(Type type, const QPointF &localPos, Qt::MouseButton button,
102                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
103    QMouseEvent(Type type, const QPointF &localPos, const QPointF &screenPos,
104                Qt::MouseButton button, Qt::MouseButtons buttons,
105                Qt::KeyboardModifiers modifiers);
106    QMouseEvent(Type type, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos,
107                Qt::MouseButton button, Qt::MouseButtons buttons,
108                Qt::KeyboardModifiers modifiers);
109    QMouseEvent(Type type, const QPointF &localPos, const QPointF &windowPos, const QPointF &screenPos,
110                Qt::MouseButton button, Qt::MouseButtons buttons,
111                Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source);
112    ~QMouseEvent();
113
114#ifndef QT_NO_INTEGER_EVENT_COORDINATES
115    inline QPoint pos() const { return l.toPoint(); }
116    inline QPoint globalPos() const { return s.toPoint(); }
117    inline int x() const { return qRound(l.x()); }
118    inline int y() const { return qRound(l.y()); }
119    inline int globalX() const { return qRound(s.x()); }
120    inline int globalY() const { return qRound(s.y()); }
121#endif
122    const QPointF &localPos() const { return l; }
123    const QPointF &windowPos() const { return w; }
124    const QPointF &screenPos() const { return s; }
125
126    inline Qt::MouseButton button() const { return b; }
127    inline Qt::MouseButtons buttons() const { return mouseState; }
128
129#if QT_DEPRECATED_SINCE(5, 0)
130    QT_DEPRECATED inline QPointF posF() const { return l; }
131#endif
132
133    Qt::MouseEventSource source() const;
134    Qt::MouseEventFlags flags() const;
135
136protected:
137    QPointF l, w, s;
138    Qt::MouseButton b;
139    Qt::MouseButtons mouseState;
140    int caps;
141    QVector2D velocity;
142
143    friend class QGuiApplicationPrivate;
144};
145
146class Q_GUI_EXPORT QHoverEvent : public QInputEvent
147{
148public:
149    QHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
150    ~QHoverEvent();
151
152#ifndef QT_NO_INTEGER_EVENT_COORDINATES
153    inline QPoint pos() const { return p.toPoint(); }
154    inline QPoint oldPos() const { return op.toPoint(); }
155#endif
156
157    inline const QPointF &posF() const { return p; }
158    inline const QPointF &oldPosF() const { return op; }
159
160protected:
161    QPointF p, op;
162};
163
164#ifndef QT_NO_WHEELEVENT
165class Q_GUI_EXPORT QWheelEvent : public QInputEvent
166{
167public:
168    enum { DefaultDeltasPerStep = 120 };
169
170    QWheelEvent(const QPointF &pos, int delta,
171                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
172                Qt::Orientation orient = Qt::Vertical);
173    QWheelEvent(const QPointF &pos, const QPointF& globalPos, int delta,
174                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
175                Qt::Orientation orient = Qt::Vertical);
176    QWheelEvent(const QPointF &pos, const QPointF& globalPos,
177                QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation,
178                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
179    QWheelEvent(const QPointF &pos, const QPointF& globalPos,
180                QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation,
181                Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase);
182    QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta,
183                int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons,
184                Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source);
185    ~QWheelEvent();
186
187
188    inline QPoint pixelDelta() const { return pixelD; }
189    inline QPoint angleDelta() const { return angleD; }
190
191    inline int delta() const  { return qt4D; }
192    inline Qt::Orientation orientation() const { return qt4O; }
193
194#ifndef QT_NO_INTEGER_EVENT_COORDINATES
195    inline QPoint pos() const { return p.toPoint(); }
196    inline QPoint globalPos()   const { return g.toPoint(); }
197    inline int x() const { return p.x(); }
198    inline int y() const { return p.y(); }
199    inline int globalX() const { return g.x(); }
200    inline int globalY() const { return g.y(); }
201#endif
202    inline const QPointF &posF() const { return p; }
203    inline const QPointF &globalPosF()   const { return g; }
204
205    inline Qt::MouseButtons buttons() const { return mouseState; }
206
207    inline Qt::ScrollPhase phase() const { return Qt::ScrollPhase(ph); }
208
209    Qt::MouseEventSource source() const { return Qt::MouseEventSource(src); }
210
211protected:
212    QPointF p;
213    QPointF g;
214    QPoint pixelD;
215    QPoint angleD;
216    int qt4D;
217    Qt::Orientation qt4O;
218    Qt::MouseButtons mouseState;
219    uint ph : 2;
220    uint src: 2;
221    int reserved : 28;
222
223    friend class QApplication;
224};
225#endif
226
227#ifndef QT_NO_TABLETEVENT
228class Q_GUI_EXPORT QTabletEvent : public QInputEvent
229{
230    Q_GADGET
231public:
232    enum TabletDevice { NoDevice, Puck, Stylus, Airbrush, FourDMouse,
233                        XFreeEraser /*internal*/, RotationStylus };
234    Q_ENUM(TabletDevice)
235    enum PointerType { UnknownPointer, Pen, Cursor, Eraser };
236    Q_ENUM(PointerType)
237    QTabletEvent(Type t, const QPointF &pos, const QPointF &globalPos,
238                 int device, int pointerType, qreal pressure, int xTilt, int yTilt,
239                 qreal tangentialPressure, qreal rotation, int z,
240                 Qt::KeyboardModifiers keyState, qint64 uniqueID); // ### remove in Qt 6
241    QTabletEvent(Type t, const QPointF &pos, const QPointF &globalPos,
242                 int device, int pointerType, qreal pressure, int xTilt, int yTilt,
243                 qreal tangentialPressure, qreal rotation, int z,
244                 Qt::KeyboardModifiers keyState, qint64 uniqueID,
245                 Qt::MouseButton button, Qt::MouseButtons buttons);
246    ~QTabletEvent();
247
248    inline QPoint pos() const { return mPos.toPoint(); }
249    inline QPoint globalPos() const { return mGPos.toPoint(); }
250#if QT_DEPRECATED_SINCE(5,0)
251    QT_DEPRECATED inline const QPointF &hiResGlobalPos() const { return mPos; }
252#endif
253
254    inline const QPointF &posF() const { return mPos; }
255    inline const QPointF &globalPosF() const { return mGPos; }
256
257    inline int x() const { return qRound(mPos.x()); }
258    inline int y() const { return qRound(mPos.y()); }
259    inline int globalX() const { return qRound(mGPos.x()); }
260    inline int globalY() const { return qRound(mGPos.y()); }
261    inline qreal hiResGlobalX() const { return mGPos.x(); }
262    inline qreal hiResGlobalY() const { return mGPos.y(); }
263    inline TabletDevice device() const { return TabletDevice(mDev); }
264    inline PointerType pointerType() const { return PointerType(mPointerType); }
265    inline qint64 uniqueId() const { return mUnique; }
266    inline qreal pressure() const { return mPress; }
267    inline int z() const { return mZ; }
268    inline qreal tangentialPressure() const { return mTangential; }
269    inline qreal rotation() const { return mRot; }
270    inline int xTilt() const { return mXT; }
271    inline int yTilt() const { return mYT; }
272    Qt::MouseButton button() const;
273    Qt::MouseButtons buttons() const;
274
275protected:
276    QPointF mPos, mGPos;
277    int mDev, mPointerType, mXT, mYT, mZ;
278    qreal mPress, mTangential, mRot;
279    qint64 mUnique;
280
281    // QTabletEventPrivate for extra storage.
282    // ### Qt 6: QPointingEvent will have Buttons, QTabletEvent will inherit
283    void *mExtra;
284};
285#endif // QT_NO_TABLETEVENT
286
287#ifndef QT_NO_GESTURES
288class Q_GUI_EXPORT QNativeGestureEvent : public QInputEvent
289{
290public:
291    QNativeGestureEvent(Qt::NativeGestureType type, const QPointF &localPos, const QPointF &windowPos,
292                        const QPointF &screenPos, qreal value, ulong sequenceId, quint64 intArgument);
293    Qt::NativeGestureType gestureType() const { return mGestureType; }
294    qreal value() const { return mRealValue; }
295
296#ifndef QT_NO_INTEGER_EVENT_COORDINATES
297    inline const QPoint pos() const { return mLocalPos.toPoint(); }
298    inline const QPoint globalPos() const { return mScreenPos.toPoint(); }
299#endif
300    const QPointF &localPos() const { return mLocalPos; }
301    const QPointF &windowPos() const { return mWindowPos; }
302    const QPointF &screenPos() const { return mScreenPos; }
303
304protected:
305    Qt::NativeGestureType mGestureType;
306    QPointF mLocalPos;
307    QPointF mWindowPos;
308    QPointF mScreenPos;
309    qreal mRealValue;
310    ulong mSequenceId;
311    quint64 mIntValue;
312};
313#endif // QT_NO_GESTURES
314
315class Q_GUI_EXPORT QKeyEvent : public QInputEvent
316{
317public:
318    QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text = QString(),
319              bool autorep = false, ushort count = 1);
320    QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers,
321              quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers,
322              const QString &text = QString(), bool autorep = false, ushort count = 1);
323    ~QKeyEvent();
324
325    int key() const { return k; }
326#ifndef QT_NO_SHORTCUT
327    bool matches(QKeySequence::StandardKey key) const;
328#endif
329    Qt::KeyboardModifiers modifiers() const;
330    inline QString text() const { return txt; }
331    inline bool isAutoRepeat() const { return autor; }
332    inline int count() const { return int(c); }
333
334    inline quint32 nativeScanCode() const { return nScanCode; }
335    inline quint32 nativeVirtualKey() const { return nVirtualKey; }
336    inline quint32 nativeModifiers() const { return nModifiers; }
337
338    // Functions for the extended key event information
339#if QT_DEPRECATED_SINCE(5, 0)
340    static inline QKeyEvent *createExtendedKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers,
341                                             quint32 nativeScanCode, quint32 nativeVirtualKey,
342                                             quint32 nativeModifiers,
343                                             const QString& text = QString(), bool autorep = false,
344                                             ushort count = 1)
345    {
346        return new QKeyEvent(type, key, modifiers,
347                             nativeScanCode, nativeVirtualKey, nativeModifiers,
348                             text, autorep, count);
349    }
350
351    inline bool hasExtendedInfo() const { return true; }
352#endif
353
354protected:
355    QString txt;
356    int k;
357    quint32 nScanCode;
358    quint32 nVirtualKey;
359    quint32 nModifiers;
360    ushort c;
361    ushort autor:1;
362    // ushort reserved:15;
363};
364
365
366class Q_GUI_EXPORT QFocusEvent : public QEvent
367{
368public:
369    explicit QFocusEvent(Type type, Qt::FocusReason reason=Qt::OtherFocusReason);
370    ~QFocusEvent();
371
372    inline bool gotFocus() const { return type() == FocusIn; }
373    inline bool lostFocus() const { return type() == FocusOut; }
374
375    Qt::FocusReason reason() const;
376
377private:
378    Qt::FocusReason m_reason;
379};
380
381
382class Q_GUI_EXPORT QPaintEvent : public QEvent
383{
384public:
385    explicit QPaintEvent(const QRegion& paintRegion);
386    explicit QPaintEvent(const QRect &paintRect);
387    ~QPaintEvent();
388
389    inline const QRect &rect() const { return m_rect; }
390    inline const QRegion &region() const { return m_region; }
391
392protected:
393    QRect m_rect;
394    QRegion m_region;
395    bool m_erased;
396};
397
398class Q_GUI_EXPORT QMoveEvent : public QEvent
399{
400public:
401    QMoveEvent(const QPoint &pos, const QPoint &oldPos);
402    ~QMoveEvent();
403
404    inline const QPoint &pos() const { return p; }
405    inline const QPoint &oldPos() const { return oldp;}
406protected:
407    QPoint p, oldp;
408    friend class QApplication;
409};
410
411class Q_GUI_EXPORT QExposeEvent : public QEvent
412{
413public:
414    explicit QExposeEvent(const QRegion &rgn);
415    ~QExposeEvent();
416
417    inline const QRegion &region() const { return rgn; }
418
419protected:
420    QRegion rgn;
421};
422
423class Q_GUI_EXPORT QPlatformSurfaceEvent : public QEvent
424{
425public:
426    enum SurfaceEventType {
427        SurfaceCreated,
428        SurfaceAboutToBeDestroyed
429    };
430
431    explicit QPlatformSurfaceEvent(SurfaceEventType surfaceEventType);
432    ~QPlatformSurfaceEvent();
433
434    inline SurfaceEventType surfaceEventType() const { return m_surfaceEventType; }
435
436protected:
437    SurfaceEventType m_surfaceEventType;
438};
439
440class Q_GUI_EXPORT QResizeEvent : public QEvent
441{
442public:
443    QResizeEvent(const QSize &size, const QSize &oldSize);
444    ~QResizeEvent();
445
446    inline const QSize &size() const { return s; }
447    inline const QSize &oldSize()const { return olds;}
448protected:
449    QSize s, olds;
450    friend class QApplication;
451};
452
453
454class Q_GUI_EXPORT QCloseEvent : public QEvent
455{
456public:
457    QCloseEvent();
458    ~QCloseEvent();
459};
460
461
462class Q_GUI_EXPORT QIconDragEvent : public QEvent
463{
464public:
465    QIconDragEvent();
466    ~QIconDragEvent();
467};
468
469
470class Q_GUI_EXPORT QShowEvent : public QEvent
471{
472public:
473    QShowEvent();
474    ~QShowEvent();
475};
476
477
478class Q_GUI_EXPORT QHideEvent : public QEvent
479{
480public:
481    QHideEvent();
482    ~QHideEvent();
483};
484
485#ifndef QT_NO_CONTEXTMENU
486class Q_GUI_EXPORT QContextMenuEvent : public QInputEvent
487{
488public:
489    enum Reason { Mouse, Keyboard, Other };
490
491    QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos,
492                      Qt::KeyboardModifiers modifiers);
493    QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos);
494    QContextMenuEvent(Reason reason, const QPoint &pos);
495    ~QContextMenuEvent();
496
497    inline int x() const { return p.x(); }
498    inline int y() const { return p.y(); }
499    inline int globalX() const { return gp.x(); }
500    inline int globalY() const { return gp.y(); }
501
502    inline const QPoint& pos() const { return p; }
503    inline const QPoint& globalPos() const { return gp; }
504
505    inline Reason reason() const { return Reason(reas); }
506
507protected:
508    QPoint p;
509    QPoint gp;
510    uint reas : 8;
511};
512#endif // QT_NO_CONTEXTMENU
513
514#ifndef QT_NO_INPUTMETHOD
515class Q_GUI_EXPORT QInputMethodEvent : public QEvent
516{
517public:
518    enum AttributeType {
519       TextFormat,
520       Cursor,
521       Language,
522       Ruby,
523       Selection
524    };
525    class Attribute {
526    public:
527        Attribute(AttributeType typ, int s, int l, QVariant val) : type(typ), start(s), length(l), value(qMove(val)) {}
528        AttributeType type;
529
530        int start;
531        int length;
532        QVariant value;
533    };
534    QInputMethodEvent();
535    QInputMethodEvent(const QString &preeditText, const QList<Attribute> &attributes);
536    ~QInputMethodEvent();
537
538    void setCommitString(const QString &commitString, int replaceFrom = 0, int replaceLength = 0);
539    inline const QList<Attribute> &attributes() const { return attrs; }
540    inline const QString &preeditString() const { return preedit; }
541
542    inline const QString &commitString() const { return commit; }
543    inline int replacementStart() const { return replace_from; }
544    inline int replacementLength() const { return replace_length; }
545
546    QInputMethodEvent(const QInputMethodEvent &other);
547
548private:
549    QString preedit;
550    QList<Attribute> attrs;
551    QString commit;
552    int replace_from;
553    int replace_length;
554};
555Q_DECLARE_TYPEINFO(QInputMethodEvent::Attribute, Q_MOVABLE_TYPE);
556
557class Q_GUI_EXPORT QInputMethodQueryEvent : public QEvent
558{
559public:
560    explicit QInputMethodQueryEvent(Qt::InputMethodQueries queries);
561    ~QInputMethodQueryEvent();
562
563    Qt::InputMethodQueries queries() const { return m_queries; }
564
565    void setValue(Qt::InputMethodQuery query, const QVariant &value);
566    QVariant value(Qt::InputMethodQuery query) const;
567private:
568    Qt::InputMethodQueries m_queries;
569    struct QueryPair {
570        Qt::InputMethodQuery query;
571        QVariant value;
572    };
573    QVector<QueryPair> m_values;
574};
575
576#endif // QT_NO_INPUTMETHOD
577
578#ifndef QT_NO_DRAGANDDROP
579
580class QMimeData;
581
582class Q_GUI_EXPORT QDropEvent : public QEvent
583{
584public:
585    QDropEvent(const QPointF& pos, Qt::DropActions actions, const QMimeData *data,
586               Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop);
587    ~QDropEvent();
588
589    inline QPoint pos() const { return p.toPoint(); }
590    inline const QPointF &posF() const { return p; }
591    inline Qt::MouseButtons mouseButtons() const { return mouseState; }
592    inline Qt::KeyboardModifiers keyboardModifiers() const { return modState; }
593
594    inline Qt::DropActions possibleActions() const { return act; }
595    inline Qt::DropAction proposedAction() const { return default_action; }
596    inline void acceptProposedAction() { drop_action = default_action; accept(); }
597
598    inline Qt::DropAction dropAction() const { return drop_action; }
599    void setDropAction(Qt::DropAction action);
600
601    QObject* source() const;
602    inline const QMimeData *mimeData() const { return mdata; }
603
604protected:
605    friend class QApplication;
606    QPointF p;
607    Qt::MouseButtons mouseState;
608    Qt::KeyboardModifiers modState;
609    Qt::DropActions act;
610    Qt::DropAction drop_action;
611    Qt::DropAction default_action;
612    const QMimeData *mdata;
613};
614
615
616class Q_GUI_EXPORT QDragMoveEvent : public QDropEvent
617{
618public:
619    QDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data,
620                   Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove);
621    ~QDragMoveEvent();
622
623    inline QRect answerRect() const { return rect; }
624
625    inline void accept() { QDropEvent::accept(); }
626    inline void ignore() { QDropEvent::ignore(); }
627
628    inline void accept(const QRect & r) { accept(); rect = r; }
629    inline void ignore(const QRect & r) { ignore(); rect = r; }
630
631protected:
632    QRect rect;
633};
634
635
636class Q_GUI_EXPORT QDragEnterEvent : public QDragMoveEvent
637{
638public:
639    QDragEnterEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data,
640                    Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers);
641    ~QDragEnterEvent();
642};
643
644
645class Q_GUI_EXPORT QDragLeaveEvent : public QEvent
646{
647public:
648    QDragLeaveEvent();
649    ~QDragLeaveEvent();
650};
651#endif // QT_NO_DRAGANDDROP
652
653
654class Q_GUI_EXPORT QHelpEvent : public QEvent
655{
656public:
657    QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos);
658    ~QHelpEvent();
659
660    inline int x() const { return p.x(); }
661    inline int y() const { return p.y(); }
662    inline int globalX() const { return gp.x(); }
663    inline int globalY() const { return gp.y(); }
664
665    inline const QPoint& pos()  const { return p; }
666    inline const QPoint& globalPos() const { return gp; }
667
668private:
669    QPoint p;
670    QPoint gp;
671};
672
673#ifndef QT_NO_STATUSTIP
674class Q_GUI_EXPORT QStatusTipEvent : public QEvent
675{
676public:
677    explicit QStatusTipEvent(const QString &tip);
678    ~QStatusTipEvent();
679
680    inline QString tip() const { return s; }
681private:
682    QString s;
683};
684#endif
685
686#ifndef QT_NO_WHATSTHIS
687class Q_GUI_EXPORT QWhatsThisClickedEvent : public QEvent
688{
689public:
690    explicit QWhatsThisClickedEvent(const QString &href);
691    ~QWhatsThisClickedEvent();
692
693    inline QString href() const { return s; }
694private:
695    QString s;
696};
697#endif
698
699#ifndef QT_NO_ACTION
700class Q_GUI_EXPORT QActionEvent : public QEvent
701{
702    QAction *act, *bef;
703public:
704    QActionEvent(int type, QAction *action, QAction *before = Q_NULLPTR);
705    ~QActionEvent();
706
707    inline QAction *action() const { return act; }
708    inline QAction *before() const { return bef; }
709};
710#endif
711
712class Q_GUI_EXPORT QFileOpenEvent : public QEvent
713{
714public:
715    explicit QFileOpenEvent(const QString &file);
716    explicit QFileOpenEvent(const QUrl &url);
717    ~QFileOpenEvent();
718
719    inline QString file() const { return f; }
720    QUrl url() const { return m_url; }
721    bool openFile(QFile &file, QIODevice::OpenMode flags) const;
722private:
723    QString f;
724    QUrl m_url;
725};
726
727#ifndef QT_NO_TOOLBAR
728class Q_GUI_EXPORT QToolBarChangeEvent : public QEvent
729{
730public:
731    explicit QToolBarChangeEvent(bool t);
732    ~QToolBarChangeEvent();
733
734    inline bool toggle() const { return tog; }
735private:
736    uint tog : 1;
737};
738#endif
739
740#ifndef QT_NO_SHORTCUT
741class Q_GUI_EXPORT QShortcutEvent : public QEvent
742{
743public:
744    QShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false);
745    ~QShortcutEvent();
746
747    inline const QKeySequence &key() const { return sequence; }
748    inline int shortcutId() const { return sid; }
749    inline bool isAmbiguous() const { return ambig; }
750protected:
751    QKeySequence sequence;
752    bool ambig;
753    int  sid;
754};
755#endif
756
757class Q_GUI_EXPORT QWindowStateChangeEvent: public QEvent
758{
759public:
760    explicit QWindowStateChangeEvent(Qt::WindowStates aOldState, bool isOverride = false);
761    ~QWindowStateChangeEvent();
762
763    inline Qt::WindowStates oldState() const { return ostate; }
764    bool isOverride() const;
765
766private:
767    Qt::WindowStates ostate;
768    bool m_override;
769};
770
771#ifndef QT_NO_DEBUG_STREAM
772Q_GUI_EXPORT QDebug operator<<(QDebug, const QEvent *);
773#endif
774
775#ifndef QT_NO_SHORTCUT
776inline bool operator==(QKeyEvent *e, QKeySequence::StandardKey key){return (e ? e->matches(key) : false);}
777inline bool operator==(QKeySequence::StandardKey key, QKeyEvent *e){return (e ? e->matches(key) : false);}
778#endif // QT_NO_SHORTCUT
779
780class QTouchEventTouchPointPrivate;
781class Q_GUI_EXPORT QTouchEvent : public QInputEvent
782{
783public:
784    class Q_GUI_EXPORT TouchPoint
785    {
786    public:
787        enum InfoFlag {
788            Pen  = 0x0001
789        };
790#ifndef Q_MOC_RUN
791        // otherwise moc gives
792        // Error: Meta object features not supported for nested classes
793        Q_DECLARE_FLAGS(InfoFlags, InfoFlag)
794#endif
795
796        explicit TouchPoint(int id = -1);
797        TouchPoint(const TouchPoint &other);
798#ifdef Q_COMPILER_RVALUE_REFS
799        TouchPoint(TouchPoint &&other) Q_DECL_NOEXCEPT
800            : d(Q_NULLPTR)
801        { qSwap(d, other.d); }
802        TouchPoint &operator=(TouchPoint &&other) Q_DECL_NOEXCEPT
803        { qSwap(d, other.d); return *this; }
804#endif
805        ~TouchPoint();
806
807        TouchPoint &operator=(const TouchPoint &other)
808        { if ( d != other.d ) { TouchPoint copy(other); swap(copy); } return *this; }
809
810        void swap(TouchPoint &other) Q_DECL_NOEXCEPT
811        { qSwap(d, other.d); }
812
813        int id() const;
814
815        Qt::TouchPointState state() const;
816
817        QPointF pos() const;
818        QPointF startPos() const;
819        QPointF lastPos() const;
820
821        QPointF scenePos() const;
822        QPointF startScenePos() const;
823        QPointF lastScenePos() const;
824
825        QPointF screenPos() const;
826        QPointF startScreenPos() const;
827        QPointF lastScreenPos() const;
828
829        QPointF normalizedPos() const;
830        QPointF startNormalizedPos() const;
831        QPointF lastNormalizedPos() const;
832
833        QRectF rect() const;
834        QRectF sceneRect() const;
835        QRectF screenRect() const;
836
837        qreal pressure() const;
838        QVector2D velocity() const;
839        InfoFlags flags() const;
840        QVector<QPointF> rawScreenPositions() const;
841
842        // internal
843        void setId(int id);
844        void setState(Qt::TouchPointStates state);
845        void setPos(const QPointF &pos);
846        void setScenePos(const QPointF &scenePos);
847        void setScreenPos(const QPointF &screenPos);
848        void setNormalizedPos(const QPointF &normalizedPos);
849        void setStartPos(const QPointF &startPos);
850        void setStartScenePos(const QPointF &startScenePos);
851        void setStartScreenPos(const QPointF &startScreenPos);
852        void setStartNormalizedPos(const QPointF &startNormalizedPos);
853        void setLastPos(const QPointF &lastPos);
854        void setLastScenePos(const QPointF &lastScenePos);
855        void setLastScreenPos(const QPointF &lastScreenPos);
856        void setLastNormalizedPos(const QPointF &lastNormalizedPos);
857        void setRect(const QRectF &rect);
858        void setSceneRect(const QRectF &sceneRect);
859        void setScreenRect(const QRectF &screenRect);
860        void setPressure(qreal pressure);
861        void setVelocity(const QVector2D &v);
862        void setFlags(InfoFlags flags);
863        void setRawScreenPositions(const QVector<QPointF> &positions);
864
865    private:
866        QTouchEventTouchPointPrivate *d;
867        friend class QGuiApplication;
868        friend class QGuiApplicationPrivate;
869        friend class QApplication;
870        friend class QApplicationPrivate;
871    };
872
873#if QT_DEPRECATED_SINCE(5, 0)
874    enum DeviceType {
875        TouchScreen,
876        TouchPad
877    };
878#endif
879
880    explicit QTouchEvent(QEvent::Type eventType,
881                         QTouchDevice *device = Q_NULLPTR,
882                         Qt::KeyboardModifiers modifiers = Qt::NoModifier,
883                         Qt::TouchPointStates touchPointStates = Qt::TouchPointStates(),
884                         const QList<QTouchEvent::TouchPoint> &touchPoints = QList<QTouchEvent::TouchPoint>());
885    ~QTouchEvent();
886
887    inline QWindow *window() const { return _window; }
888    inline QObject *target() const { return _target; }
889#if QT_DEPRECATED_SINCE(5, 0)
890    QT_DEPRECATED inline QTouchEvent::DeviceType deviceType() const { return static_cast<DeviceType>(int(_device->type())); }
891#endif
892    inline Qt::TouchPointStates touchPointStates() const { return _touchPointStates; }
893    inline const QList<QTouchEvent::TouchPoint> &touchPoints() const { return _touchPoints; }
894    inline QTouchDevice *device() const { return _device; }
895
896    // internal
897    inline void setWindow(QWindow *awindow) { _window = awindow; }
898    inline void setTarget(QObject *atarget) { _target = atarget; }
899    inline void setTouchPointStates(Qt::TouchPointStates aTouchPointStates) { _touchPointStates = aTouchPointStates; }
900    inline void setTouchPoints(const QList<QTouchEvent::TouchPoint> &atouchPoints) { _touchPoints = atouchPoints; }
901    inline void setDevice(QTouchDevice *adevice) { _device = adevice; }
902
903protected:
904    QWindow *_window;
905    QObject *_target;
906    QTouchDevice *_device;
907    Qt::TouchPointStates _touchPointStates;
908    QList<QTouchEvent::TouchPoint> _touchPoints;
909
910    friend class QGuiApplication;
911    friend class QGuiApplicationPrivate;
912    friend class QApplication;
913    friend class QApplicationPrivate;
914};
915Q_DECLARE_TYPEINFO(QTouchEvent::TouchPoint, Q_MOVABLE_TYPE);
916Q_DECLARE_OPERATORS_FOR_FLAGS(QTouchEvent::TouchPoint::InfoFlags)
917
918#ifndef QT_NO_DEBUG_STREAM
919Q_GUI_EXPORT QDebug operator<<(QDebug, const QTouchEvent::TouchPoint &);
920#endif
921
922class Q_GUI_EXPORT QScrollPrepareEvent : public QEvent
923{
924public:
925    explicit QScrollPrepareEvent(const QPointF &startPos);
926    ~QScrollPrepareEvent();
927
928    QPointF startPos() const;
929
930    QSizeF viewportSize() const;
931    QRectF contentPosRange() const;
932    QPointF contentPos() const;
933
934    void setViewportSize(const QSizeF &size);
935    void setContentPosRange(const QRectF &rect);
936    void setContentPos(const QPointF &pos);
937
938private:
939    QObject* m_target; // Qt 6 remove.
940    QPointF m_startPos;
941    QSizeF m_viewportSize;
942    QRectF m_contentPosRange;
943    QPointF m_contentPos;
944};
945
946
947class Q_GUI_EXPORT QScrollEvent : public QEvent
948{
949public:
950    enum ScrollState
951    {
952        ScrollStarted,
953        ScrollUpdated,
954        ScrollFinished
955    };
956
957    QScrollEvent(const QPointF &contentPos, const QPointF &overshoot, ScrollState scrollState);
958    ~QScrollEvent();
959
960    QPointF contentPos() const;
961    QPointF overshootDistance() const;
962    ScrollState scrollState() const;
963
964private:
965    QPointF m_contentPos;
966    QPointF m_overshoot;
967    QScrollEvent::ScrollState m_state;
968};
969
970class Q_GUI_EXPORT QScreenOrientationChangeEvent : public QEvent
971{
972public:
973    QScreenOrientationChangeEvent(QScreen *screen, Qt::ScreenOrientation orientation);
974    ~QScreenOrientationChangeEvent();
975
976    QScreen *screen() const;
977    Qt::ScreenOrientation orientation() const;
978
979private:
980    QScreen *m_screen;
981    Qt::ScreenOrientation m_orientation;
982};
983
984class Q_GUI_EXPORT QApplicationStateChangeEvent : public QEvent
985{
986public:
987    explicit QApplicationStateChangeEvent(Qt::ApplicationState state);
988    Qt::ApplicationState applicationState() const;
989
990private:
991    Qt::ApplicationState m_applicationState;
992};
993
994QT_END_NAMESPACE
995
996#endif // QEVENT_H