qevent.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2020 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
#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"
 
#if QT_CONFIG(draganddrop)
#include <qpa/qplatformdrag.h>
#include <private/qdnd_p.h>
#endif
 
#include <private/qdebug_p.h>
 
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));
 
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)
{
}
 
QEnterEvent::~QEnterEvent()
{
}
 
QInputEvent::QInputEvent(Type type, const QInputDevice *dev, Qt::KeyboardModifiers modifiers)
    : QEvent(type, QEvent::InputEventTag{}), m_dev(dev), m_modState(modifiers), m_reserved(0)
{}
 
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)
{}
 
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)
{}
 
QInputEvent::~QInputEvent()
{
}
 
QEventPoint &QPointerEvent::point(qsizetype i)
{
    return m_points[i];
}
 
QPointerEvent::QPointerEvent(QEvent::Type type, const QPointingDevice *dev,
                             Qt::KeyboardModifiers modifiers, const QList<QEventPoint> &points)
    : QInputEvent(type, QEvent::PointerEventTag{}, dev, modifiers), m_points(points)
{
}
 
QPointerEvent::QPointerEvent(QEvent::Type type, QEvent::SinglePointEventTag, const QInputDevice *dev, Qt::KeyboardModifiers modifiers)
    : QInputEvent(type, QEvent::SinglePointEventTag{}, dev, modifiers)
{
}
 
QPointerEvent::~QPointerEvent()
{
}
 
QEventPoint *QPointerEvent::pointById(int id)
{
    for (auto &p : m_points) {
        if (p.id() == id)
            return &p;
    }
    return nullptr;
}
 
bool QPointerEvent::allPointsGrabbed() const
{
    for (const auto &p : points()) {
        if (exclusiveGrabber(p) && passiveGrabbers(p).isEmpty())
            return false;
    }
    return true;
}
 
bool QPointerEvent::allPointsAccepted() const
{
    for (const auto &p : points()) {
        if (!p.isAccepted())
            return false;
    }
    return true;
}
 
void QPointerEvent::setAccepted(bool accepted)
{
    QEvent::setAccepted(accepted);
    for (auto &p : m_points)
        p.setAccepted(accepted);
}
 
const QPointingDevice *QPointerEvent::pointingDevice() const
{
    return static_cast<const QPointingDevice *>(m_dev);
}
 
void QPointerEvent::setTimestamp(quint64 timestamp)
{
    QInputEvent::setTimestamp(timestamp);
    for (auto &p : m_points)
        QMutableEventPoint::setTimestamp(p, timestamp);
}
 
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;
}
 
void QPointerEvent::setExclusiveGrabber(const QEventPoint &point, QObject *exclusiveGrabber)
{
    Q_ASSERT(pointingDevice());
    auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice()));
    devPriv->setExclusiveGrabber(this, point, exclusiveGrabber);
}
 
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;
}
 
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);
}
 
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);
}
 
void QPointerEvent::clearPassiveGrabbers(const QEventPoint &point)
{
    Q_ASSERT(pointingDevice());
    auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice()));
    devPriv->clearPassiveGrabbers(this, point);
}
 
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)
{
    bool isPress = (button != Qt::NoButton && (button | buttons) == buttons);
    bool isWheel = (type == QEvent::Type::Wheel);
    auto devPriv = QPointingDevicePrivate::get(const_cast<QPointingDevice *>(pointingDevice()));
    auto epd = devPriv->pointById(0);
    QEventPoint &p = epd->eventPoint;
    Q_ASSERT(p.device() == dev);
    // p is a reference to a non-detached instance that lives in QPointingDevicePrivate::activePoints.
    // Update persistent info in that instance.
    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);
    // Now detach, and update the detached instance with ephemeral state.
    QMutableEventPoint::detach(p);
    QMutableEventPoint::setPosition(p, localPos);
    m_points.append(p);
}
 
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;
}
 
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;
}
 
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;
}
 
bool QSinglePointEvent::isEndEvent() const
{
    return m_button != Qt::NoButton && !m_mouseState.testFlag(m_button);
}
 
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)
{
}
 
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)
{
}
 
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)
{
}
 
QMouseEvent::~QMouseEvent()
{
}
 
