[sdl_omap.git] / src / events / SDL_events.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/* General event handling code for SDL */

#include "SDL.h"
#include "SDL_syswm.h"
#include "SDL_sysevents.h"
#include "SDL_events_c.h"
#include "../timer/SDL_timer_c.h"
#if !SDL_JOYSTICK_DISABLED
#include "../joystick/SDL_joystick_c.h"
#endif

/* Public data -- the event filter */
SDL_EventFilter SDL_EventOK = NULL;
Uint8 SDL_ProcessEvents[SDL_NUMEVENTS];
static Uint32 SDL_eventstate = 0;

/* Private data -- event queue */
#define MAXEVENTS	128
static struct {
	SDL_mutex *lock;
	int active;
	int head;
	int tail;
	SDL_Event event[MAXEVENTS];
	int wmmsg_next;
	struct SDL_SysWMmsg wmmsg[MAXEVENTS];
} SDL_EventQ;

/* Private data -- event locking structure */
static struct {
	SDL_mutex *lock;
	int safe;
} SDL_EventLock;

/* Thread functions */
static SDL_Thread *SDL_EventThread = NULL;	/* Thread handle */
static Uint32 event_thread;			/* The event thread id */

void SDL_Lock_EventThread(void)
{
	if ( SDL_EventThread && (SDL_ThreadID() != event_thread) ) {
		/* Grab lock and spin until we're sure event thread stopped */
		SDL_mutexP(SDL_EventLock.lock);
		while ( ! SDL_EventLock.safe ) {
			SDL_Delay(1);
		}
	}
}
void SDL_Unlock_EventThread(void)
{
	if ( SDL_EventThread && (SDL_ThreadID() != event_thread) ) {
		SDL_mutexV(SDL_EventLock.lock);
	}
}

#ifdef __OS2__
/*
 * We'll increase the priority of GobbleEvents thread, so it will process
 *  events in time for sure! For this, we need the DosSetPriority() API
 *  from the os2.h include file.
 */
#define INCL_DOSPROCESS
#include <os2.h>
#include <time.h>
#endif

static int SDLCALL SDL_GobbleEvents(void *unused)
{
	event_thread = SDL_ThreadID();

#ifdef __OS2__
#ifdef USE_DOSSETPRIORITY
	/* Increase thread priority, so it will process events in time for sure! */
	DosSetPriority(PRTYS_THREAD, PRTYC_REGULAR, +16, 0);
#endif
#endif

	while ( SDL_EventQ.active ) {
		SDL_VideoDevice *video = current_video;
		SDL_VideoDevice *this  = current_video;

		/* Get events from the video subsystem */
		if ( video ) {
			video->PumpEvents(this);
		}

		/* Queue pending key-repeat events */
		SDL_CheckKeyRepeat();

#if !SDL_JOYSTICK_DISABLED
		/* Check for joystick state change */
		if ( SDL_numjoysticks && (SDL_eventstate & SDL_JOYEVENTMASK) ) {
			SDL_JoystickUpdate();
		}
#endif

		/* Give up the CPU for the rest of our timeslice */
		SDL_EventLock.safe = 1;
		if ( SDL_timer_running ) {
			SDL_ThreadedTimerCheck();
		}
		SDL_Delay(1);

		/* Check for event locking.
		   On the P of the lock mutex, if the lock is held, this thread
		   will wait until the lock is released before continuing.  The
		   safe flag will be set, meaning that the other thread can go
		   about it's business.  The safe flag is reset before the V,
		   so as soon as the mutex is free, other threads can see that
		   it's not safe to interfere with the event thread.
		 */
		SDL_mutexP(SDL_EventLock.lock);
		SDL_EventLock.safe = 0;
		SDL_mutexV(SDL_EventLock.lock);
	}
	SDL_SetTimerThreaded(0);
	event_thread = 0;
	return(0);
}

