/
SDL_dibevents.c
607 lines (539 loc) · 16.2 KB
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
11
12
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
13
Lesser General Public License for more details.
14
15
16
17
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
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
26
27
#include "SDL_main.h"
28
29
#include "SDL_events.h"
#include "SDL_syswm.h"
30
31
32
#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "../wincommon/SDL_lowvideo.h"
33
#include "SDL_gapidibvideo.h"
34
35
#include "SDL_vkeys.h"
36
37
38
39
40
41
42
43
#ifdef SDL_VIDEO_DRIVER_GAPI
#include "../gapi/SDL_gapivideo.h"
#endif
#ifdef SDL_VIDEO_DRIVER_WINDIB
#include "SDL_dibvideo.h"
#endif
44
45
46
47
48
49
50
51
52
53
#ifndef WM_APP
#define WM_APP 0x8000
#endif
#ifdef _WIN32_WCE
#define NO_GETKEYBOARDSTATE
#endif
/* The translation table from a Microsoft VK keysym to a SDL keysym */
static SDLKey VK_keymap[SDLK_LAST];
54
static SDL_keysym *TranslateKey(WPARAM vkey, UINT scancode, SDL_keysym *keysym, int pressed);
55
static SDLKey Arrows_keymap[4];
56
57
58
59
60
/* Masks for processing the windows KEYDOWN and KEYUP messages */
#define REPEATED_KEYMASK (1<<30)
#define EXTENDED_KEYMASK (1<<24)
61
62
/* DJM: If the user setup the window for us, we want to save his window proc,
and give him a chance to handle some messages. */
63
64
65
66
67
68
#ifdef STRICT
#define WNDPROCTYPE WNDPROC
#else
#define WNDPROCTYPE FARPROC
#endif
static WNDPROCTYPE userWindowProc = NULL;
69
70
71
#ifdef SDL_VIDEO_DRIVER_GAPI
72
73
WPARAM rotateKey(WPARAM key,int direction)
74
{
75
76
if(direction ==0 ) return key;
77
78
switch (key) {
case 0x26: /* up */
79
return Arrows_keymap[(2 + direction) % 4];
80
case 0x27: /* right */
81
return Arrows_keymap[(1 + direction) % 4];
82
case 0x28: /* down */
83
return Arrows_keymap[direction % 4];
84
case 0x25: /* left */
85
return Arrows_keymap[(3 + direction) % 4];
86
87
88
89
90
91
92
93
}
return key;
}
#endif
94
/* The main Win32 event handler */
95
LRESULT DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
96
97
98
99
100
101
102
103
{
extern int posted;
switch (msg) {
case WM_SYSKEYDOWN:
case WM_KEYDOWN: {
SDL_keysym keysym;
104
105
106
107
108
109
#ifdef SDL_VIDEO_DRIVER_GAPI
if(this->hidden->gapiInfo)
{
// Drop GAPI artefacts
if (wParam == 0x84 || wParam == 0x5B)
return 0;
110
111
112
wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform);
}
113
#endif
114
115
116
117
118
119
120
121
122
123
124
125
126
/* Ignore repeated keys */
if ( lParam&REPEATED_KEYMASK ) {
return(0);
}
switch (wParam) {
case VK_CONTROL:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RCONTROL;
else
wParam = VK_LCONTROL;
break;
case VK_SHIFT:
/* EXTENDED trick doesn't work here */
127
128
129
{
Uint8 *state = SDL_GetKeyState(NULL);
if (state[SDLK_LSHIFT] == SDL_RELEASED && (GetKeyState(VK_LSHIFT) & 0x8000)) {
130
wParam = VK_LSHIFT;
131
} else if (state[SDLK_RSHIFT] == SDL_RELEASED && (GetKeyState(VK_RSHIFT) & 0x8000)) {
132
133
wParam = VK_RSHIFT;
} else {
134
135
136
137
138
139
140
141
142
143
/* Win9x */
int sc = HIWORD(lParam) & 0xFF;
if (sc == 0x2A)
wParam = VK_LSHIFT;
else
if (sc == 0x36)
wParam = VK_RSHIFT;
else
wParam = VK_LSHIFT;
144
}
145
}
146
147
148
149
150
151
152
153
break;
case VK_MENU:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
}
154
155
156
#ifdef NO_GETKEYBOARDSTATE
/* this is the workaround for the missing ToAscii() and ToUnicode() in CE (not necessary at KEYUP!) */
if ( SDL_TranslateUNICODE ) {
157
158
159
160
161
162
163
164
MSG m;
m.hwnd = hwnd;
m.message = msg;
m.wParam = wParam;
m.lParam = lParam;
m.time = 0;
if ( TranslateMessage(&m) && PeekMessage(&m, hwnd, 0, WM_USER, PM_NOREMOVE) && (m.message == WM_CHAR) ) {
165
166
167
168
169
GetMessage(&m, hwnd, 0, WM_USER);
wParam = m.wParam;
}
}
#endif /* NO_GETKEYBOARDSTATE */
170
171
172
173
174
175
176
177
178
posted = SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey(wParam,HIWORD(lParam),&keysym,1));
}
return(0);
case WM_SYSKEYUP:
case WM_KEYUP: {
SDL_keysym keysym;
179
180
181
182
183
184
185
186
187
#ifdef SDL_VIDEO_DRIVER_GAPI
if(this->hidden->gapiInfo)
{
// Drop GAPI artifacts
if (wParam == 0x84 || wParam == 0x5B)
return 0;
wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform);
}
188
189
#endif
190
191
192
193
194
195
196
197
198
switch (wParam) {
case VK_CONTROL:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RCONTROL;
else
wParam = VK_LCONTROL;
break;
case VK_SHIFT:
/* EXTENDED trick doesn't work here */
199
200
201
{
Uint8 *state = SDL_GetKeyState(NULL);
if (state[SDLK_LSHIFT] == SDL_PRESSED && !(GetKeyState(VK_LSHIFT) & 0x8000)) {
202
wParam = VK_LSHIFT;
203
} else if (state[SDLK_RSHIFT] == SDL_PRESSED && !(GetKeyState(VK_RSHIFT) & 0x8000)) {
204
205
wParam = VK_RSHIFT;
} else {
206
207
208
209
210
211
212
213
214
215
/* Win9x */
int sc = HIWORD(lParam) & 0xFF;
if (sc == 0x2A)
wParam = VK_LSHIFT;
else
if (sc == 0x36)
wParam = VK_RSHIFT;
else
wParam = VK_LSHIFT;
216
}
217
}
218
219
220
221
222
223
224
225
break;
case VK_MENU:
if ( lParam&EXTENDED_KEYMASK )
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
}
226
227
228
229
230
/* Windows only reports keyup for print screen */
if ( wParam == VK_SNAPSHOT && SDL_GetKeyState(NULL)[SDLK_PRINT] == SDL_RELEASED ) {
posted = SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey(wParam,HIWORD(lParam),&keysym,1));
}
231
232
233
234
posted = SDL_PrivateKeyboard(SDL_RELEASED,
TranslateKey(wParam,HIWORD(lParam),&keysym,0));
}
return(0);
235
236
#if defined(SC_SCREENSAVE) && defined(SC_MONITORPOWER)
case WM_SYSCOMMAND: {
237
238
const DWORD val = (DWORD) (wParam & 0xFFF0);
if ((val == SC_SCREENSAVE) || (val == SC_MONITORPOWER)) {
239
if (this->hidden->dibInfo && !allow_screensaver) {
240
241
/* Note that this doesn't stop anything on Vista
if the screensaver has a password. */
242
return(0);
243
244
}
}
245
246
247
248
}
/* Fall through to default processing */
#endif /* SC_SCREENSAVE && SC_MONITORPOWER */
249
250
251
252
253
254
255
256
257
258
259
default: {
/* Only post the event if we're watching for it */
if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
posted = SDL_PrivateSysWMEvent(&wmmsg);
260
261
262
263
264
265
/* DJM: If the user isn't watching for private
messages in her SDL event loop, then pass it
along to any win32 specific window proc.
*/
} else if (userWindowProc) {
266
return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
267
268
269
270
271
272
273
274
275
276
277
}
}
break;
}
return(DefWindowProc(hwnd, msg, wParam, lParam));
}
void DIB_PumpEvents(_THIS)
{
MSG msg;
278
279
while ( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) ) {
if ( GetMessage(&msg, NULL, 0, 0) > 0 ) {
280
281
282
283
284
DispatchMessage(&msg);
}
}
}
285
286
static HKL hLayoutUS = NULL;
287
288
void DIB_InitOSKeymap(_THIS)
{
289
int i;
290
291
#ifndef _WIN32_WCE
char current_layout[KL_NAMELENGTH];
292
293
294
295
296
GetKeyboardLayoutName(current_layout);
//printf("Initial Keyboard Layout Name: '%s'\n", current_layout);
hLayoutUS = LoadKeyboardLayout("00000409", KLF_NOTELLSHELL);
298
299
300
301
302
if (!hLayoutUS) {
//printf("Failed to load US keyboard layout. Using current.\n");
hLayoutUS = GetKeyboardLayout(0);
}
LoadKeyboardLayout(current_layout, KLF_ACTIVATE);
303
304
305
#else
#if _WIN32_WCE >=420
TCHAR current_layout[KL_NAMELENGTH];
306
307
308
309
310
311
312
313
314
315
316
317
318
GetKeyboardLayoutName(current_layout);
//printf("Initial Keyboard Layout Name: '%s'\n", current_layout);
hLayoutUS = LoadKeyboardLayout(L"00000409", 0);
if (!hLayoutUS) {
//printf("Failed to load US keyboard layout. Using current.\n");
hLayoutUS = GetKeyboardLayout(0);
}
LoadKeyboardLayout(current_layout, 0);
#endif // _WIN32_WCE >=420
#endif
319
/* Map the VK keysyms */
320
for ( i=0; i<SDL_arraysize(VK_keymap); ++i )
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
VK_keymap[i] = SDLK_UNKNOWN;
VK_keymap[VK_BACK] = SDLK_BACKSPACE;
VK_keymap[VK_TAB] = SDLK_TAB;
VK_keymap[VK_CLEAR] = SDLK_CLEAR;
VK_keymap[VK_RETURN] = SDLK_RETURN;
VK_keymap[VK_PAUSE] = SDLK_PAUSE;
VK_keymap[VK_ESCAPE] = SDLK_ESCAPE;
VK_keymap[VK_SPACE] = SDLK_SPACE;
VK_keymap[VK_APOSTROPHE] = SDLK_QUOTE;
VK_keymap[VK_COMMA] = SDLK_COMMA;
VK_keymap[VK_MINUS] = SDLK_MINUS;
VK_keymap[VK_PERIOD] = SDLK_PERIOD;
VK_keymap[VK_SLASH] = SDLK_SLASH;
VK_keymap[VK_0] = SDLK_0;
VK_keymap[VK_1] = SDLK_1;
VK_keymap[VK_2] = SDLK_2;
VK_keymap[VK_3] = SDLK_3;
VK_keymap[VK_4] = SDLK_4;
VK_keymap[VK_5] = SDLK_5;
VK_keymap[VK_6] = SDLK_6;
VK_keymap[VK_7] = SDLK_7;
VK_keymap[VK_8] = SDLK_8;
VK_keymap[VK_9] = SDLK_9;
VK_keymap[VK_SEMICOLON] = SDLK_SEMICOLON;
VK_keymap[VK_EQUALS] = SDLK_EQUALS;
VK_keymap[VK_LBRACKET] = SDLK_LEFTBRACKET;
VK_keymap[VK_BACKSLASH] = SDLK_BACKSLASH;
349
VK_keymap[VK_OEM_102] = SDLK_LESS;
350
351
VK_keymap[VK_RBRACKET] = SDLK_RIGHTBRACKET;
VK_keymap[VK_GRAVE] = SDLK_BACKQUOTE;
352
VK_keymap[VK_BACKTICK] = SDLK_BACKQUOTE;
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
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
439
440
441
VK_keymap[VK_A] = SDLK_a;
VK_keymap[VK_B] = SDLK_b;
VK_keymap[VK_C] = SDLK_c;
VK_keymap[VK_D] = SDLK_d;
VK_keymap[VK_E] = SDLK_e;
VK_keymap[VK_F] = SDLK_f;
VK_keymap[VK_G] = SDLK_g;
VK_keymap[VK_H] = SDLK_h;
VK_keymap[VK_I] = SDLK_i;
VK_keymap[VK_J] = SDLK_j;
VK_keymap[VK_K] = SDLK_k;
VK_keymap[VK_L] = SDLK_l;
VK_keymap[VK_M] = SDLK_m;
VK_keymap[VK_N] = SDLK_n;
VK_keymap[VK_O] = SDLK_o;
VK_keymap[VK_P] = SDLK_p;
VK_keymap[VK_Q] = SDLK_q;
VK_keymap[VK_R] = SDLK_r;
VK_keymap[VK_S] = SDLK_s;
VK_keymap[VK_T] = SDLK_t;
VK_keymap[VK_U] = SDLK_u;
VK_keymap[VK_V] = SDLK_v;
VK_keymap[VK_W] = SDLK_w;
VK_keymap[VK_X] = SDLK_x;
VK_keymap[VK_Y] = SDLK_y;
VK_keymap[VK_Z] = SDLK_z;
VK_keymap[VK_DELETE] = SDLK_DELETE;
VK_keymap[VK_NUMPAD0] = SDLK_KP0;
VK_keymap[VK_NUMPAD1] = SDLK_KP1;
VK_keymap[VK_NUMPAD2] = SDLK_KP2;
VK_keymap[VK_NUMPAD3] = SDLK_KP3;
VK_keymap[VK_NUMPAD4] = SDLK_KP4;
VK_keymap[VK_NUMPAD5] = SDLK_KP5;
VK_keymap[VK_NUMPAD6] = SDLK_KP6;
VK_keymap[VK_NUMPAD7] = SDLK_KP7;
VK_keymap[VK_NUMPAD8] = SDLK_KP8;
VK_keymap[VK_NUMPAD9] = SDLK_KP9;
VK_keymap[VK_DECIMAL] = SDLK_KP_PERIOD;
VK_keymap[VK_DIVIDE] = SDLK_KP_DIVIDE;
VK_keymap[VK_MULTIPLY] = SDLK_KP_MULTIPLY;
VK_keymap[VK_SUBTRACT] = SDLK_KP_MINUS;
VK_keymap[VK_ADD] = SDLK_KP_PLUS;
VK_keymap[VK_UP] = SDLK_UP;
VK_keymap[VK_DOWN] = SDLK_DOWN;
VK_keymap[VK_RIGHT] = SDLK_RIGHT;
VK_keymap[VK_LEFT] = SDLK_LEFT;
VK_keymap[VK_INSERT] = SDLK_INSERT;
VK_keymap[VK_HOME] = SDLK_HOME;
VK_keymap[VK_END] = SDLK_END;
VK_keymap[VK_PRIOR] = SDLK_PAGEUP;
VK_keymap[VK_NEXT] = SDLK_PAGEDOWN;
VK_keymap[VK_F1] = SDLK_F1;
VK_keymap[VK_F2] = SDLK_F2;
VK_keymap[VK_F3] = SDLK_F3;
VK_keymap[VK_F4] = SDLK_F4;
VK_keymap[VK_F5] = SDLK_F5;
VK_keymap[VK_F6] = SDLK_F6;
VK_keymap[VK_F7] = SDLK_F7;
VK_keymap[VK_F8] = SDLK_F8;
VK_keymap[VK_F9] = SDLK_F9;
VK_keymap[VK_F10] = SDLK_F10;
VK_keymap[VK_F11] = SDLK_F11;
VK_keymap[VK_F12] = SDLK_F12;
VK_keymap[VK_F13] = SDLK_F13;
VK_keymap[VK_F14] = SDLK_F14;
VK_keymap[VK_F15] = SDLK_F15;
VK_keymap[VK_NUMLOCK] = SDLK_NUMLOCK;
VK_keymap[VK_CAPITAL] = SDLK_CAPSLOCK;
VK_keymap[VK_SCROLL] = SDLK_SCROLLOCK;
VK_keymap[VK_RSHIFT] = SDLK_RSHIFT;
VK_keymap[VK_LSHIFT] = SDLK_LSHIFT;
VK_keymap[VK_RCONTROL] = SDLK_RCTRL;
VK_keymap[VK_LCONTROL] = SDLK_LCTRL;
VK_keymap[VK_RMENU] = SDLK_RALT;
VK_keymap[VK_LMENU] = SDLK_LALT;
VK_keymap[VK_RWIN] = SDLK_RSUPER;
VK_keymap[VK_LWIN] = SDLK_LSUPER;
VK_keymap[VK_HELP] = SDLK_HELP;
#ifdef VK_PRINT
VK_keymap[VK_PRINT] = SDLK_PRINT;
#endif
VK_keymap[VK_SNAPSHOT] = SDLK_PRINT;
VK_keymap[VK_CANCEL] = SDLK_BREAK;
VK_keymap[VK_APPS] = SDLK_MENU;
442
443
444
445
446
Arrows_keymap[3] = 0x25;
Arrows_keymap[2] = 0x26;
Arrows_keymap[1] = 0x27;
Arrows_keymap[0] = 0x28;
447
448
}
449
450
451
452
#define EXTKEYPAD(keypad) ((scancode & 0x100)?(mvke):(keypad))
static int SDL_MapVirtualKey(int scancode, int vkey)
{
453
#ifndef _WIN32_WCE
454
int mvke = MapVirtualKeyEx(scancode & 0xFF, 1, hLayoutUS);
455
456
457
#else
int mvke = MapVirtualKey(scancode & 0xFF, 1);
#endif
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
switch(vkey) {
/* These are always correct */
case VK_DIVIDE:
case VK_MULTIPLY:
case VK_SUBTRACT:
case VK_ADD:
case VK_LWIN:
case VK_RWIN:
case VK_APPS:
/* These are already handled */
case VK_LCONTROL:
case VK_RCONTROL:
case VK_LSHIFT:
case VK_RSHIFT:
case VK_LMENU:
case VK_RMENU:
case VK_SNAPSHOT:
case VK_PAUSE:
return vkey;
}
switch(mvke) {
/* Distinguish between keypad and extended keys */
case VK_INSERT: return EXTKEYPAD(VK_NUMPAD0);
case VK_DELETE: return EXTKEYPAD(VK_DECIMAL);
case VK_END: return EXTKEYPAD(VK_NUMPAD1);
case VK_DOWN: return EXTKEYPAD(VK_NUMPAD2);
case VK_NEXT: return EXTKEYPAD(VK_NUMPAD3);
case VK_LEFT: return EXTKEYPAD(VK_NUMPAD4);
case VK_CLEAR: return EXTKEYPAD(VK_NUMPAD5);
case VK_RIGHT: return EXTKEYPAD(VK_NUMPAD6);
case VK_HOME: return EXTKEYPAD(VK_NUMPAD7);
case VK_UP: return EXTKEYPAD(VK_NUMPAD8);
case VK_PRIOR: return EXTKEYPAD(VK_NUMPAD9);
}
return mvke?mvke:vkey;
}
496
static SDL_keysym *TranslateKey(WPARAM vkey, UINT scancode, SDL_keysym *keysym, int pressed)
497
498
499
500
501
{
/* Set the keysym information */
keysym->scancode = (unsigned char) scancode;
keysym->mod = KMOD_NONE;
keysym->unicode = 0;
502
503
504
505
506
507
508
509
510
if ((vkey == VK_RETURN) && (scancode & 0x100)) {
/* No VK_ code for the keypad enter key */
keysym->sym = SDLK_KP_ENTER;
}
else {
keysym->sym = VK_keymap[SDL_MapVirtualKey(scancode, vkey)];
}
511
if ( pressed && SDL_TranslateUNICODE ) {
512
513
#ifdef NO_GETKEYBOARDSTATE
/* Uh oh, better hope the vkey is close enough.. */
514
if((keysym->sym == vkey) || (vkey > 0x7f))
515
516
keysym->unicode = vkey;
#else
517
518
BYTE keystate[256];
Uint16 wchars[2];
519
520
GetKeyboardState(keystate);
521
if (SDL_ToUnicode((UINT)vkey, scancode, keystate, wchars, sizeof(wchars)/sizeof(wchars[0]), 0) == 1)
522
523
{
keysym->unicode = wchars[0];
524
525
526
}
#endif /* NO_GETKEYBOARDSTATE */
}
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
#if 0
{
HKL hLayoutCurrent = GetKeyboardLayout(0);
int sc = scancode & 0xFF;
printf("SYM:%d, VK:0x%02X, SC:0x%04X, US:(1:0x%02X, 3:0x%02X), "
"Current:(1:0x%02X, 3:0x%02X)\n",
keysym->sym, vkey, scancode,
MapVirtualKeyEx(sc, 1, hLayoutUS),
MapVirtualKeyEx(sc, 3, hLayoutUS),
MapVirtualKeyEx(sc, 1, hLayoutCurrent),
MapVirtualKeyEx(sc, 3, hLayoutCurrent)
);
}
#endif
543
544
545
546
547
return(keysym);
}
int DIB_CreateWindow(_THIS)
{
548
char *windowid = SDL_getenv("SDL_WINDOWID");
549
550
SDL_RegisterApp(NULL, 0, 0);
551
552
553
SDL_windowid = (windowid != NULL);
if ( SDL_windowid ) {
554
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
555
/* wince 2.1 does not have strtol */
556
557
wchar_t *windowid_t = SDL_malloc((SDL_strlen(windowid) + 1) * sizeof(wchar_t));
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, windowid, -1, windowid_t, SDL_strlen(windowid) + 1);
558
SDL_Window = (HWND)wcstol(windowid_t, NULL, 0);
559
SDL_free(windowid_t);
560
#else
561
SDL_Window = (HWND)SDL_strtoull(windowid, NULL, 0);
562
#endif
563
564
565
566
567
568
569
570
if ( SDL_Window == NULL ) {
SDL_SetError("Couldn't get user specified window");
return(-1);
}
/* DJM: we want all event's for the user specified
window to be handled by SDL.
*/
571
572
userWindowProc = (WNDPROCTYPE)GetWindowLongPtr(SDL_Window, GWLP_WNDPROC);
SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)WinMessage);
573
574
575
} else {
SDL_Window = CreateWindow(SDL_Appname, SDL_Appname,
(WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX),
576
CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, NULL, NULL, SDL_Instance, NULL);
577
578
579
580
581
582
if ( SDL_Window == NULL ) {
SDL_SetError("Couldn't create window");
return(-1);
}
ShowWindow(SDL_Window, SW_HIDE);
}
583
584
585
586
587
588
589
/* JC 14 Mar 2006
Flush the message loop or this can cause big problems later
Especially if the user decides to use dialog boxes or assert()!
*/
WIN_FlushMessageQueue();
590
591
592
593
594
return(0);
}
void DIB_DestroyWindow(_THIS)
{
595
if ( SDL_windowid ) {
596
SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)userWindowProc);
597
} else {
598
599
DestroyWindow(SDL_Window);
}
600
SDL_UnregisterApp();
601
602
603
604
605
606
/* JC 14 Mar 2006
Flush the message loop or this can cause big problems later
Especially if the user decides to use dialog boxes or assert()!
*/
WIN_FlushMessageQueue();
607
}