#include "../SDL_internal.h"
#include "SDL.h"
#include "SDL_events.h"
#include "SDL_thread.h"
#include "SDL_events_c.h"
#include "../timer/SDL_timer_c.h"
#include "../joystick/SDL_joystick_c.h"
#include "../video/SDL_sysvideo.h"
#include "SDL_syswm.h"

Include dependency graph for SDL_events.c:

Data Structures
struct	SDL_EventWatcher

struct	SDL_DisabledEventBlock

struct	SDL_EventEntry

struct	SDL_SysWMEntry

Macros
#define	SDL_PRIs64 "I64d"

#define	SDL_MAX_QUEUED_EVENTS 65535

#define	uint unsigned int

#define	SDL_EVENT_CASE(x) case x: SDL_strlcpy(name, #x, sizeof (name));

#define	SDL_WINDOWEVENT_CASE(x) case x: SDL_strlcpy(name2, #x, sizeof (name2)); break

#define	PRINT_KEY_EVENT(event)

#define	PRINT_MBUTTON_EVENT(event)

#define	PRINT_JBUTTON_EVENT(event)

#define	PRINT_JOYDEV_EVENT(event) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d)", (uint) event->jdevice.timestamp, (int) event->jdevice.which)

#define	PRINT_CBUTTON_EVENT(event)

#define	PRINT_CONTROLLERDEV_EVENT(event) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d)", (uint) event->cdevice.timestamp, (int) event->cdevice.which)

#define	PRINT_FINGER_EVENT(event)

#define	PRINT_DOLLAR_EVENT(event)

#define	PRINT_DROP_EVENT(event) SDL_snprintf(details, sizeof (details), " (file='%s' timestamp=%u windowid=%u)", event->drop.file, (uint) event->drop.timestamp, (uint) event->drop.windowID)

#define	PRINT_AUDIODEV_EVENT(event) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%u iscapture=%s)", (uint) event->adevice.timestamp, (uint) event->adevice.which, event->adevice.iscapture ? "true" : "false");

Functions
static void	SDL_CalculateShouldUpdateJoysticks ()

static void	SDL_AutoUpdateJoysticksChanged (void userdata, const char name, const char oldValue, const char hint)

static void	SDL_CalculateShouldUpdateSensors ()

static void	SDL_AutoUpdateSensorsChanged (void userdata, const char name, const char oldValue, const char hint)

static void	SDL_EventLoggingChanged (void userdata, const char name, const char oldValue, const char hint)

static void	SDL_LogEvent (const SDL_Event *event)

void	SDL_StopEventLoop (void)

int	SDL_StartEventLoop (void)

static int	SDL_AddEvent (SDL_Event *event)

static void	SDL_CutEvent (SDL_EventEntry *entry)

int	SDL_PeepEvents (SDL_Event *events, int numevents, SDL_eventaction action, Uint32 minType, Uint32 maxType)

SDL_bool	SDL_HasEvent (Uint32 type)

SDL_bool	SDL_HasEvents (Uint32 minType, Uint32 maxType)

void	SDL_FlushEvent (Uint32 type)

void	SDL_FlushEvents (Uint32 minType, Uint32 maxType)

void	SDL_PumpEvents (void)

int	SDL_PollEvent (SDL_Event *event)
	Polls for currently pending events. More...

int	SDL_WaitEvent (SDL_Event *event)
	Waits indefinitely for the next available event. More...

int	SDL_WaitEventTimeout (SDL_Event *event, int timeout)
	Waits until the specified timeout (in milliseconds) for the next available event. More...

int	SDL_PushEvent (SDL_Event *event)
	Add an event to the event queue. More...

void	SDL_SetEventFilter (SDL_EventFilter filter, void *userdata)

SDL_bool	SDL_GetEventFilter (SDL_EventFilter filter, void *userdata)

void	SDL_AddEventWatch (SDL_EventFilter filter, void *userdata)

void	SDL_DelEventWatch (SDL_EventFilter filter, void *userdata)

void	SDL_FilterEvents (SDL_EventFilter filter, void *userdata)

Uint8	SDL_EventState (Uint32 type, int state)

Uint32	SDL_RegisterEvents (int numevents)

int	SDL_SendAppEvent (SDL_EventType eventType)

int	SDL_SendSysWMEvent (SDL_SysWMmsg *message)

int	SDL_SendKeymapChangedEvent (void)

int	SDL_SendLocaleChangedEvent (void)

int	SDL_EventsInit (void)

void	SDL_EventsQuit (void)

Variables
static SDL_mutex *	SDL_event_watchers_lock

static SDL_EventWatcher	SDL_EventOK

static SDL_EventWatcher *	SDL_event_watchers = NULL

static int	SDL_event_watchers_count = 0

static SDL_bool	SDL_event_watchers_dispatching = SDL_FALSE

static SDL_bool	SDL_event_watchers_removed = SDL_FALSE

static SDL_DisabledEventBlock *	SDL_disabled_events [256]

static Uint32	SDL_userevents = SDL_USEREVENT

struct {
SDL_mutex * lock

SDL_atomic_t active

SDL_atomic_t count

int max_events_seen

SDL_EventEntry * head

SDL_EventEntry * tail

SDL_EventEntry * free

SDL_SysWMEntry * wmmsg_used

SDL_SysWMEntry * wmmsg_free

}	SDL_EventQ = { NULL, { 1 }, { 0 }, 0, NULL, NULL, NULL, NULL, NULL }

static SDL_bool	SDL_update_joysticks = SDL_TRUE

static SDL_bool	SDL_update_sensors = SDL_TRUE

static int	SDL_DoEventLogging = 0

Macro Definition Documentation

◆ PRINT_AUDIODEV_EVENT

#define PRINT_AUDIODEV_EVENT ( event ) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%u iscapture=%s)", (uint) event->adevice.timestamp, (uint) event->adevice.which, event->adevice.iscapture ? "true" : "false");

◆ PRINT_CBUTTON_EVENT

#define PRINT_CBUTTON_EVENT ( event )

Value:

            SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d button=%u state=%s)", \
                (uint) event->cbutton.timestamp, (int) event->cbutton.which, \
                (uint) event->cbutton.button, event->cbutton.state == SDL_PRESSED ? "pressed" : "released")

◆ PRINT_CONTROLLERDEV_EVENT

#define PRINT_CONTROLLERDEV_EVENT ( event ) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d)", (uint) event->cdevice.timestamp, (int) event->cdevice.which)

◆ PRINT_DOLLAR_EVENT

#define PRINT_DOLLAR_EVENT ( event )

Value:

            SDL_snprintf(details, sizeof (details), " (timestamp=%u touchid=%"SDL_PRIs64" gestureid=%"SDL_PRIs64" numfingers=%u error=%f x=%f y=%f)", \
                (uint) event->dgesture.timestamp, (long long)event->dgesture.touchId, \
                (long long)event->dgesture.gestureId, (uint) event->dgesture.numFingers, \
                event->dgesture.error, event->dgesture.x, event->dgesture.y);

◆ PRINT_DROP_EVENT

#define PRINT_DROP_EVENT ( event ) SDL_snprintf(details, sizeof (details), " (file='%s' timestamp=%u windowid=%u)", event->drop.file, (uint) event->drop.timestamp, (uint) event->drop.windowID)

◆ PRINT_FINGER_EVENT

#define PRINT_FINGER_EVENT ( event )

Value:

            SDL_snprintf(details, sizeof (details), " (timestamp=%u touchid=%"SDL_PRIs64" fingerid=%"SDL_PRIs64" x=%f y=%f dx=%f dy=%f pressure=%f)", \
                (uint) event->tfinger.timestamp, (long long)event->tfinger.touchId, \
                (long long)event->tfinger.fingerId, event->tfinger.x, event->tfinger.y, \
                event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure)

