qevent_p.h

Go to the documentation of this file.

// 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
 
#ifndef QEVENT_P_H
#define QEVENT_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of other Qt classes. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include <QtGui/private/qtguiglobal_p.h>
#include <QtCore/qurl.h>
#include <QtGui/qevent.h>
#include <QtGui/qwindow.h>
 
QT_BEGIN_NAMESPACE
 
class QPointingDevice;
 
/*!
    \internal
    \since 6.9
 
    This class provides a way to store copies of QEvents. QEvents can otherwise
    only be copied by \l{QEvent::clone()}{cloning}, which allocates the copy on
    the heap. By befriending concrete QEvent subclasses, QEventStorage gains
    access to their protected copy constructors.
 
    It is similar to std::optional, but with a more targeted API.
 
    Note that by storing an event in QEventStorage, it may be sliced.
*/
template <typename Event>
class QEventStorage
{
    Q_DISABLE_COPY_MOVE(QEventStorage)
    static_assert(std::is_base_of_v<QEvent, Event>);
    union {
        char m_eventNotSet; // could be std::monostate, but don't want to pay for <variant> include
        Event m_event;
    };
    bool m_engaged = false;
 
    void engage(const Event &e)
    {
        Q_ASSERT(!m_engaged);
        new (&m_event) Event(e);
        m_engaged = true;
    }
 
    void disengage()
    {
        Q_ASSERT(m_engaged);
        m_event.~Event();
        m_engaged = false;
    }
 
public:
    QEventStorage() noexcept : m_eventNotSet{} {}
    explicit QEventStorage(const Event &e)
    {
        engage(e);
    }
 
    ~QEventStorage()
    {
        if (m_engaged)
            disengage();
    }
 
    explicit operator bool() const noexcept { return m_engaged; }
    bool operator!() const noexcept { return !m_engaged; }
 
    Event &store(const Event &e)
    {
        if (m_engaged)
            disengage();
        engage(e);
        return m_event;
    }
 
    Event &storeUnlessAlias(const Event &e)
    {
        if (m_engaged && &e == &m_event)
            return m_event;
        return store(e);
    }
 
    const Event &operator*() const
    {
        Q_PRE(m_engaged);
        return m_event;
    }
 
    Event &operator*()
    {
        Q_PRE(m_engaged);
        return m_event;
    }
 
    const Event *operator->() const
    {
        Q_PRE(m_engaged);
        return &m_event;
    }
 
    Event *operator->()
    {
        Q_PRE(m_engaged);
        return &m_event;
    }
};
 
class Q_GUI_EXPORT QMutableTouchEvent : public QTouchEvent
{
public:
    QMutableTouchEvent(QEvent::Type eventType = QEvent::TouchBegin,
                       const QPointingDevice *device = nullptr,
                       Qt::KeyboardModifiers modifiers = Qt::NoModifier,
                       const QList<QEventPoint> &touchPoints = QList<QEventPoint>()) :
        QTouchEvent(eventType, device, modifiers, touchPoints) { }
    ~QMutableTouchEvent() override;
 
    void setTarget(QObject *target) { m_target = target; }
    void addPoint(const QEventPoint &point);
 
    static void setTarget(QTouchEvent *e, QObject *target) { e->m_target = target; }
    static void addPoint(QTouchEvent *e, const QEventPoint &point);
};
 
class Q_GUI_EXPORT QMutableSinglePointEvent : public QSinglePointEvent
{
public:
    QMutableSinglePointEvent(const QSinglePointEvent &other) : QSinglePointEvent(other) {}
    QMutableSinglePointEvent(Type type = QEvent::None, const QPointingDevice *device = nullptr, const QEventPoint &point = QEventPoint(),
                             Qt::MouseButton button = Qt::NoButton, Qt::MouseButtons buttons = Qt::NoButton,
                             Qt::KeyboardModifiers modifiers = Qt::NoModifier,
                             Qt::MouseEventSource source = Qt::MouseEventSynthesizedByQt) :
        QSinglePointEvent(type, device, point, button, buttons, modifiers, source) { }
    ~QMutableSinglePointEvent() override;
 
    void setSource(Qt::MouseEventSource s) { m_source = s; }
 
    bool isDoubleClick() { return m_doubleClick; }
 
    void setDoubleClick(bool d = true) { m_doubleClick = d; }
 
    static bool isDoubleClick(const QSinglePointEvent *ev)
    {
        return ev->m_doubleClick;
    }
 
    static void setDoubleClick(QSinglePointEvent *ev, bool d)
    {
        ev->m_doubleClick = d;
    }
};
 
QT_END_NAMESPACE
 
#endif // QEVENT_P_H