event.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_EVENT_H
#define EGT_EVENT_H
 
#include <egt/detail/meta.h>
#include <egt/flags.h>
#include <egt/geometry.h>
#include <egt/keycode.h>
#include <iosfwd>
 
namespace egt
{
inline namespace v1
{
 
enum class EventId
{
    none = detail::bit(0),
 
 
    raw_pointer_down = detail::bit(1),
    raw_pointer_up = detail::bit(2),
    raw_pointer_move = detail::bit(3),
 
 
    pointer_click = detail::bit(4),
    pointer_dblclick = detail::bit(5),
    pointer_hold = detail::bit(6),
    pointer_drag_start = detail::bit(7),
    pointer_drag = detail::bit(8),
    pointer_drag_stop = detail::bit(9),
 
 
    keyboard_down = detail::bit(10),
    keyboard_up = detail::bit(11),
    keyboard_repeat = detail::bit(12),
};
 
EGT_API std::ostream& operator<<(std::ostream& os, const EventId& event);
 
struct EGT_API Pointer
{
    enum class Button
    {
        none,
        left,
        middle,
        right
    };
 
    constexpr Pointer() noexcept = default;
 
    constexpr explicit Pointer(const DisplayPoint& p, size_t s = 0) noexcept
        : point(p),
          slot(s)
    {}
 
    constexpr Pointer(const DisplayPoint& p, Button b, size_t s = 0) noexcept
        : point(p),
          btn(b),
          slot(s)
    {}
 
    constexpr Pointer(const DisplayPoint& p,
                      const DisplayPoint& d,
                      size_t s = 0) noexcept
        : point(p),
          drag_start(d),
          slot(s)
    {}
 
    EGT_NODISCARD DisplayPoint delta() const
    {
        return point - drag_start;
    }
 
    DisplayPoint point;
 
    Button btn{Button::none};
 
    DisplayPoint drag_start;
 
    size_t slot{};
};
 
static_assert(detail::rule_of_5<Pointer>(), "must fulfill rule of 5");
 
EGT_API std::ostream& operator<<(std::ostream& os, const Pointer::Button& btn);
EGT_API std::ostream& operator<<(std::ostream& os, const Pointer& pointer);
 
struct EGT_API Key
{
    enum class KeyMod : uint32_t
    {
        shift = detail::bit(0),
        control = detail::bit(1),
        lock = detail::bit(2),
    };
 
    using KeyState = egt::Flags<KeyMod>;
 
    constexpr Key() noexcept = default;
 
    constexpr explicit Key(KeyboardCode k, uint32_t u = 0, const KeyState& s = {}) noexcept
        : keycode(k),
          unicode(u),
          state(s)
    {}
 
    KeyboardCode keycode{EKEY_UNKNOWN};
 
    uint32_t unicode{0};
 
    KeyState state{};
};
 
static_assert(detail::rule_of_5<Key>(), "must fulfill rule of 5");
 
EGT_API std::ostream& operator<<(std::ostream& os, const Key& key);
 
class EventArg
{
public:
 
    void stop()
    {
        m_stop = true;
    }
 
    EGT_NODISCARD bool quit() const
    {
        return m_stop;
    }
 
protected:
 
    bool m_stop{false};
};
 
class Widget;
 
struct EGT_API Event : public EventArg
{
    constexpr Event() noexcept = default;
 
    constexpr explicit Event(EventId id) noexcept
        : m_id(id)
    {}
 
    constexpr Event(EventId id, const Pointer& pointer) noexcept
        : m_id(id),
          m_pointer(pointer)
    {}
 
    constexpr Event(EventId id, const Key& key) noexcept
        : m_id(id),
          m_key(key)
    {}
 
    EGT_NODISCARD const EventId& id() const noexcept
    {
        return m_id;
    }
 
    void id(EventId id)
    {
        m_id = id;
    }
 
    Pointer& pointer()
    {
        return m_pointer;
    }
 
    EGT_NODISCARD const Pointer& pointer() const
    {
        return m_pointer;
    }
 
    Key& key()
    {
        return m_key;
    }
 
    EGT_NODISCARD const Key& key() const
    {
        return m_key;
    };
 
    void grab(Widget* widget);
 
    void postpone_stop()
    {
        m_postponed_stop = true;
    }
 
    EGT_NODISCARD bool postponed_quit() const
    {
        return m_postponed_stop;
    }
 
protected:
 
    EventId m_id{EventId::none};
 
    Key m_key;
 
    Pointer m_pointer;
 
    bool m_postponed_stop{false};
};
 
static_assert(detail::rule_of_5<Event>(), "must fulfill rule of 5");
 
EGT_API std::ostream& operator<<(std::ostream& os, const Event& event);
 
}
}
 
#endif