◆ PRINT_JBUTTON_EVENT

#define PRINT_JBUTTON_EVENT ( event )

Value:

            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.state == SDL_PRESSED ? "pressed" : "released")

◆ PRINT_JOYDEV_EVENT

#define PRINT_JOYDEV_EVENT ( event ) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d)", (uint) event->jdevice.timestamp, (int) event->jdevice.which)

◆ PRINT_KEY_EVENT

#define PRINT_KEY_EVENT ( event )

Value:

            SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u state=%s repeat=%s scancode=%u keycode=%u mod=%u)", \
                (uint) event->key.timestamp, (uint) event->key.windowID, \
                event->key.state == SDL_PRESSED ? "pressed" : "released", \
                event->key.repeat ? "true" : "false", \
                (uint) event->key.keysym.scancode, \
                (uint) event->key.keysym.sym, \
                (uint) event->key.keysym.mod)

◆ PRINT_MBUTTON_EVENT

#define PRINT_MBUTTON_EVENT ( event )

Value:

            SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u which=%u button=%u state=%s clicks=%u x=%d y=%d)", \
                    (uint) event->button.timestamp, (uint) event->button.windowID, \
                    (uint) event->button.which, (uint) event->button.button, \
                    event->button.state == SDL_PRESSED ? "pressed" : "released", \
                    (uint) event->button.clicks, (int) event->button.x, (int) event->button.y)

◆ SDL_EVENT_CASE

#define SDL_EVENT_CASE ( x ) case x: SDL_strlcpy(name, #x, sizeof (name));

◆ SDL_MAX_QUEUED_EVENTS

#define SDL_MAX_QUEUED_EVENTS 65535

Definition at line 44 of file SDL_events.c.

◆ SDL_PRIs64

#define SDL_PRIs64 "I64d"

Definition at line 38 of file SDL_events.c.

◆ SDL_WINDOWEVENT_CASE

#define SDL_WINDOWEVENT_CASE ( x ) case x: SDL_strlcpy(name2, #x, sizeof (name2)); break

◆ uint

#define uint unsigned int

Function Documentation

◆ SDL_AddEvent()

static int SDL_AddEvent ( SDL_Event * event )

static

Definition at line 511 of file SDL_events.c.

 {
     SDL_EventEntry *entry;
     const int initial_count = SDL_AtomicGet(&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) {
             return 0;
         }
     } else {
         entry = SDL_EventQ.free;
         SDL_EventQ.free = entry->next;
     }
  
     if (SDL_DoEventLogging) {
         SDL_LogEvent(event);
     }
  
     entry->event = *event;
     if (event->type == SDL_SYSWMEVENT) {
         entry->msg = *event->syswm.msg;
         entry->event.syswm.msg = &entry->msg;
     }
  
     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_AtomicAdd(&SDL_EventQ.count, 1) + 1;
     if (final_count > SDL_EventQ.max_events_seen) {
         SDL_EventQ.max_events_seen = final_count;
     }
  
     return 1;
 }

References SDL_EventEntry::event, SDL_SysWMEvent::msg, SDL_SysWMmsg::msg, SDL_EventEntry::msg, SDL_EventEntry::next, NULL, SDL_EventEntry::prev, SDL_assert, SDL_AtomicAdd, SDL_AtomicGet, SDL_DoEventLogging, SDL_EventQ, SDL_LogEvent(), SDL_malloc, SDL_MAX_QUEUED_EVENTS, SDL_SetError, SDL_SYSWMEVENT, and SDL_Event::syswm.

Referenced by SDL_PeepEvents().

◆ SDL_AddEventWatch()

void SDL_AddEventWatch	(	SDL_EventFilter	filter,
		void *	userdata
	)

Add a function which is called when an event is added to the queue.

Definition at line 893 of file SDL_events.c.

 {
     if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
         SDL_EventWatcher *event_watchers;
  
         event_watchers = SDL_realloc(SDL_event_watchers, (SDL_event_watchers_count + 1) * sizeof(*event_watchers));
         if (event_watchers) {
             SDL_EventWatcher *watcher;
  
             SDL_event_watchers = event_watchers;
             watcher = &SDL_event_watchers[SDL_event_watchers_count];
             watcher->callback = filter;
             watcher->userdata = userdata;
             watcher->removed = SDL_FALSE;
             ++SDL_event_watchers_count;
         }
  
         if (SDL_event_watchers_lock) {
             SDL_UnlockMutex(SDL_event_watchers_lock);
         }
     }
 }

References SDL_EventWatcher::callback, SDL_EventWatcher::removed, SDL_event_watchers, SDL_event_watchers_count, SDL_event_watchers_lock, SDL_FALSE, SDL_LockMutex, SDL_realloc, SDL_UnlockMutex, and SDL_EventWatcher::userdata.

◆ SDL_AutoUpdateJoysticksChanged()

static void SDL_AutoUpdateJoysticksChanged	(	void *	userdata,
		const char *	name,
		const char *	oldValue,
		const char *	hint
	)

static

Definition at line 111 of file SDL_events.c.

 {
     SDL_CalculateShouldUpdateJoysticks();
 }

References SDL_CalculateShouldUpdateJoysticks().

Referenced by SDL_EventsInit(), and SDL_EventsQuit().

◆ SDL_AutoUpdateSensorsChanged()

static void SDL_AutoUpdateSensorsChanged	(	void *	userdata,
		const char *	name,
		const char *	oldValue,
		const char *	hint
	)

static

Definition at line 135 of file SDL_events.c.

 {
     SDL_CalculateShouldUpdateSensors();
 }

References SDL_CalculateShouldUpdateSensors().

Referenced by SDL_EventsInit(), and SDL_EventsQuit().

◆ SDL_CalculateShouldUpdateJoysticks()

static void SDL_CalculateShouldUpdateJoysticks ( )

static

Definition at line 100 of file SDL_events.c.

 {
     if (SDL_GetHintBoolean(SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_TRUE) &&
         (!SDL_disabled_events[SDL_JOYAXISMOTION >> 8] || SDL_JoystickEventState(SDL_QUERY))) {
         SDL_update_joysticks = SDL_TRUE;
     } else {
         SDL_update_joysticks = SDL_FALSE;
     }
 }

References SDL_disabled_events, SDL_FALSE, SDL_GetHintBoolean, SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_JOYAXISMOTION, SDL_JoystickEventState, SDL_QUERY, SDL_TRUE, and SDL_update_joysticks.

Referenced by SDL_AutoUpdateJoysticksChanged(), and SDL_EventState().

◆ SDL_CalculateShouldUpdateSensors()

static void SDL_CalculateShouldUpdateSensors ( )

static

Definition at line 124 of file SDL_events.c.

 {
     if (SDL_GetHintBoolean(SDL_HINT_AUTO_UPDATE_SENSORS, SDL_TRUE) &&
         !SDL_disabled_events[SDL_SENSORUPDATE >> 8]) {
         SDL_update_sensors = SDL_TRUE;
     } else {
         SDL_update_sensors = SDL_FALSE;
     }
 }

References SDL_disabled_events, SDL_FALSE, SDL_GetHintBoolean, SDL_HINT_AUTO_UPDATE_SENSORS, SDL_SENSORUPDATE, SDL_TRUE, and SDL_update_sensors.

Referenced by SDL_AutoUpdateSensorsChanged(), and SDL_EventState().

◆ SDL_CutEvent()

static void SDL_CutEvent ( SDL_EventEntry * entry )

static

Definition at line 565 of file SDL_events.c.

 {
     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;
     }
  
     entry->next = SDL_EventQ.free;
     SDL_EventQ.free = entry;
     SDL_assert(SDL_AtomicGet(&SDL_EventQ.count) > 0);
     SDL_AtomicAdd(&SDL_EventQ.count, -1);
 }

