Revision control
++ // Copyright (C) 2020 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qevent.h"
++
++ #include "qcursor.h"
++ #include "private/qguiapplication_p.h"
++ #include "private/qinputdevice_p.h"
++ #include "private/qpointingdevice_p.h"
++ #include "qpa/qplatformintegration.h"
++ #include "private/qevent_p.h"
++ #include "private/qeventpoint_p.h"
++
++ #include "qfile.h"
++ #include "qhashfunctions.h"
++ #include "qmetaobject.h"
++ #include "qmimedata.h"
++ #include "qevent_p.h"
++ #include "qmath.h"
++ #include "qloggingcategory.h"
++ #include "qpointer.h"
++
++ #if QT_CONFIG(draganddrop)
++ #include <qpa/qplatformdrag.h>
++ #include <private/qdnd_p.h>
++ #endif
++
++ #if QT_CONFIG(shortcut)
++ #include <private/qshortcut_p.h>
++ #endif
++
++ #include <private/qdebug_p.h>
++
++ #define Q_IMPL_POINTER_EVENT(Class) \
++ Class::Class(const Class &) = default; \
++ Class::~Class() = default; \
++ Class* Class::clone() const \
++ { \
++ auto c = new Class(*this); \
++ for (auto &point : c->m_points) \
++ QMutableEventPoint::detach(point); \
++ QEvent *e = c; \
++ /* check that covariant return is safe to add */ \
++ Q_ASSERT(reinterpret_cast<quintptr>(c) == reinterpret_cast<quintptr>(e)); \
++ return c; \
++ }
++
++
++
++ QT_BEGIN_NAMESPACE
++
++ static_assert(sizeof(QMutableTouchEvent) == sizeof(QTouchEvent));
++ static_assert(sizeof(QMutableSinglePointEvent) == sizeof(QSinglePointEvent));
++ static_assert(sizeof(QMouseEvent) == sizeof(QSinglePointEvent));
++ static_assert(sizeof(QVector2D) == sizeof(quint64));
++
++ /*!
++ \class QEnterEvent
++ \ingroup events
++ \inmodule QtGui
++
++ \brief The QEnterEvent class contains parameters that describe an enter event.
++
++ Enter events occur when the mouse cursor enters a window or a widget.
++
++ \since 5.0
++ */
++
++ /*!
++ Constructs an enter event object originating from \a device.
++
++ The points \a localPos, \a scenePos and \a globalPos specify the
++ mouse cursor's position relative to the receiving widget or item,
++ window, and screen or desktop, respectively.
++ */
++ QEnterEvent::QEnterEvent(const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos, const QPointingDevice *device)
++ : QSinglePointEvent(QEvent::Enter, device, localPos, scenePos, globalPos, Qt::NoButton, Qt::NoButton, Qt::NoModifier)
++ {
++ }
++
++ Q_IMPL_POINTER_EVENT(QEnterEvent)
++
++ /*!
++ \fn QPoint QEnterEvent::globalPos() const
++ \deprecated [6.0] Use globalPosition() instead.
++
++ Returns the global position of the mouse cursor \e{at the time of the event}.
++ */
++ /*!
++ \fn int QEnterEvent::globalX() const
++ \deprecated [6.0] Use globalPosition().x() instead.
++
++ Returns the global position on the X-axis of the mouse cursor \e{at the time of the event}.
++ */
++ /*!
++ \fn int QEnterEvent::globalY() const
++ \deprecated [6.0] Use globalPosition().y() instead.
++
++ Returns the global position on the Y-axis of the mouse cursor \e{at the time of the event}.
++ */
++ /*!
++ \fn QPointF QEnterEvent::localPos() const
++ \deprecated [6.0] Use position() instead.
++
++ Returns the mouse cursor's position relative to the receiving widget.
++ */
++ /*!
++ \fn QPoint QEnterEvent::pos() const
++ \deprecated [6.0] Use position().toPoint() instead.
++
++ Returns the position of the mouse cursor relative to the receiving widget.
++ */
++ /*!
++ \fn QPointF QEnterEvent::screenPos() const
++ \deprecated [6.0] Use globalPosition() instead.
++
++ Returns the position of the mouse cursor relative to the receiving screen.
++ */
++ /*!
++ \fn QPointF QEnterEvent::windowPos() const
++ \deprecated [6.0] Use scenePosition() instead.
++
++ Returns the position of the mouse cursor relative to the receiving window.
++ */
++ /*!
++ \fn int QEnterEvent::x() const
++ \deprecated [6.0] Use position().x() instead.
++
++ Returns the x position of the mouse cursor relative to the receiving widget.
++ */
++ /*!
++ \fn int QEnterEvent::y() const
++ \deprecated [6.0] Use position().y() instead.
++
++ Returns the y position of the mouse cursor relative to the receiving widget.
++ */
++
++ /*!
++ \class QInputEvent
++ \ingroup events
++ \inmodule QtGui
++
++ \brief The QInputEvent class is the base class for events that
++ describe user input.
++ */
++
++ /*!
++ \internal
++ */
++ QInputEvent::QInputEvent(Type type, const QInputDevice *dev, Qt::KeyboardModifiers modifiers)
++ : QEvent(type, QEvent::InputEventTag{}), m_dev(dev), m_modState(modifiers), m_reserved(0)
++ {}
++
++ /*!
++ \internal
++ */
++ QInputEvent::QInputEvent(QEvent::Type type, QEvent::PointerEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers)
++ : QEvent(type, QEvent::PointerEventTag{}), m_dev(dev), m_modState(modifiers), m_reserved(0)
++ {}
++
++ /*!
++ \internal
++ */
++ QInputEvent::QInputEvent(QEvent::Type type, QEvent::SinglePointEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers)
++ : QEvent(type, QEvent::SinglePointEventTag{}), m_dev(dev), m_modState(modifiers), m_reserved(0)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QInputEvent)
++
++ /*!
++ \fn QInputDevice *QInputEvent::device() const
++ \since 6.0
++
++ Returns the source device that generated the original event.
++
++ In case of a synthesized event, for example a mouse event that was
++ generated from a touch event, \c device() continues to return the touchscreen
++ device, so that you can tell that it did not come from an actual mouse.
++ Thus \c {mouseEvent.source()->type() != QInputDevice::DeviceType::Mouse}
++ is one possible replacement for the Qt 5 expression
++ \c {mouseEvent.source() == Qt::MouseEventSynthesizedByQt}.
++
++ \sa QPointerEvent::pointingDevice()
++ */
++
++ /*!
++ \fn QInputDevice::DeviceType QInputEvent::deviceType() const
++
++ Returns the type of device that generated the event.
++ */
++
++ /*!
++ \fn Qt::KeyboardModifiers QInputEvent::modifiers() const
++
++ Returns the keyboard modifier flags that existed immediately
++ before the event occurred.
++
++ \sa QGuiApplication::keyboardModifiers()
++ */
++
++ /*! \fn void QInputEvent::setModifiers(Qt::KeyboardModifiers modifiers)
++
++ \internal
++
++ Sets the keyboard modifiers flags for this event.
++ */
++
++ /*!
++ \fn quint64 QInputEvent::timestamp() const
++
++ Returns the window system's timestamp for this event.
++ It will normally be in milliseconds since some arbitrary point
++ in time, such as the time when the system was started.
++ */
++
++ /*! \fn void QInputEvent::setTimestamp(quint64 atimestamp)
++
++ \internal
++
++ Sets the timestamp for this event.
++ */
++
++ /*!
++ \class QPointerEvent
++ \since 6.0
++ \inmodule QtGui
++
++ \brief A base class for pointer events.
++ */
++
++ /*!
++ \fn qsizetype QPointerEvent::pointCount() const
++
++ Returns the number of points in this pointer event.
++ */
++
++ /*!
++ Returns a QEventPoint reference for the point at index \a i.
++ */
++ QEventPoint &QPointerEvent::point(qsizetype i)
++ {
++ return m_points[i];
++ }
++
++ /*!
++ \fn const QList<QEventPoint> &QPointerEvent::points() const
++
++ Returns a list of points in this pointer event.
++ */
++
++ /*!
++ \fn QPointingDevice::PointerType QPointerEvent::pointerType() const
++
++ Returns the type of point that generated the event.
++ */
++
++ /*!
++ \internal
++ */
++ QPointerEvent::QPointerEvent(QEvent::Type type, const QPointingDevice *dev,
++ Qt::KeyboardModifiers modifiers, const QList<QEventPoint> &points)
++ : QInputEvent(type, QEvent::PointerEventTag{}, dev, modifiers), m_points(points)
++ {
++ }
++
++ /*!
++ \internal
++ */
++ QPointerEvent::QPointerEvent(QEvent::Type type, QEvent::SinglePointEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers)
++ : QInputEvent(type, QEvent::SinglePointEventTag{}, dev, modifiers)
++ {
++ }
++
++ Q_IMPL_POINTER_EVENT(QPointerEvent);
++
++ /*!
++ Returns the point whose \l {QEventPoint::id()}{id} matches the given \a id,
++ or \c nullptr if no such point is found.
++ */
++ QEventPoint *QPointerEvent::pointById(int id)
++ {
++ for (auto &p : m_points) {
++ if (p.id() == id)
++ return &p;
++ }
++ return nullptr;
++ }
++
++ /*!
++ Returns \c true if every point in points() has either an exclusiveGrabber()
++ or one or more passiveGrabbers().
++ */
++ bool QPointerEvent::allPointsGrabbed() const
++ {
++ for (const auto &p : points()) {
++ if (!exclusiveGrabber(p) && passiveGrabbers(p).isEmpty())
++ return false;
++ }
++ return true;
++ }
++
++ /*!
++ Returns \c true if isPointAccepted() is \c true for every point in
++ points(); otherwise \c false.
++ */
++ bool QPointerEvent::allPointsAccepted() const
++ {
++ for (const auto &p : points()) {
++ if (!p.isAccepted())
++ return false;
++ }
++ return true;
++ }
++
++ /*!
++ \reimp
++ */
++ void QPointerEvent::setAccepted(bool accepted)
++ {
++ QEvent::setAccepted(accepted);
++ for (auto &p : m_points)
++ p.setAccepted(accepted);
++ }
++
++ /*!
++ Returns the source device from which this event originates.
++
++ This is the same as QInputEvent::device() but typecast for convenience.
++ */
++ const QPointingDevice *QPointerEvent::pointingDevice() const
++ {
++ return static_cast<const QPointingDevice *>(m_dev);
++ }
++
++ /*! \internal
++ Sets the timestamp for this event and its points().
++ */
++ void QPointerEvent::setTimestamp(quint64 timestamp)
++ {
++ QInputEvent::setTimestamp(timestamp);
++ for (auto &p : m_points)
++ QMutableEventPoint::setTimestamp(p, timestamp);
++ }
++
++ /*!
++ Returns the object which has been set to receive all future update events
++ and the release event containing the given \a point.
++
++ It's mainly for use in Qt Quick at this time.
++ */
++ QObject *QPointerEvent::exclusiveGrabber(const QEventPoint &point) const
++ {
++ Q_ASSERT(pointingDevice());
++ auto persistentPoint = QPointingDevicePrivate::get(pointingDevice())->queryPointById(point.id());
++ if (Q_UNLIKELY(!persistentPoint)) {
++ qWarning() << "point is not in activePoints" << point;
++ return nullptr;
++ }
++ return persistentPoint->exclusiveGrabber;
++ }
++
++ /*!
++ Informs the delivery logic that the given \a exclusiveGrabber is to
++ receive all future update events and the release event containing
++ the given \a point, and that delivery to other items can be skipped.
++
++ It's mainly for use in Qt Quick at this time.
++ */
++ void QPointerEvent::setExclusiveGrabber(const QEventPoint &point, QObject *exclusiveGrabber)
++ {
++ Q_ASSERT(pointingDevice());
++ auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice()));
++ devPriv->setExclusiveGrabber(this, point, exclusiveGrabber);
++ }
++
++ /*!
++ Returns the list of objects that have been requested to receive all
++ future update events and the release event containing the given \a point.
++
++ It's only for use by \l {Qt Quick Input Handlers}.
++
++ \sa QPointerEvent::addPassiveGrabber()
++ */
++ QList<QPointer<QObject> > QPointerEvent::passiveGrabbers(const QEventPoint &point) const
++ {
++ Q_ASSERT(pointingDevice());
++ auto persistentPoint = QPointingDevicePrivate::get(pointingDevice())->queryPointById(point.id());
++ if (Q_UNLIKELY(!persistentPoint)) {
++ qWarning() << "point is not in activePoints" << point;
++ return {};
++ }
++ return persistentPoint->passiveGrabbers;
++ }
++
++ /*!
++ Informs the delivery logic that the given \a grabber is to receive all
++ future update events and the release event containing the given \a point,
++ regardless where else those events may be delivered.
++
++ It's only for use by \l {Qt Quick Input Handlers}.
++
++ Returns \c false if \a grabber was already added, \c true otherwise.
++ */
++ bool QPointerEvent::addPassiveGrabber(const QEventPoint &point, QObject *grabber)
++ {
++ Q_ASSERT(pointingDevice());
++ auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice()));
++ return devPriv->addPassiveGrabber(this, point, grabber);
++ }
++
++ /*!
++ Removes the passive \a grabber from the given \a point if it was previously added.
++ Returns \c true if it had been a passive grabber before, \c false if not.
++
++ It's only for use by \l {Qt Quick Input Handlers}.
++
++ \sa QPointerEvent::addPassiveGrabber()
++ */
++ bool QPointerEvent::removePassiveGrabber(const QEventPoint &point, QObject *grabber)
++ {
++ Q_ASSERT(pointingDevice());
++ auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice()));
++ return devPriv->removePassiveGrabber(this, point, grabber);
++ }
++
++ /*!
++ Removes all passive grabbers from the given \a point.
++
++ It's only for use by \l {Qt Quick Input Handlers}.
++
++ \sa QPointerEvent::addPassiveGrabber()
++ */
++ void QPointerEvent::clearPassiveGrabbers(const QEventPoint &point)
++ {
++ Q_ASSERT(pointingDevice());
++ auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice()));
++ devPriv->clearPassiveGrabbers(this, point);
++ }
++
++ /*!
++ \class QSinglePointEvent
++ \since 6.0
++ \inmodule QtGui
++
++ \brief A base class for pointer events containing a single point, such as
++ mouse events.
++ */
++
++ /*! \fn Qt::MouseButton QSinglePointEvent::button() const
++
++ Returns the button that caused the event.
++
++ The returned value is always Qt::NoButton for mouse move events, as
++ well as \l TabletMove, \l TabletEnterProximity, and
++ \l TabletLeaveProximity events.
++
++ \sa buttons()
++ */
++
++ /*! \fn Qt::MouseButtons QSinglePointEvent::buttons() const
++
++ Returns the button state when the event was generated.
++
++ The button state is a combination of Qt::LeftButton, Qt::RightButton,
++ and Qt::MiddleButton using the OR operator.
++
++ For mouse move or \l TabletMove events, this is all buttons that are
++ pressed down.
++
++ For mouse press, double click, or \l TabletPress events, this includes
++ the button that caused the event.
++
++ For mouse release or \l TabletRelease events, this excludes the button
++ that caused the event.
++
++ \sa button()
++ */
++
++ /*! \fn QPointF QSinglePointEvent::position() const
++
++ Returns the position of the point in this event, relative to the widget or
++ item that received the event.
++
++ If you move your widgets around in response to mouse events, use
++ globalPosition() instead.
++
++ \sa globalPosition()
++ */
++
++ /*! \fn QPointF QSinglePointEvent::scenePosition() const
++
++ Returns the position of the point in this event, relative to the window or
++ scene.
++
++ \sa QEventPoint::scenePosition
++ */
++
++ /*! \fn QPointF QSinglePointEvent::globalPosition() const
++
++ Returns the position of the point in this event on the screen or virtual
++ desktop.
++
++ \note The global position of a mouse pointer is recorded \e{at the time
++ of the event}. This is important on asynchronous window systems
++ such as X11; whenever you move your widgets around in response to
++ mouse events, globalPosition() can differ a lot from the current
++ cursor position returned by QCursor::pos().
++
++ \sa position()
++ */
++
++ /*!
++ \internal
++ */
++ QSinglePointEvent::QSinglePointEvent(QEvent::Type type, const QPointingDevice *dev,
++ const QPointF &localPos, const QPointF &scenePos, const QPointF &globalPos,
++ Qt::MouseButton button, Qt::MouseButtons buttons,
++ Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source)
++ : QPointerEvent(type, QEvent::SinglePointEventTag{}, dev, modifiers),
++ m_button(button),
++ m_mouseState(buttons),
++ m_source(source),
++ m_reserved(0), m_reserved2(0),
++ m_doubleClick(false), m_phase(0), m_invertedScrolling(0)
++ {
++ const bool isPress = (button != Qt::NoButton && (button | buttons) == buttons);
++ const bool isWheel = (type == QEvent::Type::Wheel);
++ auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice()));
++ auto epd = devPriv->pointById(0);
++ QEventPoint &p = epd->eventPoint;
++ QMutableEventPoint::detach(p);
++ Q_ASSERT(p.device() == dev);
++ if (isPress || isWheel)
++ QMutableEventPoint::setGlobalLastPosition(p, globalPos);
++ else
++ QMutableEventPoint::setGlobalLastPosition(p, p.globalPosition());
++ QMutableEventPoint::setGlobalPosition(p, globalPos);
++ if (isWheel && p.state() != QEventPoint::State::Updated)
++ QMutableEventPoint::setGlobalPressPosition(p, globalPos);
++ if (type == MouseButtonDblClick)
++ QMutableEventPoint::setState(p, QEventPoint::State::Stationary);
++ else if (button == Qt::NoButton || isWheel)
++ QMutableEventPoint::setState(p, QEventPoint::State::Updated);
++ else if (isPress)
++ QMutableEventPoint::setState(p, QEventPoint::State::Pressed);
++ else
++ QMutableEventPoint::setState(p, QEventPoint::State::Released);
++ QMutableEventPoint::setScenePosition(p, scenePos);
++ QMutableEventPoint::setPosition(p, localPos);
++ m_points.append(p);
++ }
++
++ /*! \internal
++ Constructs a single-point event with the given \a point, which must be an instance
++ (or copy of one) that already exists in QPointingDevicePrivate::activePoints.
++ Unlike the other constructor, it does not modify the given \a point in any way.
++ This is useful when synthesizing a QMouseEvent from one point taken from a QTouchEvent, for example.
++
++ \sa QMutableSinglePointEvent()
++ */
++ QSinglePointEvent::QSinglePointEvent(QEvent::Type type, const QPointingDevice *dev, const QEventPoint &point,
++ Qt::MouseButton button, Qt::MouseButtons buttons,
++ Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source)
++ : QPointerEvent(type, QEvent::SinglePointEventTag{}, dev, modifiers),
++ m_button(button),
++ m_mouseState(buttons),
++ m_source(source),
++ m_reserved(0), m_reserved2(0),
++ m_doubleClick(false), m_phase(0), m_invertedScrolling(0)
++ {
++ m_points << point;
++ }
++
++ Q_IMPL_POINTER_EVENT(QSinglePointEvent)
++
++ /*!
++ Returns \c true if this event represents a \l {button()}{button} being pressed.
++ */
++ bool QSinglePointEvent::isBeginEvent() const
++ {
++ // A double-click event does not begin a sequence: it comes after a press event,
++ // and while it tells which button caused the double-click, it doesn't represent
++ // a change of button state. So it's an update event.
++ return m_button != Qt::NoButton && m_mouseState.testFlag(m_button)
++ && type() != QEvent::MouseButtonDblClick;
++ }
++
++ /*!
++ Returns \c true if this event does not include a change in \l {buttons()}{button state}.
++ */
++ bool QSinglePointEvent::isUpdateEvent() const
++ {
++ // A double-click event is an update event even though it tells which button
++ // caused the double-click, because a MouseButtonPress event was sent right before it.
++ return m_button == Qt::NoButton || type() == QEvent::MouseButtonDblClick;
++ }
++
++ /*!
++ Returns \c true if this event represents a \l {button()}{button} being released.
++ */
++ bool QSinglePointEvent::isEndEvent() const
++ {
++ return m_button != Qt::NoButton && !m_mouseState.testFlag(m_button);
++ }
++
++ /*!
++ \property QSinglePointEvent::exclusivePointGrabber
++ \brief the object that will receive future updates
++
++ The exclusive grabber is an object that has chosen to receive all future
++ update events and the release event containing the same point that this
++ event carries.
++
++ Setting the exclusivePointGrabber property is a convenience equivalent to:
++ \code
++ setExclusiveGrabber(points().first(), exclusiveGrabber);
++ \endcode
++ */
++
++ /*!
++ \class QMouseEvent
++ \ingroup events
++ \inmodule QtGui
++
++ \brief The QMouseEvent class contains parameters that describe a mouse event.
++
++ Mouse events occur when a mouse button is pressed or released
++ inside a widget, or when the mouse cursor is moved.
++
++ Mouse move events will occur only when a mouse button is pressed
++ down, unless mouse tracking has been enabled with
++ QWidget::setMouseTracking().
++
++ Qt automatically grabs the mouse when a mouse button is pressed
++ inside a widget; the widget will continue to receive mouse events
++ until the last mouse button is released.
++
++ A mouse event contains a special accept flag that indicates
++ whether the receiver wants the event. You should call ignore() if
++ the mouse event is not handled by your widget. A mouse event is
++ propagated up the parent widget chain until a widget accepts it
++ with accept(), or an event filter consumes it.
++
++ \note If a mouse event is propagated to a \l{QWidget}{widget} for
++ which Qt::WA_NoMousePropagation has been set, that mouse event
++ will not be propagated further up the parent widget chain.
++
++ The state of the keyboard modifier keys can be found by calling the
++ \l{QInputEvent::modifiers()}{modifiers()} function, inherited from
++ QInputEvent.
++
++ The position() function gives the cursor position
++ relative to the widget or item that receives the mouse event.
++ If you move the widget as a result of the mouse event, use the
++ global position returned by globalPosition() to avoid a shaking motion.
++
++ The QWidget::setEnabled() function can be used to enable or
++ disable mouse and keyboard events for a widget.
++
++ Reimplement the QWidget event handlers, QWidget::mousePressEvent(),
++ QWidget::mouseReleaseEvent(), QWidget::mouseDoubleClickEvent(),
++ and QWidget::mouseMoveEvent() to receive mouse events in your own
++ widgets.
++
++ \sa QWidget::setMouseTracking(), QWidget::grabMouse(),
++ QCursor::pos()
++ */
++
++ #if QT_DEPRECATED_SINCE(6, 4)
++ /*!
++ \deprecated [6.4] Use another constructor instead (global position is required).
++
++ Constructs a mouse event object originating from \a device.
++
++ The \a type parameter must be one of QEvent::MouseButtonPress,
++ QEvent::MouseButtonRelease, QEvent::MouseButtonDblClick,
++ or QEvent::MouseMove.
++
++ The \a localPos is the mouse cursor's position relative to the
++ receiving widget or item. The window position is set to the same value
++ as \a localPos.
++ The \a button that caused the event is given as a value from
++ the Qt::MouseButton enum. If the event \a type is
++ \l MouseMove, the appropriate button for this event is Qt::NoButton.
++ The mouse and keyboard states at the time of the event are specified by
++ \a buttons and \a modifiers.
++
++ The globalPosition() is initialized to QCursor::pos(), which may not
++ be appropriate. Use the other constructor to specify the global
++ position explicitly.
++ */
++ QMouseEvent::QMouseEvent(Type type, const QPointF &localPos, Qt::MouseButton button,
++ Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, const QPointingDevice *device)
++ : QSinglePointEvent(type, device, localPos, localPos,
++ #ifdef QT_NO_CURSOR
++ localPos,
++ #else
++ QCursor::pos(),
++ #endif
++ button, buttons, modifiers)
++ {
++ }
++ #endif
++
++ /*!
++ Constructs a mouse event object originating from \a device.
++
++ The \a type parameter must be QEvent::MouseButtonPress,
++ QEvent::MouseButtonRelease, QEvent::MouseButtonDblClick,
++ or QEvent::MouseMove.
++
++ The \a localPos is the mouse cursor's position relative to the
++ receiving widget or item. The cursor's position in screen coordinates is
++ specified by \a globalPos. The window position is set to the same value
++ as \a localPos. The \a button that caused the event is
++ given as a value from the \l Qt::MouseButton enum. If the event \a
++ type is \l MouseMove, the appropriate button for this event is
++ Qt::NoButton. \a buttons is the state of all buttons at the
++ time of the event, \a modifiers the state of all keyboard
++ modifiers.
++
++ */
++ QMouseEvent::QMouseEvent(Type type, const QPointF &localPos, const QPointF &globalPos,
++ Qt::MouseButton button, Qt::MouseButtons buttons,
++ Qt::KeyboardModifiers modifiers, const QPointingDevice *device)
++ : QMouseEvent(type, localPos, localPos, globalPos, button, buttons, modifiers, device)
++ {
++ }
++
++ /*!
++ Constructs a mouse event object.
++
++ The \a type parameter must be QEvent::MouseButtonPress,
++ QEvent::MouseButtonRelease, QEvent::MouseButtonDblClick,
++ or QEvent::MouseMove.
++
++ The points \a localPos, \a scenePos and \a globalPos specify the
++ mouse cursor's position relative to the receiving widget or item,
++ window, and screen or desktop, respectively.
++
++ The \a button that caused the event is given as a value from the
++ \l Qt::MouseButton enum. If the event \a type is \l MouseMove,
++ the appropriate button for this event is Qt::NoButton. \a buttons
++ is the state of all buttons at the time of the event, \a modifiers
++ is the state of all keyboard modifiers.
++ */
++ QMouseEvent::QMouseEvent(QEvent::Type type, const QPointF &localPos,
++ const QPointF &scenePos, const QPointF &globalPos,
++ Qt::MouseButton button, Qt::MouseButtons buttons,
++ Qt::KeyboardModifiers modifiers, const QPointingDevice *device)
++ : QSinglePointEvent(type, device, localPos, scenePos, globalPos, button, buttons, modifiers)
++ {
++ }
++
++ QMouseEvent::QMouseEvent(QEvent::Type type, const QPointF &localPos, const QPointF &windowPos,
++ const QPointF &globalPos, Qt::MouseButton button, Qt::MouseButtons buttons,
++ Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source,
++ const QPointingDevice *device)
++ : QSinglePointEvent(type, device, localPos, windowPos, globalPos, button, buttons, modifiers, source)
++ {
++ }
++
++ Q_IMPL_POINTER_EVENT(QMouseEvent)
++
++ /*!
++ \fn Qt::MouseEventSource QMouseEvent::source() const
++ \since 5.3
++ \deprecated [6.0] Use pointingDevice() instead.
++
++ Returns information about the mouse event source.
++
++ The mouse event source can be used to distinguish between genuine
++ and artificial mouse events. The latter are events that are
++ synthesized from touch events by the operating system or Qt itself.
++ This enum tells you from where it was synthesized; but often
++ it's more useful to know from which device it was synthesized,
++ so try to use pointingDevice() instead.
++
++ \note Many platforms provide no such information. On such platforms
++ \l Qt::MouseEventNotSynthesized is returned always.
++
++ \sa Qt::MouseEventSource
++ \sa QGraphicsSceneMouseEvent::source()
++
++ \note In Qt 5-based code, source() was often used to attempt to distinguish
++ mouse events from an actual mouse vs. those that were synthesized because
++ some legacy QQuickItem or QWidget subclass did not react to a QTouchEvent.
++ However, you could not tell whether it was synthesized from a QTouchEvent
++ or a QTabletEvent, and other information was lost. pointingDevice()
++ tells you the specific device that it came from, so you might check
++ \c {pointingDevice()->type()} or \c {pointingDevice()->capabilities()} to
++ decide how to react to this event. But it's even better to react to the
++ original event rather than handling only mouse events.
++ */
++ // Note: the docs mention 6.0 as a deprecation version. That is correct and
++ // intended, because we want our users to stop using it! Internally we will
++ // deprecate it when we port our code away from using it.
++ Qt::MouseEventSource QMouseEvent::source() const
++ {
++ return Qt::MouseEventSource(m_source);
++ }
++
++ /*!
++ \since 5.3
++
++ Returns the mouse event flags.
++
++ The mouse event flags provide additional information about a mouse event.
++
++ \sa Qt::MouseEventFlag
++ \sa QGraphicsSceneMouseEvent::flags()
++ */
++ Qt::MouseEventFlags QMouseEvent::flags() const
++ {
++ return (m_doubleClick ? Qt::MouseEventCreatedDoubleClick : Qt::NoMouseEventFlag);
++ }
++
++ /*!
++ \fn QPointF QMouseEvent::localPos() const
++ \deprecated [6.0] Use position() instead.
++
++ \since 5.0
++
++ Returns the position of the mouse cursor as a QPointF, relative to the
++ widget or item that received the event.
++
++ If you move the widget as a result of the mouse event, use the
++ screen position returned by screenPos() to avoid a shaking
++ motion.
++
++ \sa x(), y(), windowPos(), screenPos()
++ */
++
++ /*!
++ \fn void QMouseEvent::setLocalPos(const QPointF &localPosition)
++
++ \since 5.8
++
++ \internal
++
++ Sets the local position in the mouse event to \a localPosition. This allows to re-use one event
++ when sending it to a series of receivers that expect the local pos in their
++ respective local coordinates.
++ */
++
++ /*!
++ \fn QPointF QMouseEvent::windowPos() const
++ \deprecated [6.0] Use scenePosition() instead.
++
++ \since 5.0
++
++ Returns the position of the mouse cursor as a QPointF, relative to the
++ window that received the event.
++
++ If you move the widget as a result of the mouse event, use the
++ global position returned by globalPos() to avoid a shaking
++ motion.
++
++ \sa x(), y(), pos(), localPos(), screenPos()
++ */
++
++ /*!
++ \fn QPointF QMouseEvent::screenPos() const
++ \deprecated [6.0] Use globalPosition() instead.
++
++ \since 5.0
++
++ Returns the position of the mouse cursor as a QPointF, relative to the
++ screen that received the event.
++
++ \sa x(), y(), pos(), localPos(), windowPos()
++ */
++
++ /*!
++ \fn QPoint QMouseEvent::pos() const
++ \deprecated [6.0] Use position() instead.
++
++ Returns the position of the mouse cursor, relative to the widget
++ that received the event.
++
++ If you move the widget as a result of the mouse event, use the
++ global position returned by globalPos() to avoid a shaking
++ motion.
++
++ \sa x(), y(), globalPos()
++ */
++
++ /*!
++ \fn QPoint QMouseEvent::globalPos() const
++ \deprecated [6.0] Use globalPosition().toPoint() instead.
++
++ Returns the global position of the mouse cursor \e{at the time
++ of the event}. This is important on asynchronous window systems
++ like X11. Whenever you move your widgets around in response to
++ mouse events, globalPos() may differ a lot from the current
++ pointer position QCursor::pos(), and from
++ QWidget::mapToGlobal(pos()).
++
++ \sa globalX(), globalY()
++ */
++
++ /*!
++ \fn int QMouseEvent::x() const
++ \deprecated [6.0] Use position().x() instead.
++
++ Returns the x position of the mouse cursor, relative to the
++ widget that received the event.
++
++ \sa y(), pos()
++ */
++
++ /*!
++ \fn int QMouseEvent::y() const
++ \deprecated [6.0] Use position().y() instead.
++
++ Returns the y position of the mouse cursor, relative to the
++ widget that received the event.
++
++ \sa x(), pos()
++ */
++
++ /*!
++ \fn int QMouseEvent::globalX() const
++ \deprecated [6.0] Use globalPosition().x() instead.
++
++ Returns the global x position of the mouse cursor at the time of
++ the event.
++
++ \sa globalY(), globalPos()
++ */
++
++ /*!
++ \fn int QMouseEvent::globalY() const
++ \deprecated [6.0] Use globalPosition().y() instead.
++
++ Returns the global y position of the mouse cursor at the time of
++ the event.
++
++ \sa globalX(), globalPos()
++ */
++
++ /*!
++ \class QHoverEvent
++ \ingroup events
++ \inmodule QtGui
++
++ \brief The QHoverEvent class contains parameters that describe a mouse event.
++
++ Mouse events occur when a mouse cursor is moved into, out of, or within a
++ widget, and if the widget has the Qt::WA_Hover attribute.
++
++ The function position() gives the current cursor position, while oldPos() gives
++ the old mouse position.
++
++ There are a few similarities between the events QEvent::HoverEnter
++ and QEvent::HoverLeave, and the events QEvent::Enter and QEvent::Leave.
++ However, they are slightly different because we do an update() in the event
++ handler of HoverEnter and HoverLeave.
++
++ QEvent::HoverMove is also slightly different from QEvent::MouseMove. Let us
++ consider a top-level window A containing a child B which in turn contains a
++ child C (all with mouse tracking enabled):
++
++ \image hoverevents.png {Screenshot showing widgets A, B, C stacked on top
++ of each other}
++
++ Now, if you move the cursor from the top to the bottom in the middle of A,
++ you will get the following QEvent::MouseMove events:
++
++ \list 1
++ \li A::MouseMove
++ \li B::MouseMove
++ \li C::MouseMove
++ \endlist
++
++ You will get the same events for QEvent::HoverMove, except that the event
++ always propagates to the top-level regardless whether the event is accepted
++ or not. It will only stop propagating with the Qt::WA_NoMousePropagation
++ attribute.
++
++ In this case the events will occur in the following way:
++
++ \list 1
++ \li A::HoverMove
++ \li A::HoverMove, B::HoverMove
++ \li A::HoverMove, B::HoverMove, C::HoverMove
++ \endlist
++
++ */
++
++ /*!
++ \fn QPoint QHoverEvent::pos() const
++ \deprecated [6.0] Use position().toPoint() instead.
++
++ Returns the position of the mouse cursor, relative to the widget
++ that received the event.
++
++ On QEvent::HoverLeave events, this position will always be
++ QPoint(-1, -1).
++
++ \sa oldPos()
++ */
++
++ /*!
++ \fn QPoint QHoverEvent::oldPos() const
++
++ Returns the previous position of the mouse cursor, relative to the widget
++ that received the event. If there is no previous position, oldPos() will
++ return the same position as position().
++
++ On QEvent::HoverEnter events, this position will always be
++ QPoint(-1, -1).
++
++ \sa position()
++ */
++
++ /*!
++ \fn const QPointF &QHoverEvent::posF() const
++ \deprecated [6.0] Use position() instead.
++
++ Returns the position of the mouse cursor, relative to the widget
++ that received the event.
++
++ On QEvent::HoverLeave events, this position will always be
++ QPointF(-1, -1).
++
++ \sa oldPosF()
++ */
++
++ /*!
++ \fn const QPointF &QHoverEvent::oldPosF() const
++
++ Returns the previous position of the mouse cursor, relative to the widget
++ that received the event. If there is no previous position, oldPosF() will
++ return the same position as position().
++
++ On QEvent::HoverEnter events, this position will always be
++ QPointF(-1, -1).
++
++ \sa position()
++ */
++
++ /*!
++ Constructs a hover event object originating from \a device.
++
++ The \a type parameter must be QEvent::HoverEnter,
++ QEvent::HoverLeave, or QEvent::HoverMove.
++
++ The \a scenePos is the current mouse cursor's position relative to the
++ receiving window or scene, \a oldPos is its previous such position, and
++ \a globalPos is the mouse position in absolute coordinates.
++ \a modifiers hold the state of all keyboard modifiers at the time
++ of the event.
++ */
++ QHoverEvent::QHoverEvent(Type type, const QPointF &scenePos, const QPointF &globalPos, const QPointF &oldPos,
++ Qt::KeyboardModifiers modifiers, const QPointingDevice *device)
++ : QSinglePointEvent(type, device, scenePos, scenePos, globalPos, Qt::NoButton, Qt::NoButton, modifiers), m_oldPos(oldPos)
++ {
++ }
++
++ #if QT_DEPRECATED_SINCE(6, 3)
++ /*!
++ \deprecated [6.3] Use the other constructor instead (global position is required).
++
++ Constructs a hover event object originating from \a device.
++
++ The \a type parameter must be QEvent::HoverEnter,
++ QEvent::HoverLeave, or QEvent::HoverMove.
++
++ The \a pos is the current mouse cursor's position relative to the
++ receiving widget, while \a oldPos is its previous such position.
++ \a modifiers hold the state of all keyboard modifiers at the time
++ of the event.
++ */
++ QHoverEvent::QHoverEvent(Type type, const QPointF &pos, const QPointF &oldPos,
++ Qt::KeyboardModifiers modifiers, const QPointingDevice *device)
++ : QSinglePointEvent(type, device, pos, pos, pos, Qt::NoButton, Qt::NoButton, modifiers), m_oldPos(oldPos)
++ {
++ }
++ #endif
++
++ Q_IMPL_POINTER_EVENT(QHoverEvent)
++
++ #if QT_CONFIG(wheelevent)
++ /*!
++ \class QWheelEvent
++ \brief The QWheelEvent class contains parameters that describe a wheel event.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Wheel events are sent to the widget under the mouse cursor, but
++ if that widget does not handle the event they are sent to the
++ focus widget. Wheel events are generated for both mouse wheels
++ and trackpad scroll gestures. There are two ways to read the
++ wheel event delta: angleDelta() returns the deltas in wheel
++ degrees. These values are always provided. pixelDelta() returns
++ the deltas in screen pixels, and is available on platforms that
++ have high-resolution trackpads, such as \macos. If that is the
++ case, device()->type() will return QInputDevice::DeviceType::Touchpad.
++
++ The functions position() and globalPosition() return the mouse cursor's
++ location at the time of the event.
++
++ A wheel event contains a special accept flag that indicates
++ whether the receiver wants the event. You should call ignore() if
++ you do not handle the wheel event; this ensures that it will be
++ sent to the parent widget.
++
++ The QWidget::setEnabled() function can be used to enable or
++ disable mouse and keyboard events for a widget.
++
++ The event handler QWidget::wheelEvent() receives wheel events.
++
++ \sa QMouseEvent, QWidget::grabMouse()
++ */
++
++ /*!
++ \enum QWheelEvent::anonymous
++ \internal
++
++ \value DefaultDeltasPerStep Defaqult deltas per step
++ */
++
++ /*!
++ \fn Qt::MouseEventSource QWheelEvent::source() const
++ \since 5.5
++ \deprecated [6.0] Use pointingDevice() instead.
++
++ Returns information about the wheel event source.
++
++ The source can be used to distinguish between events that come from a mouse
++ with a physical wheel and events that are generated by some other means,
++ such as a flick gesture on a touchpad.
++ This enum tells you from where it was synthesized; but often
++ it's more useful to know from which device it was synthesized,
++ so try to use pointingDevice() instead.
++
++ \note Many platforms provide no such information. On such platforms
++ \l Qt::MouseEventNotSynthesized is returned always.
++
++ \sa Qt::MouseEventSource
++ */
++
++ /*!
++ \property QWheelEvent::device
++ \brief the device from which the wheel event originated
++
++ \sa pointingDevice()
++ */
++
++ /*!
++ \property QWheelEvent::inverted
++ \since 5.7
++ \brief whether the delta values delivered with the event are inverted
++
++ Normally, a vertical wheel will produce a QWheelEvent with positive delta
++ values if the top of the wheel is rotating away from the hand operating it.
++ Similarly, a horizontal wheel movement will produce a QWheelEvent with
++ positive delta values if the top of the wheel is moved to the left.
++
++ However, on some platforms this is configurable, so that the same
++ operations described above will produce negative delta values (but with the
++ same magnitude). With the inverted property a wheel event consumer can
++ choose to always follow the direction of the wheel, regardless of the
++ system settings, but only for specific widgets.
++
++ \note Many platforms provide no such information. On such platforms
++ \l inverted always returns false.
++ */
++
++ /*!
++ \fn bool QWheelEvent::inverted() const
++ \since 5.7
++
++ Returns whether the delta values delivered with the event are inverted.
++
++ Normally, a vertical wheel will produce a QWheelEvent with positive delta
++ values if the top of the wheel is rotating away from the hand operating it.
++ Similarly, a horizontal wheel movement will produce a QWheelEvent with
++ positive delta values if the top of the wheel is moved to the left.
++
++ However, on some platforms this is configurable, so that the same
++ operations described above will produce negative delta values (but with the
++ same magnitude). With the inverted property a wheel event consumer can
++ choose to always follow the direction of the wheel, regardless of the
++ system settings, but only for specific widgets. (One such use case could be
++ that the user is rotating the wheel in the same direction as a visual
++ Tumbler rotates. Another usecase is to make a slider handle follow the
++ direction of movement of fingers on a touchpad regardless of system
++ configuration.)
++
++ \note Many platforms provide no such information. On such platforms
++ \l inverted always returns false.
++ */
++
++ /*!
++ Constructs a wheel event object.
++
++ \since 5.12
++ The \a pos provides the location of the mouse cursor
++ within the window. The position in global coordinates is specified
++ by \a globalPos.
++
++ \a pixelDelta contains the scrolling distance in pixels on screen, while
++ \a angleDelta contains the wheel rotation angle. \a pixelDelta is
++ optional and can be null.
++
++ The mouse and keyboard states at the time of the event are specified by
++ \a buttons and \a modifiers.
++
++ The scrolling phase of the event is specified by \a phase, and the
++ \a source indicates whether this is a genuine or artificial (synthesized)
++ event.
++
++ If the system is configured to invert the delta values delivered with the
++ event (such as natural scrolling of the touchpad on macOS), \a inverted
++ should be \c true. Otherwise, \a inverted is \c false
++
++ The device from which the wheel event originated is specified by \a device.
++
++ \sa position(), globalPosition(), angleDelta(), pixelDelta(), phase(), inverted(), device()
++ */
++ QWheelEvent::QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta,
++ Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase,
++ bool inverted, Qt::MouseEventSource source, const QPointingDevice *device)
++ : QSinglePointEvent(Wheel, device, pos, pos, globalPos, Qt::NoButton, buttons, modifiers, source),
++ m_pixelDelta(pixelDelta), m_angleDelta(angleDelta)
++ {
++ m_phase = phase;
++ m_invertedScrolling = inverted;
++ }
++
++ Q_IMPL_POINTER_EVENT(QWheelEvent)
++
++ /*!
++ Returns \c true if this event's phase() is Qt::ScrollBegin.
++ */
++ bool QWheelEvent::isBeginEvent() const
++ {
++ return m_phase == Qt::ScrollBegin;
++ }
++
++ /*!
++ Returns \c true if this event's phase() is Qt::ScrollUpdate or Qt::ScrollMomentum.
++ */
++ bool QWheelEvent::isUpdateEvent() const
++ {
++ return m_phase == Qt::ScrollUpdate || m_phase == Qt::ScrollMomentum;
++ }
++
++ /*!
++ Returns \c true if this event's phase() is Qt::ScrollEnd.
++ */
++ bool QWheelEvent::isEndEvent() const
++ {
++ return m_phase == Qt::ScrollEnd;
++ }
++
++ #endif // QT_CONFIG(wheelevent)
++
++ /*!
++ \property QWheelEvent::pixelDelta
++ \brief the scrolling distance in pixels on screen
++
++ This value is provided on platforms that support high-resolution
++ pixel-based delta values, such as \macos. The value should be used
++ directly to scroll content on screen.
++
++ \note On platforms that support scrolling \l{phase()}{phases}, the delta
++ may be null when scrolling is about to begin (Qt::ScrollBegin) or has
++ ended (Qt::ScrollEnd).
++
++ \note On X11 this value is driver-specific and unreliable, use
++ angleDelta() instead.
++
++ \sa angleDelta()
++ */
++
++ /*!
++ \fn QPoint QWheelEvent::pixelDelta() const
++
++ Returns the scrolling distance in pixels on screen. This value is
++ provided on platforms that support high-resolution pixel-based
++ delta values, such as \macos. The value should be used directly
++ to scroll content on screen.
++
++ Example:
++
++ \snippet code/src_gui_kernel_qevent.cpp 0
++
++ \note On platforms that support scrolling \l{phase()}{phases}, the delta may be null when:
++ \list
++ \li scrolling is about to begin, but the distance did not yet change (Qt::ScrollBegin),
++ \li or scrolling has ended and the distance did not change anymore (Qt::ScrollEnd).
++ \endlist
++ \note On X11 this value is driver-specific and unreliable, use angleDelta() instead.
++ */
++
++ /*!
++ \property QWheelEvent::angleDelta
++ \brief the relative amount that the wheel was rotated, in eighths of a degree
++
++ A positive value indicates that the wheel was rotated forwards away from the
++ user; a negative value indicates that the wheel was rotated backwards toward
++ the user. \c angleDelta().y() provides the angle through which the common
++ vertical mouse wheel was rotated since the previous event. \c angleDelta().x()
++ provides the angle through which the horizontal mouse wheel was rotated, if
++ the mouse has a horizontal wheel; otherwise it stays at zero.
++
++ Most mouse types work in steps of 15 degrees, in which case the delta value
++ is a multiple of 120; i.e., 120 units * 1/8 = 15 degrees.
++
++ \note On platforms that support scrolling \l{phase()}{phases}, the delta
++ may be null when scrolling is about to begin (Qt::ScrollBegin) or has
++ ended (Qt::ScrollEnd).
++
++ \sa pixelDelta()
++ */
++
++ /*!
++ \fn QPoint QWheelEvent::angleDelta() const
++
++ Returns the relative amount that the wheel was rotated, in eighths of a
++ degree. A positive value indicates that the wheel was rotated forwards away
++ from the user; a negative value indicates that the wheel was rotated
++ backwards toward the user. \c angleDelta().y() provides the angle through
++ which the common vertical mouse wheel was rotated since the previous event.
++ \c angleDelta().x() provides the angle through which the horizontal mouse
++ wheel was rotated, if the mouse has a horizontal wheel; otherwise it stays
++ at zero. Some mice allow the user to tilt the wheel to perform horizontal
++ scrolling, and some touchpads support a horizontal scrolling gesture; that
++ will also appear in \c angleDelta().x().
++
++ Most mouse types work in steps of 15 degrees, in which case the
++ delta value is a multiple of 120; i.e., 120 units * 1/8 = 15 degrees.
++
++ However, some mice have finer-resolution wheels and send delta values
++ that are less than 120 units (less than 15 degrees). To support this
++ possibility, you can either cumulatively add the delta values from events
++ until the value of 120 is reached, then scroll the widget, or you can
++ partially scroll the widget in response to each wheel event. But to
++ provide a more native feel, you should prefer \l pixelDelta() on platforms
++ where it's available.
++
++ Example:
++
++ \snippet code/src_gui_kernel_qevent.cpp 0
++
++ \note On platforms that support scrolling \l{phase()}{phases}, the delta may be null when:
++ \list
++ \li scrolling is about to begin, but the distance did not yet change (Qt::ScrollBegin),
++ \li or scrolling has ended and the distance did not change anymore (Qt::ScrollEnd).
++ \endlist
++
++ \sa pixelDelta()
++ */
++
++ /*!
++ \property QWheelEvent::phase
++ \since 5.2
++ \brief the scrolling phase of this wheel event
++
++ \note The Qt::ScrollBegin and Qt::ScrollEnd phases are currently
++ supported only on \macos.
++ */
++
++ /*!
++ \fn Qt::ScrollPhase QWheelEvent::phase() const
++ \since 5.2
++
++ Returns the scrolling phase of this wheel event.
++
++ \note The Qt::ScrollBegin and Qt::ScrollEnd phases are currently
++ supported only on \macos.
++ */
++
++
++ /*!
++ \class QKeyEvent
++ \brief The QKeyEvent class describes a key event.
++
++ \ingroup events
++ \inmodule QtGui
++
++ Key events are sent to the widget with keyboard input focus
++ when keys are pressed or released.
++
++ A key event contains a special accept flag that indicates whether
++ the receiver will handle the key event. This flag is set by default
++ for QEvent::KeyPress and QEvent::KeyRelease, so there is no need to
++ call accept() when acting on a key event. For QEvent::ShortcutOverride
++ the receiver needs to explicitly accept the event to trigger the override.
++ Calling ignore() on a key event will propagate it to the parent widget.
++ The event is propagated up the parent widget chain until a widget
++ accepts it or an event filter consumes it.
++
++ The QWidget::setEnabled() function can be used to enable or disable
++ mouse and keyboard events for a widget.
++
++ The event handlers QWidget::keyPressEvent(), QWidget::keyReleaseEvent(),
++ QGraphicsItem::keyPressEvent() and QGraphicsItem::keyReleaseEvent()
++ receive key events.
++
++ \sa QFocusEvent, QWidget::grabKeyboard()
++ */
++
++ /*!
++ Constructs a key event object.
++
++ The \a type parameter must be QEvent::KeyPress, QEvent::KeyRelease,
++ or QEvent::ShortcutOverride.
++
++ Int \a key is the code for the Qt::Key that the event loop should listen
++ for. If \a key is 0, the event is not a result of a known key; for
++ example, it may be the result of a compose sequence or keyboard macro.
++ The \a modifiers holds the keyboard modifiers, and the given \a text
++ is the Unicode text that the key generated. If \a autorep is true,
++ isAutoRepeat() will be true. \a count is the number of keys involved
++ in the event.
++ */
++ QKeyEvent::QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text,
++ bool autorep, quint16 count)
++ : QInputEvent(type, QInputDevice::primaryKeyboard(), modifiers), m_text(text), m_key(key),
++ m_scanCode(0), m_virtualKey(0), m_nativeModifiers(0),
++ m_count(count), m_autoRepeat(autorep)
++ {
++ if (type == QEvent::ShortcutOverride)
++ ignore();
++ }
++
++ /*!
++ Constructs a key event object.
++
++ The \a type parameter must be QEvent::KeyPress, QEvent::KeyRelease,
++ or QEvent::ShortcutOverride.
++
++ Int \a key is the code for the Qt::Key that the event loop should listen
++ for. If \a key is 0, the event is not a result of a known key; for
++ example, it may be the result of a compose sequence or keyboard macro.
++ The \a modifiers holds the keyboard modifiers, and the given \a text
++ is the Unicode text that the key generated. If \a autorep is true,
++ isAutoRepeat() will be true. \a count is the number of keys involved
++ in the event.
++
++ In addition to the normal key event data, also contains \a nativeScanCode,
++ \a nativeVirtualKey and \a nativeModifiers. This extra data is used by the
++ shortcut system, to determine which shortcuts to trigger.
++ */
++ QKeyEvent::QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers,
++ quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers,
++ const QString &text, bool autorep, quint16 count, const QInputDevice *device)
++ : QInputEvent(type, device, modifiers), m_text(text), m_key(key),
++ m_scanCode(nativeScanCode), m_virtualKey(nativeVirtualKey), m_nativeModifiers(nativeModifiers),
++ m_count(count), m_autoRepeat(autorep)
++ {
++ if (type == QEvent::ShortcutOverride)
++ ignore();
++ }
++
++
++ Q_IMPL_EVENT_COMMON(QKeyEvent)
++
++ /*!
++ \fn quint32 QKeyEvent::nativeScanCode() const
++ \since 4.2
++
++ Returns the native scan code of the key event. If the key event
++ does not contain this data 0 is returned.
++
++ \note The native scan code may be 0, even if the key event contains
++ extended information.
++ */
++
++ /*!
++ \fn quint32 QKeyEvent::nativeVirtualKey() const
++ \since 4.2
++
++ Returns the native virtual key, or key sym of the key event.
++ If the key event does not contain this data 0 is returned.
++
++ \note The native virtual key may be 0, even if the key event contains extended information.
++ */
++
++ /*!
++ \fn quint32 QKeyEvent::nativeModifiers() const
++ \since 4.2
++
++ Returns the native modifiers of a key event.
++ If the key event does not contain this data 0 is returned.
++
++ \note The native modifiers may be 0, even if the key event contains extended information.
++ */
++
++ /*!
++ \fn int QKeyEvent::key() const
++
++ Returns the code of the key that was pressed or released.
++
++ See \l Qt::Key for the list of keyboard codes. These codes are
++ independent of the underlying window system. Note that this
++ function does not distinguish between capital and non-capital
++ letters, use the text() function (returning the Unicode text the
++ key generated) for this purpose.
++
++ A value of either 0 or Qt::Key_unknown means that the event is not
++ the result of a known key; for example, it may be the result of
++ a compose sequence, a keyboard macro, or due to key event
++ compression.
++
++ \sa Qt::WA_KeyCompression
++ */
++
++ /*!
++ \fn QString QKeyEvent::text() const
++
++ Returns the Unicode text that this key generated.
++
++ The text is not limited to the printable range of Unicode
++ code points, and may include control characters or characters
++ from other Unicode categories, including QChar::Other_PrivateUse.
++
++ The text may also be empty, for example when modifier keys such as
++ Shift, Control, Alt, and Meta are pressed (depending on the platform).
++ The key() function will always return a valid value.
++
++ \sa Qt::WA_KeyCompression
++ */
++
++ /*!
++ Returns the keyboard modifier flags that existed immediately
++ after the event occurred.
++
++ \warning This function cannot always be trusted. The user can
++ confuse it by pressing both \uicontrol{Shift} keys simultaneously and
++ releasing one of them, for example.
++
++ \sa QGuiApplication::keyboardModifiers()
++ */
++
++ Qt::KeyboardModifiers QKeyEvent::modifiers() const
++ {
++ if (key() == Qt::Key_Shift)
++ return Qt::KeyboardModifiers(QInputEvent::modifiers()^Qt::ShiftModifier);
++ if (key() == Qt::Key_Control)
++ return Qt::KeyboardModifiers(QInputEvent::modifiers()^Qt::ControlModifier);
++ if (key() == Qt::Key_Alt)
++ return Qt::KeyboardModifiers(QInputEvent::modifiers()^Qt::AltModifier);
++ if (key() == Qt::Key_Meta)
++ return Qt::KeyboardModifiers(QInputEvent::modifiers()^Qt::MetaModifier);
++ if (key() == Qt::Key_AltGr)
++ return Qt::KeyboardModifiers(QInputEvent::modifiers()^Qt::GroupSwitchModifier);
++ return QInputEvent::modifiers();
++ }
++
++ /*!
++ \fn QKeyCombination QKeyEvent::keyCombination() const
++
++ Returns a QKeyCombination object containing both the key() and
++ the modifiers() carried by this event.
++
++ \since 6.0
++ */
++
++ #if QT_CONFIG(shortcut)
++ /*!
++ \fn bool QKeyEvent::matches(QKeySequence::StandardKey key) const
++ \since 4.2
++
++ Returns \c true if the key event matches the given standard \a key;
++ otherwise returns \c false.
++ */
++ bool QKeyEvent::matches(QKeySequence::StandardKey matchKey) const
++ {
++ //The keypad and group switch modifier should not make a difference
++ uint searchkey = (modifiers() | key()) & ~(Qt::KeypadModifier | Qt::GroupSwitchModifier);
++
++ const QList<QKeySequence> bindings = QKeySequence::keyBindings(matchKey);
++ return bindings.contains(QKeySequence(searchkey));
++ }
++ #endif // QT_CONFIG(shortcut)
++
++
++ /*!
++ \fn bool QKeyEvent::isAutoRepeat() const
++
++ Returns \c true if this event comes from an auto-repeating key;
++ returns \c false if it comes from an initial key press.
++
++ Note that if the event is a multiple-key compressed event that is
++ partly due to auto-repeat, this function could return either true
++ or false indeterminately.
++ */
++
++ /*!
++ \fn int QKeyEvent::count() const
++
++ Returns the number of keys involved in this event. If text()
++ is not empty, this is simply the length of the string.
++
++ \sa Qt::WA_KeyCompression
++ */
++
++ /*!
++ \class QFocusEvent
++ \brief The QFocusEvent class contains event parameters for widget focus
++ events.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Focus events are sent to widgets when the keyboard input focus
++ changes. Focus events occur due to mouse actions, key presses
++ (such as \uicontrol{Tab} or \uicontrol{Backtab}), the window system, popup
++ menus, keyboard shortcuts, or other application-specific reasons.
++ The reason for a particular focus event is returned by reason()
++ in the appropriate event handler.
++
++ The event handlers QWidget::focusInEvent(),
++ QWidget::focusOutEvent(), QGraphicsItem::focusInEvent and
++ QGraphicsItem::focusOutEvent() receive focus events.
++
++ \sa QWidget::setFocus(), QWidget::setFocusPolicy(), {Keyboard Focus in Widgets}
++ */
++
++ /*!
++ Constructs a focus event object.
++
++ The \a type parameter must be either QEvent::FocusIn or
++ QEvent::FocusOut. The \a reason describes the cause of the change
++ in focus.
++ */
++ QFocusEvent::QFocusEvent(Type type, Qt::FocusReason reason)
++ : QEvent(type), m_reason(reason)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QFocusEvent)
++
++ /*!
++ Returns the reason for this focus event.
++ */
++ Qt::FocusReason QFocusEvent::reason() const
++ {
++ return m_reason;
++ }
++
++ /*!
++ \fn bool QFocusEvent::gotFocus() const
++
++ Returns \c true if type() is QEvent::FocusIn; otherwise returns
++ false.
++ */
++
++ /*!
++ \fn bool QFocusEvent::lostFocus() const
++
++ Returns \c true if type() is QEvent::FocusOut; otherwise returns
++ false.
++ */
++
++
++ /*!
++ \class QPaintEvent
++ \brief The QPaintEvent class contains event parameters for paint events.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Paint events are sent to widgets that need to update themselves,
++ for instance when part of a widget is exposed because a covering
++ widget was moved.
++
++ The event contains a region() that needs to be updated, and a
++ rect() that is the bounding rectangle of that region. Both are
++ provided because many widgets cannot make much use of region(),
++ and rect() can be much faster than region().boundingRect().
++
++ \section1 Automatic Clipping
++
++ Painting is clipped to region() during the processing of a paint
++ event. This clipping is performed by Qt's paint system and is
++ independent of any clipping that may be applied to a QPainter used to
++ draw on the paint device.
++
++ As a result, the value returned by QPainter::clipRegion() on
++ a newly-constructed QPainter will not reflect the clip region that is
++ used by the paint system.
++
++ \sa QPainter, QWidget::update(), QWidget::repaint(),
++ QWidget::paintEvent()
++ */
++
++ /*!
++ Constructs a paint event object with the region that needs to
++ be updated. The region is specified by \a paintRegion.
++ */
++ QPaintEvent::QPaintEvent(const QRegion& paintRegion)
++ : QEvent(Paint), m_rect(paintRegion.boundingRect()), m_region(paintRegion), m_erased(false)
++ {}
++
++ /*!
++ Constructs a paint event object with the rectangle that needs
++ to be updated. The region is specified by \a paintRect.
++ */
++ QPaintEvent::QPaintEvent(const QRect &paintRect)
++ : QEvent(Paint), m_rect(paintRect),m_region(paintRect), m_erased(false)
++ {}
++
++
++ Q_IMPL_EVENT_COMMON(QPaintEvent)
++
++ /*!
++ \fn const QRect &QPaintEvent::rect() const
++
++ Returns the rectangle that needs to be updated.
++
++ \sa region(), QPainter::setClipRect()
++ */
++
++ /*!
++ \fn const QRegion &QPaintEvent::region() const
++
++ Returns the region that needs to be updated.
++
++ \sa rect(), QPainter::setClipRegion()
++ */
++
++
++ /*!
++ \class QMoveEvent
++ \brief The QMoveEvent class contains event parameters for move events.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Move events are sent to widgets that have been moved to a new
++ position relative to their parent.
++
++ The event handler QWidget::moveEvent() receives move events.
++
++ \sa QWidget::move(), QWidget::setGeometry()
++ */
++
++ /*!
++ Constructs a move event with the new and old widget positions,
++ \a pos and \a oldPos respectively.
++ */
++ QMoveEvent::QMoveEvent(const QPoint &pos, const QPoint &oldPos)
++ : QEvent(Move), m_pos(pos), m_oldPos(oldPos)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QMoveEvent)
++
++ /*!
++ \fn const QPoint &QMoveEvent::pos() const
++
++ Returns the new position of the widget. This excludes the window
++ frame for top level widgets.
++ */
++
++ /*!
++ \fn const QPoint &QMoveEvent::oldPos() const
++
++ Returns the old position of the widget.
++ */
++
++ /*!
++ \class QExposeEvent
++ \since 5.0
++ \brief The QExposeEvent class contains event parameters for expose events.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Expose events are sent to windows when they move between the un-exposed and
++ exposed states.
++
++ An exposed window is potentially visible to the user. If the window is moved
++ off screen, is made totally obscured by another window, is minimized, or
++ similar, an expose event is sent to the window, and isExposed() might
++ change to false.
++
++ Expose events should not be used to paint. Handle QPaintEvent
++ instead.
++
++ The event handler QWindow::exposeEvent() receives expose events.
++ */
++
++ /*!
++ Constructs an expose event for the given \a exposeRegion which must be
++ in local coordinates.
++ */
++ QExposeEvent::QExposeEvent(const QRegion &exposeRegion)
++ : QEvent(Expose)
++ , m_region(exposeRegion)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QExposeEvent)
++
++ /*!
++ \class QPlatformSurfaceEvent
++ \since 5.5
++ \brief The QPlatformSurfaceEvent class is used to notify about native platform surface events.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Platform window events are synchronously sent to windows and offscreen surfaces when their
++ underlying native surfaces are created or are about to be destroyed.
++
++ Applications can respond to these events to know when the underlying platform
++ surface exists.
++ */
++
++ /*!
++ \enum QPlatformSurfaceEvent::SurfaceEventType
++
++ This enum describes the type of platform surface event. The possible types are:
++
++ \value SurfaceCreated The underlying native surface has been created
++ \value SurfaceAboutToBeDestroyed The underlying native surface will be destroyed immediately after this event
++
++ The \c SurfaceAboutToBeDestroyed event type is useful as a means of stopping rendering to
++ a platform window before it is destroyed.
++ */
++
++ /*!
++ \fn QPlatformSurfaceEvent::SurfaceEventType QPlatformSurfaceEvent::surfaceEventType() const
++
++ Returns the specific type of platform surface event.
++ */
++
++ /*!
++ Constructs a platform surface event for the given \a surfaceEventType.
++ */
++ QPlatformSurfaceEvent::QPlatformSurfaceEvent(SurfaceEventType surfaceEventType)
++ : QEvent(PlatformSurface)
++ , m_surfaceEventType(surfaceEventType)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QPlatformSurfaceEvent)
++
++ /*!
++ \fn const QRegion &QExposeEvent::region() const
++ \deprecated [6.0] Use QPaintEvent instead.
++
++ Returns the window area that has been exposed. The region is given in local coordinates.
++ */
++
++ /*!
++ \class QResizeEvent
++ \brief The QResizeEvent class contains event parameters for resize events.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Resize events are sent to widgets that have been resized.
++
++ The event handler QWidget::resizeEvent() receives resize events.
++
++ \sa QWidget::resize(), QWidget::setGeometry()
++ */
++
++ /*!
++ Constructs a resize event with the new and old widget sizes, \a
++ size and \a oldSize respectively.
++ */
++ QResizeEvent::QResizeEvent(const QSize &size, const QSize &oldSize)
++ : QEvent(Resize), m_size(size), m_oldSize(oldSize)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QResizeEvent)
++
++ /*!
++ \fn const QSize &QResizeEvent::size() const
++
++ Returns the new size of the widget. This is the same as
++ QWidget::size().
++ */
++
++ /*!
++ \fn const QSize &QResizeEvent::oldSize() const
++
++ Returns the old size of the widget.
++ */
++
++
++ /*!
++ \class QCloseEvent
++ \brief The QCloseEvent class contains parameters that describe a close event.
++
++ \ingroup events
++ \inmodule QtGui
++
++ Close events are sent to widgets that the user wants to close,
++ usually by choosing "Close" from the window menu, or by clicking
++ the \uicontrol{X} title bar button. They are also sent when you call
++ QWidget::close() to close a widget programmatically.
++
++ Close events contain a flag that indicates whether the receiver
++ wants the widget to be closed or not. When a widget accepts the
++ close event, it is hidden (and destroyed if it was created with
++ the Qt::WA_DeleteOnClose flag). If it refuses to accept the close
++ event nothing happens. (Under X11 it is possible that the window
++ manager will forcibly close the window; but at the time of writing
++ we are not aware of any window manager that does this.)
++
++ The event handler QWidget::closeEvent() receives close events. The
++ default implementation of this event handler accepts the close
++ event. If you do not want your widget to be hidden, or want some
++ special handling, you should reimplement the event handler and
++ ignore() the event.
++
++ If you want the widget to be deleted when it is closed, create it
++ with the Qt::WA_DeleteOnClose flag. This is very useful for
++ independent top-level windows in a multi-window application.
++
++ \l{QObject}s emits the \l{QObject::destroyed()}{destroyed()}
++ signal when they are deleted.
++
++ If the last top-level window is closed, the
++ QGuiApplication::lastWindowClosed() signal is emitted.
++
++ The isAccepted() function returns \c true if the event's receiver has
++ agreed to close the widget; call accept() to agree to close the
++ widget and call ignore() if the receiver of this event does not
++ want the widget to be closed.
++
++ \sa QWidget::close(), QWidget::hide(), QObject::destroyed(),
++ QCoreApplication::exec(), QCoreApplication::quit(),
++ QGuiApplication::lastWindowClosed()
++ */
++
++ /*!
++ Constructs a close event object.
++
++ \sa accept()
++ */
++ QCloseEvent::QCloseEvent()
++ : QEvent(Close)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QCloseEvent)
++
++ /*!
++ \class QIconDragEvent
++ \brief The QIconDragEvent class indicates that a main icon drag has begun.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Icon drag events are sent to widgets when the main icon of a window
++ has been dragged away. On \macos, this happens when the proxy
++ icon of a window is dragged off the title bar.
++
++ It is normal to begin using drag and drop in response to this
++ event.
++
++ \sa {Drag and Drop}, QMimeData, QDrag
++ */
++
++ /*!
++ Constructs an icon drag event object with the accept flag set to
++ false.
++
++ \sa accept()
++ */
++ QIconDragEvent::QIconDragEvent()
++ : QEvent(IconDrag)
++ { ignore(); }
++
++ Q_IMPL_EVENT_COMMON(QIconDragEvent)
++
++ /*!
++ \class QContextMenuEvent
++ \brief The QContextMenuEvent class contains parameters that describe a context menu event.
++ \inmodule QtGui
++
++ \ingroup events
++
++ A context menu event is sent when a user performs an action that should
++ open a contextual menu:
++ \list
++ \li clicking the right mouse button
++ \li pressing a dedicated keyboard menu key (if the keyboard has one,
++ such as the menu key on standard 104-key PC keyboards)
++ \li pressing some other keyboard shortcut (such as "Ctrl+Return" by
++ default on macOS 15 and newer)
++ \endlist
++
++ The expected context menu should contain \l {QAction}{actions} that are
++ relevant to some content within the application (the "context"). In Qt, the
++ context is at least the particular \l {QWidget}{widget} or Qt Quick \l Item
++ that receives the QContextMenuEvent. If there is a selection, that should
++ probably be treated as the context. The context can be further refined
++ using \l QContextMenuEvent::pos() to pinpoint the content within the
++ widget, item or selection.
++
++ Widgets can override \l QWidget::contextMenuEvent() to handle this event.
++ Many widgets already do that, and have useful context menus by default.
++ Some widgets have a function such as
++ \l {QLineEdit::createStandardContextMenu()}{createStandardContextMenu()}
++ to populate the default set of actions into a \l QMenu, which can be
++ customized further in your subclass and then shown.
++
++ In Qt Quick, the event can be handled via the
++ \l {QtQuick.Controls::}{ContextMenu} attached property. Some
++ \l {QtQuick.Controls} Controls already provide context menus by default.
++
++ Unlike most synthetic events (such as a QMouseEvent that is sent only after
++ a QTouchEvent or QTabletEvent was not accepted), QContextMenuEvent is sent
++ regardless of whether the original mouse or key event was already handled
++ and \l {QEvent::isAccepted()}{accepted}. This is to accommodate the Windows
++ UI pattern of selecting some kind of items (icons, drawing elements, or
++ cells in an Item View) using the right mouse button (clicking or dragging),
++ and then getting a context menu as soon as you release the right mouse
++ button. (The actions on the menu are meant to apply to the selection.)
++ Therefore, on Windows the QContextMenuEvent is sent on mouse release; while
++ on other platforms, it's sent on press. Qt follows the
++ \l {QStyleHints::contextMenuTrigger()}{platform convention} by default.
++
++ There are also some Qt Quick Controls such as \l {QtQuick.Controls::}{Pane}
++ that accept mouse events, and nevertheless receive a QContextMenuEvent
++ after a mouse press or click.
++
++ If you prefer to support the press-drag-release UI pattern to open a
++ context menu on press, and drag over a menu item to select it on release,
++ you will need to do that by handling \l {QMouseEvent}{QMouseEvents} directly
++ (by overriding \l {QWidget::mousePressEvent()}{virtual functions} in
++ QWidget subclasses, or using \l TapHandler to open a \l Menu in Qt Quick);
++ and then the QContextMenuEvent will be redundant when the \l reason() is
++ \c Mouse. You should \l ignore() the event in that case; but you should
++ still ensure that the widget, custom control or application can respond to
++ a QContextMenuEvent that \l {reason()}{comes from} the platform-specific
++ keyboard shortcut.
++
++ When a QContextMenuEvent is \l {ignore()}{ignored}, Qt attempts to deliver
++ it to other widgets and/or Items under the \l {pos()}{position} (which
++ is usually translated from the cursor position).
++ */
++
++ #ifndef QT_NO_CONTEXTMENU
++ /*!
++ Constructs a context menu event object with the accept parameter
++ flag set to false.
++
++ The \a reason parameter must be QContextMenuEvent::Mouse or
++ QContextMenuEvent::Keyboard.
++
++ The \a pos parameter specifies the mouse position relative to the
++ receiving widget. \a globalPos is the mouse position in absolute
++ coordinates. The \a modifiers holds the keyboard modifiers.
++ */
++ QContextMenuEvent::QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos,
++ Qt::KeyboardModifiers modifiers)
++ : QInputEvent(ContextMenu, QPointingDevice::primaryPointingDevice(), modifiers), m_pos(pos), m_globalPos(globalPos), m_reason(reason)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QContextMenuEvent)
++
++ #if QT_DEPRECATED_SINCE(6, 4)
++ /*!
++ \deprecated [6.4] Use the other constructor instead (global position is required).
++
++ Constructs a context menu event object with the accept parameter
++ flag set to false.
++
++ The \a reason parameter must be QContextMenuEvent::Mouse or
++ QContextMenuEvent::Keyboard.
++
++ The \a pos parameter specifies the mouse position relative to the
++ receiving widget.
++
++ The globalPos() is initialized to QCursor::pos(), which may not be
++ appropriate. Use the other constructor to specify the global
++ position explicitly.
++ */
++ QContextMenuEvent::QContextMenuEvent(Reason reason, const QPoint &pos)
++ : QInputEvent(ContextMenu, QInputDevice::primaryKeyboard()), m_pos(pos), m_reason(reason)
++ {
++ #ifndef QT_NO_CURSOR
++ m_globalPos = QCursor::pos();
++ #endif
++ }
++ #endif
++
++ /*!
++ \fn const QPoint &QContextMenuEvent::pos() const
++
++ Returns the position of the mouse pointer relative to the widget
++ that received the event.
++
++ \note If the QContextMenuEvent did not come from the right mouse button,
++ \c pos() may be \l {QPoint::isNull()}{null}.
++
++ \sa x(), y(), globalPos()
++ */
++
++ /*!
++ \fn int QContextMenuEvent::x() const
++
++ Returns the x position of the mouse pointer, relative to the
++ widget that received the event.
++
++ \sa y(), pos()
++ */
++
++ /*!
++ \fn int QContextMenuEvent::y() const
++
++ Returns the y position of the mouse pointer, relative to the
++ widget that received the event.
++
++ \sa x(), pos()
++ */
++
++ /*!
++ \fn const QPoint &QContextMenuEvent::globalPos() const
++
++ Returns the global position of the mouse pointer at the time of
++ the event.
++
++ \sa x(), y(), pos()
++ */
++
++ /*!
++ \fn int QContextMenuEvent::globalX() const
++
++ Returns the global x position of the mouse pointer at the time of
++ the event.
++
++ \sa globalY(), globalPos()
++ */
++
++ /*!
++ \fn int QContextMenuEvent::globalY() const
++
++ Returns the global y position of the mouse pointer at the time of
++ the event.
++
++ \sa globalX(), globalPos()
++ */
++ #endif // QT_NO_CONTEXTMENU
++
++ /*!
++ \enum QContextMenuEvent::Reason
++
++ This enum describes the reason why the event was sent.
++
++ \value Mouse The mouse caused the event to be sent. Normally this
++ means the right mouse button was clicked, but this is platform
++ dependent.
++
++ \value Keyboard The keyboard caused this event to be sent. On
++ Windows, this means the menu button was pressed.
++
++ \value Other The event was sent by some other means (i.e. not by
++ the mouse or keyboard).
++ */
++
++
++ /*!
++ \fn QContextMenuEvent::Reason QContextMenuEvent::reason() const
++
++ Returns the reason for this context event.
++ */
++
++
++ /*!
++ \class QInputMethodEvent
++ \brief The QInputMethodEvent class provides parameters for input method events.
++ \inmodule QtGui
++
++ \ingroup events
++
++ Input method events are sent to widgets when an input method is
++ used to enter text into a widget. Input methods are widely used
++ to enter text for languages with non-Latin alphabets.
++
++ Note that when creating custom text editing widgets, the
++ Qt::WA_InputMethodEnabled window attribute must be set explicitly
++ (using the QWidget::setAttribute() function) in order to receive
++ input method events.
++
++ The events are of interest to authors of keyboard entry widgets
++ who want to be able to correctly handle languages with complex
++ character input. Text input in such languages is usually a three
++ step process:
++
++ \list 1
++ \li \b{Starting to Compose}
++
++ When the user presses the first key on a keyboard, an input
++ context is created. This input context will contain a string
++ of the typed characters.
++
++ \li \b{Composing}
++
++ With every new key pressed, the input method will try to create a
++ matching string for the text typed so far called preedit
++ string. While the input context is active, the user can only move
++ the cursor inside the string belonging to this input context.
++
++ \li \b{Completing}
++
++ At some point, the user will activate a user interface component
++ (perhaps using a particular key) where they can choose from a
++ number of strings matching the text they have typed so far. The
++ user can either confirm their choice cancel the input; in either
++ case the input context will be closed.
++ \endlist
++
++ QInputMethodEvent models these three stages, and transfers the
++ information needed to correctly render the intermediate result. A
++ QInputMethodEvent has two main parameters: preeditString() and
++ commitString(). The preeditString() parameter gives the currently
++ active preedit string. The commitString() parameter gives a text
++ that should get added to (or replace parts of) the text of the
++ editor widget. It usually is a result of the input operations and
++ has to be inserted to the widgets text directly before the preedit
++ string.
++
++ If the commitString() should replace parts of the text in
++ the editor, replacementLength() will contain the number of
++ characters to be replaced. replacementStart() contains the position
++ at which characters are to be replaced relative from the start of
++ the preedit string.
++
++ A number of attributes control the visual appearance of the
++ preedit string (the visual appearance of text outside the preedit
++ string is controlled by the widget only). The AttributeType enum
++ describes the different attributes that can be set.
++
++ A class implementing QWidget::inputMethodEvent() or
++ QGraphicsItem::inputMethodEvent() should at least understand and
++ honor the \l TextFormat and \l Cursor attributes.
++
++ Since input methods need to be able to query certain properties
++ from the widget or graphics item, subclasses must also implement
++ QWidget::inputMethodQuery() and QGraphicsItem::inputMethodQuery(),
++ respectively.
++
++ When receiving an input method event, the text widget has to performs the
++ following steps:
++
++ \list 1
++ \li If the widget has selected text, the selected text should get
++ removed.
++
++ \li Remove the text starting at replacementStart() with length
++ replacementLength() and replace it by the commitString(). If
++ replacementLength() is 0, replacementStart() gives the insertion
++ position for the commitString().
++
++ When doing replacement the area of the preedit
++ string is ignored, thus a replacement starting at -1 with a length
++ of 2 will remove the last character before the preedit string and
++ the first character afterwards, and insert the commit string
++ directly before the preedit string.
++
++ If the widget implements undo/redo, this operation gets added to
++ the undo stack.
++
++ \li If there is no current preedit string, insert the
++ preeditString() at the current cursor position; otherwise replace
++ the previous preeditString with the one received from this event.
++
++ If the widget implements undo/redo, the preeditString() should not
++ influence the undo/redo stack in any way.
++
++ The widget should examine the list of attributes to apply to the
++ preedit string. It has to understand at least the TextFormat and
++ Cursor attributes and render them as specified.
++ \endlist
++
++ \sa QInputMethod
++ */
++
++ /*!
++ \enum QInputMethodEvent::AttributeType
++
++ \value TextFormat
++ A QTextCharFormat for the part of the preedit string specified by
++ start and length. value contains a QVariant of type QTextFormat
++ specifying rendering of this part of the preedit string. There
++ should be at most one format for every part of the preedit
++ string. If several are specified for any character in the string the
++ behaviour is undefined. A conforming implementation has to at least
++ honor the backgroundColor, textColor and fontUnderline properties
++ of the format.
++
++ \value Cursor If set, a cursor should be shown inside the preedit
++ string at position start. The length variable determines whether
++ the cursor is visible or not. If the length is 0 the cursor is
++ invisible. If value is a QVariant of type QColor this color will
++ be used for rendering the cursor, otherwise the color of the
++ surrounding text will be used. There should be at most one Cursor
++ attribute per event. If several are specified the behaviour is
++ undefined.
++
++ \value Language
++ The variant contains a QLocale object specifying the language of a
++ certain part of the preedit string. There should be at most one
++ language set for every part of the preedit string. If several are
++ specified for any character in the string the behavior is undefined.
++
++ \value Ruby
++ The ruby text for a part of the preedit string. There should be at
++ most one ruby text set for every part of the preedit string. If
++ several are specified for any character in the string the behaviour
++ is undefined.
++
++ \value Selection
++ If set, the edit cursor should be moved to the specified position
++ in the editor text contents. In contrast with \c Cursor, this
++ attribute does not work on the preedit text, but on the surrounding
++ text. The cursor will be moved after the commit string has been
++ committed, and the preedit string will be located at the new edit
++ position.
++ The start position specifies the new position and the length
++ variable can be used to set a selection starting from that point.
++ The value is unused.
++
++ \value MimeData
++ If set, the variant contains a QMimeData object representing the
++ committed text. The commitString() still provides the plain text
++ representation of the committed text.
++
++ \sa Attribute
++ */
++
++ /*!
++ \class QInputMethodEvent::Attribute
++ \inmodule QtGui
++ \brief The QInputMethodEvent::Attribute class stores an input method attribute.
++ */
++
++ /*!
++ \fn QInputMethodEvent::Attribute::Attribute(AttributeType type, int start, int length, QVariant value)
++
++ Constructs an input method attribute. \a type specifies the type
++ of attribute, \a start and \a length the position of the
++ attribute, and \a value the value of the attribute.
++ */
++
++ /*!
++ \fn QInputMethodEvent::Attribute::Attribute(AttributeType type, int start, int length)
++ \overload
++ \since 5.7
++
++ Constructs an input method attribute with no value. \a type
++ specifies the type of attribute, and \a start and \a length
++ the position of the attribute.
++ */
++
++ /*!
++ Constructs an event of type QEvent::InputMethod. The
++ attributes(), preeditString(), commitString(), replacementStart(),
++ and replacementLength() are initialized to default values.
++
++ \sa setCommitString()
++ */
++ QInputMethodEvent::QInputMethodEvent()
++ : QEvent(QEvent::InputMethod), m_replacementStart(0), m_replacementLength(0)
++ {
++ }
++
++ /*!
++ Constructs an event of type QEvent::InputMethod. The
++ preedit text is set to \a preeditText, the attributes to
++ \a attributes.
++
++ The commitString(), replacementStart(), and replacementLength()
++ values can be set using setCommitString().
++
++ \sa preeditString(), attributes()
++ */
++ QInputMethodEvent::QInputMethodEvent(const QString &preeditText, const QList<Attribute> &attributes)
++ : QEvent(QEvent::InputMethod), m_preedit(preeditText), m_attributes(attributes),
++ m_replacementStart(0), m_replacementLength(0)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QInputMethodEvent)
++
++ /*!
++ Sets the commit string to \a commitString.
++
++ The commit string is the text that should get added to (or
++ replace parts of) the text of the editor widget. It usually is a
++ result of the input operations and has to be inserted to the
++ widgets text directly before the preedit string.
++
++ If the commit string should replace parts of the text in
++ the editor, \a replaceLength specifies the number of
++ characters to be replaced. \a replaceFrom specifies the position
++ at which characters are to be replaced relative from the start of
++ the preedit string.
++
++ \sa commitString(), replacementStart(), replacementLength()
++ */
++ void QInputMethodEvent::setCommitString(const QString &commitString, int replaceFrom, int replaceLength)
++ {
++ m_commit = commitString;
++ m_replacementStart = replaceFrom;
++ m_replacementLength = replaceLength;
++ }
++
++ /*!
++ \fn const QList<Attribute> &QInputMethodEvent::attributes() const
++
++ Returns the list of attributes passed to the QInputMethodEvent
++ constructor. The attributes control the visual appearance of the
++ preedit string (the visual appearance of text outside the preedit
++ string is controlled by the widget only).
++
++ \sa preeditString(), Attribute
++ */
++
++ /*!
++ \fn const QString &QInputMethodEvent::preeditString() const
++
++ Returns the preedit text, i.e. the text before the user started
++ editing it.
++
++ \sa commitString(), attributes()
++ */
++
++ /*!
++ \fn const QString &QInputMethodEvent::commitString() const
++
++ Returns the text that should get added to (or replace parts of)
++ the text of the editor widget. It usually is a result of the
++ input operations and has to be inserted to the widgets text
++ directly before the preedit string.
++
++ \sa setCommitString(), preeditString(), replacementStart(), replacementLength()
++ */
++
++ /*!
++ \fn int QInputMethodEvent::replacementStart() const
++
++ Returns the position at which characters are to be replaced relative
++ from the start of the preedit string.
++
++ \sa replacementLength(), setCommitString()
++ */
++
++ /*!
++ \fn int QInputMethodEvent::replacementLength() const
++
++ Returns the number of characters to be replaced in the preedit
++ string.
++
++ \sa replacementStart(), setCommitString()
++ */
++
++ /*!
++ \class QInputMethodQueryEvent
++ \since 5.0
++ \inmodule QtGui
++
++ \brief The QInputMethodQueryEvent class provides an event sent by the input context to input objects.
++
++ It is used by the
++ input method to query a set of properties of the object to be
++ able to support complex input method operations as support for
++ surrounding text and reconversions.
++
++ queries() specifies which properties are queried.
++
++ The object should call setValue() on the event to fill in the requested
++ data before calling accept().
++ */
++
++ /*!
++ \fn Qt::InputMethodQueries QInputMethodQueryEvent::queries() const
++
++ Returns the properties queried by the event.
++ */
++
++ /*!
++ Constructs a query event for properties given by \a queries.
++ */
++ QInputMethodQueryEvent::QInputMethodQueryEvent(Qt::InputMethodQueries queries)
++ : QEvent(InputMethodQuery),
++ m_queries(queries)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QInputMethodQueryEvent)
++
++ /*!
++ Sets property \a query to \a value.
++ */
++ void QInputMethodQueryEvent::setValue(Qt::InputMethodQuery query, const QVariant &value)
++ {
++ for (int i = 0; i < m_values.size(); ++i) {
++ if (m_values.at(i).query == query) {
++ m_values[i].value = value;
++ return;
++ }
++ }
++ QueryPair pair = { query, value };
++ m_values.append(pair);
++ }
++
++ /*!
++ Returns value of the property \a query.
++ */
++ QVariant QInputMethodQueryEvent::value(Qt::InputMethodQuery query) const
++ {
++ for (int i = 0; i < m_values.size(); ++i)
++ if (m_values.at(i).query == query)
++ return m_values.at(i).value;
++ return QVariant();
++ }
++
++ #if QT_CONFIG(tabletevent)
++
++ /*!
++ \class QTabletEvent
++ \brief The QTabletEvent class contains parameters that describe a Tablet event.
++ \inmodule QtGui
++
++ \ingroup events
++
++ \e{Tablet events} are generated from tablet peripherals such as Wacom
++ tablets and various other brands, and electromagnetic stylus devices
++ included with some types of tablet computers. (It is not the same as
++ \l QTouchEvent which a touchscreen generates, even when a passive stylus is
++ used on a touchscreen.)
++
++ Tablet events are similar to mouse events; for example, the \l x(), \l y(),
++ \l pos(), \l globalX(), \l globalY(), and \l globalPos() accessors provide
++ the cursor position, and you can see which \l buttons() are pressed
++ (pressing the stylus tip against the tablet surface is equivalent to a left
++ mouse button). But tablet events also pass through some extra information
++ that the tablet device driver provides; for example, you might want to do
++ subpixel rendering with higher resolution coordinates (\l globalPosF()),
++ adjust color brightness based on the \l pressure() of the tool against the
++ tablet surface, use different brushes depending on the type of tool in use
++ (\l deviceType()), modulate the brush shape in some way according to the
++ X-axis and Y-axis tilt of the tool with respect to the tablet surface
++ (\l xTilt() and \l yTilt()), and use a virtual eraser instead of a brush if
++ the user switches to the other end of a double-ended stylus
++ (\l pointerType()).
++
++ Every event contains an accept flag that indicates whether the receiver
++ wants the event. You should call QTabletEvent::accept() if you handle the
++ tablet event; otherwise it will be sent to the parent widget. The exception
++ are TabletEnterProximity and TabletLeaveProximity events: these are only
++ sent to QApplication and do not check whether or not they are accepted.
++
++ The QWidget::setEnabled() function can be used to enable or disable
++ mouse, tablet and keyboard events for a widget.
++
++ The event handler QWidget::tabletEvent() receives TabletPress,
++ TabletRelease and TabletMove events. Qt will first send a
++ tablet event, then if it is not accepted by any widget, it will send a
++ mouse event. This allows users of applications that are not designed for
++ tablets to use a tablet like a mouse. However high-resolution drawing
++ applications should handle the tablet events, because they can occur at a
++ higher frequency, which is a benefit for smooth and accurate drawing.
++ If the tablet events are rejected, the synthetic mouse events may be
++ compressed for efficiency.
++
++ Note that pressing the stylus button while the stylus hovers over the
++ tablet will generate a button press on some types of tablets, while on
++ other types it will be necessary to press the stylus against the tablet
++ surface in order to register the simultaneous stylus button press.
++
++ \section1 Notes for X11 Users
++
++ If the tablet is configured in xorg.conf to use the Wacom driver, there
++ will be separate XInput "devices" for the stylus, eraser, and (optionally)
++ cursor and touchpad. Qt recognizes these by their names. Otherwise, if the
++ tablet is configured to use the evdev driver, there will be only one device
++ and applications may not be able to distinguish the stylus from the eraser.
++
++ \section1 Notes for Windows Users
++
++ Tablet support currently requires the WACOM windows driver providing the DLL
++ \c{wintab32.dll} to be installed. It is contained in older packages,
++ for example \c{pentablet_5.3.5-3.exe}.
++
++ */
++
++ /*!
++ Construct a tablet event of the given \a type.
++
++ The \a pos parameter indicates where the event occurred in the widget;
++ \a globalPos is the corresponding position in absolute coordinates.
++
++ \a pressure gives the pressure exerted on the device \a dev.
++
++ \a xTilt and \a yTilt give the device's degree of tilt from the
++ x and y axes respectively.
++
++ \a keyState specifies which keyboard modifiers are pressed (e.g.,
++ \uicontrol{Ctrl}).
++
++ The \a z parameter gives the Z coordinate of the device on the tablet;
++ this is usually given by a wheel on a 4D mouse. If the device does not
++ support a Z-axis (i.e. \l QPointingDevice::capabilities() does not include
++ \c ZPosition), pass \c 0 here.
++
++ The \a tangentialPressure parameter gives the tangential pressure
++ thumbwheel value from an airbrush. If the device does not support
++ tangential pressure (i.e. \l QPointingDevice::capabilities() does not
++ include \c TangentialPressure), pass \c 0 here.
++
++ \a rotation gives the device's rotation in degrees.
++ 4D mice, the Wacom Art Pen, and the Apple Pencil support rotation.
++ If the device does not support rotation (i.e. \l QPointingDevice::capabilities()
++ does not include \c Rotation), pass \c 0 here.
++
++ The \a button that caused the event is given as a value from the
++ \l Qt::MouseButton enum. If the event \a type is not \l TabletPress or
++ \l TabletRelease, the appropriate button for this event is \l Qt::NoButton.
++
++ \a buttons is the state of all buttons at the time of the event.
++
++ \sa pos(), globalPos(), device(), pressure(), xTilt(), yTilt(), uniqueId(), rotation(),
++ tangentialPressure(), z()
++ */
++ QTabletEvent::QTabletEvent(Type type, const QPointingDevice *dev, const QPointF &pos, const QPointF &globalPos,
++ qreal pressure, float xTilt, float yTilt,
++ float tangentialPressure, qreal rotation, float z,
++ Qt::KeyboardModifiers keyState,
++ Qt::MouseButton button, Qt::MouseButtons buttons)
++ : QSinglePointEvent(type, dev, pos, pos, globalPos, button, buttons, keyState),
++ m_tangential(tangentialPressure),
++ m_xTilt(xTilt),
++ m_yTilt(yTilt),
++ m_z(z)
++ {
++ QEventPoint &p = point(0);
++ QMutableEventPoint::setPressure(p, pressure);
++ QMutableEventPoint::setRotation(p, rotation);
++ }
++
++ Q_IMPL_POINTER_EVENT(QTabletEvent)
++
++ /*!
++ \fn qreal QTabletEvent::tangentialPressure() const
++
++ Returns the tangential pressure for the device. This is typically given by a finger
++ wheel on an airbrush tool. The range is from -1.0 to 1.0. 0.0 indicates a
++ neutral position. Current airbrushes can only move in the positive
++ direction from the neutrual position. If the device does not support
++ tangential pressure, this value is always 0.0.
++
++ \note The value is stored as a single-precision float.
++
++ \sa pressure()
++ */
++
++ /*!
++ \fn qreal QTabletEvent::rotation() const
++
++ Returns the rotation of the current tool in degrees, where zero means the
++ tip of the stylus is pointing towards the top of the tablet, a positive
++ value means it's turned to the right, and a negative value means it's
++ turned to the left. This can be given by a 4D Mouse or a rotation-capable
++ stylus (such as the Wacom Art Pen or the Apple Pencil). If the device does
++ not support rotation, this value is always 0.0.
++ */
++
++ /*!
++ \fn qreal QTabletEvent::pressure() const
++
++ Returns the pressure for the device. 0.0 indicates that the stylus is not
++ on the tablet, 1.0 indicates the maximum amount of pressure for the stylus.
++
++ \sa tangentialPressure()
++ */
++
++ /*!
++ \fn qreal QTabletEvent::xTilt() const
++
++ Returns the angle between the device (a pen, for example) and the
++ perpendicular in the direction of the x axis.
++ Positive values are towards the tablet's physical right. The angle
++ is in the range -60 to +60 degrees.
++
++ \image qtabletevent-tilt.png {Illustration of a device that is tilted
++ in a 3 Dimensional coordinate system}
++
++ \note The value is stored as a single-precision float.
++
++ \sa yTilt()
++ */
++
++ /*!
++ \fn qreal QTabletEvent::yTilt() const
++
++ Returns the angle between the device (a pen, for example) and the
++ perpendicular in the direction of the y axis.
++ Positive values are towards the bottom of the tablet. The angle is
++ within the range -60 to +60 degrees.
++
++ \note The value is stored as a single-precision float.
++
++ \sa xTilt()
++ */
++
++ /*!
++ \fn QPoint QTabletEvent::pos() const
++ \deprecated [6.0] Use position().toPoint() instead.
++
++ Returns the position of the device, relative to the widget that
++ received the event.
++
++ If you move widgets around in response to mouse events, use
++ globalPos() instead of this function.
++
++ \sa x(), y(), globalPos()
++ */
++
++ /*!
++ \fn int QTabletEvent::x() const
++ \deprecated [6.0] Use position().x() instead.
++
++ Returns the x position of the device, relative to the widget that
++ received the event.
++
++ \sa y(), pos()
++ */
++
++ /*!
++ \fn int QTabletEvent::y() const
++ \deprecated [6.0] Use position().y() instead.
++
++ Returns the y position of the device, relative to the widget that
++ received the event.
++
++ \sa x(), pos()
++ */
++
++ /*!
++ \fn qreal QTabletEvent::z() const
++
++ Returns the z position of the device. Typically this is represented by a
++ wheel on a 4D Mouse. If the device does not support a Z-axis, this value is
++ always zero. This is \b not the same as pressure.
++
++ \note The value is stored as a single-precision float.
++
++ \sa pressure()
++ */
++
++ /*!
++ \fn QPoint QTabletEvent::globalPos() const
++ \deprecated [6.0] Use globalPosition().toPoint() instead.
++
++ Returns the global position of the device \e{at the time of the
++ event}. This is important on asynchronous windows systems like X11;
++ whenever you move your widgets around in response to mouse events,
++ globalPos() can differ significantly from the current position
++ QCursor::pos().
++
++ \sa globalX(), globalY()
++ */
++
++ /*!
++ \fn int QTabletEvent::globalX() const
++ \deprecated [6.0] Use globalPosition().x() instead.
++
++ Returns the global x position of the mouse pointer at the time of
++ the event.
++
++ \sa globalY(), globalPos()
++ */
++
++ /*!
++ \fn int QTabletEvent::globalY() const
++ \deprecated [6.0] Use globalPosition().y() instead.
++
++ Returns the global y position of the tablet device at the time of
++ the event.
++
++ \sa globalX(), globalPos()
++ */
++
++ /*!
++ \fn qint64 QTabletEvent::uniqueId() const
++ \deprecated [6.0] Use pointingDevice().uniqueId() instead.
++
++ Returns a unique ID for the current device, making it possible
++ to differentiate between multiple devices being used at the same
++ time on the tablet.
++
++ Support of this feature is dependent on the tablet.
++
++ Values for the same device may vary from OS to OS.
++
++ Later versions of the Wacom driver for Linux will now report
++ the ID information. If you have a tablet that supports unique ID
++ and are not getting the information on Linux, consider upgrading
++ your driver.
++
++ As of Qt 4.2, the unique ID is the same regardless of the orientation
++ of the pen. Earlier versions would report a different value when using
++ the eraser-end versus the pen-end of the stylus on some OS's.
++
++ \sa pointerType()
++ */
++
++ /*!
++ \fn const QPointF &QTabletEvent::posF() const
++ \deprecated [6.0] Use position() instead.
++
++ Returns the position of the device, relative to the widget that
++ received the event.
++
++ If you move widgets around in response to mouse events, use
++ globalPosF() instead of this function.
++
++ \sa globalPosF()
++ */
++
++ /*!
++ \fn const QPointF &QTabletEvent::globalPosF() const
++ \deprecated [6.0] Use globalPosition() instead.
++ Returns the global position of the device \e{at the time of the
++ event}. This is important on asynchronous windows systems like X11;
++ whenever you move your widgets around in response to mouse events,
++ globalPosF() can differ significantly from the current position
++ QCursor::pos().
++
++ \sa posF()
++ */
++
++ #endif // QT_CONFIG(tabletevent)
++
++ #ifndef QT_NO_GESTURES
++ /*!
++ \class QNativeGestureEvent
++ \since 5.2
++ \brief The QNativeGestureEvent class contains parameters that describe a gesture event.
++ \inmodule QtGui
++ \ingroup events
++
++ Native gesture events are generated by the operating system, typically by
++ interpreting trackpad touch events. Gesture events are high-level events
++ such as zoom, rotate or pan. Several types hold incremental values: that is,
++ value() and delta() provide the difference from the previous event to the
++ current event.
++
++ \table
++ \header
++ \li Event Type
++ \li Description
++ \li Touch sequence
++ \row
++ \li Qt::ZoomNativeGesture
++ \li Magnification delta in percent.
++ \li \macos and Wayland: Two-finger pinch.
++ \row
++ \li Qt::SmartZoomNativeGesture
++ \li Boolean magnification state.
++ \li \macos: Two-finger douple tap (trackpad) / One-finger douple tap (magic mouse).
++ \row
++ \li Qt::RotateNativeGesture
++ \li Rotation delta in degrees.
++ \li \macos and Wayland: Two-finger rotate.
++ \row
++ \li Qt::SwipeNativeGesture
++ \li Swipe angle in degrees.
++ \li \macos: Configurable in trackpad settings.
++ \row
++ \li Qt::PanNativeGesture
++ \li Displacement delta in pixels.
++ \li Wayland: Three or more fingers moving as a group, in any direction.
++ \endtable
++
++ In addition, BeginNativeGesture and EndNativeGesture are sent before and after
++ gesture event streams:
++
++ BeginNativeGesture
++ ZoomNativeGesture
++ ZoomNativeGesture
++ ZoomNativeGesture
++ EndNativeGesture
++
++ The event stream may include interleaved gestures of different types:
++ for example the two-finger pinch gesture generates a stream of Zoom and
++ Rotate events, and PanNativeGesture may sometimes be interleaved with
++ those, depending on the platform.
++
++ Other types are standalone events: SmartZoomNativeGesture and
++ SwipeNativeGesture occur only once each time the gesture is detected.
++
++ \note On a touchpad, moving two fingers as a group (the two-finger flick gesture)
++ is usually reserved for scrolling; in that case, Qt generates QWheelEvents.
++ This is the reason that three or more fingers are needed to generate a
++ PanNativeGesture.
++
++ \sa Qt::NativeGestureType, QGestureEvent, QWheelEvent
++ */
++
++ #if QT_DEPRECATED_SINCE(6, 2)
++ /*!
++ \deprecated [6.2] Use the other constructor, because \a intValue is no longer stored separately.
++
++ Constructs a native gesture event of type \a type originating from \a device.
++
++ The points \a localPos, \a scenePos and \a globalPos specify the
++ gesture position relative to the receiving widget or item,
++ window, and screen or desktop, respectively.
++
++ \a realValue is the \macos event parameter, \a sequenceId and \a intValue are the Windows event parameters.
++ \since 5.10
++
++ \note It's not possible to store realValue and \a intValue simultaneously:
++ one or the other must be zero. If \a realValue == 0 and \a intValue != 0,
++ it is stored in the same variable, such that value() returns the value
++ given as \a intValue.
++ */
++ QNativeGestureEvent::QNativeGestureEvent(Qt::NativeGestureType type, const QPointingDevice *device,
++ const QPointF &localPos, const QPointF &scenePos,
++ const QPointF &globalPos, qreal realValue, quint64 sequenceId,
++ quint64 intValue)
++ : QSinglePointEvent(QEvent::NativeGesture, device, localPos, scenePos, globalPos, Qt::NoButton,
++ Qt::NoButton, Qt::NoModifier),
++ m_sequenceId(sequenceId), m_realValue(realValue), m_gestureType(type)
++ {
++ if (qIsNull(realValue) && intValue != 0)
++ m_realValue = intValue;
++ }
++ #endif // deprecated
++
++ /*!
++ Constructs a native gesture event of type \a type originating from \a device
++ describing a gesture at \a scenePos in which \a fingerCount fingers are involved.
++
++ The points \a localPos, \a scenePos and \a globalPos specify the gesture
++ position relative to the receiving widget or item, window, and screen or
++ desktop, respectively.
++
++ \a value has a gesture-dependent interpretation: for RotateNativeGesture or
++ SwipeNativeGesture, it's an angle in degrees. For ZoomNativeGesture,
++ \a value is an incremental scaling factor, usually much less than 1,
++ indicating that the target item should have its scale adjusted like this:
++ item.scale = item.scale * (1 + event.value)
++
++ For PanNativeGesture, \a delta gives the distance in pixels that the
++ viewport, widget or item should be moved or panned.
++
++ \note The \a delta is stored in single precision (QVector2D), so \l delta()
++ may return slightly different values in some cases. This is subject to change
++ in future versions of Qt.
++
++ \since 6.2
++ */
++ QNativeGestureEvent::QNativeGestureEvent(Qt::NativeGestureType type, const QPointingDevice *device, int fingerCount,
++ const QPointF &localPos, const QPointF &scenePos,
++ const QPointF &globalPos, qreal value, const QPointF &delta,
++ quint64 sequenceId)
++ : QSinglePointEvent(QEvent::NativeGesture, device, localPos, scenePos, globalPos, Qt::NoButton,
++ Qt::NoButton, Qt::NoModifier),
++ m_sequenceId(sequenceId), m_delta(delta), m_realValue(value), m_gestureType(type), m_fingerCount(fingerCount)
++ {
++ Q_ASSERT(fingerCount < 16); // we store it in 4 bits unsigned
++ }
++
++ Q_IMPL_POINTER_EVENT(QNativeGestureEvent)
++
++ /*!
++ \fn QNativeGestureEvent::gestureType() const
++ \since 5.2
++
++ Returns the gesture type.
++ */
++
++ /*!
++ \fn QNativeGestureEvent::fingerCount() const
++ \since 6.2
++
++ Returns the number of fingers participating in the gesture, if known.
++ When gestureType() is Qt::BeginNativeGesture or Qt::EndNativeGesture, often
++ this information is unknown, and fingerCount() returns \c 0.
++ */
++
++ /*!
++ \fn QNativeGestureEvent::value() const
++ \since 5.2
++
++ Returns the gesture value. The value should be interpreted based on the
++ gesture type. For example, a Zoom gesture provides a scale factor delta while a Rotate
++ gesture provides a rotation delta.
++
++ \sa QNativeGestureEvent, gestureType()
++ */
++
++ /*!
++ \fn QNativeGestureEvent::delta() const
++ \since 6.2
++
++ Returns the distance moved since the previous event, in pixels.
++ A Pan gesture provides the distance in pixels by which the target widget,
++ item or viewport contents should be moved.
++
++ \sa QPanGesture::delta()
++ */
++
++ /*!
++ \fn QPoint QNativeGestureEvent::globalPos() const
++ \since 5.2
++ \deprecated [6.0] Use globalPosition().toPoint() instead.
++
++ Returns the position of the gesture as a QPointF in screen coordinates
++ */
++
++ /*!
++ \fn QPoint QNativeGestureEvent::pos() const
++ \since 5.2
++ \deprecated [6.0] Use position().toPoint() instead.
++
++ Returns the position of the mouse cursor, relative to the widget
++ or item that received the event.
++ */
++
++ /*!
++ \fn QPointF QNativeGestureEvent::localPos() const
++ \since 5.2
++ \deprecated [6.0] Use position() instead.
++
++ Returns the position of the gesture as a QPointF, relative to the
++ widget or item that received the event.
++ */
++
++ /*!
++ \fn QPointF QNativeGestureEvent::screenPos() const
++ \since 5.2
++ \deprecated [6.0] Use globalPosition() instead.
++
++ Returns the position of the gesture as a QPointF in screen coordinates.
++ */
++
++ /*!
++ \fn QPointF QNativeGestureEvent::windowPos() const
++ \since 5.2
++ \deprecated [6.0] Use scenePosition() instead.
++
++ Returns the position of the gesture as a QPointF, relative to the
++ window that received the event.
++ */
++ #endif // QT_NO_GESTURES
++
++ #if QT_CONFIG(draganddrop)
++
++ #if QT_DEPRECATED_SINCE(6, 16)
++ /*!
++ Creates a QDragMoveEvent of the required \a type indicating
++ that the mouse is at position \a pos given within a widget.
++
++ The mouse and keyboard states are specified by \a buttons and
++ \a modifiers, and the \a actions describe the types of drag
++ and drop operation that are possible.
++ The drag data is passed as MIME-encoded information in \a data.
++
++ \warning Do not attempt to create a QDragMoveEvent yourself.
++ These objects rely on Qt's internal state.
++ \deprecated
++ */
++ QDragMoveEvent::QDragMoveEvent(const QPoint& pos, Qt::DropActions actions, const QMimeData *data,
++ Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type)
++ : QDropEvent(QPointF(pos), actions, data, buttons, modifiers, type)
++ , m_rect(pos, QSize(1, 1))
++ {}
++ #endif
++
++ /*!
++ Creates a QDragMoveEvent of the required \a type indicating
++ that the mouse is at position \a pos given within a widget.
++
++ The mouse and keyboard states are specified by \a buttons and
++ \a modifiers, and the \a actions describe the types of drag
++ and drop operation that are possible.
++ The drag data is passed as MIME-encoded information in \a data.
++
++ \warning Do not attempt to create a QDragMoveEvent yourself.
++ These objects rely on Qt's internal state.
++ */
++ QDragMoveEvent::QDragMoveEvent(QPointF pos, Qt::DropActions actions, const QMimeData *data,
++ Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type)
++ : QDropEvent(pos, actions, data, buttons, modifiers, type)
++ , m_rect(pos.toPoint(), QSize(1, 1))
++ {}
++
++ Q_IMPL_EVENT_COMMON(QDragMoveEvent)
++
++ /*!
++ \fn void QDragMoveEvent::accept(const QRect &rectangle)
++
++ The same as accept(), but also notifies that future moves will
++ also be acceptable if they remain within the \a rectangle
++ given on the widget. This can improve performance, but may
++ also be ignored by the underlying system.
++
++ If the rectangle is empty, drag move events will be sent
++ continuously. This is useful if the source is scrolling in a
++ timer event.
++ */
++
++ /*!
++ \fn void QDragMoveEvent::accept()
++
++ \overload
++
++ Calls QDropEvent::accept().
++ */
++
++ /*!
++ \fn void QDragMoveEvent::ignore()
++
++ \overload
++
++ Calls QDropEvent::ignore().
++ */
++
++ /*!
++ \fn void QDragMoveEvent::ignore(const QRect &rectangle)
++
++ The opposite of the accept(const QRect&) function.
++ Moves within the \a rectangle are not acceptable, and will be
++ ignored.
++ */
++
++ /*!
++ \fn QRect QDragMoveEvent::answerRect() const
++
++ Returns the rectangle in the widget where the drop will occur if accepted.
++ You can use this information to restrict drops to certain places on the
++ widget.
++ */
++
++
++ /*!
++ \class QDropEvent
++ \ingroup events
++ \ingroup draganddrop
++ \inmodule QtGui
++
++ \brief The QDropEvent class provides an event which is sent when a
++ drag and drop action is completed.
++
++ When a widget \l{QWidget::setAcceptDrops()}{accepts drop events}, it will
++ receive this event if it has accepted the most recent QDragEnterEvent or
++ QDragMoveEvent sent to it.
++
++ The drop event contains a proposed action, available from proposedAction(), for
++ the widget to either accept or ignore. If the action can be handled by the
++ widget, you should call the acceptProposedAction() function. Since the
++ proposed action can be a combination of \l Qt::DropAction values, it may be
++ useful to either select one of these values as a default action or ask
++ the user to select their preferred action.
++
++ If the proposed drop action is not suitable, perhaps because your custom
++ widget does not support that action, you can replace it with any of the
++ \l{possibleActions()}{possible drop actions} by calling setDropAction()
++ with your preferred action. If you set a value that is not present in the
++ bitwise OR combination of values returned by possibleActions(), the default
++ copy action will be used. Once a replacement drop action has been set, call
++ accept() instead of acceptProposedAction() to complete the drop operation.
++
++ The mimeData() function provides the data dropped on the widget in a QMimeData
++ object. This contains information about the MIME type of the data in addition to
++ the data itself.
++
++ \sa QMimeData, QDrag, {Drag and Drop}
++ */
++
++ /*!
++ \fn const QMimeData *QDropEvent::mimeData() const
++
++ Returns the data that was dropped on the widget and its associated MIME
++ type information.
++ */
++
++ // ### pos is in which coordinate system?
++ /*!
++ Constructs a drop event of a certain \a type corresponding to a
++ drop at the point specified by \a pos in the destination widget's
++ coordinate system.
++
++ The \a actions indicate which types of drag and drop operation can
++ be performed, and the drag data is stored as MIME-encoded data in \a data.
++
++ The states of the mouse buttons and keyboard modifiers at the time of
++ the drop are specified by \a buttons and \a modifiers.
++ */
++ QDropEvent::QDropEvent(const QPointF& pos, Qt::DropActions actions, const QMimeData *data,
++ Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type)
++ : QEvent(type), m_pos(pos), m_mouseState(buttons),
++ m_modState(modifiers), m_actions(actions),
++ m_data(data)
++ {
++ m_defaultAction = m_dropAction =
++ QGuiApplicationPrivate::platformIntegration()->drag()->defaultAction(m_actions, modifiers);
++ ignore();
++ }
++
++ Q_IMPL_EVENT_COMMON(QDropEvent)
++
++
++ /*!
++ If the source of the drag operation is a widget in this
++ application, this function returns that source; otherwise it
++ returns \nullptr. The source of the operation is the first parameter to
++ the QDrag object used instantiate the drag.
++
++ This is useful if your widget needs special behavior when dragging
++ to itself.
++
++ \sa QDrag::QDrag()
++ */
++ QObject* QDropEvent::source() const
++ {
++ if (const QDragManager *manager = QDragManager::self())
++ return manager->source();
++ return nullptr;
++ }
++
++
++ void QDropEvent::setDropAction(Qt::DropAction action)
++ {
++ if (!(action & m_actions) && action != Qt::IgnoreAction)
++ action = m_defaultAction;
++ m_dropAction = action;
++ }
++
++ /*!
++ \fn QPoint QDropEvent::pos() const
++ \deprecated [6.0] Use position().toPoint() instead.
++
++ Returns the position where the drop was made.
++ */
++
++ /*!
++ \fn const QPointF& QDropEvent::posF() const
++ \deprecated [6.0] Use position() instead.
++
++ Returns the position where the drop was made.
++ */
++
++ /*!
++ \fn QPointF QDropEvent::position() const
++ \since 6.0
++
++ Returns the position where the drop was made.
++ */
++
++ /*!
++ \fn Qt::MouseButtons QDropEvent::mouseButtons() const
++ \deprecated [6.0] Use buttons() instead.
++
++ Returns the mouse buttons that are pressed.
++ */
++
++ /*!
++ \fn Qt::MouseButtons QDropEvent::buttons() const
++ \since 6.0
++
++ Returns the mouse buttons that are pressed.
++ */
++
++ /*!
++ \fn Qt::KeyboardModifiers QDropEvent::keyboardModifiers() const
++ \deprecated [6.0] Use modifiers() instead.
++
++ Returns the modifier keys that are pressed.
++ */
++
++ /*!
++ \fn Qt::KeyboardModifiers QDropEvent::modifiers() const
++ \since 6.0
++
++ Returns the modifier keys that are pressed.
++ */
++
++ /*!
++ \fn void QDropEvent::setDropAction(Qt::DropAction action)
++
++ Sets the \a action to be performed on the data by the target.
++ Use this to override the \l{proposedAction()}{proposed action}
++ with one of the \l{possibleActions()}{possible actions}.
++
++ If you set a drop action that is not one of the possible actions, the
++ drag and drop operation will default to a copy operation.
++
++ Once you have supplied a replacement drop action, call accept()
++ instead of acceptProposedAction().
++
++ \sa dropAction()
++ */
++
++ /*!
++ \fn Qt::DropAction QDropEvent::dropAction() const
++
++ Returns the action to be performed on the data by the target. This may be
++ different from the action supplied in proposedAction() if you have called
++ setDropAction() to explicitly choose a drop action.
++
++ \sa setDropAction()
++ */
++
++ /*!
++ \fn Qt::DropActions QDropEvent::possibleActions() const
++
++ Returns an OR-combination of possible drop actions.
++
++ \sa dropAction()
++ */
++
++ /*!
++ \fn Qt::DropAction QDropEvent::proposedAction() const
++
++ Returns the proposed drop action.
++
++ \sa dropAction()
++ */
++
++ /*!
++ \fn void QDropEvent::acceptProposedAction()
++
++ Sets the drop action to be the proposed action.
++
++ \sa setDropAction(), proposedAction(), {QEvent::accept()}{accept()}
++ */
++
++ /*!
++ \class QDragEnterEvent
++ \brief The QDragEnterEvent class provides an event which is sent
++ to a widget when a drag and drop action enters it.
++
++ \ingroup events
++ \ingroup draganddrop
++ \inmodule QtGui
++
++ A widget must accept this event in order to receive the \l
++ {QDragMoveEvent}{drag move events} that are sent while the drag
++ and drop action is in progress. The drag enter event is always
++ immediately followed by a drag move event.
++
++ QDragEnterEvent inherits most of its functionality from
++ QDragMoveEvent, which in turn inherits most of its functionality
++ from QDropEvent.
++
++ \sa QDragLeaveEvent, QDragMoveEvent, QDropEvent
++ */
++
++ #if QT_DEPRECATED_SINCE(6, 16)
++ /*!
++ Constructs a QDragEnterEvent that represents a drag entering a
++ widget at the given \a point with mouse and keyboard states specified by
++ \a buttons and \a modifiers.
++
++ The drag data is passed as MIME-encoded information in \a data, and the
++ specified \a actions describe the possible types of drag and drop
++ operation that can be performed.
++
++ \warning Do not create a QDragEnterEvent yourself since these
++ objects rely on Qt's internal state.
++ \deprecated
++ */
++ QDragEnterEvent::QDragEnterEvent(const QPoint& point, Qt::DropActions actions, const QMimeData *data,
++ Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
++ : QDragMoveEvent(QPointF(point), actions, data, buttons, modifiers, DragEnter)
++ {}
++ #endif
++
++ /*!
++ Constructs a QDragEnterEvent that represents a drag entering a
++ widget at the given \a point with mouse and keyboard states specified by
++ \a buttons and \a modifiers.
++
++ The drag data is passed as MIME-encoded information in \a data, and the
++ specified \a actions describe the possible types of drag and drop
++ operation that can be performed.
++
++ \warning Do not create a QDragEnterEvent yourself since these
++ objects rely on Qt's internal state.
++ */
++ QDragEnterEvent::QDragEnterEvent(QPointF point, Qt::DropActions actions, const QMimeData *data,
++ Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
++ : QDragMoveEvent(point, actions, data, buttons, modifiers, DragEnter)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QDragEnterEvent)
++
++ /*!
++ \class QDragMoveEvent
++ \brief The QDragMoveEvent class provides an event which is sent while a drag and drop action is in progress.
++
++ \ingroup events
++ \ingroup draganddrop
++ \inmodule QtGui
++
++ A widget will receive drag move events repeatedly while the drag
++ is within its boundaries, if it accepts
++ \l{QWidget::setAcceptDrops()}{drop events} and \l
++ {QWidget::dragEnterEvent()}{enter events}. The widget should
++ examine the event to see what kind of \l{mimeData()}{data} it
++ provides, and call the accept() function to accept the drop if appropriate.
++
++ The rectangle supplied by the answerRect() function can be used to restrict
++ drops to certain parts of the widget. For example, we can check whether the
++ rectangle intersects with the geometry of a certain child widget and only
++ call \l{QDropEvent::acceptProposedAction()}{acceptProposedAction()} if that
++ is the case.
++
++ Note that this class inherits most of its functionality from
++ QDropEvent.
++
++ \sa QDragEnterEvent, QDragLeaveEvent, QDropEvent
++ */
++
++ /*!
++ \class QDragLeaveEvent
++ \brief The QDragLeaveEvent class provides an event that is sent to a widget when a drag and drop action leaves it.
++
++ \ingroup events
++ \ingroup draganddrop
++ \inmodule QtGui
++
++ This event is always preceded by a QDragEnterEvent and a series
++ of \l{QDragMoveEvent}s. It is not sent if a QDropEvent is sent
++ instead.
++
++ \sa QDragEnterEvent, QDragMoveEvent, QDropEvent
++ */
++
++ /*!
++ Constructs a QDragLeaveEvent.
++
++ \warning Do not create a QDragLeaveEvent yourself since these
++ objects rely on Qt's internal state.
++ */
++ QDragLeaveEvent::QDragLeaveEvent()
++ : QEvent(DragLeave)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QDragLeaveEvent)
++
++ #endif // QT_CONFIG(draganddrop)
++
++ /*!
++ \class QHelpEvent
++ \brief The QHelpEvent class provides an event that is used to request helpful information
++ about a particular point in a widget.
++
++ \ingroup events
++ \ingroup helpsystem
++ \inmodule QtGui
++
++ This event can be intercepted in applications to provide tooltips
++ or "What's This?" help for custom widgets. The type() can be
++ either QEvent::ToolTip or QEvent::WhatsThis.
++
++ \sa QToolTip, QWhatsThis, QStatusTipEvent, QWhatsThisClickedEvent
++ */
++
++ /*!
++ Constructs a help event with the given \a type corresponding to the
++ widget-relative position specified by \a pos and the global position
++ specified by \a globalPos.
++
++ \a type must be either QEvent::ToolTip or QEvent::WhatsThis.
++
++ \sa pos(), globalPos()
++ */
++ QHelpEvent::QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos)
++ : QEvent(type), m_pos(pos), m_globalPos(globalPos)
++ {}
++
++ /*!
++ \fn int QHelpEvent::x() const
++
++ Same as pos().x().
++
++ \sa y(), pos(), globalPos()
++ */
++
++ /*!
++ \fn int QHelpEvent::y() const
++
++ Same as pos().y().
++
++ \sa x(), pos(), globalPos()
++ */
++
++ /*!
++ \fn int QHelpEvent::globalX() const
++
++ Same as globalPos().x().
++
++ \sa x(), globalY(), globalPos()
++ */
++
++ /*!
++ \fn int QHelpEvent::globalY() const
++
++ Same as globalPos().y().
++
++ \sa y(), globalX(), globalPos()
++ */
++
++ /*!
++ \fn const QPoint &QHelpEvent::pos() const
++
++ Returns the mouse cursor position when the event was generated,
++ relative to the widget to which the event is dispatched.
++
++ \sa globalPos(), x(), y()
++ */
++
++ /*!
++ \fn const QPoint &QHelpEvent::globalPos() const
++
++ Returns the mouse cursor position when the event was generated
++ in global coordinates.
++
++ \sa pos(), globalX(), globalY()
++ */
++
++ Q_IMPL_EVENT_COMMON(QHelpEvent)
++
++ #ifndef QT_NO_STATUSTIP
++
++ /*!
++ \class QStatusTipEvent
++ \brief The QStatusTipEvent class provides an event that is used to show messages in a status bar.
++
++ \ingroup events
++ \ingroup helpsystem
++ \inmodule QtGui
++
++ Status tips can be set on a widget using the
++ QWidget::setStatusTip() function. They are shown in the status
++ bar when the mouse cursor enters the widget. For example:
++
++ \table 100%
++ \row
++ \li
++ \snippet qstatustipevent/main.cpp 1
++ \dots
++ \snippet qstatustipevent/main.cpp 3
++ \li
++ \image qstatustipevent-widget.png Widget with status tip.
++ \endtable
++
++ Status tips can also be set on actions using the
++ QAction::setStatusTip() function:
++
++ \table 100%
++ \row
++ \li
++ \snippet qstatustipevent/main.cpp 0
++ \snippet qstatustipevent/main.cpp 2
++ \dots
++ \snippet qstatustipevent/main.cpp 3
++ \li
++ \image qstatustipevent-action.png Action with status tip.
++ \endtable
++
++ Finally, status tips are supported for the item view classes
++ through the Qt::StatusTipRole enum value.
++
++ \sa QStatusBar, QHelpEvent, QWhatsThisClickedEvent
++ */
++
++ /*!
++ Constructs a status tip event with the text specified by \a tip.
++
++ \sa tip()
++ */
++ QStatusTipEvent::QStatusTipEvent(const QString &tip)
++ : QEvent(StatusTip), m_tip(tip)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QStatusTipEvent)
++
++ /*!
++ \fn QString QStatusTipEvent::tip() const
++
++ Returns the message to show in the status bar.
++
++ \sa QStatusBar::showMessage()
++ */
++
++ #endif // QT_NO_STATUSTIP
++
++ #if QT_CONFIG(whatsthis)
++
++ /*!
++ \class QWhatsThisClickedEvent
++ \brief The QWhatsThisClickedEvent class provides an event that
++ can be used to handle hyperlinks in a "What's This?" text.
++
++ \ingroup events
++ \ingroup helpsystem
++ \inmodule QtGui
++
++ \sa QWhatsThis, QHelpEvent, QStatusTipEvent
++ */
++
++ /*!
++ Constructs an event containing a URL specified by \a href when a link
++ is clicked in a "What's This?" message.
++
++ \sa href()
++ */
++ QWhatsThisClickedEvent::QWhatsThisClickedEvent(const QString &href)
++ : QEvent(WhatsThisClicked), m_href(href)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QWhatsThisClickedEvent)
++
++ /*!
++ \fn QString QWhatsThisClickedEvent::href() const
++
++ Returns the URL that was clicked by the user in the "What's
++ This?" text.
++ */
++
++ #endif // QT_CONFIG(whatsthis)
++
++ #ifndef QT_NO_ACTION
++
++ /*!
++ \class QActionEvent
++ \brief The QActionEvent class provides an event that is generated
++ when a QAction is added, removed, or changed.
++
++ \ingroup events
++ \inmodule QtGui
++
++ Actions can be added to controls, for example by using QWidget::addAction().
++ This generates an \l ActionAdded event, which you can handle to provide
++ custom behavior. For example, QToolBar reimplements
++ QWidget::actionEvent() to create \l{QToolButton}s for the
++ actions.
++
++ \sa QAction, QWidget::addAction(), QWidget::removeAction(), QWidget::actions()
++ */
++
++ /*!
++ Constructs an action event. The \a type can be \l ActionChanged,
++ \l ActionAdded, or \l ActionRemoved.
++
++ \a action is the action that is changed, added, or removed. If \a
++ type is ActionAdded, the action is to be inserted before the
++ action \a before. If \a before is \nullptr, the action is appended.
++ */
++ QActionEvent::QActionEvent(int type, QAction *action, QAction *before)
++ : QEvent(static_cast<QEvent::Type>(type)), m_action(action), m_before(before)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QActionEvent)
++
++ /*!
++ \fn QAction *QActionEvent::action() const
++
++ Returns the action that is changed, added, or removed.
++
++ \sa before()
++ */
++
++ /*!
++ \fn QAction *QActionEvent::before() const
++
++ If type() is \l ActionAdded, returns the action that should
++ appear before action(). If this function returns \nullptr, the action
++ should be appended to already existing actions on the same
++ widget.
++
++ \sa action(), QWidget::actions()
++ */
++
++ #endif // QT_NO_ACTION
++
++ /*!
++ \class QHideEvent
++ \brief The QHideEvent class provides an event which is sent after a widget is hidden.
++
++ \ingroup events
++ \inmodule QtGui
++
++ This event is sent just before QWidget::hide() returns, and also
++ when a top-level window has been hidden (iconified) by the user.
++
++ If spontaneous() is true, the event originated outside the
++ application. In this case, the user hid the window using the
++ window manager controls, either by iconifying the window or by
++ switching to another virtual desktop where the window is not
++ visible. The window will become hidden but not withdrawn. If the
++ window was iconified, QWidget::isMinimized() returns \c true.
++
++ \sa QShowEvent
++ */
++
++ /*!
++ Constructs a QHideEvent.
++ */
++ QHideEvent::QHideEvent()
++ : QEvent(Hide)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QHideEvent)
++
++ /*!
++ \class QShowEvent
++ \brief The QShowEvent class provides an event that is sent when a widget is shown.
++
++ \ingroup events
++ \inmodule QtGui
++
++ There are two kinds of show events: show events caused by the
++ window system (spontaneous), and internal show events. Spontaneous (QEvent::spontaneous())
++ show events are sent just after the window system shows the
++ window; they are also sent when a top-level window is redisplayed
++ after being iconified. Internal show events are delivered just
++ before the widget becomes visible.
++
++ \sa QHideEvent
++ */
++
++ /*!
++ Constructs a QShowEvent.
++ */
++ QShowEvent::QShowEvent()
++ : QEvent(Show)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QShowEvent)
++
++ /*!
++ \class QFileOpenEvent
++ \brief The QFileOpenEvent class provides an event that will be
++ sent when there is a request to open a file or a URL.
++
++ \ingroup events
++ \inmodule QtGui
++
++ File open events will be sent to the QApplication::instance()
++ when the operating system requests that a file or URL should be opened.
++ This is a high-level event that can be caused by different user actions
++ depending on the platform; for example, double clicking on an file in the
++ Finder or dragging a file to the application's Dock icon on \macos,
++ or sharing a file from another application on iOS.
++
++ This event is only used to notify the application of a request.
++ It may be safely ignored if the file should not be opened.
++
++ \section1 Apple platforms
++
++ In order to trigger the event on Apple platforms, the application must be
++ configured to let the OS know what kind of file(s) it should react on.
++
++ For example, the following \c Info.plist file declares that the application
++ can act as a viewer for PNG files:
++
++ \snippet qfileopenevent/Info.plist Custom Info.plist
++
++ The following key is also necessary on iOS for the application to
++ show up as an "Open With" action in e.g. the Files application:
++
++ \snippet qfileopenevent/Info.plist iOS
++
++ The following implementation of a QApplication subclass shows how to handle
++ QFileOpenEvent to open the file that was, for example, dropped on the Dock
++ icon of the application.
++
++ \snippet qfileopenevent/main.cpp QApplication subclass
++
++ Note how \c{QFileOpenEvent::file()} is not guaranteed to be the name of a
++ local file that can be opened using QFile. The contents of the string depend
++ on the source application.
++ */
++
++ /*!
++ \internal
++
++ Constructs a file open event for the given \a file.
++ */
++ QFileOpenEvent::QFileOpenEvent(const QString &file)
++ : QEvent(FileOpen), m_file(file), m_url(QUrl::fromLocalFile(file))
++ {
++ }
++
++ /*!
++ \internal
++
++ Constructs a file open event for the given \a url.
++ */
++ QFileOpenEvent::QFileOpenEvent(const QUrl &url)
++ : QEvent(FileOpen), m_file(url.toLocalFile()), m_url(url)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QFileOpenEvent)
++
++ /*!
++ \fn QString QFileOpenEvent::file() const
++
++ Returns the name of the file that the application should open.
++
++ This is not guaranteed to be the path to a local file.
++ */
++
++ /*!
++ \fn QUrl QFileOpenEvent::url() const
++
++ Returns the url that the application should open.
++
++ \since 4.6
++ */
++
++ #if QT_DEPRECATED_SINCE(6, 6)
++ /*!
++ \fn bool QFileOpenEvent::openFile(QFile &file, QIODevice::OpenMode flags) const
++ \deprecated [6.6] interpret the string returned by file().
++
++ Opens a QFile on the \a file referenced by this event in the mode specified
++ by \a flags. Returns \c true if successful; otherwise returns \c false.
++
++ This is necessary as some files cannot be opened by name, but require specific
++ information stored in this event.
++
++ \since 4.8
++ */
++ bool QFileOpenEvent::openFile(QFile &file, QIODevice::OpenMode flags) const
++ {
++ file.setFileName(m_file);
++ return file.open(flags);
++ }
++ #endif
++
++ #ifndef QT_NO_TOOLBAR
++ /*!
++ \internal
++ \class QToolBarChangeEvent
++ \brief The QToolBarChangeEvent class provides an event that is
++ sent whenever a the toolbar button is clicked on \macos.
++
++ \ingroup events
++ \inmodule QtGui
++
++ The QToolBarChangeEvent is sent when the toolbar button is clicked. On
++ \macos, this is the long oblong button on the right side of the window
++ title bar. The default implementation is to toggle the appearance (hidden or
++ shown) of the associated toolbars for the window.
++ */
++
++ /*!
++ \internal
++
++ Construct a QToolBarChangeEvent given the current button state in \a state.
++ */
++ QToolBarChangeEvent::QToolBarChangeEvent(bool t)
++ : QEvent(ToolBarChange), m_toggle(t)
++ {}
++
++ Q_IMPL_EVENT_COMMON(QToolBarChangeEvent)
++
++ /*!
++ \fn bool QToolBarChangeEvent::toggle() const
++ \internal
++ */
++
++ /*
++ \fn Qt::ButtonState QToolBarChangeEvent::state() const
++
++ Returns the keyboard modifier flags at the time of the event.
++
++ The returned value is a selection of the following values,
++ combined using the OR operator:
++ Qt::ShiftButton, Qt::ControlButton, Qt::MetaButton, and Qt::AltButton.
++ */
++
++ #endif // QT_NO_TOOLBAR
++
++ #if QT_CONFIG(shortcut)
++
++ /*!
++ Constructs a shortcut event for the given \a key press,
++ associated with the QShortcut ID \a id.
++
++ \deprecated use the other constructor.
++
++ \a ambiguous specifies whether there is more than one QShortcut
++ for the same key sequence.
++ */
++ QShortcutEvent::QShortcutEvent(const QKeySequence &key, int id, bool ambiguous)
++ : QEvent(Shortcut), m_sequence(key), m_shortcutId(id), m_ambiguous(ambiguous)
++ {
++ }
++
++ /*!
++ Constructs a shortcut event for the given \a key press,
++ associated with the QShortcut \a shortcut.
++ \since 6.5
++
++ \a ambiguous specifies whether there is more than one QShortcut
++ for the same key sequence.
++ */
++ QShortcutEvent::QShortcutEvent(const QKeySequence &key, const QShortcut *shortcut, bool ambiguous)
++ : QEvent(Shortcut), m_sequence(key), m_shortcutId(0), m_ambiguous(ambiguous)
++ {
++ if (shortcut) {
++ auto priv = static_cast<const QShortcutPrivate *>(QShortcutPrivate::get(shortcut));
++ auto index = priv->sc_sequences.indexOf(key);
++ if (index < 0) {
++ qWarning() << "Given QShortcut does not contain key-sequence " << key;
++ return;
++ }
++ m_shortcutId = priv->sc_ids[index];
++ }
++ }
++
++ Q_IMPL_EVENT_COMMON(QShortcutEvent)
++
++ #endif // QT_CONFIG(shortcut)
++
++ #ifndef QT_NO_DEBUG_STREAM
++
++ static inline void formatTouchEvent(QDebug d, const QTouchEvent &t)
++ {
++ d << "QTouchEvent(";
++ QtDebugUtils::formatQEnum(d, t.type());
++ d << " device: " << t.device()->name();
++ d << " states: ";
++ QtDebugUtils::formatQFlags(d, t.touchPointStates());
++ d << ", " << t.points().size() << " points: " << t.points() << ')';
++ }
++
++ static void formatUnicodeString(QDebug d, const QString &s)
++ {
++ d << '"' << Qt::hex;
++ for (int i = 0; i < s.size(); ++i) {
++ if (i)
++ d << ',';
++ d << "U+" << s.at(i).unicode();
++ }
++ d << Qt::dec << '"';
++ }
++
++ static QDebug operator<<(QDebug dbg, const QInputMethodEvent::Attribute &attr)
++ {
++ dbg << "[type= " << attr.type << ", start=" << attr.start << ", length=" << attr.length
++ << ", value=" << attr.value << ']';
++ return dbg;
++ }
++
++ static inline void formatInputMethodEvent(QDebug d, const QInputMethodEvent *e)
++ {
++ d << "QInputMethodEvent(";
++ if (!e->preeditString().isEmpty()) {
++ d << "preedit=";
++ formatUnicodeString(d, e->preeditString());
++ }
++ if (!e->commitString().isEmpty()) {
++ d << ", commit=";
++ formatUnicodeString(d, e->commitString());
++ }
++ if (e->replacementLength()) {
++ d << ", replacementStart=" << e->replacementStart() << ", replacementLength="
++ << e->replacementLength();
++ }
++ const auto attributes = e->attributes();
++ auto it = attributes.cbegin();
++ const auto end = attributes.cend();
++ if (it != end) {
++ d << ", attributes= {";
++ d << *it;
++ ++it;
++ for (; it != end; ++it)
++ d << ',' << *it;
++ d << '}';
++ }
++ d << ')';
++ }
++
++ static inline void formatInputMethodQueryEvent(QDebug d, const QInputMethodQueryEvent *e)
++ {
++ QDebugStateSaver saver(d);
++ d.noquote();
++ const Qt::InputMethodQueries queries = e->queries();
++ d << "QInputMethodQueryEvent(queries=" << Qt::showbase << Qt::hex << int(queries)
++ << Qt::noshowbase << Qt::dec << ", {";
++ for (unsigned mask = 1; mask <= Qt::ImInputItemClipRectangle; mask<<=1) {
++ if (queries & mask) {
++ const Qt::InputMethodQuery query = static_cast<Qt::InputMethodQuery>(mask);
++ const QVariant value = e->value(query);
++ if (value.isValid()) {
++ d << '[';
++ QtDebugUtils::formatQEnum(d, query);
++ d << '=';
++ if (query == Qt::ImHints)
++ QtDebugUtils::formatQFlags(d, Qt::InputMethodHints(value.toInt()));
++ else
++ d << value.toString();
++ d << "],";
++ }
++ }
++ }
++ d << "})";
++ }
++
++ static const char *eventClassName(QEvent::Type t)
++ {
++ switch (t) {
++ case QEvent::ActionAdded:
++ case QEvent::ActionRemoved:
++ case QEvent::ActionChanged:
++ return "QActionEvent";
++ case QEvent::MouseButtonPress:
++ case QEvent::MouseButtonRelease:
++ case QEvent::MouseButtonDblClick:
++ case QEvent::MouseMove:
++ case QEvent::NonClientAreaMouseMove:
++ case QEvent::NonClientAreaMouseButtonPress:
++ case QEvent::NonClientAreaMouseButtonRelease:
++ case QEvent::NonClientAreaMouseButtonDblClick:
++ return "QMouseEvent";
++ case QEvent::DragEnter:
++ return "QDragEnterEvent";
++ case QEvent::DragMove:
++ return "QDragMoveEvent";
++ case QEvent::Drop:
++ return "QDropEvent";
++ case QEvent::KeyPress:
++ case QEvent::KeyRelease:
++ case QEvent::ShortcutOverride:
++ return "QKeyEvent";
++ case QEvent::FocusIn:
++ case QEvent::FocusOut:
++ case QEvent::FocusAboutToChange:
++ return "QFocusEvent";
++ case QEvent::ChildAdded:
++ case QEvent::ChildPolished:
++ case QEvent::ChildRemoved:
++ return "QChildEvent";
++ case QEvent::Paint:
++ return "QPaintEvent";
++ case QEvent::Move:
++ return "QMoveEvent";
++ case QEvent::Resize:
++ return "QResizeEvent";
++ case QEvent::Show:
++ return "QShowEvent";
++ case QEvent::Hide:
++ return "QHideEvent";
++ case QEvent::Enter:
++ return "QEnterEvent";
++ case QEvent::Close:
++ return "QCloseEvent";
++ case QEvent::FileOpen:
++ return "QFileOpenEvent";
++ #ifndef QT_NO_GESTURES
++ case QEvent::NativeGesture:
++ return "QNativeGestureEvent";
++ case QEvent::Gesture:
++ case QEvent::GestureOverride:
++ return "QGestureEvent";
++ #endif
++ case QEvent::HoverEnter:
++ case QEvent::HoverLeave:
++ case QEvent::HoverMove:
++ return "QHoverEvent";
++ case QEvent::TabletEnterProximity:
++ case QEvent::TabletLeaveProximity:
++ case QEvent::TabletPress:
++ case QEvent::TabletMove:
++ case QEvent::TabletRelease:
++ return "QTabletEvent";
++ case QEvent::StatusTip:
++ return "QStatusTipEvent";
++ case QEvent::ToolTip:
++ return "QHelpEvent";
++ case QEvent::WindowStateChange:
++ return "QWindowStateChangeEvent";
++ case QEvent::Wheel:
++ return "QWheelEvent";
++ case QEvent::TouchBegin:
++ case QEvent::TouchUpdate:
++ case QEvent::TouchEnd:
++ return "QTouchEvent";
++ case QEvent::Shortcut:
++ return "QShortcutEvent";
++ case QEvent::InputMethod:
++ return "QInputMethodEvent";
++ case QEvent::InputMethodQuery:
++ return "QInputMethodQueryEvent";
++ case QEvent::OrientationChange:
++ return "QScreenOrientationChangeEvent";
++ case QEvent::ScrollPrepare:
++ return "QScrollPrepareEvent";
++ case QEvent::Scroll:
++ return "QScrollEvent";
++ case QEvent::GraphicsSceneMouseMove:
++ case QEvent::GraphicsSceneMousePress:
++ case QEvent::GraphicsSceneMouseRelease:
++ case QEvent::GraphicsSceneMouseDoubleClick:
++ return "QGraphicsSceneMouseEvent";
++ case QEvent::GraphicsSceneContextMenu:
++ case QEvent::GraphicsSceneHoverEnter:
++ case QEvent::GraphicsSceneHoverMove:
++ case QEvent::GraphicsSceneHoverLeave:
++ case QEvent::GraphicsSceneHelp:
++ case QEvent::GraphicsSceneDragEnter:
++ case QEvent::GraphicsSceneDragMove:
++ case QEvent::GraphicsSceneDragLeave:
++ case QEvent::GraphicsSceneDrop:
++ case QEvent::GraphicsSceneWheel:
++ return "QGraphicsSceneEvent";
++ case QEvent::Timer:
++ return "QTimerEvent";
++ case QEvent::PlatformSurface:
++ return "QPlatformSurfaceEvent";
++ default:
++ break;
++ }
++ return "QEvent";
++ }
++
++ # if QT_CONFIG(draganddrop)
++
++ static void formatDropEvent(QDebug d, const QDropEvent *e)
++ {
++ const QEvent::Type type = e->type();
++ d << eventClassName(type) << "(dropAction=";
++ QtDebugUtils::formatQEnum(d, e->dropAction());
++ d << ", proposedAction=";
++ QtDebugUtils::formatQEnum(d, e->proposedAction());
++ d << ", possibleActions=";
++ QtDebugUtils::formatQFlags(d, e->possibleActions());
++ d << ", posF=";
++ QtDebugUtils::formatQPoint(d, e->position());
++ if (type == QEvent::DragMove || type == QEvent::DragEnter)
++ d << ", answerRect=" << static_cast<const QDragMoveEvent *>(e)->answerRect();
++ d << ", formats=" << e->mimeData()->formats();
++ QtDebugUtils::formatNonNullQFlags(d, ", keyboardModifiers=", e->modifiers());
++ d << ", ";
++ QtDebugUtils::formatQFlags(d, e->buttons());
++ }
++
++ # endif // QT_CONFIG(draganddrop)
++
++ # if QT_CONFIG(tabletevent)
++
++ static void formatTabletEvent(QDebug d, const QTabletEvent *e)
++ {
++ const QEvent::Type type = e->type();
++
++ d << eventClassName(type) << '(';
++ QtDebugUtils::formatQEnum(d, type);
++ d << ' ';
++ QtDebugUtils::formatQFlags(d, e->buttons());
++ d << " pos=";
++ QtDebugUtils::formatQPoint(d, e->position());
++ d << " z=" << e->z()
++ << " xTilt=" << e->xTilt()
++ << " yTilt=" << e->yTilt();
++ if (type == QEvent::TabletPress || type == QEvent::TabletMove)
++ d << " pressure=" << e->pressure();
++ if (e->device()->hasCapability(QInputDevice::Capability::Rotation))
++ d << " rotation=" << e->rotation();
++ if (e->deviceType() == QInputDevice::DeviceType::Airbrush)
++ d << " tangentialPressure=" << e->tangentialPressure();
++ d << " dev=" << e->device() << ')';
++ }
++
++ # endif // QT_CONFIG(tabletevent)
++
++ QDebug operator<<(QDebug dbg, const QEventPoint *tp)
++ {
++ if (!tp)
++ return dbg << "QEventPoint(0x0)";
++
++ return operator<<(dbg, *tp);
++ }
++
++ QDebug operator<<(QDebug dbg, const QEventPoint &tp)
++ {
++ QDebugStateSaver saver(dbg);
++ dbg.nospace();
++ dbg << "QEventPoint(id=" << tp.id() << " ts=" << tp.timestamp();
++ dbg << " pos=";
++ QtDebugUtils::formatQPoint(dbg, tp.position());
++ dbg << " scn=";
++ QtDebugUtils::formatQPoint(dbg, tp.scenePosition());
++ dbg << " gbl=";
++ QtDebugUtils::formatQPoint(dbg, tp.globalPosition());
++ dbg << ' ';
++ QtDebugUtils::formatQEnum(dbg, tp.state());
++ if (!qFuzzyIsNull(tp.pressure()) && !qFuzzyCompare(tp.pressure(), 1))
++ dbg << " pressure=" << tp.pressure();
++ if (!tp.ellipseDiameters().isEmpty() || !qFuzzyIsNull(tp.rotation())) {
++ dbg << " ellipse=("
++ << tp.ellipseDiameters().width() << "x" << tp.ellipseDiameters().height()
++ << " \u2221 " << tp.rotation() << ')';
++ }
++ dbg << " vel=";
++ QtDebugUtils::formatQPoint(dbg, tp.velocity().toPointF());
++ dbg << " press=";
++ QtDebugUtils::formatQPoint(dbg, tp.pressPosition());
++ dbg << " last=";
++ QtDebugUtils::formatQPoint(dbg, tp.lastPosition());
++ dbg << " \u0394 ";
++ QtDebugUtils::formatQPoint(dbg, tp.position() - tp.lastPosition());
++ dbg << ')';
++ return dbg;
++ }
++
++ QDebug operator<<(QDebug dbg, const QEvent *e)
++ {
++ QDebugStateSaver saver(dbg);
++ dbg.nospace();
++ if (!e)
++ return dbg << "QEvent(0x0)";
++
++ // More useful event output could be added here
++ const QEvent::Type type = e->type();
++ bool isMouse = false;
++ switch (type) {
++ case QEvent::Expose:
++ dbg << "QExposeEvent()";
++ break;
++ case QEvent::Paint:
++ dbg << "QPaintEvent(" << static_cast<const QPaintEvent *>(e)->region() << ')';
++ break;
++ case QEvent::MouseButtonPress:
++ case QEvent::MouseMove:
++ case QEvent::MouseButtonRelease:
++ case QEvent::MouseButtonDblClick:
++ case QEvent::NonClientAreaMouseButtonPress:
++ case QEvent::NonClientAreaMouseMove:
++ case QEvent::NonClientAreaMouseButtonRelease:
++ case QEvent::NonClientAreaMouseButtonDblClick:
++ isMouse = true;
++ Q_FALLTHROUGH();
++ case QEvent::HoverEnter:
++ case QEvent::HoverMove:
++ case QEvent::HoverLeave:
++ {
++ const QSinglePointEvent *spe = static_cast<const QSinglePointEvent*>(e);
++ const Qt::MouseButton button = spe->button();
++ const Qt::MouseButtons buttons = spe->buttons();
++ dbg << eventClassName(type) << '(';
++ QtDebugUtils::formatQEnum(dbg, type);
++ if (dbg.verbosity() > QDebug::DefaultVerbosity)
++ dbg << " ts=" << spe->timestamp();
++ if (isMouse) {
++ if (type != QEvent::MouseMove && type != QEvent::NonClientAreaMouseMove) {
++ dbg << ' ';
++ QtDebugUtils::formatQEnum(dbg, button);
++ }
++ if (buttons && button != buttons) {
++ dbg << " btns=";
++ QtDebugUtils::formatQFlags(dbg, buttons);
++ }
++ }
++ QtDebugUtils::formatNonNullQFlags(dbg, ", ", spe->modifiers());
++ dbg << " pos=";
++ QtDebugUtils::formatQPoint(dbg, spe->position());
++ dbg << " scn=";
++ QtDebugUtils::formatQPoint(dbg, spe->scenePosition());
++ dbg << " gbl=";
++ QtDebugUtils::formatQPoint(dbg, spe->globalPosition());
++ dbg << " dev=" << spe->device() << ')';
++ if (isMouse) {
++ auto src = static_cast<const QMouseEvent*>(e)->source();
++ if (src != Qt::MouseEventNotSynthesized) {
++ dbg << " source=";
++ QtDebugUtils::formatQEnum(dbg, src);
++ }
++ }
++ }
++ break;
++ # if QT_CONFIG(wheelevent)
++ case QEvent::Wheel: {
++ const QWheelEvent *we = static_cast<const QWheelEvent *>(e);
++ dbg << "QWheelEvent(" << we->phase();
++ if (!we->pixelDelta().isNull() || !we->angleDelta().isNull())
++ dbg << ", pixelDelta=" << we->pixelDelta() << ", angleDelta=" << we->angleDelta();
++ dbg << " dev=" << we->device() << ')';
++ dbg << ')';
++ }
++ break;
++ # endif // QT_CONFIG(wheelevent)
++ case QEvent::KeyPress:
++ case QEvent::KeyRelease:
++ case QEvent::ShortcutOverride:
++ {
++ const QKeyEvent *ke = static_cast<const QKeyEvent *>(e);
++ dbg << "QKeyEvent(";
++ QtDebugUtils::formatQEnum(dbg, type);
++ dbg << ", ";
++ QtDebugUtils::formatQEnum(dbg, static_cast<Qt::Key>(ke->key()));
++ QtDebugUtils::formatNonNullQFlags(dbg, ", ", ke->modifiers());
++ if (!ke->text().isEmpty())
++ dbg << ", text=" << ke->text();
++ if (ke->isAutoRepeat())
++ dbg << ", autorepeat, count=" << ke->count();
++ if (dbg.verbosity() > QDebug::DefaultVerbosity) {
++ dbg << ", nativeScanCode=" << ke->nativeScanCode();
++ dbg << ", nativeVirtualKey=" << ke->nativeVirtualKey();
++ }
++ dbg << ')';
++ }
++ break;
++ #if QT_CONFIG(shortcut)
++ case QEvent::Shortcut: {
++ const QShortcutEvent *se = static_cast<const QShortcutEvent *>(e);
++ dbg << "QShortcutEvent(" << se->key().toString() << ", id=" << se->shortcutId();
++ if (se->isAmbiguous())
++ dbg << ", ambiguous";
++ dbg << ')';
++ }
++ break;
++ #endif
++ case QEvent::FocusAboutToChange:
++ case QEvent::FocusIn:
++ case QEvent::FocusOut:
++ dbg << "QFocusEvent(";
++ QtDebugUtils::formatQEnum(dbg, type);
++ dbg << ", ";
++ QtDebugUtils::formatQEnum(dbg, static_cast<const QFocusEvent *>(e)->reason());
++ dbg << ')';
++ break;
++ case QEvent::Move: {
++ const QMoveEvent *me = static_cast<const QMoveEvent *>(e);
++ dbg << "QMoveEvent(";
++ QtDebugUtils::formatQPoint(dbg, me->pos());
++ if (!me->spontaneous())
++ dbg << ", non-spontaneous";
++ dbg << ')';
++ }
++ break;
++ case QEvent::Resize: {
++ const QResizeEvent *re = static_cast<const QResizeEvent *>(e);
++ dbg << "QResizeEvent(";
++ QtDebugUtils::formatQSize(dbg, re->size());
++ if (!re->spontaneous())
++ dbg << ", non-spontaneous";
++ dbg << ')';
++ }
++ break;
++ # if QT_CONFIG(draganddrop)
++ case QEvent::DragEnter:
++ case QEvent::DragMove:
++ case QEvent::Drop:
++ formatDropEvent(dbg, static_cast<const QDropEvent *>(e));
++ break;
++ # endif // QT_CONFIG(draganddrop)
++ case QEvent::InputMethod:
++ formatInputMethodEvent(dbg, static_cast<const QInputMethodEvent *>(e));
++ break;
++ case QEvent::InputMethodQuery:
++ formatInputMethodQueryEvent(dbg, static_cast<const QInputMethodQueryEvent *>(e));
++ break;
++ case QEvent::TouchBegin:
++ case QEvent::TouchUpdate:
++ case QEvent::TouchEnd:
++ formatTouchEvent(dbg, *static_cast<const QTouchEvent*>(e));
++ break;
++ case QEvent::ChildAdded:
++ case QEvent::ChildPolished:
++ case QEvent::ChildRemoved:
++ dbg << "QChildEvent(";
++ QtDebugUtils::formatQEnum(dbg, type);
++ dbg << ", " << (static_cast<const QChildEvent*>(e))->child() << ')';
++ break;
++ # ifndef QT_NO_GESTURES
++ case QEvent::NativeGesture: {
++ const QNativeGestureEvent *ne = static_cast<const QNativeGestureEvent *>(e);
++ dbg << "QNativeGestureEvent(";
++ QtDebugUtils::formatQEnum(dbg, ne->gestureType());
++ if (dbg.verbosity() > QDebug::DefaultVerbosity)
++ dbg << ", ts=" << ne->timestamp();
++ dbg << ", fingerCount=" << ne->fingerCount() << ", localPos=";
++ QtDebugUtils::formatQPoint(dbg, ne->position());
++ if (!qIsNull(ne->value()))
++ dbg << ", value=" << ne->value();
++ if (!ne->delta().isNull()) {
++ dbg << ", delta=";
++ QtDebugUtils::formatQPoint(dbg, ne->delta());
++ }
++ dbg << ')';
++ }
++ break;
++ # endif // !QT_NO_GESTURES
++ case QEvent::ApplicationStateChange:
++ dbg << "QApplicationStateChangeEvent(";
++ QtDebugUtils::formatQEnum(dbg, static_cast<const QApplicationStateChangeEvent *>(e)->applicationState());
++ dbg << ')';
++ break;
++ # ifndef QT_NO_CONTEXTMENU
++ case QEvent::ContextMenu:
++ dbg << "QContextMenuEvent(" << static_cast<const QContextMenuEvent *>(e)->pos() << ')';
++ break;
++ # endif // !QT_NO_CONTEXTMENU
++ # if QT_CONFIG(tabletevent)
++ case QEvent::TabletEnterProximity:
++ case QEvent::TabletLeaveProximity:
++ case QEvent::TabletPress:
++ case QEvent::TabletMove:
++ case QEvent::TabletRelease:
++ formatTabletEvent(dbg, static_cast<const QTabletEvent *>(e));
++ break;
++ # endif // QT_CONFIG(tabletevent)
++ case QEvent::Enter:
++ dbg << "QEnterEvent(" << static_cast<const QEnterEvent *>(e)->position() << ')';
++ break;
++ case QEvent::Timer:
++ dbg << "QTimerEvent(id=" << static_cast<const QTimerEvent *>(e)->timerId() << ')';
++ break;
++ case QEvent::PlatformSurface:
++ dbg << "QPlatformSurfaceEvent(surfaceEventType=";
++ switch (static_cast<const QPlatformSurfaceEvent *>(e)->surfaceEventType()) {
++ case QPlatformSurfaceEvent::SurfaceCreated:
++ dbg << "SurfaceCreated";
++ break;
++ case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
++ dbg << "SurfaceAboutToBeDestroyed";
++ break;
++ }
++ dbg << ')';
++ break;
++ case QEvent::ScrollPrepare: {
++ const QScrollPrepareEvent *se = static_cast<const QScrollPrepareEvent *>(e);
++ dbg << "QScrollPrepareEvent(viewportSize=" << se->viewportSize()
++ << ", contentPosRange=" << se->contentPosRange()
++ << ", contentPos=" << se->contentPos() << ')';
++ }
++ break;
++ case QEvent::Scroll: {
++ const QScrollEvent *se = static_cast<const QScrollEvent *>(e);
++ dbg << "QScrollEvent(contentPos=" << se->contentPos()
++ << ", overshootDistance=" << se->overshootDistance()
++ << ", scrollState=" << se->scrollState() << ')';
++ }
++ break;
++ default:
++ dbg << eventClassName(type) << '(';
++ QtDebugUtils::formatQEnum(dbg, type);
++ dbg << ", " << (const void *)e << ')';
++ break;
++ }
++ return dbg;
++ }
++ #endif // !QT_NO_DEBUG_STREAM
++
++ /*!
++ \class QShortcutEvent
++ \brief The QShortcutEvent class provides an event which is generated when
++ the user presses a key combination.
++
++ \ingroup events
++ \inmodule QtGui
++
++ Normally you do not need to use this class directly; QShortcut
++ provides a higher-level interface to handle shortcut keys.
++
++ \sa QShortcut
++ */
++
++ /*!
++ \fn const QKeySequence &QShortcutEvent::key() const
++
++ Returns the key sequence that triggered the event.
++ */
++
++ /*!
++ \fn int QShortcutEvent::shortcutId() const
++
++ \deprecated
++
++ Returns the ID of the QShortcut object for which this event was
++ generated.
++
++ \sa QShortcut::id()
++ */
++
++ /*!
++ \fn bool QShortcutEvent::isAmbiguous() const
++
++ Returns \c true if the key sequence that triggered the event is
++ ambiguous.
++
++ \sa QShortcut::activatedAmbiguously()
++ */
++
++ /*!
++ \class QWindowStateChangeEvent
++ \ingroup events
++ \inmodule QtGui
++
++ \brief The QWindowStateChangeEvent class provides the window state before a
++ window state change.
++ */
++
++ /*! \fn Qt::WindowStates QWindowStateChangeEvent::oldState() const
++
++ Returns the state of the window before the change.
++ */
++
++ /*! \internal
++ */
++ QWindowStateChangeEvent::QWindowStateChangeEvent(Qt::WindowStates oldState, bool isOverride)
++ : QEvent(WindowStateChange), m_oldStates(oldState), m_override(isOverride)
++ {
++ }
++
++ /*! \internal
++ */
++ bool QWindowStateChangeEvent::isOverride() const
++ {
++ return m_override;
++ }
++
++ Q_IMPL_EVENT_COMMON(QWindowStateChangeEvent)
++
++
++ /*!
++ \class QTouchEvent
++ \brief The QTouchEvent class contains parameters that describe a touch event.
++ \since 4.6
++ \ingroup events
++ \ingroup touch
++ \inmodule QtGui
++
++ \section1 Enabling Touch Events
++
++ Touch events occur when pressing, releasing, or moving one or more touch points on a touch
++ device (such as a touch-screen or track-pad). To receive touch events, widgets have to have the
++ Qt::WA_AcceptTouchEvents attribute set and graphics items need to have the
++ \l{QGraphicsItem::setAcceptTouchEvents()}{acceptTouchEvents} attribute set to true.
++
++ When using QAbstractScrollArea based widgets, you should enable the Qt::WA_AcceptTouchEvents
++ attribute on the scroll area's \l{QAbstractScrollArea::viewport()}{viewport}.
++
++ Similarly to QMouseEvent, Qt automatically grabs each touch point on the first press inside a
++ widget, and the widget will receive all updates for the touch point until it is released.
++ Note that it is possible for a widget to receive events for numerous touch points, and that
++ multiple widgets may be receiving touch events at the same time.
++
++ \section1 Event Handling
++
++ All touch events are of type QEvent::TouchBegin, QEvent::TouchUpdate, QEvent::TouchEnd or
++ QEvent::TouchCancel. Reimplement QWidget::event() or QAbstractScrollArea::viewportEvent() for
++ widgets and QGraphicsItem::sceneEvent() for items in a graphics view to receive touch events.
++
++ Unlike widgets, QWindows receive touch events always, there is no need to opt in. When working
++ directly with a QWindow, it is enough to reimplement QWindow::touchEvent().
++
++ The QEvent::TouchUpdate and QEvent::TouchEnd events are sent to the widget or item that
++ accepted the QEvent::TouchBegin event. If the QEvent::TouchBegin event is not accepted and not
++ filtered by an event filter, then no further touch events are sent until the next
++ QEvent::TouchBegin.
++
++ Some systems may send an event of type QEvent::TouchCancel. Upon receiving this event
++ applications are requested to ignore the entire active touch sequence. For example in a
++ composited system the compositor may decide to treat certain gestures as system-wide
++ gestures. Whenever such a decision is made (the gesture is recognized), the clients will be
++ notified with a QEvent::TouchCancel event so they can update their state accordingly.
++
++ The pointCount() and point() functions can be used to access and iterate individual
++ touch points.
++
++ The points() function returns a list of all touch points contained in the event.
++ Note that this list may be empty, for example in case of a QEvent::TouchCancel event.
++ Each point is an instance of the QEventPoint class. The QEventPoint::State enum
++ describes the different states that a touch point may have.
++
++ \note The list of points() will never be partial: A touch event will always contain a touch
++ point for each existing physical touch contacts targeting the window or widget to which the
++ event is sent. For instance, assuming that all touches target the same window or widget, an
++ event with a condition of points().count()==2 is guaranteed to imply that the number of
++ fingers touching the touchscreen or touchpad is exactly two.
++
++ \section1 Event Delivery and Propagation
++
++ By default, QGuiApplication translates the first touch point in a QTouchEvent into
++ a QMouseEvent. This makes it possible to enable touch events on existing widgets that do not
++ normally handle QTouchEvent. See below for information on some special considerations needed
++ when doing this.
++
++ QEvent::TouchBegin is the first touch event sent to a widget. The QEvent::TouchBegin event
++ contains a special accept flag that indicates whether the receiver wants the event. By default,
++ the event is accepted. You should call ignore() if the touch event is not handled by your
++ widget. The QEvent::TouchBegin event is propagated up the parent widget chain until a widget
++ accepts it with accept(), or an event filter consumes it. For QGraphicsItems, the
++ QEvent::TouchBegin event is propagated to items under the mouse (similar to mouse event
++ propagation for QGraphicsItems).
++
++ \section1 Touch Point Grouping
++
++ As mentioned above, it is possible that several widgets can be receiving QTouchEvents at the
++ same time. However, Qt makes sure to never send duplicate QEvent::TouchBegin events to the same
++ widget, which could theoretically happen during propagation if, for example, the user touched 2
++ separate widgets in a QGroupBox and both widgets ignored the QEvent::TouchBegin event.
++
++ To avoid this, Qt will group new touch points together using the following rules:
++
++ \list
++
++ \li When the first touch point is detected, the destination widget is determined firstly by the
++ location on screen and secondly by the propagation rules.
++
++ \li When additional touch points are detected, Qt first looks to see if there are any active
++ touch points on any ancestor or descendent of the widget under the new touch point. If there
++ are, the new touch point is grouped with the first, and the new touch point will be sent in a
++ single QTouchEvent to the widget that handled the first touch point. (The widget under the new
++ touch point will not receive an event).
++
++ \endlist
++
++ This makes it possible for sibling widgets to handle touch events independently while making
++ sure that the sequence of QTouchEvents is always correct.
++
++ \section1 Mouse Events and Touch Event Synthesizing
++
++ QTouchEvent delivery is independent from that of QMouseEvent. The application flags
++ Qt::AA_SynthesizeTouchForUnhandledMouseEvents and Qt::AA_SynthesizeMouseForUnhandledTouchEvents
++ can be used to enable or disable automatic synthesizing of touch events to mouse events and
++ mouse events to touch events.
++
++ \section1 Caveats
++
++ \list
++
++ \li As mentioned above, enabling touch events means multiple widgets can be receiving touch
++ events simultaneously. Combined with the default QWidget::event() handling for QTouchEvents,
++ this gives you great flexibility in designing touch user interfaces. Be aware of the
++ implications. For example, it is possible that the user is moving a QSlider with one finger and
++ pressing a QPushButton with another. The signals emitted by these widgets will be
++ interleaved.
++
++ \li Recursion into the event loop using one of the exec() methods (e.g., QDialog::exec() or
++ QMenu::exec()) in a QTouchEvent event handler is not supported. Since there are multiple event
++ recipients, recursion may cause problems, including but not limited to lost events
++ and unexpected infinite recursion.
++
++ \li QTouchEvents are not affected by a \l{QWidget::grabMouse()}{mouse grab} or an
++ \l{QApplication::activePopupWidget()}{active pop-up widget}. The behavior of QTouchEvents is
++ undefined when opening a pop-up or grabbing the mouse while there are more than one active touch
++ points.
++
++ \endlist
++
++ \sa QEventPoint, QEventPoint::State, Qt::WA_AcceptTouchEvents,
++ QGraphicsItem::acceptTouchEvents()
++ */
++
++ /*!
++ Constructs a QTouchEvent with the given \a eventType, \a device,
++ \a touchPoints, and current keyboard \a modifiers at the time of the event.
++ */
++
++ QTouchEvent::QTouchEvent(QEvent::Type eventType,
++ const QPointingDevice *device,
++ Qt::KeyboardModifiers modifiers,
++ const QList<QEventPoint> &touchPoints)
++ : QPointerEvent(eventType, device, modifiers, touchPoints),
++ m_target(nullptr)
++ {
++ for (QEventPoint &point : m_points) {
++ m_touchPointStates |= point.state();
++ QMutableEventPoint::setDevice(point, device);
++ }
++ }
++
++ #if QT_DEPRECATED_SINCE(6, 0)
++ /*!
++ \deprecated [6.0] Use another constructor.
++
++ Constructs a QTouchEvent with the given \a eventType, \a device, and
++ \a touchPoints. The \a touchPointStates and \a modifiers are the current
++ touch point states and keyboard modifiers at the time of the event.
++ */
++ QTouchEvent::QTouchEvent(QEvent::Type eventType,
++ const QPointingDevice *device,
++ Qt::KeyboardModifiers modifiers,
++ QEventPoint::States touchPointStates,
++ const QList<QEventPoint> &touchPoints)
++ : QPointerEvent(eventType, device, modifiers, touchPoints),
++ m_target(nullptr),
++ m_touchPointStates(touchPointStates)
++ {
++ for (QEventPoint &point : m_points)
++ QMutableEventPoint::setDevice(point, device);
++ }
++ #endif // QT_DEPRECATED_SINCE(6, 0)
++
++ Q_IMPL_POINTER_EVENT(QTouchEvent)
++
++ /*!
++ Returns true if this event includes at least one newly-pressed touchpoint.
++ */
++ bool QTouchEvent::isBeginEvent() const
++ {
++ return m_touchPointStates.testFlag(QEventPoint::State::Pressed);
++ }
++
++ /*!
++ Returns true if this event does not include newly-pressed or newly-released
++ touchpoints.
++ */
++ bool QTouchEvent::isUpdateEvent() const
++ {
++ return !m_touchPointStates.testFlag(QEventPoint::State::Pressed) &&
++ !m_touchPointStates.testFlag(QEventPoint::State::Released);
++ }
++
++ /*!
++ Returns true if this event includes at least one newly-released touchpoint.
++ */
++ bool QTouchEvent::isEndEvent() const
++ {
++ return m_touchPointStates.testFlag(QEventPoint::State::Released);
++ }
++
++ /*! \fn QObject *QTouchEvent::target() const
++
++ Returns the target object within the window on which the event occurred.
++ This is typically a QWidget or a QQuickItem. May be 0 when no specific target is available.
++ */
++
++ /*! \fn QEventPoint::States QTouchEvent::touchPointStates() const
++
++ Returns a bitwise OR of all the touch point states for this event.
++ */
++
++ /*! \fn const QList<QEventPoint> &QTouchEvent::touchPoints() const
++ \deprecated [6.0] Use points() instead.
++
++ Returns a reference to the list of touch points contained in the touch event.
++
++ \sa QPointerEvent::point(), QPointerEvent::pointCount()
++ */
++
++ /*!
++ \class QScrollPrepareEvent
++ \since 4.8
++ \ingroup events
++ \inmodule QtGui
++
++ \brief The QScrollPrepareEvent class is sent in preparation of scrolling.
++
++ The scroll prepare event is sent before scrolling (usually by QScroller) is started.
++ The object receiving this event should set viewportSize, maxContentPos and contentPos.
++ It also should accept this event to indicate that scrolling should be started.
++
++ It is not guaranteed that a QScrollEvent will be sent after an accepted
++ QScrollPrepareEvent, e.g. in a case where the maximum content position is (0, 0).
++
++ \sa QScrollEvent, QScroller
++ */
++
++ /*!
++ Creates new QScrollPrepareEvent
++ The \a startPos is the position of a touch or mouse event that started the scrolling.
++ */
++ QScrollPrepareEvent::QScrollPrepareEvent(const QPointF &startPos)
++ : QEvent(QEvent::ScrollPrepare), m_startPos(startPos)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QScrollPrepareEvent)
++
++ /*!
++ \fn QPointF QScrollPrepareEvent::startPos() const
++
++ Returns the position of the touch or mouse event that started the scrolling.
++ */
++
++ /*!
++ \fn QSizeF QScrollPrepareEvent::viewportSize() const
++ Returns size of the area that is to be scrolled as set by setViewportSize
++
++ \sa setViewportSize()
++ */
++
++ /*!
++ \fn QRectF QScrollPrepareEvent::contentPosRange() const
++ Returns the range of coordinates for the content as set by setContentPosRange().
++ */
++
++ /*!
++ \fn QPointF QScrollPrepareEvent::contentPos() const
++ Returns the current position of the content as set by setContentPos.
++ */
++
++ /*!
++ Sets the size of the area that is to be scrolled to \a size.
++
++ \sa viewportSize()
++ */
++ void QScrollPrepareEvent::setViewportSize(const QSizeF &size)
++ {
++ m_viewportSize = size;
++ }
++
++ /*!
++ Sets the range of content coordinates to \a rect.
++
++ \sa contentPosRange()
++ */
++ void QScrollPrepareEvent::setContentPosRange(const QRectF &rect)
++ {
++ m_contentPosRange = rect;
++ }
++
++ /*!
++ Sets the current content position to \a pos.
++
++ \sa contentPos()
++ */
++ void QScrollPrepareEvent::setContentPos(const QPointF &pos)
++ {
++ m_contentPos = pos;
++ }
++
++
++ /*!
++ \class QScrollEvent
++ \since 4.8
++ \ingroup events
++ \inmodule QtGui
++
++ \brief The QScrollEvent class is sent when scrolling.
++
++ The scroll event is sent to indicate that the receiver should be scrolled.
++ Usually the receiver should be something visual like QWidget or QGraphicsObject.
++
++ Some care should be taken that no conflicting QScrollEvents are sent from two
++ sources. Using QScroller::scrollTo is save however.
++
++ \sa QScrollPrepareEvent, QScroller
++ */
++
++ /*!
++ \enum QScrollEvent::ScrollState
++
++ This enum describes the states a scroll event can have.
++
++ \value ScrollStarted Set for the first scroll event of a scroll activity.
++
++ \value ScrollUpdated Set for all but the first and the last scroll event of a scroll activity.
++
++ \value ScrollFinished Set for the last scroll event of a scroll activity.
++
++ \sa QScrollEvent::scrollState()
++ */
++
++ /*!
++ Creates a new QScrollEvent
++ \a contentPos is the new content position, \a overshootDistance is the
++ new overshoot distance while \a scrollState indicates if this scroll
++ event is the first one, the last one or some event in between.
++ */
++ QScrollEvent::QScrollEvent(const QPointF &contentPos, const QPointF &overshootDistance, ScrollState scrollState)
++ : QEvent(QEvent::Scroll), m_contentPos(contentPos), m_overshoot(overshootDistance), m_state(scrollState)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QScrollEvent)
++
++ /*!
++ \fn QPointF QScrollEvent::contentPos() const
++
++ Returns the new scroll position.
++ */
++
++ /*!
++ \fn QPointF QScrollEvent::overshootDistance() const
++
++ Returns the new overshoot distance.
++ See QScroller for an explanation of the term overshoot.
++
++ \sa QScroller
++ */
++
++ /*!
++ \fn QScrollEvent::ScrollState QScrollEvent::scrollState() const
++
++ Returns the current scroll state as a combination of ScrollStateFlag values.
++ ScrollStarted (or ScrollFinished) will be set, if this scroll event is the first (or last) event in a scrolling activity.
++ Please note that both values can be set at the same time, if the activity consists of a single QScrollEvent.
++ All other scroll events in between will have their state set to ScrollUpdated.
++
++ A widget could for example revert selections when scrolling is started and stopped.
++ */
++
++ /*!
++ Creates a new QScreenOrientationChangeEvent
++ \a screenOrientation is the new orientation of the \a screen.
++ */
++ QScreenOrientationChangeEvent::QScreenOrientationChangeEvent(QScreen *screen, Qt::ScreenOrientation screenOrientation)
++ : QEvent(QEvent::OrientationChange), m_screen(screen), m_orientation(screenOrientation)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QScreenOrientationChangeEvent)
++
++ /*!
++ \fn QScreen *QScreenOrientationChangeEvent::screen() const
++
++ Returns the screen whose orientation changed.
++ */
++
++ /*!
++ \fn Qt::ScreenOrientation QScreenOrientationChangeEvent::orientation() const
++
++ Returns the orientation of the screen.
++ */
++
++ /*!
++ Creates a new QApplicationStateChangeEvent.
++ \a applicationState is the new state.
++ */
++ QApplicationStateChangeEvent::QApplicationStateChangeEvent(Qt::ApplicationState applicationState)
++ : QEvent(QEvent::ApplicationStateChange), m_applicationState(applicationState)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QApplicationStateChangeEvent)
++
++ /*!
++ \fn Qt::ApplicationState QApplicationStateChangeEvent::applicationState() const
++
++ Returns the state of the application.
++ */
++
++ /*!
++ \class QChildWindowEvent
++ \inmodule QtGui
++ \since 6.7
++ \brief The QChildWindowEvent class contains event parameters for
++ child window changes.
++
++ \ingroup events
++
++ Child window events are sent to windows when children are
++ added or removed.
++
++ In both cases you can only rely on the child being a QWindow
++ — not any subclass thereof. This is because in the
++ QEvent::ChildWindowAdded case the subclass is not yet fully
++ constructed, and in the QEvent::ChildWindowRemoved case it
++ might have already been destructed.
++ */
++
++ /*!
++ Constructs a child window event object of a particular \a type
++ for the \a childWindow.
++
++ \a type can be QEvent::ChildWindowAdded or QEvent::ChildWindowRemoved.
++
++ \sa child()
++ */
++ QChildWindowEvent::QChildWindowEvent(Type type, QWindow *childWindow)
++ : QEvent(type), c(childWindow)
++ {
++ }
++
++ Q_IMPL_EVENT_COMMON(QChildWindowEvent)
++
++ /*!
++ \fn QWindow *QChildWindowEvent::child() const
++
++ Returns the child window that was added or removed.
++ */
++
++ QMutableTouchEvent::~QMutableTouchEvent()
++ = default;
++
++ /*! \internal
++ Add the given \a point.
++ */
++ void QMutableTouchEvent::addPoint(QTouchEvent *e, const QEventPoint &point)
++ {
++ e->m_points.append(point);
++ auto &added = e->m_points.last();
++ if (!added.device())
++ QMutableEventPoint::setDevice(added, e->pointingDevice());
++ e->m_touchPointStates |= point.state();
++ }
++
++
++ QMutableSinglePointEvent::~QMutableSinglePointEvent()
++ = default;
++
++ /*! \internal
++ Add the given \a point.
++ */
++ void QMutableTouchEvent::addPoint(const QEventPoint &point)
++ {
++ addPoint(this, point);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qevent.cpp"