diff options
Diffstat (limited to '3rdparty/SDL2/src/events/SDL_events.c')
-rw-r--r-- | 3rdparty/SDL2/src/events/SDL_events.c | 659 |
1 files changed, 0 insertions, 659 deletions
diff --git a/3rdparty/SDL2/src/events/SDL_events.c b/3rdparty/SDL2/src/events/SDL_events.c deleted file mode 100644 index 2f5b0af296f..00000000000 --- a/3rdparty/SDL2/src/events/SDL_events.c +++ /dev/null @@ -1,659 +0,0 @@ -/* - Simple DirectMedia Layer - Copyright (C) 1997-2016 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.h" -#include "SDL_events.h" -#include "SDL_syswm.h" -#include "SDL_thread.h" -#include "SDL_events_c.h" -#include "../timer/SDL_timer_c.h" -#if !SDL_JOYSTICK_DISABLED -#include "../joystick/SDL_joystick_c.h" -#endif -#include "../video/SDL_sysvideo.h" - -/* An arbitrary limit so we don't have unbounded growth */ -#define SDL_MAX_QUEUED_EVENTS 65535 - -/* Public data -- the event filter */ -SDL_EventFilter SDL_EventOK = NULL; -void *SDL_EventOKParam; - -typedef struct SDL_EventWatcher { - SDL_EventFilter callback; - void *userdata; - struct SDL_EventWatcher *next; -} SDL_EventWatcher; - -static SDL_EventWatcher *SDL_event_watchers = NULL; - -typedef struct { - Uint32 bits[8]; -} SDL_DisabledEventBlock; - -static SDL_DisabledEventBlock *SDL_disabled_events[256]; -static Uint32 SDL_userevents = SDL_USEREVENT; - -/* Private data -- event queue */ -typedef struct _SDL_EventEntry -{ - SDL_Event event; - SDL_SysWMmsg msg; - struct _SDL_EventEntry *prev; - struct _SDL_EventEntry *next; -} SDL_EventEntry; - -typedef struct _SDL_SysWMEntry -{ - SDL_SysWMmsg msg; - struct _SDL_SysWMEntry *next; -} SDL_SysWMEntry; - -static 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 }; - - -/* Public functions */ - -void -SDL_StopEventLoop(void) -{ - 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; - } - - while (SDL_event_watchers) { - SDL_EventWatcher *tmp = SDL_event_watchers; - SDL_event_watchers = tmp->next; - SDL_free(tmp); - } - SDL_EventOK = NULL; - - if (SDL_EventQ.lock) { - SDL_UnlockMutex(SDL_EventQ.lock); - SDL_DestroyMutex(SDL_EventQ.lock); - SDL_EventQ.lock = NULL; - } -} - -/* This function (and associated calls) may be called more than once */ -int -SDL_StartEventLoop(void) -{ - /* 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; - } -#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); - - SDL_AtomicSet(&SDL_EventQ.active, 1); - - return 0; -} - - -/* 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_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; - } - - 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; -} - -/* Remove an event from the queue -- called with the queue locked */ -static void -SDL_CutEvent(SDL_EventEntry *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; - } - - entry->next = SDL_EventQ.free; - SDL_EventQ.free = entry; - SDL_assert(SDL_AtomicGet(&SDL_EventQ.count) > 0); - SDL_AtomicAdd(&SDL_EventQ.count, -1); -} - -/* Lock the event queue, take a peep at it, and unlock it */ -int -SDL_PeepEvents(SDL_Event * events, int numevents, SDL_eventaction action, - Uint32 minType, Uint32 maxType) -{ - 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); -} - -SDL_bool -SDL_HasEvent(Uint32 type) -{ - return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, type, type) > 0); -} - -SDL_bool -SDL_HasEvents(Uint32 minType, Uint32 maxType) -{ - return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, minType, maxType) > 0); -} - -void -SDL_FlushEvent(Uint32 type) -{ - SDL_FlushEvents(type, type); -} - -void -SDL_FlushEvents(Uint32 minType, Uint32 maxType) -{ - /* 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); - } - } - SDL_UnlockMutex(SDL_EventQ.lock); - } -} - -/* Run the system dependent event loops */ -void -SDL_PumpEvents(void) -{ - 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 - - SDL_SendPendingQuit(); /* in case we had a signal handler fire, etc. */ -} - -/* Public functions */ - -int -SDL_PollEvent(SDL_Event * event) -{ - return SDL_WaitEventTimeout(event, 0); -} - -int -SDL_WaitEvent(SDL_Event * event) -{ - return SDL_WaitEventTimeout(event, -1); -} - -int -SDL_WaitEventTimeout(SDL_Event * event, int timeout) -{ - 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; - } - } -} - -int -SDL_PushEvent(SDL_Event * event) -{ - SDL_EventWatcher *curr; - - event->common.timestamp = SDL_GetTicks(); - - if (SDL_EventOK && !SDL_EventOK(SDL_EventOKParam, event)) { - return 0; - } - - for (curr = SDL_event_watchers; curr; curr = curr->next) { - curr->callback(curr->userdata, event); - } - - if (SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0, 0) <= 0) { - return -1; - } - - SDL_GestureProcessEvent(event); - - return 1; -} - -void -SDL_SetEventFilter(SDL_EventFilter filter, void *userdata) -{ - /* Set filter and discard pending events */ - SDL_EventOK = NULL; - SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT); - SDL_EventOKParam = userdata; - SDL_EventOK = filter; -} - -SDL_bool -SDL_GetEventFilter(SDL_EventFilter * filter, void **userdata) -{ - if (filter) { - *filter = SDL_EventOK; - } - if (userdata) { - *userdata = SDL_EventOKParam; - } - return SDL_EventOK ? SDL_TRUE : SDL_FALSE; -} - -/* FIXME: This is not thread-safe yet */ -void -SDL_AddEventWatch(SDL_EventFilter filter, void *userdata) -{ - SDL_EventWatcher *watcher, *tail; - - watcher = (SDL_EventWatcher *)SDL_malloc(sizeof(*watcher)); - if (!watcher) { - /* Uh oh... */ - return; - } - - /* create the watcher */ - watcher->callback = filter; - watcher->userdata = userdata; - watcher->next = NULL; - - /* add the watcher to the end of the list */ - if (SDL_event_watchers) { - for (tail = SDL_event_watchers; tail->next; tail = tail->next) { - continue; - } - tail->next = watcher; - } else { - SDL_event_watchers = watcher; - } -} - -/* FIXME: This is not thread-safe yet */ -void -SDL_DelEventWatch(SDL_EventFilter filter, void *userdata) -{ - SDL_EventWatcher *prev = NULL; - SDL_EventWatcher *curr; - - for (curr = SDL_event_watchers; curr; prev = curr, curr = curr->next) { - if (curr->callback == filter && curr->userdata == userdata) { - if (prev) { - prev->next = curr->next; - } else { - SDL_event_watchers = curr->next; - } - SDL_free(curr); - break; - } - } -} - -void -SDL_FilterEvents(SDL_EventFilter filter, void *userdata) -{ - 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); - } - } - SDL_UnlockMutex(SDL_EventQ.lock); - } -} - -Uint8 -SDL_EventState(Uint32 type, int state) -{ - 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; - } - } - - return current_state; -} - -Uint32 -SDL_RegisterEvents(int numevents) -{ - 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) -{ - 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_SendSysWMEvent(SDL_SysWMmsg * message) -{ - 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); -} - -int -SDL_SendKeymapChangedEvent(void) -{ - return SDL_SendAppEvent(SDL_KEYMAPCHANGED); -} - -/* vi: set ts=4 sw=4 expandtab: */ |