summaryrefslogtreecommitdiff
path: root/apps/plugins/sdl/src/video/windib
diff options
context:
space:
mode:
Diffstat (limited to 'apps/plugins/sdl/src/video/windib')
-rw-r--r--apps/plugins/sdl/src/video/windib/SDL_dibevents.c704
-rw-r--r--apps/plugins/sdl/src/video/windib/SDL_dibevents_c.h35
-rw-r--r--apps/plugins/sdl/src/video/windib/SDL_dibvideo.c1323
-rw-r--r--apps/plugins/sdl/src/video/windib/SDL_dibvideo.h59
-rw-r--r--apps/plugins/sdl/src/video/windib/SDL_gapidibvideo.h56
-rw-r--r--apps/plugins/sdl/src/video/windib/SDL_vkeys.h75
6 files changed, 0 insertions, 2252 deletions
diff --git a/apps/plugins/sdl/src/video/windib/SDL_dibevents.c b/apps/plugins/sdl/src/video/windib/SDL_dibevents.c
deleted file mode 100644
index 6cee54ad2c..0000000000
--- a/apps/plugins/sdl/src/video/windib/SDL_dibevents.c
+++ /dev/null
@@ -1,704 +0,0 @@
1/*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2012 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#define WIN32_LEAN_AND_MEAN
25#include <windows.h>
26
27#include "SDL_main.h"
28#include "SDL_events.h"
29#include "SDL_syswm.h"
30#include "../../events/SDL_sysevents.h"
31#include "../../events/SDL_events_c.h"
32#include "../wincommon/SDL_lowvideo.h"
33#include "SDL_gapidibvideo.h"
34#include "SDL_vkeys.h"
35
36#ifdef SDL_VIDEO_DRIVER_GAPI
37#include "../gapi/SDL_gapivideo.h"
38#endif
39
40#ifdef SDL_VIDEO_DRIVER_WINDIB
41#include "SDL_dibvideo.h"
42#endif
43
44#ifndef WM_APP
45#define WM_APP 0x8000
46#endif
47
48#ifdef _WIN32_WCE
49#define NO_GETKEYBOARDSTATE
50#endif
51
52/* The translation table from a Microsoft VK keysym to a SDL keysym */
53static SDLKey VK_keymap[SDLK_LAST];
54static SDL_keysym *TranslateKey(WPARAM vkey, UINT scancode, SDL_keysym *keysym, int pressed);
55static SDLKey Arrows_keymap[4];
56
57/* Masks for processing the windows KEYDOWN and KEYUP messages */
58#define REPEATED_KEYMASK (1<<30)
59#define EXTENDED_KEYMASK (1<<24)
60
61/* DJM: If the user setup the window for us, we want to save his window proc,
62 and give him a chance to handle some messages. */
63#ifdef STRICT
64#define WNDPROCTYPE WNDPROC
65#else
66#define WNDPROCTYPE FARPROC
67#endif
68static WNDPROCTYPE userWindowProc = NULL;
69
70
71#ifdef SDL_VIDEO_DRIVER_GAPI
72
73WPARAM rotateKey(WPARAM key,int direction)
74{
75 if(direction ==0 ) return key;
76
77 switch (key) {
78 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 return key;
89}
90
91static void GapiTransform(GapiInfo *gapiInfo, LONG *x, LONG *y)
92{
93 if(gapiInfo->hiresFix)
94 {
95 *x *= 2;
96 *y *= 2;
97 }
98
99 // 0 3 0
100 if((!gapiInfo->userOrientation && gapiInfo->systemOrientation && !gapiInfo->gapiOrientation) ||
101 // 3 0 3
102 (gapiInfo->userOrientation && !gapiInfo->systemOrientation && gapiInfo->gapiOrientation) ||
103 // 3 0 0
104 (gapiInfo->userOrientation && !gapiInfo->systemOrientation && !gapiInfo->gapiOrientation))
105 {
106 Sint16 temp = *x;
107 *x = SDL_VideoSurface->w - *y;
108 *y = temp;
109 }
110 else
111 // 0 0 0
112 if((!gapiInfo->userOrientation && !gapiInfo->systemOrientation && !gapiInfo->gapiOrientation) ||
113 // 0 0 3
114 (!gapiInfo->userOrientation && !gapiInfo->systemOrientation && gapiInfo->gapiOrientation))
115 {
116 // without changes
117 // *x = *x;
118 // *y = *y;
119 }
120 // default
121 else
122 {
123 // without changes
124 // *x = *x;
125 // *y = *y;
126 }
127}
128#endif
129
130
131/* The main Win32 event handler */
132LRESULT DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
133{
134 extern int posted;
135
136 switch (msg) {
137 case WM_SYSKEYDOWN:
138 case WM_KEYDOWN: {
139 SDL_keysym keysym;
140
141#ifdef SDL_VIDEO_DRIVER_GAPI
142 if(this->hidden->gapiInfo)
143 {
144 // Drop GAPI artefacts
145 if (wParam == 0x84 || wParam == 0x5B)
146 return 0;
147
148 wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform);
149 }
150#endif
151 /* Ignore repeated keys */
152 if ( lParam&REPEATED_KEYMASK ) {
153 return(0);
154 }
155 switch (wParam) {
156 case VK_CONTROL:
157 if ( lParam&EXTENDED_KEYMASK )
158 wParam = VK_RCONTROL;
159 else
160 wParam = VK_LCONTROL;
161 break;
162 case VK_SHIFT:
163 /* EXTENDED trick doesn't work here */
164 {
165 Uint8 *state = SDL_GetKeyState(NULL);
166 if (state[SDLK_LSHIFT] == SDL_RELEASED && (GetKeyState(VK_LSHIFT) & 0x8000)) {
167 wParam = VK_LSHIFT;
168 } else if (state[SDLK_RSHIFT] == SDL_RELEASED && (GetKeyState(VK_RSHIFT) & 0x8000)) {
169 wParam = VK_RSHIFT;
170 } else {
171 /* Win9x */
172 int sc = HIWORD(lParam) & 0xFF;
173
174 if (sc == 0x2A)
175 wParam = VK_LSHIFT;
176 else
177 if (sc == 0x36)
178 wParam = VK_RSHIFT;
179 else
180 wParam = VK_LSHIFT;
181 }
182 }
183 break;
184 case VK_MENU:
185 if ( lParam&EXTENDED_KEYMASK )
186 wParam = VK_RMENU;
187 else
188 wParam = VK_LMENU;
189 break;
190 }
191#ifdef NO_GETKEYBOARDSTATE
192 /* this is the workaround for the missing ToAscii() and ToUnicode() in CE (not necessary at KEYUP!) */
193 if ( SDL_TranslateUNICODE ) {
194 MSG m;
195
196 m.hwnd = hwnd;
197 m.message = msg;
198 m.wParam = wParam;
199 m.lParam = lParam;
200 m.time = 0;
201 if ( TranslateMessage(&m) && PeekMessage(&m, hwnd, 0, WM_USER, PM_NOREMOVE) && (m.message == WM_CHAR) ) {
202 GetMessage(&m, hwnd, 0, WM_USER);
203 wParam = m.wParam;
204 }
205 }
206#endif /* NO_GETKEYBOARDSTATE */
207 posted = SDL_PrivateKeyboard(SDL_PRESSED,
208 TranslateKey(wParam,HIWORD(lParam),&keysym,1));
209 }
210 return(0);
211
212 case WM_SYSKEYUP:
213 case WM_KEYUP: {
214 SDL_keysym keysym;
215
216#ifdef SDL_VIDEO_DRIVER_GAPI
217 if(this->hidden->gapiInfo)
218 {
219 // Drop GAPI artifacts
220 if (wParam == 0x84 || wParam == 0x5B)
221 return 0;
222
223 wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform);
224 }
225#endif
226
227 switch (wParam) {
228 case VK_CONTROL:
229 if ( lParam&EXTENDED_KEYMASK )
230 wParam = VK_RCONTROL;
231 else
232 wParam = VK_LCONTROL;
233 break;
234 case VK_SHIFT:
235 /* EXTENDED trick doesn't work here */
236 {
237 Uint8 *state = SDL_GetKeyState(NULL);
238 if (state[SDLK_LSHIFT] == SDL_PRESSED && !(GetKeyState(VK_LSHIFT) & 0x8000)) {
239 wParam = VK_LSHIFT;
240 } else if (state[SDLK_RSHIFT] == SDL_PRESSED && !(GetKeyState(VK_RSHIFT) & 0x8000)) {
241 wParam = VK_RSHIFT;
242 } else {
243 /* Win9x */
244 int sc = HIWORD(lParam) & 0xFF;
245
246 if (sc == 0x2A)
247 wParam = VK_LSHIFT;
248 else
249 if (sc == 0x36)
250 wParam = VK_RSHIFT;
251 else
252 wParam = VK_LSHIFT;
253 }
254 }
255 break;
256 case VK_MENU:
257 if ( lParam&EXTENDED_KEYMASK )
258 wParam = VK_RMENU;
259 else
260 wParam = VK_LMENU;
261 break;
262 }
263 /* Windows only reports keyup for print screen */
264 if ( wParam == VK_SNAPSHOT && SDL_GetKeyState(NULL)[SDLK_PRINT] == SDL_RELEASED ) {
265 posted = SDL_PrivateKeyboard(SDL_PRESSED,
266 TranslateKey(wParam,HIWORD(lParam),&keysym,1));
267 }
268 posted = SDL_PrivateKeyboard(SDL_RELEASED,
269 TranslateKey(wParam,HIWORD(lParam),&keysym,0));
270 }
271 return(0);
272#if defined(SC_SCREENSAVE) && defined(SC_MONITORPOWER)
273 case WM_SYSCOMMAND: {
274 const DWORD val = (DWORD) (wParam & 0xFFF0);
275 if ((val == SC_SCREENSAVE) || (val == SC_MONITORPOWER)) {
276 if (this->hidden->dibInfo && !allow_screensaver) {
277 /* Note that this doesn't stop anything on Vista
278 if the screensaver has a password. */
279 return(0);
280 }
281 }
282 }
283 /* Fall through to default processing */
284#endif /* SC_SCREENSAVE && SC_MONITORPOWER */
285
286 default: {
287 /* Only post the event if we're watching for it */
288 if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) {
289 SDL_SysWMmsg wmmsg;
290
291 SDL_VERSION(&wmmsg.version);
292 wmmsg.hwnd = hwnd;
293 wmmsg.msg = msg;
294 wmmsg.wParam = wParam;
295 wmmsg.lParam = lParam;
296 posted = SDL_PrivateSysWMEvent(&wmmsg);
297
298 /* DJM: If the user isn't watching for private
299 messages in her SDL event loop, then pass it
300 along to any win32 specific window proc.
301 */
302 } else if (userWindowProc) {
303 return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam);
304 }
305 }
306 break;
307 }
308 return(DefWindowProc(hwnd, msg, wParam, lParam));
309}
310
311#ifdef _WIN32_WCE
312static BOOL GetLastStylusPos(POINT* ptLast)
313{
314 BOOL bResult = FALSE;
315 UINT nRet;
316 GetMouseMovePoints(ptLast, 1, &nRet);
317 if ( nRet == 1 ) {
318 ptLast->x /= 4;
319 ptLast->y /= 4;
320 bResult = TRUE;
321 }
322 return bResult;
323}
324#endif
325
326static void DIB_GenerateMouseMotionEvent(_THIS)
327{
328 extern int mouse_relative;
329 extern int posted;
330
331 POINT mouse;
332#ifdef _WIN32_WCE
333 if ( !GetCursorPos(&mouse) && !GetLastStylusPos(&mouse) ) return;
334#else
335 if ( !GetCursorPos(&mouse) ) return;
336#endif
337
338 if ( mouse_relative ) {
339 POINT center;
340 center.x = (SDL_VideoSurface->w/2);
341 center.y = (SDL_VideoSurface->h/2);
342 ClientToScreen(SDL_Window, &center);
343
344 mouse.x -= center.x;
345 mouse.y -= center.y;
346 if ( mouse.x || mouse.y ) {
347 SetCursorPos(center.x, center.y);
348 posted = SDL_PrivateMouseMotion(0, 1, (Sint16)mouse.x, (Sint16)mouse.y);
349 }
350 } else {
351 ScreenToClient(SDL_Window, &mouse);
352#ifdef SDL_VIDEO_DRIVER_GAPI
353 if (SDL_VideoSurface && this->hidden->gapiInfo)
354 GapiTransform(this->hidden->gapiInfo, &mouse.x, &mouse.y);
355#endif
356 posted = SDL_PrivateMouseMotion(0, 0, (Sint16)mouse.x, (Sint16)mouse.y);
357 }
358}
359
360void DIB_PumpEvents(_THIS)
361{
362 MSG msg;
363
364 while ( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) ) {
365 if ( GetMessage(&msg, NULL, 0, 0) > 0 ) {
366 DispatchMessage(&msg);
367 }
368 }
369
370 if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {
371 DIB_GenerateMouseMotionEvent( this );
372 }
373}
374
375static HKL hLayoutUS = NULL;
376
377void DIB_InitOSKeymap(_THIS)
378{
379 int i;
380#ifndef _WIN32_WCE
381 char current_layout[KL_NAMELENGTH];
382
383 GetKeyboardLayoutName(current_layout);
384 //printf("Initial Keyboard Layout Name: '%s'\n", current_layout);
385
386 hLayoutUS = LoadKeyboardLayout("00000409", KLF_NOTELLSHELL);
387
388 if (!hLayoutUS) {
389 //printf("Failed to load US keyboard layout. Using current.\n");
390 hLayoutUS = GetKeyboardLayout(0);
391 }
392 LoadKeyboardLayout(current_layout, KLF_ACTIVATE);
393#else
394#if _WIN32_WCE >=420
395 TCHAR current_layout[KL_NAMELENGTH];
396
397 GetKeyboardLayoutName(current_layout);
398 //printf("Initial Keyboard Layout Name: '%s'\n", current_layout);
399
400 hLayoutUS = LoadKeyboardLayout(L"00000409", 0);
401
402 if (!hLayoutUS) {
403 //printf("Failed to load US keyboard layout. Using current.\n");
404 hLayoutUS = GetKeyboardLayout(0);
405 }
406 LoadKeyboardLayout(current_layout, 0);
407#endif // _WIN32_WCE >=420
408#endif
409 /* Map the VK keysyms */
410 for ( i=0; i<SDL_arraysize(VK_keymap); ++i )
411 VK_keymap[i] = SDLK_UNKNOWN;
412
413 VK_keymap[VK_BACK] = SDLK_BACKSPACE;
414 VK_keymap[VK_TAB] = SDLK_TAB;
415 VK_keymap[VK_CLEAR] = SDLK_CLEAR;
416 VK_keymap[VK_RETURN] = SDLK_RETURN;
417 VK_keymap[VK_PAUSE] = SDLK_PAUSE;
418 VK_keymap[VK_ESCAPE] = SDLK_ESCAPE;
419 VK_keymap[VK_SPACE] = SDLK_SPACE;
420 VK_keymap[VK_APOSTROPHE] = SDLK_QUOTE;
421 VK_keymap[VK_COMMA] = SDLK_COMMA;
422 VK_keymap[VK_MINUS] = SDLK_MINUS;
423 VK_keymap[VK_PERIOD] = SDLK_PERIOD;
424 VK_keymap[VK_SLASH] = SDLK_SLASH;
425 VK_keymap[VK_0] = SDLK_0;
426 VK_keymap[VK_1] = SDLK_1;
427 VK_keymap[VK_2] = SDLK_2;
428 VK_keymap[VK_3] = SDLK_3;
429 VK_keymap[VK_4] = SDLK_4;
430 VK_keymap[VK_5] = SDLK_5;
431 VK_keymap[VK_6] = SDLK_6;
432 VK_keymap[VK_7] = SDLK_7;
433 VK_keymap[VK_8] = SDLK_8;
434 VK_keymap[VK_9] = SDLK_9;
435 VK_keymap[VK_SEMICOLON] = SDLK_SEMICOLON;
436 VK_keymap[VK_EQUALS] = SDLK_EQUALS;
437 VK_keymap[VK_LBRACKET] = SDLK_LEFTBRACKET;
438 VK_keymap[VK_BACKSLASH] = SDLK_BACKSLASH;
439 VK_keymap[VK_OEM_102] = SDLK_LESS;
440 VK_keymap[VK_RBRACKET] = SDLK_RIGHTBRACKET;
441 VK_keymap[VK_GRAVE] = SDLK_BACKQUOTE;
442 VK_keymap[VK_BACKTICK] = SDLK_BACKQUOTE;
443 VK_keymap[VK_A] = SDLK_a;
444 VK_keymap[VK_B] = SDLK_b;
445 VK_keymap[VK_C] = SDLK_c;
446 VK_keymap[VK_D] = SDLK_d;
447 VK_keymap[VK_E] = SDLK_e;
448 VK_keymap[VK_F] = SDLK_f;
449 VK_keymap[VK_G] = SDLK_g;
450 VK_keymap[VK_H] = SDLK_h;
451 VK_keymap[VK_I] = SDLK_i;
452 VK_keymap[VK_J] = SDLK_j;
453 VK_keymap[VK_K] = SDLK_k;
454 VK_keymap[VK_L] = SDLK_l;
455 VK_keymap[VK_M] = SDLK_m;
456 VK_keymap[VK_N] = SDLK_n;
457 VK_keymap[VK_O] = SDLK_o;
458 VK_keymap[VK_P] = SDLK_p;
459 VK_keymap[VK_Q] = SDLK_q;
460 VK_keymap[VK_R] = SDLK_r;
461 VK_keymap[VK_S] = SDLK_s;
462 VK_keymap[VK_T] = SDLK_t;
463 VK_keymap[VK_U] = SDLK_u;
464 VK_keymap[VK_V] = SDLK_v;
465 VK_keymap[VK_W] = SDLK_w;
466 VK_keymap[VK_X] = SDLK_x;
467 VK_keymap[VK_Y] = SDLK_y;
468 VK_keymap[VK_Z] = SDLK_z;
469 VK_keymap[VK_DELETE] = SDLK_DELETE;
470
471 VK_keymap[VK_NUMPAD0] = SDLK_KP0;
472 VK_keymap[VK_NUMPAD1] = SDLK_KP1;
473 VK_keymap[VK_NUMPAD2] = SDLK_KP2;
474 VK_keymap[VK_NUMPAD3] = SDLK_KP3;
475 VK_keymap[VK_NUMPAD4] = SDLK_KP4;
476 VK_keymap[VK_NUMPAD5] = SDLK_KP5;
477 VK_keymap[VK_NUMPAD6] = SDLK_KP6;
478 VK_keymap[VK_NUMPAD7] = SDLK_KP7;
479 VK_keymap[VK_NUMPAD8] = SDLK_KP8;
480 VK_keymap[VK_NUMPAD9] = SDLK_KP9;
481 VK_keymap[VK_DECIMAL] = SDLK_KP_PERIOD;
482 VK_keymap[VK_DIVIDE] = SDLK_KP_DIVIDE;
483 VK_keymap[VK_MULTIPLY] = SDLK_KP_MULTIPLY;
484 VK_keymap[VK_SUBTRACT] = SDLK_KP_MINUS;
485 VK_keymap[VK_ADD] = SDLK_KP_PLUS;
486
487 VK_keymap[VK_UP] = SDLK_UP;
488 VK_keymap[VK_DOWN] = SDLK_DOWN;
489 VK_keymap[VK_RIGHT] = SDLK_RIGHT;
490 VK_keymap[VK_LEFT] = SDLK_LEFT;
491 VK_keymap[VK_INSERT] = SDLK_INSERT;
492 VK_keymap[VK_HOME] = SDLK_HOME;
493 VK_keymap[VK_END] = SDLK_END;
494 VK_keymap[VK_PRIOR] = SDLK_PAGEUP;
495 VK_keymap[VK_NEXT] = SDLK_PAGEDOWN;
496
497 VK_keymap[VK_F1] = SDLK_F1;
498 VK_keymap[VK_F2] = SDLK_F2;
499 VK_keymap[VK_F3] = SDLK_F3;
500 VK_keymap[VK_F4] = SDLK_F4;
501 VK_keymap[VK_F5] = SDLK_F5;
502 VK_keymap[VK_F6] = SDLK_F6;
503 VK_keymap[VK_F7] = SDLK_F7;
504 VK_keymap[VK_F8] = SDLK_F8;
505 VK_keymap[VK_F9] = SDLK_F9;
506 VK_keymap[VK_F10] = SDLK_F10;
507 VK_keymap[VK_F11] = SDLK_F11;
508 VK_keymap[VK_F12] = SDLK_F12;
509 VK_keymap[VK_F13] = SDLK_F13;
510 VK_keymap[VK_F14] = SDLK_F14;
511 VK_keymap[VK_F15] = SDLK_F15;
512
513 VK_keymap[VK_NUMLOCK] = SDLK_NUMLOCK;
514 VK_keymap[VK_CAPITAL] = SDLK_CAPSLOCK;
515 VK_keymap[VK_SCROLL] = SDLK_SCROLLOCK;
516 VK_keymap[VK_RSHIFT] = SDLK_RSHIFT;
517 VK_keymap[VK_LSHIFT] = SDLK_LSHIFT;
518 VK_keymap[VK_RCONTROL] = SDLK_RCTRL;
519 VK_keymap[VK_LCONTROL] = SDLK_LCTRL;
520 VK_keymap[VK_RMENU] = SDLK_RALT;
521 VK_keymap[VK_LMENU] = SDLK_LALT;
522 VK_keymap[VK_RWIN] = SDLK_RSUPER;
523 VK_keymap[VK_LWIN] = SDLK_LSUPER;
524
525 VK_keymap[VK_HELP] = SDLK_HELP;
526#ifdef VK_PRINT
527 VK_keymap[VK_PRINT] = SDLK_PRINT;
528#endif
529 VK_keymap[VK_SNAPSHOT] = SDLK_PRINT;
530 VK_keymap[VK_CANCEL] = SDLK_BREAK;
531 VK_keymap[VK_APPS] = SDLK_MENU;
532
533 Arrows_keymap[3] = 0x25;
534 Arrows_keymap[2] = 0x26;
535 Arrows_keymap[1] = 0x27;
536 Arrows_keymap[0] = 0x28;
537}
538
539#define EXTKEYPAD(keypad) ((scancode & 0x100)?(mvke):(keypad))
540
541static int SDL_MapVirtualKey(int scancode, int vkey)
542{
543#ifndef _WIN32_WCE
544 int mvke = MapVirtualKeyEx(scancode & 0xFF, 1, hLayoutUS);
545#else
546 int mvke = MapVirtualKey(scancode & 0xFF, 1);
547#endif
548
549 switch(vkey) {
550 /* These are always correct */
551 case VK_DIVIDE:
552 case VK_MULTIPLY:
553 case VK_SUBTRACT:
554 case VK_ADD:
555 case VK_LWIN:
556 case VK_RWIN:
557 case VK_APPS:
558 /* These are already handled */
559 case VK_LCONTROL:
560 case VK_RCONTROL:
561 case VK_LSHIFT:
562 case VK_RSHIFT:
563 case VK_LMENU:
564 case VK_RMENU:
565 case VK_SNAPSHOT:
566 case VK_PAUSE:
567 return vkey;
568 }
569 switch(mvke) {
570 /* Distinguish between keypad and extended keys */
571 case VK_INSERT: return EXTKEYPAD(VK_NUMPAD0);
572 case VK_DELETE: return EXTKEYPAD(VK_DECIMAL);
573 case VK_END: return EXTKEYPAD(VK_NUMPAD1);
574 case VK_DOWN: return EXTKEYPAD(VK_NUMPAD2);
575 case VK_NEXT: return EXTKEYPAD(VK_NUMPAD3);
576 case VK_LEFT: return EXTKEYPAD(VK_NUMPAD4);
577 case VK_CLEAR: return EXTKEYPAD(VK_NUMPAD5);
578 case VK_RIGHT: return EXTKEYPAD(VK_NUMPAD6);
579 case VK_HOME: return EXTKEYPAD(VK_NUMPAD7);
580 case VK_UP: return EXTKEYPAD(VK_NUMPAD8);
581 case VK_PRIOR: return EXTKEYPAD(VK_NUMPAD9);
582 }
583 return mvke?mvke:vkey;
584}
585
586static SDL_keysym *TranslateKey(WPARAM vkey, UINT scancode, SDL_keysym *keysym, int pressed)
587{
588 /* Set the keysym information */
589 keysym->scancode = (unsigned char) scancode;
590 keysym->mod = KMOD_NONE;
591 keysym->unicode = 0;
592
593 if ((vkey == VK_RETURN) && (scancode & 0x100)) {
594 /* No VK_ code for the keypad enter key */
595 keysym->sym = SDLK_KP_ENTER;
596 }
597 else {
598 keysym->sym = VK_keymap[SDL_MapVirtualKey(scancode, vkey)];
599 }
600
601 if ( pressed && SDL_TranslateUNICODE ) {
602#ifdef NO_GETKEYBOARDSTATE
603 /* Uh oh, better hope the vkey is close enough.. */
604 if((keysym->sym == vkey) || (vkey > 0x7f))
605 keysym->unicode = vkey;
606#else
607 BYTE keystate[256];
608 Uint16 wchars[2];
609
610 GetKeyboardState(keystate);
611 /* Numlock isn't taken into account in ToUnicode,
612 * so we handle it as a special case here */
613 if ((keystate[VK_NUMLOCK] & 1) && vkey >= VK_NUMPAD0 && vkey <= VK_NUMPAD9)
614 {
615 keysym->unicode = vkey - VK_NUMPAD0 + '0';
616 }
617 else if (SDL_ToUnicode((UINT)vkey, scancode, keystate, wchars, sizeof(wchars)/sizeof(wchars[0]), 0) > 0)
618 {
619 keysym->unicode = wchars[0];
620 }
621#endif /* NO_GETKEYBOARDSTATE */
622 }
623
624#if 0
625 {
626 HKL hLayoutCurrent = GetKeyboardLayout(0);
627 int sc = scancode & 0xFF;
628
629 printf("SYM:%d, VK:0x%02X, SC:0x%04X, US:(1:0x%02X, 3:0x%02X), "
630 "Current:(1:0x%02X, 3:0x%02X)\n",
631 keysym->sym, vkey, scancode,
632 MapVirtualKeyEx(sc, 1, hLayoutUS),
633 MapVirtualKeyEx(sc, 3, hLayoutUS),
634 MapVirtualKeyEx(sc, 1, hLayoutCurrent),
635 MapVirtualKeyEx(sc, 3, hLayoutCurrent)
636 );
637 }
638#endif
639 return(keysym);
640}
641
642int DIB_CreateWindow(_THIS)
643{
644 char *windowid;
645
646 SDL_RegisterApp(NULL, 0, 0);
647
648 windowid = SDL_getenv("SDL_WINDOWID");
649 SDL_windowid = (windowid != NULL);
650 if ( SDL_windowid ) {
651#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
652 /* wince 2.1 does not have strtol */
653 wchar_t *windowid_t = SDL_malloc((SDL_strlen(windowid) + 1) * sizeof(wchar_t));
654 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, windowid, -1, windowid_t, SDL_strlen(windowid) + 1);
655 SDL_Window = (HWND)wcstol(windowid_t, NULL, 0);
656 SDL_free(windowid_t);
657#else
658 SDL_Window = (HWND)((size_t)SDL_strtoull(windowid, NULL, 0));
659#endif
660 if ( SDL_Window == NULL ) {
661 SDL_SetError("Couldn't get user specified window");
662 return(-1);
663 }
664
665 /* DJM: we want all event's for the user specified
666 window to be handled by SDL.
667 */
668 userWindowProc = (WNDPROCTYPE)GetWindowLongPtr(SDL_Window, GWLP_WNDPROC);
669 SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)WinMessage);
670 } else {
671 SDL_Window = CreateWindow(SDL_Appname, SDL_Appname,
672 (WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX),
673 CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, NULL, NULL, SDL_Instance, NULL);
674 if ( SDL_Window == NULL ) {
675 SDL_SetError("Couldn't create window");
676 return(-1);
677 }
678 ShowWindow(SDL_Window, SW_HIDE);
679 }
680
681 /* JC 14 Mar 2006
682 Flush the message loop or this can cause big problems later
683 Especially if the user decides to use dialog boxes or assert()!
684 */
685 WIN_FlushMessageQueue();
686
687 return(0);
688}
689
690void DIB_DestroyWindow(_THIS)
691{
692 if ( SDL_windowid ) {
693 SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)userWindowProc);
694 } else {
695 DestroyWindow(SDL_Window);
696 }
697 SDL_UnregisterApp();
698
699 /* JC 14 Mar 2006
700 Flush the message loop or this can cause big problems later
701 Especially if the user decides to use dialog boxes or assert()!
702 */
703 WIN_FlushMessageQueue();
704}
diff --git a/apps/plugins/sdl/src/video/windib/SDL_dibevents_c.h b/apps/plugins/sdl/src/video/windib/SDL_dibevents_c.h
deleted file mode 100644
index 236aa68ee9..0000000000
--- a/apps/plugins/sdl/src/video/windib/SDL_dibevents_c.h
+++ /dev/null
@@ -1,35 +0,0 @@
1/*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2012 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#include "../wincommon/SDL_lowvideo.h"
25
26/* Variables and functions exported by SDL_dibevents.c to other parts
27 of the native video subsystem (SDL_dibvideo.c)
28*/
29extern LONG
30 DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
31extern int DIB_CreateWindow(_THIS);
32extern void DIB_DestroyWindow(_THIS);
33
34extern void DIB_PumpEvents(_THIS);
35extern void DIB_InitOSKeymap(_THIS);
diff --git a/apps/plugins/sdl/src/video/windib/SDL_dibvideo.c b/apps/plugins/sdl/src/video/windib/SDL_dibvideo.c
deleted file mode 100644
index 6187bfcf7e..0000000000
--- a/apps/plugins/sdl/src/video/windib/SDL_dibvideo.c
+++ /dev/null
@@ -1,1323 +0,0 @@
1/*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2012 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#define WIN32_LEAN_AND_MEAN
25#include <windows.h>
26
27/* Not yet in the mingw32 cross-compile headers */
28#ifndef CDS_FULLSCREEN
29#define CDS_FULLSCREEN 4
30#endif
31
32#include "SDL_syswm.h"
33#include "../SDL_sysvideo.h"
34#include "../SDL_pixels_c.h"
35#include "../../events/SDL_sysevents.h"
36#include "../../events/SDL_events_c.h"
37#include "SDL_gapidibvideo.h"
38#include "SDL_dibvideo.h"
39#include "../wincommon/SDL_syswm_c.h"
40#include "../wincommon/SDL_sysmouse_c.h"
41#include "SDL_dibevents_c.h"
42#include "../wincommon/SDL_wingl_c.h"
43
44#ifdef _WIN32_WCE
45
46#ifndef DM_DISPLAYORIENTATION
47#define DM_DISPLAYORIENTATION 0x00800000L
48#endif
49#ifndef DM_DISPLAYQUERYORIENTATION
50#define DM_DISPLAYQUERYORIENTATION 0x01000000L
51#endif
52#ifndef DMDO_0
53#define DMDO_0 0
54#endif
55#ifndef DMDO_90
56#define DMDO_90 1
57#endif
58#ifndef DMDO_180
59#define DMDO_180 2
60#endif
61#ifndef DMDO_270
62#define DMDO_270 4
63#endif
64
65#define NO_GETDIBITS
66#define NO_GAMMA_SUPPORT
67 #if _WIN32_WCE < 420
68 #define NO_CHANGEDISPLAYSETTINGS
69 #else
70 #define ChangeDisplaySettings(lpDevMode, dwFlags) ChangeDisplaySettingsEx(NULL, (lpDevMode), 0, (dwFlags), 0)
71 #endif
72#endif
73#ifndef WS_MAXIMIZE
74#define WS_MAXIMIZE 0
75#endif
76#ifndef WS_THICKFRAME
77#define WS_THICKFRAME 0
78#endif
79#ifndef SWP_NOCOPYBITS
80#define SWP_NOCOPYBITS 0
81#endif
82#ifndef PC_NOCOLLAPSE
83#define PC_NOCOLLAPSE 0
84#endif
85
86#ifdef _WIN32_WCE
87// defined and used in SDL_sysevents.c
88extern HINSTANCE aygshell;
89#endif
90
91/* Initialization/Query functions */
92static int DIB_VideoInit(_THIS, SDL_PixelFormat *vformat);
93static SDL_Rect **DIB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
94SDL_Surface *DIB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
95static int DIB_SetColors(_THIS, int firstcolor, int ncolors,
96 SDL_Color *colors);
97static void DIB_CheckGamma(_THIS);
98void DIB_SwapGamma(_THIS);
99void DIB_QuitGamma(_THIS);
100int DIB_SetGammaRamp(_THIS, Uint16 *ramp);
101int DIB_GetGammaRamp(_THIS, Uint16 *ramp);
102static void DIB_VideoQuit(_THIS);
103
104/* Hardware surface functions */
105static int DIB_AllocHWSurface(_THIS, SDL_Surface *surface);
106static int DIB_LockHWSurface(_THIS, SDL_Surface *surface);
107static void DIB_UnlockHWSurface(_THIS, SDL_Surface *surface);
108static void DIB_FreeHWSurface(_THIS, SDL_Surface *surface);
109
110/* Windows message handling functions */
111static void DIB_GrabStaticColors(HWND window);
112static void DIB_ReleaseStaticColors(HWND window);
113static void DIB_Activate(_THIS, BOOL active, BOOL minimized);
114static void DIB_RealizePalette(_THIS);
115static void DIB_PaletteChanged(_THIS, HWND window);
116static void DIB_WinPAINT(_THIS, HDC hdc);
117
118/* helper fn */
119static int DIB_SussScreenDepth();
120
121/* DIB driver bootstrap functions */
122
123static int DIB_Available(void)
124{
125 return(1);
126}
127
128static void DIB_DeleteDevice(SDL_VideoDevice *device)
129{
130 if ( device ) {
131 if ( device->hidden ) {
132 if ( device->hidden->dibInfo ) {
133 SDL_free( device->hidden->dibInfo );
134 }
135 SDL_free(device->hidden);
136 }
137 if ( device->gl_data ) {
138 SDL_free(device->gl_data);
139 }
140 SDL_free(device);
141 }
142}
143
144static SDL_VideoDevice *DIB_CreateDevice(int devindex)
145{
146 SDL_VideoDevice *device;
147
148 /* Initialize all variables that we clean on shutdown */
149 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
150 if ( device ) {
151 SDL_memset(device, 0, (sizeof *device));
152 device->hidden = (struct SDL_PrivateVideoData *)
153 SDL_malloc((sizeof *device->hidden));
154 if(device->hidden){
155 SDL_memset(device->hidden, 0, (sizeof *device->hidden));
156 device->hidden->dibInfo = (DibInfo *)SDL_malloc((sizeof(DibInfo)));
157 if(device->hidden->dibInfo == NULL)
158 {
159 SDL_free(device->hidden);
160 device->hidden = NULL;
161 }
162 }
163
164 device->gl_data = (struct SDL_PrivateGLData *)
165 SDL_malloc((sizeof *device->gl_data));
166 }
167 if ( (device == NULL) || (device->hidden == NULL) ||
168 (device->gl_data == NULL) ) {
169 SDL_OutOfMemory();
170 DIB_DeleteDevice(device);
171 return(NULL);
172 }
173 SDL_memset(device->hidden->dibInfo, 0, (sizeof *device->hidden->dibInfo));
174 SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
175
176 /* Set the function pointers */
177 device->VideoInit = DIB_VideoInit;
178 device->ListModes = DIB_ListModes;
179 device->SetVideoMode = DIB_SetVideoMode;
180 device->UpdateMouse = WIN_UpdateMouse;
181 device->SetColors = DIB_SetColors;
182 device->UpdateRects = NULL;
183 device->VideoQuit = DIB_VideoQuit;
184 device->AllocHWSurface = DIB_AllocHWSurface;
185 device->CheckHWBlit = NULL;
186 device->FillHWRect = NULL;
187 device->SetHWColorKey = NULL;
188 device->SetHWAlpha = NULL;
189 device->LockHWSurface = DIB_LockHWSurface;
190 device->UnlockHWSurface = DIB_UnlockHWSurface;
191 device->FlipHWSurface = NULL;
192 device->FreeHWSurface = DIB_FreeHWSurface;
193 device->SetGammaRamp = DIB_SetGammaRamp;
194 device->GetGammaRamp = DIB_GetGammaRamp;
195#if SDL_VIDEO_OPENGL
196 device->GL_LoadLibrary = WIN_GL_LoadLibrary;
197 device->GL_GetProcAddress = WIN_GL_GetProcAddress;
198 device->GL_GetAttribute = WIN_GL_GetAttribute;
199 device->GL_MakeCurrent = WIN_GL_MakeCurrent;
200 device->GL_SwapBuffers = WIN_GL_SwapBuffers;
201#endif
202 device->SetCaption = WIN_SetWMCaption;
203 device->SetIcon = WIN_SetWMIcon;
204 device->IconifyWindow = WIN_IconifyWindow;
205 device->GrabInput = WIN_GrabInput;
206 device->GetWMInfo = WIN_GetWMInfo;
207 device->FreeWMCursor = WIN_FreeWMCursor;
208 device->CreateWMCursor = WIN_CreateWMCursor;
209 device->ShowWMCursor = WIN_ShowWMCursor;
210 device->WarpWMCursor = WIN_WarpWMCursor;
211 device->CheckMouseMode = WIN_CheckMouseMode;
212 device->InitOSKeymap = DIB_InitOSKeymap;
213 device->PumpEvents = DIB_PumpEvents;
214
215 /* Set up the windows message handling functions */
216 WIN_Activate = DIB_Activate;
217 WIN_RealizePalette = DIB_RealizePalette;
218 WIN_PaletteChanged = DIB_PaletteChanged;
219 WIN_WinPAINT = DIB_WinPAINT;
220 HandleMessage = DIB_HandleMessage;
221
222 device->free = DIB_DeleteDevice;
223
224 /* We're finally ready */
225 return device;
226}
227
228VideoBootStrap WINDIB_bootstrap = {
229 "windib", "Win95/98/NT/2000/CE GDI",
230 DIB_Available, DIB_CreateDevice
231};
232
233static int cmpmodes(const void *va, const void *vb)
234{
235 SDL_Rect *a = *(SDL_Rect **)va;
236 SDL_Rect *b = *(SDL_Rect **)vb;
237 if ( a->w == b->w )
238 return b->h - a->h;
239 else
240 return b->w - a->w;
241}
242
243static int DIB_AddMode(_THIS, int bpp, int w, int h)
244{
245 SDL_Rect *mode;
246 int i, index;
247 int next_mode;
248
249 /* Check to see if we already have this mode */
250 if ( bpp < 8 || bpp > 32 ) { /* Not supported */
251 return(0);
252 }
253 index = ((bpp+7)/8)-1;
254 for ( i=0; i<SDL_nummodes[index]; ++i ) {
255 mode = SDL_modelist[index][i];
256 if ( (mode->w == w) && (mode->h == h) ) {
257 return(0);
258 }
259 }
260
261 /* Set up the new video mode rectangle */
262 mode = (SDL_Rect *)SDL_malloc(sizeof *mode);
263 if ( mode == NULL ) {
264 SDL_OutOfMemory();
265 return(-1);
266 }
267 mode->x = 0;
268 mode->y = 0;
269 mode->w = w;
270 mode->h = h;
271
272 /* Allocate the new list of modes, and fill in the new mode */
273 next_mode = SDL_nummodes[index];
274 SDL_modelist[index] = (SDL_Rect **)
275 SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *));
276 if ( SDL_modelist[index] == NULL ) {
277 SDL_OutOfMemory();
278 SDL_nummodes[index] = 0;
279 SDL_free(mode);
280 return(-1);
281 }
282 SDL_modelist[index][next_mode] = mode;
283 SDL_modelist[index][next_mode+1] = NULL;
284 SDL_nummodes[index]++;
285
286 return(0);
287}
288
289static void DIB_CreatePalette(_THIS, int bpp)
290{
291/* RJR: March 28, 2000
292 moved palette creation here from "DIB_VideoInit" */
293
294 LOGPALETTE *palette;
295 HDC hdc;
296 int ncolors;
297
298 ncolors = (1 << bpp);
299 palette = (LOGPALETTE *)SDL_malloc(sizeof(*palette)+
300 ncolors*sizeof(PALETTEENTRY));
301 palette->palVersion = 0x300;
302 palette->palNumEntries = ncolors;
303 hdc = GetDC(SDL_Window);
304 GetSystemPaletteEntries(hdc, 0, ncolors, palette->palPalEntry);
305 ReleaseDC(SDL_Window, hdc);
306 screen_pal = CreatePalette(palette);
307 screen_logpal = palette;
308}
309
310int DIB_VideoInit(_THIS, SDL_PixelFormat *vformat)
311{
312 const char *env = NULL;
313#ifndef NO_CHANGEDISPLAYSETTINGS
314 int i;
315 DEVMODE settings;
316#endif
317
318 /* Create the window */
319 if ( DIB_CreateWindow(this) < 0 ) {
320 return(-1);
321 }
322
323#if !SDL_AUDIO_DISABLED
324 DX5_SoundFocus(SDL_Window);
325#endif
326
327 /* Determine the screen depth */
328 vformat->BitsPerPixel = DIB_SussScreenDepth();
329 switch (vformat->BitsPerPixel) {
330 case 15:
331 vformat->Rmask = 0x00007c00;
332 vformat->Gmask = 0x000003e0;
333 vformat->Bmask = 0x0000001f;
334 vformat->BitsPerPixel = 16;
335 break;
336 case 16:
337 vformat->Rmask = 0x0000f800;
338 vformat->Gmask = 0x000007e0;
339 vformat->Bmask = 0x0000001f;
340 break;
341 case 24:
342 case 32:
343 /* GDI defined as 8-8-8 */
344 vformat->Rmask = 0x00ff0000;
345 vformat->Gmask = 0x0000ff00;
346 vformat->Bmask = 0x000000ff;
347 break;
348 default:
349 break;
350 }
351
352 /* See if gamma is supported on this screen */
353 DIB_CheckGamma(this);
354
355#ifndef NO_CHANGEDISPLAYSETTINGS
356
357 settings.dmSize = sizeof(DEVMODE);
358 settings.dmDriverExtra = 0;
359#ifdef _WIN32_WCE
360 settings.dmFields = DM_DISPLAYQUERYORIENTATION;
361 this->hidden->supportRotation = ChangeDisplaySettingsEx(NULL, &settings, NULL, CDS_TEST, NULL) == DISP_CHANGE_SUCCESSFUL;
362#endif
363 /* Query for the desktop resolution */
364 SDL_desktop_mode.dmSize = sizeof(SDL_desktop_mode);
365 SDL_desktop_mode.dmDriverExtra = 0;
366 EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &SDL_desktop_mode);
367 this->info.current_w = SDL_desktop_mode.dmPelsWidth;
368 this->info.current_h = SDL_desktop_mode.dmPelsHeight;
369
370 /* Query for the list of available video modes */
371 for ( i=0; EnumDisplaySettings(NULL, i, &settings); ++i ) {
372 DIB_AddMode(this, settings.dmBitsPerPel,
373 settings.dmPelsWidth, settings.dmPelsHeight);
374#ifdef _WIN32_WCE
375 if( this->hidden->supportRotation )
376 DIB_AddMode(this, settings.dmBitsPerPel,
377 settings.dmPelsHeight, settings.dmPelsWidth);
378#endif
379 }
380 /* Sort the mode lists */
381 for ( i=0; i<NUM_MODELISTS; ++i ) {
382 if ( SDL_nummodes[i] > 0 ) {
383 SDL_qsort(SDL_modelist[i], SDL_nummodes[i], sizeof *SDL_modelist[i], cmpmodes);
384 }
385 }
386#else
387 // WinCE and fullscreen mode:
388 // We use only vformat->BitsPerPixel that allow SDL to
389 // emulate other bpp (8, 32) and use triple buffer,
390 // because SDL surface conversion is much faster than the WinCE one.
391 // Although it should be tested on devices with graphics accelerator.
392
393 DIB_AddMode(this, vformat->BitsPerPixel,
394 GetDeviceCaps(GetDC(NULL), HORZRES),
395 GetDeviceCaps(GetDC(NULL), VERTRES));
396
397#endif /* !NO_CHANGEDISPLAYSETTINGS */
398
399 /* Grab an identity palette if we are in a palettized mode */
400 if ( vformat->BitsPerPixel <= 8 ) {
401 /* RJR: March 28, 2000
402 moved palette creation to "DIB_CreatePalette" */
403 DIB_CreatePalette(this, vformat->BitsPerPixel);
404 }
405
406 /* Fill in some window manager capabilities */
407 this->info.wm_available = 1;
408
409#ifdef _WIN32_WCE
410 this->hidden->origRotation = -1;
411#endif
412
413 /* Allow environment override of screensaver disable. */
414 env = SDL_getenv("SDL_VIDEO_ALLOW_SCREENSAVER");
415 if ( env ) {
416 allow_screensaver = SDL_atoi(env);
417 } else {
418#ifdef SDL_VIDEO_DISABLE_SCREENSAVER
419 allow_screensaver = 0;
420#else
421 allow_screensaver = 1;
422#endif
423 }
424
425 /* We're done! */
426 return(0);
427}
428
429/* We support any format at any dimension */
430SDL_Rect **DIB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
431{
432 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
433 return(SDL_modelist[((format->BitsPerPixel+7)/8)-1]);
434 } else {
435 return((SDL_Rect **)-1);
436 }
437}
438
439
440/*
441 Helper fn to work out which screen depth windows is currently using.
442 15 bit mode is considered 555 format, 16 bit is 565.
443 returns 0 for unknown mode.
444 (Derived from code in sept 1999 Windows Developer Journal
445 http://www.wdj.com/code/archive.html)
446*/
447static int DIB_SussScreenDepth()
448{
449#ifdef NO_GETDIBITS
450 int depth;
451 HDC hdc;
452
453 hdc = GetDC(SDL_Window);
454 depth = GetDeviceCaps(hdc, PLANES) * GetDeviceCaps(hdc, BITSPIXEL);
455 ReleaseDC(SDL_Window, hdc);
456 return(depth);
457#else
458 int depth;
459 int dib_size;
460 LPBITMAPINFOHEADER dib_hdr;
461 HDC hdc;
462 HBITMAP hbm;
463
464 /* Allocate enough space for a DIB header plus palette (for
465 * 8-bit modes) or bitfields (for 16- and 32-bit modes)
466 */
467 dib_size = sizeof(BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD);
468 dib_hdr = (LPBITMAPINFOHEADER) SDL_malloc(dib_size);
469 SDL_memset(dib_hdr, 0, dib_size);
470 dib_hdr->biSize = sizeof(BITMAPINFOHEADER);
471
472 /* Get a device-dependent bitmap that's compatible with the
473 screen.
474 */
475 hdc = GetDC(NULL);
476 hbm = CreateCompatibleBitmap( hdc, 1, 1 );
477
478 /* Convert the DDB to a DIB. We need to call GetDIBits twice:
479 * the first call just fills in the BITMAPINFOHEADER; the
480 * second fills in the bitfields or palette.
481 */
482 GetDIBits(hdc, hbm, 0, 1, NULL, (LPBITMAPINFO) dib_hdr, DIB_RGB_COLORS);
483 GetDIBits(hdc, hbm, 0, 1, NULL, (LPBITMAPINFO) dib_hdr, DIB_RGB_COLORS);
484 DeleteObject(hbm);
485 ReleaseDC(NULL, hdc);
486
487 depth = 0;
488 switch( dib_hdr->biBitCount )
489 {
490 case 8: depth = 8; break;
491 case 24: depth = 24; break;
492 case 32: depth = 32; break;
493 case 16:
494 if( dib_hdr->biCompression == BI_BITFIELDS ) {
495 /* check the red mask */
496 switch( ((DWORD*)((char*)dib_hdr + dib_hdr->biSize))[0] ) {
497 case 0xf800: depth = 16; break; /* 565 */
498 case 0x7c00: depth = 15; break; /* 555 */
499 }
500 }
501 }
502 SDL_free(dib_hdr);
503 return depth;
504#endif /* NO_GETDIBITS */
505}
506
507
508/* Various screen update functions available */
509static void DIB_NormalUpdate(_THIS, int numrects, SDL_Rect *rects);
510
511static void DIB_ResizeWindow(_THIS, int width, int height, int prev_width, int prev_height, Uint32 flags)
512{
513 RECT bounds;
514 int x, y;
515
516#ifndef _WIN32_WCE
517 /* Resize the window */
518 if ( !SDL_windowid && !IsZoomed(SDL_Window) ) {
519#else
520 if ( !SDL_windowid ) {
521#endif
522 HWND top;
523 UINT swp_flags;
524 const char *window = NULL;
525 const char *center = NULL;
526
527 if ( width != prev_width || height != prev_height ) {
528 window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
529 center = SDL_getenv("SDL_VIDEO_CENTERED");
530 if ( window ) {
531 if ( SDL_sscanf(window, "%d,%d", &x, &y) == 2 ) {
532 SDL_windowX = x;
533 SDL_windowY = y;
534 }
535 if ( SDL_strcmp(window, "center") == 0 ) {
536 center = window;
537 }
538 }
539 }
540 swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW);
541
542 bounds.left = SDL_windowX;
543 bounds.top = SDL_windowY;
544 bounds.right = SDL_windowX+width;
545 bounds.bottom = SDL_windowY+height;
546#ifndef _WIN32_WCE
547 AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), (GetMenu(SDL_Window) != NULL), 0);
548#else
549 // The bMenu parameter must be FALSE; menu bars are not supported
550 AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), 0, 0);
551#endif
552 width = bounds.right-bounds.left;
553 height = bounds.bottom-bounds.top;
554 if ( (flags & SDL_FULLSCREEN) ) {
555 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
556 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
557 } else if ( center ) {
558 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
559 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
560 } else if ( SDL_windowX || SDL_windowY || window ) {
561 x = bounds.left;
562 y = bounds.top;
563 } else {
564 x = y = -1;
565 swp_flags |= SWP_NOMOVE;
566 }
567 if ( flags & SDL_FULLSCREEN ) {
568 top = HWND_TOPMOST;
569 } else {
570 top = HWND_NOTOPMOST;
571 }
572 SetWindowPos(SDL_Window, top, x, y, width, height, swp_flags);
573 if ( !(flags & SDL_FULLSCREEN) ) {
574 SDL_windowX = SDL_bounds.left;
575 SDL_windowY = SDL_bounds.top;
576 }
577 if ( GetParent(SDL_Window) == NULL ) {
578 SetForegroundWindow(SDL_Window);
579 }
580 }
581}
582
583SDL_Surface *DIB_SetVideoMode(_THIS, SDL_Surface *current,
584 int width, int height, int bpp, Uint32 flags)
585{
586 SDL_Surface *video;
587 int prev_w, prev_h;
588 Uint32 prev_flags;
589 DWORD style;
590 const DWORD directstyle =
591 (WS_POPUP);
592 const DWORD windowstyle =
593 (WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX);
594 const DWORD resizestyle =
595 (WS_THICKFRAME|WS_MAXIMIZEBOX);
596 int binfo_size;
597 BITMAPINFO *binfo;
598 HDC hdc;
599 Uint32 Rmask, Gmask, Bmask;
600
601 prev_w = current->w;
602 prev_h = current->h;
603 prev_flags = current->flags;
604
605 /*
606 * Special case for OpenGL windows...since the app needs to call
607 * SDL_SetVideoMode() in response to resize events to continue to
608 * function, but WGL handles the GL context details behind the scenes,
609 * there's no sense in tearing the context down just to rebuild it
610 * to what it already was...tearing it down sacrifices your GL state
611 * and uploaded textures. So if we're requesting the same video mode
612 * attributes just resize the window and return immediately.
613 */
614 if ( SDL_Window &&
615 ((current->flags & ~SDL_ANYFORMAT) == (flags & ~SDL_ANYFORMAT)) &&
616 (current->format->BitsPerPixel == bpp) &&
617 (flags & SDL_OPENGL) &&
618 !(flags & SDL_FULLSCREEN) ) { /* probably not safe for fs */
619 current->w = width;
620 current->h = height;
621 SDL_resizing = 1;
622 DIB_ResizeWindow(this, width, height, prev_w, prev_h, flags);
623 SDL_resizing = 0;
624 return current;
625 }
626
627 /* Clean up any GL context that may be hanging around */
628 if ( current->flags & SDL_OPENGL ) {
629 WIN_GL_ShutDown(this);
630 }
631 SDL_resizing = 1;
632
633 /* Recalculate the bitmasks if necessary */
634 if ( bpp == current->format->BitsPerPixel ) {
635 video = current;
636 } else {
637 switch (bpp) {
638 case 15:
639 case 16:
640 if ( DIB_SussScreenDepth() == 15 ) {
641 /* 5-5-5 */
642 Rmask = 0x00007c00;
643 Gmask = 0x000003e0;
644 Bmask = 0x0000001f;
645 } else {
646 /* 5-6-5 */
647 Rmask = 0x0000f800;
648 Gmask = 0x000007e0;
649 Bmask = 0x0000001f;
650 }
651 break;
652 case 24:
653 case 32:
654 /* GDI defined as 8-8-8 */
655 Rmask = 0x00ff0000;
656 Gmask = 0x0000ff00;
657 Bmask = 0x000000ff;
658 break;
659 default:
660 Rmask = 0x00000000;
661 Gmask = 0x00000000;
662 Bmask = 0x00000000;
663 break;
664 }
665 video = SDL_CreateRGBSurface(SDL_SWSURFACE,
666 0, 0, bpp, Rmask, Gmask, Bmask, 0);
667 if ( video == NULL ) {
668 SDL_OutOfMemory();
669 return(NULL);
670 }
671 }
672
673 /* Fill in part of the video surface */
674 video->flags = 0; /* Clear flags */
675 video->w = width;
676 video->h = height;
677 video->pitch = SDL_CalculatePitch(video);
678
679 /* Small fix for WinCE/Win32 - when activating window
680 SDL_VideoSurface is equal to zero, so activating code
681 is not called properly for fullscreen windows because
682 macros WINDIB_FULLSCREEN uses SDL_VideoSurface
683 */
684 SDL_VideoSurface = video;
685
686#if defined(_WIN32_WCE)
687 if ( flags & SDL_FULLSCREEN )
688 video->flags |= SDL_FULLSCREEN;
689#endif
690
691#ifndef NO_CHANGEDISPLAYSETTINGS
692 /* Set fullscreen mode if appropriate */
693 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
694 DEVMODE settings;
695 BOOL changed;
696
697 SDL_memset(&settings, 0, sizeof(DEVMODE));
698 settings.dmSize = sizeof(DEVMODE);
699
700#ifdef _WIN32_WCE
701 // try to rotate screen to fit requested resolution
702 if( this->hidden->supportRotation )
703 {
704 DWORD rotation;
705
706 // ask current mode
707 settings.dmFields = DM_DISPLAYORIENTATION;
708 ChangeDisplaySettingsEx(NULL, &settings, NULL, CDS_TEST, NULL);
709 rotation = settings.dmDisplayOrientation;
710
711 if( (width > GetDeviceCaps(GetDC(NULL), HORZRES))
712 && (height < GetDeviceCaps(GetDC(NULL), VERTRES)))
713 {
714 switch( rotation )
715 {
716 case DMDO_0:
717 settings.dmDisplayOrientation = DMDO_90;
718 break;
719 case DMDO_270:
720 settings.dmDisplayOrientation = DMDO_180;
721 break;
722 }
723 if( settings.dmDisplayOrientation != rotation )
724 {
725 // go to landscape
726 this->hidden->origRotation = rotation;
727 ChangeDisplaySettingsEx(NULL,&settings,NULL,CDS_RESET,NULL);
728 }
729 }
730 if( (width < GetDeviceCaps(GetDC(NULL), HORZRES))
731 && (height > GetDeviceCaps(GetDC(NULL), VERTRES)))
732 {
733 switch( rotation )
734 {
735 case DMDO_90:
736 settings.dmDisplayOrientation = DMDO_0;
737 break;
738 case DMDO_180:
739 settings.dmDisplayOrientation = DMDO_270;
740 break;
741 }
742 if( settings.dmDisplayOrientation != rotation )
743 {
744 // go to portrait
745 this->hidden->origRotation = rotation;
746 ChangeDisplaySettingsEx(NULL,&settings,NULL,CDS_RESET,NULL);
747 }
748 }
749
750 }
751#endif
752
753#ifndef _WIN32_WCE
754 settings.dmBitsPerPel = video->format->BitsPerPixel;
755 settings.dmPelsWidth = width;
756 settings.dmPelsHeight = height;
757 settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
758 if ( width <= (int)SDL_desktop_mode.dmPelsWidth &&
759 height <= (int)SDL_desktop_mode.dmPelsHeight ) {
760 settings.dmDisplayFrequency = SDL_desktop_mode.dmDisplayFrequency;
761 settings.dmFields |= DM_DISPLAYFREQUENCY;
762 }
763 changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL);
764 if ( ! changed && (settings.dmFields & DM_DISPLAYFREQUENCY) ) {
765 settings.dmFields &= ~DM_DISPLAYFREQUENCY;
766 changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL);
767 }
768#else
769 changed = 1;
770#endif
771 if ( changed ) {
772 video->flags |= SDL_FULLSCREEN;
773 SDL_fullscreen_mode = settings;
774 }
775
776 }
777#endif /* !NO_CHANGEDISPLAYSETTINGS */
778
779 /* Reset the palette and create a new one if necessary */
780 if ( grab_palette ) {
781 DIB_ReleaseStaticColors(SDL_Window);
782 grab_palette = FALSE;
783 }
784 if ( screen_pal != NULL ) {
785 /* RJR: March 28, 2000
786 delete identity palette if switching from a palettized mode */
787 DeleteObject(screen_pal);
788 screen_pal = NULL;
789 }
790 if ( screen_logpal != NULL ) {
791 SDL_free(screen_logpal);
792 screen_logpal = NULL;
793 }
794
795 if ( bpp <= 8 )
796 {
797 /* RJR: March 28, 2000
798 create identity palette switching to a palettized mode */
799 DIB_CreatePalette(this, bpp);
800 }
801
802 style = GetWindowLong(SDL_Window, GWL_STYLE);
803 style &= ~(resizestyle|WS_MAXIMIZE);
804 if ( (video->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
805 style &= ~windowstyle;
806 style |= directstyle;
807 } else {
808#ifndef NO_CHANGEDISPLAYSETTINGS
809 if ( (prev_flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
810 ChangeDisplaySettings(NULL, 0);
811 }
812#endif
813 if ( flags & SDL_NOFRAME ) {
814 style &= ~windowstyle;
815 style |= directstyle;
816 video->flags |= SDL_NOFRAME;
817 } else {
818 style &= ~directstyle;
819 style |= windowstyle;
820 if ( flags & SDL_RESIZABLE ) {
821 style |= resizestyle;
822 video->flags |= SDL_RESIZABLE;
823 }
824 }
825#if WS_MAXIMIZE && !defined(_WIN32_WCE)
826 if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE;
827#endif
828 }
829
830 /* DJM: Don't piss of anyone who has setup his own window */
831 if ( !SDL_windowid )
832 SetWindowLong(SDL_Window, GWL_STYLE, style);
833
834 /* Delete the old bitmap if necessary */
835 if ( screen_bmp != NULL ) {
836 DeleteObject(screen_bmp);
837 }
838 if ( ! (flags & SDL_OPENGL) ) {
839 BOOL is16bitmode = (video->format->BytesPerPixel == 2);
840
841 /* Suss out the bitmap info header */
842 binfo_size = sizeof(*binfo);
843 if( is16bitmode ) {
844 /* 16bit modes, palette area used for rgb bitmasks */
845 binfo_size += 3*sizeof(DWORD);
846 } else if ( video->format->palette ) {
847 binfo_size += video->format->palette->ncolors *
848 sizeof(RGBQUAD);
849 }
850 binfo = (BITMAPINFO *)SDL_malloc(binfo_size);
851 if ( ! binfo ) {
852 if ( video != current ) {
853 SDL_FreeSurface(video);
854 }
855 SDL_OutOfMemory();
856 return(NULL);
857 }
858
859 binfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
860 binfo->bmiHeader.biWidth = video->w;
861 binfo->bmiHeader.biHeight = -video->h; /* -ve for topdown bitmap */
862 binfo->bmiHeader.biPlanes = 1;
863 binfo->bmiHeader.biSizeImage = video->h * video->pitch;
864 binfo->bmiHeader.biXPelsPerMeter = 0;
865 binfo->bmiHeader.biYPelsPerMeter = 0;
866 binfo->bmiHeader.biClrUsed = 0;
867 binfo->bmiHeader.biClrImportant = 0;
868 binfo->bmiHeader.biBitCount = video->format->BitsPerPixel;
869
870 if ( is16bitmode ) {
871 /* BI_BITFIELDS tells CreateDIBSection about the rgb masks in the palette */
872 binfo->bmiHeader.biCompression = BI_BITFIELDS;
873 ((Uint32*)binfo->bmiColors)[0] = video->format->Rmask;
874 ((Uint32*)binfo->bmiColors)[1] = video->format->Gmask;
875 ((Uint32*)binfo->bmiColors)[2] = video->format->Bmask;
876 } else {
877 binfo->bmiHeader.biCompression = BI_RGB; /* BI_BITFIELDS for 565 vs 555 */
878 if ( video->format->palette ) {
879 SDL_memset(binfo->bmiColors, 0,
880 video->format->palette->ncolors*sizeof(RGBQUAD));
881 }
882 }
883
884 /* Create the offscreen bitmap buffer */
885 hdc = GetDC(SDL_Window);
886 screen_bmp = CreateDIBSection(hdc, binfo, DIB_RGB_COLORS,
887 (void **)(&video->pixels), NULL, 0);
888 ReleaseDC(SDL_Window, hdc);
889 SDL_free(binfo);
890 if ( screen_bmp == NULL ) {
891 if ( video != current ) {
892 SDL_FreeSurface(video);
893 }
894 SDL_SetError("Couldn't create DIB section");
895 return(NULL);
896 }
897 this->UpdateRects = DIB_NormalUpdate;
898
899 /* Set video surface flags */
900 if ( screen_pal && (flags & (SDL_FULLSCREEN|SDL_HWPALETTE)) ) {
901 grab_palette = TRUE;
902 }
903 if ( screen_pal ) {
904 /* BitBlt() maps colors for us */
905 video->flags |= SDL_HWPALETTE;
906 }
907 }
908 DIB_ResizeWindow(this, width, height, prev_w, prev_h, flags);
909 SDL_resizing = 0;
910
911 /* Set up for OpenGL */
912 if ( flags & SDL_OPENGL ) {
913 if ( WIN_GL_SetupWindow(this) < 0 ) {
914 return(NULL);
915 }
916 video->flags |= SDL_OPENGL;
917 }
918
919 /* JC 14 Mar 2006
920 Flush the message loop or this can cause big problems later
921 Especially if the user decides to use dialog boxes or assert()!
922 */
923 WIN_FlushMessageQueue();
924
925 /* We're live! */
926 return(video);
927}
928
929/* We don't actually allow hardware surfaces in the DIB driver */
930static int DIB_AllocHWSurface(_THIS, SDL_Surface *surface)
931{
932 return(-1);
933}
934static void DIB_FreeHWSurface(_THIS, SDL_Surface *surface)
935{
936 return;
937}
938static int DIB_LockHWSurface(_THIS, SDL_Surface *surface)
939{
940 return(0);
941}
942static void DIB_UnlockHWSurface(_THIS, SDL_Surface *surface)
943{
944 return;
945}
946
947static void DIB_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
948{
949 HDC hdc, mdc;
950 int i;
951
952 hdc = GetDC(SDL_Window);
953 if ( screen_pal ) {
954 SelectPalette(hdc, screen_pal, FALSE);
955 }
956 mdc = CreateCompatibleDC(hdc);
957 SelectObject(mdc, screen_bmp);
958 for ( i=0; i<numrects; ++i ) {
959 BitBlt(hdc, rects[i].x, rects[i].y, rects[i].w, rects[i].h,
960 mdc, rects[i].x, rects[i].y, SRCCOPY);
961 }
962 DeleteDC(mdc);
963 ReleaseDC(SDL_Window, hdc);
964}
965
966static int FindPaletteIndex(LOGPALETTE *pal, BYTE r, BYTE g, BYTE b)
967{
968 PALETTEENTRY *entry;
969 int i;
970 int nentries = pal->palNumEntries;
971
972 for ( i = 0; i < nentries; ++i ) {
973 entry = &pal->palPalEntry[i];
974 if ( entry->peRed == r && entry->peGreen == g && entry->peBlue == b ) {
975 return i;
976 }
977 }
978 return -1;
979}
980
981static BOOL CheckPaletteEntry(LOGPALETTE *pal, int index, BYTE r, BYTE g, BYTE b)
982{
983 PALETTEENTRY *entry;
984 BOOL moved = 0;
985
986 entry = &pal->palPalEntry[index];
987 if ( entry->peRed != r || entry->peGreen != g || entry->peBlue != b ) {
988 int found = FindPaletteIndex(pal, r, g, b);
989 if ( found >= 0 ) {
990 pal->palPalEntry[found] = *entry;
991 }
992 entry->peRed = r;
993 entry->peGreen = g;
994 entry->peBlue = b;
995 moved = 1;
996 }
997 entry->peFlags = 0;
998
999 return moved;
1000}
1001
1002int DIB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
1003{
1004#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
1005 HDC hdc, mdc;
1006 RGBQUAD *pal;
1007#else
1008 HDC hdc;
1009#endif
1010 int i;
1011 int moved_entries = 0;
1012
1013 /* Update the display palette */
1014 hdc = GetDC(SDL_Window);
1015 if ( screen_pal ) {
1016 PALETTEENTRY *entry;
1017
1018 for ( i=0; i<ncolors; ++i ) {
1019 entry = &screen_logpal->palPalEntry[firstcolor+i];
1020 entry->peRed = colors[i].r;
1021 entry->peGreen = colors[i].g;
1022 entry->peBlue = colors[i].b;
1023 entry->peFlags = PC_NOCOLLAPSE;
1024 }
1025#if defined(SYSPAL_NOSTATIC) && !defined(_WIN32_WCE)
1026 /* Check to make sure black and white are in position */
1027 if ( GetSystemPaletteUse(hdc) != SYSPAL_NOSTATIC256 ) {
1028 moved_entries += CheckPaletteEntry(screen_logpal, 0, 0x00, 0x00, 0x00);
1029 moved_entries += CheckPaletteEntry(screen_logpal, screen_logpal->palNumEntries-1, 0xff, 0xff, 0xff);
1030 }
1031 /* FIXME:
1032 If we don't have full access to the palette, what we
1033 really want to do is find the 236 most diverse colors
1034 in the desired palette, set those entries (10-245) and
1035 then map everything into the new system palette.
1036 */
1037#endif
1038
1039#ifndef _WIN32_WCE
1040 /* Copy the entries into the system palette */
1041 UnrealizeObject(screen_pal);
1042#endif
1043 SetPaletteEntries(screen_pal, 0, screen_logpal->palNumEntries, screen_logpal->palPalEntry);
1044 SelectPalette(hdc, screen_pal, FALSE);
1045 RealizePalette(hdc);
1046 }
1047
1048#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
1049 /* Copy palette colors into DIB palette */
1050 pal = SDL_stack_alloc(RGBQUAD, ncolors);
1051 for ( i=0; i<ncolors; ++i ) {
1052 pal[i].rgbRed = colors[i].r;
1053 pal[i].rgbGreen = colors[i].g;
1054 pal[i].rgbBlue = colors[i].b;
1055 pal[i].rgbReserved = 0;
1056 }
1057
1058 /* Set the DIB palette and update the display */
1059 mdc = CreateCompatibleDC(hdc);
1060 SelectObject(mdc, screen_bmp);
1061 SetDIBColorTable(mdc, firstcolor, ncolors, pal);
1062 if ( moved_entries || !grab_palette ) {
1063 BitBlt(hdc, 0, 0, this->screen->w, this->screen->h,
1064 mdc, 0, 0, SRCCOPY);
1065 }
1066 DeleteDC(mdc);
1067 SDL_stack_free(pal);
1068#endif
1069 ReleaseDC(SDL_Window, hdc);
1070 return(1);
1071}
1072
1073
1074static void DIB_CheckGamma(_THIS)
1075{
1076#ifndef NO_GAMMA_SUPPORT
1077 HDC hdc;
1078 WORD ramp[3*256];
1079
1080 /* If we fail to get gamma, disable gamma control */
1081 hdc = GetDC(SDL_Window);
1082 if ( ! GetDeviceGammaRamp(hdc, ramp) ) {
1083 this->GetGammaRamp = NULL;
1084 this->SetGammaRamp = NULL;
1085 }
1086 ReleaseDC(SDL_Window, hdc);
1087#endif /* !NO_GAMMA_SUPPORT */
1088}
1089void DIB_SwapGamma(_THIS)
1090{
1091#ifndef NO_GAMMA_SUPPORT
1092 HDC hdc;
1093
1094 if ( gamma_saved ) {
1095 hdc = GetDC(SDL_Window);
1096 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
1097 /* About to leave active state, restore gamma */
1098 SetDeviceGammaRamp(hdc, gamma_saved);
1099 } else {
1100 /* About to enter active state, set game gamma */
1101 GetDeviceGammaRamp(hdc, gamma_saved);
1102 SetDeviceGammaRamp(hdc, this->gamma);
1103 }
1104 ReleaseDC(SDL_Window, hdc);
1105 }
1106#endif /* !NO_GAMMA_SUPPORT */
1107}
1108void DIB_QuitGamma(_THIS)
1109{
1110#ifndef NO_GAMMA_SUPPORT
1111 if ( gamma_saved ) {
1112 /* Restore the original gamma if necessary */
1113 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
1114 HDC hdc;
1115
1116 hdc = GetDC(SDL_Window);
1117 SetDeviceGammaRamp(hdc, gamma_saved);
1118 ReleaseDC(SDL_Window, hdc);
1119 }
1120
1121 /* Free the saved gamma memory */
1122 SDL_free(gamma_saved);
1123 gamma_saved = 0;
1124 }
1125#endif /* !NO_GAMMA_SUPPORT */
1126}
1127
1128int DIB_SetGammaRamp(_THIS, Uint16 *ramp)
1129{
1130#ifdef NO_GAMMA_SUPPORT
1131 SDL_SetError("SDL compiled without gamma ramp support");
1132 return -1;
1133#else
1134 HDC hdc;
1135 BOOL succeeded;
1136
1137 /* Set the ramp for the display */
1138 if ( ! gamma_saved ) {
1139 gamma_saved = (WORD *)SDL_malloc(3*256*sizeof(*gamma_saved));
1140 if ( ! gamma_saved ) {
1141 SDL_OutOfMemory();
1142 return -1;
1143 }
1144 hdc = GetDC(SDL_Window);
1145 GetDeviceGammaRamp(hdc, gamma_saved);
1146 ReleaseDC(SDL_Window, hdc);
1147 }
1148 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
1149 hdc = GetDC(SDL_Window);
1150 succeeded = SetDeviceGammaRamp(hdc, ramp);
1151 ReleaseDC(SDL_Window, hdc);
1152 } else {
1153 succeeded = TRUE;
1154 }
1155 return succeeded ? 0 : -1;
1156#endif /* !NO_GAMMA_SUPPORT */
1157}
1158
1159int DIB_GetGammaRamp(_THIS, Uint16 *ramp)
1160{
1161#ifdef NO_GAMMA_SUPPORT
1162 SDL_SetError("SDL compiled without gamma ramp support");
1163 return -1;
1164#else
1165 HDC hdc;
1166 BOOL succeeded;
1167
1168 /* Get the ramp from the display */
1169 hdc = GetDC(SDL_Window);
1170 succeeded = GetDeviceGammaRamp(hdc, ramp);
1171 ReleaseDC(SDL_Window, hdc);
1172 return succeeded ? 0 : -1;
1173#endif /* !NO_GAMMA_SUPPORT */
1174}
1175
1176void DIB_VideoQuit(_THIS)
1177{
1178 int i, j;
1179
1180 /* Destroy the window and everything associated with it */
1181 if ( SDL_Window ) {
1182 /* Delete the screen bitmap (also frees screen->pixels) */
1183 if ( this->screen ) {
1184 if ( grab_palette ) {
1185 DIB_ReleaseStaticColors(SDL_Window);
1186 }
1187#ifndef NO_CHANGEDISPLAYSETTINGS
1188 if ( this->screen->flags & SDL_FULLSCREEN ) {
1189 ChangeDisplaySettings(NULL, 0);
1190 ShowWindow(SDL_Window, SW_HIDE);
1191 }
1192#endif
1193 if ( this->screen->flags & SDL_OPENGL ) {
1194 WIN_GL_ShutDown(this);
1195 }
1196 this->screen->pixels = NULL;
1197 }
1198 if ( screen_pal != NULL ) {
1199 DeleteObject(screen_pal);
1200 screen_pal = NULL;
1201 }
1202 if ( screen_logpal != NULL ) {
1203 SDL_free(screen_logpal);
1204 screen_logpal = NULL;
1205 }
1206 if ( screen_bmp ) {
1207 DeleteObject(screen_bmp);
1208 screen_bmp = NULL;
1209 }
1210 if ( screen_icn ) {
1211 DestroyIcon(screen_icn);
1212 screen_icn = NULL;
1213 }
1214 DIB_QuitGamma(this);
1215 DIB_DestroyWindow(this);
1216
1217 SDL_Window = NULL;
1218
1219#if defined(_WIN32_WCE)
1220
1221// Unload wince aygshell library to prevent leak
1222 if( aygshell )
1223 {
1224 FreeLibrary(aygshell);
1225 aygshell = NULL;
1226 }
1227#endif
1228 }
1229
1230 for ( i=0; i < SDL_arraysize(SDL_modelist); ++i ) {
1231 if ( !SDL_modelist[i] ) {
1232 continue;
1233 }
1234 for ( j=0; SDL_modelist[i][j]; ++j ) {
1235 SDL_free(SDL_modelist[i][j]);
1236 }
1237 SDL_free(SDL_modelist[i]);
1238 SDL_modelist[i] = NULL;
1239 SDL_nummodes[i] = 0;
1240 }
1241}
1242
1243/* Exported for the windows message loop only */
1244static void DIB_GrabStaticColors(HWND window)
1245{
1246#if defined(SYSPAL_NOSTATIC) && !defined(_WIN32_WCE)
1247 HDC hdc;
1248
1249 hdc = GetDC(window);
1250 SetSystemPaletteUse(hdc, SYSPAL_NOSTATIC256);
1251 if ( GetSystemPaletteUse(hdc) != SYSPAL_NOSTATIC256 ) {
1252 SetSystemPaletteUse(hdc, SYSPAL_NOSTATIC);
1253 }
1254 ReleaseDC(window, hdc);
1255#endif
1256}
1257static void DIB_ReleaseStaticColors(HWND window)
1258{
1259#if defined(SYSPAL_NOSTATIC) && !defined(_WIN32_WCE)
1260 HDC hdc;
1261
1262 hdc = GetDC(window);
1263 SetSystemPaletteUse(hdc, SYSPAL_STATIC);
1264 ReleaseDC(window, hdc);
1265#endif
1266}
1267static void DIB_Activate(_THIS, BOOL active, BOOL minimized)
1268{
1269 if ( grab_palette ) {
1270 if ( !active ) {
1271 DIB_ReleaseStaticColors(SDL_Window);
1272 DIB_RealizePalette(this);
1273 } else if ( !minimized ) {
1274 DIB_GrabStaticColors(SDL_Window);
1275 DIB_RealizePalette(this);
1276 }
1277 }
1278}
1279static void DIB_RealizePalette(_THIS)
1280{
1281 if ( screen_pal != NULL ) {
1282 HDC hdc;
1283
1284 hdc = GetDC(SDL_Window);
1285#ifndef _WIN32_WCE
1286 UnrealizeObject(screen_pal);
1287#endif
1288 SelectPalette(hdc, screen_pal, FALSE);
1289 if ( RealizePalette(hdc) ) {
1290 InvalidateRect(SDL_Window, NULL, FALSE);
1291 }
1292 ReleaseDC(SDL_Window, hdc);
1293 }
1294}
1295static void DIB_PaletteChanged(_THIS, HWND window)
1296{
1297 if ( window != SDL_Window ) {
1298 DIB_RealizePalette(this);
1299 }
1300}
1301
1302/* Exported for the windows message loop only */
1303static void DIB_WinPAINT(_THIS, HDC hdc)
1304{
1305 HDC mdc;
1306
1307 if ( screen_pal ) {
1308 SelectPalette(hdc, screen_pal, FALSE);
1309 }
1310 mdc = CreateCompatibleDC(hdc);
1311 SelectObject(mdc, screen_bmp);
1312 BitBlt(hdc, 0, 0, SDL_VideoSurface->w, SDL_VideoSurface->h,
1313 mdc, 0, 0, SRCCOPY);
1314 DeleteDC(mdc);
1315}
1316
1317/* Stub in case DirectX isn't available */
1318#if !SDL_AUDIO_DRIVER_DSOUND
1319void DX5_SoundFocus(HWND hwnd)
1320{
1321 return;
1322}
1323#endif
diff --git a/apps/plugins/sdl/src/video/windib/SDL_dibvideo.h b/apps/plugins/sdl/src/video/windib/SDL_dibvideo.h
deleted file mode 100644
index 48b1943a9a..0000000000
--- a/apps/plugins/sdl/src/video/windib/SDL_dibvideo.h
+++ /dev/null
@@ -1,59 +0,0 @@
1/*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2012 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#ifndef _SDL_dibvideo_h
25#define _SDL_dibvideo_h
26
27#define WIN32_LEAN_AND_MEAN
28#include <windows.h>
29
30
31/* Private display data */
32struct DibInfo {
33 HBITMAP screen_bmp;
34 HPALETTE screen_pal;
35 LOGPALETTE *screen_logpal;
36 BOOL grab_palette;
37
38#define NUM_MODELISTS 4 /* 8, 16, 24, and 32 bits-per-pixel */
39 int SDL_nummodes[NUM_MODELISTS];
40 SDL_Rect **SDL_modelist[NUM_MODELISTS];
41
42#ifdef _WIN32_WCE
43 int supportRotation; /* for Pocket PC devices */
44 DWORD origRotation; /* for Pocket PC devices */
45#endif
46
47 /* Screensaver settings */
48 int allow_screensaver;
49};
50/* Old variable names */
51#define screen_bmp (this->hidden->dibInfo->screen_bmp)
52#define screen_pal (this->hidden->dibInfo->screen_pal)
53#define screen_logpal (this->hidden->dibInfo->screen_logpal)
54#define grab_palette (this->hidden->dibInfo->grab_palette)
55#define SDL_nummodes (this->hidden->dibInfo->SDL_nummodes)
56#define SDL_modelist (this->hidden->dibInfo->SDL_modelist)
57#define allow_screensaver (this->hidden->dibInfo->allow_screensaver)
58
59#endif /* _SDL_dibvideo_h */
diff --git a/apps/plugins/sdl/src/video/windib/SDL_gapidibvideo.h b/apps/plugins/sdl/src/video/windib/SDL_gapidibvideo.h
deleted file mode 100644
index 64743d1af4..0000000000
--- a/apps/plugins/sdl/src/video/windib/SDL_gapidibvideo.h
+++ /dev/null
@@ -1,56 +0,0 @@
1/*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2012 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#ifndef _SDL_gapidibvideo_h
25#define _SDL_gapidibvideo_h
26
27#define WIN32_LEAN_AND_MEAN
28#include <windows.h>
29
30/* Hidden "this" pointer for the video functions */
31#define _THIS SDL_VideoDevice *this
32
33/* typedef these to be able to define pointers, but still force everybody who
34 * wants to access them to include the corresponding header */
35typedef struct GapiInfo GapiInfo;
36typedef struct DibInfo DibInfo;
37
38/* for PDA */
39typedef enum
40{
41 SDL_ORIENTATION_UP,
42 SDL_ORIENTATION_DOWN,
43 SDL_ORIENTATION_LEFT,
44 SDL_ORIENTATION_RIGHT
45} SDL_ScreenOrientation;
46
47/* Private display data shared by gapi and windib*/
48struct SDL_PrivateVideoData {
49 int supportRotation; /* for Pocket PC devices */
50 DWORD origRotation; /* for Pocket PC devices */
51
52 GapiInfo* gapiInfo;
53 DibInfo* dibInfo;
54};
55
56#endif
diff --git a/apps/plugins/sdl/src/video/windib/SDL_vkeys.h b/apps/plugins/sdl/src/video/windib/SDL_vkeys.h
deleted file mode 100644
index 53d9246455..0000000000
--- a/apps/plugins/sdl/src/video/windib/SDL_vkeys.h
+++ /dev/null
@@ -1,75 +0,0 @@
1/*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2012 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
23#ifndef VK_0
24#define VK_0 '0'
25#define VK_1 '1'
26#define VK_2 '2'
27#define VK_3 '3'
28#define VK_4 '4'
29#define VK_5 '5'
30#define VK_6 '6'
31#define VK_7 '7'
32#define VK_8 '8'
33#define VK_9 '9'
34#define VK_A 'A'
35#define VK_B 'B'
36#define VK_C 'C'
37#define VK_D 'D'
38#define VK_E 'E'
39#define VK_F 'F'
40#define VK_G 'G'
41#define VK_H 'H'
42#define VK_I 'I'
43#define VK_J 'J'
44#define VK_K 'K'
45#define VK_L 'L'
46#define VK_M 'M'
47#define VK_N 'N'
48#define VK_O 'O'
49#define VK_P 'P'
50#define VK_Q 'Q'
51#define VK_R 'R'
52#define VK_S 'S'
53#define VK_T 'T'
54#define VK_U 'U'
55#define VK_V 'V'
56#define VK_W 'W'
57#define VK_X 'X'
58#define VK_Y 'Y'
59#define VK_Z 'Z'
60#endif /* VK_0 */
61
62/* These keys haven't been defined, but were experimentally determined */
63#define VK_SEMICOLON 0xBA
64#define VK_EQUALS 0xBB
65#define VK_COMMA 0xBC
66#define VK_MINUS 0xBD
67#define VK_PERIOD 0xBE
68#define VK_SLASH 0xBF
69#define VK_GRAVE 0xC0
70#define VK_LBRACKET 0xDB
71#define VK_BACKSLASH 0xDC
72#define VK_RBRACKET 0xDD
73#define VK_APOSTROPHE 0xDE
74#define VK_BACKTICK 0xDF
75#define VK_OEM_102 0xE2
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-30 21:30:11 +0000