// 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

#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