event.hpp

Go to the documentation of this file.

#pragma once

#include "exception.hpp"

#include <SDL.h>
#include <SDL_events.h>

#include <functional>
#include <map>
#include <vector>

#include <begin_code.h> // use SDL2 packing

// Visual Studio 2019 has became TOO pedantic about member
// initialization. Supress IntelliSence CppCoreGuideline
// "MEMBER_UNINIT" warning. The static ananlyser doesn't like our union
// initialized only by writing over the whole object with the value of an
// SDL_Event. Have to agree with it on the fact that this is using dark magic
// **BUT** we actually **KNOW** what we are doing here, thank you very much
#if _MSC_VER >= 1910
#pragma warning(push)
#pragma warning(disable : 26495)
#endif

namespace sdl
{
union Event
{
    // this is copy-pasted from the definition of SDL_Event in
    // <SDL2/SDL_events.h>
public:
    Uint32                    type;     
    SDL_CommonEvent           common;   
    SDL_WindowEvent           window;   
    SDL_KeyboardEvent         key;      
    SDL_TextEditingEvent      edit;     
    SDL_TextInputEvent        text;     
    SDL_MouseMotionEvent      motion;   
    SDL_MouseButtonEvent      button;   
    SDL_MouseWheelEvent       wheel;    
    SDL_JoyAxisEvent          jaxis;    
    SDL_JoyBallEvent          jball;    
    SDL_JoyHatEvent           jhat;     
    SDL_JoyButtonEvent        jbutton;  
    SDL_JoyDeviceEvent        jdevice;  
    SDL_ControllerAxisEvent   caxis;    
    SDL_ControllerButtonEvent cbutton;  
    SDL_ControllerDeviceEvent cdevice;  
    SDL_AudioDeviceEvent      adevice;  
    SDL_QuitEvent             quit;     
    SDL_UserEvent             user;     
    SDL_SysWMEvent            syswm;    
    SDL_TouchFingerEvent      tfinger;  
    SDL_MultiGestureEvent     mgesture; 
    SDL_DollarGestureEvent    dgesture; 
    SDL_DropEvent             drop;     
#if SDL_VERSION_ATLEAST(2, 0, 9)
    SDL_SensorEvent  sensor;  
    SDL_DisplayEvent display; 
#endif

    /*
    This is necessary for ABI compatibility between Visual C++ and GCC
    Visual C++ will respect the push pack pragma and use 52 bytes for
    this structure, and GCC will use the alignment of the largest datatype
    within the union, which is 8 bytes.

    So... we'll add padding to force the size to be 56 bytes for both.
    */
    Uint8 padding[56];

    Event()
    {
        // statically checks the likelyness of this union to lineup with the C
        // union
        static_assert(
            sizeof(Event) == sizeof(SDL_Event),
            "Hey, it's likely that the bits in sdl::Event and SDL_Event don't "
            "lineup. Please check you are using a supported version of SDL2!!");

        static_assert(offsetof(Event, common.timestamp) == offsetof(SDL_Event, common.timestamp));

        static_assert(offsetof(Event, user.windowID) == offsetof(SDL_Event, user.windowID));

        memset(this, 0, sizeof(SDL_Event));
    }

    Event(SDL_Event const& e) : Event{*reinterpret_cast<Event const*>(&e)} {}

    static Event const& ref_from(SDL_Event const& e) { return *reinterpret_cast<Event const*>(&e); }

    static Event& ref_from(SDL_Event& e) { return *reinterpret_cast<Event*>(&e); }

    static Event const& ref_from(SDL_Event const* e) { return *reinterpret_cast<Event const*>(e); }

    static Event& ref_from(SDL_Event* e) { return *reinterpret_cast<Event*>(e); }

    operator SDL_Event() const { return *reinterpret_cast<SDL_Event const*>(this); }

    SDL_Event const* ptr() const { return reinterpret_cast<SDL_Event const*>(this); }

    SDL_Event* ptr() { return reinterpret_cast<SDL_Event*>(this); }

    enum class State : int
    {
        Query  = SDL_QUERY,
        Ignore = SDL_IGNORE,
        Enable = SDL_ENABLE,
    };

    bool poll() { return SDL_PollEvent(ptr()); }

    void wait()
    {
        if (!SDL_WaitEvent(ptr())) throw Exception{"SDL_WaitEvent"};
    }

    void wait(int timeout)
    {
        if (!SDL_WaitEventTimeout(ptr(), timeout))
        {
            throw Exception{"SDL_WaitEventTimeout"};
        }
    }

    void push() const
    {
        // SDL_PushEvent won't modify it's argument
        if (!SDL_PushEvent(const_cast<SDL_Event*>(ptr())))
        {
            throw Exception{"SDL_PushEvent"};
        }
    }