References SDL_EventEntry::next, NULL, SDL_EventEntry::prev, SDL_assert, SDL_AtomicAdd, SDL_AtomicGet, and SDL_EventQ.

Referenced by SDL_FilterEvents(), SDL_FlushEvents(), and SDL_PeepEvents().

◆ SDL_DelEventWatch()

void SDL_DelEventWatch	(	SDL_EventFilter	filter,
		void *	userdata
	)

Remove an event watch function added with SDL_AddEventWatch()

Definition at line 917 of file SDL_events.c.

 {
     if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
         int i;
  
         for (i = 0; i < SDL_event_watchers_count; ++i) {
             if (SDL_event_watchers[i].callback == filter && SDL_event_watchers[i].userdata == userdata) {
                 if (SDL_event_watchers_dispatching) {
                     SDL_event_watchers[i].removed = SDL_TRUE;
                     SDL_event_watchers_removed = SDL_TRUE;
                 } else {
                     --SDL_event_watchers_count;
                     if (i < SDL_event_watchers_count) {
                         SDL_memmove(&SDL_event_watchers[i], &SDL_event_watchers[i+1], (SDL_event_watchers_count - i) * sizeof(SDL_event_watchers[i]));
                     }
                 }
                 break;
             }
         }
  
         if (SDL_event_watchers_lock) {
             SDL_UnlockMutex(SDL_event_watchers_lock);
         }
     }
 }

References callback(), i, SDL_EventWatcher::removed, SDL_event_watchers, SDL_event_watchers_count, SDL_event_watchers_dispatching, SDL_event_watchers_lock, SDL_event_watchers_removed, SDL_LockMutex, SDL_memmove, SDL_TRUE, and SDL_UnlockMutex.

◆ SDL_EventLoggingChanged()

static void SDL_EventLoggingChanged	(	void *	userdata,
		const char *	name,
		const char *	oldValue,
		const char *	hint
	)

static

Definition at line 147 of file SDL_events.c.

 {
     SDL_DoEventLogging = (hint && *hint) ? SDL_max(SDL_min(SDL_atoi(hint), 2), 0) : 0;
 }

References SDL_atoi, SDL_DoEventLogging, SDL_max, and SDL_min.

Referenced by SDL_EventsInit(), and SDL_EventsQuit().

◆ SDL_EventsInit()

int SDL_EventsInit ( void )

Definition at line 1078 of file SDL_events.c.

 {
 #if !SDL_JOYSTICK_DISABLED
     SDL_AddHintCallback(SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_AutoUpdateJoysticksChanged, NULL);
 #endif
 #if !SDL_SENSOR_DISABLED
     SDL_AddHintCallback(SDL_HINT_AUTO_UPDATE_SENSORS, SDL_AutoUpdateSensorsChanged, NULL);
 #endif
     SDL_AddHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
     if (SDL_StartEventLoop() < 0) {
         SDL_DelHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
         return -1;
     }
  
     SDL_QuitInit();
  
     return 0;
 }

References NULL, SDL_AddHintCallback, SDL_AutoUpdateJoysticksChanged(), SDL_AutoUpdateSensorsChanged(), SDL_DelHintCallback, SDL_EventLoggingChanged(), SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_HINT_AUTO_UPDATE_SENSORS, SDL_HINT_EVENT_LOGGING, SDL_QuitInit(), and SDL_StartEventLoop().

Referenced by SDL_InitSubSystem().

◆ SDL_EventsQuit()

void SDL_EventsQuit ( void )

Definition at line 1098 of file SDL_events.c.

 {
     SDL_QuitQuit();
     SDL_StopEventLoop();
     SDL_DelHintCallback(SDL_HINT_EVENT_LOGGING, SDL_EventLoggingChanged, NULL);
 #if !SDL_JOYSTICK_DISABLED
     SDL_DelHintCallback(SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_AutoUpdateJoysticksChanged, NULL);
 #endif
 #if !SDL_SENSOR_DISABLED
     SDL_DelHintCallback(SDL_HINT_AUTO_UPDATE_SENSORS, SDL_AutoUpdateSensorsChanged, NULL);
 #endif
 }

References NULL, SDL_AutoUpdateJoysticksChanged(), SDL_AutoUpdateSensorsChanged(), SDL_DelHintCallback, SDL_EventLoggingChanged(), SDL_HINT_AUTO_UPDATE_JOYSTICKS, SDL_HINT_AUTO_UPDATE_SENSORS, SDL_HINT_EVENT_LOGGING, SDL_QuitQuit(), and SDL_StopEventLoop().

Referenced by SDL_QuitSubSystem().

◆ SDL_EventState()

Uint8 SDL_EventState	(	Uint32	type,
		int	state
	)

This function allows you to set the state of processing certain events.

If state is set to SDL_IGNORE, that event will be automatically dropped from the event queue and will not be filtered.
If state is set to SDL_ENABLE, that event will be processed normally.
If state is set to SDL_QUERY, SDL_EventState() will return the current processing state of the specified event.

Definition at line 961 of file SDL_events.c.

 {
     const SDL_bool isdnd = ((state == SDL_DISABLE) || (state == SDL_ENABLE)) &&
                            ((type == SDL_DROPFILE) || (type == SDL_DROPTEXT));
     Uint8 current_state;
     Uint8 hi = ((type >> 8) & 0xff);
     Uint8 lo = (type & 0xff);
  
     if (SDL_disabled_events[hi] &&
         (SDL_disabled_events[hi]->bits[lo/32] & (1 << (lo&31)))) {
         current_state = SDL_DISABLE;
     } else {
         current_state = SDL_ENABLE;
     }
  
     if (state != current_state)
     {
         switch (state) {
         case SDL_DISABLE:
             /* 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));
                 if (!SDL_disabled_events[hi]) {
                     /* Out of memory, nothing we can do... */
                     break;
                 }
             }
             SDL_disabled_events[hi]->bits[lo/32] |= (1 << (lo&31));
             SDL_FlushEvent(type);
             break;
         case SDL_ENABLE:
             SDL_disabled_events[hi]->bits[lo/32] &= ~(1 << (lo&31));
             break;
         default:
             /* Querying state... */
             break;
         }
  
 #if !SDL_JOYSTICK_DISABLED
         if (state == SDL_DISABLE || state == SDL_ENABLE) {
             SDL_CalculateShouldUpdateJoysticks();
         }
 #endif
 #if !SDL_SENSOR_DISABLED
         if (state == SDL_DISABLE || state == SDL_ENABLE) {
             SDL_CalculateShouldUpdateSensors();
         }
 #endif
     }
  
     /* turn off drag'n'drop support if we've disabled the events.
        This might change some UI details at the OS level. */
     if (isdnd) {
         SDL_ToggleDragAndDropSupport();
     }
  
     return current_state;
 }

References SDL_DisabledEventBlock::bits, SDL_CalculateShouldUpdateJoysticks(), SDL_CalculateShouldUpdateSensors(), SDL_calloc, SDL_DISABLE, SDL_disabled_events, SDL_DROPFILE, SDL_DROPTEXT, SDL_ENABLE, SDL_FlushEvent(), SDL_ToggleDragAndDropSupport(), and state.

Referenced by SDL_StartEventLoop().

◆ SDL_FilterEvents()

void SDL_FilterEvents	(	SDL_EventFilter	filter,
		void *	userdata
	)

Run the filter function on the current event queue, removing any events for which the filter returns 0.

Definition at line 944 of file SDL_events.c.

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

References SDL_EventEntry::event, SDL_EventEntry::next, SDL_CutEvent(), SDL_EventQ, SDL_LockMutex, and SDL_UnlockMutex.

◆ SDL_FlushEvent()

void SDL_FlushEvent ( Uint32 type )

This function clears events from the event queue This function only affects currently queued events. If you want to make sure that all pending OS events are flushed, you can call SDL_PumpEvents() on the main thread immediately before the flush call.

