SDL/src/events/SDL_events.c

/*
  Simple DirectMedia Layer
  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_internal.h"

// General event handling code for SDL

#include "SDL_events_c.h"
#include "SDL_eventwatch_c.h"
#include "SDL_windowevents_c.h"
#include "../SDL_hints_c.h"
#include "../audio/SDL_audio_c.h"
#include "../camera/SDL_camera_c.h"
#include "../timer/SDL_timer_c.h"
#ifndef SDL_JOYSTICK_DISABLED
#include "../joystick/SDL_joystick_c.h"
#endif
#ifndef SDL_SENSOR_DISABLED
#include "../sensor/SDL_sensor_c.h"
#endif
#include "../video/SDL_sysvideo.h"

#ifdef SDL_PLATFORM_ANDROID
#include "../core/android/SDL_android.h"
#include "../video/android/SDL_androidevents.h"
#endif

// An arbitrary limit so we don't have unbounded growth
#define SDL_MAX_QUEUED_EVENTS 65535

// Determines how often we pump events if joystick or sensor subsystems are active
#define ENUMERATION_POLL_INTERVAL_NS (3 * SDL_NS_PER_SECOND)

// Determines how often to pump events if joysticks or sensors are actively being read
#define EVENT_POLL_INTERVAL_NS SDL_MS_TO_NS(1)

// Make sure the type in the SDL_Event aligns properly across the union
SDL_COMPILE_TIME_ASSERT(SDL_Event_type, sizeof(Uint32) == sizeof(SDL_EventType));

#define SDL2_SYSWMEVENT 0x201

#ifdef SDL_VIDEO_DRIVER_WINDOWS
#include "../core/windows/SDL_windows.h"
#endif

#ifdef SDL_VIDEO_DRIVER_X11
#include <X11/Xlib.h>
#endif

typedef struct SDL2_version
{
    Uint8 major;
    Uint8 minor;
    Uint8 patch;
} SDL2_version;

typedef enum
{
  SDL2_SYSWM_UNKNOWN
} SDL2_SYSWM_TYPE;

typedef struct SDL2_SysWMmsg
{
    SDL2_version version;
    SDL2_SYSWM_TYPE subsystem;
    union
    {
#ifdef SDL_VIDEO_DRIVER_WINDOWS
        struct {
            HWND hwnd;                  /**< The window for the message */
            UINT msg;                   /**< The type of message */
            WPARAM wParam;              /**< WORD message parameter */
            LPARAM lParam;              /**< LONG message parameter */
        } win;
#endif
#ifdef SDL_VIDEO_DRIVER_X11
        struct {
            XEvent event;
        } x11;
#endif
        /* Can't have an empty union */
        int dummy;
    } msg;
} SDL2_SysWMmsg;

static SDL_EventWatchList SDL_event_watchers;
static SDL_AtomicInt SDL_sentinel_pending;
static Uint32 SDL_last_event_id = 0;

typedef struct
{
    Uint32 bits[8];
} SDL_DisabledEventBlock;

static SDL_DisabledEventBlock *SDL_disabled_events[256];
static SDL_AtomicInt SDL_userevents;

typedef struct SDL_TemporaryMemory
{
    void *memory;
    struct SDL_TemporaryMemory *prev;
    struct SDL_TemporaryMemory *next;
} SDL_TemporaryMemory;

typedef struct SDL_TemporaryMemoryState
{
    SDL_TemporaryMemory *head;
    SDL_TemporaryMemory *tail;
} SDL_TemporaryMemoryState;

static SDL_TLSID SDL_temporary_memory;

typedef struct SDL_EventEntry
{
    SDL_Event event;
    SDL_TemporaryMemory *memory;
    struct SDL_EventEntry *prev;
    struct SDL_EventEntry *next;
} SDL_EventEntry;

static struct
{
    SDL_Mutex *lock;
    bool active;
    SDL_AtomicInt count;
    int max_events_seen;
    SDL_EventEntry *head;
    SDL_EventEntry *tail;
    SDL_EventEntry *free;
} SDL_EventQ = { NULL, false, { 0 }, 0, NULL, NULL, NULL };


static void SDL_CleanupTemporaryMemory(void *data)
{
    SDL_TemporaryMemoryState *state = (SDL_TemporaryMemoryState *)data;

    SDL_FreeTemporaryMemory();
    SDL_free(state);
}

static SDL_TemporaryMemoryState *SDL_GetTemporaryMemoryState(bool create)
{
    SDL_TemporaryMemoryState *state;

    state = (SDL_TemporaryMemoryState *)SDL_GetTLS(&SDL_temporary_memory);
    if (!state) {
        if (!create) {
            return NULL;
        }

        state = (SDL_TemporaryMemoryState *)SDL_calloc(1, sizeof(*state));
        if (!state) {
            return NULL;
        }

        if (!SDL_SetTLS(&SDL_temporary_memory, state, SDL_CleanupTemporaryMemory)) {
            SDL_free(state);
            return NULL;
        }
    }
    return state;
}

static SDL_TemporaryMemory *SDL_GetTemporaryMemoryEntry(SDL_TemporaryMemoryState *state, const void *mem)
{
    SDL_TemporaryMemory *entry;

    // Start from the end, it's likely to have been recently allocated
    for (entry = state->tail; entry; entry = entry->prev) {
        if (mem == entry->memory) {
            return entry;
        }
    }
    return NULL;
}

static void SDL_LinkTemporaryMemoryEntry(SDL_TemporaryMemoryState *state, SDL_TemporaryMemory *entry)
{
    entry->prev = state->tail;
    entry->next = NULL;

    if (state->tail) {
        state->tail->next = entry;
    } else {
        state->head = entry;
    }
    state->tail = entry;
}

static void SDL_UnlinkTemporaryMemoryEntry(SDL_TemporaryMemoryState *state, SDL_TemporaryMemory *entry)
{
    if (state->head == entry) {
        state->head = entry->next;
    }
    if (state->tail == entry) {
        state->tail = entry->prev;
    }

    if (entry->prev) {
        entry->prev->next = entry->next;
    }
    if (entry->next) {
        entry->next->prev = entry->prev;
    }

    entry->prev = NULL;
    entry->next = NULL;
}

static void SDL_FreeTemporaryMemoryEntry(SDL_TemporaryMemoryState *state, SDL_TemporaryMemory *entry, bool free_data)
{
    if (free_data) {
        SDL_free(entry->memory);
    }
    SDL_free(entry);
}

static void SDL_LinkTemporaryMemoryToEvent(SDL_EventEntry *event, const void *mem)
{
    SDL_TemporaryMemoryState *state;
    SDL_TemporaryMemory *entry;

    state = SDL_GetTemporaryMemoryState(false);
    if (!state) {
        return;
    }

    entry = SDL_GetTemporaryMemoryEntry(state, mem);
    if (entry) {
        SDL_UnlinkTemporaryMemoryEntry(state, entry);
        entry->next = event->memory;
        event->memory = entry;
    }
}

static void SDL_TransferSysWMMemoryToEvent(SDL_EventEntry *event)
{
    SDL2_SysWMmsg **wmmsg = (SDL2_SysWMmsg **)((&event->event.common)+1);
    SDL2_SysWMmsg *mem = SDL_AllocateTemporaryMemory(sizeof(*mem));
    if (mem) {
        SDL_copyp(mem, *wmmsg);
        *wmmsg = mem;
        SDL_LinkTemporaryMemoryToEvent(event, mem);
    }
}

// Transfer the event memory from the thread-local event memory list to the event
static void SDL_TransferTemporaryMemoryToEvent(SDL_EventEntry *event)
{
    switch (event->event.type) {
    case SDL_EVENT_TEXT_EDITING:
        SDL_LinkTemporaryMemoryToEvent(event, event->event.edit.text);
        break;
    case SDL_EVENT_TEXT_EDITING_CANDIDATES:
        SDL_LinkTemporaryMemoryToEvent(event, event->event.edit_candidates.candidates);
        break;
    case SDL_EVENT_TEXT_INPUT:
        SDL_LinkTemporaryMemoryToEvent(event, event->event.text.text);
        break;
    case SDL_EVENT_DROP_BEGIN:
    case SDL_EVENT_DROP_FILE:
    case SDL_EVENT_DROP_TEXT:
    case SDL_EVENT_DROP_COMPLETE:
    case SDL_EVENT_DROP_POSITION:
        SDL_LinkTemporaryMemoryToEvent(event, event->event.drop.source);
        SDL_LinkTemporaryMemoryToEvent(event, event->event.drop.data);
        break;
    case SDL_EVENT_CLIPBOARD_UPDATE:
        SDL_LinkTemporaryMemoryToEvent(event, event->event.clipboard.mime_types);
        break;
    case SDL2_SYSWMEVENT:
        // We need to copy the stack pointer into temporary memory
        SDL_TransferSysWMMemoryToEvent(event);
        break;
    default:
        break;
    }
}