#if QT_DEPRECATED_SINCE(6, 0)
Qt::MouseEventSource QMouseEvent::source() const
{
    return Qt::MouseEventSource(m_source);
}
#endif
 
Qt::MouseEventFlags QMouseEvent::flags() const
{
    return (m_doubleClick ? Qt::MouseEventCreatedDoubleClick : Qt::NoMouseEventFlag);
}
 
QHoverEvent::QHoverEvent(Type type, const QPointF &pos, const QPointF &globalPos, const QPointF &oldPos,
                         Qt::KeyboardModifiers modifiers, const QPointingDevice *device)
    : QSinglePointEvent(type, device, pos, pos, globalPos, Qt::NoButton, Qt::NoButton, modifiers), m_oldPos(oldPos)
{
}
 
#if QT_DEPRECATED_SINCE(6, 3)
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
 
QHoverEvent::~QHoverEvent()
{
}
 
#if QT_CONFIG(wheelevent)
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;
}
 
QWheelEvent::~QWheelEvent()
{
}
 
bool QWheelEvent::isBeginEvent() const
{
    return m_phase == Qt::ScrollBegin;
}
 
bool QWheelEvent::isUpdateEvent() const
{
    return m_phase == Qt::ScrollUpdate || m_phase == Qt::ScrollMomentum;
}
 
bool QWheelEvent::isEndEvent() const
{
    return m_phase == Qt::ScrollEnd;
}
 
#endif // QT_CONFIG(wheelevent)
 
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();
}
 
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();
}
 
 
QKeyEvent::~QKeyEvent()
{
}
 
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();
}
 
#if QT_CONFIG(shortcut)
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)
 
 
QFocusEvent::QFocusEvent(Type type, Qt::FocusReason reason)
    : QEvent(type), m_reason(reason)
{}
 
QFocusEvent::~QFocusEvent()
{
}
 
Qt::FocusReason QFocusEvent::reason() const
{
    return m_reason;
}
 
QPaintEvent::QPaintEvent(const QRegion& paintRegion)
    : QEvent(Paint), m_rect(paintRegion.boundingRect()), m_region(paintRegion), m_erased(false)
{}
 
QPaintEvent::QPaintEvent(const QRect &paintRect)
    : QEvent(Paint), m_rect(paintRect),m_region(paintRect), m_erased(false)
{}
 
 
QPaintEvent::~QPaintEvent()
{
}
 
QMoveEvent::QMoveEvent(const QPoint &pos, const QPoint &oldPos)
    : QEvent(Move), m_pos(pos), m_oldPos(oldPos)
{}
 
QMoveEvent::~QMoveEvent()
{
}
 
QExposeEvent::QExposeEvent(const QRegion &exposeRegion)
    : QEvent(Expose)
    , m_region(exposeRegion)
{
}
 
QExposeEvent::~QExposeEvent()
{
}
 
QPlatformSurfaceEvent::QPlatformSurfaceEvent(SurfaceEventType surfaceEventType)
    : QEvent(PlatformSurface)
    , m_surfaceEventType(surfaceEventType)
{
}
 
QPlatformSurfaceEvent::~QPlatformSurfaceEvent()
{
}
 
QResizeEvent::QResizeEvent(const QSize &size, const QSize &oldSize)
    : QEvent(Resize), m_size(size), m_oldSize(oldSize)
{}
 
QResizeEvent::~QResizeEvent()
{
}
 
QCloseEvent::QCloseEvent()
    : QEvent(Close)
{}
 
QCloseEvent::~QCloseEvent()
{
}
 
QIconDragEvent::QIconDragEvent()
    : QEvent(IconDrag)
{ ignore(); }
 
QIconDragEvent::~QIconDragEvent()
{
}
 
#ifndef QT_NO_CONTEXTMENU
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)
{}
 
 
QContextMenuEvent::~QContextMenuEvent()
{
}
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 // QT_NO_CONTEXTMENU
 
QInputMethodEvent::QInputMethodEvent()
    : QEvent(QEvent::InputMethod), m_replacementStart(0), m_replacementLength(0)
{
}
 
QInputMethodEvent::QInputMethodEvent(const QString &preeditText, const QList<Attribute> &attributes)
    : QEvent(QEvent::InputMethod), m_preedit(preeditText), m_attributes(attributes),
      m_replacementStart(0), m_replacementLength(0)
{
}
 