Definition at line 681 of file SDL_events.c.

 {
     SDL_FlushEvents(type, type);
 }

References SDL_FlushEvents().

Referenced by SDL_EventState().

◆ SDL_FlushEvents()

void SDL_FlushEvents	(	Uint32	minType,
		Uint32	maxType
	)

Definition at line 687 of file SDL_events.c.

 {
     /* !!! FIXME: we need to manually SDL_free() the strings in TEXTINPUT and
        drag'n'drop events if we're flushing them without passing them to the
        app, but I don't know if this is the right place to do that. */
  
     /* Don't look after we've quit */
     if (!SDL_AtomicGet(&SDL_EventQ.active)) {
         return;
     }
  
     /* 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 */
     if (!SDL_EventQ.lock || SDL_LockMutex(SDL_EventQ.lock) == 0) {
         SDL_EventEntry *entry, *next;
         Uint32 type;
         for (entry = SDL_EventQ.head; entry; entry = next) {
             next = entry->next;
             type = entry->event.type;
             if (minType <= type && type <= maxType) {
                 SDL_CutEvent(entry);
             }
         }
         if (SDL_EventQ.lock) {
             SDL_UnlockMutex(SDL_EventQ.lock);
         }
     }
 }

References SDL_EventEntry::event, SDL_EventEntry::next, SDL_AtomicGet, SDL_CutEvent(), SDL_EventQ, SDL_LockMutex, SDL_PumpEvents(), SDL_UnlockMutex, and SDL_Event::type.

Referenced by SDL_FlushEvent(), and SDL_SetEventFilter().

◆ SDL_GetEventFilter()

SDL_bool SDL_GetEventFilter	(	SDL_EventFilter *	filter,
		void **	userdata
	)

Return the current event filter - can be used to "chain" filters. If there is no event filter set, this function returns SDL_FALSE.

Definition at line 869 of file SDL_events.c.

 {
     SDL_EventWatcher event_ok;
  
     if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
         event_ok = SDL_EventOK;
  
         if (SDL_event_watchers_lock) {
             SDL_UnlockMutex(SDL_event_watchers_lock);
         }
     } else {
         SDL_zero(event_ok);
     }
  
     if (filter) {
         *filter = event_ok.callback;
     }
     if (userdata) {
         *userdata = event_ok.userdata;
     }
     return event_ok.callback ? SDL_TRUE : SDL_FALSE;
 }

References SDL_EventWatcher::callback, SDL_event_watchers_lock, SDL_EventOK, SDL_FALSE, SDL_LockMutex, SDL_TRUE, SDL_UnlockMutex, SDL_zero, and SDL_EventWatcher::userdata.

◆ SDL_HasEvent()

SDL_bool SDL_HasEvent ( Uint32 type )

Checks to see if certain event types are in the event queue.

Definition at line 669 of file SDL_events.c.

 {
     return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, type, type) > 0);
 }

References NULL, SDL_PEEKEVENT, and SDL_PeepEvents().

◆ SDL_HasEvents()

SDL_bool SDL_HasEvents	(	Uint32	minType,
		Uint32	maxType
	)

Definition at line 675 of file SDL_events.c.

 {
     return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, minType, maxType) > 0);
 }

References NULL, SDL_PEEKEVENT, and SDL_PeepEvents().

◆ SDL_LogEvent()

static void SDL_LogEvent ( const SDL_Event * event )

static