// Transfer the event memory from the event to the thread-local event memory list
static void SDL_TransferTemporaryMemoryFromEvent(SDL_EventEntry *event)
{
    SDL_TemporaryMemoryState *state;
    SDL_TemporaryMemory *entry, *next;

    if (!event->memory) {
        return;
    }

    state = SDL_GetTemporaryMemoryState(true);
    if (!state) {
        return;  // this is now a leak, but you probably have bigger problems if malloc failed.
    }

    for (entry = event->memory; entry; entry = next) {
        next = entry->next;
        SDL_LinkTemporaryMemoryEntry(state, entry);
    }
    event->memory = NULL;
}

static void *SDL_FreeLater(void *memory)
{
    SDL_TemporaryMemoryState *state;

    if (memory == NULL) {
        return NULL;
    }

    // Make sure we're not adding this to the list twice
    //SDL_assert(!SDL_ClaimTemporaryMemory(memory));

    state = SDL_GetTemporaryMemoryState(true);
    if (!state) {
        return memory;  // this is now a leak, but you probably have bigger problems if malloc failed.
    }

    SDL_TemporaryMemory *entry = (SDL_TemporaryMemory *)SDL_malloc(sizeof(*entry));
    if (!entry) {
        return memory;  // this is now a leak, but you probably have bigger problems if malloc failed. We could probably pool up and reuse entries, though.
    }

    entry->memory = memory;

    SDL_LinkTemporaryMemoryEntry(state, entry);

    return memory;
}

void *SDL_AllocateTemporaryMemory(size_t size)
{
    return SDL_FreeLater(SDL_malloc(size));
}

const char *SDL_CreateTemporaryString(const char *string)
{
    if (string) {
        return (const char *)SDL_FreeLater(SDL_strdup(string));
    }
    return NULL;
}

void *SDL_ClaimTemporaryMemory(const void *mem)
{
    SDL_TemporaryMemoryState *state;

    state = SDL_GetTemporaryMemoryState(false);
    if (state && mem) {
        SDL_TemporaryMemory *entry = SDL_GetTemporaryMemoryEntry(state, mem);
        if (entry) {
            SDL_UnlinkTemporaryMemoryEntry(state, entry);
            SDL_FreeTemporaryMemoryEntry(state, entry, false);
            return (void *)mem;
        }
    }
    return NULL;
}

void SDL_FreeTemporaryMemory(void)
{
    SDL_TemporaryMemoryState *state;

    state = SDL_GetTemporaryMemoryState(false);
    if (!state) {
        return;
    }

    while (state->head) {
        SDL_TemporaryMemory *entry = state->head;

        SDL_UnlinkTemporaryMemoryEntry(state, entry);
        SDL_FreeTemporaryMemoryEntry(state, entry, true);
    }
}

#ifndef SDL_JOYSTICK_DISABLED

static bool SDL_update_joysticks = true;

static void SDLCALL SDL_AutoUpdateJoysticksChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
{
    SDL_update_joysticks = SDL_GetStringBoolean(hint, true);
}

#endif // !SDL_JOYSTICK_DISABLED

#ifndef SDL_SENSOR_DISABLED

static bool SDL_update_sensors = true;

static void SDLCALL SDL_AutoUpdateSensorsChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
{
    SDL_update_sensors = SDL_GetStringBoolean(hint, true);
}

#endif // !SDL_SENSOR_DISABLED

static void SDLCALL SDL_PollSentinelChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
{
    SDL_SetEventEnabled(SDL_EVENT_POLL_SENTINEL, SDL_GetStringBoolean(hint, true));
}

/**
 * Verbosity of logged events as defined in SDL_HINT_EVENT_LOGGING:
 *  - 0: (default) no logging
 *  - 1: logging of most events
 *  - 2: as above, plus mouse, pen, and finger motion
 */
static int SDL_EventLoggingVerbosity = 0;

static void SDLCALL SDL_EventLoggingChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
{
    SDL_EventLoggingVerbosity = (hint && *hint) ? SDL_clamp(SDL_atoi(hint), 0, 3) : 0;
}

static void SDL_LogEvent(const SDL_Event *event)
{
    static const char *pen_axisnames[] = { "PRESSURE", "XTILT", "YTILT", "DISTANCE", "ROTATION", "SLIDER", "TANGENTIAL_PRESSURE" };
    SDL_COMPILE_TIME_ASSERT(pen_axisnames_array_matches, SDL_arraysize(pen_axisnames) == SDL_PEN_AXIS_COUNT);

    char name[64];
    char details[128];

    // sensor/mouse/pen/finger motion are spammy, ignore these if they aren't demanded.
    if ((SDL_EventLoggingVerbosity < 2) &&
        ((event->type == SDL_EVENT_MOUSE_MOTION) ||
         (event->type == SDL_EVENT_FINGER_MOTION) ||
         (event->type == SDL_EVENT_PEN_AXIS) ||
         (event->type == SDL_EVENT_PEN_MOTION) ||
         (event->type == SDL_EVENT_GAMEPAD_TOUCHPAD_MOTION) ||
         (event->type == SDL_EVENT_GAMEPAD_SENSOR_UPDATE) ||
         (event->type == SDL_EVENT_SENSOR_UPDATE))) {
        return;
    }

// this is to make (void)SDL_snprintf() calls cleaner.
#define uint unsigned int

    name[0] = '\0';
    details[0] = '\0';

    // !!! FIXME: This code is kinda ugly, sorry.

    if ((event->type >= SDL_EVENT_USER) && (event->type <= SDL_EVENT_LAST)) {
        char plusstr[16];
        SDL_strlcpy(name, "SDL_EVENT_USER", sizeof(name));
        if (event->type > SDL_EVENT_USER) {
            (void)SDL_snprintf(plusstr, sizeof(plusstr), "+%u", ((uint)event->type) - SDL_EVENT_USER);
        } else {
            plusstr[0] = '\0';
        }
        (void)SDL_snprintf(details, sizeof(details), "%s (timestamp=%u windowid=%u code=%d data1=%p data2=%p)",
                           plusstr, (uint)event->user.timestamp, (uint)event->user.windowID,
                           (int)event->user.code, event->user.data1, event->user.data2);
    }

    switch (event->type) {
#define SDL_EVENT_CASE(x) \
    case x:               \
        SDL_strlcpy(name, #x, sizeof(name));
        SDL_EVENT_CASE(SDL_EVENT_FIRST)
        SDL_strlcpy(details, " (THIS IS PROBABLY A BUG!)", sizeof(details));
        break;
        SDL_EVENT_CASE(SDL_EVENT_QUIT)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u)", (uint)event->quit.timestamp);
        break;
        SDL_EVENT_CASE(SDL_EVENT_TERMINATING)
        break;
        SDL_EVENT_CASE(SDL_EVENT_LOW_MEMORY)
        break;
        SDL_EVENT_CASE(SDL_EVENT_WILL_ENTER_BACKGROUND)
        break;
        SDL_EVENT_CASE(SDL_EVENT_DID_ENTER_BACKGROUND)
        break;
        SDL_EVENT_CASE(SDL_EVENT_WILL_ENTER_FOREGROUND)
        break;
        SDL_EVENT_CASE(SDL_EVENT_DID_ENTER_FOREGROUND)
        break;
        SDL_EVENT_CASE(SDL_EVENT_LOCALE_CHANGED)
        break;
        SDL_EVENT_CASE(SDL_EVENT_SYSTEM_THEME_CHANGED)
        break;
        SDL_EVENT_CASE(SDL_EVENT_KEYMAP_CHANGED)
        break;
        SDL_EVENT_CASE(SDL_EVENT_CLIPBOARD_UPDATE)
        break;

#define SDL_RENDEREVENT_CASE(x)                \
    case x:                                    \
        SDL_strlcpy(name, #x, sizeof(name));   \
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u event=%s windowid=%u)", \
                           (uint)event->display.timestamp, name, (uint)event->render.windowID); \
        break
        SDL_RENDEREVENT_CASE(SDL_EVENT_RENDER_TARGETS_RESET);
        SDL_RENDEREVENT_CASE(SDL_EVENT_RENDER_DEVICE_RESET);
        SDL_RENDEREVENT_CASE(SDL_EVENT_RENDER_DEVICE_LOST);

#define SDL_DISPLAYEVENT_CASE(x)               \
    case x:                                    \
        SDL_strlcpy(name, #x, sizeof(name));   \
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u display=%u event=%s data1=%d, data2=%d)", \
                           (uint)event->display.timestamp, (uint)event->display.displayID, name, (int)event->display.data1, (int)event->display.data2); \
        break
        SDL_DISPLAYEVENT_CASE(SDL_EVENT_DISPLAY_ORIENTATION);
        SDL_DISPLAYEVENT_CASE(SDL_EVENT_DISPLAY_ADDED);
        SDL_DISPLAYEVENT_CASE(SDL_EVENT_DISPLAY_REMOVED);
        SDL_DISPLAYEVENT_CASE(SDL_EVENT_DISPLAY_MOVED);
        SDL_DISPLAYEVENT_CASE(SDL_EVENT_DISPLAY_DESKTOP_MODE_CHANGED);
        SDL_DISPLAYEVENT_CASE(SDL_EVENT_DISPLAY_CURRENT_MODE_CHANGED);
        SDL_DISPLAYEVENT_CASE(SDL_EVENT_DISPLAY_CONTENT_SCALE_CHANGED);
#undef SDL_DISPLAYEVENT_CASE

#define SDL_WINDOWEVENT_CASE(x)                \
    case x:                                    \
        SDL_strlcpy(name, #x, sizeof(name)); \
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u event=%s data1=%d data2=%d)", \
                           (uint)event->window.timestamp, (uint)event->window.windowID, name, (int)event->window.data1, (int)event->window.data2); \
        break
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_SHOWN);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_HIDDEN);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_EXPOSED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_MOVED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_RESIZED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_METAL_VIEW_RESIZED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_SAFE_AREA_CHANGED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_MINIMIZED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_MAXIMIZED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_RESTORED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_MOUSE_ENTER);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_MOUSE_LEAVE);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_FOCUS_GAINED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_FOCUS_LOST);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_CLOSE_REQUESTED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_HIT_TEST);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_ICCPROF_CHANGED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_DISPLAY_CHANGED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_OCCLUDED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_ENTER_FULLSCREEN);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_LEAVE_FULLSCREEN);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_DESTROYED);
        SDL_WINDOWEVENT_CASE(SDL_EVENT_WINDOW_HDR_STATE_CHANGED);
