This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_win32events.c
603 lines (536 loc) · 17.6 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
*/
22
23
24
25
26
27
#if (_WIN32_WINNT < 0x0501)
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
28
29
30
31
32
33
34
35
36
#include "SDL_config.h"
#include "SDL_win32video.h"
#include "SDL_syswm.h"
#include "SDL_vkeys.h"
#include "../../events/SDL_events_c.h"
/*#define WMMSG_DEBUG*/
#ifdef WMMSG_DEBUG
37
#include <stdio.h>
38
39
40
41
#include "wmmsg.h"
#endif
/* Masks for processing the windows KEYDOWN and KEYUP messages */
42
43
#define REPEATED_KEYMASK (1<<30)
#define EXTENDED_KEYMASK (1<<24)
44
45
#define VK_ENTER 10 /* Keypad Enter ... no VKEY defined? */
46
47
48
49
50
51
52
53
54
55
56
/* Make sure XBUTTON stuff is defined that isn't in older Platform SDKs... */
#ifndef WM_XBUTTONDOWN
#define WM_XBUTTONDOWN 0x020B
#endif
#ifndef WM_XBUTTONUP
#define WM_XBUTTONUP 0x020C
#endif
#ifndef GET_XBUTTON_WPARAM
#define GET_XBUTTON_WPARAM(w) (HIWORD(w))
#endif
57
58
59
#ifndef WM_INPUT
#define WM_INPUT 0x00ff
#endif
60
61
62
63
static WPARAM
RemapVKEY(WPARAM wParam, LPARAM lParam)
{
64
int i;
65
BYTE scancode = (BYTE) ((lParam >> 16) & 0xFF);
66
67
68
69
70
/* Windows remaps alphabetic keys based on current layout.
We try to provide USB scancodes, so undo this mapping.
*/
if (wParam >= 'A' && wParam <= 'Z') {
71
72
73
if (scancode != alpha_scancodes[wParam - 'A']) {
for (i = 0; i < SDL_arraysize(alpha_scancodes); ++i) {
if (scancode == alpha_scancodes[i]) {
74
75
76
77
78
79
wParam = 'A' + i;
break;
}
}
}
}
80
81
82
83
84
85
86
87
88
89
90
/* Keypad keys are a little trickier, we always scan for them.
Keypad arrow keys have the same scancode as normal arrow keys,
except they don't have the extended bit (0x1000000) set.
*/
if (!(lParam & 0x1000000)) {
for (i = 0; i < SDL_arraysize(keypad_scancodes); ++i) {
if (scancode == keypad_scancodes[i]) {
wParam = VK_NUMPAD0 + i;
break;
}
91
92
93
}
}
94
95
96
return wParam;
}
97
98
99
100
LRESULT CALLBACK
WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
SDL_WindowData *data;
101
LRESULT returnCode = -1;
102
103
/* Send a SDL_SYSWMEVENT if the application wants them */
104
if (SDL_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) {
105
106
107
108
109
110
111
112
113
114
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.hwnd = hwnd;
wmmsg.msg = msg;
wmmsg.wParam = wParam;
wmmsg.lParam = lParam;
SDL_SendSysWMEvent(&wmmsg);
}
115
116
117
118
119
120
/* Get the window data for the window */
data = (SDL_WindowData *) GetProp(hwnd, TEXT("SDL_WindowData"));
if (!data) {
return CallWindowProc(DefWindowProc, hwnd, msg, wParam, lParam);
}
#ifdef WMMSG_DEBUG
121
122
123
124
125
126
127
128
129
130
{
FILE *log = fopen("wmmsg.txt", "a");
fprintf(log, "Received windows message: %p ", hwnd);
if (msg > MAX_WMMSG) {
fprintf(log, "%d", msg);
} else {
fprintf(log, "%s", wmtab[msg]);
}
fprintf(log, " -- 0x%X, 0x%X\n", wParam, lParam);
fclose(log);
131
}
132
133
#endif
134
135
if (IME_HandleMessage(hwnd, msg, wParam, &lParam, data->videodata))
return 0;
136
137
138
139
140
141
switch (msg) {
case WM_SHOWWINDOW:
{
if (wParam) {
142
SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_SHOWN, 0, 0);
143
} else {
144
SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
145
146
147
148
149
150
151
152
153
154
}
}
break;
case WM_ACTIVATE:
{
BOOL minimized;
minimized = HIWORD(wParam);
if (!minimized && (LOWORD(wParam) != WA_INACTIVE)) {
155
156
SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_SHOWN, 0, 0);
SDL_SendWindowEvent(data->window,
157
SDL_WINDOWEVENT_RESTORED, 0, 0);
158
#ifndef _WIN32_WCE /* WinCE misses IsZoomed() */
159
if (IsZoomed(hwnd)) {
160
SDL_SendWindowEvent(data->window,
161
162
SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
}
163
#endif
164
165
if (SDL_GetKeyboardFocus() != data->window) {
SDL_SetKeyboardFocus(data->window);
166
167
168
}
/* FIXME: Update keyboard state */
} else {
169
170
if (SDL_GetKeyboardFocus() == data->window) {
SDL_SetKeyboardFocus(NULL);
171
172
}
if (minimized) {
173
SDL_SendWindowEvent(data->window,
174
175
176
177
SDL_WINDOWEVENT_MINIMIZED, 0, 0);
}
}
}
178
179
returnCode = 0;
break;
180
181
case WM_MOUSEMOVE:
182
SDL_SendMouseMotion(data->window, 0, LOWORD(lParam), HIWORD(lParam));
183
184
break;
185
case WM_LBUTTONDOWN:
186
SDL_SendMouseButton(data->window, SDL_PRESSED, SDL_BUTTON_LEFT);
187
188
break;
189
case WM_LBUTTONUP:
190
SDL_SendMouseButton(data->window, SDL_RELEASED, SDL_BUTTON_LEFT);
191
break;
192
193
case WM_MOUSELEAVE:
194
195
if (SDL_GetMouseFocus() == data->window) {
SDL_SetMouseFocus(NULL);
196
}
197
198
returnCode = 0;
break;
199
200
201
202
203
204
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
{
/* Ignore repeated keys */
if (lParam & REPEATED_KEYMASK) {
205
206
returnCode = 0;
break;
207
208
}
209
wParam = RemapVKEY(wParam, lParam);
210
211
212
213
214
215
216
217
218
219
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 */
{
220
221
Uint8 *state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_LSHIFT] == SDL_RELEASED
222
223
&& (GetKeyState(VK_LSHIFT) & 0x8000)) {
wParam = VK_LSHIFT;
224
} else if (state[SDL_SCANCODE_RSHIFT] == SDL_RELEASED
225
226
227
228
&& (GetKeyState(VK_RSHIFT) & 0x8000)) {
wParam = VK_RSHIFT;
} else {
/* Probably a key repeat */
229
wParam = 256;
230
231
232
233
234
235
236
237
238
}
}
break;
case VK_MENU:
if (lParam & EXTENDED_KEYMASK)
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
239
240
241
242
case VK_RETURN:
if (lParam & EXTENDED_KEYMASK)
wParam = VK_ENTER;
break;
243
}
244
if (wParam < 256) {
245
SDL_SendKeyboardKey(SDL_PRESSED,
246
247
data->videodata->key_layout[wParam]);
}
248
}
249
250
returnCode = 0;
break;
251
252
253
254
case WM_SYSKEYUP:
case WM_KEYUP:
{
255
wParam = RemapVKEY(wParam, lParam);
256
257
258
259
260
261
262
263
264
265
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 */
{
266
267
Uint8 *state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_LSHIFT] == SDL_PRESSED
268
269
&& !(GetKeyState(VK_LSHIFT) & 0x8000)) {
wParam = VK_LSHIFT;
270
} else if (state[SDL_SCANCODE_RSHIFT] == SDL_PRESSED
271
272
273
274
&& !(GetKeyState(VK_RSHIFT) & 0x8000)) {
wParam = VK_RSHIFT;
} else {
/* Probably a key repeat */
275
wParam = 256;
276
277
278
279
280
281
282
283
284
}
}
break;
case VK_MENU:
if (lParam & EXTENDED_KEYMASK)
wParam = VK_RMENU;
else
wParam = VK_LMENU;
break;
285
286
287
288
case VK_RETURN:
if (lParam & EXTENDED_KEYMASK)
wParam = VK_ENTER;
break;
289
}
290
291
292
/* Windows only reports keyup for print screen */
if (wParam == VK_SNAPSHOT
293
294
&& SDL_GetKeyboardState(NULL)[SDL_SCANCODE_PRINTSCREEN] ==
SDL_RELEASED) {
295
SDL_SendKeyboardKey(SDL_PRESSED,
296
297
298
data->videodata->key_layout[wParam]);
}
if (wParam < 256) {
299
SDL_SendKeyboardKey(SDL_RELEASED,
300
data->videodata->key_layout[wParam]);
301
302
}
}
303
304
returnCode = 0;
break;
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
case WM_CHAR:
{
char text[4];
/* Convert to UTF-8 and send it on... */
if (wParam <= 0x7F) {
text[0] = (char) wParam;
text[1] = '\0';
} else if (wParam <= 0x7FF) {
text[0] = 0xC0 | (char) ((wParam >> 6) & 0x1F);
text[1] = 0x80 | (char) (wParam & 0x3F);
text[2] = '\0';
} else {
text[0] = 0xE0 | (char) ((wParam >> 12) & 0x0F);
text[1] = 0x80 | (char) ((wParam >> 6) & 0x3F);
text[2] = 0x80 | (char) (wParam & 0x3F);
text[3] = '\0';
}
324
SDL_SendKeyboardText(text);
325
}
326
327
returnCode = 0;
break;
328
329
330
case WM_INPUTLANGCHANGE:
{
331
WIN_UpdateKeymap();
332
}
333
334
returnCode = 1;
break;
335
336
337
338
339
340
341
342
case WM_GETMINMAXINFO:
{
MINMAXINFO *info;
RECT size;
int x, y;
int w, h;
int style;
343
BOOL menu;
344
345
/* If we allow resizing, let the resize happen naturally */
346
if (SDL_GetWindowFlags(data->window) & SDL_WINDOW_RESIZABLE) {
347
348
returnCode = 0;
break;
349
350
351
352
353
354
355
356
}
/* Get the current position of our window */
GetWindowRect(hwnd, &size);
x = size.left;
y = size.top;
/* Calculate current size of our window */
357
SDL_GetWindowSize(data->window, &w, &h);
358
359
360
361
362
size.top = 0;
size.left = 0;
size.bottom = h;
size.right = w;
363
364
365
366
367
style = GetWindowLong(hwnd, GWL_STYLE);
#ifdef _WIN32_WCE
menu = FALSE;
#else
368
369
370
371
372
/* DJM - according to the docs for GetMenu(), the
return value is undefined if hwnd is a child window.
Aparently it's too difficult for MS to check
inside their function, so I have to do it here.
*/
373
374
375
menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);
#endif
AdjustWindowRectEx(&size, style, menu, 0);
376
377
378
379
380
381
382
383
384
385
386
387
388
389
w = size.right - size.left;
h = size.bottom - size.top;
/* Fix our size to the current size */
info = (MINMAXINFO *) lParam;
info->ptMaxSize.x = w;
info->ptMaxSize.y = h;
info->ptMaxPosition.x = x;
info->ptMaxPosition.y = y;
info->ptMinTrackSize.x = w;
info->ptMinTrackSize.y = h;
info->ptMaxTrackSize.x = w;
info->ptMaxTrackSize.y = h;
}
390
391
returnCode = 0;
break;
392
393
394
395
396
397
398
399
case WM_WINDOWPOSCHANGED:
{
RECT rect;
int x, y;
int w, h;
Uint32 window_flags;
400
401
402
403
if (!GetClientRect(hwnd, &rect) ||
(rect.right == rect.left && rect.bottom == rect.top)) {
break;
}
404
405
406
ClientToScreen(hwnd, (LPPOINT) & rect);
ClientToScreen(hwnd, (LPPOINT) & rect + 1);
407
window_flags = SDL_GetWindowFlags(data->window);
408
409
410
411
412
413
414
if ((window_flags & SDL_WINDOW_INPUT_GRABBED) &&
(window_flags & SDL_WINDOW_INPUT_FOCUS)) {
ClipCursor(&rect);
}
x = rect.left;
y = rect.top;
415
SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MOVED, x, y);
416
417
418
w = rect.right - rect.left;
h = rect.bottom - rect.top;
419
SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_RESIZED, w,
420
421
422
423
424
425
h);
}
break;
case WM_SETCURSOR:
{
426
427
428
429
430
431
432
433
434
435
Uint16 hittest;
hittest = LOWORD(lParam);
if (hittest == HTCLIENT) {
/* FIXME: Implement the cursor API */
static HCURSOR cursor;
if (!cursor) {
cursor = LoadCursor(NULL, IDC_ARROW);
}
SetCursor(cursor);
436
returnCode = TRUE;
437
}
438
439
440
441
442
443
444
}
break;
/* We are about to get palette focus! */
case WM_QUERYNEWPALETTE:
{
/*
445
446
WIN_RealizePalette(current_video);
returnCode = TRUE;
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
*/
}
break;
/* Another application changed the palette */
case WM_PALETTECHANGED:
{
/*
WIN_PaletteChanged(current_video, (HWND) wParam);
*/
}
break;
/* We were occluded, refresh our display */
case WM_PAINT:
{
RECT rect;
if (GetUpdateRect(hwnd, &rect, FALSE)) {
ValidateRect(hwnd, &rect);
466
SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_EXPOSED,
467
468
469
0, 0);
}
}
470
471
returnCode = 0;
break;
472
473
474
475
476
477
478
479
480
481
482
483
/* We'll do our own drawing, prevent flicker */
case WM_ERASEBKGND:
{
}
return (1);
case WM_SYSCOMMAND:
{
/* Don't start the screensaver or blank the monitor in fullscreen apps */
if ((wParam & 0xFFF0) == SC_SCREENSAVE ||
(wParam & 0xFFF0) == SC_MONITORPOWER) {
484
if (SDL_GetVideoDevice()->suspend_screensaver) {
485
486
487
488
489
490
491
492
return (0);
}
}
}
break;
case WM_CLOSE:
{
493
SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_CLOSE, 0, 0);
494
}
495
496
497
498
499
500
501
502
503
504
505
returnCode = 0;
break;
}
/* If there's a window proc, assume it's going to handle messages */
if (data->wndproc) {
return CallWindowProc(data->wndproc, hwnd, msg, wParam, lParam);
} else if (returnCode >= 0) {
return returnCode;
} else {
return CallWindowProc(DefWindowProc, hwnd, msg, wParam, lParam);
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
}
}
void
WIN_PumpEvents(_THIS)
{
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
static int app_registered = 0;
LPTSTR SDL_Appname = NULL;
Uint32 SDL_Appstyle = 0;
HINSTANCE SDL_Instance = NULL;
/* Register the class for this application */
int
SDL_RegisterApp(char *name, Uint32 style, void *hInst)
{
WNDCLASS class;
/* Only do this once... */
if (app_registered) {
++app_registered;
return (0);
}
if (!name && !SDL_Appname) {
name = "SDL_app";
SDL_Appstyle = (CS_BYTEALIGNCLIENT | CS_OWNDC);
SDL_Instance = hInst ? hInst : GetModuleHandle(NULL);
}
if (name) {
SDL_Appname = WIN_UTF8ToString(name);
SDL_Appstyle = style;
SDL_Instance = hInst ? hInst : GetModuleHandle(NULL);
}
/* Register the application class */
class.hCursor = NULL;
549
550
551
class.hIcon =
LoadImage(SDL_Instance, SDL_Appname, IMAGE_ICON, 0, 0,
LR_DEFAULTCOLOR);
552
553
554
555
556
class.lpszMenuName = NULL;
class.lpszClassName = SDL_Appname;
class.hbrBackground = NULL;
class.hInstance = SDL_Instance;
class.style = SDL_Appstyle;
557
class.lpfnWndProc = WIN_WindowProc;
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
class.cbWndExtra = 0;
class.cbClsExtra = 0;
if (!RegisterClass(&class)) {
SDL_SetError("Couldn't register application class");
return (-1);
}
app_registered = 1;
return (0);
}
/* Unregisters the windowclass registered in SDL_RegisterApp above. */
void
SDL_UnregisterApp()
{
WNDCLASS class;
/* SDL_RegisterApp might not have been called before */
if (!app_registered) {
return;
}
--app_registered;
if (app_registered == 0) {
/* Check for any registered window classes. */
if (GetClassInfo(SDL_Instance, SDL_Appname, &class)) {
UnregisterClass(SDL_Appname, SDL_Instance);
}
SDL_free(SDL_Appname);
SDL_Appname = NULL;
}
}
/* Sets an error message based on GetLastError() */
void
WIN_SetError(const char *prefix)
{
TCHAR buffer[1024];
char *message;
596
597
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
buffer, SDL_arraysize(buffer), NULL);
598
message = WIN_StringToUTF8(buffer);
599
SDL_SetError("%s%s%s", prefix ? prefix : "", prefix ? ": " : "", message);
600
601
602
603
SDL_free(message);
}
/* vi: set ts=4 sw=4 expandtab: */