Definition at line 153 of file SDL_events.c.

 {
     char name[32];
     char details[128];
  
     /* mouse/finger motion are spammy, ignore these if they aren't demanded. */
     if ( (SDL_DoEventLogging < 2) &&
             ( (event->type == SDL_MOUSEMOTION) ||
               (event->type == SDL_FINGERMOTION) ) ) {
         return;
     }
  
     /* this is to make 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_USEREVENT) && (event->type <= SDL_LASTEVENT)) {
         char plusstr[16];
         SDL_strlcpy(name, "SDL_USEREVENT", sizeof (name));
         if (event->type > SDL_USEREVENT) {
             SDL_snprintf(plusstr, sizeof (plusstr), "+%u", ((uint) event->type) - SDL_USEREVENT);
         } else {
             plusstr[0] = '\0';
         }
         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_FIRSTEVENT) SDL_strlcpy(details, " (THIS IS PROBABLY A BUG!)", sizeof (details)); break;
         SDL_EVENT_CASE(SDL_QUIT) SDL_snprintf(details, sizeof (details), " (timestamp=%u)", (uint) event->quit.timestamp); break;
         SDL_EVENT_CASE(SDL_APP_TERMINATING) break;
         SDL_EVENT_CASE(SDL_APP_LOWMEMORY) break;
         SDL_EVENT_CASE(SDL_APP_WILLENTERBACKGROUND) break;
         SDL_EVENT_CASE(SDL_APP_DIDENTERBACKGROUND) break;
         SDL_EVENT_CASE(SDL_APP_WILLENTERFOREGROUND) break;
         SDL_EVENT_CASE(SDL_APP_DIDENTERFOREGROUND) break;
         SDL_EVENT_CASE(SDL_KEYMAPCHANGED) break;
         SDL_EVENT_CASE(SDL_CLIPBOARDUPDATE) break;
         SDL_EVENT_CASE(SDL_RENDER_TARGETS_RESET) break;
         SDL_EVENT_CASE(SDL_RENDER_DEVICE_RESET) break;
  
         SDL_EVENT_CASE(SDL_WINDOWEVENT) {
             char name2[64];
             switch(event->window.event) {
                 case SDL_WINDOWEVENT_NONE: SDL_strlcpy(name2, "SDL_WINDOWEVENT_NONE (THIS IS PROBABLY A BUG!)", sizeof (name2)); break;
                 #define SDL_WINDOWEVENT_CASE(x) case x: SDL_strlcpy(name2, #x, sizeof (name2)); break
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_SHOWN);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_HIDDEN);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_EXPOSED);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_MOVED);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_RESIZED);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_SIZE_CHANGED);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_MINIMIZED);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_MAXIMIZED);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_RESTORED);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_ENTER);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_LEAVE);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_FOCUS_GAINED);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_FOCUS_LOST);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_CLOSE);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_TAKE_FOCUS);
                 SDL_WINDOWEVENT_CASE(SDL_WINDOWEVENT_HIT_TEST);
                 #undef SDL_WINDOWEVENT_CASE
                 default: SDL_strlcpy(name2, "UNKNOWN (bug? fixme?)", sizeof (name2)); break;
             }
             SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u event=%s data1=%d data2=%d)",
                         (uint) event->window.timestamp, (uint) event->window.windowID, name2, (int) event->window.data1, (int) event->window.data2);
             break;
         }
  
         SDL_EVENT_CASE(SDL_SYSWMEVENT)
             /* !!! FIXME: we don't delve further at the moment. */
             SDL_snprintf(details, sizeof (details), " (timestamp=%u)", (uint) event->syswm.timestamp);
             break;
  
         #define PRINT_KEY_EVENT(event) \
             SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u state=%s repeat=%s scancode=%u keycode=%u mod=%u)", \
                 (uint) event->key.timestamp, (uint) event->key.windowID, \
                 event->key.state == SDL_PRESSED ? "pressed" : "released", \
                 event->key.repeat ? "true" : "false", \
                 (uint) event->key.keysym.scancode, \
                 (uint) event->key.keysym.sym, \
                 (uint) event->key.keysym.mod)
         SDL_EVENT_CASE(SDL_KEYDOWN) PRINT_KEY_EVENT(event); break;
         SDL_EVENT_CASE(SDL_KEYUP) PRINT_KEY_EVENT(event); break;
         #undef PRINT_KEY_EVENT
  
         SDL_EVENT_CASE(SDL_TEXTEDITING)
             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_TEXTINPUT)
             SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u text='%s')", (uint) event->text.timestamp, (uint) event->text.windowID, event->text.text);
             break;
  
  
         SDL_EVENT_CASE(SDL_MOUSEMOTION)
             SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u which=%u state=%u x=%d y=%d xrel=%d yrel=%d)",
                     (uint) event->motion.timestamp, (uint) event->motion.windowID,
                     (uint) event->motion.which, (uint) event->motion.state,
                     (int) event->motion.x, (int) event->motion.y,
                     (int) event->motion.xrel, (int) event->motion.yrel);
             break;
  
         #define PRINT_MBUTTON_EVENT(event) \
             SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u which=%u button=%u state=%s clicks=%u x=%d y=%d)", \
                     (uint) event->button.timestamp, (uint) event->button.windowID, \
                     (uint) event->button.which, (uint) event->button.button, \
                     event->button.state == SDL_PRESSED ? "pressed" : "released", \
                     (uint) event->button.clicks, (int) event->button.x, (int) event->button.y)
         SDL_EVENT_CASE(SDL_MOUSEBUTTONDOWN) PRINT_MBUTTON_EVENT(event); break;
         SDL_EVENT_CASE(SDL_MOUSEBUTTONUP) PRINT_MBUTTON_EVENT(event); break;
         #undef PRINT_MBUTTON_EVENT
  
  
         SDL_EVENT_CASE(SDL_MOUSEWHEEL)
             SDL_snprintf(details, sizeof (details), " (timestamp=%u windowid=%u which=%u x=%d y=%d direction=%s)",
                     (uint) event->wheel.timestamp, (uint) event->wheel.windowID,
                     (uint) event->wheel.which, (int) event->wheel.x, (int) event->wheel.y,
                     event->wheel.direction == SDL_MOUSEWHEEL_NORMAL ? "normal" : "flipped");
             break;
  
         SDL_EVENT_CASE(SDL_JOYAXISMOTION)
             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_JOYBALLMOTION)
             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_JOYHATMOTION)
             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) \
             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.state == SDL_PRESSED ? "pressed" : "released")
         SDL_EVENT_CASE(SDL_JOYBUTTONDOWN) PRINT_JBUTTON_EVENT(event); break;
         SDL_EVENT_CASE(SDL_JOYBUTTONUP) PRINT_JBUTTON_EVENT(event); break;
         #undef PRINT_JBUTTON_EVENT
  
         #define PRINT_JOYDEV_EVENT(event) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d)", (uint) event->jdevice.timestamp, (int) event->jdevice.which)
         SDL_EVENT_CASE(SDL_JOYDEVICEADDED) PRINT_JOYDEV_EVENT(event); break;
         SDL_EVENT_CASE(SDL_JOYDEVICEREMOVED) PRINT_JOYDEV_EVENT(event); break;
         #undef PRINT_JOYDEV_EVENT
  
         SDL_EVENT_CASE(SDL_CONTROLLERAXISMOTION)
             SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d axis=%u value=%d)",
                 (uint) event->caxis.timestamp, (int) event->caxis.which,
                 (uint) event->caxis.axis, (int) event->caxis.value);
             break;
  
         #define PRINT_CBUTTON_EVENT(event) \
             SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d button=%u state=%s)", \
                 (uint) event->cbutton.timestamp, (int) event->cbutton.which, \
                 (uint) event->cbutton.button, event->cbutton.state == SDL_PRESSED ? "pressed" : "released")
         SDL_EVENT_CASE(SDL_CONTROLLERBUTTONDOWN) PRINT_CBUTTON_EVENT(event); break;
         SDL_EVENT_CASE(SDL_CONTROLLERBUTTONUP) PRINT_CBUTTON_EVENT(event); break;
         #undef PRINT_CBUTTON_EVENT
  
         #define PRINT_CONTROLLERDEV_EVENT(event) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%d)", (uint) event->cdevice.timestamp, (int) event->cdevice.which)
         SDL_EVENT_CASE(SDL_CONTROLLERDEVICEADDED) PRINT_CONTROLLERDEV_EVENT(event); break;
         SDL_EVENT_CASE(SDL_CONTROLLERDEVICEREMOVED) PRINT_CONTROLLERDEV_EVENT(event); break;
         SDL_EVENT_CASE(SDL_CONTROLLERDEVICEREMAPPED) PRINT_CONTROLLERDEV_EVENT(event); break;
         #undef PRINT_CONTROLLERDEV_EVENT
  
         #define PRINT_FINGER_EVENT(event) \
             SDL_snprintf(details, sizeof (details), " (timestamp=%u touchid=%"SDL_PRIs64" fingerid=%"SDL_PRIs64" x=%f y=%f dx=%f dy=%f pressure=%f)", \
                 (uint) event->tfinger.timestamp, (long long)event->tfinger.touchId, \
                 (long long)event->tfinger.fingerId, event->tfinger.x, event->tfinger.y, \
                 event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure)
         SDL_EVENT_CASE(SDL_FINGERDOWN) PRINT_FINGER_EVENT(event); break;
         SDL_EVENT_CASE(SDL_FINGERUP) PRINT_FINGER_EVENT(event); break;
         SDL_EVENT_CASE(SDL_FINGERMOTION) PRINT_FINGER_EVENT(event); break;
         #undef PRINT_FINGER_EVENT
  
         #define PRINT_DOLLAR_EVENT(event) \
             SDL_snprintf(details, sizeof (details), " (timestamp=%u touchid=%"SDL_PRIs64" gestureid=%"SDL_PRIs64" numfingers=%u error=%f x=%f y=%f)", \
                 (uint) event->dgesture.timestamp, (long long)event->dgesture.touchId, \
                 (long long)event->dgesture.gestureId, (uint) event->dgesture.numFingers, \
                 event->dgesture.error, event->dgesture.x, event->dgesture.y);
         SDL_EVENT_CASE(SDL_DOLLARGESTURE) PRINT_DOLLAR_EVENT(event); break;
         SDL_EVENT_CASE(SDL_DOLLARRECORD) PRINT_DOLLAR_EVENT(event); break;
         #undef PRINT_DOLLAR_EVENT
  
         SDL_EVENT_CASE(SDL_MULTIGESTURE)
             SDL_snprintf(details, sizeof (details), " (timestamp=%u touchid=%"SDL_PRIs64" dtheta=%f ddist=%f x=%f y=%f numfingers=%u)",
                 (uint) event->mgesture.timestamp, (long long)event->mgesture.touchId,
                 event->mgesture.dTheta, event->mgesture.dDist,
                 event->mgesture.x, event->mgesture.y, (uint) event->mgesture.numFingers);
             break;
  
         #define PRINT_DROP_EVENT(event) SDL_snprintf(details, sizeof (details), " (file='%s' timestamp=%u windowid=%u)", event->drop.file, (uint) event->drop.timestamp, (uint) event->drop.windowID)
         SDL_EVENT_CASE(SDL_DROPFILE) PRINT_DROP_EVENT(event); break;
         SDL_EVENT_CASE(SDL_DROPTEXT) PRINT_DROP_EVENT(event); break;
         SDL_EVENT_CASE(SDL_DROPBEGIN) PRINT_DROP_EVENT(event); break;
         SDL_EVENT_CASE(SDL_DROPCOMPLETE) PRINT_DROP_EVENT(event); break;
         #undef PRINT_DROP_EVENT
  
         #define PRINT_AUDIODEV_EVENT(event) SDL_snprintf(details, sizeof (details), " (timestamp=%u which=%u iscapture=%s)", (uint) event->adevice.timestamp, (uint) event->adevice.which, event->adevice.iscapture ? "true" : "false");
         SDL_EVENT_CASE(SDL_AUDIODEVICEADDED) PRINT_AUDIODEV_EVENT(event); break;
         SDL_EVENT_CASE(SDL_AUDIODEVICEREMOVED) PRINT_AUDIODEV_EVENT(event); break;
         #undef PRINT_AUDIODEV_EVENT
  
         #undef SDL_EVENT_CASE
  
         default:
             if (!name[0]) {
                 SDL_strlcpy(name, "UNKNOWN", sizeof (name));
                 SDL_snprintf(details, sizeof (details), " #%u! (Bug? FIXME?)", (uint) event->type);
             }
             break;
     }
  
     if (name[0]) {
         SDL_Log("SDL EVENT: %s%s", name, details);
     }
  
     #undef uint
 }