QInputMethodEvent::~QInputMethodEvent()
{
}
 
void QInputMethodEvent::setCommitString(const QString &commitString, int replaceFrom, int replaceLength)
{
    m_commit = commitString;
    m_replacementStart = replaceFrom;
    m_replacementLength = replaceLength;
}
 
QInputMethodQueryEvent::QInputMethodQueryEvent(Qt::InputMethodQueries queries)
    : QEvent(InputMethodQuery),
      m_queries(queries)
{
}
 
QInputMethodQueryEvent::~QInputMethodQueryEvent()
{
}
 
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);
}
 
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)
 
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);
}
 
QTabletEvent::~QTabletEvent()
{
}
 
#endif // QT_CONFIG(tabletevent)
 
#ifndef QT_NO_GESTURES
#if QT_DEPRECATED_SINCE(6, 2)
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
 
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
}
 
QNativeGestureEvent::~QNativeGestureEvent() = default;
 
#endif // QT_NO_GESTURES
 
#if QT_CONFIG(draganddrop)
QDragMoveEvent::QDragMoveEvent(const QPoint& 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, QSize(1, 1))
{}
 
QDragMoveEvent::~QDragMoveEvent()
{
}
 
// ### pos is in which coordinate system?
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();
}
 
QDropEvent::~QDropEvent()
{
}
 
 
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;
}
 
QDragEnterEvent::QDragEnterEvent(const QPoint& point, Qt::DropActions actions, const QMimeData *data,
                                 Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
    : QDragMoveEvent(point, actions, data, buttons, modifiers, DragEnter)
{}
 
QDragEnterEvent::~QDragEnterEvent()
{
}
 
QDragLeaveEvent::QDragLeaveEvent()
    : QEvent(DragLeave)
{}
 
QDragLeaveEvent::~QDragLeaveEvent()
{
}
#endif // QT_CONFIG(draganddrop)
 
QHelpEvent::QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos)
    : QEvent(type), m_pos(pos), m_globalPos(globalPos)
{}
 
QHelpEvent::~QHelpEvent()
{
}
 
#ifndef QT_NO_STATUSTIP
 
QStatusTipEvent::QStatusTipEvent(const QString &tip)
    : QEvent(StatusTip), m_tip(tip)
{}
 
QStatusTipEvent::~QStatusTipEvent()
{
}
 
#endif // QT_NO_STATUSTIP
 
#if QT_CONFIG(whatsthis)
 
QWhatsThisClickedEvent::QWhatsThisClickedEvent(const QString &href)
    : QEvent(WhatsThisClicked), m_href(href)
{}
 
QWhatsThisClickedEvent::~QWhatsThisClickedEvent()
{
}
 
#endif // QT_CONFIG(whatsthis)
 
#ifndef QT_NO_ACTION
 
QActionEvent::QActionEvent(int type, QAction *action, QAction *before)
    : QEvent(static_cast<QEvent::Type>(type)), m_action(action), m_before(before)
{}
 
QActionEvent::~QActionEvent()
{
}
 
#endif // QT_NO_ACTION
 
QHideEvent::QHideEvent()
    : QEvent(Hide)
{}
 
QHideEvent::~QHideEvent()
{
}
 
QShowEvent::QShowEvent()
    : QEvent(Show)
{}
 
QShowEvent::~QShowEvent()
{
}
 
QFileOpenEvent::QFileOpenEvent(const QString &file)
    : QEvent(FileOpen), m_file(file), m_url(QUrl::fromLocalFile(file))
{
}
 
QFileOpenEvent::QFileOpenEvent(const QUrl &url)
    : QEvent(FileOpen), m_file(url.toLocalFile()), m_url(url)
{
}
 
 
QFileOpenEvent::~QFileOpenEvent()
{
}
 
bool QFileOpenEvent::openFile(QFile &file, QIODevice::OpenMode flags) const
{
    file.setFileName(m_file);
    return file.open(flags);
}
 
#ifndef QT_NO_TOOLBAR
QToolBarChangeEvent::QToolBarChangeEvent(bool t)
    : QEvent(ToolBarChange), m_toggle(t)
{}
 
QToolBarChangeEvent::~QToolBarChangeEvent()
{
}
 