    void peek()
    {
        if (SDL_PeepEvents(ptr(), 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) < 0)
        {
            throw Exception{"SDL_PeepEvents"};
        }
    }

    inline bool has_events() { return SDL_HasEvents(SDL_FIRSTEVENT, SDL_LASTEVENT); }

    inline bool has_events(Uint32 type) { return SDL_HasEvent(type); }

    inline bool has_events(Uint32 minType, Uint32 maxType)
    {
        return SDL_HasEvents(minType, maxType);
    }

    inline void pump_events() { SDL_PumpEvents(); }

    inline void flush_events(Uint32 minType, Uint32 maxType) { SDL_FlushEvents(minType, maxType); }

    inline void flush_events() { flush_events(SDL_FIRSTEVENT, SDL_LASTEVENT); }

    inline void flush_events(Uint32 type) { flush_events(type, type); }

    inline void add_events(std::vector<Event> const& events, Uint32 minType, Uint32 maxType)
    {
        // This use of SDL_PeepEvents don't modify the events
        auto array = const_cast<SDL_Event*>(reinterpret_cast<SDL_Event const*>(&events[0]));
        if (SDL_PeepEvents(array, int(events.size()), SDL_ADDEVENT, minType, maxType) < 0)
        {
            throw Exception{"SDL_PeepEvents"};
        }
    }

    inline void add_events(std::vector<Event> const& events)
    {
        add_events(events, SDL_FIRSTEVENT, SDL_LASTEVENT);
    }

    inline void add_events(std::vector<Event> const& events, Uint32 type)
    {
        add_events(events, type, type);
    }

    inline std::vector<Event> peek_events(size_t maxEvents, Uint32 minType, Uint32 maxType)
    {
        auto res   = std::vector<Event>(maxEvents);
        auto array = reinterpret_cast<SDL_Event*>(&res[0]);
        if (SDL_PeepEvents(array, int(maxEvents), SDL_PEEKEVENT, minType, maxType) < 0)
        {
            throw Exception{"SDL_PeepEvents"};
        }
        return res;
    }

    inline std::vector<Event> peek_events(size_t maxEvents)
    {
        return peek_events(maxEvents, SDL_FIRSTEVENT, SDL_LASTEVENT);
    }

    inline std::vector<Event> peek_events(size_t maxEvents, Uint32 type)
    {
        return peek_events(maxEvents, type, type);
    }

    inline std::vector<Event> get_events(size_t maxEvents, Uint32 minType, Uint32 maxType)
    {
        auto res   = std::vector<Event>(maxEvents);
        auto array = reinterpret_cast<SDL_Event*>(&res[0]);
        if (SDL_PeepEvents(array, int(maxEvents), SDL_GETEVENT, minType, maxType) < 0)
        {
            throw Exception{"SDL_PeepEvents"};
        }
        return res;
    }

    inline std::vector<Event> get_events(size_t maxEvents)
    {
        return get_events(maxEvents, SDL_FIRSTEVENT, SDL_LASTEVENT);
    }

    inline std::vector<Event> get_events(size_t maxEvents, Uint32 type)
    {
        return get_events(maxEvents, type, type);
    }

    struct EventFilter
    {
        using func_type = bool (*)(void*, Event&);

        void*     userdata_  = nullptr;
        func_type filter_    = nullptr;
        bool      isWatcher_ = false;

        EventFilter(func_type filter, void* userdata) : filter_{filter}, userdata_{userdata} {}

        EventFilter(func_type filter) : filter_{filter} {}

        ~EventFilter()
        {
            if (isWatcher_) del_watcher();
        }

        static int call_filter(void* data, SDL_Event* event)
        {
            auto filter = static_cast<EventFilter*>(data);
            return filter->filter_(filter->userdata_, sdl::Event::ref_from(event));
        }

        void filter_queue() { SDL_FilterEvents(&call_filter, this); }

        void set() { SDL_SetEventFilter(&call_filter, userdata_); }

        static void unset() { SDL_FilterEvents(nullptr, nullptr); }

        void add_watcher()
        {
            SDL_AddEventWatch(&call_filter, this);
            isWatcher_ = true;
        }

        void del_watcher()
        {
            SDL_DelEventWatch(&call_filter, this);
            isWatcher_ = false;
        }
    };

    inline Event::State event_state(Uint32 type)
    {
        return static_cast<Event::State>(SDL_GetEventState(type));
    }

    inline void set_event_state(Uint32 type, Event::State state)
    {
        SDL_EventState(type, int(state));
    }
};
} // namespace sdl

#include <close_code.h>

#if _MSC_VER >= 1910
#pragma warning(pop)
#endif