sdl-ios-xcode: src/video/os2fslib/SDL

comparison src/video/os2fslib/SDL_os2fslib.c @ 1895:c121d94672cb

SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.

author	Sam Lantinga <slouken@libsdl.org>
date	Mon, 10 Jul 2006 21:04:37 +0000
parents	066236f0cbf0
children	e1da92da346c 204be4fc2726

comparison

equal deleted inserted replaced

-:c69cee13dd76
+:c121d94672cb
 */
 #include "SDL_config.h"
 #define _ULS_CALLCONV_
 #define CALLCONV _System
-#include <unidef.h>                    // Unicode API
+#include <unidef.h>             // Unicode API
-#include <uconv.h>                     // Unicode API (codepage conversion)
+#include <uconv.h>              // Unicode API (codepage conversion)
 #include <process.h>
 #include <time.h>
 #include "SDL_video.h"
 #include "../../events/SDL_events_c.h"
 #include "SDL_os2fslib.h"
 static ULONG ulFCFToUse =
 FCF_TITLEBAR |
 FCF_SYSMENU |
 FCF_MINBUTTON |
-FCF_MAXBUTTON |
+FCF_MAXBUTTON | FCF_NOBYTEALIGN | FCF_SIZEBORDER | FCF_TASKLIST;
-FCF_NOBYTEALIGN |
-FCF_SIZEBORDER |
+static int bMouseCaptured = 0;
-FCF_TASKLIST;
-static int bMouseCaptured   = 0;
 static int bMouseCapturable = 0;
 static HPOINTER hptrGlobalPointer = NULL;
 static HPOINTER hptrCurrentIcon = NULL;
 static int iWindowSizeX = 320;
 static int iWindowSizeY = 200;
 static int bWindowResized = 0;
 #pragma pack(1)
 typedef struct BMPINFO
 {
 BITMAPINFO;
-RGB  clr;
+RGB clr;
 } BMPINFO, *PBMPINFO;
 #pragma pack()
 // Backdoors:
-DECLSPEC void SDLCALL SDL_OS2FSLIB_SetFCFToUse(ULONG ulFCF)
+DECLSPEC void SDLCALL
-{
+SDL_OS2FSLIB_SetFCFToUse(ULONG ulFCF)
-ulFCFToUse = ulFCF;
+{
+ulFCFToUse = ulFCF;
 }
 // Configuration defines:
 // We have to report empty alpha mask, otherwise SDL will select
 // even if the surface is resizable.
 //#define RESIZE_EVEN_IF_RESIZABLE
 /* The translation table from a VK keysym to a SDL keysym */
 static SDLKey HWScanKeyMap[256];
-static SDL_keysym *TranslateKey(int vkey, int chcode, int scancode, SDL_keysym *keysym, int iPressed);
+static SDL_keysym *TranslateKey(int vkey, int chcode, int scancode,
-static int  iShiftIsPressed;
+SDL_keysym * keysym, int iPressed);
+static int iShiftIsPressed;
 #ifdef BITBLT_IN_WINMESSAGEPROC
 #define WM_UPDATERECTSREQUEST   WM_USER+50
 #endif
 //
 // Same as WinSetWindowPos(), but takes care for the window to be
 // always on the screen, the titlebar will be accessable everytime.
 //
 /////////////////////////////////////////////////////////////////////
-static BOOL SetAccessableWindowPos(HWND hwnd, HWND hwndInsertBehind,
+static BOOL
-LONG x, LONG y,
+SetAccessableWindowPos(HWND hwnd, HWND hwndInsertBehind,
-LONG cx, LONG cy,
+LONG x, LONG y, LONG cx, LONG cy, ULONG fl)
-ULONG fl)
+{
-{
+SWP swpDesktop, swp;
-SWP swpDesktop, swp;
+// Get desktop area
-// Get desktop area
+WinQueryWindowPos(HWND_DESKTOP, &swpDesktop);
-WinQueryWindowPos(HWND_DESKTOP, &swpDesktop);
+if ((fl & SWP_MOVE) && (fl & SWP_SIZE)) {
-if ((fl & SWP_MOVE) && (fl & SWP_SIZE))
+// If both moving and sizing, then change size and pos now!!
-{
+if (x + cx > swpDesktop.cx)
-// If both moving and sizing, then change size and pos now!!
+x = swpDesktop.cx - cx;
-if (x+cx>swpDesktop.cx)
+if (x < 0)
-x = swpDesktop.cx - cx;
+x = 0;
-if (x<0)
+if (y < 0)
-x = 0;
+y = 0;
-if (y<0)
+if (y + cy > swpDesktop.cy)
-y = 0;
+y = swpDesktop.cy - cy;
-if (y+cy>swpDesktop.cy)
+return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
-y = swpDesktop.cy - cy;
+} else if (fl & SWP_MOVE) {
-return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
+// Just moving
-} else
+WinQueryWindowPos(hwnd, &swp);
-if (fl & SWP_MOVE)
+if (x + swp.cx > swpDesktop.cx)
-{
+x = swpDesktop.cx - swp.cx;
-// Just moving
+if (x < 0)
-WinQueryWindowPos(hwnd, &swp);
+x = 0;
-if (x+swp.cx>swpDesktop.cx)
+if (y < 0)
-x = swpDesktop.cx - swp.cx;
+y = 0;
-if (x<0)
+if (y + swp.cy > swpDesktop.cy)
-x = 0;
+y = swpDesktop.cy - swp.cy;
-if (y<0)
+return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
-y = 0;
+} else if (fl & SWP_SIZE) {
-if (y+swp.cy>swpDesktop.cy)
+// Just sizing
-y = swpDesktop.cy - swp.cy;
+WinQueryWindowPos(hwnd, &swp);
-return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
+x = swp.x;
-} else
+y = swp.y;
-if (fl & SWP_SIZE)
+if (x + cx > swpDesktop.cx)
-{
+x = swpDesktop.cx - cx;
-// Just sizing
+if (x < 0)
-WinQueryWindowPos(hwnd, &swp);
+x = 0;
-x = swp.x;
+if (y < 0)
-y = swp.y;
+y = 0;
-if (x+cx>swpDesktop.cx)
+if (y + cy > swpDesktop.cy)
-x = swpDesktop.cx - cx;
+y = swpDesktop.cy - cy;
-if (x<0)
+return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy,
-x = 0;
+fl | SWP_MOVE);
-if (y<0)
+} else
-y = 0;
+return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
-if (y+cy>swpDesktop.cy)
+}
-y = swpDesktop.cy - cy;
-return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl | SWP_MOVE);
+static UniChar
-} else
+NativeCharToUniChar(int chcode)
-return WinSetWindowPos(hwnd, hwndInsertBehind, x, y, cx, cy, fl);
+{
-}
+UniChar ucResult = (UniChar) chcode;
+int rc;
-static UniChar NativeCharToUniChar(int chcode)
+UconvObject ucoTemp;
-{
+char achFrom[2];
-UniChar ucResult = (UniChar) chcode;
+char *pchFrom;
-int rc;
+size_t iFromCount;
-UconvObject ucoTemp;
+UniChar aucTo[10];
-char     achFrom[2];
+UniChar *pucTo;
-char     *pchFrom;
+size_t iToCount;
-size_t   iFromCount;
+size_t iNonIdentical;
-UniChar  aucTo[10];
-UniChar  *pucTo;
+// Create unicode convert object
-size_t   iToCount;
+rc = UniCreateUconvObject(L"", &ucoTemp);
-size_t   iNonIdentical;
+if (rc != ULS_SUCCESS) {
+// Could not create convert object!
-// Create unicode convert object
+return ucResult;
-rc = UniCreateUconvObject(L"", &ucoTemp);
+}
-if (rc!=ULS_SUCCESS)
+// Convert language code string to unicode string
-{
+achFrom[0] = (char) chcode;
-// Could not create convert object!
+achFrom[1] = 0;
-return ucResult;
+iFromCount = sizeof(char) * 2;
-}
+iToCount = sizeof(UniChar) * 2;
+pucTo = &(aucTo[0]);
-// Convert language code string to unicode string
+pchFrom = &(achFrom[0]);
-achFrom[0] = (char) chcode;
-achFrom[1] = 0;
+rc = UniUconvToUcs(ucoTemp,
-iFromCount = sizeof(char) * 2;
+&pchFrom,
-iToCount = sizeof(UniChar) * 2;
+&iFromCount, &pucTo, &iToCount, &iNonIdentical);
-pucTo = &(aucTo[0]);
-pchFrom = &(achFrom[0]);
+if (rc != ULS_SUCCESS) {
+// Could not convert language code to UCS string!
-rc = UniUconvToUcs(ucoTemp,
+UniFreeUconvObject(ucoTemp);
-&pchFrom,
+return ucResult;
-&iFromCount,
+}
-&pucTo,
-&iToCount,
-&iNonIdentical);
-if (rc!=ULS_SUCCESS)
-{
-// Could not convert language code to UCS string!
 UniFreeUconvObject(ucoTemp);
-return ucResult;
-}
+#ifdef DEBUG_BUILD
+printf("%02x converted to %02x\n", (int) chcode, (int) (aucTo[0]));
-UniFreeUconvObject(ucoTemp);
+#endif
-#ifdef DEBUG_BUILD
+return aucTo[0];
-printf("%02x converted to %02x\n", (int) chcode, (int) (aucTo[0]));
-#endif
-return aucTo[0];
 }
 /////////////////////////////////////////////////////////////////////
 //
 // TranslateKey
 //
 // This creates SDL Keycodes from VK_ and hardware scan codes
 //
 /////////////////////////////////////////////////////////////////////
