summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/src/events/SDL_events.c
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/SDL2/src/events/SDL_events.c')
-rw-r--r--3rdparty/SDL2/src/events/SDL_events.c658
1 files changed, 658 insertions, 0 deletions
diff --git a/3rdparty/SDL2/src/events/SDL_events.c b/3rdparty/SDL2/src/events/SDL_events.c
new file mode 100644
index 00000000000..ffd10382495
--- /dev/null
+++ b/3rdparty/SDL2/src/events/SDL_events.c
@@ -0,0 +1,658 @@
+/*
+ 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;
+ volatile SDL_bool active;
+ volatile int count;
+ volatile int max_events_seen;
+ SDL_EventEntry *head;
+ SDL_EventEntry *tail;
+ SDL_EventEntry *free;
+ SDL_SysWMEntry *wmmsg_used;
+ SDL_SysWMEntry *wmmsg_free;
+} SDL_EventQ = { NULL, SDL_TRUE, 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_EventQ.active = SDL_FALSE;
+
+ 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_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_EventQ.active = SDL_TRUE;
+
+ return (0);
+}
+
+
+/* Add an event to the event queue -- called with the queue locked */
+static int
+SDL_AddEvent(SDL_Event * event)
+{
+ SDL_EventEntry *entry;
+
+ if (SDL_EventQ.count >= SDL_MAX_QUEUED_EVENTS) {
+ SDL_SetError("Event queue is full (%d events)", SDL_EventQ.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;
+ }
+ ++SDL_EventQ.count;
+
+ if (SDL_EventQ.count > SDL_EventQ.max_events_seen) {
+ SDL_EventQ.max_events_seen = SDL_EventQ.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_EventQ.count > 0);
+ --SDL_EventQ.count;
+}
+
+/* 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_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;
+ SDL_Event tmpevent;
+ Uint32 type;
+
+ /* If 'events' is NULL, just see if they exist */
+ if (events == NULL) {
+ action = SDL_PEEKEVENT;
+ numevents = 1;
+ events = &tmpevent;
+ }
+
+ /* 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 && used < numevents; entry = next) {
+ next = entry->next;
+ type = entry->event.type;
+ if (minType <= type && type <= maxType) {
+ 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;
+ }
+ ++used;
+
+ if (action == SDL_GETEVENT) {
+ SDL_CutEvent(entry);
+ }
+ }
+ }
+ }
+ 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_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_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 1:
+ return 1;
+ 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;
+ }
+ }
+}
+
+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: */