WindowEventSource.cpp

Go to the documentation of this file.

#include "WindowEventSource.hpp"
 
#include "MayaFlux/Kriya/Awaiters/EventAwaiter.hpp"
 
namespace MayaFlux::Vruta {
 
void WindowEventSource::signal(Core::WindowEvent event)
{
    if (auto* kd = std::get_if<Core::WindowEvent::KeyData>(&event.data)) {
        if (event.type == Core::WindowEventType::KEY_PRESSED) {
            m_key_states[kd->key] = true;
        } else if (event.type == Core::WindowEventType::KEY_RELEASED) {
            m_key_states[kd->key] = false;
        }
    }
 
    if (auto* bd = std::get_if<Core::WindowEvent::MouseButtonData>(&event.data)) {
        if (event.type == Core::WindowEventType::MOUSE_BUTTON_PRESSED) {
            m_button_states[bd->button] = true;
        } else if (event.type == Core::WindowEventType::MOUSE_BUTTON_RELEASED) {
            m_button_states[bd->button] = false;
        }
    }
 
    if (auto* pd = std::get_if<Core::WindowEvent::MousePosData>(&event.data)) {
        m_mouse_x = pd->x;
        m_mouse_y = pd->y;
    }
 
    const size_t resumed_before = m_resumed;
    ++m_signal_depth;
    dispatch(&event);
    --m_signal_depth;
    if (m_resumed == resumed_before) {
        m_pending_events.push_back(event);
        auto& held = m_pending_counts[static_cast<uint8_t>(event.type)];
        if (++held > k_max_pending_events) {
            auto oldest = std::ranges::find(m_pending_events, event.type, &Core::WindowEvent::type);
            m_pending_events.erase(oldest);
            --held;
        }
    }
 
    if (m_signal_depth != 0 || m_deferred_actions.empty())
        return;
 
    std::vector<std::function<void()>> deferred_actions;
    deferred_actions.swap(m_deferred_actions);
    for (auto& action : deferred_actions)
        action();
}
 
void WindowEventSource::defer(std::function<void()> action)
{
    if (!action)
        return;
 
    if (m_signal_depth == 0) {
        action();
        return;
    }
 
    m_deferred_actions.push_back(std::move(action));
}
 
Kriya::WindowEventAwaiter WindowEventSource::next_event()
{
    return Kriya::WindowEventAwaiter { *this, {} };
}
 
Kriya::WindowEventAwaiter WindowEventSource::await_event(Core::WindowEventType type)
{
    return Kriya::WindowEventAwaiter { *this, type };
}
 
std::optional<Core::WindowEvent> WindowEventSource::pop_event(const WindowEventFilter& filter)
{
    if (m_pending_events.empty())
        return std::nullopt;
 
    if (!filter.event_type && !filter.key_code && !filter.button) {
        auto ev = m_pending_events.front();
        m_pending_events.pop_front();
        --m_pending_counts[static_cast<uint8_t>(ev.type)];
        return ev;
    }
 
    std::deque<Core::WindowEvent> tmp;
    std::optional<Core::WindowEvent> result;
 
    while (!m_pending_events.empty()) {
        auto ev = m_pending_events.front();
        m_pending_events.pop_front();
 
        bool matches = true;
 
        if (filter.event_type && ev.type != *filter.event_type)
            matches = false;
 
        if (matches && filter.key_code) {
            if (auto* kd = std::get_if<Core::WindowEvent::KeyData>(&ev.data)) {
                matches = kd->key == static_cast<int16_t>(*filter.key_code);
            } else {
                matches = false;
            }
        }
 
        if (matches && filter.button) {
            if (auto* bd = std::get_if<Core::WindowEvent::MouseButtonData>(&ev.data)) {
                matches = bd->button == static_cast<int>(*filter.button);
            } else {
                matches = false;
            }
        }
 
        if (matches && !result) {
            result = ev;
        } else {
            tmp.push_back(ev);
        }
    }
 
    m_pending_events = std::move(tmp);
    if (result)
        --m_pending_counts[static_cast<uint8_t>(result->type)];
    return result;
}
 
bool WindowEventSource::is_key_pressed(IO::Keys key) const
{
    auto it = m_key_states.find(static_cast<int16_t>(key));
    return it != m_key_states.end() && it->second;
}
 
bool WindowEventSource::is_mouse_pressed(int button) const
{
    auto it = m_button_states.find(button);
    return it != m_button_states.end() && it->second;
}
 
std::pair<double, double> WindowEventSource::get_mouse_position() const
{
    return { m_mouse_x, m_mouse_y };
}
 
} // namespace MayaFlux::Vruta