#undef SDL_WINDOWEVENT_CASE

#define PRINT_KEYDEV_EVENT(event) (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%u)", (uint)event->kdevice.timestamp, (uint)event->kdevice.which)
        SDL_EVENT_CASE(SDL_EVENT_KEYBOARD_ADDED)
        PRINT_KEYDEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_KEYBOARD_REMOVED)
        PRINT_KEYDEV_EVENT(event);
        break;
#undef PRINT_KEYDEV_EVENT

#define PRINT_KEY_EVENT(event)                                                                                                              \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u state=%s repeat=%s scancode=%u keycode=%u mod=0x%x)", \
                       (uint)event->key.timestamp, (uint)event->key.windowID, (uint)event->key.which,                                       \
                       event->key.down ? "pressed" : "released",                                                            \
                       event->key.repeat ? "true" : "false",                                                                                \
                       (uint)event->key.scancode,                                                                                           \
                       (uint)event->key.key,                                                                                                \
                       (uint)event->key.mod)
        SDL_EVENT_CASE(SDL_EVENT_KEY_DOWN)
        PRINT_KEY_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_KEY_UP)
        PRINT_KEY_EVENT(event);
        break;
#undef PRINT_KEY_EVENT

        SDL_EVENT_CASE(SDL_EVENT_TEXT_EDITING)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u text='%s' start=%d length=%d)",
                           (uint)event->edit.timestamp, (uint)event->edit.windowID,
                           event->edit.text, (int)event->edit.start, (int)event->edit.length);
        break;

        SDL_EVENT_CASE(SDL_EVENT_TEXT_EDITING_CANDIDATES)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u num_candidates=%d selected_candidate=%d)",
                           (uint)event->edit_candidates.timestamp, (uint)event->edit_candidates.windowID,
                           (int)event->edit_candidates.num_candidates, (int)event->edit_candidates.selected_candidate);
        break;

        SDL_EVENT_CASE(SDL_EVENT_TEXT_INPUT)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u text='%s')", (uint)event->text.timestamp, (uint)event->text.windowID, event->text.text);
        break;

#define PRINT_MOUSEDEV_EVENT(event) (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%u)", (uint)event->mdevice.timestamp, (uint)event->mdevice.which)
        SDL_EVENT_CASE(SDL_EVENT_MOUSE_ADDED)
        PRINT_MOUSEDEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_MOUSE_REMOVED)
        PRINT_MOUSEDEV_EVENT(event);
        break;
#undef PRINT_MOUSEDEV_EVENT

        SDL_EVENT_CASE(SDL_EVENT_MOUSE_MOTION)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u state=%u x=%g y=%g xrel=%g yrel=%g)",
                           (uint)event->motion.timestamp, (uint)event->motion.windowID,
                           (uint)event->motion.which, (uint)event->motion.state,
                           event->motion.x, event->motion.y,
                           event->motion.xrel, event->motion.yrel);
        break;

#define PRINT_MBUTTON_EVENT(event)                                                                                              \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u button=%u state=%s clicks=%u x=%g y=%g)", \
                       (uint)event->button.timestamp, (uint)event->button.windowID,                                             \
                       (uint)event->button.which, (uint)event->button.button,                                                   \
                       event->button.down ? "pressed" : "released",                                                             \
                       (uint)event->button.clicks, event->button.x, event->button.y)
        SDL_EVENT_CASE(SDL_EVENT_MOUSE_BUTTON_DOWN)
        PRINT_MBUTTON_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_MOUSE_BUTTON_UP)
        PRINT_MBUTTON_EVENT(event);
        break;
#undef PRINT_MBUTTON_EVENT

        SDL_EVENT_CASE(SDL_EVENT_MOUSE_WHEEL)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u x=%g y=%g integer_x=%d integer_y=%d direction=%s)",
                           (uint)event->wheel.timestamp, (uint)event->wheel.windowID,
                           (uint)event->wheel.which, event->wheel.x, event->wheel.y,
                           (int)event->wheel.integer_x, (int)event->wheel.integer_y,
                           event->wheel.direction == SDL_MOUSEWHEEL_NORMAL ? "normal" : "flipped");
        break;

        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_AXIS_MOTION)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d axis=%u value=%d)",
                           (uint)event->jaxis.timestamp, (int)event->jaxis.which,
                           (uint)event->jaxis.axis, (int)event->jaxis.value);
        break;

        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_BALL_MOTION)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d ball=%u xrel=%d yrel=%d)",
                           (uint)event->jball.timestamp, (int)event->jball.which,
                           (uint)event->jball.ball, (int)event->jball.xrel, (int)event->jball.yrel);
        break;

        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_HAT_MOTION)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d hat=%u value=%u)",
                           (uint)event->jhat.timestamp, (int)event->jhat.which,
                           (uint)event->jhat.hat, (uint)event->jhat.value);
        break;

#define PRINT_JBUTTON_EVENT(event)                                                              \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d button=%u state=%s)", \
                       (uint)event->jbutton.timestamp, (int)event->jbutton.which,               \
                       (uint)event->jbutton.button, event->jbutton.down ? "pressed" : "released")
        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_BUTTON_DOWN)
        PRINT_JBUTTON_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_BUTTON_UP)
        PRINT_JBUTTON_EVENT(event);
        break;
#undef PRINT_JBUTTON_EVENT

        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_BATTERY_UPDATED)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d state=%u percent=%d)",
                           (uint)event->jbattery.timestamp, (int)event->jbattery.which,
                           event->jbattery.state, event->jbattery.percent);
        break;

#define PRINT_JOYDEV_EVENT(event) (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d)", (uint)event->jdevice.timestamp, (int)event->jdevice.which)
        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_ADDED)
        PRINT_JOYDEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_REMOVED)
        PRINT_JOYDEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_JOYSTICK_UPDATE_COMPLETE)
        PRINT_JOYDEV_EVENT(event);
        break;
#undef PRINT_JOYDEV_EVENT

        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_AXIS_MOTION)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d axis=%u value=%d)",
                           (uint)event->gaxis.timestamp, (int)event->gaxis.which,
                           (uint)event->gaxis.axis, (int)event->gaxis.value);
        break;

#define PRINT_CBUTTON_EVENT(event)                                                              \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d button=%u state=%s)", \
                       (uint)event->gbutton.timestamp, (int)event->gbutton.which,               \
                       (uint)event->gbutton.button, event->gbutton.down ? "pressed" : "released")
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_BUTTON_DOWN)
        PRINT_CBUTTON_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_BUTTON_UP)
        PRINT_CBUTTON_EVENT(event);
        break;
#undef PRINT_CBUTTON_EVENT

#define PRINT_GAMEPADDEV_EVENT(event) (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d)", (uint)event->gdevice.timestamp, (int)event->gdevice.which)
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_ADDED)
        PRINT_GAMEPADDEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_REMOVED)
        PRINT_GAMEPADDEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_REMAPPED)
        PRINT_GAMEPADDEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_UPDATE_COMPLETE)
        PRINT_GAMEPADDEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_STEAM_HANDLE_UPDATED)
        PRINT_GAMEPADDEV_EVENT(event);
        break;