-static SDL_keysym *TranslateKey(int vkey, int chcode, int scancode, SDL_keysym *keysym, int iPressed)
+static SDL_keysym *
-{
+TranslateKey(int vkey, int chcode, int scancode, SDL_keysym * keysym,
-keysym->scancode = (unsigned char) scancode;
+int iPressed)
-keysym->mod = KMOD_NONE;
+{
-keysym->unicode = 0;
+keysym->scancode = (unsigned char) scancode;
+keysym->mod = KMOD_NONE;
-if (iPressed && SDL_TranslateUNICODE)
+keysym->unicode = 0;
-{
-if (chcode)
+if (iPressed && SDL_TranslateUNICODE) {
-keysym->unicode = NativeCharToUniChar(chcode);
+if (chcode)
-else
+keysym->unicode = NativeCharToUniChar(chcode);
-keysym->unicode = vkey;
+else
-}
+keysym->unicode = vkey;
+}
-keysym->sym = HWScanKeyMap[scancode];
+keysym->sym = HWScanKeyMap[scancode];
-// Now stuffs based on state of shift key(s)!
-if (vkey == VK_SHIFT)
+// Now stuffs based on state of shift key(s)!
-{
+if (vkey == VK_SHIFT) {
 iShiftIsPressed = iPressed;
 }
-if ((iShiftIsPressed) && (SDL_TranslateUNICODE))
+if ((iShiftIsPressed) && (SDL_TranslateUNICODE)) {
-{
+// Change syms, if Unicode stuff is required
-// Change syms, if Unicode stuff is required
+// I think it's silly, but it's SDL...
-// I think it's silly, but it's SDL...
+switch (keysym->sym) {
-switch (keysym->sym)
+case SDLK_BACKQUOTE:
-{
+keysym->sym = '~';
-case SDLK_BACKQUOTE:
+break;
-keysym->sym = '~';
+case SDLK_1:
-break;
+keysym->sym = SDLK_EXCLAIM;
-case SDLK_1:
+break;
-keysym->sym = SDLK_EXCLAIM;
+case SDLK_2:
-break;
+keysym->sym = SDLK_AT;
-case SDLK_2:
+break;
-keysym->sym = SDLK_AT;
+case SDLK_3:
-break;
+keysym->sym = SDLK_HASH;
-case SDLK_3:
+break;
-keysym->sym = SDLK_HASH;
+case SDLK_4:
-break;
+keysym->sym = SDLK_DOLLAR;
-case SDLK_4:
+break;
-keysym->sym = SDLK_DOLLAR;
+case SDLK_5:
-break;
+keysym->sym = '%';
-case SDLK_5:
+break;
-keysym->sym = '%';
+case SDLK_6:
-break;
+keysym->sym = SDLK_CARET;
-case SDLK_6:
+break;
-keysym->sym = SDLK_CARET;
+case SDLK_7:
-break;
+keysym->sym = SDLK_AMPERSAND;
-case SDLK_7:
+break;
-keysym->sym = SDLK_AMPERSAND;
+case SDLK_8:
-break;
+keysym->sym = SDLK_ASTERISK;
-case SDLK_8:
+break;
-keysym->sym = SDLK_ASTERISK;
+case SDLK_9:
-break;
+keysym->sym = SDLK_LEFTPAREN;
-case SDLK_9:
+break;
-keysym->sym = SDLK_LEFTPAREN;
+case SDLK_0:
-break;
+keysym->sym = SDLK_RIGHTPAREN;
-case SDLK_0:
+break;
-keysym->sym = SDLK_RIGHTPAREN;
+case SDLK_MINUS:
-break;
+keysym->sym = SDLK_UNDERSCORE;
-case SDLK_MINUS:
+break;
-keysym->sym = SDLK_UNDERSCORE;
+case SDLK_PLUS:
-break;
+keysym->sym = SDLK_EQUALS;
-case SDLK_PLUS:
+break;
-keysym->sym = SDLK_EQUALS;
-break;
+case SDLK_LEFTBRACKET:
+keysym->sym = '{';
-case SDLK_LEFTBRACKET:
+break;
-keysym->sym = '{';
+case SDLK_RIGHTBRACKET:
-break;
+keysym->sym = '}';
-case SDLK_RIGHTBRACKET:
+break;
-keysym->sym = '}';
-break;
+case SDLK_SEMICOLON:
+keysym->sym = SDLK_COLON;
-case SDLK_SEMICOLON:
+break;
-keysym->sym = SDLK_COLON;
+case SDLK_QUOTE:
-break;
+keysym->sym = SDLK_QUOTEDBL;
-case SDLK_QUOTE:
+break;
-keysym->sym = SDLK_QUOTEDBL;
+case SDLK_BACKSLASH:
-break;
+keysym->sym = '|';
-case SDLK_BACKSLASH:
+break;
-keysym->sym = '|';
-break;
+case SDLK_COMMA:
+keysym->sym = SDLK_LESS;
-case SDLK_COMMA:
+break;
-keysym->sym = SDLK_LESS;
+case SDLK_PERIOD:
-break;
+keysym->sym = SDLK_GREATER;
-case SDLK_PERIOD:
+break;
-keysym->sym = SDLK_GREATER;
+case SDLK_SLASH:
-break;
+keysym->sym = SDLK_QUESTION;
-case SDLK_SLASH:
+break;
-keysym->sym = SDLK_QUESTION;
-break;
+default:
+break;
-default:
+}
-break;
+}
-}
+return keysym;
-}
-return keysym;
 }
 #define CONVERTMOUSEPOSITION()  \
 /* We have to inverse the mouse position, because every non-os/2 system */                                                \
 /* has a coordinate system where the (0;0) is the top-left corner,      */                                                \
 // It handles switching back and away from the app (taking care of
 // going out and back to and from fullscreen mode), sending keystrokes
 // and mouse events to where it has to be sent, etc...
 //
 /////////////////////////////////////////////////////////////////////
-static MRESULT EXPENTRY WndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
+static MRESULT EXPENTRY
-{
+WndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
-HPS ps;
+{
-RECTL rcl;
+HPS ps;
-SDL_VideoDevice *pVideo = NULL;
+RECTL rcl;
+SDL_VideoDevice *pVideo = NULL;
-switch (msg)
-{
+switch (msg) {
-case WM_CHAR:  // Keypress notification
+case WM_CHAR:              // Keypress notification
 #ifdef DEBUG_BUILD
 //      printf("WM_CHAR\n"); fflush(stdout);
 #endif
 pVideo = WinQueryWindowPtr(hwnd, 0);
-if (pVideo)
+if (pVideo) {
-{
+/*
-/*
+// We skip repeated keys:
-// We skip repeated keys:
+if (CHARMSG(&msg)->cRepeat>1)
-if (CHARMSG(&msg)->cRepeat>1)
+{
+#ifdef DEBUG_BUILD
+//          printf("Repeated key (%d), skipping...\n", CHARMSG(&msg)->cRepeat); fflush(stdout);
+#endif
+return (MRESULT) TRUE;
+}
+*/
+// If it's not repeated, then let's see if its pressed or released!
+if (SHORT1FROMMP(mp1) & KC_KEYUP) {
+// A key has been released
+SDL_keysym keysym;
+#ifdef DEBUG_BUILD
+//          printf("WM_CHAR, keyup, code is [0x%0x]\n", CHAR4FROMMP(mp1)); // HW scan code
+#endif
+// One problem is with F1, which gets only the keyup message because
+// it is a system key.
+// So, when we get keyup message, we simulate keydown too!
+// UPDATE:
+//  This problem should be solved now, that the accelerator keys are
+//  disabled for this window!
+/*
+if (SHORT2FROMMP(mp2)==VK_F1)
+{
+SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(SHORT2FROMMP(mp2), // VK_ code
+SHORT1FROMMP(mp2), // Character code
+CHAR4FROMMP(mp1),  // HW Scan code
+&keysym,0));
+} */
+SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(SHORT2FROMMP(mp2),       // VK_ code
+SHORT1FROMMP(mp2),       // Character code
+CHAR4FROMMP(mp1),        // HW Scan code
+&keysym, 0));
+} else {
+// A key has been pressed
+SDL_keysym keysym;
+#ifdef DEBUG_BUILD
+//          printf("WM_CHAR, keydown, code is [0x%0x]\n", CHAR4FROMMP(mp1)); // HW scan code
+#endif
+// Check for fastkeys: ALT+HOME to toggle FS mode
+//                     ALT+END to close app
+if ((SHORT1FROMMP(mp1) & KC_ALT) &&
+(SHORT2FROMMP(mp2) == VK_HOME)) {
+#ifdef DEBUG_BUILD
+printf(" Pressed ALT+HOME!\n");
+fflush(stdout);
+#endif
+// Only switch between fullscreen and back if it's not
+// a resizable mode!
+if ((!pVideo->hidden->pSDLSurface) ||
+((pVideo->hidden->pSDLSurface)
+&&
+((pVideo->hidden->pSDLSurface->
+flags & SDL_RESIZABLE) == 0)))
+FSLib_ToggleFSMode(hwnd, !FSLib_QueryFSMode(hwnd));
+#ifdef DEBUG_BUILD
+else
+printf(" Resizable mode, so discarding ALT+HOME!\n");
+fflush(stdout);
+#endif
+} else if ((SHORT1FROMMP(mp1) & KC_ALT) &&
+(SHORT2FROMMP(mp2) == VK_END)) {
+#ifdef DEBUG_BUILD
+printf(" Pressed ALT+END!\n");
+fflush(stdout);
+#endif
+// Close window, and get out of loop!
+// Also send event to SDL application, but we won't
+// wait for it to be processed!
+SDL_PrivateQuit();
+WinPostMsg(hwnd, WM_QUIT, 0, 0);
+} else {
+SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(SHORT2FROMMP(mp2),    // VK_ code
+SHORT1FROMMP(mp2),    // Character code
+CHAR4FROMMP(mp1),     // HW Scan code
+&keysym,
+1));
+}
+}
+}
+return (MRESULT) TRUE;
+case WM_TRANSLATEACCEL:
 {
-#ifdef DEBUG_BUILD
+PQMSG pqmsg;
-//          printf("Repeated key (%d), skipping...\n", CHARMSG(&msg)->cRepeat); fflush(stdout);
+pqmsg = (PQMSG) mp1;
-#endif
+if (mp1) {
-return (MRESULT) TRUE;
+if (pqmsg->msg == WM_CHAR) {
-}
+// WM_CHAR message!
-*/
+// Let's filter the ALT keypress and all other acceleration keys!
+return (MRESULT) FALSE;
-// If it's not repeated, then let's see if its pressed or released!
+}
-if (SHORT1FROMMP(mp1) & KC_KEYUP)
+}
+break;              // Default processing (pass to parent until frame control)
+}
+case WM_PAINT:             // Window redraw!
+#ifdef DEBUG_BUILD
+printf("WM_PAINT (0x%x)\n", hwnd);
+fflush(stdout);
+#endif
+ps = WinBeginPaint(hwnd, 0, &rcl);
+pVideo = FSLib_GetUserParm(hwnd);
+if (pVideo) {
+if (!pVideo->hidden->pSDLSurface) {
+RECTL rclRect;
+// So, don't blit now!
+#ifdef DEBUG_BUILD
+printf("WM_PAINT : Skipping blit while resizing (Pre!)!\n");
+fflush(stdout);
+#endif
+WinQueryWindowRect(hwnd, &rclRect);
+// Fill with black
+WinFillRect(ps, &rclRect, CLR_BLACK);
+} else {
+if (DosRequestMutexSem
+(pVideo->hidden->hmtxUseSrcBuffer, 1000) == NO_ERROR) {
+int iTop, iLeft, iWidth, iHeight;
+int iXScaleError, iYScaleError;
+int iXScaleError2, iYScaleError2;
+SWP swp;
+// Re-blit the modified area!
+// For this, we have to calculate the points, scaled!
+WinQueryWindowPos(hwnd, &swp);
+#ifdef DEBUG_BUILD
+printf
+("WM_PAINT : WinSize: %d %d, BufSize: %d %d\n",
+swp.cx, swp.cy,
+pVideo->hidden->SrcBufferDesc.uiXResolution,
+pVideo->hidden->SrcBufferDesc.uiYResolution);
+fflush(stdout);
+#endif
+#ifndef RESIZE_EVEN_IF_RESIZABLE
+// But only blit if the window is not resizable, or if
+// the window is resizable and the source buffer size is the
+// same as the destination buffer size!
+if ((!pVideo->hidden->pSDLSurface) ||
+((pVideo->hidden->pSDLSurface) &&
+(pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE)
+&&
+((swp.cx !=
+pVideo->hidden->SrcBufferDesc.uiXResolution)
+|| (swp.cy !=
+pVideo->hidden->SrcBufferDesc.uiYResolution))
+&& (!FSLib_QueryFSMode(hwnd)))) {
+RECTL rclRect;
+// Resizable surface and in resizing!
+// So, don't blit now!
+#ifdef DEBUG_BUILD
+printf("WM_PAINT : Skipping blit while resizing!\n");
+fflush(stdout);
+#endif
+WinQueryWindowRect(hwnd, &rclRect);
+// Fill with black
+WinFillRect(ps, &rclRect, CLR_BLACK);
+} else
+#endif
+{
+iXScaleError =
+(pVideo->hidden->SrcBufferDesc.
+uiXResolution - 1) / swp.cx;
+iYScaleError =
+(pVideo->hidden->SrcBufferDesc.
+uiYResolution - 1) / swp.cy;
+if (iXScaleError < 0)
+iXScaleError = 0;
+if (iYScaleError < 0)
+iYScaleError = 0;
+iXScaleError2 =
+(swp.cx -
+1) /
+(pVideo->hidden->SrcBufferDesc.uiXResolution);
+iYScaleError2 =
+(swp.cy -
+1) /
+(pVideo->hidden->SrcBufferDesc.uiYResolution);
+if (iXScaleError2 < 0)
+iXScaleError2 = 0;
+if (iYScaleError2 < 0)
+iYScaleError2 = 0;
+iTop =
+(swp.cy -
+rcl.yTop) *
+pVideo->hidden->SrcBufferDesc.
+uiYResolution / swp.cy - iYScaleError;
+iLeft =
+rcl.xLeft *
+pVideo->hidden->SrcBufferDesc.
+uiXResolution / swp.cx - iXScaleError;
+iWidth =
+((rcl.xRight -
+rcl.xLeft) *
+pVideo->hidden->SrcBufferDesc.
+uiXResolution + swp.cx - 1) / swp.cx +
+2 * iXScaleError;
+iHeight =
+((rcl.yTop -
+rcl.yBottom) *
+pVideo->hidden->SrcBufferDesc.
+uiYResolution + swp.cy - 1) / swp.cy +
+2 * iYScaleError;
+iWidth += iXScaleError2;
+iHeight += iYScaleError2;
+if (iTop < 0)
+iTop = 0;
+if (iLeft < 0)
+iLeft = 0;
+if (iTop + iHeight >
+pVideo->hidden->SrcBufferDesc.uiYResolution)
+iHeight =
+pVideo->hidden->SrcBufferDesc.
+uiYResolution - iTop;
+if (iLeft + iWidth >
+pVideo->hidden->SrcBufferDesc.uiXResolution)
+iWidth =
+pVideo->hidden->SrcBufferDesc.
+uiXResolution - iLeft;
+#ifdef DEBUG_BUILD
+printf
+("WM_PAINT : BitBlt: %d %d -> %d %d (Buf %d x %d)\n",
+iTop, iLeft, iWidth, iHeight,
+pVideo->hidden->SrcBufferDesc.
+uiXResolution,
+pVideo->hidden->SrcBufferDesc.uiYResolution);
+fflush(stdout);
+#endif
+FSLIB_BITBLT(hwnd,
+pVideo->hidden->pchSrcBuffer,
+iTop, iLeft, iWidth, iHeight);
+}
+DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
+}
+}
+}
+#ifdef DEBUG_BUILD
+else {
+printf("WM_PAINT : No pVideo!\n");
+fflush(stdout);
+}
+#endif
+WinEndPaint(ps);
+#ifdef DEBUG_BUILD
+printf("WM_PAINT : Done.\n");
+fflush(stdout);
+#endif
+return 0;
+case WM_SIZE:
 {
-// A key has been released
+#ifdef DEBUG_BUILD
-SDL_keysym keysym;
+printf("WM_SIZE : (%d %d)\n",
+SHORT1FROMMP(mp2), SHORT2FROMMP(mp2));
-#ifdef DEBUG_BUILD
+fflush(stdout);
-//          printf("WM_CHAR, keyup, code is [0x%0x]\n", CHAR4FROMMP(mp1)); // HW scan code
+#endif
-#endif
+iWindowSizeX = SHORT1FROMMP(mp2);
+iWindowSizeY = SHORT2FROMMP(mp2);
-// One problem is with F1, which gets only the keyup message because
+bWindowResized = 1;
-// it is a system key.
-// So, when we get keyup message, we simulate keydown too!
+// Make sure the window will be redrawn
-// UPDATE:
+WinInvalidateRegion(hwnd, NULL, TRUE);
-//  This problem should be solved now, that the accelerator keys are
+}
-//  disabled for this window!
+break;
-/*
-if (SHORT2FROMMP(mp2)==VK_F1)
+case WM_FSLIBNOTIFICATION:
-{
+#ifdef DEBUG_BUILD
-SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(SHORT2FROMMP(mp2), // VK_ code
+printf("WM_FSLIBNOTIFICATION\n");
-SHORT1FROMMP(mp2), // Character code
+fflush(stdout);
-CHAR4FROMMP(mp1),  // HW Scan code
+#endif
-&keysym,0));
+if ((int) mp1 == FSLN_TOGGLEFSMODE) {
-}*/
+// FS mode changed, reblit image!
+pVideo = FSLib_GetUserParm(hwnd);
-SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(SHORT2FROMMP(mp2), // VK_ code
+if (pVideo) {
-SHORT1FROMMP(mp2), // Character code
+if (!pVideo->hidden->pSDLSurface) {
-CHAR4FROMMP(mp1),  // HW Scan code
+// Resizable surface and in resizing!
-&keysym,0));
+// So, don't blit now!
+#ifdef DEBUG_BUILD
-} else
+printf
-{
+("WM_FSLIBNOTIFICATION : Can not blit if there is no surface, doing nothing.\n");
-// A key has been pressed
+fflush(stdout);
-SDL_keysym keysym;
+#endif
+} else {
-#ifdef DEBUG_BUILD
+if (DosRequestMutexSem
-//          printf("WM_CHAR, keydown, code is [0x%0x]\n", CHAR4FROMMP(mp1)); // HW scan code
+(pVideo->hidden->hmtxUseSrcBuffer,
-#endif
+1000) == NO_ERROR) {
-// Check for fastkeys: ALT+HOME to toggle FS mode
+if (pVideo->hidden->pSDLSurface) {
-//                     ALT+END to close app
+#ifndef RESIZE_EVEN_IF_RESIZABLE
-if ((SHORT1FROMMP(mp1) & KC_ALT) &&
+SWP swp;
-(SHORT2FROMMP(mp2) == VK_HOME))
-{
+// But only blit if the window is not resizable, or if
-#ifdef DEBUG_BUILD
+// the window is resizable and the source buffer size is the
-printf(" Pressed ALT+HOME!\n"); fflush(stdout);
+// same as the destination buffer size!
-#endif
+WinQueryWindowPos(hwnd, &swp);
-// Only switch between fullscreen and back if it's not
+if ((!pVideo->hidden->pSDLSurface) ||
-// a resizable mode!
+((pVideo->hidden->pSDLSurface) &&
-if (
+(pVideo->hidden->pSDLSurface->
-(!pVideo->hidden->pSDLSurface) ||
+flags & SDL_RESIZABLE)
-((pVideo->hidden->pSDLSurface)
+&&
-&& ((pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE)==0)
+((swp.cx !=
-)
+pVideo->hidden->SrcBufferDesc.
-)
+uiXResolution)
-FSLib_ToggleFSMode(hwnd, !FSLib_QueryFSMode(hwnd));
+|| (swp.cy !=
-#ifdef DEBUG_BUILD
+pVideo->hidden->
-else
+SrcBufferDesc.uiYResolution))
-printf(" Resizable mode, so discarding ALT+HOME!\n"); fflush(stdout);
+&& (!FSLib_QueryFSMode(hwnd)))) {
-#endif
+// Resizable surface and in resizing!
-} else
+// So, don't blit now!
-if ((SHORT1FROMMP(mp1) & KC_ALT) &&
+#ifdef DEBUG_BUILD
-(SHORT2FROMMP(mp2) == VK_END))
+printf
-{
+("WM_FSLIBNOTIFICATION : Cannot blit while resizing, doing nothing.\n");
-#ifdef DEBUG_BUILD
+fflush(stdout);
-printf(" Pressed ALT+END!\n"); fflush(stdout);
+#endif
-#endif
+} else
-// Close window, and get out of loop!
+#endif
-// Also send event to SDL application, but we won't
+{
-// wait for it to be processed!
+#ifdef DEBUG_BUILD
+printf("WM_FSLIBNOTIFICATION : Blitting!\n");
+fflush(stdout);
+#endif
+FSLIB_BITBLT(hwnd,
+pVideo->hidden->
+pchSrcBuffer, 0,
+0,
+pVideo->hidden->
+SrcBufferDesc.
+uiXResolution,
+pVideo->hidden->
+SrcBufferDesc.uiYResolution);
+}
+}
+#ifdef DEBUG_BUILD
+else
+printf
+("WM_FSLIBNOTIFICATION : No public surface!\n");
+fflush(stdout);
+#endif
+DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
+}
+}
+}
+}
+return (MPARAM) 1;
+case WM_ACTIVATE:
+#ifdef DEBUG_BUILD
+printf("WM_ACTIVATE\n");
+fflush(stdout);
+#endif
+pVideo = FSLib_GetUserParm(hwnd);
+if (pVideo) {
+pVideo->hidden->fInFocus = (int) mp1;
+if (pVideo->hidden->fInFocus) {
+// Went into focus
+if ((pVideo->hidden->iMouseVisible)
+&& (!bMouseCaptured))
+WinSetPointer(HWND_DESKTOP,
+WinQuerySysPointer(HWND_DESKTOP,
+SPTR_ARROW, FALSE));
+else
+WinSetPointer(HWND_DESKTOP, NULL);
+if (bMouseCapturable) {
+// Re-capture the mouse, if we captured it before!
+WinSetCapture(HWND_DESKTOP, hwnd);
+bMouseCaptured = 1;
+{
+SWP swpClient;
+POINTL ptl;
+// Center the mouse to the middle of the window!
+WinQueryWindowPos(pVideo->hidden->hwndClient,
+&swpClient);
+ptl.x = 0;
+ptl.y = 0;
+WinMapWindowPoints(pVideo->hidden->
+hwndClient, HWND_DESKTOP, &ptl, 1);
+pVideo->hidden->iSkipWMMOUSEMOVE++;     /* Don't take next WM_MOUSEMOVE into account!  */
+WinSetPointerPos(HWND_DESKTOP,
+ptl.x + swpClient.cx / 2,
+ptl.y + swpClient.cy / 2);
+}
+}
+} else {
+// Went out of focus
+WinSetPointer(HWND_DESKTOP,
+WinQuerySysPointer(HWND_DESKTOP,
+SPTR_ARROW, FALSE));
+if (bMouseCaptured) {
+// Release the mouse
+WinSetCapture(HWND_DESKTOP, hwnd);
+bMouseCaptured = 0;
+}
+}
+}
+#ifdef DEBUG_BUILD
+printf("WM_ACTIVATE done\n");
+fflush(stdout);
+#endif
+break;
+case WM_BUTTON1DOWN:
+#ifdef DEBUG_BUILD
+printf("WM_BUTTON1DOWN\n");
+fflush(stdout);
+#endif
+pVideo = FSLib_GetUserParm(hwnd);
+if (pVideo) {
+SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0); // Don't report mouse movement!
+if (bMouseCapturable) {
+// We should capture the mouse!
+if (!bMouseCaptured) {
+WinSetCapture(HWND_DESKTOP, hwnd);
+WinSetPointer(HWND_DESKTOP, NULL);
+bMouseCaptured = 1;
+{
+SWP swpClient;
+POINTL ptl;
+// Center the mouse to the middle of the window!
+WinQueryWindowPos(pVideo->hidden->hwndClient,
+&swpClient);
+ptl.x = 0;
+ptl.y = 0;
+WinMapWindowPoints(pVideo->hidden->
+hwndClient, HWND_DESKTOP, &ptl, 1);
+pVideo->hidden->iSkipWMMOUSEMOVE++;     /* Don't take next WM_MOUSEMOVE into account!  */
+WinSetPointerPos(HWND_DESKTOP,
+ptl.x + swpClient.cx / 2,
+ptl.y + swpClient.cy / 2);
+}
+}
+}
+}
+break;
+case WM_BUTTON1UP:
+#ifdef DEBUG_BUILD
+printf("WM_BUTTON1UP\n");
+fflush(stdout);
+#endif
+SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);    // Don't report mouse movement!
+break;
+case WM_BUTTON2DOWN:
+#ifdef DEBUG_BUILD
+printf("WM_BUTTON2DOWN\n");
+fflush(stdout);
+#endif
+pVideo = FSLib_GetUserParm(hwnd);
+if (pVideo) {
+SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0);        // Don't report mouse movement!
+if (bMouseCapturable) {
+// We should capture the mouse!
+if (!bMouseCaptured) {
+WinSetCapture(HWND_DESKTOP, hwnd);
+WinSetPointer(HWND_DESKTOP, NULL);
+bMouseCaptured = 1;
+{
+SWP swpClient;
+POINTL ptl;
+// Center the mouse to the middle of the window!
+WinQueryWindowPos(pVideo->hidden->hwndClient,
+&swpClient);
+ptl.x = 0;
+ptl.y = 0;
+WinMapWindowPoints(pVideo->hidden->
+hwndClient, HWND_DESKTOP, &ptl, 1);
+pVideo->hidden->iSkipWMMOUSEMOVE++;     /* Don't take next WM_MOUSEMOVE into account!  */
+WinSetPointerPos(HWND_DESKTOP,
+ptl.x + swpClient.cx / 2,
+ptl.y + swpClient.cy / 2);
+}
+}
+}
+}
+break;
+case WM_BUTTON2UP:
+#ifdef DEBUG_BUILD
+printf("WM_BUTTON2UP\n");
+fflush(stdout);
+#endif
+SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0);   // Don't report mouse movement!
+break;
+case WM_BUTTON3DOWN:
+#ifdef DEBUG_BUILD
+printf("WM_BUTTON3DOWN\n");
+fflush(stdout);
+#endif
+pVideo = FSLib_GetUserParm(hwnd);
+if (pVideo) {
+SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_MIDDLE, 0, 0);       // Don't report mouse movement!
+if (bMouseCapturable) {
+// We should capture the mouse!
+if (!bMouseCaptured) {
+WinSetCapture(HWND_DESKTOP, hwnd);
+WinSetPointer(HWND_DESKTOP, NULL);
+bMouseCaptured = 1;
+{
+SWP swpClient;
+POINTL ptl;
+// Center the mouse to the middle of the window!
+WinQueryWindowPos(pVideo->hidden->hwndClient,
+&swpClient);
+ptl.x = 0;
+ptl.y = 0;
+WinMapWindowPoints(pVideo->hidden->
+hwndClient, HWND_DESKTOP, &ptl, 1);
+pVideo->hidden->iSkipWMMOUSEMOVE++;     /* Don't take next WM_MOUSEMOVE into account!  */
+WinSetPointerPos(HWND_DESKTOP,
+ptl.x + swpClient.cx / 2,
+ptl.y + swpClient.cy / 2);
+}
+}
+}
+}
+break;
+case WM_BUTTON3UP:
+#ifdef DEBUG_BUILD
+printf("WM_BUTTON3UP\n");
+fflush(stdout);
+#endif
+SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0);  // Don't report mouse movement!
+break;
+case WM_MOUSEMOVE:
+#ifdef DEBUG_BUILD
+//      printf("WM_MOUSEMOVE\n"); fflush(stdout);
+#endif
+pVideo = FSLib_GetUserParm(hwnd);
+if (pVideo) {
+if (pVideo->hidden->iSkipWMMOUSEMOVE) {
+pVideo->hidden->iSkipWMMOUSEMOVE--;
+} else {
+POINTS *ppts = (POINTS *) (&mp1);
+POINTL ptl;
+if (bMouseCaptured) {
+SWP swpClient;
+WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
+// Send relative mouse position, and re-center the mouse
+// Reposition the mouse to the center of the screen/window
+SDL_PrivateMouseMotion(0,   // Buttons not changed
+1,   // Relative position
+ppts->x -
+(swpClient.cx / 2),
+(swpClient.cy / 2) - ppts->y);
+ptl.x = 0;
+ptl.y = 0;
+WinMapWindowPoints(pVideo->hidden->hwndClient,
+HWND_DESKTOP, &ptl, 1);
+pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account!  */
+// Center the mouse to the middle of the window!
+WinSetPointerPos(HWND_DESKTOP,
+ptl.x + swpClient.cx / 2,
+ptl.y + swpClient.cy / 2);
+} else {
+CONVERTMOUSEPOSITION();
+// Send absolute mouse position
+SDL_PrivateMouseMotion(0,   // Buttons not changed
+0,   // Absolute position
+ppts->x, ppts->y);
+}
+}
+if ((pVideo->hidden->iMouseVisible) && (!bMouseCaptured)) {
+#ifdef DEBUG_BUILD
+//          printf("WM_MOUSEMOVE : ptr = %p\n", hptrGlobalPointer); fflush(stdout);
+#endif
+if (hptrGlobalPointer)
+WinSetPointer(HWND_DESKTOP, hptrGlobalPointer);
+else
+WinSetPointer(HWND_DESKTOP,
+WinQuerySysPointer(HWND_DESKTOP,
+SPTR_ARROW, FALSE));
+} else {
+WinSetPointer(HWND_DESKTOP, NULL);
+}
+}
+#ifdef DEBUG_BUILD
+//      printf("WM_MOUSEMOVE done\n"); fflush(stdout);
+#endif
+return (MRESULT) FALSE;
+case WM_CLOSE:             // Window close
+#ifdef DEBUG_BUILD
+printf("WM_CLOSE\n");
+fflush(stdout);
+#endif
+pVideo = FSLib_GetUserParm(hwnd);
+if (pVideo) {
+// Send Quit message to the SDL application!
 SDL_PrivateQuit();
-WinPostMsg(hwnd, WM_QUIT, 0, 0);
+return 0;
-} else
+}
-{
+break;
-SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(SHORT2FROMMP(mp2), // VK_ code
-SHORT1FROMMP(mp2), // Character code
-CHAR4FROMMP(mp1),  // HW Scan code
-&keysym,1));
-}
-}
-}
-return (MRESULT) TRUE;
-case WM_TRANSLATEACCEL:
-{
-PQMSG pqmsg;
-pqmsg = (PQMSG) mp1;
-if (mp1)
-{
-if (pqmsg->msg == WM_CHAR)
-{
-// WM_CHAR message!
-// Let's filter the ALT keypress and all other acceleration keys!
-return (MRESULT) FALSE;
-}
-}
-break; // Default processing (pass to parent until frame control)
-}
-case WM_PAINT:  // Window redraw!
-#ifdef DEBUG_BUILD
-printf("WM_PAINT (0x%x)\n", hwnd); fflush(stdout);
-#endif
-ps = WinBeginPaint(hwnd,0,&rcl);
-pVideo = FSLib_GetUserParm(hwnd);
-if (pVideo)
-{
-if (!pVideo->hidden->pSDLSurface)
-{
-RECTL rclRect;
-// So, don't blit now!
-#ifdef DEBUG_BUILD
-printf("WM_PAINT : Skipping blit while resizing (Pre!)!\n"); fflush(stdout);
-#endif
-WinQueryWindowRect(hwnd, &rclRect);
-// Fill with black
-WinFillRect(ps, &rclRect, CLR_BLACK);
-} else
-{
-if (DosRequestMutexSem(pVideo->hidden->hmtxUseSrcBuffer, 1000)==NO_ERROR)
-{
-int iTop, iLeft, iWidth, iHeight;
-int iXScaleError, iYScaleError;
-int iXScaleError2, iYScaleError2;
-SWP swp;
-// Re-blit the modified area!
-// For this, we have to calculate the points, scaled!
-WinQueryWindowPos(hwnd, &swp);
-#ifdef DEBUG_BUILD
-printf("WM_PAINT : WinSize: %d %d, BufSize: %d %d\n",
-swp.cx,
-swp.cy,
-pVideo->hidden->SrcBufferDesc.uiXResolution,
-pVideo->hidden->SrcBufferDesc.uiYResolution
-);
-fflush(stdout);
-#endif
-#ifndef RESIZE_EVEN_IF_RESIZABLE
-// But only blit if the window is not resizable, or if
-// the window is resizable and the source buffer size is the
-// same as the destination buffer size!
-if ((!pVideo->hidden->pSDLSurface) ||
-((pVideo->hidden->pSDLSurface) &&
-(pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
-((swp.cx != pVideo->hidden->SrcBufferDesc.uiXResolution) ||
-(swp.cy != pVideo->hidden->SrcBufferDesc.uiYResolution)
-) &&
-(!FSLib_QueryFSMode(hwnd))
-)
-)
-{
-RECTL rclRect;
-// Resizable surface and in resizing!
-// So, don't blit now!
-#ifdef DEBUG_BUILD
-printf("WM_PAINT : Skipping blit while resizing!\n"); fflush(stdout);
-#endif
-WinQueryWindowRect(hwnd, &rclRect);
-// Fill with black
-WinFillRect(ps, &rclRect, CLR_BLACK);
-} else
-#endif
-{
-iXScaleError = (pVideo->hidden->SrcBufferDesc.uiXResolution-1) / swp.cx;
-iYScaleError = (pVideo->hidden->SrcBufferDesc.uiYResolution-1) / swp.cy;
-if (iXScaleError<0) iXScaleError = 0;
-if (iYScaleError<0) iYScaleError = 0;
-iXScaleError2 = (swp.cx-1)/(pVideo->hidden->SrcBufferDesc.uiXResolution);
-iYScaleError2 = (swp.cy-1)/(pVideo->hidden->SrcBufferDesc.uiYResolution);
-if (iXScaleError2<0) iXScaleError2 = 0;
-if (iYScaleError2<0) iYScaleError2 = 0;
-iTop = (swp.cy - rcl.yTop) * pVideo->hidden->SrcBufferDesc.uiYResolution / swp.cy - iYScaleError;
-iLeft = rcl.xLeft * pVideo->hidden->SrcBufferDesc.uiXResolution / swp.cx - iXScaleError;
-iWidth = ((rcl.xRight-rcl.xLeft) * pVideo->hidden->SrcBufferDesc.uiXResolution + swp.cx-1)
-/ swp.cx + 2*iXScaleError;
-iHeight = ((rcl.yTop-rcl.yBottom) * pVideo->hidden->SrcBufferDesc.uiYResolution + swp.cy-1)
-/ swp.cy + 2*iYScaleError;
-iWidth+=iXScaleError2;
-iHeight+=iYScaleError2;
-if (iTop<0) iTop = 0;
-if (iLeft<0) iLeft = 0;
-if (iTop+iHeight>pVideo->hidden->SrcBufferDesc.uiYResolution) iHeight = pVideo->hidden->SrcBufferDesc.uiYResolution-iTop;
-if (iLeft+iWidth>pVideo->hidden->SrcBufferDesc.uiXResolution) iWidth = pVideo->hidden->SrcBufferDesc.uiXResolution-iLeft;
-#ifdef DEBUG_BUILD
-printf("WM_PAINT : BitBlt: %d %d -> %d %d (Buf %d x %d)\n",
-iTop, iLeft, iWidth, iHeight,
-pVideo->hidden->SrcBufferDesc.uiXResolution,
-pVideo->hidden->SrcBufferDesc.uiYResolution
-);
-fflush(stdout);
-#endif
-FSLIB_BITBLT(hwnd, pVideo->hidden->pchSrcBuffer, iTop, iLeft, iWidth, iHeight);
-}
-DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
-}
-}
-}
-#ifdef DEBUG_BUILD
-else
-{
-printf("WM_PAINT : No pVideo!\n"); fflush(stdout);
-}
-#endif
-WinEndPaint(ps);
-#ifdef DEBUG_BUILD
-printf("WM_PAINT : Done.\n");
-fflush(stdout);
-#endif
-return 0;
-case WM_SIZE:
-{
-#ifdef DEBUG_BUILD
-printf("WM_SIZE : (%d %d)\n",
-SHORT1FROMMP(mp2), SHORT2FROMMP(mp2)); fflush(stdout);
-#endif
-iWindowSizeX = SHORT1FROMMP(mp2);
-iWindowSizeY = SHORT2FROMMP(mp2);
-bWindowResized = 1;
-// Make sure the window will be redrawn
-WinInvalidateRegion(hwnd, NULL, TRUE);
-}
-break;
-case WM_FSLIBNOTIFICATION:
-#ifdef DEBUG_BUILD
-printf("WM_FSLIBNOTIFICATION\n"); fflush(stdout);
-#endif
-if ((int)mp1 == FSLN_TOGGLEFSMODE)
-{
-// FS mode changed, reblit image!
-pVideo = FSLib_GetUserParm(hwnd);
-if (pVideo)
-{
-if (!pVideo->hidden->pSDLSurface)
-{
-// Resizable surface and in resizing!
-// So, don't blit now!
-#ifdef DEBUG_BUILD
-printf("WM_FSLIBNOTIFICATION : Can not blit if there is no surface, doing nothing.\n"); fflush(stdout);
-#endif
-} else
-{
-if (DosRequestMutexSem(pVideo->hidden->hmtxUseSrcBuffer, 1000)==NO_ERROR)
-{
-if (pVideo->hidden->pSDLSurface)
-{
-#ifndef RESIZE_EVEN_IF_RESIZABLE
-SWP swp;
-// But only blit if the window is not resizable, or if
-// the window is resizable and the source buffer size is the
-// same as the destination buffer size!
-WinQueryWindowPos(hwnd, &swp);
-if ((!pVideo->hidden->pSDLSurface) ||
-(
-(pVideo->hidden->pSDLSurface) &&
-(pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
-((swp.cx != pVideo->hidden->SrcBufferDesc.uiXResolution) ||
-(swp.cy != pVideo->hidden->SrcBufferDesc.uiYResolution)
-) &&
-(!FSLib_QueryFSMode(hwnd))
-)
-)
-{
-// Resizable surface and in resizing!
-// So, don't blit now!
-#ifdef DEBUG_BUILD
-printf("WM_FSLIBNOTIFICATION : Cannot blit while resizing, doing nothing.\n"); fflush(stdout);
-#endif
-} else
-#endif
-{
-#ifdef DEBUG_BUILD
-printf("WM_FSLIBNOTIFICATION : Blitting!\n"); fflush(stdout);
-#endif
-FSLIB_BITBLT(hwnd, pVideo->hidden->pchSrcBuffer,
-0, 0,
-pVideo->hidden->SrcBufferDesc.uiXResolution,
-pVideo->hidden->SrcBufferDesc.uiYResolution);
-}
-}
-#ifdef DEBUG_BUILD
-else
-printf("WM_FSLIBNOTIFICATION : No public surface!\n"); fflush(stdout);
-#endif
-DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
-}
-}
-}
-}
-return (MPARAM) 1;
-case WM_ACTIVATE:
-#ifdef DEBUG_BUILD
-printf("WM_ACTIVATE\n"); fflush(stdout);
-#endif
-pVideo = FSLib_GetUserParm(hwnd);
-if (pVideo)
-{
-pVideo->hidden->fInFocus = (int) mp1;
-if (pVideo->hidden->fInFocus)
-{
-// Went into focus
-if ((pVideo->hidden->iMouseVisible) && (!bMouseCaptured))
-WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
-else
-WinSetPointer(HWND_DESKTOP, NULL);
-if (bMouseCapturable)
-{
-// Re-capture the mouse, if we captured it before!
-WinSetCapture(HWND_DESKTOP, hwnd);
-bMouseCaptured = 1;
-{
-SWP swpClient;
-POINTL ptl;
-// Center the mouse to the middle of the window!
-WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
-ptl.x = 0; ptl.y = 0;
-WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
-pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account!  */
-WinSetPointerPos(HWND_DESKTOP,
-ptl.x + swpClient.cx/2,
-ptl.y + swpClient.cy/2);
-}
-}
-} else
-{
-// Went out of focus
-WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
-if (bMouseCaptured)
-{
-// Release the mouse
-WinSetCapture(HWND_DESKTOP, hwnd);
-bMouseCaptured = 0;
-}
-}
-}
-#ifdef DEBUG_BUILD
-printf("WM_ACTIVATE done\n"); fflush(stdout);
-#endif
-break;
-case WM_BUTTON1DOWN:
-#ifdef DEBUG_BUILD
-printf("WM_BUTTON1DOWN\n"); fflush(stdout);
-#endif
-pVideo = FSLib_GetUserParm(hwnd);
-if (pVideo)
-{
-SDL_PrivateMouseButton(SDL_PRESSED,
-SDL_BUTTON_LEFT,
-0, 0); // Don't report mouse movement!
-if (bMouseCapturable)
-{
-// We should capture the mouse!
-if (!bMouseCaptured)
-{
-WinSetCapture(HWND_DESKTOP, hwnd);
-WinSetPointer(HWND_DESKTOP, NULL);
-bMouseCaptured = 1;
-{
-SWP swpClient;
-POINTL ptl;
-// Center the mouse to the middle of the window!
-WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
-ptl.x = 0; ptl.y = 0;
-WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
-pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account!  */
-WinSetPointerPos(HWND_DESKTOP,
-ptl.x + swpClient.cx/2,
-ptl.y + swpClient.cy/2);
-}
-}
-}
-}
-break;
-case WM_BUTTON1UP:
-#ifdef DEBUG_BUILD
-printf("WM_BUTTON1UP\n"); fflush(stdout);
-#endif
-SDL_PrivateMouseButton(SDL_RELEASED,
-SDL_BUTTON_LEFT,
-0, 0); // Don't report mouse movement!
-break;
-case WM_BUTTON2DOWN:
-#ifdef DEBUG_BUILD
-printf("WM_BUTTON2DOWN\n"); fflush(stdout);
-#endif
-pVideo = FSLib_GetUserParm(hwnd);
-if (pVideo)
-{
-SDL_PrivateMouseButton(SDL_PRESSED,
-SDL_BUTTON_RIGHT,
-0, 0); // Don't report mouse movement!
-if (bMouseCapturable)
-{
-// We should capture the mouse!
-if (!bMouseCaptured)
-{
-WinSetCapture(HWND_DESKTOP, hwnd);
-WinSetPointer(HWND_DESKTOP, NULL);
-bMouseCaptured = 1;
-{
-SWP swpClient;
-POINTL ptl;
-// Center the mouse to the middle of the window!
-WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
-ptl.x = 0; ptl.y = 0;
-WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
-pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account!  */
-WinSetPointerPos(HWND_DESKTOP,
-ptl.x + swpClient.cx/2,
-ptl.y + swpClient.cy/2);
-}
-}
-}
-}
-break;
-case WM_BUTTON2UP:
-#ifdef DEBUG_BUILD
-printf("WM_BUTTON2UP\n"); fflush(stdout);
-#endif
-SDL_PrivateMouseButton(SDL_RELEASED,
-SDL_BUTTON_RIGHT,
-0, 0); // Don't report mouse movement!
-break;
-case WM_BUTTON3DOWN:
-#ifdef DEBUG_BUILD
-printf("WM_BUTTON3DOWN\n"); fflush(stdout);
-#endif
-pVideo = FSLib_GetUserParm(hwnd);
-if (pVideo)
-{
-SDL_PrivateMouseButton(SDL_PRESSED,
-SDL_BUTTON_MIDDLE,
-0, 0); // Don't report mouse movement!
-if (bMouseCapturable)
-{
-// We should capture the mouse!
-if (!bMouseCaptured)
-{
-WinSetCapture(HWND_DESKTOP, hwnd);
-WinSetPointer(HWND_DESKTOP, NULL);
-bMouseCaptured = 1;
-{
-SWP swpClient;
-POINTL ptl;
-// Center the mouse to the middle of the window!
-WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
-ptl.x = 0; ptl.y = 0;
-WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
-pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account!  */
-WinSetPointerPos(HWND_DESKTOP,
-ptl.x + swpClient.cx/2,
-ptl.y + swpClient.cy/2);
-}
-}
-}
-}
-break;
-case WM_BUTTON3UP:
-#ifdef DEBUG_BUILD
-printf("WM_BUTTON3UP\n"); fflush(stdout);
-#endif
-SDL_PrivateMouseButton(SDL_RELEASED,
-SDL_BUTTON_MIDDLE,
-0, 0); // Don't report mouse movement!
-break;
-case WM_MOUSEMOVE:
-#ifdef DEBUG_BUILD
-//      printf("WM_MOUSEMOVE\n"); fflush(stdout);
-#endif
-pVideo = FSLib_GetUserParm(hwnd);
-if (pVideo)
-{
-if (pVideo->hidden->iSkipWMMOUSEMOVE)
-{
-pVideo->hidden->iSkipWMMOUSEMOVE--;
-} else
-{
-POINTS *ppts = (POINTS *) (&mp1);
-POINTL ptl;
-if (bMouseCaptured)
-{
-SWP swpClient;
-WinQueryWindowPos(pVideo->hidden->hwndClient, &swpClient);
-// Send relative mouse position, and re-center the mouse
-// Reposition the mouse to the center of the screen/window
-SDL_PrivateMouseMotion(0, // Buttons not changed
-1, // Relative position
-ppts->x - (swpClient.cx/2),
-(swpClient.cy/2) - ppts->y);
-ptl.x = 0; ptl.y = 0;
-WinMapWindowPoints(pVideo->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
-pVideo->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account!  */
-// Center the mouse to the middle of the window!
-WinSetPointerPos(HWND_DESKTOP,
-ptl.x + swpClient.cx/2,
-ptl.y + swpClient.cy/2);
-} else
-{
-CONVERTMOUSEPOSITION();
-// Send absolute mouse position
-SDL_PrivateMouseMotion(0, // Buttons not changed
-0, // Absolute position
-ppts->x,
-ppts->y);
-}
-}
-if ((pVideo->hidden->iMouseVisible) && (!bMouseCaptured))
-{
-#ifdef DEBUG_BUILD
-//          printf("WM_MOUSEMOVE : ptr = %p\n", hptrGlobalPointer); fflush(stdout);
-#endif
-if (hptrGlobalPointer)
-WinSetPointer(HWND_DESKTOP, hptrGlobalPointer);
-else
-WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
-}
-else
-{
-WinSetPointer(HWND_DESKTOP, NULL);
-}
-}
-#ifdef DEBUG_BUILD
-//      printf("WM_MOUSEMOVE done\n"); fflush(stdout);
-#endif
-return (MRESULT) FALSE;
-case WM_CLOSE: // Window close
-#ifdef DEBUG_BUILD
-printf("WM_CLOSE\n"); fflush(stdout);
-#endif
-pVideo = FSLib_GetUserParm(hwnd);
-if (pVideo)
-{
-// Send Quit message to the SDL application!
-SDL_PrivateQuit();
-return 0;
-}
-break;
 #ifdef BITBLT_IN_WINMESSAGEPROC
 case WM_UPDATERECTSREQUEST:
 pVideo = FSLib_GetUserParm(hwnd);
-if ((pVideo) && (pVideo->hidden->pSDLSurface))
+if ((pVideo) && (pVideo->hidden->pSDLSurface)) {
-{
+if (DosRequestMutexSem
-if (DosRequestMutexSem(pVideo->hidden->hmtxUseSrcBuffer, SEM_INDEFINITE_WAIT)==NO_ERROR)
+(pVideo->hidden->hmtxUseSrcBuffer,
-{
+SEM_INDEFINITE_WAIT) == NO_ERROR) {
 int numrects;
 SDL_Rect *rects;
 int i;
 SWP swp;
 numrects = (int) mp1;
 rects = (SDL_Rect *) mp2;
 WinQueryWindowPos(hwnd, &swp);
 #ifndef RESIZE_EVEN_IF_RESIZABLE
 if ((!pVideo->hidden->pSDLSurface) ||
-(
+((pVideo->hidden->pSDLSurface) &&
-(pVideo->hidden->pSDLSurface) &&
+(pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE)
-(pVideo->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
+&&
-((swp.cx != pVideo->hidden->SrcBufferDesc.uiXResolution) ||
+((swp.cx != pVideo->hidden->SrcBufferDesc.uiXResolution)
-(swp.cy != pVideo->hidden->SrcBufferDesc.uiYResolution)
+|| (swp.cy !=
-) &&
+pVideo->hidden->SrcBufferDesc.uiYResolution))
-(!FSLib_QueryFSMode(hwnd))
+&& (!FSLib_QueryFSMode(hwnd)))) {
-)
+// Resizable surface and in resizing!
-)
+// So, don't blit now!
-{
+#ifdef DEBUG_BUILD
-// Resizable surface and in resizing!
+printf
-// So, don't blit now!
+("[WM_UPDATERECTSREQUEST] : Skipping blit while resizing!\n");
-#ifdef DEBUG_BUILD
+fflush(stdout);
-printf("[WM_UPDATERECTSREQUEST] : Skipping blit while resizing!\n"); fflush(stdout);
+#endif
-#endif
+} else
-} else
+#endif
-#endif
+{
-{
+#ifdef DEBUG_BUILD
-#ifdef DEBUG_BUILD
+printf("[WM_UPDATERECTSREQUEST] : Blitting!\n");
-printf("[WM_UPDATERECTSREQUEST] : Blitting!\n"); fflush(stdout);
+fflush(stdout);
 #endif
 // Blit the changed areas
-for (i=0; i<numrects; i++)
+for (i = 0; i < numrects; i++)
-FSLIB_BITBLT(hwnd, pVideo->hidden->pchSrcBuffer,
+FSLIB_BITBLT(hwnd,
-rects[i].y, rects[i].x, rects[i].w, rects[i].h);
+pVideo->hidden->pchSrcBuffer,
-}
+rects[i].y, rects[i].x,
-DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
+rects[i].w, rects[i].h);
 }
-}
+DosReleaseMutexSem(pVideo->hidden->hmtxUseSrcBuffer);
-return 0;
+}
+}
+return 0;
 #endif
 default:
 #ifdef DEBUG_BUILD
-printf("Unhandled: %x\n", msg); fflush(stdout);
+printf("Unhandled: %x\n", msg);
-#endif
+fflush(stdout);
+#endif
-break;
-}
+break;
-// Run the default window procedure for unhandled stuffs
+}
-return WinDefWindowProc(hwnd, msg, mp1, mp2);
+// Run the default window procedure for unhandled stuffs
+return WinDefWindowProc(hwnd, msg, mp1, mp2);
 }
 /////////////////////////////////////////////////////////////////////
 //
 // FrameWndProc
 //
 // This is the message processing window procedure for the
 // frame window of SDLWindowClass.
 //
 /////////////////////////////////////////////////////////////////////
-static MRESULT EXPENTRY FrameWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
+static MRESULT EXPENTRY
-{
+FrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
-PFNWP pOldFrameProc;
+{
-MRESULT result;
+PFNWP pOldFrameProc;
-PTRACKINFO ti;
+MRESULT result;
-int cx, cy, ncx, ncy;
+PTRACKINFO ti;
-RECTL rclTemp;
+int cx, cy, ncx, ncy;
-PSWP pswpTemp;
+RECTL rclTemp;
+PSWP pswpTemp;
-SDL_VideoDevice *pVideo = NULL;
+SDL_VideoDevice *pVideo = NULL;
-pVideo = (SDL_VideoDevice *) WinQueryWindowULong(hwnd, QWL_USER);
+pVideo = (SDL_VideoDevice *) WinQueryWindowULong(hwnd, QWL_USER);
-pOldFrameProc = pVideo->hidden->pfnOldFrameProc;
+pOldFrameProc = pVideo->hidden->pfnOldFrameProc;
-if ((pVideo->hidden->bProportionalResize) &&
-(msg==WM_ADJUSTWINDOWPOS) &&
+if ((pVideo->hidden->bProportionalResize) &&
-(!FSLib_QueryFSMode(pVideo->hidden->hwndClient))
+(msg == WM_ADJUSTWINDOWPOS) &&
-)
+(!FSLib_QueryFSMode(pVideo->hidden->hwndClient))) {
-{
+pswpTemp = (PSWP) mp1;
-pswpTemp = (PSWP) mp1;
+/* Resizing? */
-/* Resizing? */
+if (pswpTemp->fl & SWP_SIZE) {
-if (pswpTemp->fl & SWP_SIZE)
+/* Calculate client size */
-{
+rclTemp.xLeft = pswpTemp->x;
-/* Calculate client size */
+rclTemp.xRight = pswpTemp->x + pswpTemp->cx;
-rclTemp.xLeft = pswpTemp->x;
+rclTemp.yBottom = pswpTemp->y;
-rclTemp.xRight = pswpTemp->x + pswpTemp->cx;
+rclTemp.yTop = pswpTemp->y + pswpTemp->cy;
-rclTemp.yBottom = pswpTemp->y;
+WinCalcFrameRect(hwnd, &rclTemp, TRUE);
-rclTemp.yTop = pswpTemp->y + pswpTemp->cy;
-WinCalcFrameRect(hwnd, &rclTemp, TRUE);
+ncx = cx = rclTemp.xRight - rclTemp.xLeft;
+ncy = cy = rclTemp.yTop - rclTemp.yBottom;
-ncx = cx = rclTemp.xRight - rclTemp.xLeft;
-ncy = cy = rclTemp.yTop - rclTemp.yBottom;
+/* Calculate new size to keep it proportional */
-/* Calculate new size to keep it proportional */
+if ((pVideo->hidden->ulResizingFlag & TF_LEFT)
+|| (pVideo->hidden->ulResizingFlag & TF_RIGHT)) {
-if ((pVideo->hidden->ulResizingFlag & TF_LEFT) || (pVideo->hidden->ulResizingFlag & TF_RIGHT))
+/* The window is resized horizontally */
-{
+ncy =
-/* The window is resized horizontally */
+pVideo->hidden->SrcBufferDesc.uiYResolution * cx /
-ncy = pVideo->hidden->SrcBufferDesc.uiYResolution * cx / pVideo->hidden->SrcBufferDesc.uiXResolution;
+pVideo->hidden->SrcBufferDesc.uiXResolution;
-} else
+} else if ((pVideo->hidden->ulResizingFlag & TF_TOP)
-if ((pVideo->hidden->ulResizingFlag & TF_TOP) || (pVideo->hidden->ulResizingFlag & TF_BOTTOM))
+|| (pVideo->hidden->ulResizingFlag & TF_BOTTOM)) {
-{
+/* The window is resized vertically */
-/* The window is resized vertically */
+ncx =
-ncx = pVideo->hidden->SrcBufferDesc.uiXResolution * cy / pVideo->hidden->SrcBufferDesc.uiYResolution;
+pVideo->hidden->SrcBufferDesc.uiXResolution * cy /
-}
+pVideo->hidden->SrcBufferDesc.uiYResolution;
+}
-/* Calculate back frame coordinates */
-rclTemp.xLeft = pswpTemp->x;
+/* Calculate back frame coordinates */
-rclTemp.xRight = pswpTemp->x + ncx;
+rclTemp.xLeft = pswpTemp->x;
-rclTemp.yBottom = pswpTemp->y;
+rclTemp.xRight = pswpTemp->x + ncx;
-rclTemp.yTop = pswpTemp->y + ncy;
+rclTemp.yBottom = pswpTemp->y;
-WinCalcFrameRect(hwnd, &rclTemp, FALSE);
+rclTemp.yTop = pswpTemp->y + ncy;
+WinCalcFrameRect(hwnd, &rclTemp, FALSE);
-/* Store new size/position info */
-pswpTemp->cx = rclTemp.xRight - rclTemp.xLeft;
+/* Store new size/position info */
+pswpTemp->cx = rclTemp.xRight - rclTemp.xLeft;
-if (!(pVideo->hidden->ulResizingFlag & TF_TOP))
-{
+if (!(pVideo->hidden->ulResizingFlag & TF_TOP)) {
-pswpTemp->y = pswpTemp->y + pswpTemp->cy - (rclTemp.yTop - rclTemp.yBottom);
+pswpTemp->y =
-pswpTemp->cy = rclTemp.yTop - rclTemp.yBottom;
+pswpTemp->y + pswpTemp->cy - (rclTemp.yTop -
-} else
+rclTemp.yBottom);
-{
+pswpTemp->cy = rclTemp.yTop - rclTemp.yBottom;
-pswpTemp->cy = rclTemp.yTop - rclTemp.yBottom;
+} else {
-}
+pswpTemp->cy = rclTemp.yTop - rclTemp.yBottom;
 }
 }
+}
-result = (*pOldFrameProc)(hwnd, msg, mp1, mp2);
+result = (*pOldFrameProc) (hwnd, msg, mp1, mp2);
-if ((pVideo->hidden->bProportionalResize) && (msg==WM_QUERYTRACKINFO))
-{
+if ((pVideo->hidden->bProportionalResize) && (msg == WM_QUERYTRACKINFO)) {
 ti = (PTRACKINFO) mp2;
 /* Store the direction of resizing */
 if ((ti->fs & TF_LEFT) || (ti->fs & TF_RIGHT) ||
 (ti->fs & TF_TOP) || (ti->fs & TF_BOTTOM))
 pVideo->hidden->ulResizingFlag = ti->fs;
 }
 return result;
 }
 /////////////////////////////////////////////////////////////////////
 //
 // PMThreadFunc
 //
 // This function implements the PM-Thread, which initializes the
 // application window itself, the DIVE, and start message processing.
 //
 /////////////////////////////////////////////////////////////////////
-int iNumOfPMThreadInstances = 0; // Global!
+int iNumOfPMThreadInstances = 0;        // Global!
-static void PMThreadFunc(void *pParm)
+static void
-{
+PMThreadFunc(void *pParm)
-SDL_VideoDevice *pVideo = pParm;
+{
-HAB hab;
+SDL_VideoDevice *pVideo = pParm;
-HMQ hmq;
+HAB hab;
-QMSG msg;
+HMQ hmq;
-ULONG fcf;
+QMSG msg;
+ULONG fcf;
-#ifdef DEBUG_BUILD
-printf("[PMThreadFunc] : Starting\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[PMThreadFunc] : Starting\n");
-iNumOfPMThreadInstances++;
-// Initialize PM, create a message queue.
-hab=WinInitialize(0);
-hmq=WinCreateMsgQueue(hab,0);
-if (hmq==0)
-{
-#ifdef DEBUG_BUILD
-printf("[PMThreadFunc] : Could not create message queue!\n");
-printf("                 It might be that the application using SDL is not a PM app!\n");
 fflush(stdout);
 #endif
-pVideo->hidden->iPMThreadStatus = 2;
-} else
+iNumOfPMThreadInstances++;
-{
-int rc;
+// Initialize PM, create a message queue.
-RECTL rectl;
+hab = WinInitialize(0);
-fcf = ulFCFToUse; // Get from global setting
+hmq = WinCreateMsgQueue(hab, 0);
+if (hmq == 0) {
 #ifdef DEBUG_BUILD
-printf("[PMThreadFunc] : FSLib_CreateWindow()!\n");
+printf("[PMThreadFunc] : Could not create message queue!\n");
+printf
+("                 It might be that the application using SDL is not a PM app!\n");
+fflush(stdout);
+#endif
+pVideo->hidden->iPMThreadStatus = 2;
+} else {
+int rc;
+RECTL rectl;
+fcf = ulFCFToUse;       // Get from global setting
+#ifdef DEBUG_BUILD
+printf("[PMThreadFunc] : FSLib_CreateWindow()!\n");
+fflush(stdout);
+#endif
+rc = FSLib_CreateWindow(HWND_DESKTOP, 0, &fcf,
+"SDL Application",
+NULLHANDLE, 0,
+&(pVideo->hidden->SrcBufferDesc),
+WndProc,
+&(pVideo->hidden->hwndClient),
+&(pVideo->hidden->hwndFrame));
+#ifdef DEBUG_BUILD
+printf("[PMThreadFunc] : FSLib_CreateWindow() rc = %d\n", rc);
+fflush(stdout);
+#endif
+if (!rc) {
+#ifdef DEBUG_BUILD
+printf("[PMThreadFunc] : Could not create FSLib window!\n");
+fflush(stdout);
+#endif
+pVideo->hidden->iPMThreadStatus = 3;
+} else {
+#ifdef DEBUG_BUILD
+printf("[PMThreadFunc] : FSLib_AddUserParm()!\n");
+fflush(stdout);
+#endif
+// Store pVideo pointer in window data for client window, so
+// it will know the instance to which it belongs to.
+FSLib_AddUserParm(pVideo->hidden->hwndClient, pVideo);
+// Now set default image width height and fourcc!
+#ifdef DEBUG_BUILD
+printf("[PMThreadFunc] : SetWindowPos()!\n");
+fflush(stdout);
+#endif
+// Set the position and size of the main window,
+// and make it visible!
+// Calculate frame window size from client window size
+rectl.xLeft = 0;
+rectl.yBottom = 0;
+rectl.xRight = pVideo->hidden->SrcBufferDesc.uiXResolution; // Noninclusive
+rectl.yTop = pVideo->hidden->SrcBufferDesc.uiYResolution;   // Noninclusive
+WinCalcFrameRect(pVideo->hidden->hwndFrame, &rectl, FALSE);
+SetAccessableWindowPos(pVideo->hidden->hwndFrame,
+HWND_TOP,
+(WinQuerySysValue
+(HWND_DESKTOP,
+SV_CXSCREEN) - (rectl.xRight -
+rectl.xLeft)) / 2,
+(WinQuerySysValue
+(HWND_DESKTOP,
+SV_CYSCREEN) - (rectl.yTop -
+rectl.yBottom)) / 2,
+(rectl.xRight - rectl.xLeft),
+(rectl.yTop - rectl.yBottom),
+SWP_SIZE | SWP_ACTIVATE | SWP_SHOW |
+SWP_MOVE);
+// Subclass frame procedure and store old window proc address
+pVideo->hidden->pfnOldFrameProc =
+WinSubclassWindow(pVideo->hidden->hwndFrame, FrameWndProc);
+WinSetWindowULong(pVideo->hidden->hwndFrame, QWL_USER,
+(ULONG) pVideo);
+#ifdef DEBUG_BUILD
+printf("[PMThreadFunc] : Entering message loop\n");
+fflush(stdout);
+#endif
+pVideo->hidden->iPMThreadStatus = 1;
+while (WinGetMsg(hab, (PQMSG) & msg, 0, 0, 0))
+WinDispatchMsg(hab, (PQMSG) & msg);
+#ifdef DEBUG_BUILD
+printf("[PMThreadFunc] : Leaving message loop\n");
+fflush(stdout);
+#endif
+// We should release the captured the mouse!
+if (bMouseCaptured) {
+WinSetCapture(HWND_DESKTOP, NULLHANDLE);
+bMouseCaptured = 0;
+}
+// Destroy our window
+WinDestroyWindow(pVideo->hidden->hwndFrame);
+pVideo->hidden->hwndFrame = NULL;
+// Show pointer to make sure it will not be left hidden.
+WinSetPointer(HWND_DESKTOP,
+WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW,
+FALSE));
+WinShowPointer(HWND_DESKTOP, TRUE);
+}
+// Uninitialize PM
+WinDestroyMsgQueue(hmq);
+// All done!
+pVideo->hidden->iPMThreadStatus = 0;
+}
+WinTerminate(hab);
+/* Commented out, should not be needed anymore, because we send it
+from WM_CLOSE.
+// Notify SDL that it should really die now...
+SDL_PrivateQuit(); SDL_PrivateQuit(); SDL_PrivateQuit(); //... :))
+*/
+#ifdef DEBUG_BUILD
+printf("[PMThreadFunc] : End, status is %d!\n",
+pVideo->hidden->iPMThreadStatus);
 fflush(stdout);
 #endif
-rc = FSLib_CreateWindow(HWND_DESKTOP, 0, &fcf,
+iNumOfPMThreadInstances--;
-"SDL Application",
-NULLHANDLE, 0,
+// HACK to prevent zombie and hanging SDL applications, which does not take
-&(pVideo->hidden->SrcBufferDesc),
+// care of closing the window for some reason:
-WndProc,
+// There are some apps which do not process messages, so do a lot of things
-&(pVideo->hidden->hwndClient),
+// without noticing that the application should close. To close these,
-&(pVideo->hidden->hwndFrame));
+// I've thought about the following:
+// If the window is closed (the execution came here), I wait a bit to
-#ifdef DEBUG_BUILD
+// give time to the app to finish its execution. If it does not, I kill it
-printf("[PMThreadFunc] : FSLib_CreateWindow() rc = %d\n", rc);
+// using DosExit(). Brute force, but should work.
+if (pVideo->hidden->iPMThreadStatus == 0) {
+DosSleep(5000);         // Wait 5 secs
+// If a new PM thread has been spawned (reinitializing video mode), then all right.
+// Otherwise, we have a problem, the app doesn't want to stop. Kill!
+if (iNumOfPMThreadInstances == 0) {
+#ifdef DEBUG_BUILD
+printf
+("[PMThreadFunc] : It seems that the application haven't terminated itself\n");
+fflush(stdout);
+printf
+("[PMThreadFunc] : in the last 5 seconds, so we go berserk.\n");
+fflush(stdout);
+printf
+("[PMThreadFunc] : Brute force mode. :) Killing process! Dieeeee...\n");
+fflush(stdout);
+#endif
+DosExit(EXIT_PROCESS, -1);
+}
+}
+_endthread();
+}
+struct WMcursor
+{
+HBITMAP hbm;
+HPOINTER hptr;
+char *pchData;
+};
+/* Free a window manager cursor */
+void
+os2fslib_FreeWMCursor(_THIS, WMcursor * cursor)
+{
+if (cursor) {
+GpiDeleteBitmap(cursor->hbm);
+WinDestroyPointer(cursor->hptr);
+SDL_free(cursor->pchData);
+SDL_free(cursor);
+}
+}
+/* Local functions to convert the SDL cursor mask into OS/2 format */
+static void
+memnot(Uint8 * dst, Uint8 * src, int len)
+{
+while (len-- > 0)
+*dst++ = ~*src++;
+}
+static void
+memxor(Uint8 * dst, Uint8 * src1, Uint8 * src2, int len)
+{
+while (len-- > 0)
+*dst++ = (*src1++) ^ (*src2++);
+}
+/* Create a black/white window manager cursor */
+WMcursor *
+os2fslib_CreateWMCursor_Win(_THIS, Uint8 * data, Uint8 * mask,
+int w, int h, int hot_x, int hot_y)
+{
+HPOINTER hptr;
+HBITMAP hbm;
+BITMAPINFOHEADER bmih;
+BMPINFO bmi;
+HPS hps;
+char *pchTemp;
+char *xptr, *aptr;
+int maxx, maxy;
+int i, run, pad;
+WMcursor *pResult;
+maxx = WinQuerySysValue(HWND_DESKTOP, SV_CXPOINTER);
+maxy = WinQuerySysValue(HWND_DESKTOP, SV_CYPOINTER);
+// Check for max size!
+if ((w > maxx) || (h > maxy))
+return (WMcursor *) NULL;
+pResult = (WMcursor *) SDL_malloc(sizeof(WMcursor));
+if (!pResult)
+return (WMcursor *) NULL;
+pchTemp = (char *) SDL_malloc((maxx + 7) / 8 * maxy * 2);
+if (!pchTemp) {
+SDL_free(pResult);
+return (WMcursor *) NULL;
+}
+SDL_memset(pchTemp, 0, (maxx + 7) / 8 * maxy * 2);
+hps = WinGetPS(_this->hidden->hwndClient);
+bmi.cbFix = sizeof(BITMAPINFOHEADER);
+bmi.cx = maxx;
+bmi.cy = 2 * maxy;
+bmi.cPlanes = 1;
+bmi.cBitCount = 1;
+bmi.argbColor[0].bBlue = 0x00;
+bmi.argbColor[0].bGreen = 0x00;
+bmi.argbColor[0].bRed = 0x00;
+bmi.argbColor[1].bBlue = 0x00;
+bmi.argbColor[1].bGreen = 0x00;
+bmi.argbColor[1].bRed = 0xff;
+SDL_memset(&bmih, 0, sizeof(BITMAPINFOHEADER));
+bmih.cbFix = sizeof(BITMAPINFOHEADER);
+bmih.cx = maxx;
+bmih.cy = 2 * maxy;
+bmih.cPlanes = 1;
+bmih.cBitCount = 1;
+run = (w + 7) / 8;
+pad = (maxx + 7) / 8 - run;
+for (i = 0; i < h; i++) {
+xptr = pchTemp + (maxx + 7) / 8 * (maxy - 1 - i);
+aptr = pchTemp + (maxx + 7) / 8 * (maxy + maxy - 1 - i);
+memxor(xptr, data, mask, run);
+xptr += run;
+data += run;
+memnot(aptr, mask, run);
+mask += run;
+aptr += run;
+SDL_memset(xptr, 0, pad);
+xptr += pad;
+SDL_memset(aptr, ~0, pad);
+aptr += pad;
+}
+pad += run;
+for (i = h; i < maxy; i++) {
+xptr = pchTemp + (maxx + 7) / 8 * (maxy - 1 - i);
+aptr = pchTemp + (maxx + 7) / 8 * (maxy + maxy - 1 - i);
+SDL_memset(xptr, 0, (maxx + 7) / 8);
+xptr += (maxx + 7) / 8;
+SDL_memset(aptr, ~0, (maxx + 7) / 8);
+aptr += (maxx + 7) / 8;
+}
+hbm =
+GpiCreateBitmap(hps, (PBITMAPINFOHEADER2) & bmih, CBM_INIT,
+(PBYTE) pchTemp, (PBITMAPINFO2) & bmi);
+hptr = WinCreatePointer(HWND_DESKTOP, hbm, TRUE, hot_x, maxy - hot_y - 1);
+#ifdef DEBUG_BUILD
+printf("HotSpot          : %d ; %d\n", hot_x, hot_y);
+printf("HPS returned     : %x\n", (ULONG) hps);
+printf("HBITMAP returned : %x\n", (ULONG) hbm);
+printf("HPOINTER returned: %x\n", (ULONG) hptr);
+#endif
+WinReleasePS(hps);
+#ifdef DEBUG_BUILD
+printf("[CreateWMCursor] : ptr = %p\n", hptr);
 fflush(stdout);
 #endif
-if (!rc)
+pResult->hptr = hptr;
-{
+pResult->hbm = hbm;
-#ifdef DEBUG_BUILD
+pResult->pchData = pchTemp;
-printf("[PMThreadFunc] : Could not create FSLib window!\n");
-fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[CreateWMCursor] : ptr = %p return.\n", hptr);
-pVideo->hidden->iPMThreadStatus = 3;
+fflush(stdout);
-} else
+#endif
-{
-#ifdef DEBUG_BUILD
+return (WMcursor *) pResult;
-printf("[PMThreadFunc] : FSLib_AddUserParm()!\n");
+}
-fflush(stdout);
-#endif
+WMcursor *
+os2fslib_CreateWMCursor_FS(_THIS, Uint8 * data, Uint8 * mask,
-// Store pVideo pointer in window data for client window, so
+int w, int h, int hot_x, int hot_y)
-// it will know the instance to which it belongs to.
+{
-FSLib_AddUserParm(pVideo->hidden->hwndClient, pVideo);
+#ifdef DEBUG_BUILD
+printf("[CreateWMCursor_FS] : returning pointer NULL\n");
-// Now set default image width height and fourcc!
+fflush(stdout);
-#ifdef DEBUG_BUILD
+#endif
-printf("[PMThreadFunc] : SetWindowPos()!\n");
-fflush(stdout);
+// In FS mode we'll use software cursor
-#endif
-// Set the position and size of the main window,
-// and make it visible!
-// Calculate frame window size from client window size
-rectl.xLeft = 0;
-rectl.yBottom = 0;
-rectl.xRight = pVideo->hidden->SrcBufferDesc.uiXResolution; // Noninclusive
-rectl.yTop = pVideo->hidden->SrcBufferDesc.uiYResolution; // Noninclusive
-WinCalcFrameRect(pVideo->hidden->hwndFrame, &rectl, FALSE);
-SetAccessableWindowPos(pVideo->hidden->hwndFrame,
-HWND_TOP,
-(WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN) - (rectl.xRight-rectl.xLeft)) / 2,
-(WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN) - (rectl.yTop-rectl.yBottom)) / 2,
-(rectl.xRight-rectl.xLeft),
-(rectl.yTop-rectl.yBottom),
-SWP_SIZE | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE);
-// Subclass frame procedure and store old window proc address
-pVideo->hidden->pfnOldFrameProc =
-WinSubclassWindow(pVideo->hidden->hwndFrame, FrameWndProc);
-WinSetWindowULong(pVideo->hidden->hwndFrame, QWL_USER, (ULONG) pVideo);
-#ifdef DEBUG_BUILD
-printf("[PMThreadFunc] : Entering message loop\n"); fflush(stdout);
-#endif
-pVideo->hidden->iPMThreadStatus = 1;
-while (WinGetMsg(hab, (PQMSG)&msg, 0, 0, 0))
-WinDispatchMsg(hab, (PQMSG) &msg);
-#ifdef DEBUG_BUILD
-printf("[PMThreadFunc] : Leaving message loop\n"); fflush(stdout);
-#endif
-// We should release the captured the mouse!
-if (bMouseCaptured)
-{
-WinSetCapture(HWND_DESKTOP, NULLHANDLE);
-bMouseCaptured = 0;
-}
-// Destroy our window
-WinDestroyWindow(pVideo->hidden->hwndFrame); pVideo->hidden->hwndFrame=NULL;
-// Show pointer to make sure it will not be left hidden.
-WinSetPointer(HWND_DESKTOP, WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE));
-WinShowPointer(HWND_DESKTOP, TRUE);
-}
-// Uninitialize PM
-WinDestroyMsgQueue(hmq);
-// All done!
-pVideo->hidden->iPMThreadStatus = 0;
-}
-WinTerminate(hab);
-/* Commented out, should not be needed anymore, because we send it
-from WM_CLOSE.
-// Notify SDL that it should really die now...
-SDL_PrivateQuit(); SDL_PrivateQuit(); SDL_PrivateQuit(); //... :))
-*/
-#ifdef DEBUG_BUILD
-printf("[PMThreadFunc] : End, status is %d!\n", pVideo->hidden->iPMThreadStatus); fflush(stdout);
-#endif
-iNumOfPMThreadInstances--;
-// HACK to prevent zombie and hanging SDL applications, which does not take
-// care of closing the window for some reason:
-// There are some apps which do not process messages, so do a lot of things
-// without noticing that the application should close. To close these,
-// I've thought about the following:
-// If the window is closed (the execution came here), I wait a bit to
-// give time to the app to finish its execution. If it does not, I kill it
-// using DosExit(). Brute force, but should work.
-if (pVideo->hidden->iPMThreadStatus==0)
-{
-DosSleep(5000); // Wait 5 secs
-// If a new PM thread has been spawned (reinitializing video mode), then all right.
-// Otherwise, we have a problem, the app doesn't want to stop. Kill!
-if (iNumOfPMThreadInstances==0)
-{
-#ifdef DEBUG_BUILD
-printf("[PMThreadFunc] : It seems that the application haven't terminated itself\n"); fflush(stdout);
-printf("[PMThreadFunc] : in the last 5 seconds, so we go berserk.\n"); fflush(stdout);
-printf("[PMThreadFunc] : Brute force mode. :) Killing process! Dieeeee...\n"); fflush(stdout);
-#endif
-DosExit(EXIT_PROCESS, -1);
-}
-}
-_endthread();
-}
-struct WMcursor
-{
-HBITMAP hbm;
-HPOINTER hptr;
-char *pchData;
-};
-/* Free a window manager cursor */
-void os2fslib_FreeWMCursor(_THIS, WMcursor *cursor)
-{
-if (cursor)
-{
-GpiDeleteBitmap(cursor->hbm);
-WinDestroyPointer(cursor->hptr);
-SDL_free(cursor->pchData);
-SDL_free(cursor);
-}
-}
-/* Local functions to convert the SDL cursor mask into OS/2 format */
-static void memnot(Uint8 *dst, Uint8 *src, int len)
-{
-while ( len-- > 0 )
-*dst++ = ~*src++;
-}
-static void memxor(Uint8 *dst, Uint8 *src1, Uint8 *src2, int len)
-{
-while ( len-- > 0 )
-*dst++ = (*src1++)^(*src2++);
-}
-/* Create a black/white window manager cursor */
-WMcursor *os2fslib_CreateWMCursor_Win(_THIS, Uint8 *data, Uint8 *mask,
-int w, int h, int hot_x, int hot_y)
-{
-HPOINTER hptr;
-HBITMAP hbm;
-BITMAPINFOHEADER bmih;
-BMPINFO          bmi;
-HPS              hps;
-char *pchTemp;
-char *xptr, *aptr;
-int maxx, maxy;
-int i, run, pad;
-WMcursor *pResult;
-maxx = WinQuerySysValue(HWND_DESKTOP, SV_CXPOINTER);
-maxy = WinQuerySysValue(HWND_DESKTOP, SV_CYPOINTER);
-// Check for max size!
-if ((w>maxx) || (h>maxy))
 return (WMcursor *) NULL;
-pResult = (WMcursor *) SDL_malloc(sizeof(WMcursor));
-if (!pResult) return (WMcursor *) NULL;
-pchTemp = (char *) SDL_malloc((maxx + 7)/8 * maxy*2);
-if (!pchTemp)
-{
-SDL_free(pResult);
-return (WMcursor *) NULL;
-}
-SDL_memset(pchTemp, 0, (maxx + 7)/8 * maxy*2);
-hps = WinGetPS(_this->hidden->hwndClient);
-bmi.cbFix = sizeof(BITMAPINFOHEADER);
-bmi.cx = maxx;
-bmi.cy = 2*maxy;
-bmi.cPlanes = 1;
-bmi.cBitCount = 1;
-bmi.argbColor[0].bBlue = 0x00;
-bmi.argbColor[0].bGreen = 0x00;
-bmi.argbColor[0].bRed = 0x00;
-bmi.argbColor[1].bBlue = 0x00;
-bmi.argbColor[1].bGreen = 0x00;
-bmi.argbColor[1].bRed = 0xff;
-SDL_memset(&bmih, 0, sizeof(BITMAPINFOHEADER));
-bmih.cbFix = sizeof(BITMAPINFOHEADER);
-bmih.cx = maxx;
-bmih.cy = 2*maxy;
-bmih.cPlanes = 1;
-bmih.cBitCount = 1;
-run = (w+7)/8;
-pad = (maxx+7)/8 - run;
-for (i=0; i<h; i++)
-{
-xptr = pchTemp + (maxx+7)/8 * (maxy-1-i);
-aptr = pchTemp + (maxx+7)/8 * (maxy+maxy-1-i);
-memxor(xptr, data, mask, run);
-xptr += run;
-data += run;
-memnot(aptr, mask, run);
-mask += run;
-aptr += run;
-SDL_memset(xptr,  0, pad);
-xptr += pad;
-SDL_memset(aptr, ~0, pad);
-aptr += pad;
-}
-pad += run;
-for (i=h ; i<maxy; i++ )
-{
-xptr = pchTemp + (maxx+7)/8 * (maxy-1-i);
-aptr = pchTemp + (maxx+7)/8 * (maxy+maxy-1-i);
-SDL_memset(xptr,  0, (maxx+7)/8);
-xptr += (maxx+7)/8;
-SDL_memset(aptr, ~0, (maxx+7)/8);
-aptr += (maxx+7)/8;
-}
-hbm = GpiCreateBitmap(hps, (PBITMAPINFOHEADER2)&bmih, CBM_INIT, (PBYTE) pchTemp, (PBITMAPINFO2)&bmi);
-hptr = WinCreatePointer(HWND_DESKTOP, hbm, TRUE, hot_x, maxy - hot_y - 1);
-#ifdef DEBUG_BUILD
-printf("HotSpot          : %d ; %d\n", hot_x, hot_y);
-printf("HPS returned     : %x\n", (ULONG)hps);
-printf("HBITMAP returned : %x\n", (ULONG)hbm);
-printf("HPOINTER returned: %x\n", (ULONG)hptr);
-#endif
-WinReleasePS(hps);
-#ifdef DEBUG_BUILD
-printf("[CreateWMCursor] : ptr = %p\n", hptr); fflush(stdout);
-#endif
-pResult->hptr = hptr;
-pResult->hbm = hbm;
-pResult->pchData = pchTemp;
-#ifdef DEBUG_BUILD
-printf("[CreateWMCursor] : ptr = %p return.\n", hptr); fflush(stdout);
-#endif
-return (WMcursor *) pResult;
-}
-WMcursor *os2fslib_CreateWMCursor_FS(_THIS, Uint8 *data, Uint8 *mask,
-int w, int h, int hot_x, int hot_y)
-{
-#ifdef DEBUG_BUILD
-printf("[CreateWMCursor_FS] : returning pointer NULL\n"); fflush(stdout);
-#endif
-// In FS mode we'll use software cursor
-return (WMcursor *) NULL;
 }
 /* Show the specified cursor, or hide if cursor is NULL */
-int os2fslib_ShowWMCursor(_THIS, WMcursor *cursor)
+int
-{
+os2fslib_ShowWMCursor(_THIS, WMcursor * cursor)
-#ifdef DEBUG_BUILD
+{
-printf("[ShowWMCursor] : ptr = %p\n", cursor); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[ShowWMCursor] : ptr = %p\n", cursor);
+fflush(stdout);
-if (cursor)
+#endif
-{
-WinSetPointer(HWND_DESKTOP, cursor->hptr);
+if (cursor) {
-hptrGlobalPointer = cursor->hptr;
+WinSetPointer(HWND_DESKTOP, cursor->hptr);
-_this->hidden->iMouseVisible = 1;
+hptrGlobalPointer = cursor->hptr;
-}
+_this->hidden->iMouseVisible = 1;
-else
+} else {
-{
+WinSetPointer(HWND_DESKTOP, FALSE);
-WinSetPointer(HWND_DESKTOP, FALSE);
+hptrGlobalPointer = NULL;
-hptrGlobalPointer = NULL;
+_this->hidden->iMouseVisible = 0;
-_this->hidden->iMouseVisible = 0;
+}
-}
+#ifdef DEBUG_BUILD
-#ifdef DEBUG_BUILD
+printf("[ShowWMCursor] : ptr = %p, DONE\n", cursor);
-printf("[ShowWMCursor] : ptr = %p, DONE\n", cursor); fflush(stdout);
+fflush(stdout);
 #endif
 return 1;
 }
 /* Warp the window manager cursor to (x,y)
 If NULL, a mouse motion event is posted internally.
 */
-void os2fslib_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
+void
-{
+os2fslib_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
-LONG lx, ly;
+{
-SWP swpClient;
+LONG lx, ly;
-POINTL ptlPoints;
+SWP swpClient;
-WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
+POINTL ptlPoints;
-ptlPoints.x = swpClient.x;
+WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
-ptlPoints.y = swpClient.y;
+ptlPoints.x = swpClient.x;
-WinMapWindowPoints(_this->hidden->hwndFrame, HWND_DESKTOP, &ptlPoints, 1);
+ptlPoints.y = swpClient.y;
-lx = ptlPoints.x + (x*swpClient.cx) / _this->hidden->SrcBufferDesc.uiXResolution;
+WinMapWindowPoints(_this->hidden->hwndFrame, HWND_DESKTOP, &ptlPoints, 1);
-ly = ptlPoints.y + swpClient.cy - ((y*swpClient.cy) / _this->hidden->SrcBufferDesc.uiYResolution) - 1;
+lx = ptlPoints.x +
+(x * swpClient.cx) / _this->hidden->SrcBufferDesc.uiXResolution;
-SDL_PrivateMouseMotion(0, // Buttons not changed
+ly = ptlPoints.y + swpClient.cy -
-0, // Absolute position
+((y * swpClient.cy) / _this->hidden->SrcBufferDesc.uiYResolution) - 1;
-x,
-y);
+SDL_PrivateMouseMotion(0,   // Buttons not changed
+0,   // Absolute position
-WinSetPointerPos(HWND_DESKTOP, lx, ly);
+x, y);
+WinSetPointerPos(HWND_DESKTOP, lx, ly);
 }
 /* If not NULL, this is called when a mouse motion event occurs */
-void os2fslib_MoveWMCursor(_THIS, int x, int y)
+void
-{
+os2fslib_MoveWMCursor(_THIS, int x, int y)
-/*
+{
-SDL_Rect rect;
+/*
+SDL_Rect rect;
-#ifdef DEBUG_BUILD
-printf("[MoveWMCursor] : at %d ; %d\n", x, y); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[MoveWMCursor] : at %d ; %d\n", x, y); fflush(stdout);
+#endif
-rect.x = x;
-rect.y = y;
+rect.x = x;
-rect.w = 32;
+rect.y = y;
-rect.h = 32;
+rect.w = 32;
-os2fslib_UpdateRects(_this, 1, &rect);
+rect.h = 32;
-// TODO!
+os2fslib_UpdateRects(_this, 1, &rect);
-*/
+// TODO!
+*/
 }
 /* Determine whether the mouse should be in relative mode or not.
 This function is called when the input grab state or cursor
 visibility state changes.
 If the cursor is not visible, and the input is grabbed, the
 driver can place the mouse in relative mode, which may result
 in higher accuracy sampling of the pointer motion.
 */
-void os2fslib_CheckMouseMode(_THIS)
+void
-{
+os2fslib_CheckMouseMode(_THIS)
-}
+{
+}
-static void os2fslib_PumpEvents(_THIS)
-{
+static void
-// Notify SDL that if window has been resized!
+os2fslib_PumpEvents(_THIS)
-if (
+{
-(_this->hidden->pSDLSurface) &&
+// Notify SDL that if window has been resized!
-(_this->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
+if ((_this->hidden->pSDLSurface) &&
-(
+(_this->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
-(_this->hidden->SrcBufferDesc.uiXResolution!=iWindowSizeX) ||
+((_this->hidden->SrcBufferDesc.uiXResolution != iWindowSizeX) ||
-(_this->hidden->SrcBufferDesc.uiYResolution!=iWindowSizeY)
+(_this->hidden->SrcBufferDesc.uiYResolution != iWindowSizeY)) &&
-) &&
+(iWindowSizeX > 0) && (iWindowSizeY > 0)) {
-(iWindowSizeX>0) &&
+static time_t prev_time;
-(iWindowSizeY>0)
+time_t curr_time;
-)
-{
+curr_time = time(NULL);
-static time_t prev_time;
+if ((difftime(curr_time, prev_time) >= 0.25) || (bWindowResized)) {
-time_t curr_time;
+// Make sure we won't flood the event queue with resize events,
+// only send them at 250 msecs!
-curr_time = time(NULL);
+// (or when the window is resized)
-if ((difftime(curr_time, prev_time)>=0.25) ||
+#ifdef DEBUG_BUILD
-(bWindowResized))
+printf
-{
+("[os2fslib_PumpEvents] : Calling PrivateResize (%d %d).\n",
-// Make sure we won't flood the event queue with resize events,
+iWindowSizeX, iWindowSizeY);
-// only send them at 250 msecs!
+fflush(stdout);
-// (or when the window is resized)
+#endif
-#ifdef DEBUG_BUILD
+// Tell SDL the new size
-printf("[os2fslib_PumpEvents] : Calling PrivateResize (%d %d).\n",
+SDL_PrivateResize(iWindowSizeX, iWindowSizeY);
-iWindowSizeX, iWindowSizeY);
+prev_time = curr_time;
-fflush(stdout);
+bWindowResized = 0;
-#endif
+}
-// Tell SDL the new size
+}
-SDL_PrivateResize(iWindowSizeX, iWindowSizeY);
-prev_time = curr_time;
-bWindowResized = 0;
-}
-}
 }
 /* We don't actually allow hardware surfaces other than the main one */
-static int os2fslib_AllocHWSurface(_THIS, SDL_Surface *surface)
+static int
-{
+os2fslib_AllocHWSurface(_THIS, SDL_Surface * surface)
-return(-1);
+{
-}
+return (-1);
-static void os2fslib_FreeHWSurface(_THIS, SDL_Surface *surface)
+}
-{
+static void
-return;
+os2fslib_FreeHWSurface(_THIS, SDL_Surface * surface)
+{
+return;
 }
 /* We need to wait for vertical retrace on page flipped displays */
-static int os2fslib_LockHWSurface(_THIS, SDL_Surface *surface)
+static int
-{
+os2fslib_LockHWSurface(_THIS, SDL_Surface * surface)
-return(0);
+{
-}
+return (0);
+}
-static void os2fslib_UnlockHWSurface(_THIS, SDL_Surface *surface)
-{
+static void
-return;
+os2fslib_UnlockHWSurface(_THIS, SDL_Surface * surface)
-}
+{
+return;
-static int os2fslib_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+}
-{
-printf("[os2fslib_SetColors] : TODO!\n"); fflush(stdout);
+static int
-// TODO: Implement paletted modes
+os2fslib_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
-return(1);
+{
-}
+printf("[os2fslib_SetColors] : TODO!\n");
+fflush(stdout);
-static void os2fslib_DestroyIcon(HWND hwndFrame)
+// TODO: Implement paletted modes
-{
+return (1);
-if (hptrCurrentIcon)
+}
-{
-WinDestroyPointer(hptrCurrentIcon);
+static void
-hptrCurrentIcon = NULL;
+os2fslib_DestroyIcon(HWND hwndFrame)
+{
-WinSendMsg(hwndFrame,
+if (hptrCurrentIcon) {
-WM_SETICON,
+WinDestroyPointer(hptrCurrentIcon);
-NULL,
+hptrCurrentIcon = NULL;
-NULL);
-}
+WinSendMsg(hwndFrame, WM_SETICON, NULL, NULL);
+}
 }
 /* Set the window icon image */
-void os2fslib_SetIcon(_THIS, SDL_Surface *icon, Uint8 *mask)
+void
-{
+os2fslib_SetIcon(_THIS, SDL_Surface * icon, Uint8 * mask)
-HWND hwndFrame;
+{
-SDL_Surface *icon_rgb;
+HWND hwndFrame;
-HPOINTER hptrIcon;
+SDL_Surface *icon_rgb;
-HBITMAP hbm;
+HPOINTER hptrIcon;
-BITMAPINFOHEADER bmih;
+HBITMAP hbm;
-BMPINFO          bmi;
+BITMAPINFOHEADER bmih;
-HPS              hps;
+BMPINFO bmi;
-char *pchTemp;
+HPS hps;
-char *pptr, *mptr, *dptr, *dmptr;
+char *pchTemp;
-int maxx, maxy, w, h, x, y;
+char *pptr, *mptr, *dptr, *dmptr;
-SDL_Rect bounds;
+int maxx, maxy, w, h, x, y;
+SDL_Rect bounds;
-#ifdef DEBUG_BUILD
-printf("[os2fslib_SetIcon] : Creating and setting new icon\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_SetIcon] : Creating and setting new icon\n");
+fflush(stdout);
-hwndFrame = WinQueryWindow(_this->hidden->hwndClient, QW_PARENT);
+#endif
-// Make sure the old icon resource will be free'd!
+hwndFrame = WinQueryWindow(_this->hidden->hwndClient, QW_PARENT);
-os2fslib_DestroyIcon(hwndFrame);
+// Make sure the old icon resource will be free'd!
-if ((!icon) || (!mask))
+os2fslib_DestroyIcon(hwndFrame);
-return;
+if ((!icon) || (!mask))
-w = icon->w;
+return;
-h = icon->h;
+w = icon->w;
-maxx = WinQuerySysValue(HWND_DESKTOP, SV_CXICON);
+h = icon->h;
-maxy = WinQuerySysValue(HWND_DESKTOP, SV_CYICON);
+maxx = WinQuerySysValue(HWND_DESKTOP, SV_CXICON);
-// Check for max size!
+maxy = WinQuerySysValue(HWND_DESKTOP, SV_CYICON);
-if ((w>maxx) || (h>maxy))
-return;
+// Check for max size!
+if ((w > maxx) || (h > maxy))
-pchTemp = (char *) SDL_malloc(w * h*2 * 4);
+return;
-if (!pchTemp)
-return;
+pchTemp = (char *) SDL_malloc(w * h * 2 * 4);
+if (!pchTemp)
-SDL_memset(pchTemp, 0, w * h*2 * 4);
+return;
-// Convert surface to RGB, if it's not RGB yet!
+SDL_memset(pchTemp, 0, w * h * 2 * 4);
-icon_rgb = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
-32, 0, 0, 0, 0);
+// Convert surface to RGB, if it's not RGB yet!
-if ( icon_rgb == NULL )
+icon_rgb = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
-{
+32, 0, 0, 0, 0);
+if (icon_rgb == NULL) {
+SDL_free(pchTemp);
+return;
+}
+bounds.x = 0;
+bounds.y = 0;
+bounds.w = icon->w;
+bounds.h = icon->h;
+if (SDL_LowerBlit(icon, &bounds, icon_rgb, &bounds) < 0) {
+SDL_FreeSurface(icon_rgb);
+SDL_free(pchTemp);
+return;
+}
+/* Copy pixels upside-down from RGB surface into BMP, masked with the icon mask */
+// Pixels
+pptr = (char *) (icon_rgb->pixels);
+// Mask
+mptr = mask;
+for (y = 0; y < h; y++) {
+unsigned char uchMaskByte;
+// Destination
+dptr = pchTemp + w * 4 * (h - y - 1);
+// Destination mask
+dmptr = pchTemp + w * h * 4 + w * 4 * (h - y - 1);
+for (x = 0; x < w; x++) {
+if (x % 8 == 0) {
+uchMaskByte = (unsigned char) (*mptr);
+mptr++;
+} else
+uchMaskByte <<= 1;
+if (uchMaskByte & 0x80) {
+// Copy RGB
+*dptr++ = *pptr++;
+*dptr++ = *pptr++;
+*dptr++ = *pptr++;
+*dptr++ = *pptr++;
+*dmptr++ = 0;
+*dmptr++ = 0;
+*dmptr++ = 0;
+*dmptr++ = 0;
+} else {
+// Set pixels to fully transparent
+*dptr++ = 0;
+pptr++;
+*dptr++ = 0;
+pptr++;
+*dptr++ = 0;
+pptr++;
+*dptr++ = 0;
+pptr++;
+*dmptr++ = 255;
+*dmptr++ = 255;
+*dmptr++ = 255;
+*dmptr++ = 255;
+}
+}
+}
+// There is no more need for the RGB surface
+SDL_FreeSurface(icon_rgb);
+hps = WinGetPS(_this->hidden->hwndClient);
+bmi.cbFix = sizeof(BITMAPINFOHEADER);
+bmi.cx = w;
+bmi.cy = 2 * h;
+bmi.cPlanes = 1;
+bmi.cBitCount = 32;
+SDL_memset(&bmih, 0, sizeof(BITMAPINFOHEADER));
+bmih.cbFix = sizeof(BITMAPINFOHEADER);
+bmih.cx = w;
+bmih.cy = 2 * h;
+bmih.cPlanes = 1;
+bmih.cBitCount = 32;
+hbm =
+GpiCreateBitmap(hps, (PBITMAPINFOHEADER2) & bmih, CBM_INIT,
+(PBYTE) pchTemp, (PBITMAPINFO2) & bmi);
+hptrIcon = WinCreatePointer(HWND_DESKTOP, hbm, FALSE, 0, 0);
+WinReleasePS(hps);
+// Free pixel array
 SDL_free(pchTemp);
-return;
-}
+// Change icon in frame window
-bounds.x = 0;
+WinSendMsg(hwndFrame, WM_SETICON, (MPARAM) hptrIcon, NULL);
-bounds.y = 0;
-bounds.w = icon->w;
+/*
-bounds.h = icon->h;
+// Change icon in switchlist
-if ( SDL_LowerBlit(icon, &bounds, icon_rgb, &bounds) < 0 )
+// Seems like it's not needed, the WM_SETICON already does it.
 {
-SDL_FreeSurface(icon_rgb);
+PID pidFrame;
-SDL_free(pchTemp);
+HSWITCH hswitchFrame;
-return;
+SWCNTRL swctl;
-}
+WinQueryWindowProcess(hwndFrame, &pidFrame, NULL);
-/* Copy pixels upside-down from RGB surface into BMP, masked with the icon mask */
+hswitchFrame = WinQuerySwitchHandle(hwndFrame, pidFrame);
+WinQuerySwitchEntry(hswitchFrame, &swctl);
-// Pixels
-pptr = (char *) (icon_rgb->pixels);
+swctl.hwndIcon = hptrIcon;
-// Mask
-mptr = mask;
+WinChangeSwitchEntry(hswitchFrame, &swctl);
+}
-for (y=0; y<h; y++)
+*/
-{
-unsigned char uchMaskByte;
+// Store icon handle in global variable
+hptrCurrentIcon = hptrIcon;
-// Destination
-dptr = pchTemp + w*4 * (h-y-1);
-// Destination mask
-dmptr = pchTemp + w*h*4 + w*4 * (h-y-1);
-for (x=0; x<w; x++)
-{
-if (x%8==0)
-{
-uchMaskByte = (unsigned char) (*mptr);
-mptr++;
-} else
-uchMaskByte <<= 1;
-if (uchMaskByte & 0x80)
-{
-// Copy RGB
-*dptr++ = *pptr++;
-*dptr++ = *pptr++;
-*dptr++ = *pptr++;
-*dptr++ = *pptr++;
-*dmptr++ = 0;
-*dmptr++ = 0;
-*dmptr++ = 0;
-*dmptr++ = 0;
-} else
-{
-// Set pixels to fully transparent
-*dptr++ = 0; pptr++;
-*dptr++ = 0; pptr++;
-*dptr++ = 0; pptr++;
-*dptr++ = 0; pptr++;
-*dmptr++ = 255;
-*dmptr++ = 255;
-*dmptr++ = 255;
-*dmptr++ = 255;
-}
-}
-}
-// There is no more need for the RGB surface
-SDL_FreeSurface(icon_rgb);
-hps = WinGetPS(_this->hidden->hwndClient);
-bmi.cbFix = sizeof(BITMAPINFOHEADER);
-bmi.cx = w;
-bmi.cy = 2*h;
-bmi.cPlanes = 1;
-bmi.cBitCount = 32;
-SDL_memset(&bmih, 0, sizeof(BITMAPINFOHEADER));
-bmih.cbFix = sizeof(BITMAPINFOHEADER);
-bmih.cx = w;
-bmih.cy = 2*h;
-bmih.cPlanes = 1;
-bmih.cBitCount = 32;
-hbm = GpiCreateBitmap(hps, (PBITMAPINFOHEADER2)&bmih, CBM_INIT, (PBYTE) pchTemp, (PBITMAPINFO2)&bmi);
-hptrIcon = WinCreatePointer(HWND_DESKTOP, hbm, FALSE, 0, 0);
-WinReleasePS(hps);
-// Free pixel array
-SDL_free(pchTemp);
-// Change icon in frame window
-WinSendMsg(hwndFrame,
-WM_SETICON,
-(MPARAM) hptrIcon,
-NULL);
-/*
-// Change icon in switchlist
-// Seems like it's not needed, the WM_SETICON already does it.
-{
-PID pidFrame;
-HSWITCH hswitchFrame;
-SWCNTRL swctl;
-WinQueryWindowProcess(hwndFrame, &pidFrame, NULL);
-hswitchFrame = WinQuerySwitchHandle(hwndFrame, pidFrame);
-WinQuerySwitchEntry(hswitchFrame, &swctl);
-swctl.hwndIcon = hptrIcon;
-WinChangeSwitchEntry(hswitchFrame, &swctl);
-}
-*/
-// Store icon handle in global variable
-hptrCurrentIcon = hptrIcon;
 }
 // ------------------------ REAL FUNCTIONS -----------------
-static void os2fslib_SetCursorManagementFunctions(_THIS, int iForWindowedMode)
+static void
-{
+os2fslib_SetCursorManagementFunctions(_THIS, int iForWindowedMode)
-if (iForWindowedMode)
+{
-{
+if (iForWindowedMode) {
 _this->FreeWMCursor = os2fslib_FreeWMCursor;
 _this->CreateWMCursor = os2fslib_CreateWMCursor_Win;
 _this->ShowWMCursor = os2fslib_ShowWMCursor;
 _this->WarpWMCursor = os2fslib_WarpWMCursor;
 _this->MoveWMCursor = os2fslib_MoveWMCursor;
-_this->CheckMouseMode = NULL;//os2fslib_CheckMouseMode;
+_this->CheckMouseMode = NULL;   //os2fslib_CheckMouseMode;
-} else
+} else {
-{
+// We'll have software mouse cursor in FS mode!
-// We'll have software mouse cursor in FS mode!
+_this->FreeWMCursor = os2fslib_FreeWMCursor;
-_this->FreeWMCursor = os2fslib_FreeWMCursor;
+_this->CreateWMCursor = os2fslib_CreateWMCursor_FS;
-_this->CreateWMCursor = os2fslib_CreateWMCursor_FS;
+_this->ShowWMCursor = os2fslib_ShowWMCursor;
-_this->ShowWMCursor = os2fslib_ShowWMCursor;
+_this->WarpWMCursor = os2fslib_WarpWMCursor;
-_this->WarpWMCursor = os2fslib_WarpWMCursor;
+_this->MoveWMCursor = os2fslib_MoveWMCursor;
-_this->MoveWMCursor = os2fslib_MoveWMCursor;
+_this->CheckMouseMode = NULL;   //os2fslib_CheckMouseMode;
-_this->CheckMouseMode = NULL;//os2fslib_CheckMouseMode;
+}
 }
-}
+static void
-static void os2fslib_InitOSKeymap(_THIS)
+os2fslib_InitOSKeymap(_THIS)
 {
 int i;
 iShiftIsPressed = 0;
 /* Map the VK and CH keysyms */
-for ( i=0; i<=255; ++i )
+for (i = 0; i <= 255; ++i)
 HWScanKeyMap[i] = SDLK_UNKNOWN;
 // First line of keyboard:
 HWScanKeyMap[0x1] = SDLK_ESCAPE;
 HWScanKeyMap[0x3b] = SDLK_F1;
 HWScanKeyMap[0x3c] = SDLK_F2;
 HWScanKeyMap[0x3d] = SDLK_F3;
 HWScanKeyMap[0x3e] = SDLK_F4;
 HWScanKeyMap[0x3f] = SDLK_F5;
 HWScanKeyMap[0x40] = SDLK_F6;
 HWScanKeyMap[0x41] = SDLK_F7;
 HWScanKeyMap[0x42] = SDLK_F8;
 HWScanKeyMap[0x43] = SDLK_F9;
 HWScanKeyMap[0x44] = SDLK_F10;
 HWScanKeyMap[0x57] = SDLK_F11;
 HWScanKeyMap[0x58] = SDLK_F12;
 HWScanKeyMap[0x5d] = SDLK_PRINT;
 HWScanKeyMap[0x46] = SDLK_SCROLLOCK;
 HWScanKeyMap[0x5f] = SDLK_PAUSE;
 // Second line of keyboard:
 HWScanKeyMap[0x29] = SDLK_BACKQUOTE;
 HWScanKeyMap[0x2] = SDLK_1;
 HWScanKeyMap[0x3] = SDLK_2;
 HWScanKeyMap[0x4] = SDLK_3;
 HWScanKeyMap[0x5] = SDLK_4;
 HWScanKeyMap[0x6] = SDLK_5;
 HWScanKeyMap[0x7] = SDLK_6;
 HWScanKeyMap[0x8] = SDLK_7;
 HWScanKeyMap[0x9] = SDLK_8;
 HWScanKeyMap[0xa] = SDLK_9;
 HWScanKeyMap[0xb] = SDLK_0;
 HWScanKeyMap[0xc] = SDLK_MINUS;
 HWScanKeyMap[0xd] = SDLK_EQUALS;
 HWScanKeyMap[0xe] = SDLK_BACKSPACE;
 HWScanKeyMap[0x68] = SDLK_INSERT;
 HWScanKeyMap[0x60] = SDLK_HOME;
 HWScanKeyMap[0x62] = SDLK_PAGEUP;
 HWScanKeyMap[0x45] = SDLK_NUMLOCK;
 HWScanKeyMap[0x5c] = SDLK_KP_DIVIDE;
 HWScanKeyMap[0x37] = SDLK_KP_MULTIPLY;
 HWScanKeyMap[0x4a] = SDLK_KP_MINUS;
 // Third line of keyboard:
 HWScanKeyMap[0xf] = SDLK_TAB;
 HWScanKeyMap[0x10] = SDLK_q;
 HWScanKeyMap[0x11] = SDLK_w;
 HWScanKeyMap[0x12] = SDLK_e;
 HWScanKeyMap[0x13] = SDLK_r;
 HWScanKeyMap[0x14] = SDLK_t;
 HWScanKeyMap[0x15] = SDLK_y;
 HWScanKeyMap[0x16] = SDLK_u;
 HWScanKeyMap[0x17] = SDLK_i;
 HWScanKeyMap[0x18] = SDLK_o;
 HWScanKeyMap[0x19] = SDLK_p;
 HWScanKeyMap[0x1a] = SDLK_LEFTBRACKET;
 HWScanKeyMap[0x1b] = SDLK_RIGHTBRACKET;
 HWScanKeyMap[0x1c] = SDLK_RETURN;
 HWScanKeyMap[0x69] = SDLK_DELETE;
 HWScanKeyMap[0x65] = SDLK_END;
 HWScanKeyMap[0x67] = SDLK_PAGEDOWN;
 HWScanKeyMap[0x47] = SDLK_KP7;
 HWScanKeyMap[0x48] = SDLK_KP8;
 HWScanKeyMap[0x49] = SDLK_KP9;
 HWScanKeyMap[0x4e] = SDLK_KP_PLUS;
 // Fourth line of keyboard:
 HWScanKeyMap[0x3a] = SDLK_CAPSLOCK;
 HWScanKeyMap[0x1e] = SDLK_a;
 HWScanKeyMap[0x1f] = SDLK_s;
 HWScanKeyMap[0x20] = SDLK_d;
 HWScanKeyMap[0x21] = SDLK_f;
 HWScanKeyMap[0x22] = SDLK_g;
 HWScanKeyMap[0x23] = SDLK_h;
 HWScanKeyMap[0x24] = SDLK_j;
 HWScanKeyMap[0x25] = SDLK_k;
 HWScanKeyMap[0x26] = SDLK_l;
 HWScanKeyMap[0x27] = SDLK_SEMICOLON;
 HWScanKeyMap[0x28] = SDLK_QUOTE;
 HWScanKeyMap[0x2b] = SDLK_BACKSLASH;
 HWScanKeyMap[0x4b] = SDLK_KP4;
 HWScanKeyMap[0x4c] = SDLK_KP5;
 HWScanKeyMap[0x4d] = SDLK_KP6;
 // Fifth line of keyboard:
 HWScanKeyMap[0x2a] = SDLK_LSHIFT;
-HWScanKeyMap[0x56] = SDLK_WORLD_1; // Code 161, letter i' on hungarian keyboard
+HWScanKeyMap[0x56] = SDLK_WORLD_1;  // Code 161, letter i' on hungarian keyboard
 HWScanKeyMap[0x2c] = SDLK_z;
 HWScanKeyMap[0x2d] = SDLK_x;
 HWScanKeyMap[0x2e] = SDLK_c;
 HWScanKeyMap[0x2f] = SDLK_v;
 HWScanKeyMap[0x30] = SDLK_b;
 HWScanKeyMap[0x31] = SDLK_n;
 HWScanKeyMap[0x32] = SDLK_m;
 HWScanKeyMap[0x33] = SDLK_COMMA;
 HWScanKeyMap[0x34] = SDLK_PERIOD;
 HWScanKeyMap[0x35] = SDLK_SLASH;
 HWScanKeyMap[0x36] = SDLK_RSHIFT;
 HWScanKeyMap[0x61] = SDLK_UP;
 HWScanKeyMap[0x4f] = SDLK_KP1;
 HWScanKeyMap[0x50] = SDLK_KP2;
 HWScanKeyMap[0x51] = SDLK_KP3;
 HWScanKeyMap[0x5a] = SDLK_KP_ENTER;
 // Sixth line of keyboard:
 HWScanKeyMap[0x1d] = SDLK_LCTRL;
-HWScanKeyMap[0x7e] = SDLK_LSUPER; // Windows key
+HWScanKeyMap[0x7e] = SDLK_LSUPER;   // Windows key
 HWScanKeyMap[0x38] = SDLK_LALT;
 HWScanKeyMap[0x39] = SDLK_SPACE;
-HWScanKeyMap[0x5e] = SDLK_RALT;// Actually, altgr on my keyboard...
+HWScanKeyMap[0x5e] = SDLK_RALT;     // Actually, altgr on my keyboard...
 HWScanKeyMap[0x7f] = SDLK_RSUPER;
 HWScanKeyMap[0x7c] = SDLK_MENU;
 HWScanKeyMap[0x5b] = SDLK_RCTRL;
 HWScanKeyMap[0x63] = SDLK_LEFT;
 HWScanKeyMap[0x66] = SDLK_DOWN;
 HWScanKeyMap[0x64] = SDLK_RIGHT;
 HWScanKeyMap[0x52] = SDLK_KP0;
 HWScanKeyMap[0x53] = SDLK_KP_PERIOD;
 }
 /* Iconify the window.
 This function returns 1 if there is a window manager and the
 window was actually iconified, it returns 0 otherwise.
 */
-int os2fslib_IconifyWindow(_THIS)
+int
-{
+os2fslib_IconifyWindow(_THIS)
-HAB hab;
+{
-HMQ hmq;
+HAB hab;
-ERRORID hmqerror;
+HMQ hmq;
+ERRORID hmqerror;
-// If there is no more window, nothing we can do!
-if (_this->hidden->iPMThreadStatus!=1) return 0;
+// If there is no more window, nothing we can do!
+if (_this->hidden->iPMThreadStatus != 1)
-// Cannot do anything in fullscreen mode!
+return 0;
-if (FSLib_QueryFSMode(_this->hidden->hwndClient))
-return 0;
+// Cannot do anything in fullscreen mode!
+if (FSLib_QueryFSMode(_this->hidden->hwndClient))
-// Make sure this thread is prepared for using the Presentation Manager!
+return 0;
-hab = WinInitialize(0);
-hmq = WinCreateMsgQueue(hab,0);
+// Make sure this thread is prepared for using the Presentation Manager!
-// Remember if there was an error at WinCreateMsgQueue(), because we don't
+hab = WinInitialize(0);
-// want to destroy somebody else's queue later. :)
+hmq = WinCreateMsgQueue(hab, 0);
-hmqerror = WinGetLastError(hab);
+// Remember if there was an error at WinCreateMsgQueue(), because we don't
+// want to destroy somebody else's queue later. :)
-WinSetWindowPos(_this->hidden->hwndFrame, HWND_TOP,
+hmqerror = WinGetLastError(hab);
-0, 0, 0, 0, SWP_MINIMIZE);
+WinSetWindowPos(_this->hidden->hwndFrame, HWND_TOP,
-// Now destroy the message queue, if we've created it!
+0, 0, 0, 0, SWP_MINIMIZE);
-if (ERRORIDERROR(hmqerror)==0)
-WinDestroyMsgQueue(hmq);
+// Now destroy the message queue, if we've created it!
+if (ERRORIDERROR(hmqerror) == 0)
-return 1;
+WinDestroyMsgQueue(hmq);
-}
+return 1;
-static SDL_GrabMode os2fslib_GrabInput(_THIS, SDL_GrabMode mode)
+}
-{
-HAB hab;
+static SDL_GrabMode
-HMQ hmq;
+os2fslib_GrabInput(_THIS, SDL_GrabMode mode)
-ERRORID hmqerror;
+{
+HAB hab;
+HMQ hmq;
-// If there is no more window, nothing we can do!
+ERRORID hmqerror;
-if (_this->hidden->iPMThreadStatus!=1)
-return SDL_GRAB_OFF;
+// If there is no more window, nothing we can do!
-// Make sure this thread is prepared for using the Presentation Manager!
+if (_this->hidden->iPMThreadStatus != 1)
-hab = WinInitialize(0);
+return SDL_GRAB_OFF;
-hmq = WinCreateMsgQueue(hab,0);
-// Remember if there was an error at WinCreateMsgQueue(), because we don't
+// Make sure this thread is prepared for using the Presentation Manager!
-// want to destroy somebody else's queue later. :)
+hab = WinInitialize(0);
-hmqerror = WinGetLastError(hab);
+hmq = WinCreateMsgQueue(hab, 0);
+// Remember if there was an error at WinCreateMsgQueue(), because we don't
+// want to destroy somebody else's queue later. :)
-if (mode == SDL_GRAB_OFF)
+hmqerror = WinGetLastError(hab);
-{
-#ifdef DEBUG_BUILD
-printf("[os2fslib_GrabInput] : Releasing mouse\n"); fflush(stdout);
+if (mode == SDL_GRAB_OFF) {
-#endif
+#ifdef DEBUG_BUILD
+printf("[os2fslib_GrabInput] : Releasing mouse\n");
-// Release the mouse
+fflush(stdout);
-bMouseCapturable = 0;
+#endif
-if (bMouseCaptured)
-{
+// Release the mouse
-WinSetCapture(HWND_DESKTOP, NULLHANDLE);
+bMouseCapturable = 0;
-bMouseCaptured = 0;
+if (bMouseCaptured) {
-}
+WinSetCapture(HWND_DESKTOP, NULLHANDLE);
-} else
+bMouseCaptured = 0;
-{
+}
-#ifdef DEBUG_BUILD
+} else {
-printf("[os2fslib_GrabInput] : Capturing mouse\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_GrabInput] : Capturing mouse\n");
+fflush(stdout);
-// Capture the mouse
+#endif
-bMouseCapturable = 1;
-if (WinQueryFocus(HWND_DESKTOP) == _this->hidden->hwndClient)
+// Capture the mouse
-{
+bMouseCapturable = 1;
-WinSetCapture(HWND_DESKTOP, _this->hidden->hwndClient);
+if (WinQueryFocus(HWND_DESKTOP) == _this->hidden->hwndClient) {
-bMouseCaptured = 1;
+WinSetCapture(HWND_DESKTOP, _this->hidden->hwndClient);
-{
+bMouseCaptured = 1;
-SWP swpClient;
+{
-POINTL ptl;
+SWP swpClient;
-// Center the mouse to the middle of the window!
+POINTL ptl;
-WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
+// Center the mouse to the middle of the window!
-ptl.x = 0; ptl.y = 0;
+WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
-WinMapWindowPoints(_this->hidden->hwndClient, HWND_DESKTOP, &ptl, 1);
+ptl.x = 0;
-_this->hidden->iSkipWMMOUSEMOVE++; /* Don't take next WM_MOUSEMOVE into account!  */
+ptl.y = 0;
-WinSetPointerPos(HWND_DESKTOP,
+WinMapWindowPoints(_this->hidden->hwndClient,
-ptl.x + swpClient.cx/2,
+HWND_DESKTOP, &ptl, 1);
-ptl.y + swpClient.cy/2);
+_this->hidden->iSkipWMMOUSEMOVE++;      /* Don't take next WM_MOUSEMOVE into account!  */
-}
+WinSetPointerPos(HWND_DESKTOP,
-}
+ptl.x + swpClient.cx / 2,
-}
+ptl.y + swpClient.cy / 2);
+}
-// Now destroy the message queue, if we've created it!
+}
-if (ERRORIDERROR(hmqerror)==0)
+}
-WinDestroyMsgQueue(hmq);
+// Now destroy the message queue, if we've created it!
-return mode;
+if (ERRORIDERROR(hmqerror) == 0)
+WinDestroyMsgQueue(hmq);
+return mode;
 }
 /* Set the title and icon text */
-static void os2fslib_SetCaption(_THIS, const char *title, const char *icon)
+static void
-{
+os2fslib_SetCaption(_THIS, const char *title, const char *icon)
-HAB hab;
+{
-HMQ hmq;
+HAB hab;
-ERRORID hmqerror;
+HMQ hmq;
+ERRORID hmqerror;
-// If there is no more window, nothing we can do!
-if (_this->hidden->iPMThreadStatus!=1) return;
+// If there is no more window, nothing we can do!
+if (_this->hidden->iPMThreadStatus != 1)
-// Make sure this thread is prepared for using the Presentation Manager!
+return;
-hab = WinInitialize(0);
-hmq = WinCreateMsgQueue(hab,0);
+// Make sure this thread is prepared for using the Presentation Manager!
-// Remember if there was an error at WinCreateMsgQueue(), because we don't
+hab = WinInitialize(0);
-// want to destroy somebody else's queue later. :)
+hmq = WinCreateMsgQueue(hab, 0);
-hmqerror = WinGetLastError(hab);
+// Remember if there was an error at WinCreateMsgQueue(), because we don't
+// want to destroy somebody else's queue later. :)
-WinSetWindowText(_this->hidden->hwndFrame, (char *) title);
+hmqerror = WinGetLastError(hab);
-// Now destroy the message queue, if we've created it!
+WinSetWindowText(_this->hidden->hwndFrame, (char *) title);
-if (ERRORIDERROR(hmqerror)==0)
-WinDestroyMsgQueue(hmq);
+// Now destroy the message queue, if we've created it!
-}
+if (ERRORIDERROR(hmqerror) == 0)
+WinDestroyMsgQueue(hmq);
-static int os2fslib_ToggleFullScreen(_THIS, int on)
+}
-{
-#ifdef DEBUG_BUILD
+static int
-printf("[os2fslib_ToggleFullScreen] : %d\n", on); fflush(stdout);
+os2fslib_ToggleFullScreen(_THIS, int on)
-#endif
+{
-// If there is no more window, nothing we can do!
+#ifdef DEBUG_BUILD
-if (_this->hidden->iPMThreadStatus!=1) return 0;
+printf("[os2fslib_ToggleFullScreen] : %d\n", on);
+fflush(stdout);
-FSLib_ToggleFSMode(_this->hidden->hwndClient, on);
+#endif
-/* Cursor manager functions to Windowed/FS mode*/
+// If there is no more window, nothing we can do!
-os2fslib_SetCursorManagementFunctions(_this, !on);
+if (_this->hidden->iPMThreadStatus != 1)
-return 1;
+return 0;
+FSLib_ToggleFSMode(_this->hidden->hwndClient, on);
+/* Cursor manager functions to Windowed/FS mode */
+os2fslib_SetCursorManagementFunctions(_this, !on);
+return 1;
 }
 /* This is called after the video mode has been set, to get the
 initial mouse state.  It should queue events as necessary to
 properly represent the current mouse focus and position.
 */
-static void os2fslib_UpdateMouse(_THIS)
+static void
-{
+os2fslib_UpdateMouse(_THIS)
-POINTL ptl;
+{
-HAB hab;
+POINTL ptl;
-HMQ hmq;
+HAB hab;
-ERRORID hmqerror;
+HMQ hmq;
-SWP swpClient;
+ERRORID hmqerror;
+SWP swpClient;
-// If there is no more window, nothing we can do!
-if (_this->hidden->iPMThreadStatus!=1) return;
+// If there is no more window, nothing we can do!
+if (_this->hidden->iPMThreadStatus != 1)
+return;
-// Make sure this thread is prepared for using the Presentation Manager!
-hab = WinInitialize(0);
-hmq = WinCreateMsgQueue(hab,0);
+// Make sure this thread is prepared for using the Presentation Manager!
-// Remember if there was an error at WinCreateMsgQueue(), because we don't
+hab = WinInitialize(0);
-// want to destroy somebody else's queue later. :)
+hmq = WinCreateMsgQueue(hab, 0);
-hmqerror = WinGetLastError(hab);
+// Remember if there was an error at WinCreateMsgQueue(), because we don't
+// want to destroy somebody else's queue later. :)
+hmqerror = WinGetLastError(hab);
-if (_this->hidden->fInFocus)
-{
-// If our app is in focus
+if (_this->hidden->fInFocus) {
-SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
+// If our app is in focus
-SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
+SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
-SDL_PrivateAppActive(1, SDL_APPACTIVE);
+SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
-WinQueryPointerPos(HWND_DESKTOP, &ptl);
+SDL_PrivateAppActive(1, SDL_APPACTIVE);
-WinMapWindowPoints(HWND_DESKTOP, _this->hidden->hwndClient, &ptl, 1);
+WinQueryPointerPos(HWND_DESKTOP, &ptl);
-WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
+WinMapWindowPoints(HWND_DESKTOP, _this->hidden->hwndClient, &ptl, 1);
-// Convert OS/2 mouse position to SDL position, and also scale it!
+WinQueryWindowPos(_this->hidden->hwndClient, &swpClient);
-ptl.x = ptl.x * _this->hidden->SrcBufferDesc.uiXResolution / swpClient.cx;
+// Convert OS/2 mouse position to SDL position, and also scale it!
-ptl.y = ptl.y * _this->hidden->SrcBufferDesc.uiYResolution / swpClient.cy;
+ptl.x =
-ptl.y = _this->hidden->SrcBufferDesc.uiYResolution - ptl.y - 1;
+ptl.x * _this->hidden->SrcBufferDesc.uiXResolution / swpClient.cx;
-SDL_PrivateMouseMotion(0, 0, (Sint16) (ptl.x), (Sint16) (ptl.y));
+ptl.y =
-} else
+ptl.y * _this->hidden->SrcBufferDesc.uiYResolution / swpClient.cy;
-{
+ptl.y = _this->hidden->SrcBufferDesc.uiYResolution - ptl.y - 1;
-// If we're not in focus
+SDL_PrivateMouseMotion(0, 0, (Sint16) (ptl.x), (Sint16) (ptl.y));
-SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
+} else {
-SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);
+// If we're not in focus
-SDL_PrivateAppActive(0, SDL_APPACTIVE);
+SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
-SDL_PrivateMouseMotion(0, 0, (Sint16) -1, (Sint16) -1);
+SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);
-}
+SDL_PrivateAppActive(0, SDL_APPACTIVE);
+SDL_PrivateMouseMotion(0, 0, (Sint16) - 1, (Sint16) - 1);
-// Now destroy the message queue, if we've created it!
+}
-if (ERRORIDERROR(hmqerror)==0)
-WinDestroyMsgQueue(hmq);
+// Now destroy the message queue, if we've created it!
+if (ERRORIDERROR(hmqerror) == 0)
+WinDestroyMsgQueue(hmq);
 }
 /* This pointer should exist in the native video subsystem and should
 point to an appropriate update function for the current video mode
 */
-static void os2fslib_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
+static void
-{
+os2fslib_UpdateRects(_THIS, int numrects, SDL_Rect * rects)
-// If there is no more window, nothing we can do!
+{
-if (_this->hidden->iPMThreadStatus!=1) return;
+// If there is no more window, nothing we can do!
+if (_this->hidden->iPMThreadStatus != 1)
+return;
 #ifdef BITBLT_IN_WINMESSAGEPROC
 WinSendMsg(_this->hidden->hwndClient,
-WM_UPDATERECTSREQUEST,
+WM_UPDATERECTSREQUEST, (MPARAM) numrects, (MPARAM) rects);
-(MPARAM) numrects,
-(MPARAM) rects);
 #else
-if (DosRequestMutexSem(_this->hidden->hmtxUseSrcBuffer, SEM_INDEFINITE_WAIT)==NO_ERROR)
+if (DosRequestMutexSem
-{
+(_this->hidden->hmtxUseSrcBuffer, SEM_INDEFINITE_WAIT) == NO_ERROR) {
 int i;
-if (_this->hidden->pSDLSurface)
+if (_this->hidden->pSDLSurface) {
-{
 #ifndef RESIZE_EVEN_IF_RESIZABLE
 SWP swp;
 // But only blit if the window is not resizable, or if
 // the window is resizable and the source buffer size is the
 // same as the destination buffer size!
 WinQueryWindowPos(_this->hidden->hwndClient, &swp);
 if ((_this->hidden->pSDLSurface) &&
 (_this->hidden->pSDLSurface->flags & SDL_RESIZABLE) &&
 ((swp.cx != _this->hidden->SrcBufferDesc.uiXResolution) ||
-(swp.cy != _this->hidden->SrcBufferDesc.uiYResolution)
+(swp.cy != _this->hidden->SrcBufferDesc.uiYResolution))
-) &&
+&& (!FSLib_QueryFSMode(_this->hidden->hwndClient))) {
-(!FSLib_QueryFSMode(_this->hidden->hwndClient))
+// Resizable surface and in resizing!
-)
+// So, don't blit now!
-{
+#ifdef DEBUG_BUILD
-// Resizable surface and in resizing!
+printf("[UpdateRects] : Skipping blit while resizing!\n");
-// So, don't blit now!
+fflush(stdout);
-#ifdef DEBUG_BUILD
+#endif
-printf("[UpdateRects] : Skipping blit while resizing!\n"); fflush(stdout);
+} else
 #endif
-} else
+{
-#endif
+/*
-{
+// Blit the whole window
-/*
+FSLIB_BITBLT(_this->hidden->hwndClient, _this->hidden->pchSrcBuffer,
-// Blit the whole window
+0, 0,
-FSLIB_BITBLT(_this->hidden->hwndClient, _this->hidden->pchSrcBuffer,
+_this->hidden->SrcBufferDesc.uiXResolution,
-0, 0,
+_this->hidden->SrcBufferDesc.uiYResolution);
-_this->hidden->SrcBufferDesc.uiXResolution,
+*/
-_this->hidden->SrcBufferDesc.uiYResolution);
+#ifdef DEBUG_BUILD
-*/
+printf("[os2fslib_UpdateRects] : Blitting!\n");
-#ifdef DEBUG_BUILD
+fflush(stdout);
-printf("[os2fslib_UpdateRects] : Blitting!\n"); fflush(stdout);
+#endif
-#endif
+// Blit the changed areas
-// Blit the changed areas
+for (i = 0; i < numrects; i++)
-for (i=0; i<numrects; i++)
+FSLIB_BITBLT(_this->hidden->hwndClient,
-FSLIB_BITBLT(_this->hidden->hwndClient, _this->hidden->pchSrcBuffer,
+_this->hidden->pchSrcBuffer,
-rects[i].y, rects[i].x, rects[i].w, rects[i].h);
+rects[i].y, rects[i].x, rects[i].w,
-}
+rects[i].h);
 }
-#ifdef DEBUG_BUILD
+}
-else
+#ifdef DEBUG_BUILD
-printf("[os2fslib_UpdateRects] : No public surface!\n"); fflush(stdout);
+else
-#endif
+printf("[os2fslib_UpdateRects] : No public surface!\n");
-DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
+fflush(stdout);
-}
+#endif
-#ifdef DEBUG_BUILD
+DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
-else
+}
-printf("[os2fslib_UpdateRects] : Error in mutex!\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
+else
+printf("[os2fslib_UpdateRects] : Error in mutex!\n");
+fflush(stdout);
 #endif
 #endif
 }
 /* Reverse the effects VideoInit() -- called if VideoInit() fails
 or if the application is shutting down the video subsystem.
 */
-static void os2fslib_VideoQuit(_THIS)
+static void
-{
+os2fslib_VideoQuit(_THIS)
-#ifdef DEBUG_BUILD
+{
-printf("[os2fslib_VideoQuit]\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_VideoQuit]\n");
-// Close PM stuff if running!
+fflush(stdout);
-if (_this->hidden->iPMThreadStatus == 1)
+#endif
-{
+// Close PM stuff if running!
-int iTimeout;
+if (_this->hidden->iPMThreadStatus == 1) {
-WinPostMsg(_this->hidden->hwndFrame, WM_QUIT, (MPARAM) 0, (MPARAM) 0);
+int iTimeout;
-// HACK: We had this line before:
+WinPostMsg(_this->hidden->hwndFrame, WM_QUIT, (MPARAM) 0, (MPARAM) 0);
-//DosWaitThread((TID *) &(_this->hidden->tidPMThread), DCWW_WAIT);
+// HACK: We had this line before:
-// We don't use it, because the PMThread will never stop, or if it stops,
+//DosWaitThread((TID *) &(_this->hidden->tidPMThread), DCWW_WAIT);
-// it will kill the whole process as a emergency fallback.
+// We don't use it, because the PMThread will never stop, or if it stops,
-// So, we only check for the iPMThreadStatus stuff!
+// it will kill the whole process as a emergency fallback.
-#ifdef DEBUG_BUILD
+// So, we only check for the iPMThreadStatus stuff!
-printf("[os2fslib_VideoQuit] : Waiting for PM thread to die\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_VideoQuit] : Waiting for PM thread to die\n");
+fflush(stdout);
-iTimeout=0;
+#endif
-while ((_this->hidden->iPMThreadStatus == 1) && (iTimeout<100))
-{
+iTimeout = 0;
-iTimeout++;
+while ((_this->hidden->iPMThreadStatus == 1) && (iTimeout < 100)) {
-DosSleep(64);
+iTimeout++;
-}
+DosSleep(64);
+}
-#ifdef DEBUG_BUILD
-printf("[os2fslib_VideoQuit] : End of wait.\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_VideoQuit] : End of wait.\n");
+fflush(stdout);
-if (_this->hidden->iPMThreadStatus == 1)
+#endif
-{
-#ifdef DEBUG_BUILD
+if (_this->hidden->iPMThreadStatus == 1) {
-printf("[os2fslib_VideoQuit] : Killing PM thread!\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_VideoQuit] : Killing PM thread!\n");
+fflush(stdout);
-_this->hidden->iPMThreadStatus = 0;
+#endif
-DosKillThread(_this->hidden->tidPMThread);
+_this->hidden->iPMThreadStatus = 0;
-if (_this->hidden->hwndFrame)
+DosKillThread(_this->hidden->tidPMThread);
-{
-#ifdef DEBUG_BUILD
+if (_this->hidden->hwndFrame) {
-printf("[os2fslib_VideoQuit] : Destroying PM window!\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_VideoQuit] : Destroying PM window!\n");
+fflush(stdout);
-WinDestroyWindow(_this->hidden->hwndFrame); _this->hidden->hwndFrame=NULL;
+#endif
-}
-}
+WinDestroyWindow(_this->hidden->hwndFrame);
+_this->hidden->hwndFrame = NULL;
 }
+}
-// Free result of an old ListModes() call, because there is
-// no FreeListModes() call in SDL!
+}
-if (_this->hidden->pListModesResult)
+// Free result of an old ListModes() call, because there is
-{
+// no FreeListModes() call in SDL!
-SDL_free(_this->hidden->pListModesResult); _this->hidden->pListModesResult = NULL;
+if (_this->hidden->pListModesResult) {
-}
+SDL_free(_this->hidden->pListModesResult);
+_this->hidden->pListModesResult = NULL;
-// Free list of available fullscreen modes
+}
-if (_this->hidden->pAvailableFSLibVideoModes)
+// Free list of available fullscreen modes
-{
+if (_this->hidden->pAvailableFSLibVideoModes) {
 FSLib_FreeVideoModeList(_this->hidden->pAvailableFSLibVideoModes);
 _this->hidden->pAvailableFSLibVideoModes = NULL;
 }
+// Free application icon if we had one
-// Free application icon if we had one
+if (hptrCurrentIcon) {
-if (hptrCurrentIcon)
+WinDestroyPointer(hptrCurrentIcon);
-{
+hptrCurrentIcon = NULL;
-WinDestroyPointer(hptrCurrentIcon);
+}
-hptrCurrentIcon = NULL;
-}
 }
 /* Set the requested video mode, returning a surface which will be
 set to the SDL_VideoSurface.  The width and height will already
 be verified by ListModes(), and the video subsystem is free to
 set the mode to a supported bit depth different from the one
 specified -- the desired bpp will be emulated with a shadow
 surface if necessary.  If a new mode is returned, this function
 should take care of cleaning up the current mode.
 */
-static SDL_Surface *os2fslib_SetVideoMode(_THIS, SDL_Surface *current,
+static SDL_Surface *
-int width, int height, int bpp, Uint32 flags)
+os2fslib_SetVideoMode(_THIS, SDL_Surface * current,
-{
+int width, int height, int bpp, Uint32 flags)
-static int bFirstCall = 1;
+{
-FSLib_VideoMode_p pModeInfo, pModeInfoFound;
+static int bFirstCall = 1;
-FSLib_VideoMode TempModeInfo;
+FSLib_VideoMode_p pModeInfo, pModeInfoFound;
-HAB hab;
+FSLib_VideoMode TempModeInfo;
-HMQ hmq;
+HAB hab;
-ERRORID hmqerror;
+HMQ hmq;
-RECTL rectl;
+ERRORID hmqerror;
-SDL_Surface *pResult;
+RECTL rectl;
+SDL_Surface *pResult;
-// If there is no more window, nothing we can do!
-if (_this->hidden->iPMThreadStatus!=1) return NULL;
+// If there is no more window, nothing we can do!
+if (_this->hidden->iPMThreadStatus != 1)
-#ifdef DEBUG_BUILD
+return NULL;
-printf("[os2fslib_SetVideoMode] : Request for %dx%d @ %dBPP, flags=0x%x\n", width, height, bpp, flags); fflush(stdout);
-#endif
+#ifdef DEBUG_BUILD
+printf
-// We don't support palette modes!
+("[os2fslib_SetVideoMode] : Request for %dx%d @ %dBPP, flags=0x%x\n",
-if (bpp==8) bpp=32;
+width, height, bpp, flags);
+fflush(stdout);
-// Also, we don't support resizable modes in fullscreen mode.
+#endif
-if (flags & SDL_RESIZABLE)
-flags &= ~SDL_FULLSCREEN;
+// We don't support palette modes!
+if (bpp == 8)
-// No double buffered mode
+bpp = 32;
-if (flags & SDL_DOUBLEBUF)
-flags &= ~SDL_DOUBLEBUF;
+// Also, we don't support resizable modes in fullscreen mode.
+if (flags & SDL_RESIZABLE)
-// And, we don't support HWSURFACE yet.
+flags &= ~SDL_FULLSCREEN;
-if (flags & SDL_HWSURFACE)
-{
+// No double buffered mode
-flags &= ~SDL_HWSURFACE;
+if (flags & SDL_DOUBLEBUF)
-flags |= SDL_SWSURFACE;
+flags &= ~SDL_DOUBLEBUF;
-}
+// And, we don't support HWSURFACE yet.
-#ifdef DEBUG_BUILD
+if (flags & SDL_HWSURFACE) {
-printf("[os2fslib_SetVideoMode] : Changed request to %dx%d @ %dBPP, flags=0x%x\n", width, height, bpp, flags); fflush(stdout);
+flags &= ~SDL_HWSURFACE;
-#endif
+flags |= SDL_SWSURFACE;
+}
-// First check if there is such a video mode they want!
+#ifdef DEBUG_BUILD
-pModeInfoFound = NULL;
+printf
+("[os2fslib_SetVideoMode] : Changed request to %dx%d @ %dBPP, flags=0x%x\n",
-// For fullscreen mode we don't support every resolution!
+width, height, bpp, flags);
-// So, go through the video modes, and check for such a resolution!
+fflush(stdout);
-pModeInfoFound = NULL;
+#endif
-pModeInfo = _this->hidden->pAvailableFSLibVideoModes;
+// First check if there is such a video mode they want!
-while (pModeInfo)
+pModeInfoFound = NULL;
-{
-// Check all available fullscreen modes for this resolution
+// For fullscreen mode we don't support every resolution!
-if ((pModeInfo->uiXResolution == width) &&
+// So, go through the video modes, and check for such a resolution!
-(pModeInfo->uiYResolution == height) &&
+pModeInfoFound = NULL;
-(pModeInfo->uiBPP!=8)) // palettized modes not yet supported
-{
-// If good resolution, try to find the exact BPP, or at least
-// something similar...
-if (!pModeInfoFound)
-pModeInfoFound = pModeInfo;
-else
-if ((pModeInfoFound->uiBPP!=bpp) &&
-(pModeInfoFound->uiBPP<pModeInfo->uiBPP))
-pModeInfoFound = pModeInfo;
-}
-pModeInfo = pModeInfo->pNext;
-}
-// If we did not find a good fullscreen mode, then try a similar
-if (!pModeInfoFound)
-{
-#ifdef DEBUG_BUILD
-printf("[os2fslib_SetVideoMode] : Requested video mode not found, looking for a similar one!\n"); fflush(stdout);
-#endif
-// Go through the video modes again, and find a similar resolution!
 pModeInfo = _this->hidden->pAvailableFSLibVideoModes;
-while (pModeInfo)
-{
+while (pModeInfo) {
 // Check all available fullscreen modes for this resolution
-if ((pModeInfo->uiXResolution >= width) &&
+if ((pModeInfo->uiXResolution == width) && (pModeInfo->uiYResolution == height) && (pModeInfo->uiBPP != 8))     // palettized modes not yet supported
-(pModeInfo->uiYResolution >= height) &&
-(pModeInfo->uiBPP == bpp))
-{
-if (!pModeInfoFound)
-pModeInfoFound = pModeInfo;
-else
-if (((pModeInfoFound->uiXResolution-width)*(pModeInfoFound->uiYResolution-height))>
-((pModeInfo->uiXResolution-width)*(pModeInfo->uiYResolution-height)))
 {
-// Found a mode which is closer than the current one
+// If good resolution, try to find the exact BPP, or at least
-pModeInfoFound = pModeInfo;
+// something similar...
-}
+if (!pModeInfoFound)
-}
+pModeInfoFound = pModeInfo;
-pModeInfo = pModeInfo->pNext;
+else if ((pModeInfoFound->uiBPP != bpp) &&
-}
+(pModeInfoFound->uiBPP < pModeInfo->uiBPP))
-}
+pModeInfoFound = pModeInfo;
+}
-// If we did not find a good fullscreen mode, then return NULL
+pModeInfo = pModeInfo->pNext;
-if (!pModeInfoFound)
+}
-{
-#ifdef DEBUG_BUILD
+// If we did not find a good fullscreen mode, then try a similar
-printf("[os2fslib_SetVideoMode] : Requested video mode not found!\n"); fflush(stdout);
+if (!pModeInfoFound) {
-#endif
+#ifdef DEBUG_BUILD
-return NULL;
+printf
-}
+("[os2fslib_SetVideoMode] : Requested video mode not found, looking for a similar one!\n");
+fflush(stdout);
-#ifdef DEBUG_BUILD
+#endif
-printf("[os2fslib_SetVideoMode] : Found mode!\n"); fflush(stdout);
+// Go through the video modes again, and find a similar resolution!
-#endif
+pModeInfo = _this->hidden->pAvailableFSLibVideoModes;
+while (pModeInfo) {
-// We'll possibly adjust the structure, so copy out the values
+// Check all available fullscreen modes for this resolution
-// into TempModeInfo!
+if ((pModeInfo->uiXResolution >= width) &&
-SDL_memcpy(&TempModeInfo, pModeInfoFound, sizeof(TempModeInfo));
+(pModeInfo->uiYResolution >= height) &&
-pModeInfoFound = &TempModeInfo;
+(pModeInfo->uiBPP == bpp)) {
+if (!pModeInfoFound)
-if (flags & SDL_RESIZABLE)
+pModeInfoFound = pModeInfo;
-{
+else if (((pModeInfoFound->uiXResolution -
-#ifdef DEBUG_BUILD
+width) * (pModeInfoFound->uiYResolution -
-printf("[os2fslib_SetVideoMode] : Requested mode is resizable, changing width/height\n"); fflush(stdout);
+height)) >
-#endif
+((pModeInfo->uiXResolution -
-// Change width and height to requested one!
+width) * (pModeInfo->uiYResolution - height))) {
-TempModeInfo.uiXResolution = width;
+// Found a mode which is closer than the current one
-TempModeInfo.uiYResolution = height;
+pModeInfoFound = pModeInfo;
-TempModeInfo.uiScanLineSize = width * ((TempModeInfo.uiBPP+7)/8);
+}
 }
+pModeInfo = pModeInfo->pNext;
-// We can try create new surface!
+}
+}
-// Make sure this thread is prepared for using the Presentation Manager!
+// If we did not find a good fullscreen mode, then return NULL
-hab = WinInitialize(0);
+if (!pModeInfoFound) {
-hmq = WinCreateMsgQueue(hab,0);
+#ifdef DEBUG_BUILD
-// Remember if there was an error at WinCreateMsgQueue(), because we don't
+printf("[os2fslib_SetVideoMode] : Requested video mode not found!\n");
-// want to destroy somebody else's queue later. :)
+fflush(stdout);
-hmqerror = WinGetLastError(hab);
+#endif
+return NULL;
+}
+#ifdef DEBUG_BUILD
-if (DosRequestMutexSem(_this->hidden->hmtxUseSrcBuffer, SEM_INDEFINITE_WAIT)==NO_ERROR)
+printf("[os2fslib_SetVideoMode] : Found mode!\n");
-{
+fflush(stdout);
-#ifdef DEBUG_BUILD
+#endif
-printf("[os2fslib_SetVideoMode] : Creating new SW surface\n"); fflush(stdout);
-#endif
+// We'll possibly adjust the structure, so copy out the values
+// into TempModeInfo!
-// Create new software surface!
+SDL_memcpy(&TempModeInfo, pModeInfoFound, sizeof(TempModeInfo));
-pResult = SDL_CreateRGBSurface(SDL_SWSURFACE,
+pModeInfoFound = &TempModeInfo;
-pModeInfoFound->uiXResolution,
-pModeInfoFound->uiYResolution,
+if (flags & SDL_RESIZABLE) {
-pModeInfoFound->uiBPP,
+#ifdef DEBUG_BUILD
-((unsigned int) pModeInfoFound->PixelFormat.ucRedMask) << pModeInfoFound->PixelFormat.ucRedPosition,
+printf
-((unsigned int) pModeInfoFound->PixelFormat.ucGreenMask) << pModeInfoFound->PixelFormat.ucGreenPosition,
+("[os2fslib_SetVideoMode] : Requested mode is resizable, changing width/height\n");
-((unsigned int) pModeInfoFound->PixelFormat.ucBlueMask) << pModeInfoFound->PixelFormat.ucBluePosition,
+fflush(stdout);
-((unsigned int) pModeInfoFound->PixelFormat.ucAlphaMask) << pModeInfoFound->PixelFormat.ucAlphaPosition);
+#endif
+// Change width and height to requested one!
-if (pResult == NULL)
+TempModeInfo.uiXResolution = width;
-{
+TempModeInfo.uiYResolution = height;
-DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
+TempModeInfo.uiScanLineSize = width * ((TempModeInfo.uiBPP + 7) / 8);
-SDL_OutOfMemory();
+}
-return NULL;
+// We can try create new surface!
-}
+// Make sure this thread is prepared for using the Presentation Manager!
-#ifdef DEBUG_BUILD
+hab = WinInitialize(0);
-printf("[os2fslib_SetVideoMode] : Adjusting pixel format\n"); fflush(stdout);
+hmq = WinCreateMsgQueue(hab, 0);
-#endif
+// Remember if there was an error at WinCreateMsgQueue(), because we don't
+// want to destroy somebody else's queue later. :)
-// Adjust pixel format mask!
+hmqerror = WinGetLastError(hab);
-pResult->format->Rmask = ((unsigned int) pModeInfoFound->PixelFormat.ucRedMask) << pModeInfoFound->PixelFormat.ucRedPosition;
-pResult->format->Rshift = pModeInfoFound->PixelFormat.ucRedPosition;
-pResult->format->Rloss = pModeInfoFound->PixelFormat.ucRedAdjust;
-pResult->format->Gmask = ((unsigned int) pModeInfoFound->PixelFormat.ucGreenMask) << pModeInfoFound->PixelFormat.ucGreenPosition;
+if (DosRequestMutexSem
-pResult->format->Gshift = pModeInfoFound->PixelFormat.ucGreenPosition;
+(_this->hidden->hmtxUseSrcBuffer, SEM_INDEFINITE_WAIT) == NO_ERROR) {
-pResult->format->Gloss = pModeInfoFound->PixelFormat.ucGreenAdjust;
+#ifdef DEBUG_BUILD
-pResult->format->Bmask = ((unsigned int) pModeInfoFound->PixelFormat.ucBlueMask) << pModeInfoFound->PixelFormat.ucBluePosition;
+printf("[os2fslib_SetVideoMode] : Creating new SW surface\n");
-pResult->format->Bshift = pModeInfoFound->PixelFormat.ucBluePosition;
+fflush(stdout);
-pResult->format->Bloss = pModeInfoFound->PixelFormat.ucBlueAdjust;
+#endif
-pResult->format->Amask = ((unsigned int) pModeInfoFound->PixelFormat.ucAlphaMask) << pModeInfoFound->PixelFormat.ucAlphaPosition;
-pResult->format->Ashift = pModeInfoFound->PixelFormat.ucAlphaPosition;
+// Create new software surface!
-pResult->format->Aloss = pModeInfoFound->PixelFormat.ucAlphaAdjust;
+pResult = SDL_CreateRGBSurface(SDL_SWSURFACE,
+pModeInfoFound->uiXResolution,
+pModeInfoFound->uiYResolution,
+pModeInfoFound->uiBPP,
+((unsigned int) pModeInfoFound->
+PixelFormat.
+ucRedMask) << pModeInfoFound->
+PixelFormat.ucRedPosition,
+((unsigned int) pModeInfoFound->
+PixelFormat.
+ucGreenMask) << pModeInfoFound->
+PixelFormat.ucGreenPosition,
+((unsigned int) pModeInfoFound->
+PixelFormat.
+ucBlueMask) << pModeInfoFound->
+PixelFormat.ucBluePosition,
+((unsigned int) pModeInfoFound->
+PixelFormat.
+ucAlphaMask) << pModeInfoFound->
+PixelFormat.ucAlphaPosition);
+if (pResult == NULL) {
+DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
+SDL_OutOfMemory();
+return NULL;
+}
+#ifdef DEBUG_BUILD
+printf("[os2fslib_SetVideoMode] : Adjusting pixel format\n");
+fflush(stdout);
+#endif
+// Adjust pixel format mask!
+pResult->format->Rmask =
+((unsigned int) pModeInfoFound->PixelFormat.
+ucRedMask) << pModeInfoFound->PixelFormat.ucRedPosition;
+pResult->format->Rshift = pModeInfoFound->PixelFormat.ucRedPosition;
+pResult->format->Rloss = pModeInfoFound->PixelFormat.ucRedAdjust;
+pResult->format->Gmask =
+((unsigned int) pModeInfoFound->PixelFormat.
+ucGreenMask) << pModeInfoFound->PixelFormat.ucGreenPosition;
+pResult->format->Gshift = pModeInfoFound->PixelFormat.ucGreenPosition;
+pResult->format->Gloss = pModeInfoFound->PixelFormat.ucGreenAdjust;
+pResult->format->Bmask =
+((unsigned int) pModeInfoFound->PixelFormat.
+ucBlueMask) << pModeInfoFound->PixelFormat.ucBluePosition;
+pResult->format->Bshift = pModeInfoFound->PixelFormat.ucBluePosition;
+pResult->format->Bloss = pModeInfoFound->PixelFormat.ucBlueAdjust;
+pResult->format->Amask =
+((unsigned int) pModeInfoFound->PixelFormat.
+ucAlphaMask) << pModeInfoFound->PixelFormat.ucAlphaPosition;
+pResult->format->Ashift = pModeInfoFound->PixelFormat.ucAlphaPosition;
+pResult->format->Aloss = pModeInfoFound->PixelFormat.ucAlphaAdjust;
 #ifdef REPORT_EMPTY_ALPHA_MASK
 pResult->format->Amask =
-pResult->format->Ashift =
+pResult->format->Ashift = pResult->format->Aloss = 0;
-pResult->format->Aloss = 0;
+#endif
-#endif
+// Adjust surface flags
-// Adjust surface flags
+pResult->flags |= (flags & SDL_FULLSCREEN);
-pResult->flags |= (flags & SDL_FULLSCREEN);
+pResult->flags |= (flags & SDL_RESIZABLE);
-pResult->flags |= (flags & SDL_RESIZABLE);
+// It might be that the software surface pitch is not the same as
-// It might be that the software surface pitch is not the same as
+// the pitch we have, so adjust that!
-// the pitch we have, so adjust that!
+pModeInfoFound->uiScanLineSize = pResult->pitch;
-pModeInfoFound->uiScanLineSize = pResult->pitch;
+// Store new source buffer parameters!
-// Store new source buffer parameters!
+SDL_memcpy(&(_this->hidden->SrcBufferDesc), pModeInfoFound,
-SDL_memcpy(&(_this->hidden->SrcBufferDesc), pModeInfoFound, sizeof(*pModeInfoFound));
+sizeof(*pModeInfoFound));
 _this->hidden->pchSrcBuffer = pResult->pixels;
 #ifdef DEBUG_BUILD
-printf("[os2fslib_SetVideoMode] : Telling FSLib the stuffs\n"); fflush(stdout);
+printf("[os2fslib_SetVideoMode] : Telling FSLib the stuffs\n");
-#endif
+fflush(stdout);
+#endif
-// Tell the FSLib window the new source image format
-FSLib_SetSrcBufferDesc(_this->hidden->hwndClient, &(_this->hidden->SrcBufferDesc));
+// Tell the FSLib window the new source image format
+FSLib_SetSrcBufferDesc(_this->hidden->hwndClient,
-if (
+&(_this->hidden->SrcBufferDesc));
-((flags & SDL_RESIZABLE)==0) ||
-(bFirstCall)
+if (((flags & SDL_RESIZABLE) == 0) || (bFirstCall)) {
-)
+bFirstCall = 0;
-{
+#ifdef DEBUG_BUILD
-bFirstCall = 0;
+printf("[os2fslib_SetVideoMode] : Modifying window size\n");
-#ifdef DEBUG_BUILD
+fflush(stdout);
-printf("[os2fslib_SetVideoMode] : Modifying window size\n"); fflush(stdout);
+#endif
-#endif
+// Calculate frame window size from client window size
-// Calculate frame window size from client window size
+rectl.xLeft = 0;
-rectl.xLeft = 0;
+rectl.yBottom = 0;
-rectl.yBottom = 0;
+rectl.xRight = pModeInfoFound->uiXResolution;       // Noninclusive
-rectl.xRight = pModeInfoFound->uiXResolution; // Noninclusive
+rectl.yTop = pModeInfoFound->uiYResolution; // Noninclusive
-rectl.yTop = pModeInfoFound->uiYResolution; // Noninclusive
+WinCalcFrameRect(_this->hidden->hwndFrame, &rectl, FALSE);
-WinCalcFrameRect(_this->hidden->hwndFrame, &rectl, FALSE);
+// Set the new size of the main window
-// Set the new size of the main window
+SetAccessableWindowPos(_this->hidden->hwndFrame,
-SetAccessableWindowPos(_this->hidden->hwndFrame,
+HWND_TOP,
-HWND_TOP,
+0, 0,
-0, 0,
+(rectl.xRight - rectl.xLeft),
-(rectl.xRight-rectl.xLeft),
+(rectl.yTop - rectl.yBottom),
-(rectl.yTop-rectl.yBottom),
+SWP_SIZE | SWP_ACTIVATE | SWP_SHOW);
-SWP_SIZE | SWP_ACTIVATE | SWP_SHOW);
+}
-}
+// Set fullscreen mode flag, and switch to fullscreen if needed!
+if (flags & SDL_FULLSCREEN) {
-// Set fullscreen mode flag, and switch to fullscreen if needed!
+#ifdef DEBUG_BUILD
-if (flags & SDL_FULLSCREEN)
+printf
-{
+("[os2fslib_SetVideoMode] : Also trying to switch to fullscreen\n");
-#ifdef DEBUG_BUILD
+fflush(stdout);
-printf("[os2fslib_SetVideoMode] : Also trying to switch to fullscreen\n");
+#endif
-fflush(stdout);
+FSLib_ToggleFSMode(_this->hidden->hwndClient, 1);
-#endif
+/* Cursor manager functions to FS mode */
-FSLib_ToggleFSMode(_this->hidden->hwndClient, 1);
+os2fslib_SetCursorManagementFunctions(_this, 0);
-/* Cursor manager functions to FS mode*/
+} else {
-os2fslib_SetCursorManagementFunctions(_this, 0);
+#ifdef DEBUG_BUILD
-} else
+printf
-{
+("[os2fslib_SetVideoMode] : Also trying to switch to desktop mode\n");
-#ifdef DEBUG_BUILD
+fflush(stdout);
-printf("[os2fslib_SetVideoMode] : Also trying to switch to desktop mode\n");
+#endif
-fflush(stdout);
+FSLib_ToggleFSMode(_this->hidden->hwndClient, 0);
-#endif
+/* Cursor manager functions to Windowed mode */
-FSLib_ToggleFSMode(_this->hidden->hwndClient, 0);
+os2fslib_SetCursorManagementFunctions(_this, 1);
-/* Cursor manager functions to Windowed mode*/
+}
-os2fslib_SetCursorManagementFunctions(_this, 1);
-}
+_this->hidden->pSDLSurface = pResult;
-_this->hidden->pSDLSurface = pResult;
+DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
+} else {
-DosReleaseMutexSem(_this->hidden->hmtxUseSrcBuffer);
+#ifdef DEBUG_BUILD
-} else
+printf("[os2fslib_SetVideoMode] : Could not get hmtxUseSrcBuffer!\n");
-{
+fflush(stdout);
-#ifdef DEBUG_BUILD
+#endif
-printf("[os2fslib_SetVideoMode] : Could not get hmtxUseSrcBuffer!\n"); fflush(stdout);
-#endif
+pResult = NULL;
+}
-pResult = NULL;
-}
+// As we have the new surface, we don't need the current one anymore!
+if ((pResult) && (current)) {
-// As we have the new surface, we don't need the current one anymore!
+#ifdef DEBUG_BUILD
-if ((pResult) && (current))
+printf("[os2fslib_SetVideoMode] : Freeing old surface\n");
-{
+fflush(stdout);
-#ifdef DEBUG_BUILD
+#endif
-printf("[os2fslib_SetVideoMode] : Freeing old surface\n"); fflush(stdout);
+SDL_FreeSurface(current);
-#endif
+}
-SDL_FreeSurface(current);
+// Redraw window
-}
+WinInvalidateRegion(_this->hidden->hwndClient, NULL, TRUE);
-// Redraw window
+// Now destroy the message queue, if we've created it!
-WinInvalidateRegion(_this->hidden->hwndClient, NULL, TRUE);
+if (ERRORIDERROR(hmqerror) == 0) {
+#ifdef DEBUG_BUILD
-// Now destroy the message queue, if we've created it!
+printf("[os2fslib_SetVideoMode] : Destroying message queue\n");
-if (ERRORIDERROR(hmqerror)==0)
+fflush(stdout);
-{
+#endif
-#ifdef DEBUG_BUILD
+WinDestroyMsgQueue(hmq);
-printf("[os2fslib_SetVideoMode] : Destroying message queue\n"); fflush(stdout);
+}
-#endif
+#ifdef DEBUG_BUILD
-WinDestroyMsgQueue(hmq);
+printf("[os2fslib_SetVideoMode] : Done\n");
-}
+fflush(stdout);
+#endif
-#ifdef DEBUG_BUILD
-printf("[os2fslib_SetVideoMode] : Done\n"); fflush(stdout);
+/* We're done */
-#endif
+// Return with the new surface!
-/* We're done */
+return pResult;
-// Return with the new surface!
-return pResult;
 }
 /* List the available video modes for the given pixel format, sorted
 from largest to smallest.
 */
-static SDL_Rect **os2fslib_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
+static SDL_Rect **
-{
+os2fslib_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
-#ifdef DEBUG_BUILD
+{
-printf("[os2fslib_ListModes] : ListModes of %d Bpp\n", format->BitsPerPixel);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_ListModes] : ListModes of %d Bpp\n",
-// Destroy result of previous call, if there is any
+format->BitsPerPixel);
-if (_this->hidden->pListModesResult)
+#endif
-{
+// Destroy result of previous call, if there is any
-SDL_free(_this->hidden->pListModesResult); _this->hidden->pListModesResult = NULL;
+if (_this->hidden->pListModesResult) {
-}
+SDL_free(_this->hidden->pListModesResult);
+_this->hidden->pListModesResult = NULL;
-// For resizable and windowed mode we support every resolution!
+}
-if ((flags & SDL_RESIZABLE) && ((flags & SDL_FULLSCREEN) == 0))
+// For resizable and windowed mode we support every resolution!
-return (SDL_Rect **)-1;
+if ((flags & SDL_RESIZABLE) && ((flags & SDL_FULLSCREEN) == 0))
+return (SDL_Rect **) - 1;
-// Check if they need fullscreen or non-fullscreen video modes!
-if ((flags & SDL_FULLSCREEN) == 0)
+// Check if they need fullscreen or non-fullscreen video modes!
+if ((flags & SDL_FULLSCREEN) == 0) {
-{
+// For windowed mode we support every resolution!
-// For windowed mode we support every resolution!
+return (SDL_Rect **) - 1;
-return (SDL_Rect **)-1;
+} else {
-} else
+FSLib_VideoMode_p pFSMode;
-{
+// For fullscreen mode we don't support every resolution!
-FSLib_VideoMode_p pFSMode;
+// Now create a new list
-// For fullscreen mode we don't support every resolution!
+pFSMode = _this->hidden->pAvailableFSLibVideoModes;
-// Now create a new list
+while (pFSMode) {
-pFSMode = _this->hidden->pAvailableFSLibVideoModes;
+if (pFSMode->uiBPP == format->BitsPerPixel) {
-while (pFSMode)
+SDL_Rect *pRect = (SDL_Rect *) SDL_malloc(sizeof(SDL_Rect));
-{
+if (pRect) {
-if (pFSMode->uiBPP == format->BitsPerPixel)
+// Fill description
-{
+pRect->x = 0;
-SDL_Rect *pRect = (SDL_Rect *) SDL_malloc(sizeof(SDL_Rect));
+pRect->y = 0;
-if (pRect)
+pRect->w = pFSMode->uiXResolution;
-{
+pRect->h = pFSMode->uiYResolution;
-// Fill description
-pRect->x = 0;
-pRect->y = 0;
-pRect->w = pFSMode->uiXResolution;
-pRect->h = pFSMode->uiYResolution;
 #ifdef DEBUG_BUILD
 //          printf("!!! Seems to be good!\n");
 //        printf("F: %dx%d\n", pRect->w, pRect->h);
 #endif
 // And insert into list of pRects
-if (!(_this->hidden->pListModesResult))
+if (!(_this->hidden->pListModesResult)) {
-{
 #ifdef DEBUG_BUILD
 //            printf("!!! Inserting to beginning\n");
 #endif
 // We're the first one to be inserted!
-_this->hidden->pListModesResult = (SDL_Rect**) SDL_malloc(2*sizeof(SDL_Rect*));
+_this->hidden->pListModesResult =
-if (_this->hidden->pListModesResult)
+(SDL_Rect **) SDL_malloc(2 * sizeof(SDL_Rect *));
-{
+if (_this->hidden->pListModesResult) {
 _this->hidden->pListModesResult[0] = pRect;
 _this->hidden->pListModesResult[1] = NULL;
-} else
+} else {
-{
+SDL_free(pRect);
-SDL_free(pRect);
+}
+} else {
+// We're not the first ones, so find the place where we
+// have to insert ourselves
+SDL_Rect **pNewList;
+int iPlace, iNumOfSlots, i;
+#ifdef DEBUG_BUILD
+//            printf("!!! Searching where to insert\n");
+#endif
+iPlace = -1;
+iNumOfSlots = 1;        // Count the last NULL too!
+for (i = 0; _this->hidden->pListModesResult[i]; i++) {
+iNumOfSlots++;
+if (iPlace == -1) {
+if ((_this->hidden->
+pListModesResult[i]->w *
+_this->hidden->
+pListModesResult[i]->h) <
+(pRect->w * pRect->h)) {
+iPlace = i;
+}
+}
+}
+if (iPlace == -1)
+iPlace = iNumOfSlots - 1;
+#ifdef DEBUG_BUILD
+//            printf("!!! From %d slots, it will be at %d\n", iNumOfSlots, iPlace);
+#endif
+pNewList =
+(SDL_Rect **) SDL_realloc(_this->
+hidden->
+pListModesResult,
+(iNumOfSlots
++
+1) *
+sizeof(SDL_Rect *));
+if (pNewList) {
+for (i = iNumOfSlots; i > iPlace; i--)
+pNewList[i] = pNewList[i - 1];
+pNewList[iPlace] = pRect;
+_this->hidden->pListModesResult = pNewList;
+} else {
+SDL_free(pRect);
+}
+}
+}
 }
-} else
+pFSMode = pFSMode->pNext;
-{
+}
-// We're not the first ones, so find the place where we
+}
-// have to insert ourselves
-SDL_Rect **pNewList;
-int iPlace, iNumOfSlots, i;
-#ifdef DEBUG_BUILD
-//            printf("!!! Searching where to insert\n");
-#endif
-iPlace = -1; iNumOfSlots = 1; // Count the last NULL too!
-for (i=0; _this->hidden->pListModesResult[i]; i++)
-{
-iNumOfSlots++;
-if (iPlace==-1)
-{
-if ((_this->hidden->pListModesResult[i]->w*_this->hidden->pListModesResult[i]->h)<
-(pRect->w*pRect->h))
-{
-iPlace = i;
-}
-}
-}
-if (iPlace==-1) iPlace = iNumOfSlots-1;
-#ifdef DEBUG_BUILD
-//            printf("!!! From %d slots, it will be at %d\n", iNumOfSlots, iPlace);
-#endif
-pNewList = (SDL_Rect**) SDL_realloc(_this->hidden->pListModesResult, (iNumOfSlots+1)*sizeof(SDL_Rect*));
-if (pNewList)
-{
-for (i=iNumOfSlots;i>iPlace;i--)
-pNewList[i] = pNewList[i-1];
-pNewList[iPlace] = pRect;
-_this->hidden->pListModesResult = pNewList;
-} else
-{
-SDL_free(pRect);
-}
-}
-}
-}
-pFSMode = pFSMode->pNext;
-}
-}
 #ifdef DEBUG_BUILD
 //  printf("Returning list\n");
 #endif
 return _this->hidden->pListModesResult;
 }
 /* Initialize the native video subsystem, filling 'vformat' with the
 "best" display pixel format, returning 0 or -1 if there's an error.
 */
-static int os2fslib_VideoInit(_THIS, SDL_PixelFormat *vformat)
+static int
-{
+os2fslib_VideoInit(_THIS, SDL_PixelFormat * vformat)
-FSLib_VideoMode_p pDesktopMode;
+{
+FSLib_VideoMode_p pDesktopMode;
-#ifdef DEBUG_BUILD
-printf("[os2fslib_VideoInit] : Enter\n"); fflush(stdout);
+#ifdef DEBUG_BUILD
-#endif
+printf("[os2fslib_VideoInit] : Enter\n");
+fflush(stdout);
-// Report the best pixel format. For this,
+#endif
-// we'll use the current desktop format.
-pDesktopMode = FSLib_GetDesktopVideoMode();
+// Report the best pixel format. For this,
-if (!pDesktopMode)
+// we'll use the current desktop format.
-{
+pDesktopMode = FSLib_GetDesktopVideoMode();
-SDL_SetError("Could not query desktop video mode!");
+if (!pDesktopMode) {
-#ifdef DEBUG_BUILD
+SDL_SetError("Could not query desktop video mode!");
-printf("[os2fslib_VideoInit] : Could not query desktop video mode!\n");
+#ifdef DEBUG_BUILD
-#endif
+printf
-return -1;
+("[os2fslib_VideoInit] : Could not query desktop video mode!\n");
-}
+#endif
+return -1;
-/* Determine the current screen size */
+}
-_this->info.current_w = pDesktopMode->uiXResolution;
-_this->info.current_h = pDesktopMode->uiYResolution;
+/* Determine the current screen size */
+_this->info.current_w = pDesktopMode->uiXResolution;
-/* Determine the screen depth */
+_this->info.current_h = pDesktopMode->uiYResolution;
-vformat->BitsPerPixel = pDesktopMode->uiBPP;
-vformat->BytesPerPixel = (vformat->BitsPerPixel+7)/8;
+/* Determine the screen depth */
+vformat->BitsPerPixel = pDesktopMode->uiBPP;
-vformat->Rmask = ((unsigned int) pDesktopMode->PixelFormat.ucRedMask) << pDesktopMode->PixelFormat.ucRedPosition;
+vformat->BytesPerPixel = (vformat->BitsPerPixel + 7) / 8;
-vformat->Rshift = pDesktopMode->PixelFormat.ucRedPosition;
-vformat->Rloss = pDesktopMode->PixelFormat.ucRedAdjust;
+vformat->Rmask =
-vformat->Gmask = ((unsigned int) pDesktopMode->PixelFormat.ucGreenMask) << pDesktopMode->PixelFormat.ucGreenPosition;
+((unsigned int) pDesktopMode->PixelFormat.ucRedMask) << pDesktopMode->
-vformat->Gshift = pDesktopMode->PixelFormat.ucGreenPosition;
+PixelFormat.ucRedPosition;
-vformat->Gloss = pDesktopMode->PixelFormat.ucGreenAdjust;
+vformat->Rshift = pDesktopMode->PixelFormat.ucRedPosition;
-vformat->Bmask = ((unsigned int) pDesktopMode->PixelFormat.ucBlueMask) << pDesktopMode->PixelFormat.ucBluePosition;
+vformat->Rloss = pDesktopMode->PixelFormat.ucRedAdjust;
-vformat->Bshift = pDesktopMode->PixelFormat.ucBluePosition;
+vformat->Gmask =
-vformat->Bloss = pDesktopMode->PixelFormat.ucBlueAdjust;
+((unsigned int) pDesktopMode->PixelFormat.
-vformat->Amask = ((unsigned int) pDesktopMode->PixelFormat.ucAlphaMask) << pDesktopMode->PixelFormat.ucAlphaPosition;
+ucGreenMask) << pDesktopMode->PixelFormat.ucGreenPosition;
-vformat->Ashift = pDesktopMode->PixelFormat.ucAlphaPosition;
+vformat->Gshift = pDesktopMode->PixelFormat.ucGreenPosition;
-vformat->Aloss = pDesktopMode->PixelFormat.ucAlphaAdjust;
+vformat->Gloss = pDesktopMode->PixelFormat.ucGreenAdjust;
+vformat->Bmask =
+((unsigned int) pDesktopMode->PixelFormat.
+ucBlueMask) << pDesktopMode->PixelFormat.ucBluePosition;
+vformat->Bshift = pDesktopMode->PixelFormat.ucBluePosition;
+vformat->Bloss = pDesktopMode->PixelFormat.ucBlueAdjust;
+vformat->Amask =
+((unsigned int) pDesktopMode->PixelFormat.
+ucAlphaMask) << pDesktopMode->PixelFormat.ucAlphaPosition;
+vformat->Ashift = pDesktopMode->PixelFormat.ucAlphaPosition;
+vformat->Aloss = pDesktopMode->PixelFormat.ucAlphaAdjust;
 #ifdef REPORT_EMPTY_ALPHA_MASK
-vformat->Amask =
+vformat->Amask = vformat->Ashift = vformat->Aloss = 0;
-vformat->Ashift =
+#endif
-vformat->Aloss = 0;
-#endif
+// Fill in some window manager capabilities
+_this->info.wm_available = 1;
-// Fill in some window manager capabilities
-_this->info.wm_available = 1;
+// Initialize some internal variables
+_this->hidden->pListModesResult = NULL;
-// Initialize some internal variables
+_this->hidden->fInFocus = 0;
-_this->hidden->pListModesResult = NULL;
+_this->hidden->iSkipWMMOUSEMOVE = 0;
-_this->hidden->fInFocus = 0;
+_this->hidden->iMouseVisible = 1;
-_this->hidden->iSkipWMMOUSEMOVE = 0;
-_this->hidden->iMouseVisible = 1;
+if (getenv("SDL_USE_PROPORTIONAL_WINDOW"))
+_this->hidden->bProportionalResize = 1;
-if (getenv("SDL_USE_PROPORTIONAL_WINDOW"))
+else {
-_this->hidden->bProportionalResize = 1;
+PPIB pib;
-else
+PTIB tib;
-{
+char *pchFileName, *pchTemp;
+char achConfigFile[CCHMAXPATH];
+FILE *hFile;
+/* No environment variable to have proportional window.
+* Ok, let's check if this executable is in config file!
+*/
+_this->hidden->bProportionalResize = 0;
+DosGetInfoBlocks(&tib, &pib);
+pchTemp = pchFileName = pib->pib_pchcmd;
+while (*pchTemp) {
+if (*pchTemp == '\\')
+pchFileName = pchTemp + 1;
+pchTemp++;
+}
+if (getenv("HOME")) {
+sprintf(achConfigFile, "%s\\.sdl.proportionals", getenv("HOME"));
+hFile = fopen(achConfigFile, "rt");
+if (!hFile) {
+/* Seems like the file cannot be opened or does not exist.
+* Let's try to create it with defaults!
+*/
+hFile = fopen(achConfigFile, "wt");
+if (hFile) {
+fprintf(hFile,
+"; This file is a config file of SDL/2, containing\n");
+fprintf(hFile,
+"; the list of executables that must have proportional\n");
+fprintf(hFile, "; windows.\n");
+fprintf(hFile, ";\n");
+fprintf(hFile,
+"; You can add executable filenames into this file,\n");
+fprintf(hFile,
+"; one under the other. If SDL finds that a given\n");
+fprintf(hFile,
+"; program is in this list, then that application\n");
+fprintf(hFile,
+"; will have proportional windows, just like if\n");
+fprintf(hFile,
+"; the SET SDL_USE_PROPORTIONAL_WINDOW env. variable\n");
+fprintf(hFile,
+"; would have been set for that process.\n");
+fprintf(hFile, ";\n");
+fprintf(hFile, "\n");
+fprintf(hFile, "dosbox.exe\n");
+fclose(hFile);
+}
+hFile = fopen(achConfigFile, "rt");
+}
+if (hFile) {
+while (fgets(achConfigFile, sizeof(achConfigFile), hFile)) {
+/* Cut \n from end of string */
+while (achConfigFile[strlen(achConfigFile) - 1]
+== '\n')
+achConfigFile[strlen(achConfigFile) - 1] = 0;
+/* Compare... */
+if (stricmp(achConfigFile, pchFileName) == 0) {
+/* Found it in config file! */
+_this->hidden->bProportionalResize = 1;
+break;
+}
+}
+fclose(hFile);
+}
+}
+}
+DosCreateMutexSem(NULL, &(_this->hidden->hmtxUseSrcBuffer), 0, FALSE);
+// Now create our window with a default size
+// For this, we select the first available fullscreen mode as
+// current window size!
+SDL_memcpy(&(_this->hidden->SrcBufferDesc),
+_this->hidden->pAvailableFSLibVideoModes,
+sizeof(_this->hidden->SrcBufferDesc));
+// Allocate new video buffer!
+_this->hidden->pchSrcBuffer =
+(char *) SDL_malloc(_this->hidden->pAvailableFSLibVideoModes->
+uiScanLineSize *
+_this->hidden->pAvailableFSLibVideoModes->
+uiYResolution);
+if (!_this->hidden->pchSrcBuffer) {
+#ifdef DEBUG_BUILD
+printf
+("[os2fslib_VideoInit] : Yikes, not enough memory for new video buffer!\n");
+fflush(stdout);
+#endif
+SDL_SetError("Not enough memory for new video buffer!\n");
+return -1;
+}
+// For this, we need a message processing thread.
+// We'll create a new thread for this, which will do everything
+// what is related to PM
+_this->hidden->iPMThreadStatus = 0;
+_this->hidden->tidPMThread =
+_beginthread(PMThreadFunc, NULL, 65536, (void *) _this);
+if (_this->hidden->tidPMThread <= 0) {
+#ifdef DEBUG_BUILD
+printf("[os2fslib_VideoInit] : Could not create PM thread!\n");
+#endif
+SDL_SetError("Could not create PM thread");
+return -1;
+}
+#ifdef USE_DOSSETPRIORITY
+// Burst the priority of PM Thread!
+DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0,
+_this->hidden->tidPMThread);
+#endif
+// Wait for the PM thread to initialize!
+while (_this->hidden->iPMThreadStatus == 0)
+DosSleep(32);
+// If the PM thread could not set up everything, then
+// report an error!
+if (_this->hidden->iPMThreadStatus != 1) {
+#ifdef DEBUG_BUILD
+printf("[os2fslib_VideoInit] : PMThread reported an error : %d\n",
+_this->hidden->iPMThreadStatus);
+#endif
+SDL_SetError("Error initializing PM thread");
+return -1;
+}
+return 0;
+}
+static void
+os2fslib_DeleteDevice(_THIS)
+{
+#ifdef DEBUG_BUILD
+printf("[os2fslib_DeleteDevice]\n");
+fflush(stdout);
+#endif
+// Free used memory
+FSLib_FreeVideoModeList(_this->hidden->pAvailableFSLibVideoModes);
+if (_this->hidden->pListModesResult)
+SDL_free(_this->hidden->pListModesResult);
+if (_this->hidden->pchSrcBuffer)
+SDL_free(_this->hidden->pchSrcBuffer);
+DosCloseMutexSem(_this->hidden->hmtxUseSrcBuffer);
+SDL_free(_this->hidden);
+SDL_free(_this);
+FSLib_Uninitialize();
+}
+static int
+os2fslib_Available(void)
+{
+// If we can run, it means that we could load FSLib,
+// so we assume that it's available then!
+return 1;
+}
+static void
+os2fslib_MorphToPM()
+{
 PPIB pib;
 PTIB tib;
-char *pchFileName, *pchTemp;
-char achConfigFile[CCHMAXPATH];
-FILE *hFile;
-/* No environment variable to have proportional window.
-* Ok, let's check if this executable is in config file!
-*/
-_this->hidden->bProportionalResize = 0;
 DosGetInfoBlocks(&tib, &pib);
-pchTemp = pchFileName = pib->pib_pchcmd;
-while (*pchTemp)
+// Change flag from VIO to PM:
-{
+if (pib->pib_ultype == 2)
-if (*pchTemp=='\\')
+pib->pib_ultype = 3;
-pchFileName = pchTemp+1;
+}
-pchTemp++;
-}
+static SDL_VideoDevice *
-if (getenv("HOME"))
+os2fslib_CreateDevice(int devindex)
 {
-sprintf(achConfigFile, "%s\\.sdl.proportionals", getenv("HOME"));
+SDL_VideoDevice *device;
-hFile = fopen(achConfigFile, "rt");
-if (!hFile)
+#ifdef DEBUG_BUILD
-{
+printf("[os2fslib_CreateDevice] : Enter\n");
-/* Seems like the file cannot be opened or does not exist.
+fflush(stdout);
-* Let's try to create it with defaults!
+#endif
-*/
-hFile = fopen(achConfigFile, "wt");
+/* Initialize all variables that we clean on shutdown */
-if (hFile)
+device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
-{
+if (device) {
-fprintf(hFile, "; This file is a config file of SDL/2, containing\n");
+SDL_memset(device, 0, (sizeof *device));
-fprintf(hFile, "; the list of executables that must have proportional\n");
+// Also allocate memory for private data
-fprintf(hFile, "; windows.\n");
+device->hidden = (struct SDL_PrivateVideoData *)
-fprintf(hFile, ";\n");
+SDL_malloc((sizeof(struct SDL_PrivateVideoData)));
-fprintf(hFile, "; You can add executable filenames into this file,\n");
+}
-fprintf(hFile, "; one under the other. If SDL finds that a given\n");
+if ((device == NULL) || (device->hidden == NULL)) {
-fprintf(hFile, "; program is in this list, then that application\n");
+SDL_OutOfMemory();
-fprintf(hFile, "; will have proportional windows, just like if\n");
+if (device)
-fprintf(hFile, "; the SET SDL_USE_PROPORTIONAL_WINDOW env. variable\n");
+SDL_free(device);
-fprintf(hFile, "; would have been set for that process.\n");
+return NULL;
-fprintf(hFile, ";\n");
+}
-fprintf(hFile, "\n");
+SDL_memset(device->hidden, 0, (sizeof *device->hidden));
-fprintf(hFile, "dosbox.exe\n");
-fclose(hFile);
+/* Set the function pointers */
-}
+#ifdef DEBUG_BUILD
+printf("[os2fslib_CreateDevice] : VideoInit is %p\n", os2fslib_VideoInit);
-hFile = fopen(achConfigFile, "rt");
+fflush(stdout);
-}
+#endif
-if (hFile)
+/* Initialization/Query functions */
-{
+device->VideoInit = os2fslib_VideoInit;
-while (fgets(achConfigFile, sizeof(achConfigFile), hFile))
+device->ListModes = os2fslib_ListModes;
-{
+device->SetVideoMode = os2fslib_SetVideoMode;
-/* Cut \n from end of string */
+device->ToggleFullScreen = os2fslib_ToggleFullScreen;
+device->UpdateMouse = os2fslib_UpdateMouse;
-while (achConfigFile[strlen(achConfigFile)-1] == '\n')
+device->CreateYUVOverlay = NULL;
-achConfigFile[strlen(achConfigFile)-1] = 0;
+device->SetColors = os2fslib_SetColors;
+device->UpdateRects = os2fslib_UpdateRects;
-/* Compare... */
+device->VideoQuit = os2fslib_VideoQuit;
-if (stricmp(achConfigFile, pchFileName)==0)
+/* Hardware acceleration functions */
-{
+device->AllocHWSurface = os2fslib_AllocHWSurface;
-/* Found it in config file! */
+device->CheckHWBlit = NULL;
-_this->hidden->bProportionalResize = 1;
+device->FillHWRect = NULL;
-break;
+device->SetHWColorKey = NULL;
-}
+device->SetHWAlpha = NULL;
-}
+device->LockHWSurface = os2fslib_LockHWSurface;
-fclose(hFile);
+device->UnlockHWSurface = os2fslib_UnlockHWSurface;
-}
+device->FlipHWSurface = NULL;
-}
+device->FreeHWSurface = os2fslib_FreeHWSurface;
-}
+/* Window manager functions */
+device->SetCaption = os2fslib_SetCaption;
-DosCreateMutexSem(NULL, &(_this->hidden->hmtxUseSrcBuffer), 0, FALSE);
+device->SetIcon = os2fslib_SetIcon;
+device->IconifyWindow = os2fslib_IconifyWindow;
-// Now create our window with a default size
+device->GrabInput = os2fslib_GrabInput;
+device->GetWMInfo = NULL;
-// For this, we select the first available fullscreen mode as
+/* Cursor manager functions to Windowed mode */
-// current window size!
+os2fslib_SetCursorManagementFunctions(device, 1);
-SDL_memcpy(&(_this->hidden->SrcBufferDesc), _this->hidden->pAvailableFSLibVideoModes, sizeof(_this->hidden->SrcBufferDesc));
+/* Event manager functions */
-// Allocate new video buffer!
+device->InitOSKeymap = os2fslib_InitOSKeymap;
-_this->hidden->pchSrcBuffer = (char *) SDL_malloc(_this->hidden->pAvailableFSLibVideoModes->uiScanLineSize * _this->hidden->pAvailableFSLibVideoModes->uiYResolution);
+device->PumpEvents = os2fslib_PumpEvents;
-if (!_this->hidden->pchSrcBuffer)
+/* The function used to dispose of this structure */
-{
+device->free = os2fslib_DeleteDevice;
-#ifdef DEBUG_BUILD
-printf("[os2fslib_VideoInit] : Yikes, not enough memory for new video buffer!\n"); fflush(stdout);
+// Make sure we'll be able to use Win* API even if the application
-#endif
+// was linked to be a VIO application!
-SDL_SetError("Not enough memory for new video buffer!\n");
+os2fslib_MorphToPM();
-return -1;
-}
+// Now initialize FSLib, and query available video modes!
+if (!FSLib_Initialize()) {
-// For this, we need a message processing thread.
+// Could not initialize FSLib!
-// We'll create a new thread for this, which will do everything
+#ifdef DEBUG_BUILD
-// what is related to PM
+printf("[os2fslib_CreateDevice] : Could not initialize FSLib!\n");
-_this->hidden->iPMThreadStatus = 0;
+#endif
-_this->hidden->tidPMThread = _beginthread(PMThreadFunc, NULL, 65536, (void *) _this);
+SDL_SetError("Could not initialize FSLib!");
-if (_this->hidden->tidPMThread <= 0)
+SDL_free(device->hidden);
-{
+SDL_free(device);
-#ifdef DEBUG_BUILD
+return NULL;
-printf("[os2fslib_VideoInit] : Could not create PM thread!\n");
+}
-#endif
+device->hidden->pAvailableFSLibVideoModes = FSLib_GetVideoModeList();
-SDL_SetError("Could not create PM thread");
-return -1;
+return device;
-}
-#ifdef USE_DOSSETPRIORITY
-// Burst the priority of PM Thread!
-DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, _this->hidden->tidPMThread);
-#endif
-// Wait for the PM thread to initialize!
-while (_this->hidden->iPMThreadStatus==0)
-DosSleep(32);
-// If the PM thread could not set up everything, then
-// report an error!
-if (_this->hidden->iPMThreadStatus!=1)
-{
-#ifdef DEBUG_BUILD
-printf("[os2fslib_VideoInit] : PMThread reported an error : %d\n", _this->hidden->iPMThreadStatus);
-#endif
-SDL_SetError("Error initializing PM thread");
-return -1;
-}
-return 0;
-}
-static void os2fslib_DeleteDevice(_THIS)
-{
-#ifdef DEBUG_BUILD
-printf("[os2fslib_DeleteDevice]\n"); fflush(stdout);
-#endif
-// Free used memory
-FSLib_FreeVideoModeList(_this->hidden->pAvailableFSLibVideoModes);
-if (_this->hidden->pListModesResult)
-SDL_free(_this->hidden->pListModesResult);
-if (_this->hidden->pchSrcBuffer)
-SDL_free(_this->hidden->pchSrcBuffer);
-DosCloseMutexSem(_this->hidden->hmtxUseSrcBuffer);
-SDL_free(_this->hidden);
-SDL_free(_this);
-FSLib_Uninitialize();
-}
-static int os2fslib_Available(void)
-{
-// If we can run, it means that we could load FSLib,
-// so we assume that it's available then!
-return 1;
-}
-static void os2fslib_MorphToPM()
-{
-PPIB pib;
-PTIB tib;
-DosGetInfoBlocks(&tib, &pib);
-// Change flag from VIO to PM:
-if (pib->pib_ultype==2) pib->pib_ultype = 3;
-}
-static SDL_VideoDevice *os2fslib_CreateDevice(int devindex)
-{
-SDL_VideoDevice *device;
-#ifdef DEBUG_BUILD
-printf("[os2fslib_CreateDevice] : Enter\n"); fflush(stdout);
-#endif
-/* Initialize all variables that we clean on shutdown */
-device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
-if ( device )
-{
-SDL_memset(device, 0, (sizeof *device));
-// Also allocate memory for private data
-device->hidden = (struct SDL_PrivateVideoData *) SDL_malloc((sizeof(struct SDL_PrivateVideoData)));
-}
-if ( (device == NULL) || (device->hidden == NULL) )
-{
-SDL_OutOfMemory();
-if ( device )
-SDL_free(device);
-return NULL;
-}
-SDL_memset(device->hidden, 0, (sizeof *device->hidden));
-/* Set the function pointers */
-#ifdef DEBUG_BUILD
-printf("[os2fslib_CreateDevice] : VideoInit is %p\n", os2fslib_VideoInit); fflush(stdout);
-#endif
-/* Initialization/Query functions */
-device->VideoInit = os2fslib_VideoInit;
-device->ListModes = os2fslib_ListModes;
-device->SetVideoMode = os2fslib_SetVideoMode;
-device->ToggleFullScreen = os2fslib_ToggleFullScreen;
-device->UpdateMouse = os2fslib_UpdateMouse;
-device->CreateYUVOverlay = NULL;
-device->SetColors = os2fslib_SetColors;
-device->UpdateRects = os2fslib_UpdateRects;
-device->VideoQuit = os2fslib_VideoQuit;
-/* Hardware acceleration functions */
-device->AllocHWSurface = os2fslib_AllocHWSurface;
-device->CheckHWBlit = NULL;
-device->FillHWRect = NULL;
-device->SetHWColorKey = NULL;
-device->SetHWAlpha = NULL;
-device->LockHWSurface = os2fslib_LockHWSurface;
-device->UnlockHWSurface = os2fslib_UnlockHWSurface;
-device->FlipHWSurface = NULL;
-device->FreeHWSurface = os2fslib_FreeHWSurface;
-/* Window manager functions */
-device->SetCaption = os2fslib_SetCaption;
-device->SetIcon = os2fslib_SetIcon;
-device->IconifyWindow = os2fslib_IconifyWindow;
-device->GrabInput = os2fslib_GrabInput;
-device->GetWMInfo = NULL;
-/* Cursor manager functions to Windowed mode*/
-os2fslib_SetCursorManagementFunctions(device, 1);
-/* Event manager functions */
-device->InitOSKeymap = os2fslib_InitOSKeymap;
-device->PumpEvents = os2fslib_PumpEvents;
-/* The function used to dispose of this structure */
-device->free = os2fslib_DeleteDevice;
-// Make sure we'll be able to use Win* API even if the application
-// was linked to be a VIO application!
-os2fslib_MorphToPM();
-// Now initialize FSLib, and query available video modes!
-if (!FSLib_Initialize())
-{
-// Could not initialize FSLib!
-#ifdef DEBUG_BUILD
-printf("[os2fslib_CreateDevice] : Could not initialize FSLib!\n");
-#endif
-SDL_SetError("Could not initialize FSLib!");
-SDL_free(device->hidden);
-SDL_free(device);
-return NULL;
-}
-device->hidden->pAvailableFSLibVideoModes =
-FSLib_GetVideoModeList();
-return device;
 }
 VideoBootStrap OS2FSLib_bootstrap = {
 "os2fslib", "OS/2 Video Output using FSLib",
 os2fslib_Available, os2fslib_CreateDevice
 };
+/* vi: set ts=4 sw=4 expandtab: */

Mercurial > sdl-ios-xcode

comparison src/video/os2fslib/SDL_os2fslib.c @ 1895:c121d94672cb