static int SDL_StartEventThread(Uint32 flags)
{
	/* Reset everything to zero */
	SDL_EventThread = NULL;
	SDL_memset(&SDL_EventLock, 0, sizeof(SDL_EventLock));

	/* Create the lock and set ourselves active */
#if !SDL_THREADS_DISABLED
	SDL_EventQ.lock = SDL_CreateMutex();
	if ( SDL_EventQ.lock == NULL ) {
#ifdef __MACOS__ /* MacOS classic you can't multithread, so no lock needed */
		;
#else
		return(-1);
#endif
	}
#endif /* !SDL_THREADS_DISABLED */
	SDL_EventQ.active = 1;

	if ( (flags&SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD ) {
		SDL_EventLock.lock = SDL_CreateMutex();
		if ( SDL_EventLock.lock == NULL ) {
			return(-1);
		}
		SDL_EventLock.safe = 0;

		/* The event thread will handle timers too */
		SDL_SetTimerThreaded(2);
#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC) && !defined(__SYMBIAN32__)
#undef SDL_CreateThread
		SDL_EventThread = SDL_CreateThread(SDL_GobbleEvents, NULL, NULL, NULL);
#else
		SDL_EventThread = SDL_CreateThread(SDL_GobbleEvents, NULL);
#endif
		if ( SDL_EventThread == NULL ) {
			return(-1);
		}
	} else {
		event_thread = 0;
	}
	return(0);
}

static void SDL_StopEventThread(void)
{
	SDL_EventQ.active = 0;
	if ( SDL_EventThread ) {
		SDL_WaitThread(SDL_EventThread, NULL);
		SDL_EventThread = NULL;
		SDL_DestroyMutex(SDL_EventLock.lock);
		SDL_EventLock.lock = NULL;
	}
#ifndef IPOD
	SDL_DestroyMutex(SDL_EventQ.lock);
	SDL_EventQ.lock = NULL;
#endif
}

Uint32 SDL_EventThreadID(void)
{
	return(event_thread);
}

/* Public functions */

void SDL_StopEventLoop(void)
{
	/* Halt the event thread, if running */
	SDL_StopEventThread();

	/* Shutdown event handlers */
	SDL_AppActiveQuit();
	SDL_KeyboardQuit();
	SDL_MouseQuit();
	SDL_QuitQuit();

	/* Clean out EventQ */
	SDL_EventQ.head = 0;
	SDL_EventQ.tail = 0;
	SDL_EventQ.wmmsg_next = 0;
}

/* This function (and associated calls) may be called more than once */
int SDL_StartEventLoop(Uint32 flags)
{
	int retcode;

	/* Clean out the event queue */
	SDL_EventThread = NULL;
	SDL_EventQ.lock = NULL;
	SDL_StopEventLoop();

	/* No filter to start with, process most event types */
	SDL_EventOK = NULL;
	SDL_memset(SDL_ProcessEvents,SDL_ENABLE,sizeof(SDL_ProcessEvents));
	SDL_eventstate = ~0;
	/* It's not save to call SDL_EventState() yet */
	SDL_eventstate &= ~(0x00000001 << SDL_SYSWMEVENT);
	SDL_ProcessEvents[SDL_SYSWMEVENT] = SDL_IGNORE;

	/* Initialize event handlers */
	retcode = 0;
	retcode += SDL_AppActiveInit();
	retcode += SDL_KeyboardInit();
	retcode += SDL_MouseInit();
	retcode += SDL_QuitInit();
	if ( retcode < 0 ) {
		/* We don't expect them to fail, but... */
		return(-1);
	}

	/* Create the lock and event thread */
	if ( SDL_StartEventThread(flags) < 0 ) {
		SDL_StopEventLoop();
		return(-1);
	}
	return(0);
}


/* Add an event to the event queue -- called with the queue locked */
static int SDL_AddEvent(SDL_Event *event)
{
	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);
}

/* Cut an event, and return the next valid spot, or the tail */
/*                           -- called with the queue locked */
static int SDL_CutEvent(int spot)
{
	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 */
}