#undef PRINT_GAMEPADDEV_EVENT

#define PRINT_CTOUCHPAD_EVENT(event)                                                                                     \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d touchpad=%d finger=%d x=%f y=%f pressure=%f)", \
                       (uint)event->gtouchpad.timestamp, (int)event->gtouchpad.which,                                    \
                       (int)event->gtouchpad.touchpad, (int)event->gtouchpad.finger,                                     \
                       event->gtouchpad.x, event->gtouchpad.y, event->gtouchpad.pressure)
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_TOUCHPAD_DOWN)
        PRINT_CTOUCHPAD_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_TOUCHPAD_UP)
        PRINT_CTOUCHPAD_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_TOUCHPAD_MOTION)
        PRINT_CTOUCHPAD_EVENT(event);
        break;
#undef PRINT_CTOUCHPAD_EVENT

        SDL_EVENT_CASE(SDL_EVENT_GAMEPAD_SENSOR_UPDATE)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d sensor=%d data[0]=%f data[1]=%f data[2]=%f)",
                           (uint)event->gsensor.timestamp, (int)event->gsensor.which, (int)event->gsensor.sensor,
                           event->gsensor.data[0], event->gsensor.data[1], event->gsensor.data[2]);
        break;

#define PRINT_FINGER_EVENT(event)                                                                                                                      \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u touchid=%" SDL_PRIu64 " fingerid=%" SDL_PRIu64 " x=%f y=%f dx=%f dy=%f pressure=%f)", \
                       (uint)event->tfinger.timestamp, event->tfinger.touchID,                                                              \
                       event->tfinger.fingerID, event->tfinger.x, event->tfinger.y,                                                         \
                       event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure)
        SDL_EVENT_CASE(SDL_EVENT_FINGER_DOWN)
        PRINT_FINGER_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_FINGER_UP)
        PRINT_FINGER_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_FINGER_CANCELED)
        PRINT_FINGER_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_FINGER_MOTION)
        PRINT_FINGER_EVENT(event);
        break;
#undef PRINT_FINGER_EVENT

#define PRINT_PTOUCH_EVENT(event)                                                                             \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u pen_state=%u x=%g y=%g eraser=%s state=%s)", \
                       (uint)event->ptouch.timestamp, (uint)event->ptouch.windowID, (uint)event->ptouch.which, (uint)event->ptouch.pen_state, event->ptouch.x, event->ptouch.y, \
                       event->ptouch.eraser ? "yes" : "no", event->ptouch.down ? "down" : "up");
        SDL_EVENT_CASE(SDL_EVENT_PEN_DOWN)
        PRINT_PTOUCH_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_PEN_UP)
        PRINT_PTOUCH_EVENT(event);
        break;
#undef PRINT_PTOUCH_EVENT

#define PRINT_PPROXIMITY_EVENT(event)                                                                             \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u)", \
                       (uint)event->pproximity.timestamp, (uint)event->pproximity.windowID, (uint)event->pproximity.which);
        SDL_EVENT_CASE(SDL_EVENT_PEN_PROXIMITY_IN)
        PRINT_PPROXIMITY_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_PEN_PROXIMITY_OUT)
        PRINT_PPROXIMITY_EVENT(event);
        break;
#undef PRINT_PPROXIMITY_EVENT

        SDL_EVENT_CASE(SDL_EVENT_PEN_AXIS)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u pen_state=%u x=%g y=%g axis=%s value=%g)",
                           (uint)event->paxis.timestamp, (uint)event->paxis.windowID, (uint)event->paxis.which, (uint)event->paxis.pen_state, event->paxis.x, event->paxis.y,
                           ((((int) event->paxis.axis) >= 0) && (event->paxis.axis < SDL_arraysize(pen_axisnames))) ? pen_axisnames[event->paxis.axis] : "[UNKNOWN]", event->paxis.value);
        break;

        SDL_EVENT_CASE(SDL_EVENT_PEN_MOTION)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u pen_state=%u x=%g y=%g)",
                           (uint)event->pmotion.timestamp, (uint)event->pmotion.windowID, (uint)event->pmotion.which, (uint)event->pmotion.pen_state, event->pmotion.x, event->pmotion.y);
        break;

#define PRINT_PBUTTON_EVENT(event)                                                                                                               \
    (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u windowid=%u which=%u pen_state=%u x=%g y=%g button=%u state=%s)", \
                       (uint)event->pbutton.timestamp, (uint)event->pbutton.windowID, (uint)event->pbutton.which, (uint)event->pbutton.pen_state, event->pbutton.x, event->pbutton.y, \
                       (uint)event->pbutton.button, event->pbutton.down ? "down" : "up");
        SDL_EVENT_CASE(SDL_EVENT_PEN_BUTTON_DOWN)
        PRINT_PBUTTON_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_PEN_BUTTON_UP)
        PRINT_PBUTTON_EVENT(event);
        break;
#undef PRINT_PBUTTON_EVENT

#define PRINT_DROP_EVENT(event) (void)SDL_snprintf(details, sizeof(details), " (data='%s' timestamp=%u windowid=%u x=%f y=%f)", event->drop.data, (uint)event->drop.timestamp, (uint)event->drop.windowID, event->drop.x, event->drop.y)
        SDL_EVENT_CASE(SDL_EVENT_DROP_FILE)
        PRINT_DROP_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_DROP_TEXT)
        PRINT_DROP_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_DROP_BEGIN)
        PRINT_DROP_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_DROP_COMPLETE)
        PRINT_DROP_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_DROP_POSITION)
        PRINT_DROP_EVENT(event);
        break;
#undef PRINT_DROP_EVENT

#define PRINT_AUDIODEV_EVENT(event) (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%u recording=%s)", (uint)event->adevice.timestamp, (uint)event->adevice.which, event->adevice.recording ? "true" : "false")
        SDL_EVENT_CASE(SDL_EVENT_AUDIO_DEVICE_ADDED)
        PRINT_AUDIODEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_AUDIO_DEVICE_REMOVED)
        PRINT_AUDIODEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_AUDIO_DEVICE_FORMAT_CHANGED)
        PRINT_AUDIODEV_EVENT(event);
        break;
#undef PRINT_AUDIODEV_EVENT

#define PRINT_CAMERADEV_EVENT(event) (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%u)", (uint)event->cdevice.timestamp, (uint)event->cdevice.which)
        SDL_EVENT_CASE(SDL_EVENT_CAMERA_DEVICE_ADDED)
        PRINT_CAMERADEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_CAMERA_DEVICE_REMOVED)
        PRINT_CAMERADEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_CAMERA_DEVICE_APPROVED)
        PRINT_CAMERADEV_EVENT(event);
        break;
        SDL_EVENT_CASE(SDL_EVENT_CAMERA_DEVICE_DENIED)
        PRINT_CAMERADEV_EVENT(event);
        break;
#undef PRINT_CAMERADEV_EVENT

        SDL_EVENT_CASE(SDL_EVENT_SENSOR_UPDATE)
        (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u which=%d data[0]=%f data[1]=%f data[2]=%f data[3]=%f data[4]=%f data[5]=%f)",
                           (uint)event->sensor.timestamp, (int)event->sensor.which,
                           event->sensor.data[0], event->sensor.data[1], event->sensor.data[2],
                           event->sensor.data[3], event->sensor.data[4], event->sensor.data[5]);
        break;

#undef SDL_EVENT_CASE

    case SDL_EVENT_POLL_SENTINEL:
        // No logging necessary for this one
        break;

    default:
        if (!name[0]) {
            if (event->type >= SDL_EVENT_USER) {
                SDL_strlcpy(name, "USER", sizeof(name));
            } else {
                SDL_strlcpy(name, "UNKNOWN", sizeof(name));
            }
            (void)SDL_snprintf(details, sizeof(details), " 0x%x", (uint)event->type);
        }
        break;
    }

    if (name[0]) {
        SDL_Log("SDL EVENT: %s%s", name, details);
    }

#undef uint
}

