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