zenilib: zenilib/jni/external/sdl/src/events/SDL_events.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
SDL_events.c
Go to the documentation of this file.
1 /*
2 Simple DirectMedia Layer
3 Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the authors be held liable for any damages
7 arising from the use of this software.
8
9 Permission is granted to anyone to use this software for any purpose,
10 including commercial applications, and to alter it and redistribute it
11 freely, subject to the following restrictions:
12
13 1. The origin of this software must not be misrepresented; you must not
14 claim that you wrote the original software. If you use this software
15 in a product, an acknowledgment in the product documentation would be
16 appreciated but is not required.
17 2. Altered source versions must be plainly marked as such, and must not be
18 misrepresented as being the original software.
19 3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "SDL_config.h"
22
23 /* General event handling code for SDL */
24
25 #include "SDL.h"
26 #include "SDL_events.h"
27 #include "SDL_syswm.h"
28 #include "SDL_thread.h"
29 #include "SDL_events_c.h"
30 #include "../timer/SDL_timer_c.h"
31 #if !SDL_JOYSTICK_DISABLED
32 #include "../joystick/SDL_joystick_c.h"
33 #endif
34 #include "../video/SDL_sysvideo.h"
35
36 /* An arbitrary limit so we don't have unbounded growth */
37 #define SDL_MAX_QUEUED_EVENTS 65535
38
39 /* Public data -- the event filter */
40 SDL_EventFilter SDL_EventOK = NULL;
41 void *SDL_EventOKParam;
42
43 typedef struct SDL_EventWatcher {
44 SDL_EventFilter callback;
45 void *userdata;
46 struct SDL_EventWatcher *next;
47 } SDL_EventWatcher;
48
49 static SDL_EventWatcher *SDL_event_watchers = NULL;
50
51 typedef struct {
52 Uint32 bits[8];
53 } SDL_DisabledEventBlock;
54
55 static SDL_DisabledEventBlock *SDL_disabled_events[256];
56 static Uint32 SDL_userevents = SDL_USEREVENT;
57
58 /* Private data -- event queue */
59 typedef struct _SDL_EventEntry
60 {
61 SDL_Event event;
62 SDL_SysWMmsg msg;
63 struct _SDL_EventEntry *prev;
64 struct _SDL_EventEntry *next;
65 } SDL_EventEntry;
66
67 typedef struct _SDL_SysWMEntry
68 {
69 SDL_SysWMmsg msg;
70 struct _SDL_SysWMEntry *next;
71 } SDL_SysWMEntry;
72
73 static struct
74 {
75 SDL_mutex *lock;
76 volatile SDL_bool active;
77 volatile int count;
78 SDL_EventEntry *head;
79 SDL_EventEntry *tail;
80 SDL_EventEntry *free;
81 SDL_SysWMEntry *wmmsg_used;
82 SDL_SysWMEntry *wmmsg_free;
83 } SDL_EventQ = { NULL, SDL_TRUE };
84
85
86 static __inline__ SDL_bool
87 SDL_ShouldPollJoystick()
88 {
89 #if !SDL_JOYSTICK_DISABLED
90 if ((!SDL_disabled_events[SDL_JOYAXISMOTION >> 8] ||
91 SDL_JoystickEventState(SDL_QUERY)) &&
92 SDL_PrivateJoystickNeedsPolling()) {
93 return SDL_TRUE;
94 }
95 #endif
96 return SDL_FALSE;
97 }
98
99 /* Public functions */
100
101 void
102 SDL_StopEventLoop(void)
103 {
104 int i;
105 SDL_EventEntry *entry;
106 SDL_SysWMEntry *wmmsg;
107
108 if (SDL_EventQ.lock) {
109 SDL_LockMutex(SDL_EventQ.lock);
110 }
111
112 SDL_EventQ.active = SDL_FALSE;
113
114 /* Clean out EventQ */
115 for (entry = SDL_EventQ.head; entry; ) {
116 SDL_EventEntry *next = entry->next;
117 SDL_free(entry);
118 entry = next;
119 }
120 for (entry = SDL_EventQ.free; entry; ) {
121 SDL_EventEntry *next = entry->next;
122 SDL_free(entry);
123 entry = next;
124 }
125 for (wmmsg = SDL_EventQ.wmmsg_used; wmmsg; ) {
126 SDL_SysWMEntry *next = wmmsg->next;
127 SDL_free(wmmsg);
128 wmmsg = next;
129 }
130 for (wmmsg = SDL_EventQ.wmmsg_free; wmmsg; ) {
131 SDL_SysWMEntry *next = wmmsg->next;
132 SDL_free(wmmsg);
133 wmmsg = next;
134 }
135 SDL_EventQ.count = 0;
136 SDL_EventQ.head = NULL;
137 SDL_EventQ.tail = NULL;
138 SDL_EventQ.free = NULL;
139 SDL_EventQ.wmmsg_used = NULL;
140 SDL_EventQ.wmmsg_free = NULL;
141
142 /* Clear disabled event state */
143 for (i = 0; i < SDL_arraysize(SDL_disabled_events); ++i) {
144 SDL_free(SDL_disabled_events[i]);
145 SDL_disabled_events[i] = NULL;
146 }
147
148 while (SDL_event_watchers) {
149 SDL_EventWatcher *tmp = SDL_event_watchers;
150 SDL_event_watchers = tmp->next;
151 SDL_free(tmp);
152 }
153 SDL_EventOK = NULL;
154
155 if (SDL_EventQ.lock) {
156 SDL_UnlockMutex(SDL_EventQ.lock);
157 SDL_DestroyMutex(SDL_EventQ.lock);
158 SDL_EventQ.lock = NULL;
159 }
160 }
161
162 /* This function (and associated calls) may be called more than once */
163 int
164 SDL_StartEventLoop(void)
165 {
166 /* We'll leave the event queue alone, since we might have gotten
167 some important events at launch (like SDL_DROPFILE)
168
169 FIXME: Does this introduce any other bugs with events at startup?
170 */
171
172 /* Create the lock and set ourselves active */
173 #if !SDL_THREADS_DISABLED
174 if (!SDL_EventQ.lock) {
175 SDL_EventQ.lock = SDL_CreateMutex();
176 }
177 if (SDL_EventQ.lock == NULL) {
178 return (-1);
179 }
180 #endif /* !SDL_THREADS_DISABLED */
181
182 /* Process most event types */
183 SDL_EventState(SDL_TEXTINPUT, SDL_DISABLE);
184 SDL_EventState(SDL_TEXTEDITING, SDL_DISABLE);
185 SDL_EventState(SDL_SYSWMEVENT, SDL_DISABLE);
186
187 SDL_EventQ.active = SDL_TRUE;
188
189 return (0);
190 }
191
192
193 /* Add an event to the event queue -- called with the queue locked */
194 static int
195 SDL_AddEvent(SDL_Event * event)
196 {
197 SDL_EventEntry *entry;
198
199 if (SDL_EventQ.count >= SDL_MAX_QUEUED_EVENTS) {
200 SDL_SetError("Event queue is full (%d events)", SDL_EventQ.count);
201 return 0;
202 }
203
204 if (SDL_EventQ.free == NULL) {
205 entry = (SDL_EventEntry *)SDL_malloc(sizeof(*entry));
206 if (!entry) {
207 return 0;
208 }
209 } else {
210 entry = SDL_EventQ.free;
211 SDL_EventQ.free = entry->next;
212 }
213
214 entry->event = *event;
215 if (event->type == SDL_SYSWMEVENT) {
216 entry->msg = *event->syswm.msg;
217 entry->event.syswm.msg = &entry->msg;
218 }
219
220 if (SDL_EventQ.tail) {
221 SDL_EventQ.tail->next = entry;
222 entry->prev = SDL_EventQ.tail;
223 SDL_EventQ.tail = entry;
224 entry->next = NULL;
225 } else {
226 SDL_assert(!SDL_EventQ.head);
227 SDL_EventQ.head = entry;
228 SDL_EventQ.tail = entry;
229 entry->prev = NULL;
230 entry->next = NULL;
231 }
232 ++SDL_EventQ.count;
233
234 return 1;
235 }
236
237 /* Remove an event from the queue -- called with the queue locked */
238 static void
239 SDL_CutEvent(SDL_EventEntry *entry)
240 {
241 if (entry->prev) {
242 entry->prev->next = entry->next;
243 }
244 if (entry->next) {
245 entry->next->prev = entry->prev;
246 }
247
248 if (entry == SDL_EventQ.head) {
249 SDL_assert(entry->prev == NULL);
250 SDL_EventQ.head = entry->next;
251 }
252 if (entry == SDL_EventQ.tail) {
253 SDL_assert(entry->next == NULL);
254 SDL_EventQ.tail = entry->prev;
255 }
256
257 entry->next = SDL_EventQ.free;
258 SDL_EventQ.free = entry;
259 SDL_assert(SDL_EventQ.count > 0);
260 --SDL_EventQ.count;
261 }
262
263 /* Lock the event queue, take a peep at it, and unlock it */
264 int
265 SDL_PeepEvents(SDL_Event * events, int numevents, SDL_eventaction action,
266 Uint32 minType, Uint32 maxType)
267 {
268 int i, used;
269
270 /* Don't look after we've quit */
271 if (!SDL_EventQ.active) {
272 /* We get a few spurious events at shutdown, so don't warn then */
273 if (action != SDL_ADDEVENT) {
274 SDL_SetError("The event system has been shut down");
275 }
276 return (-1);
277 }
278 /* Lock the event queue */
279 used = 0;
280 if (!SDL_EventQ.lock || SDL_LockMutex(SDL_EventQ.lock) == 0) {
281 if (action == SDL_ADDEVENT) {
282 for (i = 0; i < numevents; ++i) {
283 used += SDL_AddEvent(&events[i]);
284 }
285 } else {
286 SDL_EventEntry *entry, *next;
287 SDL_SysWMEntry *wmmsg, *wmmsg_next;
288 SDL_Event tmpevent;
289 Uint32 type;
290
291 /* If 'events' is NULL, just see if they exist */
292 if (events == NULL) {
293 action = SDL_PEEKEVENT;
294 numevents = 1;
295 events = &tmpevent;
296 }
297
298 /* Clean out any used wmmsg data
299 FIXME: Do we want to retain the data for some period of time?
300 */
301 for (wmmsg = SDL_EventQ.wmmsg_used; wmmsg; wmmsg = wmmsg_next) {
302 wmmsg_next = wmmsg->next;
303 wmmsg->next = SDL_EventQ.wmmsg_free;
304 SDL_EventQ.wmmsg_free = wmmsg;
305 }
306 SDL_EventQ.wmmsg_used = NULL;
307
308 for (entry = SDL_EventQ.head; entry && used < numevents; entry = next) {
309 next = entry->next;
310 type = entry->event.type;
311 if (minType <= type && type <= maxType) {
312 events[used] = entry->event;
313 if (entry->event.type == SDL_SYSWMEVENT) {
314 /* We need to copy the wmmsg somewhere safe.
315 For now we'll guarantee it's valid at least until
316 the next call to SDL_PeepEvents()
317 */
318 SDL_SysWMEntry *wmmsg;
319 if (SDL_EventQ.wmmsg_free) {
320 wmmsg = SDL_EventQ.wmmsg_free;
321 SDL_EventQ.wmmsg_free = wmmsg->next;
322 } else {
323 wmmsg = (SDL_SysWMEntry *)SDL_malloc(sizeof(*wmmsg));
324 }
325 wmmsg->msg = *entry->event.syswm.msg;
326 wmmsg->next = SDL_EventQ.wmmsg_used;
327 SDL_EventQ.wmmsg_used = wmmsg;
328 events[used].syswm.msg = &wmmsg->msg;
329 }
330 ++used;
331
332 if (action == SDL_GETEVENT) {
333 SDL_CutEvent(entry);
334 }
335 }
336 }
337 }
338 SDL_UnlockMutex(SDL_EventQ.lock);
339 } else {
340 return SDL_SetError("Couldn't lock event queue");
341 }
342 return (used);
343 }
344
345 SDL_bool
346 SDL_HasEvent(Uint32 type)
347 {
348 return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, type, type) > 0);
349 }
350
351 SDL_bool
352 SDL_HasEvents(Uint32 minType, Uint32 maxType)
353 {
354 return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, minType, maxType) > 0);
355 }
356
357 void
358 SDL_FlushEvent(Uint32 type)
359 {
360 SDL_FlushEvents(type, type);
361 }
362
363 void
364 SDL_FlushEvents(Uint32 minType, Uint32 maxType)
365 {
366 /* Don't look after we've quit */
367 if (!SDL_EventQ.active) {
368 return;
369 }
370
371 /* Make sure the events are current */
372 #if 0
373 /* Actually, we can't do this since we might be flushing while processing
374 a resize event, and calling this might trigger further resize events.
375 */
376 SDL_PumpEvents();
377 #endif
378
379 /* Lock the event queue */
380 if (SDL_LockMutex(SDL_EventQ.lock) == 0) {
381 SDL_EventEntry *entry, *next;
382 Uint32 type;
383 for (entry = SDL_EventQ.head; entry; entry = next) {
384 next = entry->next;
385 type = entry->event.type;
386 if (minType <= type && type <= maxType) {
387 SDL_CutEvent(entry);
388 }
389 }
390 SDL_UnlockMutex(SDL_EventQ.lock);
391 }
392 }
393
394 /* Run the system dependent event loops */
395 void
396 SDL_PumpEvents(void)
397 {
398 SDL_VideoDevice *_this = SDL_GetVideoDevice();
399
400 /* Get events from the video subsystem */
401 if (_this) {
402 _this->PumpEvents(_this);
403 }
404 #if !SDL_JOYSTICK_DISABLED
405 /* Check for joystick state change */
406 if (SDL_ShouldPollJoystick()) {
407 SDL_JoystickUpdate();
408 }
409 #endif
410 }
411
412 /* Public functions */
413
414 int
415 SDL_PollEvent(SDL_Event * event)
416 {
417 return SDL_WaitEventTimeout(event, 0);
418 }
419
420 int
421 SDL_WaitEvent(SDL_Event * event)
422 {
423 return SDL_WaitEventTimeout(event, -1);
424 }
425
426 int
427 SDL_WaitEventTimeout(SDL_Event * event, int timeout)
428 {
429 Uint32 expiration = 0;
430
431 if (timeout > 0)
432 expiration = SDL_GetTicks() + timeout;
433
434 for (;;) {
435 SDL_PumpEvents();
436 switch (SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
437 case -1:
438 return 0;
439 case 1:
440 return 1;
441 case 0:
442 if (timeout == 0) {
443 /* Polling and no events, just return */
444 return 0;
445 }
446 if (timeout > 0 && ((int) (SDL_GetTicks() - expiration) >= 0)) {
447 /* Timeout expired and no events */
448 return 0;
449 }
450 SDL_Delay(10);
451 break;
452 }
453 }
454 }
455
456 int
457 SDL_PushEvent(SDL_Event * event)
458 {
459 SDL_EventWatcher *curr;
460
461 event->common.timestamp = SDL_GetTicks();
462
463 if (SDL_EventOK && !SDL_EventOK(SDL_EventOKParam, event)) {
464 return 0;
465 }
466
467 for (curr = SDL_event_watchers; curr; curr = curr->next) {
468 curr->callback(curr->userdata, event);
469 }
470
471 if (SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0, 0) <= 0) {
472 return -1;
473 }
474
475 SDL_GestureProcessEvent(event);
476
477 return 1;
478 }
479
480 void
481 SDL_SetEventFilter(SDL_EventFilter filter, void *userdata)
482 {
483 /* Set filter and discard pending events */
484 SDL_EventOK = NULL;
485 SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
486 SDL_EventOKParam = userdata;
487 SDL_EventOK = filter;
488 }
489
490 SDL_bool
491 SDL_GetEventFilter(SDL_EventFilter * filter, void **userdata)
492 {
493 if (filter) {
494 *filter = SDL_EventOK;
495 }
496 if (userdata) {
497 *userdata = SDL_EventOKParam;
498 }
499 return SDL_EventOK ? SDL_TRUE : SDL_FALSE;
500 }
501
502 /* FIXME: This is not thread-safe yet */
503 void
504 SDL_AddEventWatch(SDL_EventFilter filter, void *userdata)
505 {
506 SDL_EventWatcher *watcher;
507
508 watcher = (SDL_EventWatcher *)SDL_malloc(sizeof(*watcher));
509 if (!watcher) {
510 /* Uh oh... */
511 return;
512 }
513 watcher->callback = filter;
514 watcher->userdata = userdata;
515 watcher->next = SDL_event_watchers;
516 SDL_event_watchers = watcher;
517 }
518
519 /* FIXME: This is not thread-safe yet */
520 void
521 SDL_DelEventWatch(SDL_EventFilter filter, void *userdata)
522 {
523 SDL_EventWatcher *prev = NULL;
524 SDL_EventWatcher *curr;
525
526 for (curr = SDL_event_watchers; curr; prev = curr, curr = curr->next) {
527 if (curr->callback == filter && curr->userdata == userdata) {
528 if (prev) {
529 prev->next = curr->next;
530 } else {
531 SDL_event_watchers = curr->next;
532 }
533 SDL_free(curr);
534 break;
535 }
536 }
537 }
538
539 void
540 SDL_FilterEvents(SDL_EventFilter filter, void *userdata)
541 {
542 if (SDL_LockMutex(SDL_EventQ.lock) == 0) {
543 SDL_EventEntry *entry, *next;
544 for (entry = SDL_EventQ.head; entry; entry = next) {
545 next = entry->next;
546 if (!filter(userdata, &entry->event)) {
547 SDL_CutEvent(entry);
548 }
549 }
550 SDL_UnlockMutex(SDL_EventQ.lock);
551 }
552 }
553
554 Uint8
555 SDL_EventState(Uint32 type, int state)
556 {
557 Uint8 current_state;
558 Uint8 hi = ((type >> 8) & 0xff);
559 Uint8 lo = (type & 0xff);
560
561 if (SDL_disabled_events[hi] &&
562 (SDL_disabled_events[hi]->bits[lo/32] & (1 << (lo&31)))) {
563 current_state = SDL_DISABLE;
564 } else {
565 current_state = SDL_ENABLE;
566 }
567
568 if (state != current_state)
569 {
570 switch (state) {
571 case SDL_DISABLE:
572 /* Disable this event type and discard pending events */
573 if (!SDL_disabled_events[hi]) {
574 SDL_disabled_events[hi] = (SDL_DisabledEventBlock*) SDL_calloc(1, sizeof(SDL_DisabledEventBlock));
575 if (!SDL_disabled_events[hi]) {
576 /* Out of memory, nothing we can do... */
577 break;
578 }
579 }
580 SDL_disabled_events[hi]->bits[lo/32] |= (1 << (lo&31));
581 SDL_FlushEvent(type);
582 break;
583 case SDL_ENABLE:
584 SDL_disabled_events[hi]->bits[lo/32] &= ~(1 << (lo&31));
585 break;
586 default:
587 /* Querying state... */
588 break;
589 }
590 }
591
592 return current_state;
593 }
594
595 Uint32
596 SDL_RegisterEvents(int numevents)
597 {
598 Uint32 event_base;
599
600 if ((numevents > 0) && (SDL_userevents+numevents <= SDL_LASTEVENT)) {
601 event_base = SDL_userevents;
602 SDL_userevents += numevents;
603 } else {
604 event_base = (Uint32)-1;
605 }
606 return event_base;
607 }
608
609 int
610 SDL_SendAppEvent(SDL_EventType eventType)
611 {
612 int posted;
613
614 posted = 0;
615 if (SDL_GetEventState(eventType) == SDL_ENABLE) {
616 SDL_Event event;
617 event.type = eventType;
618 posted = (SDL_PushEvent(&event) > 0);
619 }
620 return (posted);
621 }
622
623 int
624 SDL_SendSysWMEvent(SDL_SysWMmsg * message)
625 {
626 int posted;
627
628 posted = 0;
629 if (SDL_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) {
630 SDL_Event event;
631 SDL_memset(&event, 0, sizeof(event));
632 event.type = SDL_SYSWMEVENT;
633 event.syswm.msg = message;
634 posted = (SDL_PushEvent(&event) > 0);
635 }
636 /* Update internal event state */
637 return (posted);
638 }
639
640 /* vi: set ts=4 sw=4 expandtab: */
wmmsg_used
SDL_SysWMEntry * wmmsg_used
Definition: SDL_events.c:81
SDL_eventaction
SDL_eventaction
Definition: SDL_events.h:545
SDL_FlushEvents
DECLSPEC void SDLCALL SDL_FlushEvents(Uint32 minType, Uint32 maxType)
Definition: SDL_events.c:364
__inline__
#define __inline__
Definition: begin_code.h:119
active
volatile SDL_bool active
Definition: SDL_events.c:76
SDL_JoystickUpdate
DECLSPEC void SDLCALL SDL_JoystickUpdate(void)
Definition: SDL_joystick.c:657
SDL_PushEvent
DECLSPEC int SDLCALL SDL_PushEvent(SDL_Event *event)
Add an event to the event queue.
Definition: SDL_events.c:457
SDL_event_watchers
static SDL_EventWatcher * SDL_event_watchers
Definition: SDL_events.c:49
type
GLint GLenum GLsizei GLsizei GLsizei GLint GLenum GLenum type
Definition: gl2ext.h:845
SDL_calloc
DECLSPEC void *SDLCALL SDL_calloc(size_t nmemb, size_t size)
message
GLsizei GLenum GLuint GLuint GLsizei GLchar * message
Definition: glew.h:2540
filter
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: gl2ext.h:961
NULL
#define NULL
Definition: ftobjs.h:61
SDL_LockMutex
DECLSPEC int SDLCALL SDL_LockMutex(SDL_mutex *mutex)
Definition: SDL_sysmutex.c:73
SDL_AddEvent
static int SDL_AddEvent(SDL_Event *event)
Definition: SDL_events.c:195
SDL_WaitEvent
DECLSPEC int SDLCALL SDL_WaitEvent(SDL_Event *event)
Waits indefinitely for the next available event.
Definition: SDL_events.c:421
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:116
SDL_SysWMEvent::msg
SDL_SysWMmsg * msg
Definition: SDL_events.h:489
SDL_SYSWMEVENT
Definition: SDL_events.h:90
cordic.hi
int hi
Definition: cordic.py:54
SDL_TRUE
Definition: SDL_stdinc.h:119
SDL_PEEKEVENT
Definition: SDL_events.h:548
free
SDL_EventEntry * free
Definition: SDL_events.c:80
SDL_PollEvent
DECLSPEC int SDLCALL SDL_PollEvent(SDL_Event *event)
Polls for currently pending events.
Definition: SDL_events.c:415
SDL_StartEventLoop
int SDL_StartEventLoop(void)
Definition: SDL_events.c:164
SDL_CreateMutex
DECLSPEC SDL_mutex *SDLCALL SDL_CreateMutex(void)
Definition: SDL_sysmutex.c:38
SDL_MAX_QUEUED_EVENTS
#define SDL_MAX_QUEUED_EVENTS
Definition: SDL_events.c:37
SDL_events.h
SDL_free
DECLSPEC void SDLCALL SDL_free(void *mem)
SDL_USEREVENT
Definition: SDL_events.h:140
SDL_ENABLE
#define SDL_ENABLE
Definition: SDL_events.h:688
cordic.lo
tuple lo
Definition: cordic.py:53
SDL_EventState
DECLSPEC Uint8 SDLCALL SDL_EventState(Uint32 type, int state)
Definition: SDL_events.c:555
SDL_PumpEvents
DECLSPEC void SDLCALL SDL_PumpEvents(void)
Definition: SDL_events.c:396
SDL_EventQ
static struct @79 SDL_EventQ
SDL_JOYAXISMOTION
Definition: SDL_events.h:105
SDL_FALSE
Definition: SDL_stdinc.h:118
SDL_config.h
SDL_UnlockMutex
DECLSPEC int SDLCALL SDL_UnlockMutex(SDL_mutex *mutex)
Definition: SDL_sysmutex.c:160
SDL_SendSysWMEvent
int SDL_SendSysWMEvent(SDL_SysWMmsg *message)
Definition: SDL_events.c:624
SDL_PeepEvents
DECLSPEC int SDLCALL SDL_PeepEvents(SDL_Event *events, int numevents, SDL_eventaction action, Uint32 minType, Uint32 maxType)
Definition: SDL_events.c:265
_this
static SDL_VideoDevice * _this
Definition: SDL_video.c:92
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:145
SDL_GetTicks
DECLSPEC Uint32 SDLCALL SDL_GetTicks(void)
Get the number of milliseconds since the SDL library initialization.
Definition: SDL_systimer.c:44
SDL_GestureProcessEvent
void SDL_GestureProcessEvent(SDL_Event *event)
Definition: SDL_gesture.c:485
SDL_ShouldPollJoystick
static __inline__ SDL_bool SDL_ShouldPollJoystick()
Definition: SDL_events.c:87
SDL_GetEventState
#define SDL_GetEventState(type)
Definition: SDL_events.h:701
SDL_EventOK
SDL_EventFilter SDL_EventOK
Definition: SDL_events.c:40
count
GLint GLsizei count
Definition: gl2ext.h:1011
SDL_SysWMmsg
Definition: SDL_syswm.h:112
SDL_Delay
DECLSPEC void SDLCALL SDL_Delay(Uint32 ms)
Wait a specified number of milliseconds before returning.
Definition: SDL_systimer.c:70
SDL_memset
DECLSPEC void *SDLCALL SDL_memset(void *dst, int c, size_t len)
Definition: SDL_string.c:261
bits
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: SDL_opengl.h:10449
SDL_EventType
SDL_EventType
The types of events that can be delivered.
Definition: SDL_events.h:55
SDL_SysWMmsg::msg
union SDL_SysWMmsg::@77 msg
SDL_SetError
DECLSPEC int SDLCALL SDL_SetError(const char *fmt,...)
Definition: SDL_error.c:53
SDL_malloc
DECLSPEC void *SDLCALL SDL_malloc(size_t size)
SDL_VideoDevice::PumpEvents
void(* PumpEvents)(_THIS)
Definition: SDL_sysvideo.h:237
timeout
GLbitfield GLuint64 timeout
Definition: glew.h:5938
SDL_CutEvent
static void SDL_CutEvent(SDL_EventEntry *entry)
Definition: SDL_events.c:239
SDL_WaitEventTimeout
DECLSPEC int SDLCALL SDL_WaitEventTimeout(SDL_Event *event, int timeout)
Waits until the specified timeout (in milliseconds) for the next available event. ...
Definition: SDL_events.c:427
SDL_AddEventWatch
DECLSPEC void SDLCALL SDL_AddEventWatch(SDL_EventFilter filter, void *userdata)
Definition: SDL_events.c:504
SDL_SysWMEntry
struct _SDL_SysWMEntry SDL_SysWMEntry
SDL_JoystickEventState
DECLSPEC int SDLCALL SDL_JoystickEventState(int state)
Definition: SDL_joystick.c:708
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:159
SDL_EventOKParam
void * SDL_EventOKParam
Definition: SDL_events.c:41
SDL_GetEventFilter
DECLSPEC SDL_bool SDLCALL SDL_GetEventFilter(SDL_EventFilter *filter, void **userdata)
Definition: SDL_events.c:491
SDL_FIRSTEVENT
Definition: SDL_events.h:57
SDL_events_c.h
SDL_DISABLE
#define SDL_DISABLE
Definition: SDL_events.h:687
SDL_HasEvent
DECLSPEC SDL_bool SDLCALL SDL_HasEvent(Uint32 type)
Definition: SDL_events.c:346
tail
SDL_EventEntry * tail
Definition: SDL_events.c:79
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:83
SDL_mutex
struct SDL_mutex SDL_mutex
Definition: SDL_mutex.h:59
SDL_SetEventFilter
DECLSPEC void SDLCALL SDL_SetEventFilter(SDL_EventFilter filter, void *userdata)
Definition: SDL_events.c:481
SDL_EventWatcher
struct SDL_EventWatcher SDL_EventWatcher
SDL_Event::syswm
SDL_SysWMEvent syswm
Definition: SDL_events.h:516
SDL_DelEventWatch
DECLSPEC void SDLCALL SDL_DelEventWatch(SDL_EventFilter filter, void *userdata)
Definition: SDL_events.c:521
SDL_HasEvents
DECLSPEC SDL_bool SDLCALL SDL_HasEvents(Uint32 minType, Uint32 maxType)
Definition: SDL_events.c:352
SDL_TEXTINPUT
Definition: SDL_events.h:96
lock
SDL_mutex * lock
Definition: SDL_events.c:75
SDL_EventEntry
struct _SDL_EventEntry SDL_EventEntry
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:129
SDL_userevents
static Uint32 SDL_userevents
Definition: SDL_events.c:56
SDL_disabled_events
static SDL_DisabledEventBlock * SDL_disabled_events[256]
Definition: SDL_events.c:55
wmmsg_free
SDL_SysWMEntry * wmmsg_free
Definition: SDL_events.c:82
SDL_VideoDevice
Definition: SDL_sysvideo.h:135
SDL_RegisterEvents
DECLSPEC Uint32 SDLCALL SDL_RegisterEvents(int numevents)
Definition: SDL_events.c:596
SDL_FlushEvent
DECLSPEC void SDLCALL SDL_FlushEvent(Uint32 type)
Definition: SDL_events.c:358
SDL_GetVideoDevice
SDL_VideoDevice * SDL_GetVideoDevice(void)
Definition: SDL_video.c:548
SDL_Event
General event structure.
Definition: SDL_events.h:495
SDL_SendAppEvent
int SDL_SendAppEvent(SDL_EventType eventType)
Definition: SDL_events.c:610
SDL_DestroyMutex
DECLSPEC void SDLCALL SDL_DestroyMutex(SDL_mutex *mutex)
Definition: SDL_sysmutex.c:61
SDL_GETEVENT
Definition: SDL_events.h:549
SDL_QUERY
#define SDL_QUERY
Definition: SDL_events.h:685
SDL_ADDEVENT
Definition: SDL_events.h:547
i
int i
Definition: pngrutil.c:1377
head
SDL_EventEntry * head
Definition: SDL_events.c:78
SDL_FilterEvents
DECLSPEC void SDLCALL SDL_FilterEvents(SDL_EventFilter filter, void *userdata)
Definition: SDL_events.c:540
SDL_PrivateJoystickNeedsPolling
SDL_bool SDL_PrivateJoystickNeedsPolling()
Definition: SDL_joystick.c:741
SDL_syswm.h
SDL_TEXTEDITING
Definition: SDL_events.h:95
SDL_LASTEVENT
Definition: SDL_events.h:145
SDL_Event::type
Uint32 type
Definition: SDL_events.h:497
SDL_StopEventLoop
void SDL_StopEventLoop(void)
Definition: SDL_events.c:102
event
cl_event event
Definition: glew.h:3556