Mercurial > sdl-ios-xcode
annotate src/thread/SDL_thread.c @ 1348:40d0975c1769
Date: Mon, 6 Feb 2006 11:41:04 -0500
From: "mystml@adinet.com.uy"
Subject: [SDL] ALT-F4 using DirectX
My game isn't getting SDL_QUIT when I press ALT-F4 using the DirectX
driver; it does get SDL_QUIT when I press the red X in the window.
I tracked this down to DX5_HandleMessage() in SDL_dx5events.c;
WM_SYSKEYDOWN is being trapped and ignored which causes Windows not to post
a WM_CLOSE, hence no SDL_QUIT is being generated.
The relevant code is this :
/* The keyboard is handled via DirectInput */
case WM_SYSKEYUP:
case WM_SYSKEYDOWN:
case WM_KEYUP:
case WM_KEYDOWN: {
/* Ignore windows keyboard messages */;
}
return(0);
If I comment the WM_SYSKEYDOWN case, it falls through DefWindowProc() and
ALT-F4 starts working again.
I'm not sure about the best way to fix this. One option is handling ALT-F4
as a particular case somehow, but doesn't sound good. Another option would
be to handle WM_SYSKEYDOWN separately and breaking instead of returning 0,
so processing falls through and goes to DefWindowProc which does The Right
Thing (TM). This seems to be the minimal change that makes ALT-F4 work and
normal keyboard input continues to work.
Does this sound reasonable? Am I overlooking anything? Do I submit a patch?
--Gabriel
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Wed, 08 Feb 2006 17:19:43 +0000 |
| parents | 604d73db6802 |
| children | c71e05b4dc2e |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1190
diff
changeset
|
3 Copyright (C) 1997-2006 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1190
diff
changeset
|
6 modify it under the terms of the GNU Lesser General Public |
| 0 | 7 License as published by the Free Software Foundation; either |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1190
diff
changeset
|
8 version 2.1 of the License, or (at your option) any later version. |
| 0 | 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 | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1190
diff
changeset
|
13 Lesser General Public License for more details. |
| 0 | 14 |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1190
diff
changeset
|
15 You should have received a copy of the GNU Lesser General Public |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1190
diff
changeset
|
16 License along with this library; if not, write to the Free Software |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1190
diff
changeset
|
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 0 | 18 |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
0
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
| 22 | |
| 23 /* System independent thread management routines for SDL */ | |
| 24 | |
|
1338
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
25 #include "SDL_stdlib.h" |
|
604d73db6802
Removed uses of stdlib.h and string.h
Sam Lantinga <slouken@libsdl.org>
parents:
1336
diff
changeset
|
26 #include "SDL_string.h" |
| 0 | 27 #include "SDL_error.h" |
| 28 #include "SDL_mutex.h" | |
| 29 #include "SDL_thread.h" | |
| 30 #include "SDL_thread_c.h" | |
| 31 #include "SDL_systhread.h" | |
| 32 | |
| 33 #define ARRAY_CHUNKSIZE 32 | |
| 34 /* The array of threads currently active in the application | |
| 35 (except the main thread) | |
| 36 The manipulation of an array here is safer than using a linked list. | |
| 37 */ | |
| 38 static int SDL_maxthreads = 0; | |
| 39 static int SDL_numthreads = 0; | |
| 40 static SDL_Thread **SDL_Threads = NULL; | |
| 41 static SDL_mutex *thread_lock = NULL; | |
| 42 int _creating_thread_lock = 0; | |
| 43 | |
| 44 int SDL_ThreadsInit(void) | |
| 45 { | |
| 46 int retval; | |
| 47 | |
| 48 retval = 0; | |
| 49 /* Set the thread lock creation flag so that we can reuse an | |
| 50 existing lock on the system - since this mutex never gets | |
| 51 destroyed (see SDL_ThreadsQuit()), we want to reuse it. | |
| 52 */ | |
| 53 _creating_thread_lock = 1; | |
| 54 thread_lock = SDL_CreateMutex(); | |
| 55 _creating_thread_lock = 0; | |
| 56 if ( thread_lock == NULL ) { | |
| 57 retval = -1; | |
| 58 } | |
| 59 return(retval); | |
| 60 } | |
| 61 | |
| 62 /* This should never be called... | |
| 63 If this is called by SDL_Quit(), we don't know whether or not we should | |
| 64 clean up threads here. If any threads are still running after this call, | |
| 65 they will no longer have access to any per-thread data. | |
| 66 */ | |
| 67 void SDL_ThreadsQuit() | |
| 68 { | |
| 69 SDL_mutex *mutex; | |
| 70 | |
| 71 mutex = thread_lock; | |
| 72 thread_lock = NULL; | |
| 73 if ( mutex != NULL ) { | |
| 74 SDL_DestroyMutex(mutex); | |
| 75 } | |
| 76 } | |
| 77 | |
| 78 /* Routines for manipulating the thread list */ | |
| 79 static void SDL_AddThread(SDL_Thread *thread) | |
| 80 { | |
| 81 SDL_Thread **threads; | |
| 82 | |
| 83 /* WARNING: | |
| 84 If the very first threads are created simultaneously, then | |
| 85 there could be a race condition causing memory corruption. | |
| 86 In practice, this isn't a problem because by definition there | |
| 87 is only one thread running the first time this is called. | |
| 88 */ | |
| 89 if ( thread_lock == NULL ) { | |
| 90 if ( SDL_ThreadsInit() < 0 ) { | |
| 91 return; | |
| 92 } | |
| 93 } | |
| 94 SDL_mutexP(thread_lock); | |
| 95 | |
| 96 /* Expand the list of threads, if necessary */ | |
| 97 #ifdef DEBUG_THREADS | |
| 98 printf("Adding thread (%d already - %d max)\n", | |
| 99 SDL_numthreads, SDL_maxthreads); | |
| 100 #endif | |
| 101 if ( SDL_numthreads == SDL_maxthreads ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
102 threads=(SDL_Thread **)SDL_malloc((SDL_maxthreads+ARRAY_CHUNKSIZE)* |
| 0 | 103 (sizeof *threads)); |
| 104 if ( threads == NULL ) { | |
| 105 SDL_OutOfMemory(); | |
| 106 goto done; | |
| 107 } | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
108 SDL_memcpy(threads, SDL_Threads, SDL_numthreads*(sizeof *threads)); |
| 0 | 109 SDL_maxthreads += ARRAY_CHUNKSIZE; |
| 110 if ( SDL_Threads ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
111 SDL_free(SDL_Threads); |
| 0 | 112 } |
| 113 SDL_Threads = threads; | |
| 114 } | |
| 115 SDL_Threads[SDL_numthreads++] = thread; | |
| 116 done: | |
| 117 SDL_mutexV(thread_lock); | |
| 118 } | |
| 119 | |
| 120 static void SDL_DelThread(SDL_Thread *thread) | |
| 121 { | |
| 122 int i; | |
| 123 | |
| 124 if ( thread_lock ) { | |
| 125 SDL_mutexP(thread_lock); | |
| 126 for ( i=0; i<SDL_numthreads; ++i ) { | |
| 127 if ( thread == SDL_Threads[i] ) { | |
| 128 break; | |
| 129 } | |
| 130 } | |
| 131 if ( i < SDL_numthreads ) { | |
|
340
b9f1ce709960
Fixed a minor memory leak in the SDL thread subsystem
Sam Lantinga <slouken@libsdl.org>
parents:
329
diff
changeset
|
132 if ( --SDL_numthreads > 0 ) { |
|
b9f1ce709960
Fixed a minor memory leak in the SDL thread subsystem
Sam Lantinga <slouken@libsdl.org>
parents:
329
diff
changeset
|
133 while ( i < SDL_numthreads ) { |
|
b9f1ce709960
Fixed a minor memory leak in the SDL thread subsystem
Sam Lantinga <slouken@libsdl.org>
parents:
329
diff
changeset
|
134 SDL_Threads[i] = SDL_Threads[i+1]; |
|
b9f1ce709960
Fixed a minor memory leak in the SDL thread subsystem
Sam Lantinga <slouken@libsdl.org>
parents:
329
diff
changeset
|
135 ++i; |
|
b9f1ce709960
Fixed a minor memory leak in the SDL thread subsystem
Sam Lantinga <slouken@libsdl.org>
parents:
329
diff
changeset
|
136 } |
|
b9f1ce709960
Fixed a minor memory leak in the SDL thread subsystem
Sam Lantinga <slouken@libsdl.org>
parents:
329
diff
changeset
|
137 } else { |
|
b9f1ce709960
Fixed a minor memory leak in the SDL thread subsystem
Sam Lantinga <slouken@libsdl.org>
parents:
329
diff
changeset
|
138 SDL_maxthreads = 0; |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
139 SDL_free(SDL_Threads); |
|
340
b9f1ce709960
Fixed a minor memory leak in the SDL thread subsystem
Sam Lantinga <slouken@libsdl.org>
parents:
329
diff
changeset
|
140 SDL_Threads = NULL; |
| 0 | 141 } |
| 142 #ifdef DEBUG_THREADS | |
| 143 printf("Deleting thread (%d left - %d max)\n", | |
| 144 SDL_numthreads, SDL_maxthreads); | |
| 145 #endif | |
| 146 } | |
| 147 SDL_mutexV(thread_lock); | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 /* The default (non-thread-safe) global error variable */ | |
| 152 static SDL_error SDL_global_error; | |
| 153 | |
| 154 /* Routine to get the thread-specific error variable */ | |
| 155 SDL_error *SDL_GetErrBuf(void) | |
| 156 { | |
| 157 SDL_error *errbuf; | |
| 158 | |
| 159 errbuf = &SDL_global_error; | |
| 160 if ( SDL_Threads ) { | |
| 161 int i; | |
| 162 Uint32 this_thread; | |
| 163 | |
| 164 this_thread = SDL_ThreadID(); | |
| 165 SDL_mutexP(thread_lock); | |
| 166 for ( i=0; i<SDL_numthreads; ++i ) { | |
| 167 if ( this_thread == SDL_Threads[i]->threadid ) { | |
| 168 errbuf = &SDL_Threads[i]->errbuf; | |
| 169 break; | |
| 170 } | |
| 171 } | |
| 172 SDL_mutexV(thread_lock); | |
| 173 } | |
| 174 return(errbuf); | |
| 175 } | |
| 176 | |
| 177 | |
| 178 /* Arguments and callback to setup and run the user thread function */ | |
| 179 typedef struct { | |
| 180 int (*func)(void *); | |
| 181 void *data; | |
| 182 SDL_Thread *info; | |
| 183 SDL_sem *wait; | |
| 184 } thread_args; | |
| 185 | |
| 186 void SDL_RunThread(void *data) | |
| 187 { | |
| 188 thread_args *args; | |
| 189 int (*userfunc)(void *); | |
| 190 void *userdata; | |
| 191 int *statusloc; | |
| 192 | |
| 193 /* Perform any system-dependent setup | |
| 194 - this function cannot fail, and cannot use SDL_SetError() | |
| 195 */ | |
| 196 SDL_SYS_SetupThread(); | |
| 197 | |
| 198 /* Get the thread id */ | |
| 199 args = (thread_args *)data; | |
| 200 args->info->threadid = SDL_ThreadID(); | |
| 201 | |
| 202 /* Figure out what function to run */ | |
| 203 userfunc = args->func; | |
| 204 userdata = args->data; | |
| 205 statusloc = &args->info->status; | |
| 206 | |
| 207 /* Wake up the parent thread */ | |
| 208 SDL_SemPost(args->wait); | |
| 209 | |
| 210 /* Run the function */ | |
| 211 *statusloc = userfunc(userdata); | |
| 212 } | |
| 213 | |
|
1330
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
214 #if defined(_WIN32) || defined(__OS2__) |
|
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
215 #undef SDL_CreateThread |
|
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
216 DECLSPEC SDL_Thread * SDLCALL SDL_CreateThread(int (*fn)(void *), void *data, pfnSDL_CurrentBeginThread pfnBeginThread, pfnSDL_CurrentEndThread pfnEndThread) |
| 1190 | 217 #else |
| 218 DECLSPEC SDL_Thread * SDLCALL SDL_CreateThread(int (*fn)(void *), void *data) | |
| 219 #endif | |
| 0 | 220 { |
| 221 SDL_Thread *thread; | |
| 222 thread_args *args; | |
| 223 int ret; | |
| 224 | |
| 225 /* Allocate memory for the thread info structure */ | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
226 thread = (SDL_Thread *)SDL_malloc(sizeof(*thread)); |
| 0 | 227 if ( thread == NULL ) { |
| 228 SDL_OutOfMemory(); | |
| 229 return(NULL); | |
| 230 } | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
231 SDL_memset(thread, 0, (sizeof *thread)); |
| 0 | 232 thread->status = -1; |
| 233 | |
| 234 /* Set up the arguments for the thread */ | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
235 args = (thread_args *)SDL_malloc(sizeof(*args)); |
| 0 | 236 if ( args == NULL ) { |
| 237 SDL_OutOfMemory(); | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
238 SDL_free(thread); |
| 0 | 239 return(NULL); |
| 240 } | |
| 241 args->func = fn; | |
| 242 args->data = data; | |
| 243 args->info = thread; | |
| 244 args->wait = SDL_CreateSemaphore(0); | |
| 245 if ( args->wait == NULL ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
246 SDL_free(thread); |
|
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
247 SDL_free(args); |
| 0 | 248 return(NULL); |
| 249 } | |
| 250 | |
| 251 /* Add the thread to the list of available threads */ | |
| 252 SDL_AddThread(thread); | |
| 253 | |
| 254 /* Create the thread and go! */ | |
|
1330
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
255 #if defined(_WIN32) || defined(__OS2__) |
|
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
256 ret = SDL_SYS_CreateThread(thread, args, pfnBeginThread, pfnEndThread); |
| 1190 | 257 #else |
| 0 | 258 ret = SDL_SYS_CreateThread(thread, args); |
| 1190 | 259 #endif |
| 0 | 260 if ( ret >= 0 ) { |
| 261 /* Wait for the thread function to use arguments */ | |
| 262 SDL_SemWait(args->wait); | |
| 263 } else { | |
| 264 /* Oops, failed. Gotta free everything */ | |
| 265 SDL_DelThread(thread); | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
266 SDL_free(thread); |
| 0 | 267 thread = NULL; |
| 268 } | |
| 269 SDL_DestroySemaphore(args->wait); | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
270 SDL_free(args); |
| 0 | 271 |
| 272 /* Everything is running now */ | |
| 273 return(thread); | |
| 274 } | |
| 275 | |
| 276 void SDL_WaitThread(SDL_Thread *thread, int *status) | |
| 277 { | |
| 278 if ( thread ) { | |
| 279 SDL_SYS_WaitThread(thread); | |
| 280 if ( status ) { | |
| 281 *status = thread->status; | |
| 282 } | |
| 283 SDL_DelThread(thread); | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
284 SDL_free(thread); |
| 0 | 285 } |
| 286 } | |
| 287 | |
| 288 Uint32 SDL_GetThreadID(SDL_Thread *thread) | |
| 289 { | |
| 290 Uint32 id; | |
| 291 | |
| 292 if ( thread ) { | |
| 293 id = thread->threadid; | |
| 294 } else { | |
| 295 id = SDL_ThreadID(); | |
| 296 } | |
| 297 return(id); | |
| 298 } | |
| 299 | |
| 300 void SDL_KillThread(SDL_Thread *thread) | |
| 301 { | |
| 302 if ( thread ) { | |
| 303 SDL_SYS_KillThread(thread); | |
| 304 SDL_WaitThread(thread, NULL); | |
| 305 } | |
| 306 } | |
| 307 |