/* Lock the event queue, take a peep at it, and unlock it */
int SDL_PeepEvents(SDL_Event *events, int numevents, SDL_eventaction action,
								Uint32 mask)
{
	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)) {
				if ( mask & SDL_EVENTMASK(SDL_EventQ.event[spot].type) ) {
					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);
}

/* Run the system dependent event loops */
void SDL_PumpEvents(void)
{
	if ( !SDL_EventThread ) {
		SDL_VideoDevice *video = current_video;
		SDL_VideoDevice *this  = current_video;

		/* Get events from the video subsystem */
		if ( video ) {
			video->PumpEvents(this);
		}

		/* Queue pending key-repeat events */
		SDL_CheckKeyRepeat();

#if !SDL_JOYSTICK_DISABLED
		/* Check for joystick state change */
		if ( SDL_numjoysticks && (SDL_eventstate & SDL_JOYEVENTMASK) ) {
			SDL_JoystickUpdate();
		}
#endif
	}
}

/* Public functions */

int SDL_PollEvent (SDL_Event *event)
{
	SDL_PumpEvents();

	/* We can't return -1, just return 0 (no event) on error */
	if ( SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS) <= 0 )
		return 0;
	return 1;
}

int SDL_WaitEvent (SDL_Event *event)
{
	while ( 1 ) {
		SDL_PumpEvents();
		switch(SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
		    case -1: return 0;
		    case 1: return 1;
		    case 0: SDL_Delay(10);
		}
	}
}

int SDL_PushEvent(SDL_Event *event)
{
	if ( SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0) <= 0 )
		return -1;
	return 0;
}

void SDL_SetEventFilter (SDL_EventFilter filter)
{
	SDL_Event bitbucket;

	/* Set filter and discard pending events */
	SDL_EventOK = filter;
	while ( SDL_PollEvent(&bitbucket) > 0 )
		;
}

SDL_EventFilter SDL_GetEventFilter(void)
{
	return(SDL_EventOK);
}

Uint8 SDL_EventState (Uint8 type, int state)
{
	SDL_Event bitbucket;
	Uint8 current_state;

	/* If SDL_ALLEVENTS was specified... */
	if ( type == 0xFF ) {
		current_state = SDL_IGNORE;
		for ( type=0; type<SDL_NUMEVENTS; ++type ) {
			if ( SDL_ProcessEvents[type] != SDL_IGNORE ) {
				current_state = SDL_ENABLE;
			}
			SDL_ProcessEvents[type] = state;
			if ( state == SDL_ENABLE ) {
				SDL_eventstate |= (0x00000001 << (type));
			} else {
				SDL_eventstate &= ~(0x00000001 << (type));
			}
		}
		while ( SDL_PollEvent(&bitbucket) > 0 )
			;
		return(current_state);
	}

	/* Just set the state for one event type */
	current_state = SDL_ProcessEvents[type];
	switch (state) {
		case SDL_IGNORE:
		case SDL_ENABLE:
			/* Set state and discard pending events */
			SDL_ProcessEvents[type] = state;
			if ( state == SDL_ENABLE ) {
				SDL_eventstate |= (0x00000001 << (type));
			} else {
				SDL_eventstate &= ~(0x00000001 << (type));
			}
			while ( SDL_PollEvent(&bitbucket) > 0 )
				;
			break;
		default:
			/* Querying state? */
			break;
	}
	return(current_state);
}

/* This is a generic event handler.
 */
