#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_MAX_QUEUED_EVENTS 65535

Functions
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.
int	SDL_WaitEvent (SDL_Event *event)
	Waits indefinitely for the next available event.
int	SDL_WaitEventTimeout (SDL_Event *event, int timeout)
	Waits until the specified timeout (in milliseconds) for the next available event.
int	SDL_PushEvent (SDL_Event *event)
	Add an event to the event queue.
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)

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

Macro Definition Documentation

#define SDL_MAX_QUEUED_EVENTS 65535

Definition at line 39 of file SDL_events.c.

Referenced by SDL_AddEvent().

Function Documentation

static int SDL_AddEvent ( SDL_Event * event )

static

Definition at line 433 of file SDL_events.c.

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

Referenced by SDL_PeepEvents().

{
    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;
    }
    #ifdef SDL_DEBUG_EVENTS
    SDL_DebugPrintEvent(event);
    #endif
    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;
}

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 811 of file SDL_events.c.

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

{
    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);
        }
    }
}

static void SDL_CutEvent ( SDL_EventEntry * entry )

static

Definition at line 487 of file SDL_events.c.

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().

{
    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);
}

void SDL_DelEventWatch	(	SDL_EventFilter	filter,
		void *	userdata
	)

Remove an event watch function added with SDL_AddEventWatch()

Definition at line 835 of file SDL_events.c.

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

{
    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);
        }
    }
}

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 879 of file SDL_events.c.

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

{
    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;
        }
    }
    /* 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;
}

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 862 of file SDL_events.c.

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

{
    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);
        }
    }
}

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 603 of file SDL_events.c.

References SDL_FlushEvents.

{
    SDL_FlushEvents(type, type);
}

void SDL_FlushEvents	(	Uint32	minType,
		Uint32	maxType
	)

Definition at line 609 of file SDL_events.c.

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

{
    /* !!! 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);
        }
    }
}

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 787 of file SDL_events.c.

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

{
    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;
}

SDL_bool SDL_HasEvent ( Uint32 type )

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

Definition at line 591 of file SDL_events.c.

References NULL, SDL_PEEKEVENT, and SDL_PeepEvents.

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

SDL_bool SDL_HasEvents	(	Uint32	minType,
		Uint32	maxType
	)

Definition at line 597 of file SDL_events.c.

References NULL, SDL_PEEKEVENT, and SDL_PeepEvents.

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

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 513 of file SDL_events.c.

References SDL_EventEntry::event, i, SDL_SysWMEntry::msg, SDL_SysWMEvent::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.

{
    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);
}

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 675 of file SDL_events.c.

References SDL_WaitEventTimeout.

{
    return SDL_WaitEventTimeout(event, 0);
}

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 647 of file SDL_events.c.

References _this, SDL_VideoDevice::PumpEvents, SDL_GetVideoDevice(), SDL_JOYAXISMOTION, SDL_JoystickEventState, SDL_JoystickUpdate, SDL_QUERY, SDL_SendPendingQuit(), SDL_SENSORUPDATE, and SDL_SensorUpdate.

{
    SDL_VideoDevice *_this = SDL_GetVideoDevice();
    /* Get events from the video subsystem */
    if (_this) {
        _this->PumpEvents(_this);
    }
#if !SDL_JOYSTICK_DISABLED
    /* Check for joystick state change */
    if ((!SDL_disabled_events[SDL_JOYAXISMOTION >> 8] || SDL_JoystickEventState(SDL_QUERY))) {
        SDL_JoystickUpdate();
    }
#endif
#if !SDL_SENSOR_DISABLED
    /* Check for sensor state change */
    if (!SDL_disabled_events[SDL_SENSORUPDATE >> 8]) {
        SDL_SensorUpdate();
    }
#endif
    SDL_SendPendingQuit();  /* in case we had a signal handler fire, etc. */
}

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 718 of file SDL_events.c.

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

{
    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;
}

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 928 of file SDL_events.c.

References SDL_LASTEVENT, and SDL_userevents.

{
    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;
}

int SDL_SendAppEvent ( SDL_EventType eventType )

Definition at line 942 of file SDL_events.c.

References SDL_ENABLE, SDL_GetEventState, and SDL_PushEvent.

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

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

int SDL_SendKeymapChangedEvent ( void )

Definition at line 973 of file SDL_events.c.

References SDL_KEYMAPCHANGED, and SDL_SendAppEvent().

{
    return SDL_SendAppEvent(SDL_KEYMAPCHANGED);
}

int SDL_SendSysWMEvent ( SDL_SysWMmsg * message )

Definition at line 956 of file SDL_events.c.

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

{
    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);
}

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);

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 772 of file SDL_events.c.

References SDL_EventWatcher::callback, SDL_FIRSTEVENT, SDL_FlushEvents, SDL_LASTEVENT, SDL_LockMutex, SDL_UnlockMutex, and SDL_EventWatcher::userdata.

{
    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);
        }
    }
}

int SDL_StartEventLoop ( void )

Definition at line 391 of file SDL_events.c.

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

Referenced by SDL_InitSubSystem().

{
    /* 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;
}

void SDL_StopEventLoop ( void )

Definition at line 317 of file SDL_events.c.

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

Referenced by SDL_QuitSubSystem().

{
    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;
    }
}

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 681 of file SDL_events.c.

References SDL_WaitEventTimeout.

{
    return SDL_WaitEventTimeout(event, -1);
}

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 687 of file SDL_events.c.

References SDL_Delay, SDL_FIRSTEVENT, SDL_GETEVENT, SDL_GetTicks(), SDL_LASTEVENT, SDL_PeepEvents, SDL_PumpEvents, and SDL_TICKS_PASSED.

{
    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(10);
            break;
        default:
            /* Has events */
            return 1;
        }
    }
}