Mercurial > sdl-ios-xcode

comparison src/video/os2fslib/SDL_os2fslib.c @ 1190:173c063d4f55

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
OS/2 port! This was mostly, if not entirely, written by "Doodle" and "Caetano": doodle@scenergy.dfmk.hu daniel@caetano.eng.br --ryan.
author Ryan C. Gordon <icculus@icculus.org>
date Wed, 23 Nov 2005 07:29:56 +0000
parents
children 3692456e7b0f
comparison
equal deleted inserted replaced
1189:c96b326b90ba 1190:173c063d4f55
1 /*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2004 Sam Lantinga
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 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 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with this library; if not, write to the Free
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
19 Sam Lantinga
20 slouken@libsdl.org
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <process.h>
27 #include <time.h>
28
29 #include "SDL.h"
30 #include "SDL_error.h"
31 #include "SDL_video.h"
32 #include "SDL_mouse.h"
33 #include "SDL_sysvideo.h"
34 #include "SDL_pixels_c.h"
35 #include "SDL_events_c.h"
36
37 #include "SDL_os2fslib.h"
38
39 static ULONG ulFCFToUse =
40 FCF_TITLEBAR |
41 FCF_SYSMENU |
42 FCF_MINBUTTON |
43 FCF_MAXBUTTON |
44 FCF_NOBYTEALIGN |
45 FCF_SIZEBORDER |
46 FCF_TASKLIST;
47
48 static int bMouseCaptured = 0;
49 static int bMouseCapturable = 0;
50 static HPOINTER hptrGlobalPointer = NULL;
51 static HPOINTER hptrCurrentIcon = NULL;
52 static int iWindowSizeX = 320;
53 static int iWindowSizeY = 200;
54 static int bWindowResized = 0;
55
56 #pragma pack(1)
57 typedef struct BMPINFO
58 {
59 BITMAPINFO;
60 RGB clr;
61 } BMPINFO, *PBMPINFO;
62 #pragma pack()
63
64
65 // Backdoors:
66 DECLSPEC void SDLCALL SDL_OS2FSLIB_SetFCFToUse(ULONG ulFCF)
67 {
68 ulFCFToUse = ulFCF;
69 }
70
71 // Configuration defines:
72
73 // We have to report empty alpha mask, otherwise SDL will select
74 // alpha blitters, and this will have unwanted results, as we don't
75 // support alpha channel in FSLib yet.
76 #define REPORT_EMPTY_ALPHA_MASK
77
78 // Experimental: Move every FSLib_BitBlt() call into window message
79 // processing function.
80 // This may fix dirt left on desktop. Or not.
81 //#define BITBLT_IN_WINMESSAGEPROC
82
83 // Experimental-2: Use WinLockWindowUpdate() in around bitblts!
84 // This is not enabled, because it seems to cause more problems
85 // than good.
86 //#define USE_WINLOCKWINDOWUPDATE_AROUND_BITBLTS
87
88 // Use the following to show resized image instead of black stuff
89 // even if the surface is resizable.
90 //#define RESIZE_EVEN_IF_RESIZABLE
91
92 /* The translation table from a VK keysym to a SDL keysym */
93 static SDLKey HWScanKeyMap[256];
94 static SDL_keysym *TranslateKey(int vkey, int chcode, int scancode, SDL_keysym *keysym, int iPressed);
95 static int iShiftIsPressed;
96
97 #ifdef BITBLT_IN_WINMESSAGEPROC
98 #define WM_UPDATERECTSREQUEST WM_USER+50
99 #endif
100
101 #ifdef USE_WINLOCKWINDOWUPDATE_AROUND_BITBLTS
102 #define FSLIB_BITBLT(hwnd, buffer, top, left, width, height) \
103 { \
104 WinLockWindowUpdate(HWND_DESKTOP, HWND_DESKTOP); \
105 FSLib_BitBlt(hwnd, buffer, top, left, width, height); \
106 WinLockWindowUpdate(HWND_DESKTOP, NULL); \
107 }
108 #else
109 #define FSLIB_BITBLT(hwnd, buffer, top, left, width, height) \
110 FSLib_BitBlt(hwnd, buffer, top, left, width, height);
111 #endif
112
113 /////////////////////////////////////////////////////////////////////
114 //
115 // SetAccessableWindowPos
116 //
117 // Same as WinSetWindowPos(), but takes care for the window to be
118 // always on the screen, the titlebar will be accessable everytime.
119 //
120 /////////////////////////////////////////////////////////////////////
121 static BOOL SetAccessableWindowPos(HWND hwnd, HWND hwndInsertBehind,
122 LONG x, LONG y,
123 LONG cx, LONG cy,
124 ULONG fl)
125 {
126 SWP swpDesktop, swp;
127 // Get desktop area
128 WinQueryWindowPos(HWND_DESKTOP, &swpDesktop);
129
130 if ((fl & SWP_MOVE) && (fl & SWP_SIZE))
131 {
132 // If both moving and sizing, then change size and pos now!!
133 if (x+cx>swpDesktop.cx)
134 x = swpDesktop.cx - cx;
135 if (x<0)
136 x = 0;
137 if (y<0)
138 y = 0;
139 if (y+cy>swpDesktop.cy)
140 y = swpDesktop.cy - cy;
141 return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
142 } else
143 if (fl & SWP_MOVE)
144 {
145 // Just moving
146 WinQueryWindowPos(hwnd, &swp);
147 if (x+swp.cx>swpDesktop.cx)
148 x = swpDesktop.cx - swp.cx;
149 if (x<0)
150 x = 0;
151 if (y<0)
152 y = 0;
153 if (y+swp.cy>swpDesktop.cy)
154 y = swpDesktop.cy - swp.cy;
155 return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
156 } else
157 if (fl & SWP_SIZE)
158 {
159 // Just sizing
160 WinQueryWindowPos(hwnd, &swp);
161 x = swp.x;
162 y = swp.y;
163 if (x+cx>swpDesktop.cx)
164 x = swpDesktop.cx - cx;
165 if (x<0)
166 x = 0;
167 if (y<0)
168 y = 0;
169 if (y+cy>swpDesktop.cy)
170 y = swpDesktop.cy - cy;
171 return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl | SWP_MOVE);
172 } else
173 return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
174 }
175
176 /////////////////////////////////////////////////////////////////////
177 //
178 // TranslateKey
179 //
180 // This creates SDL Keycodes from VK_ and hardware scan codes
181 //
182 /////////////////////////////////////////////////////////////////////
183 static SDL_keysym *TranslateKey(int vkey, int chcode, int scancode, SDL_keysym *keysym, int iPressed)
184 {
185 keysym->scancode = (unsigned char) scancode;
186 keysym->mod = KMOD_NONE;
187 keysym->unicode = 0;
188
189 if (iPressed && SDL_TranslateUNICODE)
190 {
191 // TODO:
192 // Implement real unicode conversion!
193 if (chcode)
194 keysym->unicode = chcode;
195 else
196 keysym->unicode = vkey;
197 }
198
199 keysym->sym = HWScanKeyMap[scancode];
200
201 // Now stuffs based on state of shift key(s)!
202 if (vkey == VK_SHIFT)
203 {
204 iShiftIsPressed = iPressed;
205 }
206
207 if ((iShiftIsPressed) && (SDL_TranslateUNICODE))
208 {
209 // Change syms, if Unicode stuff is required
210 // I think it's silly, but it's SDL...
211 switch (keysym->sym)
212 {
213 case SDLK_BACKQUOTE:
214 keysym->sym = '~';
215 break;
216 case SDLK_1:
217 keysym->sym = SDLK_EXCLAIM;
218 break;
219 case SDLK_2:
220 keysym->sym = SDLK_AT;
221 break;
222 case SDLK_3:
223 keysym->sym = SDLK_HASH;
224 break;
225 case SDLK_4:
226 keysym->sym = SDLK_DOLLAR;
227 break;
228 case SDLK_5:
229 keysym->sym = '%';
230 break;
231 case SDLK_6:
232 keysym->sym = SDLK_CARET;
233 break;
234 case SDLK_7:
235 keysym->sym = SDLK_AMPERSAND;
236 break;
237 case SDLK_8:
238 keysym->sym = SDLK_ASTERISK;
239 break;
240 case SDLK_9:
241 keysym->sym = SDLK_LEFTPAREN;
242 break;
243 case SDLK_0:
244 keysym->sym = SDLK_RIGHTPAREN;
245 break;
246 case SDLK_MINUS:
247 keysym->sym = SDLK_UNDERSCORE;
248 break;
249 case SDLK_PLUS:
250 keysym->sym = SDLK_EQUALS;
251 break;
252
253 case SDLK_LEFTBRACKET:
254 keysym->sym = '{';
255 break;
256 case SDLK_RIGHTBRACKET:
257 keysym->sym = '}';
258 break;
259
260 case SDLK_SEMICOLON:
261 keysym->sym = SDLK_COLON;
262 break;
263 case SDLK_QUOTE:
264 keysym->sym = SDLK_QUOTEDBL;
265 break;
266 case SDLK_BACKSLASH:
267 keysym->sym = '|';
268 break;
269
270 case SDLK_COMMA:
271 keysym->sym = SDLK_LESS;
272 break;
273 case SDLK_PERIOD:
274 keysym->sym = SDLK_GREATER;
275 break;
276 case SDLK_SLASH:
277 keysym->sym = SDLK_QUESTION;
278 break;
279
280 default:
281 break;
282 }
283 }
284 return keysym;
285 }
286
287 #define CONVERTMOUSEPOSITION() \
288 /* We have to inverse the mouse position, because every non-os/2 system */ \
289 /* has a coordinate system where the (0;0) is the top-left corner, */ \
290 /* while on os/2 it's the bottom left corner! */ \
291 if (FSLib_QueryFSMode(hwnd)) \
292 { \
293 /* We're in FS mode! */ \
294 /* In FS mode our window is as big as fullscreen mode, but not necessary as */ \
295 /* big as the source buffer (can be bigger) */ \
296 /* So, limit mouse pos to source buffer size! */ \
297 if (ppts->x<0) ppts->x = 0; \
298 if (ppts->y<0) ppts->y = 0; \
299 if (ppts->x>=pVideo->hidden->SrcBufferDesc.uiXResolution) ppts->x = pVideo->hidden->SrcBufferDesc.uiXResolution-1; \
300 if (ppts->y>=pVideo->hidden->SrcBufferDesc.uiYResolution) ppts->y = pVideo->hidden->SrcBufferDesc.uiYResolution-1; \
301 pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account! */ \
302 ptl.x = ppts->x; ptl.y = ppts->y; \
303 WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1); \
304 WinSetPointerPos(HWND_DESKTOP, ptl.x, ptl.y); \
305 /* Then convert OS/2 position to SDL position */ \
306 ppts->y = pVideo->hidden->SrcBufferDesc.uiYResolution - ppts->y - 1; \
307 } else \
308 { \
309 SWP swpClient; \
310 /* We're in windowed mode! */ \
311 WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient); \
312 /* Convert OS/2 mouse position to SDL position, and also scale it! */ \
313 (ppts->x) = (ppts->x) * pVideo->hidden->SrcBufferDesc.uiXResolution / swpClient.cx; \
314 (ppts->y) = (ppts->y) * pVideo->hidden->SrcBufferDesc.uiYResolution / swpClient.cy; \
315 (ppts->y) = pVideo->hidden->SrcBufferDesc.uiYResolution - (ppts->y) - 1; \
316 }
317
318
319
320 /////////////////////////////////////////////////////////////////////
321 //
322 // WndProc
323 //
324 // This is the message processing window procedure for the
325 // SDLWindowClass, which is the client window in our application.
326 // It handles switching back and away from the app (taking care of
327 // going out and back to and from fullscreen mode), sending keystrokes
328 // and mouse events to where it has to be sent, etc...
329 //
330 /////////////////////////////////////////////////////////////////////
331 static MRESULT EXPENTRY WndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
332 {
333 HPS ps;
334 RECTL rcl;
335 SDL_VideoDevice *pVideo = NULL;
336
337 switch (msg)
338 {
339 case WM_CHAR: // Keypress notification
340 #ifdef DEBUG_BUILD
341 // printf("WM_CHAR\n"); fflush(stdout);
342 #endif
343 pVideo = WinQueryWindowPtr(hwnd, 0);
344 if (pVideo)
345 {
346 /*
347 // We skip repeated keys:
348 if (CHARMSG(&msg)->cRepeat>1)
349 {
350 #ifdef DEBUG_BUILD
351 // printf("Repeated key (%d), skipping...\n", CHARMSG(&msg)->cRepeat); fflush(stdout);
352 #endif
353 return (MRESULT) TRUE;
354 }
355 */
356
357 // If it's not repeated, then let's see if its pressed or released!
358 if (SHORT1FROMMP(mp1) & KC_KEYUP)
359 {
360 // A key has been released
361 SDL_keysym keysym;
362
363 #ifdef DEBUG_BUILD
364 // printf("WM_CHAR, keyup, code is [0x%0x]\n", CHAR4FROMMP(mp1)); // HW scan code
365 #endif
366
367 // One problem is with F1, which gets only the keyup message because
368 // it is a system key.
369 // So, when we get keyup message, we simulate keydown too!
370 // UPDATE:
371 // This problem should be solved now, that the accelerator keys are
372 // disabled for this window!
373 /*
374 if (SHORT2FROMMP(mp2)==VK_F1)
375 {
376 SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(SHORT2FROMMP(mp2), // VK_ code
377 SHORT1FROMMP(mp2), // Character code
378 CHAR4FROMMP(mp1), // HW Scan code
379 &keysym,0));
380 }*/
381
382 SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(SHORT2FROMMP(mp2), // VK_ code
383 SHORT1FROMMP(mp2), // Character code
384 CHAR4FROMMP(mp1), // HW Scan code
385 &keysym,0));
386
387 } else
388 {
389 // A key has been pressed
390 SDL_keysym keysym;
391
392 #ifdef DEBUG_BUILD
393 // printf("WM_CHAR, keydown, code is [0x%0x]\n", CHAR4FROMMP(mp1)); // HW scan code
394 #endif
395 // Check for fastkeys: ALT+HOME to toggle FS mode
396 // ALT+END to close app
397 if ((SHORT1FROMMP(mp1) & KC_ALT) &&
398 (SHORT2FROMMP(mp2) == VK_HOME))
399 {
400 #ifdef DEBUG_BUILD
401 printf(" Pressed ALT+HOME!\n"); fflush(stdout);
402 #endif
403 // Only switch between fullscreen and back if it's not
404 // a resizable mode!
405 if (
406 (!pVideo->hidden->pSDLSurface) ||
407 ((pVideo->hidden->pSDLSurface)
408 && ((pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE)==0)
409 )
410 )
411 FSLib_ToggleFSMode(hwnd, !FSLib_QueryFSMode(hwnd));
412 #ifdef DEBUG_BUILD
413 else
414 printf(" Resizable mode, so discarding ALT+HOME!\n"); fflush(stdout);
415 #endif
416 } else
417 if ((SHORT1FROMMP(mp1) & KC_ALT) &&
418 (SHORT2FROMMP(mp2) == VK_END))
419 {
420 #ifdef DEBUG_BUILD
421 printf(" Pressed ALT+END!\n"); fflush(stdout);
422 #endif
423 // Close window, and get out of loop!
424 // Also send event to SDL application, but we won't
425 // wait for it to be processed!
426 SDL_PrivateQuit();
427 WinPostMsg(hwnd, WM_QUIT, 0, 0);
428 } else
429 {
430
431 SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(SHORT2FROMMP(mp2), // VK_ code
432 SHORT1FROMMP(mp2), // Character code
433 CHAR4FROMMP(mp1), // HW Scan code
434 &keysym,1));
435
436 }
437 }
438 }
439 return (MRESULT) TRUE;
440
441 case WM_TRANSLATEACCEL:
442 {
443 PQMSG pqmsg;
444 pqmsg = (PQMSG) mp1;
445 if (mp1)
446 {
447 if (pqmsg->msg == WM_CHAR)
448 {
449 // WM_CHAR message!
450 // Let's filter the ALT keypress and all other acceleration keys!
451 return (MRESULT) FALSE;
452 }
453 }
454 break; // Default processing (pass to parent until frame control)
455 }
456
457 case WM_PAINT: // Window redraw!
458 #ifdef DEBUG_BUILD
459 printf("WM_PAINT (0x%x)\n", hwnd); fflush(stdout);
460 #endif
461 ps = WinBeginPaint(hwnd,0,&rcl);
462 pVideo = FSLib_GetUserParm(hwnd);
463 if (pVideo)
464 {
465 if (!pVideo->hidden->pSDLSurface)
466 {
467 RECTL rclRect;
468 // So, don't blit now!
469 #ifdef DEBUG_BUILD
470 printf("WM_PAINT : Skipping blit while resizing (Pre!)!\n"); fflush(stdout);
471 #endif
472 WinQueryWindowRect(hwnd, &rclRect);
473 // Fill with black
474 WinFillRect(ps, &rclRect, CLR_BLACK);
475 } else
476 {
477 if (DosRequestMutexSem(pVideo->hidden->hmtxUseSrcBuffer, 1000)==NO_ERROR)
478 {
479 int iTop, iLeft, iWidth, iHeight;
480 int iXScaleError, iYScaleError;
481 int iXScaleError2, iYScaleError2;
482 SWP swp;
483
484 // Re-blit the modified area!
485 // For this, we have to calculate the points, scaled!
486 WinQueryWindowPos(hwnd, &swp);
487 #ifdef DEBUG_BUILD
488 printf("WM_PAINT : WinSize: %d %d, BufSize: %d %d\n",
489 swp.cx,
490 swp.cy,
491 pVideo->hidden->SrcBufferDesc.uiXResolution,
492 pVideo->hidden->SrcBufferDesc.uiYResolution
493 );
494 fflush(stdout);
495 #endif
496
497 #ifndef RESIZE_EVEN_IF_RESIZABLE
498 // But only blit if the window is not resizable, or if
499 // the window is resizable and the source buffer size is the
500 // same as the destination buffer size!
501 if ((!pVideo->hidden->pSDLSurface) ||
502 ((pVideo->hidden->pSDLSurface) &&
503 (pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
504 ((swp.cx != pVideo->hidden->SrcBufferDesc.uiXResolution) ||
505 (swp.cy != pVideo->hidden->SrcBufferDesc.uiYResolution)
506 ) &&
507 (!FSLib_QueryFSMode(hwnd))
508 )
509 )
510 {
511 RECTL rclRect;
512 // Resizable surface and in resizing!
513 // So, don't blit now!
514 #ifdef DEBUG_BUILD
515 printf("WM_PAINT : Skipping blit while resizing!\n"); fflush(stdout);
516 #endif
517 WinQueryWindowRect(hwnd, &rclRect);
518 // Fill with black
519 WinFillRect(ps, &rclRect, CLR_BLACK);
520 } else
521 #endif
522 {
523
524 iXScaleError = (pVideo->hidden->SrcBufferDesc.uiXResolution-1) / swp.cx;
525 iYScaleError = (pVideo->hidden->SrcBufferDesc.uiYResolution-1) / swp.cy;
526 if (iXScaleError<0) iXScaleError = 0;
527 if (iYScaleError<0) iYScaleError = 0;
528 iXScaleError2 = (swp.cx-1)/(pVideo->hidden->SrcBufferDesc.uiXResolution);
529 iYScaleError2 = (swp.cy-1)/(pVideo->hidden->SrcBufferDesc.uiYResolution);
530 if (iXScaleError2<0) iXScaleError2 = 0;
531 if (iYScaleError2<0) iYScaleError2 = 0;
532
533 iTop = (swp.cy - rcl.yTop) * pVideo->hidden->SrcBufferDesc.uiYResolution / swp.cy - iYScaleError;
534 iLeft = rcl.xLeft * pVideo->hidden->SrcBufferDesc.uiXResolution / swp.cx - iXScaleError;
535 iWidth = ((rcl.xRight-rcl.xLeft) * pVideo->hidden->SrcBufferDesc.uiXResolution + swp.cx-1)
536 / swp.cx + 2*iXScaleError;
537 iHeight = ((rcl.yTop-rcl.yBottom) * pVideo->hidden->SrcBufferDesc.uiYResolution + swp.cy-1)
538 / swp.cy + 2*iYScaleError;
539
540 iWidth+=iXScaleError2;
541 iHeight+=iYScaleError2;
542
543 if (iTop<0) iTop = 0;
544 if (iLeft<0) iLeft = 0;
545 if (iTop+iHeight>pVideo->hidden->SrcBufferDesc.uiYResolution) iHeight = pVideo->hidden->SrcBufferDesc.uiYResolution-iTop;
546 if (iLeft+iWidth>pVideo->hidden->SrcBufferDesc.uiXResolution) iWidth = pVideo->hidden->SrcBufferDesc.uiXResolution-iLeft;
547
548 #ifdef DEBUG_BUILD
549 printf("WM_PAINT : BitBlt: %d %d -> %d %d (Buf %d x %d)\n",
550 iTop, iLeft, iWidth, iHeight,
551 pVideo->hidden->SrcBufferDesc.uiXResolution,
552 pVideo->hidden->SrcBufferDesc.uiYResolution
553 );
554 fflush(stdout);
555 #endif
556
557 FSLIB_BITBLT(hwnd, pVideo->hidden->pchSrcBuffer, iTop, iLeft, iWidth, iHeight);
558 }
559
560 DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
561 }
562 }
563 }
564 #ifdef DEBUG_BUILD
565 else
566 {
567 printf("WM_PAINT : No pVideo!\n"); fflush(stdout);
568 }
569 #endif
570 WinEndPaint(ps);
571 #ifdef DEBUG_BUILD
572 printf("WM_PAINT : Done.\n");
573 fflush(stdout);
574 #endif
575 return 0;
576
577 case WM_SIZE:
578 {
579 #ifdef DEBUG_BUILD
580 printf("WM_SIZE : (%d %d)\n",
581 SHORT1FROMMP(mp2), SHORT2FROMMP(mp2)); fflush(stdout);
582 #endif
583 iWindowSizeX = SHORT1FROMMP(mp2);
584 iWindowSizeY = SHORT2FROMMP(mp2);
585 bWindowResized = 1;
586
587 // Make sure the window will be redrawn
588 WinInvalidateRegion(hwnd, NULL, TRUE);
589 }
590 break;
591
592 case WM_FSLIBNOTIFICATION:
593 #ifdef DEBUG_BUILD
594 printf("WM_FSLIBNOTIFICATION\n"); fflush(stdout);
595 #endif
596 if ((int)mp1 == FSLN_TOGGLEFSMODE)
597 {
598 // FS mode changed, reblit image!
599 pVideo = FSLib_GetUserParm(hwnd);
600 if (pVideo)
601 {
602 if (!pVideo->hidden->pSDLSurface)
603 {
604 // Resizable surface and in resizing!
605 // So, don't blit now!
606 #ifdef DEBUG_BUILD
607 printf("WM_FSLIBNOTIFICATION : Can not blit if there is no surface, doing nothing.\n"); fflush(stdout);
608 #endif
609 } else
610 {
611 if (DosRequestMutexSem(pVideo->hidden->hmtxUseSrcBuffer, 1000)==NO_ERROR)
612 {
613 if (pVideo->hidden->pSDLSurface)
614 {
615 #ifndef RESIZE_EVEN_IF_RESIZABLE
616 SWP swp;
617
618 // But only blit if the window is not resizable, or if
619 // the window is resizable and the source buffer size is the
620 // same as the destination buffer size!
621 WinQueryWindowPos(hwnd, &swp);
622 if ((!pVideo->hidden->pSDLSurface) ||
623 (
624 (pVideo->hidden->pSDLSurface) &&
625 (pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
626 ((swp.cx != pVideo->hidden->SrcBufferDesc.uiXResolution) ||
627 (swp.cy != pVideo->hidden->SrcBufferDesc.uiYResolution)
628 ) &&
629 (!FSLib_QueryFSMode(hwnd))
630 )
631 )
632 {
633 // Resizable surface and in resizing!
634 // So, don't blit now!
635 #ifdef DEBUG_BUILD
636 printf("WM_FSLIBNOTIFICATION : Cannot blit while resizing, doing nothing.\n"); fflush(stdout);
637 #endif
638 } else
639 #endif
640 {
641 #ifdef DEBUG_BUILD
642 printf("WM_FSLIBNOTIFICATION : Blitting!\n"); fflush(stdout);
643 #endif
644 FSLIB_BITBLT(hwnd, pVideo->hidden->pchSrcBuffer,
645 0, 0,
646 pVideo->hidden->SrcBufferDesc.uiXResolution,
647 pVideo->hidden->SrcBufferDesc.uiYResolution);
648 }
649 }
650 #ifdef DEBUG_BUILD
651 else
652 printf("WM_FSLIBNOTIFICATION : No public surface!\n"); fflush(stdout);
653 #endif
654
655 DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
656 }
657 }
658 }
659 }
660 return (MPARAM) 1;
661
662 case WM_ACTIVATE:
663 #ifdef DEBUG_BUILD
664 printf("WM_ACTIVATE\n"); fflush(stdout);
665 #endif
666
667 pVideo = FSLib_GetUserParm(hwnd);
668 if (pVideo)
669 {
670 pVideo->hidden->fInFocus = (int) mp1;
671 if (pVideo->hidden->fInFocus)
672 {
673 // Went into focus
674 if ((pVideo->hidden->iMouseVisible) && (!bMouseCaptured))
675 WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
676 else
677 WinSetPointer(HWND_DESKTOP, NULL);
678
679 if (bMouseCapturable)
680 {
681 // Re-capture the mouse, if we captured it before!
682 WinSetCapture(HWND_DESKTOP, hwnd);
683 bMouseCaptured = 1;
684 {
685 SWP swpClient;
686 POINTL ptl;
687 // Center the mouse to the middle of the window!
688 WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
689 ptl.x = 0; ptl.y = 0;
690 WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
691 pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account! */
692 WinSetPointerPos(HWND_DESKTOP,
693 ptl.x + swpClient.cx/2,
694 ptl.y + swpClient.cy/2);
695 }
696 }
697 } else
698 {
699 // Went out of focus
700 WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
701
702 if (bMouseCaptured)
703 {
704 // Release the mouse
705 WinSetCapture(HWND_DESKTOP, hwnd);
706 bMouseCaptured = 0;
707 }
708 }
709 }
710 #ifdef DEBUG_BUILD
711 printf("WM_ACTIVATE done\n"); fflush(stdout);
712 #endif
713
714 break;
715
716 case WM_BUTTON1DOWN:
717 #ifdef DEBUG_BUILD
718 printf("WM_BUTTON1DOWN\n"); fflush(stdout);
719 #endif
720
721 pVideo = FSLib_GetUserParm(hwnd);
722 if (pVideo)
723 {
724 SDL_PrivateMouseButton(SDL_PRESSED,
725 SDL_BUTTON_LEFT,
726 0, 0); // Don't report mouse movement!
727
728 if (bMouseCapturable)
729 {
730 // We should capture the mouse!
731 if (!bMouseCaptured)
732 {
733 WinSetCapture(HWND_DESKTOP, hwnd);
734 WinSetPointer(HWND_DESKTOP, NULL);
735 bMouseCaptured = 1;
736 {
737 SWP swpClient;
738 POINTL ptl;
739 // Center the mouse to the middle of the window!
740 WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
741 ptl.x = 0; ptl.y = 0;
742 WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
743 pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account! */
744 WinSetPointerPos(HWND_DESKTOP,
745 ptl.x + swpClient.cx/2,
746 ptl.y + swpClient.cy/2);
747 }
748 }
749 }
750 }
751 break;
752 case WM_BUTTON1UP:
753 #ifdef DEBUG_BUILD
754 printf("WM_BUTTON1UP\n"); fflush(stdout);
755 #endif
756 SDL_PrivateMouseButton(SDL_RELEASED,
757 SDL_BUTTON_LEFT,
758 0, 0); // Don't report mouse movement!
759 break;
760 case WM_BUTTON2DOWN:
761 #ifdef DEBUG_BUILD
762 printf("WM_BUTTON2DOWN\n"); fflush(stdout);
763 #endif
764
765 pVideo = FSLib_GetUserParm(hwnd);
766 if (pVideo)
767 {
768 SDL_PrivateMouseButton(SDL_PRESSED,
769 SDL_BUTTON_RIGHT,
770 0, 0); // Don't report mouse movement!
771
772 if (bMouseCapturable)
773 {
774 // We should capture the mouse!
775 if (!bMouseCaptured)
776 {
777 WinSetCapture(HWND_DESKTOP, hwnd);
778 WinSetPointer(HWND_DESKTOP, NULL);
779 bMouseCaptured = 1;
780 {
781 SWP swpClient;
782 POINTL ptl;
783 // Center the mouse to the middle of the window!
784 WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
785 ptl.x = 0; ptl.y = 0;
786 WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
787 pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account! */
788 WinSetPointerPos(HWND_DESKTOP,
789 ptl.x + swpClient.cx/2,
790 ptl.y + swpClient.cy/2);
791 }
792 }
793 }
794
795 }
796 break;
797 case WM_BUTTON2UP:
798 #ifdef DEBUG_BUILD
799 printf("WM_BUTTON2UP\n"); fflush(stdout);
800 #endif
801 SDL_PrivateMouseButton(SDL_RELEASED,
802 SDL_BUTTON_RIGHT,
803 0, 0); // Don't report mouse movement!
804 break;
805 case WM_BUTTON3DOWN:
806 #ifdef DEBUG_BUILD
807 printf("WM_BUTTON3DOWN\n"); fflush(stdout);
808 #endif
809
810 pVideo = FSLib_GetUserParm(hwnd);
811 if (pVideo)
812 {
813 SDL_PrivateMouseButton(SDL_PRESSED,
814 SDL_BUTTON_MIDDLE,
815 0, 0); // Don't report mouse movement!
816
817 if (bMouseCapturable)
818 {
819 // We should capture the mouse!
820 if (!bMouseCaptured)
821 {
822 WinSetCapture(HWND_DESKTOP, hwnd);
823 WinSetPointer(HWND_DESKTOP, NULL);
824 bMouseCaptured = 1;
825 {
826 SWP swpClient;
827 POINTL ptl;
828 // Center the mouse to the middle of the window!
829 WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
830 ptl.x = 0; ptl.y = 0;
831 WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
832 pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account! */
833 WinSetPointerPos(HWND_DESKTOP,
834 ptl.x + swpClient.cx/2,
835 ptl.y + swpClient.cy/2);
836 }
837 }
838 }
839 }
840 break;
841 case WM_BUTTON3UP:
842 #ifdef DEBUG_BUILD
843 printf("WM_BUTTON3UP\n"); fflush(stdout);
844 #endif
845 SDL_PrivateMouseButton(SDL_RELEASED,
846 SDL_BUTTON_MIDDLE,
847 0, 0); // Don't report mouse movement!
848 break;
849 case WM_MOUSEMOVE:
850 #ifdef DEBUG_BUILD
851 // printf("WM_MOUSEMOVE\n"); fflush(stdout);
852 #endif
853
854 pVideo = FSLib_GetUserParm(hwnd);
855 if (pVideo)
856 {
857 if (pVideo->hidden->iSkipWMMOUSEMOVE)
858 {
859 pVideo->hidden->iSkipWMMOUSEMOVE--;
860 } else
861 {
862 POINTS *ppts = (POINTS *) (&mp1);
863 POINTL ptl;
864
865 CONVERTMOUSEPOSITION();
866
867 if (bMouseCaptured)
868 {
869 SWP swpClient;
870 // Send relative mouse position, and re-center the mouse
871 // Reposition the mouse to the center of the screen/window
872 SDL_PrivateMouseMotion(0, // Buttons not changed
873 1, // Relative position
874 ppts->x - (pVideo->hidden->SrcBufferDesc.uiXResolution/2),
875 ppts->y+1 - (pVideo->hidden->SrcBufferDesc.uiYResolution/2));
876
877 WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
878 ptl.x = 0; ptl.y = 0;
879 WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
880 pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account! */
881 // Center the mouse to the middle of the window!
882 WinSetPointerPos(HWND_DESKTOP,
883 ptl.x + swpClient.cx/2,
884 ptl.y + swpClient.cy/2);
885 } else
886 {
887 // Send absolute mouse position
888 SDL_PrivateMouseMotion(0, // Buttons not changed
889 0, // Absolute position
890 ppts->x,
891 ppts->y);
892 }
893 }
894 if ((pVideo->hidden->iMouseVisible) && (!bMouseCaptured))
895 {
896 #ifdef DEBUG_BUILD
897 // printf("WM_MOUSEMOVE : ptr = %p\n", hptrGlobalPointer); fflush(stdout);
898 #endif
899
900 if (hptrGlobalPointer)
901 WinSetPointer(HWND_DESKTOP, hptrGlobalPointer);
902 else
903 WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
904 }
905 else
906 {
907 WinSetPointer(HWND_DESKTOP, NULL);
908 }
909 }
910 #ifdef DEBUG_BUILD
911 // printf("WM_MOUSEMOVE done\n"); fflush(stdout);
912 #endif
913
914 return (MRESULT) FALSE;
915 case WM_CLOSE: // Window close
916 #ifdef DEBUG_BUILD
917 printf("WM_CLOSE\n"); fflush(stdout);
918 #endif
919
920 pVideo = FSLib_GetUserParm(hwnd);
921 if (pVideo)
922 {
923 // Send Quit message to the SDL application!
924 SDL_PrivateQuit();
925 return 0;
926 }
927 break;
928
929 #ifdef BITBLT_IN_WINMESSAGEPROC
930 case WM_UPDATERECTSREQUEST:
931 pVideo = FSLib_GetUserParm(hwnd);
932 if ((pVideo) && (pVideo->hidden->pSDLSurface))
933 {
934 if (DosRequestMutexSem(pVideo->hidden->hmtxUseSrcBuffer, SEM_INDEFINITE_WAIT)==NO_ERROR)
935 {
936 int numrects;
937 SDL_Rect *rects;
938 int i;
939 SWP swp;
940
941 numrects = (int) mp1;
942 rects = (SDL_Rect *) mp2;
943
944 WinQueryWindowPos(hwnd, &swp);
945 #ifndef RESIZE_EVEN_IF_RESIZABLE
946 if ((!pVideo->hidden->pSDLSurface) ||
947 (
948 (pVideo->hidden->pSDLSurface) &&
949 (pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
950 ((swp.cx != pVideo->hidden->SrcBufferDesc.uiXResolution) ||
951 (swp.cy != pVideo->hidden->SrcBufferDesc.uiYResolution)
952 ) &&
953 (!FSLib_QueryFSMode(hwnd))
954 )
955 )
956 {
957 // Resizable surface and in resizing!
958 // So, don't blit now!
959 #ifdef DEBUG_BUILD
960 printf("[WM_UPDATERECTSREQUEST] : Skipping blit while resizing!\n"); fflush(stdout);
961 #endif
962 } else
963 #endif
964 {
965 #ifdef DEBUG_BUILD
966 printf("[WM_UPDATERECTSREQUEST] : Blitting!\n"); fflush(stdout);
967 #endif
968
969 // Blit the changed areas
970 for (i=0; i<numrects; i++)
971 FSLIB_BITBLT(hwnd, pVideo->hidden->pchSrcBuffer,
972 rects[i].y, rects[i].x, rects[i].w, rects[i].h);
973 }
974 DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
975 }
976 }
977 return 0;
978 #endif
979
980 default:
981 #ifdef DEBUG_BUILD
982 printf("Unhandled: %x\n", msg); fflush(stdout);
983 #endif
984
985 break;
986 }
987 // Run the default window procedure for unhandled stuffs
988 return WinDefWindowProc(hwnd, msg, mp1, mp2);
989 }
990
991 /////////////////////////////////////////////////////////////////////
992 //
993 // PMThreadFunc
994 //
995 // This function implements the PM-Thread, which initializes the
996 // application window itself, the DIVE, and start message processing.
997 //
998 /////////////////////////////////////////////////////////////////////
999 int iNumOfPMThreadInstances = 0; // Global!
1000 static void PMThreadFunc(void *pParm)
1001 {
1002 SDL_VideoDevice *pVideo = pParm;
1003 HAB hab;
1004 HMQ hmq;
1005 QMSG msg;
1006 ULONG fcf;
1007
1008 #ifdef DEBUG_BUILD
1009 printf("[PMThreadFunc] : Starting\n"); fflush(stdout);
1010 #endif
1011
1012 iNumOfPMThreadInstances++;
1013
1014 // Initialize PM, create a message queue.
1015
1016 hab=WinInitialize(0);
1017 hmq=WinCreateMsgQueue(hab,0);
1018 if (hmq==0)
1019 {
1020 #ifdef DEBUG_BUILD
1021 printf("[PMThreadFunc] : Could not create message queue!\n");
1022 printf(" It might be that the application using SDL is not a PM app!\n");
1023 fflush(stdout);
1024 #endif
1025 pVideo->hidden->iPMThreadStatus = 2;
1026 } else
1027 {
1028 int rc;
1029 RECTL rectl;
1030
1031 fcf = ulFCFToUse; // Get from global setting
1032
1033 #ifdef DEBUG_BUILD
1034 printf("[PMThreadFunc] : FSLib_CreateWindow()!\n");
1035 fflush(stdout);
1036 #endif
1037
1038 rc = FSLib_CreateWindow(HWND_DESKTOP, 0, &fcf,
1039 "SDL Application",
1040 NULLHANDLE, 0,
1041 &(pVideo->hidden->SrcBufferDesc),
1042 WndProc,
1043 &(pVideo->hidden->hwndClient),
1044 &(pVideo->hidden->hwndFrame));
1045
1046 #ifdef DEBUG_BUILD
1047 printf("[PMThreadFunc] : FSLib_CreateWindow() rc = %d\n", rc);
1048 fflush(stdout);
1049 #endif
1050
1051 if (!rc)
1052 {
1053 #ifdef DEBUG_BUILD
1054 printf("[PMThreadFunc] : Could not create FSLib window!\n");
1055 fflush(stdout);
1056 #endif
1057 pVideo->hidden->iPMThreadStatus = 3;
1058 } else
1059 {
1060 #ifdef DEBUG_BUILD
1061 printf("[PMThreadFunc] : FSLib_AddUserParm()!\n");
1062 fflush(stdout);
1063 #endif
1064
1065 // Store pVideo pointer in window data for client window, so
1066 // it will know the instance to which it belongs to.
1067 FSLib_AddUserParm(pVideo->hidden->hwndClient, pVideo);
1068
1069 // Now set default image width height and fourcc!
1070 #ifdef DEBUG_BUILD
1071 printf("[PMThreadFunc] : SetWindowPos()!\n");
1072 fflush(stdout);
1073 #endif
1074
1075 // Set the position and size of the main window,
1076 // and make it visible!
1077 // Calculate frame window size from client window size
1078 rectl.xLeft = 0;
1079 rectl.yBottom = 0;
1080 rectl.xRight = pVideo->hidden->SrcBufferDesc.uiXResolution; // Noninclusive
1081 rectl.yTop = pVideo->hidden->SrcBufferDesc.uiYResolution; // Noninclusive
1082 WinCalcFrameRect(pVideo->hidden->hwndFrame, &rectl, FALSE);
1083
1084 SetAccessableWindowPos(pVideo->hidden->hwndFrame,
1085 HWND_TOP,
1086 (WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN) - (rectl.xRight-rectl.xLeft)) / 2,
1087 (WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN) - (rectl.yTop-rectl.yBottom)) / 2,
1088 (rectl.xRight-rectl.xLeft),
1089 (rectl.yTop-rectl.yBottom),
1090 SWP_SIZE | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE);
1091
1092 #ifdef DEBUG_BUILD
1093 printf("[PMThreadFunc] : Entering message loop\n"); fflush(stdout);
1094 #endif
1095 pVideo->hidden->iPMThreadStatus = 1;
1096
1097 while (WinGetMsg(hab, (PQMSG)&msg, 0, 0, 0))
1098 WinDispatchMsg(hab, (PQMSG) &msg);
1099
1100 #ifdef DEBUG_BUILD
1101 printf("[PMThreadFunc] : Leaving message loop\n"); fflush(stdout);
1102 #endif
1103 // We should release the captured the mouse!
1104 if (bMouseCaptured)
1105 {
1106 WinSetCapture(HWND_DESKTOP, NULLHANDLE);
1107 bMouseCaptured = 0;
1108 }
1109 // Destroy our window
1110 WinDestroyWindow(pVideo->hidden->hwndFrame); pVideo->hidden->hwndFrame=NULL;
1111 // Show pointer to make sure it will not be left hidden.
1112 WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
1113 WinShowPointer(HWND_DESKTOP, TRUE);
1114 }
1115 // Uninitialize PM
1116 WinDestroyMsgQueue(hmq);
1117 // All done!
1118 pVideo->hidden->iPMThreadStatus = 0;
1119 }
1120 WinTerminate(hab);
1121 /* Commented out, should not be needed anymore, because we send it
1122 from WM_CLOSE.
1123 // Notify SDL that it should really die now...
1124 SDL_PrivateQuit(); SDL_PrivateQuit(); SDL_PrivateQuit(); //... :))
1125 */
1126 #ifdef DEBUG_BUILD
1127 printf("[PMThreadFunc] : End, status is %d!\n", pVideo->hidden->iPMThreadStatus); fflush(stdout);
1128 #endif
1129
1130 iNumOfPMThreadInstances--;
1131
1132 // HACK to prevent zombie and hanging SDL applications, which does not take
1133 // care of closing the window for some reason:
1134 // There are some apps which do not process messages, so do a lot of things
1135 // without noticing that the application should close. To close these,
1136 // I've thought about the following:
1137 // If the window is closed (the execution came here), I wait a bit to
1138 // give time to the app to finish its execution. If it does not, I kill it
1139 // using DosExit(). Brute force, but should work.
1140 if (pVideo->hidden->iPMThreadStatus==0)
1141 {
1142 DosSleep(5000); // Wait 5 secs
1143 // If a new PM thread has been spawned (reinitializing video mode), then all right.
1144 // Otherwise, we have a problem, the app doesn't want to stop. Kill!
1145 if (iNumOfPMThreadInstances==0)
1146 {
1147 #ifdef DEBUG_BUILD
1148 printf("[PMThreadFunc] : It seems that the application haven't terminated itself\n"); fflush(stdout);
1149 printf("[PMThreadFunc] : in the last 5 seconds, so we go berserk.\n"); fflush(stdout);
1150 printf("[PMThreadFunc] : Brute force mode. :) Killing process! Dieeeee...\n"); fflush(stdout);
1151 #endif
1152 DosExit(EXIT_PROCESS, -1);
1153 }
1154 }
1155 _endthread();
1156 }
1157
1158 struct WMcursor
1159 {
1160 HBITMAP hbm;
1161 HPOINTER hptr;
1162 char *pchData;
1163 };
1164
1165 /* Free a window manager cursor */
1166 void os2fslib_FreeWMCursor(_THIS, WMcursor *cursor)
1167 {
1168 if (cursor)
1169 {
1170 GpiDeleteBitmap(cursor->hbm);
1171 WinDestroyPointer(cursor->hptr);
1172 free(cursor->pchData);
1173 free(cursor);
1174 }
1175 }
1176
1177 /* Local functions to convert the SDL cursor mask into OS/2 format */
1178 static void memnot(Uint8 *dst, Uint8 *src, int len)
1179 {
1180 while ( len-- > 0 )
1181 *dst++ = ~*src++;
1182 }
1183 static void memxor(Uint8 *dst, Uint8 *src1, Uint8 *src2, int len)
1184 {
1185 while ( len-- > 0 )
1186 *dst++ = (*src1++)^(*src2++);
1187 }
1188
1189 /* Create a black/white window manager cursor */
1190 WMcursor *os2fslib_CreateWMCursor_Win(_THIS, Uint8 *data, Uint8 *mask,
1191 int w, int h, int hot_x, int hot_y)
1192 {
1193 HPOINTER hptr;
1194 HBITMAP hbm;
1195 BITMAPINFOHEADER bmih;
1196 BMPINFO bmi;
1197 HPS hps;
1198 char *pchTemp;
1199 char *xptr, *aptr;
1200 int maxx, maxy;
1201 int i, run, pad;
1202 WMcursor *pResult;
1203
1204 maxx = WinQuerySysValue(HWND_DESKTOP, SV_CXPOINTER);
1205 maxy = WinQuerySysValue(HWND_DESKTOP, SV_CYPOINTER);
1206
1207 // Check for max size!
1208 if ((w>maxx) || (h>maxy))
1209 return (WMcursor *) NULL;
1210
1211 pResult = (WMcursor *) malloc(sizeof(WMcursor));
1212 if (!pResult) return (WMcursor *) NULL;
1213
1214 pchTemp = (char *) malloc((maxx + 7)/8 * maxy*2);
1215 if (!pchTemp)
1216 {
1217 free(pResult);
1218 return (WMcursor *) NULL;
1219 }
1220
1221 memset(pchTemp, 0, (maxx + 7)/8 * maxy*2);
1222
1223 hps = WinGetPS(_this->hidden->hwndClient);
1224
1225 bmi.cbFix = sizeof(BITMAPINFOHEADER);
1226 bmi.cx = maxx;
1227 bmi.cy = 2*maxy;
1228 bmi.cPlanes = 1;
1229 bmi.cBitCount = 1;
1230 bmi.argbColor[0].bBlue = 0x00;
1231 bmi.argbColor[0].bGreen = 0x00;
1232 bmi.argbColor[0].bRed = 0x00;
1233 bmi.argbColor[1].bBlue = 0x00;
1234 bmi.argbColor[1].bGreen = 0x00;
1235 bmi.argbColor[1].bRed = 0xff;
1236
1237 memset(&bmih, 0, sizeof(BITMAPINFOHEADER));
1238 bmih.cbFix = sizeof(BITMAPINFOHEADER);
1239 bmih.cx = maxx;
1240 bmih.cy = 2*maxy;
1241 bmih.cPlanes = 1;
1242 bmih.cBitCount = 1;
1243
1244 run = (w+7)/8;
1245 pad = (maxx+7)/8 - run;
1246
1247 for (i=0; i<h; i++)
1248 {
1249 xptr = pchTemp + (maxx+7)/8 * (maxy-1-i);
1250 aptr = pchTemp + (maxx+7)/8 * (maxy+maxy-1-i);
1251 memxor(xptr, data, mask, run);
1252 xptr += run;
1253 data += run;
1254 memnot(aptr, mask, run);
1255 mask += run;
1256 aptr += run;
1257 memset(xptr, 0, pad);
1258 xptr += pad;
1259 memset(aptr, ~0, pad);
1260 aptr += pad;
1261 }
1262 pad += run;
1263 for (i=h ; i<maxy; i++ )
1264 {
1265 xptr = pchTemp + (maxx+7)/8 * (maxy-1-i);
1266 aptr = pchTemp + (maxx+7)/8 * (maxy+maxy-1-i);
1267
1268 memset(xptr, 0, (maxx+7)/8);
1269 xptr += (maxx+7)/8;
1270 memset(aptr, ~0, (maxx+7)/8);
1271 aptr += (maxx+7)/8;
1272 }
1273
1274 hbm = GpiCreateBitmap(hps, (PBITMAPINFOHEADER2)&bmih, CBM_INIT, (PBYTE) pchTemp, (PBITMAPINFO2)&bmi);
1275 hptr = WinCreatePointer(HWND_DESKTOP, hbm, TRUE, hot_x, maxy - hot_y - 1);
1276
1277 #ifdef DEBUG_BUILD
1278 printf("HotSpot : %d ; %d\n", hot_x, hot_y);
1279 printf("HPS returned : %x\n", (ULONG)hps);
1280 printf("HBITMAP returned : %x\n", (ULONG)hbm);
1281 printf("HPOINTER returned: %x\n", (ULONG)hptr);
1282 #endif
1283
1284 WinReleasePS(hps);
1285
1286 #ifdef DEBUG_BUILD
1287 printf("[CreateWMCursor] : ptr = %p\n", hptr); fflush(stdout);
1288 #endif
1289
1290 pResult->hptr = hptr;
1291 pResult->hbm = hbm;
1292 pResult->pchData = pchTemp;
1293
1294 #ifdef DEBUG_BUILD
1295 printf("[CreateWMCursor] : ptr = %p return.\n", hptr); fflush(stdout);
1296 #endif
1297
1298 return (WMcursor *) pResult;
1299 }
1300
1301 WMcursor *os2fslib_CreateWMCursor_FS(_THIS, Uint8 *data, Uint8 *mask,
1302 int w, int h, int hot_x, int hot_y)
1303 {
1304 #ifdef DEBUG_BUILD
1305 printf("[CreateWMCursor_FS] : returning pointer NULL\n"); fflush(stdout);
1306 #endif
1307
1308 // In FS mode we'll use software cursor
1309 return (WMcursor *) NULL;
1310 }
1311
1312 /* Show the specified cursor, or hide if cursor is NULL */
1313 int os2fslib_ShowWMCursor(_THIS, WMcursor *cursor)
1314 {
1315 #ifdef DEBUG_BUILD
1316 printf("[ShowWMCursor] : ptr = %p\n", cursor); fflush(stdout);
1317 #endif
1318
1319 if (cursor)
1320 {
1321 WinSetPointer(HWND_DESKTOP, cursor->hptr);
1322 hptrGlobalPointer = cursor->hptr;
1323 _this->hidden->iMouseVisible = 1;
1324 }
1325 else
1326 {
1327 WinSetPointer(HWND_DESKTOP, FALSE);
1328 hptrGlobalPointer = NULL;
1329 _this->hidden->iMouseVisible = 0;
1330 }
1331
1332 #ifdef DEBUG_BUILD
1333 printf("[ShowWMCursor] : ptr = %p, DONE\n", cursor); fflush(stdout);
1334 #endif
1335
1336 return 1;
1337 }
1338
1339 /* Warp the window manager cursor to (x,y)
1340 If NULL, a mouse motion event is posted internally.
1341 */
1342 void os2fslib_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
1343 {
1344 LONG lx, ly;
1345 SWP swpClient;
1346 POINTL ptlPoints;
1347 WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
1348 ptlPoints.x = swpClient.x;
1349 ptlPoints.y = swpClient.y;
1350 WinMapWindowPoints(_this->hidden->hwndFrame, HWND_DESKTOP, &ptlPoints, 1);
1351 lx = ptlPoints.x + (x*swpClient.cx) / _this->hidden->SrcBufferDesc.uiXResolution;
1352 ly = ptlPoints.y + swpClient.cy - ((y*swpClient.cy) / _this->hidden->SrcBufferDesc.uiYResolution) - 1;
1353
1354 SDL_PrivateMouseMotion(0, // Buttons not changed
1355 0, // Absolute position
1356 x,
1357 y);
1358
1359 WinSetPointerPos(HWND_DESKTOP, lx, ly);
1360
1361 }
1362
1363 /* If not NULL, this is called when a mouse motion event occurs */
1364 void os2fslib_MoveWMCursor(_THIS, int x, int y)
1365 {
1366 /*
1367 SDL_Rect rect;
1368
1369 #ifdef DEBUG_BUILD
1370 printf("[MoveWMCursor] : at %d ; %d\n", x, y); fflush(stdout);
1371 #endif
1372
1373 rect.x = x;
1374 rect.y = y;
1375 rect.w = 32;
1376 rect.h = 32;
1377 os2fslib_UpdateRects(_this, 1, &rect);
1378 // TODO!
1379 */
1380 }
1381
1382 /* Determine whether the mouse should be in relative mode or not.
1383 This function is called when the input grab state or cursor
1384 visibility state changes.
1385 If the cursor is not visible, and the input is grabbed, the
1386 driver can place the mouse in relative mode, which may result
1387 in higher accuracy sampling of the pointer motion.
1388 */
1389 void os2fslib_CheckMouseMode(_THIS)
1390 {
1391 }
1392
1393 static void os2fslib_PumpEvents(_THIS)
1394 {
1395 // Notify SDL that if window has been resized!
1396 if (
1397 (_this->hidden->pSDLSurface) &&
1398 (_this->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
1399 (
1400 (_this->hidden->SrcBufferDesc.uiXResolution!=iWindowSizeX) ||
1401 (_this->hidden->SrcBufferDesc.uiYResolution!=iWindowSizeY)
1402 ) &&
1403 (iWindowSizeX>0) &&
1404 (iWindowSizeY>0)
1405 )
1406 {
1407 static time_t prev_time;
1408 time_t curr_time;
1409
1410 curr_time = time(NULL);
1411 if ((difftime(curr_time, prev_time)>=0.25) ||
1412 (bWindowResized))
1413 {
1414 // Make sure we won't flood the event queue with resize events,
1415 // only send them at 250 msecs!
1416 // (or when the window is resized)
1417 #ifdef DEBUG_BUILD
1418 printf("[os2fslib_PumpEvents] : Calling PrivateResize (%d %d).\n",
1419 iWindowSizeX, iWindowSizeY);
1420 fflush(stdout);
1421 #endif
1422 // Tell SDL the new size
1423 SDL_PrivateResize(iWindowSizeX, iWindowSizeY);
1424 prev_time = curr_time;
1425 bWindowResized = 0;
1426 }
1427 }
1428 }
1429
1430 /* We don't actually allow hardware surfaces other than the main one */
1431 static int os2fslib_AllocHWSurface(_THIS, SDL_Surface *surface)
1432 {
1433 return(-1);
1434 }
1435 static void os2fslib_FreeHWSurface(_THIS, SDL_Surface *surface)
1436 {
1437 return;
1438 }
1439
1440 /* We need to wait for vertical retrace on page flipped displays */
1441 static int os2fslib_LockHWSurface(_THIS, SDL_Surface *surface)
1442 {
1443 return(0);
1444 }
1445
1446 static void os2fslib_UnlockHWSurface(_THIS, SDL_Surface *surface)
1447 {
1448 return;
1449 }
1450
1451 static int os2fslib_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
1452 {
1453 printf("[os2fslib_SetColors] : TODO!\n"); fflush(stdout);
1454 // TODO: Implement paletted modes
1455 return(1);
1456 }
1457
1458 static void os2fslib_DestroyIcon(HWND hwndFrame)
1459 {
1460 if (hptrCurrentIcon)
1461 {
1462 WinDestroyPointer(hptrCurrentIcon);
1463 hptrCurrentIcon = NULL;
1464
1465 WinSendMsg(hwndFrame,
1466 WM_SETICON,
1467 NULL,
1468 NULL);
1469 }
1470
1471 }
1472
1473 /* Set the window icon image */
1474 void os2fslib_SetIcon(_THIS, SDL_Surface *icon, Uint8 *mask)
1475 {
1476 HWND hwndFrame;
1477 SDL_Surface *icon_rgb;
1478 HPOINTER hptrIcon;
1479 HBITMAP hbm;
1480 BITMAPINFOHEADER bmih;
1481 BMPINFO bmi;
1482 HPS hps;
1483 char *pchTemp;
1484 char *pptr, *mptr, *dptr, *dmptr;
1485 int maxx, maxy, w, h, x, y;
1486 SDL_Rect bounds;
1487
1488 #ifdef DEBUG_BUILD
1489 printf("[os2fslib_SetIcon] : Creating and setting new icon\n"); fflush(stdout);
1490 #endif
1491
1492 hwndFrame = WinQueryWindow(_this->hidden->hwndClient, QW_PARENT);
1493
1494 // Make sure the old icon resource will be free'd!
1495 os2fslib_DestroyIcon(hwndFrame);
1496
1497 if ((!icon) || (!mask))
1498 return;
1499
1500 w = icon->w;
1501 h = icon->h;
1502
1503 maxx = WinQuerySysValue(HWND_DESKTOP, SV_CXICON);
1504 maxy = WinQuerySysValue(HWND_DESKTOP, SV_CYICON);
1505
1506 // Check for max size!
1507 if ((w>maxx) || (h>maxy))
1508 return;
1509
1510 pchTemp = (char *) malloc(w * h*2 * 4);
1511 if (!pchTemp)
1512 return;
1513
1514 memset(pchTemp, 0, w * h*2 * 4);
1515
1516 // Convert surface to RGB, if it's not RGB yet!
1517 icon_rgb = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
1518 32, 0, 0, 0, 0);
1519 if ( icon_rgb == NULL )
1520 {
1521 free(pchTemp);
1522 return;
1523 }
1524 bounds.x = 0;
1525 bounds.y = 0;
1526 bounds.w = icon->w;
1527 bounds.h = icon->h;
1528 if ( SDL_LowerBlit(icon, &bounds, icon_rgb, &bounds) < 0 )
1529 {
1530 SDL_FreeSurface(icon_rgb);
1531 free(pchTemp);
1532 return;
1533 }
1534
1535 /* Copy pixels upside-down from RGB surface into BMP, masked with the icon mask */
1536
1537 // Pixels
1538 pptr = (char *) (icon_rgb->pixels);
1539 // Mask
1540 mptr = mask;
1541
1542 for (y=0; y<h; y++)
1543 {
1544 unsigned char uchMaskByte;
1545
1546 // Destination
1547 dptr = pchTemp + w*4 * (h-y-1);
1548 // Destination mask
1549 dmptr = pchTemp + w*h*4 + w*4 * (h-y-1);
1550
1551 for (x=0; x<w; x++)
1552 {
1553 if (x%8==0)
1554 {
1555 uchMaskByte = (unsigned char) (*mptr);
1556 mptr++;
1557 } else
1558 uchMaskByte <<= 1;
1559
1560 if (uchMaskByte & 0x80)
1561 {
1562 // Copy RGB
1563 *dptr++ = *pptr++;
1564 *dptr++ = *pptr++;
1565 *dptr++ = *pptr++;
1566 *dptr++ = *pptr++;
1567
1568 *dmptr++ = 0;
1569 *dmptr++ = 0;
1570 *dmptr++ = 0;
1571 *dmptr++ = 0;
1572 } else
1573 {
1574 // Set pixels to fully transparent
1575 *dptr++ = 0; pptr++;
1576 *dptr++ = 0; pptr++;
1577 *dptr++ = 0; pptr++;
1578 *dptr++ = 0; pptr++;
1579
1580 *dmptr++ = 255;
1581 *dmptr++ = 255;
1582 *dmptr++ = 255;
1583 *dmptr++ = 255;
1584 }
1585 }
1586 }
1587
1588 // There is no more need for the RGB surface
1589 SDL_FreeSurface(icon_rgb);
1590
1591 hps = WinGetPS(_this->hidden->hwndClient);
1592
1593 bmi.cbFix = sizeof(BITMAPINFOHEADER);
1594 bmi.cx = w;
1595 bmi.cy = 2*h;
1596 bmi.cPlanes = 1;
1597 bmi.cBitCount = 32;
1598
1599 memset(&bmih, 0, sizeof(BITMAPINFOHEADER));
1600 bmih.cbFix = sizeof(BITMAPINFOHEADER);
1601 bmih.cx = w;
1602 bmih.cy = 2*h;
1603 bmih.cPlanes = 1;
1604 bmih.cBitCount = 32;
1605
1606 hbm = GpiCreateBitmap(hps, (PBITMAPINFOHEADER2)&bmih, CBM_INIT, (PBYTE) pchTemp, (PBITMAPINFO2)&bmi);
1607 hptrIcon = WinCreatePointer(HWND_DESKTOP, hbm, FALSE, 0, 0);
1608
1609 WinReleasePS(hps);
1610
1611 // Free pixel array
1612 free(pchTemp);
1613
1614 // Change icon in frame window
1615 WinSendMsg(hwndFrame,
1616 WM_SETICON,
1617 (MPARAM) hptrIcon,
1618 NULL);
1619
1620 /*
1621 // Change icon in switchlist
1622 // Seems like it's not needed, the WM_SETICON already does it.
1623 {
1624 PID pidFrame;
1625 HSWITCH hswitchFrame;
1626 SWCNTRL swctl;
1627
1628 WinQueryWindowProcess(hwndFrame, &pidFrame, NULL);
1629 hswitchFrame = WinQuerySwitchHandle(hwndFrame, pidFrame);
1630 WinQuerySwitchEntry(hswitchFrame, &swctl);
1631
1632 swctl.hwndIcon = hptrIcon;
1633
1634 WinChangeSwitchEntry(hswitchFrame, &swctl);
1635 }
1636 */
1637
1638 // Store icon handle in global variable
1639 hptrCurrentIcon = hptrIcon;
1640 }
1641
1642 // ------------------------ REAL FUNCTIONS -----------------
1643
1644
1645 static void os2fslib_SetCursorManagementFunctions(_THIS, int iForWindowedMode)
1646 {
1647 if (iForWindowedMode)
1648 {
1649 _this->FreeWMCursor = os2fslib_FreeWMCursor;
1650 _this->CreateWMCursor = os2fslib_CreateWMCursor_Win;
1651 _this->ShowWMCursor = os2fslib_ShowWMCursor;
1652 _this->WarpWMCursor = os2fslib_WarpWMCursor;
1653 _this->MoveWMCursor = os2fslib_MoveWMCursor;
1654 _this->CheckMouseMode = NULL;//os2fslib_CheckMouseMode;
1655 } else
1656 {
1657 // We'll have software mouse cursor in FS mode!
1658 _this->FreeWMCursor = os2fslib_FreeWMCursor;
1659 _this->CreateWMCursor = os2fslib_CreateWMCursor_FS;
1660 _this->ShowWMCursor = os2fslib_ShowWMCursor;
1661 _this->WarpWMCursor = os2fslib_WarpWMCursor;
1662 _this->MoveWMCursor = os2fslib_MoveWMCursor;
1663 _this->CheckMouseMode = NULL;//os2fslib_CheckMouseMode;
1664 }
1665 }
1666
1667 static void os2fslib_InitOSKeymap(_THIS)
1668 {
1669 int i;
1670
1671 iShiftIsPressed = 0;
1672
1673 /* Map the VK and CH keysyms */
1674 for ( i=0; i<=255; ++i )
1675 HWScanKeyMap[i] = SDLK_UNKNOWN;
1676
1677 // First line of keyboard:
1678 HWScanKeyMap[0x1] = SDLK_ESCAPE;
1679 HWScanKeyMap[0x3b] = SDLK_F1;
1680 HWScanKeyMap[0x3c] = SDLK_F2;
1681 HWScanKeyMap[0x3d] = SDLK_F3;
1682 HWScanKeyMap[0x3e] = SDLK_F4;
1683 HWScanKeyMap[0x3f] = SDLK_F5;
1684 HWScanKeyMap[0x40] = SDLK_F6;
1685 HWScanKeyMap[0x41] = SDLK_F7;
1686 HWScanKeyMap[0x42] = SDLK_F8;
1687 HWScanKeyMap[0x43] = SDLK_F9;
1688 HWScanKeyMap[0x44] = SDLK_F10;
1689 HWScanKeyMap[0x57] = SDLK_F11;
1690 HWScanKeyMap[0x58] = SDLK_F12;
1691 HWScanKeyMap[0x5d] = SDLK_PRINT;
1692 HWScanKeyMap[0x46] = SDLK_SCROLLOCK;
1693 HWScanKeyMap[0x5f] = SDLK_PAUSE;
1694
1695 // Second line of keyboard:
1696 HWScanKeyMap[0x29] = SDLK_BACKQUOTE;
1697 HWScanKeyMap[0x2] = SDLK_1;
1698 HWScanKeyMap[0x3] = SDLK_2;
1699 HWScanKeyMap[0x4] = SDLK_3;
1700 HWScanKeyMap[0x5] = SDLK_4;
1701 HWScanKeyMap[0x6] = SDLK_5;
1702 HWScanKeyMap[0x7] = SDLK_6;
1703 HWScanKeyMap[0x8] = SDLK_7;
1704 HWScanKeyMap[0x9] = SDLK_8;
1705 HWScanKeyMap[0xa] = SDLK_9;
1706 HWScanKeyMap[0xb] = SDLK_0;
1707 HWScanKeyMap[0xc] = SDLK_MINUS;
1708 HWScanKeyMap[0xd] = SDLK_EQUALS;
1709 HWScanKeyMap[0xe] = SDLK_BACKSPACE;
1710 HWScanKeyMap[0x68] = SDLK_INSERT;
1711 HWScanKeyMap[0x60] = SDLK_HOME;
1712 HWScanKeyMap[0x62] = SDLK_PAGEUP;
1713 HWScanKeyMap[0x45] = SDLK_NUMLOCK;
1714 HWScanKeyMap[0x5c] = SDLK_KP_DIVIDE;
1715 HWScanKeyMap[0x37] = SDLK_KP_MULTIPLY;
1716 HWScanKeyMap[0x4a] = SDLK_KP_MINUS;
1717
1718 // Third line of keyboard:
1719 HWScanKeyMap[0xf] = SDLK_TAB;
1720 HWScanKeyMap[0x10] = SDLK_q;
1721 HWScanKeyMap[0x11] = SDLK_w;
1722 HWScanKeyMap[0x12] = SDLK_e;
1723 HWScanKeyMap[0x13] = SDLK_r;
1724 HWScanKeyMap[0x14] = SDLK_t;
1725 HWScanKeyMap[0x15] = SDLK_y;
1726 HWScanKeyMap[0x16] = SDLK_u;
1727 HWScanKeyMap[0x17] = SDLK_i;
1728 HWScanKeyMap[0x18] = SDLK_o;
1729 HWScanKeyMap[0x19] = SDLK_p;
1730 HWScanKeyMap[0x1a] = SDLK_LEFTBRACKET;
1731 HWScanKeyMap[0x1b] = SDLK_RIGHTBRACKET;
1732 HWScanKeyMap[0x1c] = SDLK_RETURN;
1733 HWScanKeyMap[0x69] = SDLK_DELETE;
1734 HWScanKeyMap[0x65] = SDLK_END;
1735 HWScanKeyMap[0x67] = SDLK_PAGEDOWN;
1736 HWScanKeyMap[0x47] = SDLK_KP7;
1737 HWScanKeyMap[0x48] = SDLK_KP8;
1738 HWScanKeyMap[0x49] = SDLK_KP9;
1739 HWScanKeyMap[0x4e] = SDLK_KP_PLUS;
1740
1741 // Fourth line of keyboard:
1742 HWScanKeyMap[0x3a] = SDLK_CAPSLOCK;
1743 HWScanKeyMap[0x1e] = SDLK_a;
1744 HWScanKeyMap[0x1f] = SDLK_s;
1745 HWScanKeyMap[0x20] = SDLK_d;
1746 HWScanKeyMap[0x21] = SDLK_f;
1747 HWScanKeyMap[0x22] = SDLK_g;
1748 HWScanKeyMap[0x23] = SDLK_h;
1749 HWScanKeyMap[0x24] = SDLK_j;
1750 HWScanKeyMap[0x25] = SDLK_k;
1751 HWScanKeyMap[0x26] = SDLK_l;
1752 HWScanKeyMap[0x27] = SDLK_SEMICOLON;
1753 HWScanKeyMap[0x28] = SDLK_QUOTE;
1754 HWScanKeyMap[0x2b] = SDLK_BACKSLASH;
1755 HWScanKeyMap[0x4b] = SDLK_KP4;
1756 HWScanKeyMap[0x4c] = SDLK_KP5;
1757 HWScanKeyMap[0x4d] = SDLK_KP6;
1758
1759 // Fifth line of keyboard:
1760 HWScanKeyMap[0x2a] = SDLK_LSHIFT;
1761 HWScanKeyMap[0x56] = SDLK_WORLD_1; // Code 161, letter i' on hungarian keyboard
1762 HWScanKeyMap[0x2c] = SDLK_z;
1763 HWScanKeyMap[0x2d] = SDLK_x;
1764 HWScanKeyMap[0x2e] = SDLK_c;
1765 HWScanKeyMap[0x2f] = SDLK_v;
1766 HWScanKeyMap[0x30] = SDLK_b;
1767 HWScanKeyMap[0x31] = SDLK_n;
1768 HWScanKeyMap[0x32] = SDLK_m;
1769 HWScanKeyMap[0x33] = SDLK_COMMA;
1770 HWScanKeyMap[0x34] = SDLK_PERIOD;
1771 HWScanKeyMap[0x35] = SDLK_SLASH;
1772 HWScanKeyMap[0x36] = SDLK_RSHIFT;
1773 HWScanKeyMap[0x61] = SDLK_UP;
1774 HWScanKeyMap[0x4f] = SDLK_KP1;
1775 HWScanKeyMap[0x50] = SDLK_KP2;
1776 HWScanKeyMap[0x51] = SDLK_KP3;
1777 HWScanKeyMap[0x5a] = SDLK_KP_ENTER;
1778
1779 // Sixth line of keyboard:
1780 HWScanKeyMap[0x1d] = SDLK_LCTRL;
1781 HWScanKeyMap[0x7e] = SDLK_LSUPER; // Windows key
1782 HWScanKeyMap[0x38] = SDLK_LALT;
1783 HWScanKeyMap[0x39] = SDLK_SPACE;
1784 HWScanKeyMap[0x5e] = SDLK_RALT;// Actually, altgr on my keyboard...
1785 HWScanKeyMap[0x7f] = SDLK_RSUPER;
1786 HWScanKeyMap[0x7c] = SDLK_MENU;
1787 HWScanKeyMap[0x5b] = SDLK_RCTRL;
1788 HWScanKeyMap[0x63] = SDLK_LEFT;
1789 HWScanKeyMap[0x66] = SDLK_DOWN;
1790 HWScanKeyMap[0x64] = SDLK_RIGHT;
1791 HWScanKeyMap[0x52] = SDLK_KP0;
1792 HWScanKeyMap[0x53] = SDLK_KP_PERIOD;
1793 }
1794
1795
1796 /* Iconify the window.
1797 This function returns 1 if there is a window manager and the
1798 window was actually iconified, it returns 0 otherwise.
1799 */
1800 int os2fslib_IconifyWindow(_THIS)
1801 {
1802 HAB hab;
1803 HMQ hmq;
1804 ERRORID hmqerror;
1805
1806 // If there is no more window, nothing we can do!
1807 if (_this->hidden->iPMThreadStatus!=1) return 0;
1808
1809 // Cannot do anything in fullscreen mode!
1810 if (FSLib_QueryFSMode(_this->hidden->hwndClient))
1811 return 0;
1812
1813 // Make sure this thread is prepared for using the Presentation Manager!
1814 hab = WinInitialize(0);
1815 hmq = WinCreateMsgQueue(hab,0);
1816 // Remember if there was an error at WinCreateMsgQueue(), because we don't
1817 // want to destroy somebody else's queue later. :)
1818 hmqerror = WinGetLastError(hab);
1819
1820 WinSetWindowPos(_this->hidden->hwndFrame, HWND_TOP,
1821 0, 0, 0, 0, SWP_MINIMIZE);
1822
1823 // Now destroy the message queue, if we've created it!
1824 if (ERRORIDERROR(hmqerror)==0)
1825 WinDestroyMsgQueue(hmq);
1826
1827 return 1;
1828 }
1829
1830 static SDL_GrabMode os2fslib_GrabInput(_THIS, SDL_GrabMode mode)
1831 {
1832 HAB hab;
1833 HMQ hmq;
1834 ERRORID hmqerror;
1835
1836
1837 // If there is no more window, nothing we can do!
1838 if (_this->hidden->iPMThreadStatus!=1)
1839 return SDL_GRAB_OFF;
1840
1841 // Make sure this thread is prepared for using the Presentation Manager!
1842 hab = WinInitialize(0);
1843 hmq = WinCreateMsgQueue(hab,0);
1844 // Remember if there was an error at WinCreateMsgQueue(), because we don't
1845 // want to destroy somebody else's queue later. :)
1846 hmqerror = WinGetLastError(hab);
1847
1848
1849 if (mode == SDL_GRAB_OFF)
1850 {
1851 #ifdef DEBUG_BUILD
1852 printf("[os2fslib_GrabInput] : Releasing mouse\n"); fflush(stdout);
1853 #endif
1854
1855 // Release the mouse
1856 bMouseCapturable = 0;
1857 if (bMouseCaptured)
1858 {
1859 WinSetCapture(HWND_DESKTOP, NULLHANDLE);
1860 bMouseCaptured = 0;
1861 }
1862 } else
1863 {
1864 #ifdef DEBUG_BUILD
1865 printf("[os2fslib_GrabInput] : Capturing mouse\n"); fflush(stdout);
1866 #endif
1867
1868 // Capture the mouse
1869 bMouseCapturable = 1;
1870 if (WinQueryFocus(HWND_DESKTOP) == _this->hidden->hwndClient)
1871 {
1872 WinSetCapture(HWND_DESKTOP, _this->hidden->hwndClient);
1873 bMouseCaptured = 1;
1874 {
1875 SWP swpClient;
1876 POINTL ptl;
1877 // Center the mouse to the middle of the window!
1878 WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
1879 ptl.x = 0; ptl.y = 0;
1880 WinMapWindowPoints(_this->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
1881 _this->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account! */
1882 WinSetPointerPos(HWND_DESKTOP,
1883 ptl.x + swpClient.cx/2,
1884 ptl.y + swpClient.cy/2);
1885 }
1886 }
1887 }
1888
1889 // Now destroy the message queue, if we've created it!
1890 if (ERRORIDERROR(hmqerror)==0)
1891 WinDestroyMsgQueue(hmq);
1892
1893 return mode;
1894 }
1895
1896 /* Set the title and icon text */
1897 static void os2fslib_SetCaption(_THIS, const char *title, const char *icon)
1898 {
1899 HAB hab;
1900 HMQ hmq;
1901 ERRORID hmqerror;
1902
1903 // If there is no more window, nothing we can do!
1904 if (_this->hidden->iPMThreadStatus!=1) return;
1905
1906 // Make sure this thread is prepared for using the Presentation Manager!
1907 hab = WinInitialize(0);
1908 hmq = WinCreateMsgQueue(hab,0);
1909 // Remember if there was an error at WinCreateMsgQueue(), because we don't
1910 // want to destroy somebody else's queue later. :)
1911 hmqerror = WinGetLastError(hab);
1912
1913 WinSetWindowText(_this->hidden->hwndFrame, (char *) title);
1914
1915 // Now destroy the message queue, if we've created it!
1916 if (ERRORIDERROR(hmqerror)==0)
1917 WinDestroyMsgQueue(hmq);
1918 }
1919
1920 static int os2fslib_ToggleFullScreen(_THIS, int on)
1921 {
1922 #ifdef DEBUG_BUILD
1923 printf("[os2fslib_ToggleFullScreen] : %d\n", on); fflush(stdout);
1924 #endif
1925 // If there is no more window, nothing we can do!
1926 if (_this->hidden->iPMThreadStatus!=1) return 0;
1927
1928 FSLib_ToggleFSMode(_this->hidden->hwndClient, on);
1929 /* Cursor manager functions to Windowed/FS mode*/
1930 os2fslib_SetCursorManagementFunctions(_this, !on);
1931 return 1;
1932 }
1933
1934 /* This is called after the video mode has been set, to get the
1935 initial mouse state. It should queue events as necessary to
1936 properly represent the current mouse focus and position.
1937 */
1938 static void os2fslib_UpdateMouse(_THIS)
1939 {
1940 POINTL ptl;
1941 HAB hab;
1942 HMQ hmq;
1943 ERRORID hmqerror;
1944 SWP swpClient;
1945
1946 // If there is no more window, nothing we can do!
1947 if (_this->hidden->iPMThreadStatus!=1) return;
1948
1949
1950 // Make sure this thread is prepared for using the Presentation Manager!
1951 hab = WinInitialize(0);
1952 hmq = WinCreateMsgQueue(hab,0);
1953 // Remember if there was an error at WinCreateMsgQueue(), because we don't
1954 // want to destroy somebody else's queue later. :)
1955 hmqerror = WinGetLastError(hab);
1956
1957
1958
1959 if (_this->hidden->fInFocus)
1960 {
1961 // If our app is in focus
1962 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
1963 SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
1964 SDL_PrivateAppActive(1, SDL_APPACTIVE);
1965 WinQueryPointerPos(HWND_DESKTOP, &ptl);
1966 WinMapWindowPoints(HWND_DESKTOP, _this->hidden->hwndClient, &ptl, 1);
1967 WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
1968 // Convert OS/2 mouse position to SDL position, and also scale it!
1969 ptl.x = ptl.x * _this->hidden->SrcBufferDesc.uiXResolution / swpClient.cx;
1970 ptl.y = ptl.y * _this->hidden->SrcBufferDesc.uiYResolution / swpClient.cy;
1971 ptl.y = _this->hidden->SrcBufferDesc.uiYResolution - ptl.y - 1;
1972 SDL_PrivateMouseMotion(0, 0, (Sint16) (ptl.x), (Sint16) (ptl.y));
1973 } else
1974 {
1975 // If we're not in focus
1976 SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
1977 SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);
1978 SDL_PrivateAppActive(0, SDL_APPACTIVE);
1979 SDL_PrivateMouseMotion(0, 0, (Sint16) -1, (Sint16) -1);
1980 }
1981
1982 // Now destroy the message queue, if we've created it!
1983 if (ERRORIDERROR(hmqerror)==0)
1984 WinDestroyMsgQueue(hmq);
1985
1986 }
1987
1988 /* This pointer should exist in the native video subsystem and should
1989 point to an appropriate update function for the current video mode
1990 */
1991 static void os2fslib_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
1992 {
1993 // If there is no more window, nothing we can do!
1994 if (_this->hidden->iPMThreadStatus!=1) return;
1995
1996 #ifdef BITBLT_IN_WINMESSAGEPROC
1997 WinSendMsg(_this->hidden->hwndClient,
1998 WM_UPDATERECTSREQUEST,
1999 (MPARAM) numrects,
2000 (MPARAM) rects);
2001 #else
2002 if (DosRequestMutexSem(_this->hidden->hmtxUseSrcBuffer, SEM_INDEFINITE_WAIT)==NO_ERROR)
2003 {
2004 int i;
2005
2006 if (_this->hidden->pSDLSurface)
2007 {
2008 #ifndef RESIZE_EVEN_IF_RESIZABLE
2009 SWP swp;
2010 // But only blit if the window is not resizable, or if
2011 // the window is resizable and the source buffer size is the
2012 // same as the destination buffer size!
2013 WinQueryWindowPos(_this->hidden->hwndClient, &swp);
2014 if ((_this->hidden->pSDLSurface) &&
2015 (_this->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
2016 ((swp.cx != _this->hidden->SrcBufferDesc.uiXResolution) ||
2017 (swp.cy != _this->hidden->SrcBufferDesc.uiYResolution)
2018 ) &&
2019 (!FSLib_QueryFSMode(_this->hidden->hwndClient))
2020 )
2021 {
2022 // Resizable surface and in resizing!
2023 // So, don't blit now!
2024 #ifdef DEBUG_BUILD
2025 printf("[UpdateRects] : Skipping blit while resizing!\n"); fflush(stdout);
2026 #endif
2027 } else
2028 #endif
2029 {
2030 /*
2031 // Blit the whole window
2032 FSLIB_BITBLT(_this->hidden->hwndClient, _this->hidden->pchSrcBuffer,
2033 0, 0,
2034 _this->hidden->SrcBufferDesc.uiXResolution,
2035 _this->hidden->SrcBufferDesc.uiYResolution);
2036 */
2037 #ifdef DEBUG_BUILD
2038 printf("[os2fslib_UpdateRects] : Blitting!\n"); fflush(stdout);
2039 #endif
2040
2041 // Blit the changed areas
2042 for (i=0; i<numrects; i++)
2043 FSLIB_BITBLT(_this->hidden->hwndClient, _this->hidden->pchSrcBuffer,
2044 rects[i].y, rects[i].x, rects[i].w, rects[i].h);
2045 }
2046 }
2047 #ifdef DEBUG_BUILD
2048 else
2049 printf("[os2fslib_UpdateRects] : No public surface!\n"); fflush(stdout);
2050 #endif
2051 DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
2052 }
2053 #ifdef DEBUG_BUILD
2054 else
2055 printf("[os2fslib_UpdateRects] : Error in mutex!\n"); fflush(stdout);
2056 #endif
2057 #endif
2058 }
2059
2060
2061 /* Reverse the effects VideoInit() -- called if VideoInit() fails
2062 or if the application is shutting down the video subsystem.
2063 */
2064 static void os2fslib_VideoQuit(_THIS)
2065 {
2066 #ifdef DEBUG_BUILD
2067 printf("[os2fslib_VideoQuit]\n"); fflush(stdout);
2068 #endif
2069 // Close PM stuff if running!
2070 if (_this->hidden->iPMThreadStatus == 1)
2071 {
2072 int iTimeout;
2073 WinPostMsg(_this->hidden->hwndFrame, WM_QUIT, (MPARAM) 0, (MPARAM) 0);
2074 // HACK: We had this line before:
2075 //DosWaitThread((TID *) &(_this->hidden->tidPMThread), DCWW_WAIT);
2076 // We don't use it, because the PMThread will never stop, or if it stops,
2077 // it will kill the whole process as a emergency fallback.
2078 // So, we only check for the iPMThreadStatus stuff!
2079 #ifdef DEBUG_BUILD
2080 printf("[os2fslib_VideoQuit] : Waiting for PM thread to die\n"); fflush(stdout);
2081 #endif
2082
2083 iTimeout=0;
2084 while ((_this->hidden->iPMThreadStatus == 1) && (iTimeout<100))
2085 {
2086 iTimeout++;
2087 DosSleep(64);
2088 }
2089
2090 #ifdef DEBUG_BUILD
2091 printf("[os2fslib_VideoQuit] : End of wait.\n"); fflush(stdout);
2092 #endif
2093
2094 if (_this->hidden->iPMThreadStatus == 1)
2095 {
2096 #ifdef DEBUG_BUILD
2097 printf("[os2fslib_VideoQuit] : Killing PM thread!\n"); fflush(stdout);
2098 #endif
2099
2100 _this->hidden->iPMThreadStatus = 0;
2101 DosKillThread(_this->hidden->tidPMThread);
2102
2103 if (_this->hidden->hwndFrame)
2104 {
2105 #ifdef DEBUG_BUILD
2106 printf("[os2fslib_VideoQuit] : Destroying PM window!\n"); fflush(stdout);
2107 #endif
2108
2109 WinDestroyWindow(_this->hidden->hwndFrame); _this->hidden->hwndFrame=NULL;
2110 }
2111 }
2112
2113 }
2114
2115 // Free result of an old ListModes() call, because there is
2116 // no FreeListModes() call in SDL!
2117 if (_this->hidden->pListModesResult)
2118 {
2119 free(_this->hidden->pListModesResult); _this->hidden->pListModesResult = NULL;
2120 }
2121
2122 // Free list of available fullscreen modes
2123 if (_this->hidden->pAvailableFSLibVideoModes)
2124 {
2125 FSLib_FreeVideoModeList(_this->hidden->pAvailableFSLibVideoModes);
2126 _this->hidden->pAvailableFSLibVideoModes = NULL;
2127 }
2128
2129 // Free application icon if we had one
2130 if (hptrCurrentIcon)
2131 {
2132 WinDestroyPointer(hptrCurrentIcon);
2133 hptrCurrentIcon = NULL;
2134 }
2135 }
2136
2137 /* Set the requested video mode, returning a surface which will be
2138 set to the SDL_VideoSurface. The width and height will already
2139 be verified by ListModes(), and the video subsystem is free to
2140 set the mode to a supported bit depth different from the one
2141 specified -- the desired bpp will be emulated with a shadow
2142 surface if necessary. If a new mode is returned, this function
2143 should take care of cleaning up the current mode.
2144 */
2145 static SDL_Surface *os2fslib_SetVideoMode(_THIS, SDL_Surface *current,
2146 int width, int height, int bpp, Uint32 flags)
2147 {
2148 static int bFirstCall = 1;
2149 FSLib_VideoMode_p pModeInfo, pModeInfoFound;
2150 FSLib_VideoMode TempModeInfo;
2151 HAB hab;
2152 HMQ hmq;
2153 ERRORID hmqerror;
2154 RECTL rectl;
2155 SDL_Surface *pResult;
2156
2157 // If there is no more window, nothing we can do!
2158 if (_this->hidden->iPMThreadStatus!=1) return NULL;
2159
2160 #ifdef DEBUG_BUILD
2161 printf("[os2fslib_SetVideoMode] : Request for %dx%d @ %dBPP, flags=0x%x\n", width, height, bpp, flags); fflush(stdout);
2162 #endif
2163
2164 // We don't support palette modes!
2165 if (bpp==8) bpp=32;
2166
2167 // Also, we don't support resizable modes in fullscreen mode.
2168 if (flags & SDL_RESIZABLE)
2169 flags &= ~SDL_FULLSCREEN;
2170
2171 // No double buffered mode
2172 if (flags & SDL_DOUBLEBUF)
2173 flags &= ~SDL_DOUBLEBUF;
2174
2175 // And, we don't support HWSURFACE yet.
2176 if (flags & SDL_HWSURFACE)
2177 {
2178 flags &= ~SDL_HWSURFACE;
2179 flags |= SDL_SWSURFACE;
2180 }
2181
2182 #ifdef DEBUG_BUILD
2183 printf("[os2fslib_SetVideoMode] : Changed request to %dx%d @ %dBPP, flags=0x%x\n", width, height, bpp, flags); fflush(stdout);
2184 #endif
2185
2186 // First check if there is such a video mode they want!
2187 pModeInfoFound = NULL;
2188
2189 // For fullscreen mode we don't support every resolution!
2190 // So, go through the video modes, and check for such a resolution!
2191 pModeInfoFound = NULL;
2192 pModeInfo = _this->hidden->pAvailableFSLibVideoModes;
2193
2194 while (pModeInfo)
2195 {
2196 // Check all available fullscreen modes for this resolution
2197 if ((pModeInfo->uiXResolution == width) &&
2198 (pModeInfo->uiYResolution == height) &&
2199 (pModeInfo->uiBPP!=8)) // palettized modes not yet supported
2200 {
2201 // If good resolution, try to find the exact BPP, or at least
2202 // something similar...
2203 if (!pModeInfoFound)
2204 pModeInfoFound = pModeInfo;
2205 else
2206 if ((pModeInfoFound->uiBPP!=bpp) &&
2207 (pModeInfoFound->uiBPP<pModeInfo->uiBPP))
2208 pModeInfoFound = pModeInfo;
2209 }
2210 pModeInfo = pModeInfo->pNext;
2211 }
2212
2213 // If we did not find a good fullscreen mode, then try a similar
2214 if (!pModeInfoFound)
2215 {
2216 #ifdef DEBUG_BUILD
2217 printf("[os2fslib_SetVideoMode] : Requested video mode not found, looking for a similar one!\n"); fflush(stdout);
2218 #endif
2219 // Go through the video modes again, and find a similar resolution!
2220 pModeInfo = _this->hidden->pAvailableFSLibVideoModes;
2221 while (pModeInfo)
2222 {
2223 // Check all available fullscreen modes for this resolution
2224 if ((pModeInfo->uiXResolution >= width) &&
2225 (pModeInfo->uiYResolution >= height) &&
2226 (pModeInfo->uiBPP == bpp))
2227 {
2228 if (!pModeInfoFound)
2229 pModeInfoFound = pModeInfo;
2230 else
2231 if (((pModeInfoFound->uiXResolution-width)*(pModeInfoFound->uiYResolution-height))>
2232 ((pModeInfo->uiXResolution-width)*(pModeInfo->uiYResolution-height)))
2233 {
2234 // Found a mode which is closer than the current one
2235 pModeInfoFound = pModeInfo;
2236 }
2237 }
2238 pModeInfo = pModeInfo->pNext;
2239 }
2240 }
2241
2242 // If we did not find a good fullscreen mode, then return NULL
2243 if (!pModeInfoFound)
2244 {
2245 #ifdef DEBUG_BUILD
2246 printf("[os2fslib_SetVideoMode] : Requested video mode not found!\n"); fflush(stdout);
2247 #endif
2248 return NULL;
2249 }
2250
2251 #ifdef DEBUG_BUILD
2252 printf("[os2fslib_SetVideoMode] : Found mode!\n"); fflush(stdout);
2253 #endif
2254
2255 // We'll possibly adjust the structure, so copy out the values
2256 // into TempModeInfo!
2257 memcpy(&TempModeInfo, pModeInfoFound, sizeof(TempModeInfo));
2258 pModeInfoFound = &TempModeInfo;
2259
2260 if (flags & SDL_RESIZABLE)
2261 {
2262 #ifdef DEBUG_BUILD
2263 printf("[os2fslib_SetVideoMode] : Requested mode is resizable, changing width/height\n"); fflush(stdout);
2264 #endif
2265 // Change width and height to requested one!
2266 TempModeInfo.uiXResolution = width;
2267 TempModeInfo.uiYResolution = height;
2268 TempModeInfo.uiScanLineSize = width * ((TempModeInfo.uiBPP+7)/8);
2269 }
2270
2271 // We can try create new surface!
2272
2273 // Make sure this thread is prepared for using the Presentation Manager!
2274 hab = WinInitialize(0);
2275 hmq = WinCreateMsgQueue(hab,0);
2276 // Remember if there was an error at WinCreateMsgQueue(), because we don't
2277 // want to destroy somebody else's queue later. :)
2278 hmqerror = WinGetLastError(hab);
2279
2280
2281
2282 if (DosRequestMutexSem(_this->hidden->hmtxUseSrcBuffer, SEM_INDEFINITE_WAIT)==NO_ERROR)
2283 {
2284 #ifdef DEBUG_BUILD
2285 printf("[os2fslib_SetVideoMode] : Creating new SW surface\n"); fflush(stdout);
2286 #endif
2287
2288 // Create new software surface!
2289 pResult = SDL_CreateRGBSurface(SDL_SWSURFACE,
2290 pModeInfoFound->uiXResolution,
2291 pModeInfoFound->uiYResolution,
2292 pModeInfoFound->uiBPP,
2293 ((unsigned int) pModeInfoFound->PixelFormat.ucRedMask) << pModeInfoFound->PixelFormat.ucRedPosition,
2294 ((unsigned int) pModeInfoFound->PixelFormat.ucGreenMask) << pModeInfoFound->PixelFormat.ucGreenPosition,
2295 ((unsigned int) pModeInfoFound->PixelFormat.ucBlueMask) << pModeInfoFound->PixelFormat.ucBluePosition,
2296 ((unsigned int) pModeInfoFound->PixelFormat.ucAlphaMask) << pModeInfoFound->PixelFormat.ucAlphaPosition);
2297
2298 if (pResult == NULL)
2299 {
2300 DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
2301 SDL_OutOfMemory();
2302 return NULL;
2303 }
2304
2305 #ifdef DEBUG_BUILD
2306 printf("[os2fslib_SetVideoMode] : Adjusting pixel format\n"); fflush(stdout);
2307 #endif
2308
2309 // Adjust pixel format mask!
2310 pResult->format->Rmask = ((unsigned int) pModeInfoFound->PixelFormat.ucRedMask) << pModeInfoFound->PixelFormat.ucRedPosition;
2311 pResult->format->Rshift = pModeInfoFound->PixelFormat.ucRedPosition;
2312 pResult->format->Rloss = pModeInfoFound->PixelFormat.ucRedAdjust;
2313 pResult->format->Gmask = ((unsigned int) pModeInfoFound->PixelFormat.ucGreenMask) << pModeInfoFound->PixelFormat.ucGreenPosition;
2314 pResult->format->Gshift = pModeInfoFound->PixelFormat.ucGreenPosition;
2315 pResult->format->Gloss = pModeInfoFound->PixelFormat.ucGreenAdjust;
2316 pResult->format->Bmask = ((unsigned int) pModeInfoFound->PixelFormat.ucBlueMask) << pModeInfoFound->PixelFormat.ucBluePosition;
2317 pResult->format->Bshift = pModeInfoFound->PixelFormat.ucBluePosition;
2318 pResult->format->Bloss = pModeInfoFound->PixelFormat.ucBlueAdjust;
2319 pResult->format->Amask = ((unsigned int) pModeInfoFound->PixelFormat.ucAlphaMask) << pModeInfoFound->PixelFormat.ucAlphaPosition;
2320 pResult->format->Ashift = pModeInfoFound->PixelFormat.ucAlphaPosition;
2321 pResult->format->Aloss = pModeInfoFound->PixelFormat.ucAlphaAdjust;
2322
2323 #ifdef REPORT_EMPTY_ALPHA_MASK
2324 pResult->format->Amask =
2325 pResult->format->Ashift =
2326 pResult->format->Aloss = 0;
2327 #endif
2328
2329 // Adjust surface flags
2330 pResult->flags |= (flags & SDL_FULLSCREEN);
2331 pResult->flags |= (flags & SDL_RESIZABLE);
2332
2333 // It might be that the software surface pitch is not the same as
2334 // the pitch we have, so adjust that!
2335 pModeInfoFound->uiScanLineSize = pResult->pitch;
2336
2337 // Store new source buffer parameters!
2338 memcpy(&(_this->hidden->SrcBufferDesc), pModeInfoFound, sizeof(*pModeInfoFound));
2339 _this->hidden->pchSrcBuffer = pResult->pixels;
2340
2341 #ifdef DEBUG_BUILD
2342 printf("[os2fslib_SetVideoMode] : Telling FSLib the stuffs\n"); fflush(stdout);
2343 #endif
2344
2345 // Tell the FSLib window the new source image format
2346 FSLib_SetSrcBufferDesc(_this->hidden->hwndClient, &(_this->hidden->SrcBufferDesc));
2347
2348 if (
2349 ((flags & SDL_RESIZABLE)==0) ||
2350 (bFirstCall)
2351 )
2352 {
2353 bFirstCall = 0;
2354 #ifdef DEBUG_BUILD
2355 printf("[os2fslib_SetVideoMode] : Modifying window size\n"); fflush(stdout);
2356 #endif
2357
2358 // Calculate frame window size from client window size
2359 rectl.xLeft = 0;
2360 rectl.yBottom = 0;
2361 rectl.xRight = pModeInfoFound->uiXResolution; // Noninclusive
2362 rectl.yTop = pModeInfoFound->uiYResolution; // Noninclusive
2363 WinCalcFrameRect(_this->hidden->hwndFrame, &rectl, FALSE);
2364
2365 // Set the new size of the main window
2366 SetAccessableWindowPos(_this->hidden->hwndFrame,
2367 HWND_TOP,
2368 0, 0,
2369 (rectl.xRight-rectl.xLeft),
2370 (rectl.yTop-rectl.yBottom),
2371 SWP_SIZE | SWP_ACTIVATE | SWP_SHOW);
2372 }
2373
2374 // Set fullscreen mode flag, and switch to fullscreen if needed!
2375 if (flags & SDL_FULLSCREEN)
2376 {
2377 #ifdef DEBUG_BUILD
2378 printf("[os2fslib_SetVideoMode] : Also trying to switch to fullscreen\n");
2379 fflush(stdout);
2380 #endif
2381 FSLib_ToggleFSMode(_this->hidden->hwndClient, 1);
2382 /* Cursor manager functions to FS mode*/
2383 os2fslib_SetCursorManagementFunctions(_this, 0);
2384 } else
2385 {
2386 #ifdef DEBUG_BUILD
2387 printf("[os2fslib_SetVideoMode] : Also trying to switch to desktop mode\n");
2388 fflush(stdout);
2389 #endif
2390 FSLib_ToggleFSMode(_this->hidden->hwndClient, 0);
2391 /* Cursor manager functions to Windowed mode*/
2392 os2fslib_SetCursorManagementFunctions(_this, 1);
2393 }
2394
2395 _this->hidden->pSDLSurface = pResult;
2396
2397 DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
2398 } else
2399 {
2400 #ifdef DEBUG_BUILD
2401 printf("[os2fslib_SetVideoMode] : Could not get hmtxUseSrcBuffer!\n"); fflush(stdout);
2402 #endif
2403
2404 pResult = NULL;
2405 }
2406
2407 // As we have the new surface, we don't need the current one anymore!
2408 if ((pResult) && (current))
2409 {
2410 #ifdef DEBUG_BUILD
2411 printf("[os2fslib_SetVideoMode] : Freeing old surface\n"); fflush(stdout);
2412 #endif
2413 SDL_FreeSurface(current);
2414 }
2415
2416 // Redraw window
2417 WinInvalidateRegion(_this->hidden->hwndClient, NULL, TRUE);
2418
2419 // Now destroy the message queue, if we've created it!
2420 if (ERRORIDERROR(hmqerror)==0)
2421 {
2422 #ifdef DEBUG_BUILD
2423 printf("[os2fslib_SetVideoMode] : Destroying message queue\n"); fflush(stdout);
2424 #endif
2425 WinDestroyMsgQueue(hmq);
2426 }
2427
2428 #ifdef DEBUG_BUILD
2429 printf("[os2fslib_SetVideoMode] : Done\n"); fflush(stdout);
2430 #endif
2431
2432 /* We're done */
2433
2434 // Return with the new surface!
2435 return pResult;
2436 }
2437
2438 /* List the available video modes for the given pixel format, sorted
2439 from largest to smallest.
2440 */
2441 static SDL_Rect **os2fslib_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
2442 {
2443 #ifdef DEBUG_BUILD
2444 printf("[os2fslib_ListModes] : ListModes of %d Bpp\n", format->BitsPerPixel);
2445 #endif
2446 // Destroy result of previous call, if there is any
2447 if (_this->hidden->pListModesResult)
2448 {
2449 free(_this->hidden->pListModesResult); _this->hidden->pListModesResult = NULL;
2450 }
2451
2452 // For resizable and windowed mode we support every resolution!
2453 if ((flags & SDL_RESIZABLE) && ((flags & SDL_FULLSCREEN) == 0))
2454 return (SDL_Rect **)-1;
2455
2456 // Check if they need fullscreen or non-fullscreen video modes!
2457 if ((flags & SDL_FULLSCREEN) == 0)
2458
2459 {
2460 // For windowed mode we support every resolution!
2461 return (SDL_Rect **)-1;
2462 } else
2463 {
2464 FSLib_VideoMode_p pFSMode;
2465 // For fullscreen mode we don't support every resolution!
2466 // Now create a new list
2467 pFSMode = _this->hidden->pAvailableFSLibVideoModes;
2468 while (pFSMode)
2469 {
2470 if (pFSMode->uiBPP == format->BitsPerPixel)
2471 {
2472 SDL_Rect *pRect = (SDL_Rect *) malloc(sizeof(SDL_Rect));
2473 if (pRect)
2474 {
2475 // Fill description
2476 pRect->x = 0;
2477 pRect->y = 0;
2478 pRect->w = pFSMode->uiXResolution;
2479 pRect->h = pFSMode->uiYResolution;
2480 #ifdef DEBUG_BUILD
2481 // printf("!!! Seems to be good!\n");
2482 // printf("F: %dx%d\n", pRect->w, pRect->h);
2483 #endif
2484 // And insert into list of pRects
2485 if (!(_this->hidden->pListModesResult))
2486 {
2487 #ifdef DEBUG_BUILD
2488 // printf("!!! Inserting to beginning\n");
2489 #endif
2490
2491 // We're the first one to be inserted!
2492 _this->hidden->pListModesResult = (SDL_Rect**) malloc(2*sizeof(SDL_Rect*));
2493 if (_this->hidden->pListModesResult)
2494 {
2495 _this->hidden->pListModesResult[0] = pRect;
2496 _this->hidden->pListModesResult[1] = NULL;
2497 } else
2498 {
2499 free(pRect);
2500 }
2501 } else
2502 {
2503 // We're not the first ones, so find the place where we
2504 // have to insert ourselves
2505 SDL_Rect **pNewList;
2506 int iPlace, iNumOfSlots, i;
2507
2508 #ifdef DEBUG_BUILD
2509 // printf("!!! Searching where to insert\n");
2510 #endif
2511
2512 iPlace = -1; iNumOfSlots = 1; // Count the last NULL too!
2513 for (i=0; _this->hidden->pListModesResult[i]; i++)
2514 {
2515 iNumOfSlots++;
2516 if (iPlace==-1)
2517 {
2518 if ((_this->hidden->pListModesResult[i]->w*_this->hidden->pListModesResult[i]->h)<
2519 (pRect->w*pRect->h))
2520 {
2521 iPlace = i;
2522 }
2523 }
2524 }
2525 if (iPlace==-1) iPlace = iNumOfSlots-1;
2526
2527 #ifdef DEBUG_BUILD
2528 // printf("!!! From %d slots, it will be at %d\n", iNumOfSlots, iPlace);
2529 #endif
2530
2531 pNewList = (SDL_Rect**) realloc(_this->hidden->pListModesResult, (iNumOfSlots+1)*sizeof(SDL_Rect*));
2532 if (pNewList)
2533 {
2534 for (i=iNumOfSlots;i>iPlace;i--)
2535 pNewList[i] = pNewList[i-1];
2536 pNewList[iPlace] = pRect;
2537 _this->hidden->pListModesResult = pNewList;
2538 } else
2539 {
2540 free(pRect);
2541 }
2542 }
2543 }
2544 }
2545 pFSMode = pFSMode->pNext;
2546 }
2547 }
2548 #ifdef DEBUG_BUILD
2549 // printf("Returning list\n");
2550 #endif
2551 return _this->hidden->pListModesResult;
2552 }
2553
2554 /* Initialize the native video subsystem, filling 'vformat' with the
2555 "best" display pixel format, returning 0 or -1 if there's an error.
2556 */
2557 static int os2fslib_VideoInit(_THIS, SDL_PixelFormat *vformat)
2558 {
2559 FSLib_VideoMode_p pDesktopMode;
2560
2561 #ifdef DEBUG_BUILD
2562 printf("[os2fslib_VideoInit] : Enter\n"); fflush(stdout);
2563 #endif
2564
2565 // Report the best pixel format. For this,
2566 // we'll use the current desktop format.
2567 pDesktopMode = FSLib_GetDesktopVideoMode();
2568 if (!pDesktopMode)
2569 {
2570 SDL_SetError("Could not query desktop video mode!");
2571 #ifdef DEBUG_BUILD
2572 printf("[os2fslib_VideoInit] : Could not query desktop video mode!\n");
2573 #endif
2574 return -1;
2575 }
2576
2577 /* Determine the screen depth */
2578 vformat->BitsPerPixel = pDesktopMode->uiBPP;
2579 vformat->BytesPerPixel = (vformat->BitsPerPixel+7)/8;
2580
2581 vformat->Rmask = ((unsigned int) pDesktopMode->PixelFormat.ucRedMask) << pDesktopMode->PixelFormat.ucRedPosition;
2582 vformat->Rshift = pDesktopMode->PixelFormat.ucRedPosition;
2583 vformat->Rloss = pDesktopMode->PixelFormat.ucRedAdjust;
2584 vformat->Gmask = ((unsigned int) pDesktopMode->PixelFormat.ucGreenMask) << pDesktopMode->PixelFormat.ucGreenPosition;
2585 vformat->Gshift = pDesktopMode->PixelFormat.ucGreenPosition;
2586 vformat->Gloss = pDesktopMode->PixelFormat.ucGreenAdjust;
2587 vformat->Bmask = ((unsigned int) pDesktopMode->PixelFormat.ucBlueMask) << pDesktopMode->PixelFormat.ucBluePosition;
2588 vformat->Bshift = pDesktopMode->PixelFormat.ucBluePosition;
2589 vformat->Bloss = pDesktopMode->PixelFormat.ucBlueAdjust;
2590 vformat->Amask = ((unsigned int) pDesktopMode->PixelFormat.ucAlphaMask) << pDesktopMode->PixelFormat.ucAlphaPosition;
2591 vformat->Ashift = pDesktopMode->PixelFormat.ucAlphaPosition;
2592 vformat->Aloss = pDesktopMode->PixelFormat.ucAlphaAdjust;
2593
2594 #ifdef REPORT_EMPTY_ALPHA_MASK
2595 vformat->Amask =
2596 vformat->Ashift =
2597 vformat->Aloss = 0;
2598 #endif
2599
2600 // Fill in some window manager capabilities
2601 _this->info.wm_available = 1;
2602
2603 // Initialize some internal variables
2604 _this->hidden->pListModesResult = NULL;
2605 _this->hidden->fInFocus = 0;
2606 _this->hidden->iSkipWMMOUSEMOVE = 0;
2607 _this->hidden->iMouseVisible = 1;
2608 DosCreateMutexSem(NULL, &(_this->hidden->hmtxUseSrcBuffer), 0, FALSE);
2609
2610 // Now create our window with a default size
2611
2612 // For this, we select the first available fullscreen mode as
2613 // current window size!
2614 memcpy(&(_this->hidden->SrcBufferDesc), _this->hidden->pAvailableFSLibVideoModes, sizeof(_this->hidden->SrcBufferDesc));
2615 // Allocate new video buffer!
2616 _this->hidden->pchSrcBuffer = (char *) malloc(_this->hidden->pAvailableFSLibVideoModes->uiScanLineSize * _this->hidden->pAvailableFSLibVideoModes->uiYResolution);
2617 if (!_this->hidden->pchSrcBuffer)
2618 {
2619 #ifdef DEBUG_BUILD
2620 printf("[os2fslib_VideoInit] : Yikes, not enough memory for new video buffer!\n"); fflush(stdout);
2621 #endif
2622 SDL_SetError("Not enough memory for new video buffer!\n");
2623 return -1;
2624 }
2625
2626 // For this, we need a message processing thread.
2627 // We'll create a new thread for this, which will do everything
2628 // what is related to PM
2629 _this->hidden->iPMThreadStatus = 0;
2630 _this->hidden->tidPMThread = _beginthread(PMThreadFunc, NULL, 65536, (void *) _this);
2631 if (_this->hidden->tidPMThread <= 0)
2632 {
2633 #ifdef DEBUG_BUILD
2634 printf("[os2fslib_VideoInit] : Could not create PM thread!\n");
2635 #endif
2636 SDL_SetError("Could not create PM thread");
2637 return -1;
2638 }
2639 #ifdef USE_DOSSETPRIORITY
2640 // Burst the priority of PM Thread!
2641 DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, _this->hidden->tidPMThread);
2642 #endif
2643 // Wait for the PM thread to initialize!
2644 while (_this->hidden->iPMThreadStatus==0)
2645 DosSleep(32);
2646 // If the PM thread could not set up everything, then
2647 // report an error!
2648 if (_this->hidden->iPMThreadStatus!=1)
2649 {
2650 #ifdef DEBUG_BUILD
2651 printf("[os2fslib_VideoInit] : PMThread reported an error : %d\n", _this->hidden->iPMThreadStatus);
2652 #endif
2653 SDL_SetError("Error initializing PM thread");
2654 return -1;
2655 }
2656
2657 return 0;
2658 }
2659
2660
2661 static void os2fslib_DeleteDevice(_THIS)
2662 {
2663 #ifdef DEBUG_BUILD
2664 printf("[os2fslib_DeleteDevice]\n"); fflush(stdout);
2665 #endif
2666 // Free used memory
2667 FSLib_FreeVideoModeList(_this->hidden->pAvailableFSLibVideoModes);
2668 if (_this->hidden->pListModesResult)
2669 free(_this->hidden->pListModesResult);
2670 if (_this->hidden->pchSrcBuffer)
2671 free(_this->hidden->pchSrcBuffer);
2672 DosCloseMutexSem(_this->hidden->hmtxUseSrcBuffer);
2673 free(_this->hidden);
2674 free(_this);
2675 FSLib_Uninitialize();
2676 }
2677
2678 static int os2fslib_Available(void)
2679 {
2680
2681 // If we can run, it means that we could load FSLib,
2682 // so we assume that it's available then!
2683 return 1;
2684 }
2685
2686 static void os2fslib_MorphToPM()
2687 {
2688 PPIB pib;
2689 PTIB tib;
2690
2691 DosGetInfoBlocks(&tib, &pib);
2692
2693 // Change flag from VIO to PM:
2694 if (pib->pib_ultype==2) pib->pib_ultype = 3;
2695 }
2696
2697 static SDL_VideoDevice *os2fslib_CreateDevice(int devindex)
2698 {
2699 SDL_VideoDevice *device;
2700
2701 #ifdef DEBUG_BUILD
2702 printf("[os2fslib_CreateDevice] : Enter\n"); fflush(stdout);
2703 #endif
2704
2705 /* Initialize all variables that we clean on shutdown */
2706 device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
2707 if ( device )
2708 {
2709 memset(device, 0, (sizeof *device));
2710 // Also allocate memory for private data
2711 device->hidden = (struct SDL_PrivateVideoData *) malloc((sizeof(struct SDL_PrivateVideoData)));
2712 }
2713 if ( (device == NULL) || (device->hidden == NULL) )
2714 {
2715 SDL_OutOfMemory();
2716 if ( device )
2717 free(device);
2718 return NULL;
2719 }
2720 memset(device->hidden, 0, (sizeof *device->hidden));
2721
2722 /* Set the function pointers */
2723 #ifdef DEBUG_BUILD
2724 printf("[os2fslib_CreateDevice] : VideoInit is %p\n", os2fslib_VideoInit); fflush(stdout);
2725 #endif
2726
2727 /* Initialization/Query functions */
2728 device->VideoInit = os2fslib_VideoInit;
2729 device->ListModes = os2fslib_ListModes;
2730 device->SetVideoMode = os2fslib_SetVideoMode;
2731 device->ToggleFullScreen = os2fslib_ToggleFullScreen;
2732 device->UpdateMouse = os2fslib_UpdateMouse;
2733 device->CreateYUVOverlay = NULL;
2734 device->SetColors = os2fslib_SetColors;
2735 device->UpdateRects = os2fslib_UpdateRects;
2736 device->VideoQuit = os2fslib_VideoQuit;
2737 /* Hardware acceleration functions */
2738 device->AllocHWSurface = os2fslib_AllocHWSurface;
2739 device->CheckHWBlit = NULL;
2740 device->FillHWRect = NULL;
2741 device->SetHWColorKey = NULL;
2742 device->SetHWAlpha = NULL;
2743 device->LockHWSurface = os2fslib_LockHWSurface;
2744 device->UnlockHWSurface = os2fslib_UnlockHWSurface;
2745 device->FlipHWSurface = NULL;
2746 device->FreeHWSurface = os2fslib_FreeHWSurface;
2747 /* Window manager functions */
2748 device->SetCaption = os2fslib_SetCaption;
2749 device->SetIcon = os2fslib_SetIcon;
2750 device->IconifyWindow = os2fslib_IconifyWindow;
2751 device->GrabInput = os2fslib_GrabInput;
2752 device->GetWMInfo = NULL;
2753 /* Cursor manager functions to Windowed mode*/
2754 os2fslib_SetCursorManagementFunctions(device, 1);
2755 /* Event manager functions */
2756 device->InitOSKeymap = os2fslib_InitOSKeymap;
2757 device->PumpEvents = os2fslib_PumpEvents;
2758 /* The function used to dispose of this structure */
2759 device->free = os2fslib_DeleteDevice;
2760
2761 // Make sure we'll be able to use Win* API even if the application
2762 // was linked to be a VIO application!
2763 os2fslib_MorphToPM();
2764
2765 // Now initialize FSLib, and query available video modes!
2766 if (!FSLib_Initialize())
2767 {
2768 // Could not initialize FSLib!
2769 #ifdef DEBUG_BUILD
2770 printf("[os2fslib_CreateDevice] : Could not initialize FSLib!\n");
2771 #endif
2772 SDL_SetError("Could not initialize FSLib!");
2773 free(device->hidden);
2774 free(device);
2775 return NULL;
2776 }
2777 device->hidden->pAvailableFSLibVideoModes =
2778 FSLib_GetVideoModeList();
2779
2780 return device;
2781 }
2782
2783 VideoBootStrap OS2FSLib_bootstrap = {
2784 "os2fslib", "OS/2 Video Output using FSLib",
2785 os2fslib_Available, os2fslib_CreateDevice
2786 };
2787