References PRINT_AUDIODEV_EVENT, PRINT_CBUTTON_EVENT, PRINT_CONTROLLERDEV_EVENT, PRINT_DOLLAR_EVENT, PRINT_DROP_EVENT, PRINT_FINGER_EVENT, PRINT_JBUTTON_EVENT, PRINT_JOYDEV_EVENT, PRINT_KEY_EVENT, PRINT_MBUTTON_EVENT, SDL_APP_DIDENTERBACKGROUND, SDL_APP_DIDENTERFOREGROUND, SDL_APP_LOWMEMORY, SDL_APP_TERMINATING, SDL_APP_WILLENTERBACKGROUND, SDL_APP_WILLENTERFOREGROUND, SDL_AUDIODEVICEADDED, SDL_AUDIODEVICEREMOVED, SDL_CLIPBOARDUPDATE, SDL_CONTROLLERAXISMOTION, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMAPPED, SDL_CONTROLLERDEVICEREMOVED, SDL_DoEventLogging, SDL_DOLLARGESTURE, SDL_DOLLARRECORD, SDL_DROPBEGIN, SDL_DROPCOMPLETE, SDL_DROPFILE, SDL_DROPTEXT, SDL_EVENT_CASE, SDL_FINGERDOWN, SDL_FINGERMOTION, SDL_FINGERUP, SDL_FIRSTEVENT, SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, SDL_JOYDEVICEADDED, SDL_JOYDEVICEREMOVED, SDL_JOYHATMOTION, SDL_KEYDOWN, SDL_KEYMAPCHANGED, SDL_KEYUP, SDL_LASTEVENT, SDL_Log, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEMOTION, SDL_MOUSEWHEEL, SDL_MOUSEWHEEL_NORMAL, SDL_MULTIGESTURE, SDL_PRIs64, SDL_QUIT, SDL_RENDER_DEVICE_RESET, SDL_RENDER_TARGETS_RESET, SDL_snprintf, SDL_strlcpy, SDL_SYSWMEVENT, SDL_TEXTEDITING, SDL_TEXTINPUT, SDL_USEREVENT, SDL_WINDOWEVENT, SDL_WINDOWEVENT_CASE, SDL_WINDOWEVENT_CLOSE, SDL_WINDOWEVENT_ENTER, SDL_WINDOWEVENT_EXPOSED, SDL_WINDOWEVENT_FOCUS_GAINED, SDL_WINDOWEVENT_FOCUS_LOST, SDL_WINDOWEVENT_HIDDEN, SDL_WINDOWEVENT_HIT_TEST, SDL_WINDOWEVENT_LEAVE, SDL_WINDOWEVENT_MAXIMIZED, SDL_WINDOWEVENT_MINIMIZED, SDL_WINDOWEVENT_MOVED, SDL_WINDOWEVENT_NONE, SDL_WINDOWEVENT_RESIZED, SDL_WINDOWEVENT_RESTORED, SDL_WINDOWEVENT_SHOWN, SDL_WINDOWEVENT_SIZE_CHANGED, SDL_WINDOWEVENT_TAKE_FOCUS, and uint.

Referenced by SDL_AddEvent().

◆ SDL_PeepEvents()

int SDL_PeepEvents	(	SDL_Event *	events,
		int	numevents,
		SDL_eventaction	action,
		Uint32	minType,
		Uint32	maxType
	)

Checks the event queue for messages and optionally returns them.

If action is SDL_ADDEVENT, up to numevents events will be added to the back of the event queue.

If action is SDL_PEEKEVENT, up to numevents events at the front of the event queue, within the specified minimum and maximum type, will be returned and will not be removed from the queue.

If action is SDL_GETEVENT, up to numevents events at the front of the event queue, within the specified minimum and maximum type, will be returned and will be removed from the queue.

Returns: The number of events actually stored, or -1 if there was an error.

This function is thread-safe.

Definition at line 591 of file SDL_events.c.

 {
     int i, used;
  
     /* Don't look after we've quit */
     if (!SDL_AtomicGet(&SDL_EventQ.active)) {
         /* We get a few spurious events at shutdown, so don't warn then */
         if (action != SDL_ADDEVENT) {
             SDL_SetError("The event system has been shut down");
         }
         return (-1);
     }
     /* Lock the event queue */
     used = 0;
     if (!SDL_EventQ.lock || SDL_LockMutex(SDL_EventQ.lock) == 0) {
         if (action == SDL_ADDEVENT) {
             for (i = 0; i < numevents; ++i) {
                 used += SDL_AddEvent(&events[i]);
             }
         } else {
             SDL_EventEntry *entry, *next;
             SDL_SysWMEntry *wmmsg, *wmmsg_next;
             Uint32 type;
  
             if (action == SDL_GETEVENT) {
                 /* Clean out any used wmmsg data
                    FIXME: Do we want to retain the data for some period of time?
                  */
                 for (wmmsg = SDL_EventQ.wmmsg_used; wmmsg; wmmsg = wmmsg_next) {
                     wmmsg_next = wmmsg->next;
                     wmmsg->next = SDL_EventQ.wmmsg_free;
                     SDL_EventQ.wmmsg_free = wmmsg;
                 }
                 SDL_EventQ.wmmsg_used = NULL;
             }
  
             for (entry = SDL_EventQ.head; entry && (!events || used < numevents); entry = next) {
                 next = entry->next;
                 type = entry->event.type;
                 if (minType <= type && type <= maxType) {
                     if (events) {
                         events[used] = entry->event;
                         if (entry->event.type == SDL_SYSWMEVENT) {
                             /* We need to copy the wmmsg somewhere safe.
                                For now we'll guarantee it's valid at least until
                                the next call to SDL_PeepEvents()
                              */
                             if (SDL_EventQ.wmmsg_free) {
                                 wmmsg = SDL_EventQ.wmmsg_free;
                                 SDL_EventQ.wmmsg_free = wmmsg->next;
                             } else {
                                 wmmsg = (SDL_SysWMEntry *)SDL_malloc(sizeof(*wmmsg));
                             }
                             wmmsg->msg = *entry->event.syswm.msg;
                             wmmsg->next = SDL_EventQ.wmmsg_used;
                             SDL_EventQ.wmmsg_used = wmmsg;
                             events[used].syswm.msg = &wmmsg->msg;
                         }
  
                         if (action == SDL_GETEVENT) {
                             SDL_CutEvent(entry);
                         }
                     }
                     ++used;
                 }
             }
         }
         if (SDL_EventQ.lock) {
             SDL_UnlockMutex(SDL_EventQ.lock);
         }
     } else {
         return SDL_SetError("Couldn't lock event queue");
     }
     return (used);
 }

References action, SDL_EventEntry::event, events, i, SDL_SysWMEvent::msg, SDL_SysWMEntry::msg, SDL_EventEntry::next, SDL_SysWMEntry::next, NULL, SDL_ADDEVENT, SDL_AddEvent(), SDL_AtomicGet, SDL_CutEvent(), SDL_EventQ, SDL_GETEVENT, SDL_LockMutex, SDL_malloc, SDL_SetError, SDL_SYSWMEVENT, SDL_UnlockMutex, SDL_Event::syswm, and SDL_Event::type.