void SDL_StopEventLoop(void)
{
    const char *report = SDL_GetHint("SDL_EVENT_QUEUE_STATISTICS");
    int i;
    SDL_EventEntry *entry;

    SDL_LockMutex(SDL_EventQ.lock);

    SDL_EventQ.active = false;

    if (report && SDL_atoi(report)) {
        SDL_Log("SDL EVENT QUEUE: Maximum events in-flight: %d",
                SDL_EventQ.max_events_seen);
    }

    // Clean out EventQ
    for (entry = SDL_EventQ.head; entry;) {
        SDL_EventEntry *next = entry->next;
        SDL_TransferTemporaryMemoryFromEvent(entry);
        SDL_free(entry);
        entry = next;
    }
    for (entry = SDL_EventQ.free; entry;) {
        SDL_EventEntry *next = entry->next;
        SDL_free(entry);
        entry = next;
    }

    SDL_SetAtomicInt(&SDL_EventQ.count, 0);
    SDL_EventQ.max_events_seen = 0;
    SDL_EventQ.head = NULL;
    SDL_EventQ.tail = NULL;
    SDL_EventQ.free = NULL;
    SDL_SetAtomicInt(&SDL_sentinel_pending, 0);

    // Clear disabled event state
    for (i = 0; i < SDL_arraysize(SDL_disabled_events); ++i) {
        SDL_free(SDL_disabled_events[i]);
        SDL_disabled_events[i] = NULL;
    }

    SDL_QuitEventWatchList(&SDL_event_watchers);
    SDL_QuitWindowEventWatch();

    SDL_Mutex *lock = NULL;
    if (SDL_EventQ.lock) {
        lock = SDL_EventQ.lock;
        SDL_EventQ.lock = NULL;
    }

    SDL_UnlockMutex(lock);

    if (lock) {
        SDL_DestroyMutex(lock);
    }
}

// This function (and associated calls) may be called more than once
bool SDL_StartEventLoop(void)
{
    /* We'll leave the event queue alone, since we might have gotten
       some important events at launch (like SDL_EVENT_DROP_FILE)

       FIXME: Does this introduce any other bugs with events at startup?
     */

    // Create the lock and set ourselves active
#ifndef SDL_THREADS_DISABLED
    if (!SDL_EventQ.lock) {
        SDL_EventQ.lock = SDL_CreateMutex();
        if (SDL_EventQ.lock == NULL) {
            return false;
        }
    }
    SDL_LockMutex(SDL_EventQ.lock);

    if (!SDL_InitEventWatchList(&SDL_event_watchers)) {
        SDL_UnlockMutex(SDL_EventQ.lock);
        return false;
    }
#endif // !SDL_THREADS_DISABLED

    SDL_InitWindowEventWatch();

    SDL_EventQ.active = true;

#ifndef SDL_THREADS_DISABLED
    SDL_UnlockMutex(SDL_EventQ.lock);
#endif
    return true;
}

// Add an event to the event queue -- called with the queue locked
static int SDL_AddEvent(SDL_Event *event)
{
    SDL_EventEntry *entry;
    const int initial_count = SDL_GetAtomicInt(&SDL_EventQ.count);
    int final_count;

    if (initial_count >= SDL_MAX_QUEUED_EVENTS) {
        SDL_SetError("Event queue is full (%d events)", initial_count);
        return 0;
    }

    if (SDL_EventQ.free == NULL) {
        entry = (SDL_EventEntry *)SDL_malloc(sizeof(*entry));
        if (entry == NULL) {
            return 0;
        }
    } else {
        entry = SDL_EventQ.free;
        SDL_EventQ.free = entry->next;
    }

    if (SDL_EventLoggingVerbosity > 0) {
        SDL_LogEvent(event);
    }

    SDL_copyp(&entry->event, event);
    if (event->type == SDL_EVENT_POLL_SENTINEL) {
        SDL_AddAtomicInt(&SDL_sentinel_pending, 1);
    }
    entry->memory = NULL;
    SDL_TransferTemporaryMemoryToEvent(entry);

    if (SDL_EventQ.tail) {
        SDL_EventQ.tail->next = entry;
        entry->prev = SDL_EventQ.tail;
        SDL_EventQ.tail = entry;
        entry->next = NULL;
    } else {
        SDL_assert(!SDL_EventQ.head);
        SDL_EventQ.head = entry;
        SDL_EventQ.tail = entry;
        entry->prev = NULL;
        entry->next = NULL;
    }

    final_count = SDL_AddAtomicInt(&SDL_EventQ.count, 1) + 1;
    if (final_count > SDL_EventQ.max_events_seen) {
        SDL_EventQ.max_events_seen = final_count;
    }

    ++SDL_last_event_id;

    return 1;
}

// Remove an event from the queue -- called with the queue locked
static void SDL_CutEvent(SDL_EventEntry *entry)
{
    SDL_TransferTemporaryMemoryFromEvent(entry);

    if (entry->prev) {
        entry->prev->next = entry->next;
    }
    if (entry->next) {
        entry->next->prev = entry->prev;
    }

    if (entry == SDL_EventQ.head) {
        SDL_assert(entry->prev == NULL);
        SDL_EventQ.head = entry->next;
    }
    if (entry == SDL_EventQ.tail) {
        SDL_assert(entry->next == NULL);
        SDL_EventQ.tail = entry->prev;
    }

    if (entry->event.type == SDL_EVENT_POLL_SENTINEL) {
        SDL_AddAtomicInt(&SDL_sentinel_pending, -1);
    }

    entry->next = SDL_EventQ.free;
    SDL_EventQ.free = entry;
    SDL_assert(SDL_GetAtomicInt(&SDL_EventQ.count) > 0);
    SDL_AddAtomicInt(&SDL_EventQ.count, -1);
}

static void SDL_SendWakeupEvent(void)
{
#ifdef SDL_PLATFORM_ANDROID
    Android_SendLifecycleEvent(SDL_ANDROID_LIFECYCLE_WAKE);
#else
    SDL_VideoDevice *_this = SDL_GetVideoDevice();
    if (_this == NULL || !_this->SendWakeupEvent) {
        return;
    }

    SDL_LockMutex(_this->wakeup_lock);
    {
        if (_this->wakeup_window) {
            _this->SendWakeupEvent(_this, _this->wakeup_window);

            // No more wakeup events needed until we enter a new wait
            _this->wakeup_window = NULL;
        }
    }
    SDL_UnlockMutex(_this->wakeup_lock);
#endif
}

// Lock the event queue, take a peep at it, and unlock it
static int SDL_PeepEventsInternal(SDL_Event *events, int numevents, SDL_EventAction action,
                                  Uint32 minType, Uint32 maxType, bool include_sentinel)
{
    int i, used, sentinels_expected = 0;

    // Lock the event queue
    used = 0;

    SDL_LockMutex(SDL_EventQ.lock);
    {
        // Don't look after we've quit
        if (!SDL_EventQ.active) {
            // We get a few spurious events at shutdown, so don't warn then
            if (action == SDL_GETEVENT) {
                SDL_SetError("The event system has been shut down");
            }
            SDL_UnlockMutex(SDL_EventQ.lock);
            return -1;
        }
        if (action == SDL_ADDEVENT) {
            if (!events) {
                SDL_UnlockMutex(SDL_EventQ.lock);
                return SDL_InvalidParamError("events");
            }
            for (i = 0; i < numevents; ++i) {
                used += SDL_AddEvent(&events[i]);
            }
        } else {
            SDL_EventEntry *entry, *next;
            Uint32 type;

            for (entry = SDL_EventQ.head; entry && (events == NULL || used < numevents); entry = next) {
                next = entry->next;
                type = entry->event.type;
                if (minType <= type && type <= maxType) {
                    if (events) {
                        SDL_copyp(&events[used], &entry->event);

                        if (action == SDL_GETEVENT) {
                            SDL_CutEvent(entry);
                        }
                    }
                    if (type == SDL_EVENT_POLL_SENTINEL) {
                        // Special handling for the sentinel event
                        if (!include_sentinel) {
                            // Skip it, we don't want to include it
                            continue;
                        }
                        if (events == NULL || action != SDL_GETEVENT) {
                            ++sentinels_expected;
                        }
                        if (SDL_GetAtomicInt(&SDL_sentinel_pending) > sentinels_expected) {
                            // Skip it, there's another one pending
                            continue;
                        }
                    }
                    ++used;
                }
            }
        }
    }
    SDL_UnlockMutex(SDL_EventQ.lock);

    if (used > 0 && action == SDL_ADDEVENT) {
        SDL_SendWakeupEvent();
    }

    return used;
}
int SDL_PeepEvents(SDL_Event *events, int numevents, SDL_EventAction action,
                   Uint32 minType, Uint32 maxType)
{
    return SDL_PeepEventsInternal(events, numevents, action, minType, maxType, false);
}

bool SDL_HasEvent(Uint32 type)
{
    return SDL_HasEvents(type, type);
}

bool SDL_HasEvents(Uint32 minType, Uint32 maxType)
{
    bool found = false;

    SDL_LockMutex(SDL_EventQ.lock);
    {
        if (SDL_EventQ.active) {
            for (SDL_EventEntry *entry = SDL_EventQ.head; entry; entry = entry->next) {
                const Uint32 type = entry->event.type;
                if (minType <= type && type <= maxType) {
                    found = true;
                    break;
                }
            }
        }
    }
    SDL_UnlockMutex(SDL_EventQ.lock);

    return found;
}

