This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_events.c
531 lines (461 loc) · 13.2 KB
1
/*
2
3
Simple DirectMedia Layer
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
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.
8
9
10
11
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:
12
13
14
15
16
17
18
19
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.
20
*/
21
#include "SDL_config.h"
22
23
24
25
/* General event handling code for SDL */
#include "SDL.h"
26
#include "SDL_events.h"
27
#include "SDL_syswm.h"
28
#include "SDL_thread.h"
29
30
31
32
33
#include "SDL_events_c.h"
#include "../timer/SDL_timer_c.h"
#if !SDL_JOYSTICK_DISABLED
#include "../joystick/SDL_joystick_c.h"
#endif
34
#include "../video/SDL_sysvideo.h"
35
36
37
/* Public data -- the event filter */
SDL_EventFilter SDL_EventOK = NULL;
38
void *SDL_EventOKParam;
39
40
41
42
43
44
45
46
47
typedef struct SDL_EventWatcher {
SDL_EventFilter callback;
void *userdata;
struct SDL_EventWatcher *next;
} SDL_EventWatcher;
static SDL_EventWatcher *SDL_event_watchers = NULL;
48
49
50
51
52
53
typedef struct {
Uint32 bits[8];
} SDL_DisabledEventBlock;
static SDL_DisabledEventBlock *SDL_disabled_events[256];
static Uint32 SDL_userevents = SDL_USEREVENT;
54
55
56
/* Private data -- event queue */
#define MAXEVENTS 128
57
58
59
60
61
62
63
64
65
static struct
{
SDL_mutex *lock;
int active;
int head;
int tail;
SDL_Event event[MAXEVENTS];
int wmmsg_next;
struct SDL_SysWMmsg wmmsg[MAXEVENTS];
66
67
68
} SDL_EventQ;
69
70
71
static __inline__ SDL_bool
SDL_ShouldPollJoystick()
{
72
#if !SDL_JOYSTICK_DISABLED
73
74
75
76
77
if (SDL_numjoysticks &&
(!SDL_disabled_events[SDL_JOYAXISMOTION >> 8] ||
SDL_JoystickEventState(SDL_QUERY))) {
return SDL_TRUE;
}
78
#endif
79
80
81
return SDL_FALSE;
}
82
83
/* Public functions */
84
85
void
SDL_StopEventLoop(void)
86
{
87
88
int i;
89
90
91
92
if (SDL_EventQ.lock) {
SDL_DestroyMutex(SDL_EventQ.lock);
SDL_EventQ.lock = NULL;
}
93
94
95
96
97
/* Clean out EventQ */
SDL_EventQ.head = 0;
SDL_EventQ.tail = 0;
SDL_EventQ.wmmsg_next = 0;
98
99
100
101
102
103
104
105
/* Clear disabled event state */
for (i = 0; i < SDL_arraysize(SDL_disabled_events); ++i) {
if (SDL_disabled_events[i]) {
SDL_free(SDL_disabled_events[i]);
SDL_disabled_events[i] = NULL;
}
}
106
107
108
109
110
111
while (SDL_event_watchers) {
SDL_EventWatcher *tmp = SDL_event_watchers;
SDL_event_watchers = tmp->next;
SDL_free(tmp);
}
112
113
114
}
/* This function (and associated calls) may be called more than once */
115
int
116
SDL_StartEventLoop(void)
117
{
118
119
120
121
122
123
/* Clean out the event queue */
SDL_EventQ.lock = NULL;
SDL_StopEventLoop();
/* No filter to start with, process most event types */
SDL_EventOK = NULL;
124
SDL_EventState(SDL_SYSWMEVENT, SDL_DISABLE);
125
126
127
128
129
/* Create the lock and set ourselves active */
#if !SDL_THREADS_DISABLED
SDL_EventQ.lock = SDL_CreateMutex();
if (SDL_EventQ.lock == NULL) {
130
131
return (-1);
}
132
133
#endif /* !SDL_THREADS_DISABLED */
SDL_EventQ.active = 1;
134
135
return (0);
136
137
138
139
}
/* Add an event to the event queue -- called with the queue locked */
140
141
static int
SDL_AddEvent(SDL_Event * event)
142
{
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
int tail, added;
tail = (SDL_EventQ.tail + 1) % MAXEVENTS;
if (tail == SDL_EventQ.head) {
/* Overflow, drop event */
added = 0;
} else {
SDL_EventQ.event[SDL_EventQ.tail] = *event;
if (event->type == SDL_SYSWMEVENT) {
/* Note that it's possible to lose an event */
int next = SDL_EventQ.wmmsg_next;
SDL_EventQ.wmmsg[next] = *event->syswm.msg;
SDL_EventQ.event[SDL_EventQ.tail].syswm.msg =
&SDL_EventQ.wmmsg[next];
SDL_EventQ.wmmsg_next = (next + 1) % MAXEVENTS;
}
SDL_EventQ.tail = tail;
added = 1;
}
return (added);
163
164
165
166
}
/* Cut an event, and return the next valid spot, or the tail */
/* -- called with the queue locked */
167
168
static int
SDL_CutEvent(int spot)
169
{
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
if (spot == SDL_EventQ.head) {
SDL_EventQ.head = (SDL_EventQ.head + 1) % MAXEVENTS;
return (SDL_EventQ.head);
} else if ((spot + 1) % MAXEVENTS == SDL_EventQ.tail) {
SDL_EventQ.tail = spot;
return (SDL_EventQ.tail);
} else
/* We cut the middle -- shift everything over */
{
int here, next;
/* This can probably be optimized with SDL_memcpy() -- careful! */
if (--SDL_EventQ.tail < 0) {
SDL_EventQ.tail = MAXEVENTS - 1;
}
for (here = spot; here != SDL_EventQ.tail; here = next) {
next = (here + 1) % MAXEVENTS;
SDL_EventQ.event[here] = SDL_EventQ.event[next];
}
return (spot);
}
/* NOTREACHED */
192
193
194
}
/* Lock the event queue, take a peep at it, and unlock it */
195
196
int
SDL_PeepEvents(SDL_Event * events, int numevents, SDL_eventaction action,
197
Uint32 minType, Uint32 maxType)
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
{
int i, used;
/* Don't look after we've quit */
if (!SDL_EventQ.active) {
return (-1);
}
/* Lock the event queue */
used = 0;
if (SDL_mutexP(SDL_EventQ.lock) == 0) {
if (action == SDL_ADDEVENT) {
for (i = 0; i < numevents; ++i) {
used += SDL_AddEvent(&events[i]);
}
} else {
SDL_Event tmpevent;
int spot;
/* If 'events' is NULL, just see if they exist */
if (events == NULL) {
action = SDL_PEEKEVENT;
numevents = 1;
events = &tmpevent;
}
spot = SDL_EventQ.head;
while ((used < numevents) && (spot != SDL_EventQ.tail)) {
224
225
Uint32 type = SDL_EventQ.event[spot].type;
if (minType <= type && type <= maxType) {
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
events[used++] = SDL_EventQ.event[spot];
if (action == SDL_GETEVENT) {
spot = SDL_CutEvent(spot);
} else {
spot = (spot + 1) % MAXEVENTS;
}
} else {
spot = (spot + 1) % MAXEVENTS;
}
}
}
SDL_mutexV(SDL_EventQ.lock);
} else {
SDL_SetError("Couldn't lock event queue");
used = -1;
}
return (used);
}
SDL_bool
246
247
248
249
250
251
252
SDL_HasEvent(Uint32 type)
{
return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, type, type) > 0);
}
SDL_bool
SDL_HasEvents(Uint32 minType, Uint32 maxType)
253
{
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
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;
}
271
/* Make sure the events are current */
272
273
274
275
#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.
*/
276
SDL_PumpEvents();
277
#endif
278
279
280
281
282
283
284
285
286
287
288
289
290
291
/* Lock the event queue */
if (SDL_mutexP(SDL_EventQ.lock) == 0) {
int spot = SDL_EventQ.head;
while (spot != SDL_EventQ.tail) {
Uint32 type = SDL_EventQ.event[spot].type;
if (minType <= type && type <= maxType) {
spot = SDL_CutEvent(spot);
} else {
spot = (spot + 1) % MAXEVENTS;
}
}
SDL_mutexV(SDL_EventQ.lock);
}
292
293
294
}
/* Run the system dependent event loops */
295
296
void
SDL_PumpEvents(void)
297
{
298
SDL_VideoDevice *_this = SDL_GetVideoDevice();
299
300
301
302
303
/* Get events from the video subsystem */
if (_this) {
_this->PumpEvents(_this);
}
304
#if !SDL_JOYSTICK_DISABLED
305
306
307
/* Check for joystick state change */
if (SDL_ShouldPollJoystick()) {
SDL_JoystickUpdate();
308
}
309
#endif
310
311
312
313
}
/* Public functions */
314
315
int
SDL_PollEvent(SDL_Event * event)
316
{
317
return SDL_WaitEventTimeout(event, 0);
318
319
}
320
321
int
SDL_WaitEvent(SDL_Event * event)
322
{
323
324
325
326
327
328
329
330
331
332
333
334
return SDL_WaitEventTimeout(event, -1);
}
int
SDL_WaitEventTimeout(SDL_Event * event, int timeout)
{
Uint32 expiration = 0;
if (timeout > 0)
expiration = SDL_GetTicks() + timeout;
for (;;) {
335
SDL_PumpEvents();
336
switch (SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
337
338
339
340
341
case -1:
return 0;
case 1:
return 1;
case 0:
342
343
344
345
346
347
348
349
if (timeout == 0) {
/* Polling and no events, just return */
return 0;
}
if (timeout > 0 && ((int) (SDL_GetTicks() - expiration) >= 0)) {
/* Timeout expired and no events */
return 0;
}
350
SDL_Delay(10);
351
break;
352
353
}
}
354
355
}
356
357
int
SDL_PushEvent(SDL_Event * event)
358
{
359
360
SDL_EventWatcher *curr;
361
362
363
if (SDL_EventOK && !SDL_EventOK(SDL_EventOKParam, event)) {
return 0;
}
364
365
366
367
368
for (curr = SDL_event_watchers; curr; curr = curr->next) {
curr->callback(curr->userdata, event);
}
369
if (SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0, 0) <= 0) {
370
371
return -1;
}
372
373
374
375
SDL_GestureProcessEvent(event);
376
return 1;
377
378
}
379
380
void
SDL_SetEventFilter(SDL_EventFilter filter, void *userdata)
381
{
382
SDL_Event bitbucket;
383
384
385
386
387
/* Set filter and discard pending events */
SDL_EventOK = filter;
SDL_EventOKParam = userdata;
while (SDL_PollEvent(&bitbucket) > 0);
388
389
}
390
391
SDL_bool
SDL_GetEventFilter(SDL_EventFilter * filter, void **userdata)
392
{
393
394
395
396
397
398
399
if (filter) {
*filter = SDL_EventOK;
}
if (userdata) {
*userdata = SDL_EventOKParam;
}
return SDL_EventOK ? SDL_TRUE : SDL_FALSE;
400
401
}
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
/* FIXME: This is not thread-safe yet */
void
SDL_AddEventWatch(SDL_EventFilter filter, void *userdata)
{
SDL_EventWatcher *watcher;
watcher = (SDL_EventWatcher *)SDL_malloc(sizeof(*watcher));
if (!watcher) {
/* Uh oh... */
return;
}
watcher->callback = filter;
watcher->userdata = userdata;
watcher->next = SDL_event_watchers;
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;
}
}
}
439
440
void
SDL_FilterEvents(SDL_EventFilter filter, void *userdata)
441
{
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
if (SDL_mutexP(SDL_EventQ.lock) == 0) {
int spot;
spot = SDL_EventQ.head;
while (spot != SDL_EventQ.tail) {
if (filter(userdata, &SDL_EventQ.event[spot])) {
spot = (spot + 1) % MAXEVENTS;
} else {
spot = SDL_CutEvent(spot);
}
}
}
SDL_mutexV(SDL_EventQ.lock);
}
Uint8
458
SDL_EventState(Uint32 type, int state)
459
460
{
Uint8 current_state;
461
462
Uint8 hi = ((type >> 8) & 0xff);
Uint8 lo = (type & 0xff);
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
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;
}
482
}
483
484
485
486
487
488
489
490
491
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;
492
493
494
}
}
495
496
497
498
499
500
501
502
503
504
505
506
507
return current_state;
}
Uint32
SDL_RegisterEvents(int numevents)
{
Uint32 event_base;
if (SDL_userevents+numevents <= SDL_LASTEVENT) {
event_base = SDL_userevents;
SDL_userevents += numevents;
} else {
event_base = (Uint32)-1;
508
}
509
return event_base;
510
511
512
513
}
/* This is a generic event handler.
*/
514
515
int
SDL_SendSysWMEvent(SDL_SysWMmsg * message)
516
{
517
518
519
int posted;
posted = 0;
520
if (SDL_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) {
521
522
523
524
525
526
527
528
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);
529
}
530
531
/* vi: set ts=4 sw=4 expandtab: */