Referenced by SDL_HasEvent(), SDL_HasEvents(), SDL_PushEvent(), and SDL_WaitEventTimeout().

◆ SDL_PollEvent()

int SDL_PollEvent ( SDL_Event * event )

Polls for currently pending events.

Returns: 1 if there are any pending events, or 0 if there are none available.

Parameters

event If not NULL, the next event is removed from the queue and stored in that area.

Definition at line 757 of file SDL_events.c.

 {
     return SDL_WaitEventTimeout(event, 0);
 }

References SDL_WaitEventTimeout().

◆ SDL_PumpEvents()

void SDL_PumpEvents ( void )

Pumps the event loop, gathering events from the input devices.

This function updates the event queue and internal input device state.

This should only be run in the thread that sets the video mode.

Definition at line 725 of file SDL_events.c.

 {
     SDL_VideoDevice *_this = SDL_GetVideoDevice();
  
     /* Release any keys held down from last frame */
     SDL_ReleaseAutoReleaseKeys();
  
     /* Get events from the video subsystem */
     if (_this) {
         _this->PumpEvents(_this);
     }
  
 #if !SDL_JOYSTICK_DISABLED
     /* Check for joystick state change */
     if (SDL_update_joysticks) {
         SDL_JoystickUpdate();
     }
 #endif
  
 #if !SDL_SENSOR_DISABLED
     /* Check for sensor state change */
     if (SDL_update_sensors) {
         SDL_SensorUpdate();
     }
 #endif
  
     SDL_SendPendingSignalEvents();  /* in case we had a signal handler fire, etc. */
 }

References _this, SDL_VideoDevice::PumpEvents, SDL_GetVideoDevice(), SDL_JoystickUpdate, SDL_ReleaseAutoReleaseKeys(), SDL_SendPendingSignalEvents(), SDL_SensorUpdate, SDL_update_joysticks, and SDL_update_sensors.

Referenced by SDL_FlushEvents(), and SDL_WaitEventTimeout().

◆ SDL_PushEvent()

int SDL_PushEvent ( SDL_Event * event )

Add an event to the event queue.

Returns: 1 on success, 0 if the event was filtered, or -1 if the event queue was full or there was some other error.

Definition at line 800 of file SDL_events.c.

 {
     event->common.timestamp = SDL_GetTicks();
  
     if (SDL_EventOK.callback || SDL_event_watchers_count > 0) {
         if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
             if (SDL_EventOK.callback && !SDL_EventOK.callback(SDL_EventOK.userdata, event)) {
                 if (SDL_event_watchers_lock) {
                     SDL_UnlockMutex(SDL_event_watchers_lock);
                 }
                 return 0;
             }
  
             if (SDL_event_watchers_count > 0) {
                 /* Make sure we only dispatch the current watcher list */
                 int i, event_watchers_count = SDL_event_watchers_count;
  
                 SDL_event_watchers_dispatching = SDL_TRUE;
                 for (i = 0; i < event_watchers_count; ++i) {
                     if (!SDL_event_watchers[i].removed) {
                         SDL_event_watchers[i].callback(SDL_event_watchers[i].userdata, event);
                     }
                 }
                 SDL_event_watchers_dispatching = SDL_FALSE;
  
                 if (SDL_event_watchers_removed) {
                     for (i = SDL_event_watchers_count; i--; ) {
                         if (SDL_event_watchers[i].removed) {
                             --SDL_event_watchers_count;
                             if (i < SDL_event_watchers_count) {
                                 SDL_memmove(&SDL_event_watchers[i], &SDL_event_watchers[i+1], (SDL_event_watchers_count - i) * sizeof(SDL_event_watchers[i]));
                             }
                         }
                     }
                     SDL_event_watchers_removed = SDL_FALSE;
                 }
             }
  
             if (SDL_event_watchers_lock) {
                 SDL_UnlockMutex(SDL_event_watchers_lock);
             }
         }
     }
  
     if (SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0, 0) <= 0) {
         return -1;
     }
  
     SDL_GestureProcessEvent(event);
  
     return 1;
 }

References SDL_EventWatcher::callback, i, SDL_ADDEVENT, SDL_event_watchers, SDL_event_watchers_count, SDL_event_watchers_dispatching, SDL_event_watchers_lock, SDL_event_watchers_removed, SDL_EventOK, SDL_FALSE, SDL_GestureProcessEvent(), SDL_GetTicks(), SDL_LockMutex, SDL_memmove, SDL_PeepEvents(), SDL_TRUE, SDL_UnlockMutex, and SDL_EventWatcher::userdata.

Referenced by SDL_SendAppEvent(), and SDL_SendSysWMEvent().

◆ SDL_RegisterEvents()

Uint32 SDL_RegisterEvents ( int numevents )

This function allocates a set of user-defined events, and returns the beginning event number for that set of events.

If there aren't enough user-defined events left, this function returns (Uint32)-1

Definition at line 1021 of file SDL_events.c.

 {
     Uint32 event_base;
  
     if ((numevents > 0) && (SDL_userevents+numevents <= SDL_LASTEVENT)) {
         event_base = SDL_userevents;
         SDL_userevents += numevents;
     } else {
         event_base = (Uint32)-1;
     }
     return event_base;
 }

References SDL_LASTEVENT, and SDL_userevents.

◆ SDL_SendAppEvent()

int SDL_SendAppEvent ( SDL_EventType eventType )

Definition at line 1035 of file SDL_events.c.

 {
     int posted;
  
     posted = 0;
     if (SDL_GetEventState(eventType) == SDL_ENABLE) {
         SDL_Event event;
         event.type = eventType;
         posted = (SDL_PushEvent(&event) > 0);
     }
     return (posted);
 }

References SDL_ENABLE, SDL_GetEventState, and SDL_PushEvent().

Referenced by SDL_OnApplicationDidBecomeActive(), SDL_OnApplicationDidEnterBackground(), SDL_OnApplicationDidReceiveMemoryWarning(), SDL_OnApplicationWillEnterForeground(), SDL_OnApplicationWillResignActive(), SDL_OnApplicationWillTerminate(), SDL_SendKeymapChangedEvent(), SDL_SendLocaleChangedEvent(), and SDL_SendQuit().

◆ SDL_SendKeymapChangedEvent()

int SDL_SendKeymapChangedEvent ( void )

Definition at line 1066 of file SDL_events.c.

 {
     return SDL_SendAppEvent(SDL_KEYMAPCHANGED);
 }

References SDL_KEYMAPCHANGED, and SDL_SendAppEvent().

◆ SDL_SendLocaleChangedEvent()

int SDL_SendLocaleChangedEvent ( void )

Definition at line 1072 of file SDL_events.c.

 {
     return SDL_SendAppEvent(SDL_LOCALECHANGED);
 }

References SDL_LOCALECHANGED, and SDL_SendAppEvent().

Referenced by SDL_BApp::MessageReceived().

◆ SDL_SendSysWMEvent()

int SDL_SendSysWMEvent ( SDL_SysWMmsg * message )

Definition at line 1049 of file SDL_events.c.

 {
     int posted;
  
     posted = 0;
     if (SDL_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) {
         SDL_Event event;
         SDL_memset(&event, 0, sizeof(event));
         event.type = SDL_SYSWMEVENT;
         event.syswm.msg = message;
         posted = (SDL_PushEvent(&event) > 0);
     }
     /* Update internal event state */
     return (posted);
 }

References SDL_ENABLE, SDL_GetEventState, SDL_memset, SDL_PushEvent(), and SDL_SYSWMEVENT.

◆ SDL_SetEventFilter()

void SDL_SetEventFilter	(	SDL_EventFilter	filter,
		void *	userdata
	)

Sets up a filter to process all events before they change internal state and are posted to the internal event queue.