void SDL_FlushEvent(Uint32 type)
{
    SDL_FlushEvents(type, type);
}

void SDL_FlushEvents(Uint32 minType, Uint32 maxType)
{
    SDL_EventEntry *entry, *next;
    Uint32 type;

    // Make sure the events are current
#if 0
    /* Actually, we can't do this since we might be flushing while processing
       a resize event, and calling this might trigger further resize events.
    */
    SDL_PumpEvents();
#endif

    // Lock the event queue
    SDL_LockMutex(SDL_EventQ.lock);
    {
        // Don't look after we've quit
        if (!SDL_EventQ.active) {
            SDL_UnlockMutex(SDL_EventQ.lock);
            return;
        }
        for (entry = SDL_EventQ.head; entry; entry = next) {
            next = entry->next;
            type = entry->event.type;
            if (minType <= type && type <= maxType) {
                SDL_CutEvent(entry);
            }
        }
    }
    SDL_UnlockMutex(SDL_EventQ.lock);
}

typedef enum
{
    SDL_MAIN_CALLBACK_WAITING,
    SDL_MAIN_CALLBACK_COMPLETE,
    SDL_MAIN_CALLBACK_CANCELED,
} SDL_MainThreadCallbackState;

typedef struct SDL_MainThreadCallbackEntry
{
    SDL_MainThreadCallback callback;
    void *userdata;
    SDL_AtomicInt state;
    SDL_Semaphore *semaphore;
    struct SDL_MainThreadCallbackEntry *next;
} SDL_MainThreadCallbackEntry;

static SDL_Mutex *SDL_main_callbacks_lock;
static SDL_MainThreadCallbackEntry *SDL_main_callbacks_head;
static SDL_MainThreadCallbackEntry *SDL_main_callbacks_tail;

static SDL_MainThreadCallbackEntry *SDL_CreateMainThreadCallback(SDL_MainThreadCallback callback, void *userdata, bool wait_complete)
{
    SDL_MainThreadCallbackEntry *entry = (SDL_MainThreadCallbackEntry *)SDL_malloc(sizeof(*entry));
    if (!entry) {
        return NULL;
    }

    entry->callback = callback;
    entry->userdata = userdata;
    SDL_SetAtomicInt(&entry->state, SDL_MAIN_CALLBACK_WAITING);
    if (wait_complete) {
        entry->semaphore = SDL_CreateSemaphore(0);
        if (!entry->semaphore) {
            SDL_free(entry);
            return NULL;
        }
    } else {
        entry->semaphore = NULL;
    }
    entry->next = NULL;

    return entry;
}

static void SDL_DestroyMainThreadCallback(SDL_MainThreadCallbackEntry *entry)
{
    if (entry->semaphore) {
        SDL_DestroySemaphore(entry->semaphore);
    }
    SDL_free(entry);
}

static void SDL_InitMainThreadCallbacks(void)
{
    SDL_main_callbacks_lock = SDL_CreateMutex();
    SDL_assert(SDL_main_callbacks_head == NULL &&
               SDL_main_callbacks_tail == NULL);
}

static void SDL_QuitMainThreadCallbacks(void)
{
    SDL_MainThreadCallbackEntry *entry;

    SDL_LockMutex(SDL_main_callbacks_lock);
    {
        entry = SDL_main_callbacks_head;
        SDL_main_callbacks_head = NULL;
        SDL_main_callbacks_tail = NULL;
    }
    SDL_UnlockMutex(SDL_main_callbacks_lock);

    while (entry) {
        SDL_MainThreadCallbackEntry *next = entry->next;

        if (entry->semaphore) {
            // Let the waiting thread know this is canceled
            SDL_SetAtomicInt(&entry->state, SDL_MAIN_CALLBACK_CANCELED);
            SDL_SignalSemaphore(entry->semaphore);
        } else {
            // Nobody's waiting for this, clean it up
            SDL_DestroyMainThreadCallback(entry);
        }
        entry = next;
    }

    SDL_DestroyMutex(SDL_main_callbacks_lock);
    SDL_main_callbacks_lock = NULL;
}

static void SDL_RunMainThreadCallbacks(void)
{
    SDL_MainThreadCallbackEntry *entry;

    SDL_LockMutex(SDL_main_callbacks_lock);
    {
        entry = SDL_main_callbacks_head;
        SDL_main_callbacks_head = NULL;
        SDL_main_callbacks_tail = NULL;
    }
    SDL_UnlockMutex(SDL_main_callbacks_lock);

    while (entry) {
        SDL_MainThreadCallbackEntry *next = entry->next;

        entry->callback(entry->userdata);

        if (entry->semaphore) {
            // Let the waiting thread know this is done
            SDL_SetAtomicInt(&entry->state, SDL_MAIN_CALLBACK_COMPLETE);
            SDL_SignalSemaphore(entry->semaphore);
        } else {
            // Nobody's waiting for this, clean it up
            SDL_DestroyMainThreadCallback(entry);
        }
        entry = next;
    }
}

bool SDL_RunOnMainThread(SDL_MainThreadCallback callback, void *userdata, bool wait_complete)
{
    if (SDL_IsMainThread() || !SDL_WasInit(SDL_INIT_EVENTS)) {
        // No need to queue the callback
        callback(userdata);
        return true;
    }

    SDL_MainThreadCallbackEntry *entry = SDL_CreateMainThreadCallback(callback, userdata, wait_complete);
    if (!entry) {
        return false;
    }

    SDL_LockMutex(SDL_main_callbacks_lock);
    {
        if (SDL_main_callbacks_tail) {
            SDL_main_callbacks_tail->next = entry;
            SDL_main_callbacks_tail = entry;
        } else {
            SDL_main_callbacks_head = entry;
            SDL_main_callbacks_tail = entry;
        }
    }
    SDL_UnlockMutex(SDL_main_callbacks_lock);

    // If the main thread is waiting for events, wake it up
    SDL_SendWakeupEvent();

    if (!wait_complete) {
        // Queued for execution, wait not requested
        return true;
    }

    SDL_WaitSemaphore(entry->semaphore);

    switch (SDL_GetAtomicInt(&entry->state)) {
    case SDL_MAIN_CALLBACK_COMPLETE:
        // Execution complete!
        SDL_DestroyMainThreadCallback(entry);
        return true;

    case SDL_MAIN_CALLBACK_CANCELED:
        // The callback was canceled on the main thread
        SDL_DestroyMainThreadCallback(entry);
        return SDL_SetError("Callback canceled");

    default:
        // Probably hit a deadlock in the callback
        // We can't destroy the entry as the semaphore will be signaled
        // if it ever comes back, just leak it here.
        return SDL_SetError("Callback timed out");
    }
}

void SDL_PumpEventMaintenance(void)
{
#ifndef SDL_AUDIO_DISABLED
    SDL_UpdateAudio();
#endif

#ifndef SDL_CAMERA_DISABLED
    SDL_UpdateCamera();
#endif

#ifndef SDL_SENSOR_DISABLED
    // Check for sensor state change
    if (SDL_update_sensors) {
        SDL_UpdateSensors();
    }
#endif

#ifndef SDL_JOYSTICK_DISABLED
    // Check for joystick state change
    if (SDL_update_joysticks) {
        SDL_UpdateJoysticks();
    }
#endif

    SDL_UpdateTrays();

    SDL_SendPendingSignalEvents(); // in case we had a signal handler fire, etc.
}

// Run the system dependent event loops
static void SDL_PumpEventsInternal(bool push_sentinel)
{
    // Free any temporary memory from old events
    SDL_FreeTemporaryMemory();

    // Release any keys held down from last frame
    SDL_ReleaseAutoReleaseKeys();

    // Run any pending main thread callbacks
    SDL_RunMainThreadCallbacks();

#ifdef SDL_PLATFORM_ANDROID
    // Android event processing is independent of the video subsystem
    Android_PumpEvents(0);
#else
    // Get events from the video subsystem
    SDL_VideoDevice *_this = SDL_GetVideoDevice();
    if (_this) {
        _this->PumpEvents(_this);
    }
#endif

    SDL_PumpEventMaintenance();

    if (push_sentinel && SDL_EventEnabled(SDL_EVENT_POLL_SENTINEL)) {
        SDL_Event sentinel;

        // Make sure we don't already have a sentinel in the queue, and add one to the end
        if (SDL_GetAtomicInt(&SDL_sentinel_pending) > 0) {
            SDL_PeepEventsInternal(&sentinel, 1, SDL_GETEVENT, SDL_EVENT_POLL_SENTINEL, SDL_EVENT_POLL_SENTINEL, true);
        }

        sentinel.type = SDL_EVENT_POLL_SENTINEL;
        sentinel.common.timestamp = 0;
        SDL_PushEvent(&sentinel);
    }
}