int SDL_PrivateSysWMEvent(SDL_SysWMmsg *message)
{
	int posted;

	posted = 0;
	if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
		SDL_Event event;
		SDL_memset(&event, 0, sizeof(event));
		event.type = SDL_SYSWMEVENT;
		event.syswm.msg = message;
		if ( (SDL_EventOK == NULL) || (*SDL_EventOK)(&event) ) {
			posted = 1;
			SDL_PushEvent(&event);
		}
	}
	/* Update internal event state */
	return(posted);
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	/* General event handling code for SDL */
	25
	26	#include "SDL.h"
	27	#include "SDL_syswm.h"
	28	#include "SDL_sysevents.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
	35	/* Public data -- the event filter */
	36	SDL_EventFilter SDL_EventOK = NULL;
	37	Uint8 SDL_ProcessEvents[SDL_NUMEVENTS];
	38	static Uint32 SDL_eventstate = 0;
	39
	40	/* Private data -- event queue */
	41	#define MAXEVENTS 128
	42	static struct {
	43	SDL_mutex *lock;
	44	int active;
	45	int head;
	46	int tail;
	47	SDL_Event event[MAXEVENTS];
	48	int wmmsg_next;
	49	struct SDL_SysWMmsg wmmsg[MAXEVENTS];
	50	} SDL_EventQ;
	51
	52	/* Private data -- event locking structure */
	53	static struct {
	54	SDL_mutex *lock;
	55	int safe;
	56	} SDL_EventLock;
	57
	58	/* Thread functions */
	59	static SDL_Thread SDL_EventThread = NULL; / Thread handle */
	60	static Uint32 event_thread; /* The event thread id */
	61
	62	void SDL_Lock_EventThread(void)
	63	{
	64	if ( SDL_EventThread && (SDL_ThreadID() != event_thread) ) {
65	/* Grab lock and spin until we're sure event thread stopped */
66	SDL_mutexP(SDL_EventLock.lock);
67	while ( ! SDL_EventLock.safe ) {
68	SDL_Delay(1);
69	}
70	}
71	}
72	void SDL_Unlock_EventThread(void)
73	{
74	if ( SDL_EventThread && (SDL_ThreadID() != event_thread) ) {
75	SDL_mutexV(SDL_EventLock.lock);
76	}
77	}
78
79	#ifdef __OS2__
80	/*
81	* We'll increase the priority of GobbleEvents thread, so it will process
82	* events in time for sure! For this, we need the DosSetPriority() API
83	* from the os2.h include file.
84	*/
85	#define INCL_DOSPROCESS
86	#include <os2.h>
87	#include <time.h>
88	#endif
89
90	static int SDLCALL SDL_GobbleEvents(void *unused)
91	{
92	event_thread = SDL_ThreadID();
93
94	#ifdef __OS2__
95	#ifdef USE_DOSSETPRIORITY
96	/* Increase thread priority, so it will process events in time for sure! */
97	DosSetPriority(PRTYS_THREAD, PRTYC_REGULAR, +16, 0);
98	#endif
99	#endif
100
101	while ( SDL_EventQ.active ) {
102	SDL_VideoDevice *video = current_video;
103	SDL_VideoDevice *this = current_video;
104
105	/* Get events from the video subsystem */
106	if ( video ) {
107	video->PumpEvents(this);
108	}
109
110	/* Queue pending key-repeat events */
111	SDL_CheckKeyRepeat();
112
113	#if !SDL_JOYSTICK_DISABLED
114	/* Check for joystick state change */
115	if ( SDL_numjoysticks && (SDL_eventstate & SDL_JOYEVENTMASK) ) {
116	SDL_JoystickUpdate();
117	}
118	#endif
119
120	/* Give up the CPU for the rest of our timeslice */
121	SDL_EventLock.safe = 1;
122	if ( SDL_timer_running ) {
123	SDL_ThreadedTimerCheck();
124	}
125	SDL_Delay(1);
126
127	/* Check for event locking.
128	On the P of the lock mutex, if the lock is held, this thread
129	will wait until the lock is released before continuing. The
130	safe flag will be set, meaning that the other thread can go
131	about it's business. The safe flag is reset before the V,
132	so as soon as the mutex is free, other threads can see that
133	it's not safe to interfere with the event thread.
134	*/
135	SDL_mutexP(SDL_EventLock.lock);
136	SDL_EventLock.safe = 0;
137	SDL_mutexV(SDL_EventLock.lock);
138	}
139	SDL_SetTimerThreaded(0);
140	event_thread = 0;
141	return(0);
142	}
143
144	static int SDL_StartEventThread(Uint32 flags)
145	{
146	/* Reset everything to zero */
147	SDL_EventThread = NULL;
148	SDL_memset(&SDL_EventLock, 0, sizeof(SDL_EventLock));
149
150	/* Create the lock and set ourselves active */
151	#if !SDL_THREADS_DISABLED
152	SDL_EventQ.lock = SDL_CreateMutex();
153	if ( SDL_EventQ.lock == NULL ) {
154	#ifdef __MACOS__ /* MacOS classic you can't multithread, so no lock needed */
155	;
156	#else
157	return(-1);
158	#endif
159	}
160	#endif /* !SDL_THREADS_DISABLED */
161	SDL_EventQ.active = 1;
162
163	if ( (flags&SDL_INIT_EVENTTHREAD) == SDL_INIT_EVENTTHREAD ) {
164	SDL_EventLock.lock = SDL_CreateMutex();
165	if ( SDL_EventLock.lock == NULL ) {
166	return(-1);
167	}
168	SDL_EventLock.safe = 0;
169
170	/* The event thread will handle timers too */
171	SDL_SetTimerThreaded(2);
172	#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC) && !defined(__SYMBIAN32__)
173	#undef SDL_CreateThread
174	SDL_EventThread = SDL_CreateThread(SDL_GobbleEvents, NULL, NULL, NULL);
175	#else
176	SDL_EventThread = SDL_CreateThread(SDL_GobbleEvents, NULL);
177	#endif
178	if ( SDL_EventThread == NULL ) {
179	return(-1);
180	}
181	} else {
182	event_thread = 0;
183	}
184	return(0);
185	}
186
187	static void SDL_StopEventThread(void)
188	{
189	SDL_EventQ.active = 0;
190	if ( SDL_EventThread ) {
191	SDL_WaitThread(SDL_EventThread, NULL);
192	SDL_EventThread = NULL;
193	SDL_DestroyMutex(SDL_EventLock.lock);
194	SDL_EventLock.lock = NULL;
195	}
196	#ifndef IPOD
197	SDL_DestroyMutex(SDL_EventQ.lock);
198	SDL_EventQ.lock = NULL;
199	#endif
200	}
201
202	Uint32 SDL_EventThreadID(void)
203	{
204	return(event_thread);
205	}
206
207	/* Public functions */
208
209	void SDL_StopEventLoop(void)
210	{
211	/* Halt the event thread, if running */
212	SDL_StopEventThread();
213
214	/* Shutdown event handlers */
215	SDL_AppActiveQuit();
216	SDL_KeyboardQuit();
217	SDL_MouseQuit();
218	SDL_QuitQuit();
219
220	/* Clean out EventQ */
221	SDL_EventQ.head = 0;
222	SDL_EventQ.tail = 0;
223	SDL_EventQ.wmmsg_next = 0;
224	}
225
226	/* This function (and associated calls) may be called more than once */
227	int SDL_StartEventLoop(Uint32 flags)
228	{
229	int retcode;
230
231	/* Clean out the event queue */
232	SDL_EventThread = NULL;
233	SDL_EventQ.lock = NULL;
234	SDL_StopEventLoop();
235
236	/* No filter to start with, process most event types */
237	SDL_EventOK = NULL;
238	SDL_memset(SDL_ProcessEvents,SDL_ENABLE,sizeof(SDL_ProcessEvents));
239	SDL_eventstate = ~0;
240	/* It's not save to call SDL_EventState() yet */
241	SDL_eventstate &= ~(0x00000001 << SDL_SYSWMEVENT);
242	SDL_ProcessEvents[SDL_SYSWMEVENT] = SDL_IGNORE;
243
244	/* Initialize event handlers */
245	retcode = 0;
246	retcode += SDL_AppActiveInit();
247	retcode += SDL_KeyboardInit();
248	retcode += SDL_MouseInit();
249	retcode += SDL_QuitInit();
250	if ( retcode < 0 ) {
251	/* We don't expect them to fail, but... */
252	return(-1);
253	}
254
255	/* Create the lock and event thread */
256	if ( SDL_StartEventThread(flags) < 0 ) {
257	SDL_StopEventLoop();
258	return(-1);
259	}
260	return(0);
261	}
262
263
264	/* Add an event to the event queue -- called with the queue locked */
265	static int SDL_AddEvent(SDL_Event *event)
266	{
267	int tail, added;
268
269	tail = (SDL_EventQ.tail+1)%MAXEVENTS;
270	if ( tail == SDL_EventQ.head ) {
271	/* Overflow, drop event */
272	added = 0;
273	} else {
274	SDL_EventQ.event[SDL_EventQ.tail] = *event;
275	if (event->type == SDL_SYSWMEVENT) {
276	/* Note that it's possible to lose an event */
277	int next = SDL_EventQ.wmmsg_next;
278	SDL_EventQ.wmmsg[next] = *event->syswm.msg;
279	SDL_EventQ.event[SDL_EventQ.tail].syswm.msg =
280	&SDL_EventQ.wmmsg[next];
281	SDL_EventQ.wmmsg_next = (next+1)%MAXEVENTS;
282	}
283	SDL_EventQ.tail = tail;
284	added = 1;
285	}
286	return(added);
287	}
288
289	/* Cut an event, and return the next valid spot, or the tail */
290	/* -- called with the queue locked */
291	static int SDL_CutEvent(int spot)
292	{
293	if ( spot == SDL_EventQ.head ) {
294	SDL_EventQ.head = (SDL_EventQ.head+1)%MAXEVENTS;
295	return(SDL_EventQ.head);
296	} else
297	if ( (spot+1)%MAXEVENTS == SDL_EventQ.tail ) {
298	SDL_EventQ.tail = spot;
299	return(SDL_EventQ.tail);
300	} else
301	/* We cut the middle -- shift everything over */
302	{
303	int here, next;
304
305	/* This can probably be optimized with SDL_memcpy() -- careful! */
306	if ( --SDL_EventQ.tail < 0 ) {
307	SDL_EventQ.tail = MAXEVENTS-1;
308	}
309	for ( here=spot; here != SDL_EventQ.tail; here = next ) {
310	next = (here+1)%MAXEVENTS;
311	SDL_EventQ.event[here] = SDL_EventQ.event[next];
312	}
313	return(spot);
314	}
315	/* NOTREACHED */
316	}
317
318	/* Lock the event queue, take a peep at it, and unlock it */
319	int SDL_PeepEvents(SDL_Event *events, int numevents, SDL_eventaction action,
320	Uint32 mask)
321	{
322	int i, used;
323
324	/* Don't look after we've quit */
325	if ( ! SDL_EventQ.active ) {
326	return(-1);
327	}
328	/* Lock the event queue */
329	used = 0;
330	if ( SDL_mutexP(SDL_EventQ.lock) == 0 ) {
331	if ( action == SDL_ADDEVENT ) {
332	for ( i=0; i<numevents; ++i ) {
333	used += SDL_AddEvent(&events[i]);
334	}
335	} else {
336	SDL_Event tmpevent;
337	int spot;
338
339	/* If 'events' is NULL, just see if they exist */
340	if ( events == NULL ) {
341	action = SDL_PEEKEVENT;
342	numevents = 1;
343	events = &tmpevent;
344	}
345	spot = SDL_EventQ.head;
346	while ((used < numevents)&&(spot != SDL_EventQ.tail)) {
347	if ( mask & SDL_EVENTMASK(SDL_EventQ.event[spot].type) ) {
348	events[used++] = SDL_EventQ.event[spot];
349	if ( action == SDL_GETEVENT ) {
350	spot = SDL_CutEvent(spot);
351	} else {
352	spot = (spot+1)%MAXEVENTS;
353	}
354	} else {
355	spot = (spot+1)%MAXEVENTS;
356	}
357	}
358	}
359	SDL_mutexV(SDL_EventQ.lock);
360	} else {
361	SDL_SetError("Couldn't lock event queue");
362	used = -1;
363	}
364	return(used);
365	}
366
367	/* Run the system dependent event loops */
368	void SDL_PumpEvents(void)
369	{
370	if ( !SDL_EventThread ) {
371	SDL_VideoDevice *video = current_video;
372	SDL_VideoDevice *this = current_video;
373
374	/* Get events from the video subsystem */
375	if ( video ) {
376	video->PumpEvents(this);
377	}
378
379	/* Queue pending key-repeat events */
380	SDL_CheckKeyRepeat();
381
382	#if !SDL_JOYSTICK_DISABLED
383	/* Check for joystick state change */
384	if ( SDL_numjoysticks && (SDL_eventstate & SDL_JOYEVENTMASK) ) {
385	SDL_JoystickUpdate();
386	}
387	#endif
388	}
389	}
390
391	/* Public functions */
392
393	int SDL_PollEvent (SDL_Event *event)
394	{
395	SDL_PumpEvents();
396
397	/* We can't return -1, just return 0 (no event) on error */
398	if ( SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS) <= 0 )
399	return 0;
400	return 1;
401	}
402
403	int SDL_WaitEvent (SDL_Event *event)
404	{
405	while ( 1 ) {
406	SDL_PumpEvents();
407	switch(SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_ALLEVENTS)) {
408	case -1: return 0;
409	case 1: return 1;
410	case 0: SDL_Delay(10);
411	}
412	}
413	}
414
415	int SDL_PushEvent(SDL_Event *event)
416	{
417	if ( SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0) <= 0 )
418	return -1;
419	return 0;
420	}
421
422	void SDL_SetEventFilter (SDL_EventFilter filter)
423	{
424	SDL_Event bitbucket;
425
426	/* Set filter and discard pending events */
427	SDL_EventOK = filter;
428	while ( SDL_PollEvent(&bitbucket) > 0 )
429	;
430	}
431
432	SDL_EventFilter SDL_GetEventFilter(void)
433	{
434	return(SDL_EventOK);
435	}
436
437	Uint8 SDL_EventState (Uint8 type, int state)
438	{
439	SDL_Event bitbucket;
440	Uint8 current_state;
441
442	/* If SDL_ALLEVENTS was specified... */
443	if ( type == 0xFF ) {
444	current_state = SDL_IGNORE;
445	for ( type=0; type<SDL_NUMEVENTS; ++type ) {
446	if ( SDL_ProcessEvents[type] != SDL_IGNORE ) {
447	current_state = SDL_ENABLE;
448	}
449	SDL_ProcessEvents[type] = state;
450	if ( state == SDL_ENABLE ) {
451	SDL_eventstate \|= (0x00000001 << (type));
452	} else {
453	SDL_eventstate &= ~(0x00000001 << (type));
454	}
455	}
456	while ( SDL_PollEvent(&bitbucket) > 0 )
457	;
458	return(current_state);
459	}
460
461	/* Just set the state for one event type */
462	current_state = SDL_ProcessEvents[type];
463	switch (state) {
464	case SDL_IGNORE:
465	case SDL_ENABLE:
466	/* Set state and discard pending events */
467	SDL_ProcessEvents[type] = state;
468	if ( state == SDL_ENABLE ) {
469	SDL_eventstate \|= (0x00000001 << (type));
470	} else {
471	SDL_eventstate &= ~(0x00000001 << (type));
472	}
473	while ( SDL_PollEvent(&bitbucket) > 0 )
474	;
475	break;
476	default:
477	/* Querying state? */
478	break;
479	}
480	return(current_state);
481	}
482
483	/* This is a generic event handler.
484	*/
485	int SDL_PrivateSysWMEvent(SDL_SysWMmsg *message)
486	{
487	int posted;
488
489	posted = 0;
490	if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
491	SDL_Event event;
492	SDL_memset(&event, 0, sizeof(event));
493	event.type = SDL_SYSWMEVENT;
494	event.syswm.msg = message;
495	if ( (SDL_EventOK == NULL) \|\| (*SDL_EventOK)(&event) ) {
496	posted = 1;
497	SDL_PushEvent(&event);
498	}
499	}
500	/* Update internal event state */
501	return(posted);
502	}