The filter is prototyped as:

int SDL_EventFilter(void *userdata, SDL_Event * event);

SDL_EventFilter

int(* SDL_EventFilter)(void *userdata, SDL_Event *event)

Definition: SDL_events.h:735

If the filter returns 1, then the event will be added to the internal queue. If it returns 0, then the event will be dropped from the queue, but the internal state will still be updated. This allows selective filtering of dynamically arriving events.

Warning: Be very careful of what you do in the event filter function, as it may run in a different thread!

There is one caveat when dealing with the SDL_QuitEvent event type. The event filter is only called when the window manager desires to close the application window. If the event filter returns 1, then the window will be closed, otherwise the window will remain open if possible.

If the quit event is generated by an interrupt signal, it will bypass the internal queue and be delivered to the application at the next event poll.

Definition at line 854 of file SDL_events.c.

 {
     if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
         /* Set filter and discard pending events */
         SDL_EventOK.callback = filter;
         SDL_EventOK.userdata = userdata;
         SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
  
         if (SDL_event_watchers_lock) {
             SDL_UnlockMutex(SDL_event_watchers_lock);
         }
     }
 }

References SDL_EventWatcher::callback, SDL_event_watchers_lock, SDL_EventOK, SDL_FIRSTEVENT, SDL_FlushEvents(), SDL_LASTEVENT, SDL_LockMutex, SDL_UnlockMutex, and SDL_EventWatcher::userdata.

◆ SDL_StartEventLoop()

int SDL_StartEventLoop ( void )

Definition at line 469 of file SDL_events.c.

 {
     /* We'll leave the event queue alone, since we might have gotten
        some important events at launch (like SDL_DROPFILE)
  
        FIXME: Does this introduce any other bugs with events at startup?
      */
  
     /* Create the lock and set ourselves active */
 #if !SDL_THREADS_DISABLED
     if (!SDL_EventQ.lock) {
         SDL_EventQ.lock = SDL_CreateMutex();
         if (SDL_EventQ.lock == NULL) {
             return -1;
         }
     }
  
     if (!SDL_event_watchers_lock) {
         SDL_event_watchers_lock = SDL_CreateMutex();
         if (SDL_event_watchers_lock == NULL) {
             return -1;
         }
     }
 #endif /* !SDL_THREADS_DISABLED */
  
     /* Process most event types */
     SDL_EventState(SDL_TEXTINPUT, SDL_DISABLE);
     SDL_EventState(SDL_TEXTEDITING, SDL_DISABLE);
     SDL_EventState(SDL_SYSWMEVENT, SDL_DISABLE);
 #if 0 /* Leave these events enabled so apps can respond to items being dragged onto them at startup */
     SDL_EventState(SDL_DROPFILE, SDL_DISABLE);
     SDL_EventState(SDL_DROPTEXT, SDL_DISABLE);
 #endif
  
     SDL_AtomicSet(&SDL_EventQ.active, 1);
  
     return 0;
 }

References NULL, SDL_AtomicSet, SDL_CreateMutex, SDL_DISABLE, SDL_DROPFILE, SDL_DROPTEXT, SDL_event_watchers_lock, SDL_EventQ, SDL_EventState(), SDL_SYSWMEVENT, SDL_TEXTEDITING, and SDL_TEXTINPUT.

Referenced by SDL_EventsInit().

◆ SDL_StopEventLoop()

void SDL_StopEventLoop ( void )

Definition at line 395 of file SDL_events.c.

 {
     const char *report = SDL_GetHint("SDL_EVENT_QUEUE_STATISTICS");
     int i;
     SDL_EventEntry *entry;
     SDL_SysWMEntry *wmmsg;
  
     if (SDL_EventQ.lock) {
         SDL_LockMutex(SDL_EventQ.lock);
     }
  
     SDL_AtomicSet(&SDL_EventQ.active, 0);
  
     if (report && SDL_atoi(report)) {
         SDL_Log("SDL EVENT QUEUE: Maximum events in-flight: %d\n",
                 SDL_EventQ.max_events_seen);
     }
  
     /* Clean out EventQ */
     for (entry = SDL_EventQ.head; entry; ) {
         SDL_EventEntry *next = entry->next;
         SDL_free(entry);
         entry = next;
     }
     for (entry = SDL_EventQ.free; entry; ) {
         SDL_EventEntry *next = entry->next;
         SDL_free(entry);
         entry = next;
     }
     for (wmmsg = SDL_EventQ.wmmsg_used; wmmsg; ) {
         SDL_SysWMEntry *next = wmmsg->next;
         SDL_free(wmmsg);
         wmmsg = next;
     }
     for (wmmsg = SDL_EventQ.wmmsg_free; wmmsg; ) {
         SDL_SysWMEntry *next = wmmsg->next;
         SDL_free(wmmsg);
         wmmsg = next;
     }
  
     SDL_AtomicSet(&SDL_EventQ.count, 0);
     SDL_EventQ.max_events_seen = 0;
     SDL_EventQ.head = NULL;
     SDL_EventQ.tail = NULL;
     SDL_EventQ.free = NULL;
     SDL_EventQ.wmmsg_used = NULL;
     SDL_EventQ.wmmsg_free = NULL;
  
     /* 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;
     }
  
     if (SDL_event_watchers_lock) {
         SDL_DestroyMutex(SDL_event_watchers_lock);
         SDL_event_watchers_lock = NULL;
     }
     if (SDL_event_watchers) {
         SDL_free(SDL_event_watchers);
         SDL_event_watchers = NULL;
         SDL_event_watchers_count = 0;
     }
     SDL_zero(SDL_EventOK);
  
     if (SDL_EventQ.lock) {
         SDL_UnlockMutex(SDL_EventQ.lock);
         SDL_DestroyMutex(SDL_EventQ.lock);
         SDL_EventQ.lock = NULL;
     }
 }

References i, SDL_EventEntry::next, SDL_SysWMEntry::next, NULL, SDL_arraysize, SDL_atoi, SDL_AtomicSet, SDL_DestroyMutex, SDL_disabled_events, SDL_event_watchers, SDL_event_watchers_count, SDL_event_watchers_lock, SDL_EventOK, SDL_EventQ, SDL_free, SDL_GetHint, SDL_LockMutex, SDL_Log, SDL_UnlockMutex, and SDL_zero.

Referenced by SDL_EventsQuit().

◆ SDL_WaitEvent()

int SDL_WaitEvent ( SDL_Event * event )

Waits indefinitely for the next available event.

Returns: 1, or 0 if there was an error while waiting for events.

Parameters

event If not NULL, the next event is removed from the queue and stored in that area.

Definition at line 763 of file SDL_events.c.

 {
     return SDL_WaitEventTimeout(event, -1);
 }

References SDL_WaitEventTimeout().

◆ SDL_WaitEventTimeout()

int SDL_WaitEventTimeout	(	SDL_Event *	event,
		int	timeout
	)

Waits until the specified timeout (in milliseconds) for the next available event.

Returns: 1, or 0 if there was an error while waiting for events.

Parameters

event	If not NULL, the next event is removed from the queue and stored in that area.
timeout	The timeout (in milliseconds) to wait for next event.

Definition at line 769 of file SDL_events.c.

 {
     Uint32 expiration = 0;
  
     if (timeout > 0)
         expiration = SDL_GetTicks() + timeout;
  
     for (;;) {
         SDL_PumpEvents();
         switch (SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
         case -1:
             return 0;
         case 0:
             if (timeout == 0) {
                 /* Polling and no events, just return */
                 return 0;
             }
             if (timeout > 0 && SDL_TICKS_PASSED(SDL_GetTicks(), expiration)) {
                 /* Timeout expired and no events */
                 return 0;
             }
             SDL_Delay(1);
             break;
         default:
             /* Has events */
             return 1;
         }
     }
 }