SDL3pp_events.h

#ifndef SDL3PP_EVENTS_H_
#define SDL3PP_EVENTS_H_
 
#include <atomic>
#include <chrono>
#include <SDL3/SDL_events.h>
#include "SDL3pp_stdinc.h"
#include "SDL3pp_video.h"
 
namespace SDL {
 
using EventType = SDL_EventType;
 
constexpr EventType EVENT_FIRST = SDL_EVENT_FIRST; 
 
constexpr EventType EVENT_QUIT = SDL_EVENT_QUIT; 
 
constexpr EventType EVENT_TERMINATING = SDL_EVENT_TERMINATING;
 
constexpr EventType EVENT_LOW_MEMORY = SDL_EVENT_LOW_MEMORY;
 
constexpr EventType EVENT_WILL_ENTER_BACKGROUND =
  SDL_EVENT_WILL_ENTER_BACKGROUND;
 
constexpr EventType EVENT_DID_ENTER_BACKGROUND = SDL_EVENT_DID_ENTER_BACKGROUND;
 
constexpr EventType EVENT_WILL_ENTER_FOREGROUND =
  SDL_EVENT_WILL_ENTER_FOREGROUND;
 
constexpr EventType EVENT_DID_ENTER_FOREGROUND = SDL_EVENT_DID_ENTER_FOREGROUND;
 
constexpr EventType EVENT_LOCALE_CHANGED =
  SDL_EVENT_LOCALE_CHANGED; 
 
constexpr EventType EVENT_SYSTEM_THEME_CHANGED =
  SDL_EVENT_SYSTEM_THEME_CHANGED; 
 
constexpr EventType EVENT_DISPLAY_ORIENTATION =
  SDL_EVENT_DISPLAY_ORIENTATION; 
 
constexpr EventType EVENT_DISPLAY_ADDED =
  SDL_EVENT_DISPLAY_ADDED; 
 
constexpr EventType EVENT_DISPLAY_REMOVED =
  SDL_EVENT_DISPLAY_REMOVED; 
 
constexpr EventType EVENT_DISPLAY_MOVED =
  SDL_EVENT_DISPLAY_MOVED; 
 
constexpr EventType EVENT_DISPLAY_DESKTOP_MODE_CHANGED =
  SDL_EVENT_DISPLAY_DESKTOP_MODE_CHANGED; 
 
constexpr EventType EVENT_DISPLAY_CURRENT_MODE_CHANGED =
  SDL_EVENT_DISPLAY_CURRENT_MODE_CHANGED; 
 
constexpr EventType EVENT_DISPLAY_CONTENT_SCALE_CHANGED =
  SDL_EVENT_DISPLAY_CONTENT_SCALE_CHANGED; 
 
constexpr EventType EVENT_DISPLAY_FIRST =
  SDL_EVENT_DISPLAY_FIRST; 
 
constexpr EventType EVENT_DISPLAY_LAST =
  SDL_EVENT_DISPLAY_LAST; 
 
constexpr EventType EVENT_WINDOW_SHOWN =
  SDL_EVENT_WINDOW_SHOWN; 
 
constexpr EventType EVENT_WINDOW_HIDDEN =
  SDL_EVENT_WINDOW_HIDDEN; 
 
constexpr EventType EVENT_WINDOW_EXPOSED = SDL_EVENT_WINDOW_EXPOSED;
 
constexpr EventType EVENT_WINDOW_MOVED =
  SDL_EVENT_WINDOW_MOVED; 
 
constexpr EventType EVENT_WINDOW_RESIZED =
  SDL_EVENT_WINDOW_RESIZED; 
 
constexpr EventType EVENT_WINDOW_PIXEL_SIZE_CHANGED =
  SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED;
 
constexpr EventType EVENT_WINDOW_METAL_VIEW_RESIZED =
  SDL_EVENT_WINDOW_METAL_VIEW_RESIZED;
 
constexpr EventType EVENT_WINDOW_MINIMIZED =
  SDL_EVENT_WINDOW_MINIMIZED; 
 
constexpr EventType EVENT_WINDOW_MAXIMIZED =
  SDL_EVENT_WINDOW_MAXIMIZED; 
 
constexpr EventType EVENT_WINDOW_RESTORED = SDL_EVENT_WINDOW_RESTORED;
 
constexpr EventType EVENT_WINDOW_MOUSE_ENTER =
  SDL_EVENT_WINDOW_MOUSE_ENTER; 
 
constexpr EventType EVENT_WINDOW_MOUSE_LEAVE =
  SDL_EVENT_WINDOW_MOUSE_LEAVE; 
 
constexpr EventType EVENT_WINDOW_FOCUS_GAINED =
  SDL_EVENT_WINDOW_FOCUS_GAINED; 
 
constexpr EventType EVENT_WINDOW_FOCUS_LOST =
  SDL_EVENT_WINDOW_FOCUS_LOST; 
 
constexpr EventType EVENT_WINDOW_CLOSE_REQUESTED =
  SDL_EVENT_WINDOW_CLOSE_REQUESTED;
 
constexpr EventType EVENT_WINDOW_HIT_TEST =
  SDL_EVENT_WINDOW_HIT_TEST; 
 
constexpr EventType EVENT_WINDOW_ICCPROF_CHANGED =
  SDL_EVENT_WINDOW_ICCPROF_CHANGED;
 
constexpr EventType EVENT_WINDOW_DISPLAY_CHANGED =
  SDL_EVENT_WINDOW_DISPLAY_CHANGED; 
 
constexpr EventType EVENT_WINDOW_DISPLAY_SCALE_CHANGED =
  SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED; 
 
constexpr EventType EVENT_WINDOW_SAFE_AREA_CHANGED =
  SDL_EVENT_WINDOW_SAFE_AREA_CHANGED; 
 
constexpr EventType EVENT_WINDOW_OCCLUDED =
  SDL_EVENT_WINDOW_OCCLUDED; 
 
constexpr EventType EVENT_WINDOW_ENTER_FULLSCREEN =
  SDL_EVENT_WINDOW_ENTER_FULLSCREEN; 
 
constexpr EventType EVENT_WINDOW_LEAVE_FULLSCREEN =
  SDL_EVENT_WINDOW_LEAVE_FULLSCREEN; 
 
constexpr EventType EVENT_WINDOW_DESTROYED = SDL_EVENT_WINDOW_DESTROYED;
 
constexpr EventType EVENT_WINDOW_HDR_STATE_CHANGED =
  SDL_EVENT_WINDOW_HDR_STATE_CHANGED; 
 
constexpr EventType EVENT_WINDOW_FIRST =
  SDL_EVENT_WINDOW_FIRST; 
 
constexpr EventType EVENT_WINDOW_LAST = SDL_EVENT_WINDOW_LAST; 
 
constexpr EventType EVENT_KEY_DOWN = SDL_EVENT_KEY_DOWN; 
 
constexpr EventType EVENT_KEY_UP = SDL_EVENT_KEY_UP; 
 
constexpr EventType EVENT_TEXT_EDITING =
  SDL_EVENT_TEXT_EDITING; 
 
constexpr EventType EVENT_TEXT_INPUT =
  SDL_EVENT_TEXT_INPUT; 
 
constexpr EventType EVENT_KEYMAP_CHANGED = SDL_EVENT_KEYMAP_CHANGED;
 
constexpr EventType EVENT_KEYBOARD_ADDED =
  SDL_EVENT_KEYBOARD_ADDED; 
 
constexpr EventType EVENT_KEYBOARD_REMOVED =
  SDL_EVENT_KEYBOARD_REMOVED; 
 
constexpr EventType EVENT_TEXT_EDITING_CANDIDATES =
  SDL_EVENT_TEXT_EDITING_CANDIDATES; 
 
constexpr EventType EVENT_MOUSE_MOTION =
  SDL_EVENT_MOUSE_MOTION; 
 
constexpr EventType EVENT_MOUSE_BUTTON_DOWN =
  SDL_EVENT_MOUSE_BUTTON_DOWN; 
 
constexpr EventType EVENT_MOUSE_BUTTON_UP =
  SDL_EVENT_MOUSE_BUTTON_UP; 
 
constexpr EventType EVENT_MOUSE_WHEEL =
  SDL_EVENT_MOUSE_WHEEL; 
 
constexpr EventType EVENT_MOUSE_ADDED =
  SDL_EVENT_MOUSE_ADDED; 
 
constexpr EventType EVENT_MOUSE_REMOVED =
  SDL_EVENT_MOUSE_REMOVED; 
 
constexpr EventType EVENT_JOYSTICK_AXIS_MOTION =
  SDL_EVENT_JOYSTICK_AXIS_MOTION; 
 
constexpr EventType EVENT_JOYSTICK_BALL_MOTION =
  SDL_EVENT_JOYSTICK_BALL_MOTION; 
 
constexpr EventType EVENT_JOYSTICK_HAT_MOTION =
  SDL_EVENT_JOYSTICK_HAT_MOTION; 
 
constexpr EventType EVENT_JOYSTICK_BUTTON_DOWN =
  SDL_EVENT_JOYSTICK_BUTTON_DOWN; 
 
constexpr EventType EVENT_JOYSTICK_BUTTON_UP =
  SDL_EVENT_JOYSTICK_BUTTON_UP; 
 
constexpr EventType EVENT_JOYSTICK_ADDED =
  SDL_EVENT_JOYSTICK_ADDED; 
 
constexpr EventType EVENT_JOYSTICK_REMOVED =
  SDL_EVENT_JOYSTICK_REMOVED; 
 
constexpr EventType EVENT_JOYSTICK_BATTERY_UPDATED =
  SDL_EVENT_JOYSTICK_BATTERY_UPDATED; 
 
constexpr EventType EVENT_JOYSTICK_UPDATE_COMPLETE =
  SDL_EVENT_JOYSTICK_UPDATE_COMPLETE; 
 
constexpr EventType EVENT_GAMEPAD_AXIS_MOTION =
  SDL_EVENT_GAMEPAD_AXIS_MOTION; 
 
constexpr EventType EVENT_GAMEPAD_BUTTON_DOWN =
  SDL_EVENT_GAMEPAD_BUTTON_DOWN; 
 
constexpr EventType EVENT_GAMEPAD_BUTTON_UP =
  SDL_EVENT_GAMEPAD_BUTTON_UP; 
 
constexpr EventType EVENT_GAMEPAD_ADDED =
  SDL_EVENT_GAMEPAD_ADDED; 
 
constexpr EventType EVENT_GAMEPAD_REMOVED =
  SDL_EVENT_GAMEPAD_REMOVED; 
 
constexpr EventType EVENT_GAMEPAD_REMAPPED =
  SDL_EVENT_GAMEPAD_REMAPPED; 
 
constexpr EventType EVENT_GAMEPAD_TOUCHPAD_DOWN =
  SDL_EVENT_GAMEPAD_TOUCHPAD_DOWN; 
 
constexpr EventType EVENT_GAMEPAD_TOUCHPAD_MOTION =
  SDL_EVENT_GAMEPAD_TOUCHPAD_MOTION; 
 
constexpr EventType EVENT_GAMEPAD_TOUCHPAD_UP =
  SDL_EVENT_GAMEPAD_TOUCHPAD_UP; 
 
constexpr EventType EVENT_GAMEPAD_SENSOR_UPDATE =
  SDL_EVENT_GAMEPAD_SENSOR_UPDATE; 
 
constexpr EventType EVENT_GAMEPAD_UPDATE_COMPLETE =
  SDL_EVENT_GAMEPAD_UPDATE_COMPLETE; 
 
constexpr EventType EVENT_GAMEPAD_STEAM_HANDLE_UPDATED =
  SDL_EVENT_GAMEPAD_STEAM_HANDLE_UPDATED; 
 
constexpr EventType EVENT_FINGER_DOWN = SDL_EVENT_FINGER_DOWN; 
 
constexpr EventType EVENT_FINGER_UP = SDL_EVENT_FINGER_UP; 
 
constexpr EventType EVENT_FINGER_MOTION =
  SDL_EVENT_FINGER_MOTION; 
 
constexpr EventType EVENT_FINGER_CANCELED =
  SDL_EVENT_FINGER_CANCELED; 
 
constexpr EventType EVENT_CLIPBOARD_UPDATE =
  SDL_EVENT_CLIPBOARD_UPDATE; 
 
constexpr EventType EVENT_DROP_FILE =
  SDL_EVENT_DROP_FILE; 
 
constexpr EventType EVENT_DROP_TEXT =
  SDL_EVENT_DROP_TEXT; 
 
constexpr EventType EVENT_DROP_BEGIN =
  SDL_EVENT_DROP_BEGIN; 
 
constexpr EventType EVENT_DROP_COMPLETE = SDL_EVENT_DROP_COMPLETE;
 
constexpr EventType EVENT_DROP_POSITION =
  SDL_EVENT_DROP_POSITION; 
 
constexpr EventType EVENT_AUDIO_DEVICE_ADDED =
  SDL_EVENT_AUDIO_DEVICE_ADDED; 
 
constexpr EventType EVENT_AUDIO_DEVICE_REMOVED =
  SDL_EVENT_AUDIO_DEVICE_REMOVED; 
 
constexpr EventType EVENT_AUDIO_DEVICE_FORMAT_CHANGED =
  SDL_EVENT_AUDIO_DEVICE_FORMAT_CHANGED;
 
constexpr EventType EVENT_SENSOR_UPDATE =
  SDL_EVENT_SENSOR_UPDATE; 
 
constexpr EventType EVENT_PEN_PROXIMITY_IN =
  SDL_EVENT_PEN_PROXIMITY_IN; 
 
constexpr EventType EVENT_PEN_PROXIMITY_OUT =
  SDL_EVENT_PEN_PROXIMITY_OUT; 
 
constexpr EventType EVENT_PEN_DOWN =
  SDL_EVENT_PEN_DOWN; 
 
constexpr EventType EVENT_PEN_UP = SDL_EVENT_PEN_UP;
 
constexpr EventType EVENT_PEN_BUTTON_DOWN =
  SDL_EVENT_PEN_BUTTON_DOWN; 
 
constexpr EventType EVENT_PEN_BUTTON_UP =
  SDL_EVENT_PEN_BUTTON_UP; 
 
constexpr EventType EVENT_PEN_MOTION =
  SDL_EVENT_PEN_MOTION; 
 
constexpr EventType EVENT_PEN_AXIS =
  SDL_EVENT_PEN_AXIS; 
 
constexpr EventType EVENT_CAMERA_DEVICE_ADDED =
  SDL_EVENT_CAMERA_DEVICE_ADDED; 
 
constexpr EventType EVENT_CAMERA_DEVICE_REMOVED =
  SDL_EVENT_CAMERA_DEVICE_REMOVED; 
 
constexpr EventType EVENT_CAMERA_DEVICE_APPROVED =
  SDL_EVENT_CAMERA_DEVICE_APPROVED;
 
constexpr EventType EVENT_CAMERA_DEVICE_DENIED = SDL_EVENT_CAMERA_DEVICE_DENIED;
 
constexpr EventType EVENT_RENDER_TARGETS_RESET = SDL_EVENT_RENDER_TARGETS_RESET;
 
constexpr EventType EVENT_RENDER_DEVICE_RESET = SDL_EVENT_RENDER_DEVICE_RESET;
 
constexpr EventType EVENT_RENDER_DEVICE_LOST =
  SDL_EVENT_RENDER_DEVICE_LOST; 
 
constexpr EventType EVENT_PRIVATE0 = SDL_EVENT_PRIVATE0; 
 
constexpr EventType EVENT_PRIVATE1 = SDL_EVENT_PRIVATE1; 
 
constexpr EventType EVENT_PRIVATE2 = SDL_EVENT_PRIVATE2; 
 
constexpr EventType EVENT_PRIVATE3 = SDL_EVENT_PRIVATE3; 
 
constexpr EventType EVENT_POLL_SENTINEL =
  SDL_EVENT_POLL_SENTINEL; 
 
constexpr EventType EVENT_USER = SDL_EVENT_USER;
 
constexpr EventType EVENT_LAST = SDL_EVENT_LAST;
 
constexpr EventType EVENT_ENUM_PADDING =
  SDL_EVENT_ENUM_PADDING; 
 
 
using CommonEvent = SDL_CommonEvent;
 
using DisplayEvent = SDL_DisplayEvent;
 
using WindowEvent = SDL_WindowEvent;
 
using KeyboardDeviceEvent = SDL_KeyboardDeviceEvent;
 
using KeyboardEvent = SDL_KeyboardEvent;
 
using TextEditingEvent = SDL_TextEditingEvent;
 
using TextEditingCandidatesEvent = SDL_TextEditingCandidatesEvent;
 
using TextInputEvent = SDL_TextInputEvent;
 
using MouseDeviceEvent = SDL_MouseDeviceEvent;
 
using MouseMotionEvent = SDL_MouseMotionEvent;
 
using MouseButtonEvent = SDL_MouseButtonEvent;
 
using MouseWheelEvent = SDL_MouseWheelEvent;
 
using JoyAxisEvent = SDL_JoyAxisEvent;
 
using JoyBallEvent = SDL_JoyBallEvent;
 
using JoyHatEvent = SDL_JoyHatEvent;
 
using JoyButtonEvent = SDL_JoyButtonEvent;
 
using JoyDeviceEvent = SDL_JoyDeviceEvent;
 
using JoyBatteryEvent = SDL_JoyBatteryEvent;
 
using GamepadAxisEvent = SDL_GamepadAxisEvent;
 
using GamepadButtonEvent = SDL_GamepadButtonEvent;
 
using GamepadDeviceEvent = SDL_GamepadDeviceEvent;
 
using GamepadTouchpadEvent = SDL_GamepadTouchpadEvent;
 
using GamepadSensorEvent = SDL_GamepadSensorEvent;
 
using AudioDeviceEvent = SDL_AudioDeviceEvent;
 
using CameraDeviceEvent = SDL_CameraDeviceEvent;
 
using RenderEvent = SDL_RenderEvent;
 
using TouchFingerEvent = SDL_TouchFingerEvent;
 
using PenProximityEvent = SDL_PenProximityEvent;
 
using PenMotionEvent = SDL_PenMotionEvent;
 
using PenTouchEvent = SDL_PenTouchEvent;
 
using PenButtonEvent = SDL_PenButtonEvent;
 
using PenAxisEvent = SDL_PenAxisEvent;
 
using DropEvent = SDL_DropEvent;
 
using ClipboardEvent = SDL_ClipboardEvent;
 
using SensorEvent = SDL_SensorEvent;
 
using QuitEvent = SDL_QuitEvent;
 
using UserEvent = SDL_UserEvent;
 
using Event = SDL_Event;
 
inline void PumpEvents() { return SDL_PumpEvents(); }
 
using EventAction = SDL_EventAction;
 
constexpr EventAction ADDEVENT =
  SDL_ADDEVENT; 
 
constexpr EventAction PEEKEVENT = SDL_PEEKEVENT;
 
constexpr EventAction GETEVENT = SDL_GETEVENT;
 
 
inline int PeepEvents(Event* events,
                      int numevents,
                      EventAction action,
                      Uint32 minType = EVENT_FIRST,
                      Uint32 maxType = EVENT_LAST)
{
  return SDL_PeepEvents(events, numevents, action, minType, maxType);
}
 
inline bool HasEvent(Uint32 type) { return SDL_HasEvent(type); }
 
inline bool HasEvents(Uint32 minType = EVENT_FIRST, Uint32 maxType = EVENT_LAST)
{
  return SDL_HasEvents(minType, maxType);
}
 
inline void FlushEvent(Uint32 type) { return SDL_FlushEvent(type); }
 
inline void FlushEvents(Uint32 minType = EVENT_FIRST,
                        Uint32 maxType = EVENT_LAST)
{
  return SDL_FlushEvents(minType, maxType);
}
 
inline bool PollEvent(Event* event) { return SDL_PollEvent(event); }
 
inline std::optional<Event> PollEvent()
{
  if (Event event; PollEvent(&event)) return event;
  return std::nullopt;
}
 
inline void WaitEvent(Event* event) { CheckError(SDL_WaitEvent(event)); }
 
inline Event WaitEvent()
{
  Event event;
  WaitEvent(&event);
  return event;
}
 
inline bool WaitEventTimeout(Event* event, Sint32 timeoutMS)
{
  return SDL_WaitEventTimeout(event, timeoutMS);
}
 
inline std::optional<Event> WaitEventTimeout(Sint32 timeoutMS)
{
  if (Event event; WaitEventTimeout(&event, timeoutMS)) return event;
  return std::nullopt;
}
 
inline bool WaitEventTimeout(Event* event,
                             std::chrono::milliseconds timeoutDuration)
{
  return WaitEventTimeout(event, std::max(timeoutDuration.count(), 1l));
}
inline std::optional<Event> WaitEventTimeout(
  std::chrono::milliseconds timeoutDuration)
{
  if (Event event; WaitEventTimeout(&event, timeoutDuration)) return event;
  return std::nullopt;
}
 
inline void PushEvent(Event* event) { CheckError(SDL_PushEvent(event)); }
 
inline void PushEvent(const Event& event)
{
  PushEvent(const_cast<Event*>(&event));
}
 
using EventFilter = SDL_EventFilter;
 
using EventFilterCB = std::function<bool(const Event&)>;
 
struct EventWatchHandle : CallbackHandle
{
  using CallbackHandle::CallbackHandle;
};
 
inline void SetEventFilter(EventFilter filter, void* userdata)
{
  UniqueCallbackWrapper<EventFilterCB>::erase();
  return SDL_SetEventFilter(filter, userdata);
}
 
inline void SetEventFilter(EventFilterCB filter = {})
{
  using Wrapper = UniqueCallbackWrapper<EventFilterCB>;
  SDL_SetEventFilter(
    [](void* userdata, SDL_Event* event) {
      return Wrapper::Call(userdata, *event);
    },
    Wrapper::Wrap(std::move(filter)));
}
 
inline void GetEventFilter(EventFilter* filter, void** userdata)
{
  CheckError(SDL_GetEventFilter(filter, userdata));
}
 
inline EventFilterCB GetEventFilter()
{
  using Wrapper = UniqueCallbackWrapper<EventFilterCB>;
 
  EventFilter filter;
  void* userdata;
  GetEventFilter(&filter, &userdata);
  if (!userdata)
    return [filter](const Event& event) {
      return filter(nullptr, const_cast<Event*>(&event));
    };
  if (auto cb = Wrapper::at(userdata)) return cb;
  return [filter, userdata](const Event& event) {
    return filter(userdata, const_cast<Event*>(&event));
  };
}
 
inline bool EventWatchAuxCallback(void* userdata, Event* event)
{
  auto& f = *static_cast<EventFilterCB*>(userdata);
  return f(*event);
}
 
inline void AddEventWatch(EventFilter filter, void* userdata)
{
  CheckError(SDL_AddEventWatch(filter, userdata));
}
 
inline EventWatchHandle AddEventWatch(EventFilterCB filter)
{
  using Wrapper = CallbackWrapper<EventFilterCB>;
  auto cb = Wrapper::Wrap(std::move(filter));
  if (!SDL_AddEventWatch(&EventWatchAuxCallback, &cb)) {
    Wrapper::release(cb);
    throw Error{};
  }
  return EventWatchHandle{cb};
}
 
inline void RemoveEventWatch(EventFilter filter, void* userdata)
{
  SDL_RemoveEventWatch(filter, userdata);
}
 
inline void RemoveEventWatch(EventWatchHandle handle)
{
  using Wrapper = CallbackWrapper<EventFilterCB>;
  Wrapper::release(handle);
}
 
inline void FilterEvents(EventFilter filter, void* userdata)
{
  SDL_FilterEvents(filter, userdata);
}
 
inline void FilterEvents(EventFilterCB filter)
{
  return FilterEvents(
    [](void* userdata, SDL_Event* event) {
      auto& f = *static_cast<EventFilterCB*>(userdata);
      return f(*event);
    },
    &filter);
}
inline void SetEventEnabled(Uint32 type, bool enabled)
{
  return SDL_SetEventEnabled(type, enabled);
}
 
inline bool EventEnabled(Uint32 type) { return SDL_EventEnabled(type); }
 
inline Uint32 RegisterEvents(int numevents)
{
  return SDL_RegisterEvents(numevents);
}
 
inline WindowRef GetWindowFromEvent(const Event& event)
{
  return CheckError(SDL_GetWindowFromEvent(&event));
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_EVENTS_H_ */