void SDL_PumpEvents(void)
{
    SDL_PumpEventsInternal(false);
}

// Public functions

bool SDL_PollEvent(SDL_Event *event)
{
    return SDL_WaitEventTimeoutNS(event, 0);
}

#ifndef SDL_PLATFORM_ANDROID

static Sint64 SDL_events_get_polling_interval(void)
{
    Sint64 poll_intervalNS = SDL_MAX_SINT64;

#ifndef SDL_JOYSTICK_DISABLED
    if (SDL_WasInit(SDL_INIT_JOYSTICK) && SDL_update_joysticks) {
        if (SDL_JoysticksOpened()) {
            // If we have joysticks open, we need to poll rapidly for events
            poll_intervalNS = SDL_min(poll_intervalNS, EVENT_POLL_INTERVAL_NS);
        } else {
            // If not, just poll every few seconds to enumerate new joysticks
            poll_intervalNS = SDL_min(poll_intervalNS, ENUMERATION_POLL_INTERVAL_NS);
        }
    }
#endif

#ifndef SDL_SENSOR_DISABLED
    if (SDL_WasInit(SDL_INIT_SENSOR) && SDL_update_sensors && SDL_SensorsOpened()) {
        // If we have sensors open, we need to poll rapidly for events
        poll_intervalNS = SDL_min(poll_intervalNS, EVENT_POLL_INTERVAL_NS);
    }
#endif

    return poll_intervalNS;
}

static int SDL_WaitEventTimeout_Device(SDL_VideoDevice *_this, SDL_Window *wakeup_window, SDL_Event *event, Uint64 start, Sint64 timeoutNS)
{
    Sint64 loop_timeoutNS = timeoutNS;
    Sint64 poll_intervalNS = SDL_events_get_polling_interval();

    for (;;) {
        int status;
        /* Pump events on entry and each time we wake to ensure:
           a) All pending events are batch processed after waking up from a wait
           b) Waiting can be completely skipped if events are already available to be pumped
           c) Periodic processing that takes place in some platform PumpEvents() functions happens
           d) Signals received in WaitEventTimeout() are turned into SDL events
        */
        SDL_PumpEventsInternal(true);

        SDL_LockMutex(_this->wakeup_lock);
        {
            status = SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_EVENT_FIRST, SDL_EVENT_LAST);
            // If status == 0 we are going to block so wakeup will be needed.
            if (status == 0) {
                _this->wakeup_window = wakeup_window;
            } else {
                _this->wakeup_window = NULL;
            }
        }
        SDL_UnlockMutex(_this->wakeup_lock);

        if (status < 0) {
            // Got an error: return
            break;
        }
        if (status > 0) {
            // There is an event, we can return.
            return 1;
        }
        // No events found in the queue, call WaitEventTimeout to wait for an event.
        if (timeoutNS > 0) {
            Sint64 elapsed = SDL_GetTicksNS() - start;
            if (elapsed >= timeoutNS) {
                // Set wakeup_window to NULL without holding the lock.
                _this->wakeup_window = NULL;
                return 0;
            }
            loop_timeoutNS = (timeoutNS - elapsed);
        }
        // Adjust the timeout for any polling requirements we currently have.
        if (poll_intervalNS != SDL_MAX_SINT64) {
            if (loop_timeoutNS >= 0) {
                loop_timeoutNS = SDL_min(loop_timeoutNS, poll_intervalNS);
            } else {
                loop_timeoutNS = poll_intervalNS;
            }
        }
        status = _this->WaitEventTimeout(_this, loop_timeoutNS);
        // Set wakeup_window to NULL without holding the lock.
        _this->wakeup_window = NULL;
        if (status == 0 && poll_intervalNS != SDL_MAX_SINT64 && loop_timeoutNS == poll_intervalNS) {
            // We may have woken up to poll. Try again
            continue;
        } else if (status <= 0) {
            // There is either an error or the timeout is elapsed: return
            return status;
        }
        /* An event was found and pumped into the SDL events queue. Continue the loop
          to let SDL_PeepEvents pick it up .*/
    }
    return 0;
}

static SDL_Window *SDL_find_active_window(SDL_VideoDevice *_this)
{
    SDL_Window *window;
    for (window = _this->windows; window; window = window->next) {
        if (!window->is_destroying) {
            return window;
        }
    }
    return NULL;
}

#endif // !SDL_PLATFORM_ANDROID

bool SDL_WaitEvent(SDL_Event *event)
{
    return SDL_WaitEventTimeoutNS(event, -1);
}

bool SDL_WaitEventTimeout(SDL_Event *event, Sint32 timeoutMS)
{
    Sint64 timeoutNS;

    if (timeoutMS > 0) {
        timeoutNS = SDL_MS_TO_NS(timeoutMS);
    } else {
        timeoutNS = timeoutMS;
    }
    return SDL_WaitEventTimeoutNS(event, timeoutNS);
}

bool SDL_WaitEventTimeoutNS(SDL_Event *event, Sint64 timeoutNS)
{
    Uint64 start, expiration;
    bool include_sentinel = (timeoutNS == 0);
    int result;

    if (timeoutNS > 0) {
        start = SDL_GetTicksNS();
        expiration = start + timeoutNS;
    } else {
        start = 0;
        expiration = 0;
    }

    // If there isn't a poll sentinel event pending, pump events and add one
    if (SDL_GetAtomicInt(&SDL_sentinel_pending) == 0) {
        SDL_PumpEventsInternal(true);
    }

    // First check for existing events
    result = SDL_PeepEventsInternal(event, 1, SDL_GETEVENT, SDL_EVENT_FIRST, SDL_EVENT_LAST, include_sentinel);
    if (result < 0) {
        return false;
    }
    if (include_sentinel) {
        if (event) {
            if (event->type == SDL_EVENT_POLL_SENTINEL) {
                // Reached the end of a poll cycle, and not willing to wait
                return false;
            }
        } else {
            // Need to peek the next event to check for sentinel
            SDL_Event dummy;

            if (SDL_PeepEventsInternal(&dummy, 1, SDL_PEEKEVENT, SDL_EVENT_FIRST, SDL_EVENT_LAST, true) &&
                dummy.type == SDL_EVENT_POLL_SENTINEL) {
                SDL_PeepEventsInternal(&dummy, 1, SDL_GETEVENT, SDL_EVENT_POLL_SENTINEL, SDL_EVENT_POLL_SENTINEL, true);
                // Reached the end of a poll cycle, and not willing to wait
                return false;
            }
        }
    }
    if (result == 0) {
        if (timeoutNS == 0) {
            // No events available, and not willing to wait
            return false;
        }
    } else {
        // Has existing events
        return true;
    }
    // We should have completely handled timeoutNS == 0 above
    SDL_assert(timeoutNS != 0);

#ifdef SDL_PLATFORM_ANDROID
    for (;;) {
        if (SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_EVENT_FIRST, SDL_EVENT_LAST) > 0) {
            return true;
        }

        Uint64 delay = -1;
        if (timeoutNS > 0) {
            Uint64 now = SDL_GetTicksNS();
            if (now >= expiration) {
                // Timeout expired and no events
                return false;
            }
            delay = (expiration - now);
        }
        Android_PumpEvents(delay);
    }
#else
    SDL_VideoDevice *_this = SDL_GetVideoDevice();
    if (_this && _this->WaitEventTimeout && _this->SendWakeupEvent) {
        // Look if a shown window is available to send the wakeup event.
        SDL_Window *wakeup_window = SDL_find_active_window(_this);
        if (wakeup_window) {
            result = SDL_WaitEventTimeout_Device(_this, wakeup_window, event, start, timeoutNS);
            if (result > 0) {
                return true;
            } else if (result == 0) {
                return false;
            } else {
                /* There may be implementation-defined conditions where the backend cannot
                 * reliably wait for the next event. If that happens, fall back to polling.
                 */
            }
        }
    }

    for (;;) {
        SDL_PumpEventsInternal(true);

        if (SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_EVENT_FIRST, SDL_EVENT_LAST) > 0) {
            return true;
        }

        Uint64 delay = EVENT_POLL_INTERVAL_NS;
        if (timeoutNS > 0) {
            Uint64 now = SDL_GetTicksNS();
            if (now >= expiration) {
                // Timeout expired and no events
                return false;
            }
            delay = SDL_min((expiration - now), delay);
        }
        SDL_DelayNS(delay);
    }
#endif // SDL_PLATFORM_ANDROID
}

static bool SDL_CallEventWatchers(SDL_Event *event)
{
    if (event->common.type == SDL_EVENT_POLL_SENTINEL) {
        return true;
    }

    return SDL_DispatchEventWatchList(&SDL_event_watchers, event);
}