/*
    \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)
 
QShortcutEvent::QShortcutEvent(const QKeySequence &key, int id, bool ambiguous)
    : QEvent(Shortcut), m_sequence(key), m_shortcutId(id), m_ambiguous(ambiguous)
{
}
 
QShortcutEvent::~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 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();
    }
    if (const int attributeCount = e->attributes().size()) {
        d << ", attributes= {";
        for (int a = 0; a < attributeCount; ++a) {
            const QInputMethodEvent::Attribute &at = e->attributes().at(a);
            if (a)
                d << ',';
            d << "[type= " << at.type << ", start=" << at.start << ", length=" << at.length
              << ", value=" << at.value << ']';
        }
        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) {
        dbg << "QEventPoint(0x0)";
        return dbg;
    }
    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) {
        dbg << "QEvent(this = 0x0)";
        return dbg;
    }
    // More useful event output could be added here
    const QEvent::Type type = e->type();
    bool isMouse = false;
    switch (type) {
    case QEvent::Expose:
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
        dbg << "QExposeEvent(" << static_cast<const QExposeEvent *>(e)->region() << ')';
QT_WARNING_POP
        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 (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 << ')';
    }
        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();
        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());
        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
 
QWindowStateChangeEvent::QWindowStateChangeEvent(Qt::WindowStates oldState, bool isOverride)
    : QEvent(WindowStateChange), m_oldStates(oldState), m_override(isOverride)
{
}
 
bool QWindowStateChangeEvent::isOverride() const
{
    return m_override;
}
 
QWindowStateChangeEvent::~QWindowStateChangeEvent()
{
}
 
 
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);
    }
}
 
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);
}
 
QTouchEvent::~QTouchEvent()
{ }
 
bool QTouchEvent::isBeginEvent() const
{
    return m_touchPointStates.testFlag(QEventPoint::State::Pressed);
}
 
bool QTouchEvent::isUpdateEvent() const
{
    return !m_touchPointStates.testFlag(QEventPoint::State::Pressed) &&
           !m_touchPointStates.testFlag(QEventPoint::State::Released);
}
 
bool QTouchEvent::isEndEvent() const
{
    return m_touchPointStates.testFlag(QEventPoint::State::Released);
}
 
QScrollPrepareEvent::QScrollPrepareEvent(const QPointF &startPos)
    : QEvent(QEvent::ScrollPrepare), m_startPos(startPos)
{
}
 
QScrollPrepareEvent::~QScrollPrepareEvent()
{
}
 
void QScrollPrepareEvent::setViewportSize(const QSizeF &size)
{
    m_viewportSize = size;
}
 
void QScrollPrepareEvent::setContentPosRange(const QRectF &rect)
{
    m_contentPosRange = rect;
}
 
void QScrollPrepareEvent::setContentPos(const QPointF &pos)
{
    m_contentPos = pos;
}
 
 
QScrollEvent::QScrollEvent(const QPointF &contentPos, const QPointF &overshootDistance, ScrollState scrollState)
    : QEvent(QEvent::Scroll), m_contentPos(contentPos), m_overshoot(overshootDistance), m_state(scrollState)
{
}
 
QScrollEvent::~QScrollEvent()
{
}
 
QScreenOrientationChangeEvent::QScreenOrientationChangeEvent(QScreen *screen, Qt::ScreenOrientation screenOrientation)
    : QEvent(QEvent::OrientationChange), m_screen(screen), m_orientation(screenOrientation)
{
}
 
QScreenOrientationChangeEvent::~QScreenOrientationChangeEvent()
{
}
 
QApplicationStateChangeEvent::QApplicationStateChangeEvent(Qt::ApplicationState applicationState)
    : QEvent(QEvent::ApplicationStateChange), m_applicationState(applicationState)
{
}
 
QMutableTouchEvent::~QMutableTouchEvent()
    = default;
 
void QMutableTouchEvent::addPoint(const QEventPoint &point)
{
    m_points.append(point);
    auto &added = m_points.last();
    if (!added.device())
        QMutableEventPoint::setDevice(added, pointingDevice());
    m_touchPointStates |= point.state();
}
 
 
QMutableSinglePointEvent::~QMutableSinglePointEvent()
    = default;
 
QT_END_NAMESPACE
 
#include "moc_qevent.cpp"