bool SDL_PushEvent(SDL_Event *event)
{
    if (!event->common.timestamp) {
        event->common.timestamp = SDL_GetTicksNS();
    }

    if (!SDL_CallEventWatchers(event)) {
        SDL_ClearError();
        return false;
    }

    if (SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0, 0) <= 0) {
        return false;
    }

    return true;
}

void SDL_SetEventFilter(SDL_EventFilter filter, void *userdata)
{
    SDL_EventEntry *event, *next;
    SDL_LockMutex(SDL_event_watchers.lock);
    {
        // Set filter and discard pending events
        SDL_event_watchers.filter.callback = filter;
        SDL_event_watchers.filter.userdata = userdata;
        if (filter) {
            // Cut all events not accepted by the filter
            SDL_LockMutex(SDL_EventQ.lock);
            {
                for (event = SDL_EventQ.head; event; event = next) {
                    next = event->next;
                    if (!filter(userdata, &event->event)) {
                        SDL_CutEvent(event);
                    }
                }
            }
            SDL_UnlockMutex(SDL_EventQ.lock);
        }
    }
    SDL_UnlockMutex(SDL_event_watchers.lock);
}

bool SDL_GetEventFilter(SDL_EventFilter *filter, void **userdata)
{
    SDL_EventWatcher event_ok;

    SDL_LockMutex(SDL_event_watchers.lock);
    {
        event_ok = SDL_event_watchers.filter;
    }
    SDL_UnlockMutex(SDL_event_watchers.lock);

    if (filter) {
        *filter = event_ok.callback;
    }
    if (userdata) {
        *userdata = event_ok.userdata;
    }
    return event_ok.callback ? true : false;
}

bool SDL_AddEventWatch(SDL_EventFilter filter, void *userdata)
{
    return SDL_AddEventWatchList(&SDL_event_watchers, filter, userdata);
}

void SDL_RemoveEventWatch(SDL_EventFilter filter, void *userdata)
{
    SDL_RemoveEventWatchList(&SDL_event_watchers, filter, userdata);
}

void SDL_FilterEvents(SDL_EventFilter filter, void *userdata)
{
    SDL_LockMutex(SDL_EventQ.lock);
    {
        SDL_EventEntry *entry, *next;
        for (entry = SDL_EventQ.head; entry; entry = next) {
            next = entry->next;
            if (!filter(userdata, &entry->event)) {
                SDL_CutEvent(entry);
            }
        }
    }
    SDL_UnlockMutex(SDL_EventQ.lock);
}

void SDL_SetEventEnabled(Uint32 type, bool enabled)
{
    bool current_state;
    Uint8 hi = ((type >> 8) & 0xff);
    Uint8 lo = (type & 0xff);

    if (SDL_disabled_events[hi] &&
        (SDL_disabled_events[hi]->bits[lo / 32] & (1U << (lo & 31)))) {
        current_state = false;
    } else {
        current_state = true;
    }

    if ((enabled != false) != current_state) {
        if (enabled) {
            SDL_assert(SDL_disabled_events[hi] != NULL);
            SDL_disabled_events[hi]->bits[lo / 32] &= ~(1U << (lo & 31));

            // Gamepad events depend on joystick events
            switch (type) {
            case SDL_EVENT_GAMEPAD_ADDED:
                SDL_SetEventEnabled(SDL_EVENT_JOYSTICK_ADDED, true);
                break;
            case SDL_EVENT_GAMEPAD_REMOVED:
                SDL_SetEventEnabled(SDL_EVENT_JOYSTICK_REMOVED, true);
                break;
            case SDL_EVENT_GAMEPAD_AXIS_MOTION:
            case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
            case SDL_EVENT_GAMEPAD_BUTTON_UP:
                SDL_SetEventEnabled(SDL_EVENT_JOYSTICK_AXIS_MOTION, true);
                SDL_SetEventEnabled(SDL_EVENT_JOYSTICK_HAT_MOTION, true);
                SDL_SetEventEnabled(SDL_EVENT_JOYSTICK_BUTTON_DOWN, true);
                SDL_SetEventEnabled(SDL_EVENT_JOYSTICK_BUTTON_UP, true);
                break;
            case SDL_EVENT_GAMEPAD_UPDATE_COMPLETE:
                SDL_SetEventEnabled(SDL_EVENT_JOYSTICK_UPDATE_COMPLETE, true);
                break;
            default:
                break;
            }
        } else {
            // Disable this event type and discard pending events
            if (!SDL_disabled_events[hi]) {
                SDL_disabled_events[hi] = (SDL_DisabledEventBlock *)SDL_calloc(1, sizeof(SDL_DisabledEventBlock));
            }
            // Out of memory, nothing we can do...
            if (SDL_disabled_events[hi]) {
                SDL_disabled_events[hi]->bits[lo / 32] |= (1U << (lo & 31));
                SDL_FlushEvent(type);
            }
        }

        /* turn off drag'n'drop support if we've disabled the events.
           This might change some UI details at the OS level. */
        if (type == SDL_EVENT_DROP_FILE || type == SDL_EVENT_DROP_TEXT) {
            SDL_ToggleDragAndDropSupport();
        }
    }
}

bool SDL_EventEnabled(Uint32 type)
{
    Uint8 hi = ((type >> 8) & 0xff);
    Uint8 lo = (type & 0xff);

    if (SDL_disabled_events[hi] &&
        (SDL_disabled_events[hi]->bits[lo / 32] & (1U << (lo & 31)))) {
        return false;
    } else {
        return true;
    }
}

Uint32 SDL_RegisterEvents(int numevents)
{
    Uint32 event_base = 0;

    if (numevents > 0) {
        int value = SDL_AddAtomicInt(&SDL_userevents, numevents);
        if (value >= 0 && value <= (SDL_EVENT_LAST - SDL_EVENT_USER)) {
            event_base = (Uint32)(SDL_EVENT_USER + value);
        }
    }
    return event_base;
}

void SDL_SendAppEvent(SDL_EventType eventType)
{
    if (SDL_EventEnabled(eventType)) {
        SDL_Event event;
        event.type = eventType;
        event.common.timestamp = 0;

        switch (eventType) {
        case SDL_EVENT_TERMINATING:
        case SDL_EVENT_LOW_MEMORY:
        case SDL_EVENT_WILL_ENTER_BACKGROUND:
        case SDL_EVENT_DID_ENTER_BACKGROUND:
        case SDL_EVENT_WILL_ENTER_FOREGROUND:
        case SDL_EVENT_DID_ENTER_FOREGROUND:
            // We won't actually queue this event, it needs to be handled in this call stack by an event watcher
            if (SDL_EventLoggingVerbosity > 0) {
                SDL_LogEvent(&event);
            }
            SDL_CallEventWatchers(&event);
            break;
        default:
            SDL_PushEvent(&event);
            break;
        }
    }
}

void SDL_SendKeymapChangedEvent(void)
{
    SDL_SendAppEvent(SDL_EVENT_KEYMAP_CHANGED);
}

void SDL_SendLocaleChangedEvent(void)
{
    SDL_SendAppEvent(SDL_EVENT_LOCALE_CHANGED);
}

void SDL_SendSystemThemeChangedEvent(void)
{
    SDL_SendAppEvent(SDL_EVENT_SYSTEM_THEME_CHANGED);
}

bool SDL_InitEvents(void)
{
#ifdef SDL_PLATFORM_ANDROID
    Android_InitEvents();
#endif
#ifndef SDL_JOYSTICK_DISABLED
    SDL_AddHintCallback(SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_AutoUpdateJoysticksChanged, NULL);
#endif
#ifndef SDL_SENSOR_DISABLED
    SDL_AddHintCallback(SDL_HINT_AUTO_UPDATE_SENSORS, SDL_AutoUpdateSensorsChanged, NULL);
#endif
    SDL_AddHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
    SDL_AddHintCallback(SDL_HINT_POLL_SENTINEL, SDL_PollSentinelChanged, NULL);
    SDL_InitMainThreadCallbacks();
    if (!SDL_StartEventLoop()) {
        SDL_RemoveHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
        return false;
    }

    SDL_InitQuit();

    return true;
}

void SDL_QuitEvents(void)
{
    SDL_QuitQuit();
    SDL_StopEventLoop();
    SDL_QuitMainThreadCallbacks();
    SDL_RemoveHintCallback(SDL_HINT_POLL_SENTINEL, SDL_PollSentinelChanged, NULL);
    SDL_RemoveHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
#ifndef SDL_JOYSTICK_DISABLED
    SDL_RemoveHintCallback(SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_AutoUpdateJoysticksChanged, NULL);
#endif
#ifndef SDL_SENSOR_DISABLED
    SDL_RemoveHintCallback(SDL_HINT_AUTO_UPDATE_SENSORS, SDL_AutoUpdateSensorsChanged, NULL);
#endif
#ifdef SDL_PLATFORM_ANDROID
    Android_QuitEvents();
#endif
}