kc3-lang/SDL/src/video/os2/SDL_os2video.c

Branch - branch -v2.28

• Show log

  Commit

• Hash : 0479df53
  Author :
  Date : 2023-01-09T09:48:21
  

  Updated copyright for 2023

Download

• src/video/os2/SDL_os2video.c

• /*
    Simple DirectMedia Layer
    Copyright (C) 1997-2023 Sam Lantinga <slouken@libsdl.org>
  
    This software is provided 'as-is', without any express or implied
    warranty.  In no event will the authors be held liable for any damages
    arising from the use of this software.
  
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
  
    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software. If you use this software
       in a product, an acknowledgment in the product documentation would be
       appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
  */
  
  #include "../../SDL_internal.h"
  
  #if SDL_VIDEO_DRIVER_OS2
  
  #include "SDL_video.h"
  #include "SDL_mouse.h"
  #include "../SDL_pixels_c.h"
  #include "../SDL_shape_internals.h"
  #include "../../events/SDL_events_c.h"
  #include "SDL_os2video.h"
  #include "SDL_syswm.h"
  #include "SDL_os2util.h"
  
  #define __MEERROR_H__
  #define  _MEERROR_H_
  #include <mmioos2.h>
  #include <fourcc.h>
  #ifndef FOURCC_R666
  #define FOURCC_R666 mmioFOURCC('R','6','6','6')
  #endif
  
  #define WIN_CLIENT_CLASS        "SDL2"
  #define OS2DRIVER_NAME_DIVE     "DIVE"
  #define OS2DRIVER_NAME_VMAN     "VMAN"
  
  
  static const SDL_Scancode aSDLScancode[] = {
           /*   0                       1                           2                           3                           4                        5                                                       6                           7 */
           /*   8                       9                           A                           B                           C                        D                                                       E                           F */
           SDL_SCANCODE_UNKNOWN,        SDL_SCANCODE_ESCAPE,        SDL_SCANCODE_1,             SDL_SCANCODE_2,             SDL_SCANCODE_3,          SDL_SCANCODE_4,             SDL_SCANCODE_5,             SDL_SCANCODE_6,          /* 0 */
           SDL_SCANCODE_7,              SDL_SCANCODE_8,             SDL_SCANCODE_9,             SDL_SCANCODE_0,             SDL_SCANCODE_MINUS,      SDL_SCANCODE_EQUALS,        SDL_SCANCODE_BACKSPACE,     SDL_SCANCODE_TAB,        /* 0 */
  
           SDL_SCANCODE_Q,              SDL_SCANCODE_W,             SDL_SCANCODE_E,             SDL_SCANCODE_R,             SDL_SCANCODE_T,          SDL_SCANCODE_Y,             SDL_SCANCODE_U,             SDL_SCANCODE_I,          /* 1 */
           SDL_SCANCODE_O,              SDL_SCANCODE_P,             SDL_SCANCODE_LEFTBRACKET,   SDL_SCANCODE_RIGHTBRACKET,  SDL_SCANCODE_RETURN,     SDL_SCANCODE_LCTRL,         SDL_SCANCODE_A,             SDL_SCANCODE_S,          /* 1 */
  
           SDL_SCANCODE_D,              SDL_SCANCODE_F,             SDL_SCANCODE_G,             SDL_SCANCODE_H,             SDL_SCANCODE_J,          SDL_SCANCODE_K,             SDL_SCANCODE_L,             SDL_SCANCODE_SEMICOLON,  /* 2 */
           SDL_SCANCODE_APOSTROPHE,     SDL_SCANCODE_GRAVE,         SDL_SCANCODE_LSHIFT,        SDL_SCANCODE_BACKSLASH,     SDL_SCANCODE_Z,          SDL_SCANCODE_X,             SDL_SCANCODE_C,             SDL_SCANCODE_V,          /* 2 */
  
           SDL_SCANCODE_B,              SDL_SCANCODE_N,             SDL_SCANCODE_M,             SDL_SCANCODE_COMMA,         SDL_SCANCODE_PERIOD,     SDL_SCANCODE_SLASH,         SDL_SCANCODE_RSHIFT,  /*55*/SDL_SCANCODE_KP_MULTIPLY,/* 3 */
           SDL_SCANCODE_LALT,           SDL_SCANCODE_SPACE,         SDL_SCANCODE_CAPSLOCK,      SDL_SCANCODE_F1,            SDL_SCANCODE_F2,         SDL_SCANCODE_F3,            SDL_SCANCODE_F4,            SDL_SCANCODE_F5,         /* 3 */
  
           SDL_SCANCODE_F6,             SDL_SCANCODE_F7,            SDL_SCANCODE_F8,            SDL_SCANCODE_F9,            SDL_SCANCODE_F10,        SDL_SCANCODE_NUMLOCKCLEAR,  SDL_SCANCODE_SCROLLLOCK,    SDL_SCANCODE_KP_7,       /* 4 */
   /*72*/  SDL_SCANCODE_KP_8,     /*73*/SDL_SCANCODE_KP_9,          SDL_SCANCODE_KP_MINUS,/*75*/SDL_SCANCODE_KP_4,    /*76*/SDL_SCANCODE_KP_5, /*77*/SDL_SCANCODE_KP_6,    /*78*/SDL_SCANCODE_KP_PLUS, /*79*/SDL_SCANCODE_KP_1,       /* 4 */
  
   /*80*/  SDL_SCANCODE_KP_2,     /*81*/SDL_SCANCODE_KP_3,          SDL_SCANCODE_KP_0,    /*83*/SDL_SCANCODE_KP_PERIOD,     SDL_SCANCODE_UNKNOWN,    SDL_SCANCODE_UNKNOWN,       SDL_SCANCODE_NONUSBACKSLASH,SDL_SCANCODE_F11,        /* 5 */
   /*88*/  SDL_SCANCODE_F12,      /*89*/SDL_SCANCODE_PAUSE,   /*90*/SDL_SCANCODE_KP_ENTER,/*91*/SDL_SCANCODE_RCTRL,   /*92*/SDL_SCANCODE_KP_DIVIDE,  SDL_SCANCODE_APPLICATION,   SDL_SCANCODE_RALT,    /*95*/SDL_SCANCODE_UNKNOWN,    /* 5 */
  
   /*96*/  SDL_SCANCODE_HOME,     /*97*/SDL_SCANCODE_UP,      /*98*/SDL_SCANCODE_PAGEUP,        SDL_SCANCODE_LEFT,   /*100*/SDL_SCANCODE_RIGHT,      SDL_SCANCODE_END,    /*102*/SDL_SCANCODE_DOWN,   /*103*/SDL_SCANCODE_PAGEDOWN,   /* 6 */
  /*104*/  SDL_SCANCODE_F17,     /*105*/SDL_SCANCODE_DELETE,        SDL_SCANCODE_F19,           SDL_SCANCODE_UNKNOWN,       SDL_SCANCODE_UNKNOWN,    SDL_SCANCODE_UNKNOWN,/*110*/SDL_SCANCODE_UNKNOWN,/*111*/SDL_SCANCODE_UNKNOWN,    /* 6 */
  
  /*112*/  SDL_SCANCODE_INTERNATIONAL2, SDL_SCANCODE_UNKNOWN,       SDL_SCANCODE_UNKNOWN,       SDL_SCANCODE_INTERNATIONAL1,SDL_SCANCODE_UNKNOWN,    SDL_SCANCODE_UNKNOWN,       SDL_SCANCODE_UNKNOWN,       SDL_SCANCODE_UNKNOWN,    /* 7 */
  /*120*/  SDL_SCANCODE_UNKNOWN,        SDL_SCANCODE_INTERNATIONAL4,SDL_SCANCODE_UNKNOWN,       SDL_SCANCODE_INTERNATIONAL5,SDL_SCANCODE_APPLICATION,SDL_SCANCODE_INTERNATIONAL3,SDL_SCANCODE_LGUI,          SDL_SCANCODE_RGUI        /* 7 */
  };
  
  /*  Utilites.
   *  ---------
   */
  static BOOL _getSDLPixelFormatData(SDL_PixelFormat *pSDLPixelFormat,
                                     ULONG ulBPP, ULONG fccColorEncoding)
  {
      ULONG   ulRshift, ulGshift, ulBshift;
      ULONG   ulRmask, ulGmask, ulBmask;
      ULONG   ulRloss, ulGloss, ulBloss;
  
      pSDLPixelFormat->BitsPerPixel = ulBPP;
      pSDLPixelFormat->BytesPerPixel = (pSDLPixelFormat->BitsPerPixel + 7) / 8;
  
      switch (fccColorEncoding) {
      case FOURCC_LUT8:
          ulRshift = 0; ulGshift = 0; ulBshift = 0;
          ulRmask = 0; ulGmask = 0; ulBmask = 0;
          ulRloss = 8; ulGloss = 8; ulBloss = 8;
          break;
  
      case FOURCC_R555:
          ulRshift = 10; ulGshift = 5; ulBshift = 0;
          ulRmask = 0x7C00; ulGmask = 0x03E0; ulBmask = 0x001F;
          ulRloss = 3; ulGloss = 3; ulBloss = 3;
          break;
  
      case FOURCC_R565:
          ulRshift = 11; ulGshift = 5; ulBshift = 0;
          ulRmask = 0xF800; ulGmask = 0x07E0; ulBmask = 0x001F;
          ulRloss = 3; ulGloss = 2; ulBloss = 3;
          break;
  
      case FOURCC_R664:
          ulRshift = 10; ulGshift = 4; ulBshift = 0;
          ulRmask = 0xFC00; ulGmask = 0x03F0; ulBmask = 0x000F;
          ulRloss = 2; ulGloss = 4; ulBloss = 3;
          break;
  
      case FOURCC_R666:
          ulRshift = 12; ulGshift = 6; ulBshift = 0;
          ulRmask = 0x03F000; ulGmask = 0x000FC0; ulBmask = 0x00003F;
          ulRloss = 2; ulGloss = 2; ulBloss = 2;
          break;
  
      case FOURCC_RGB3:
      case FOURCC_RGB4:
          ulRshift = 0; ulGshift = 8; ulBshift = 16;
          ulRmask = 0x0000FF; ulGmask = 0x00FF00; ulBmask = 0xFF0000;
          ulRloss = 0x00; ulGloss = 0x00; ulBloss = 0x00;
          break;
  
      case FOURCC_BGR3:
      case FOURCC_BGR4:
          ulRshift = 16; ulGshift = 8; ulBshift = 0;
          ulRmask = 0xFF0000; ulGmask = 0x00FF00; ulBmask = 0x0000FF;
          ulRloss = 0; ulGloss = 0; ulBloss = 0;
          break;
  
      default:
  /*      printf("Unknown color encoding: %.4s\n", fccColorEncoding);*/
          SDL_memset(pSDLPixelFormat, 0, sizeof(SDL_PixelFormat));
          return FALSE;
      }
  
      pSDLPixelFormat->Rshift = ulRshift;
      pSDLPixelFormat->Gshift = ulGshift;
      pSDLPixelFormat->Bshift = ulBshift;
      pSDLPixelFormat->Rmask  = ulRmask;
      pSDLPixelFormat->Gmask  = ulGmask;
      pSDLPixelFormat->Bmask  = ulBmask;
      pSDLPixelFormat->Rloss  = ulRloss;
      pSDLPixelFormat->Gloss  = ulGloss;
      pSDLPixelFormat->Bloss  = ulBloss;
  
      pSDLPixelFormat->Ashift = 0x00;
      pSDLPixelFormat->Amask  = 0x00;
      pSDLPixelFormat->Aloss  = 0x00;
  
      return TRUE;
  }
  
  static Uint32 _getSDLPixelFormat(ULONG ulBPP, FOURCC fccColorEncoding)
  {
      SDL_PixelFormat stSDLPixelFormat;
      Uint32          uiResult = SDL_PIXELFORMAT_UNKNOWN;
  
      if (_getSDLPixelFormatData(&stSDLPixelFormat, ulBPP, fccColorEncoding))
          uiResult = SDL_MasksToPixelFormatEnum(ulBPP, stSDLPixelFormat.Rmask,
                                                stSDLPixelFormat.Gmask,
                                                stSDLPixelFormat.Bmask, 0);
  
      return uiResult;
  }
  
  static SDL_DisplayMode *_getDisplayModeForSDLWindow(SDL_Window *window)
  {
      SDL_VideoDisplay *pSDLDisplay = SDL_GetDisplayForWindow(window);
  
      if (pSDLDisplay == NULL) {
          debug_os2("No display for the window");
          return FALSE;
      }
  
      return &pSDLDisplay->current_mode;
  }
  
  static VOID _mouseCheck(WINDATA *pWinData)
  {
      SDL_Mouse *pSDLMouse = SDL_GetMouse();
  
      if ((pSDLMouse->relative_mode || (pWinData->window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0) &&
          ((pWinData->window->flags & SDL_WINDOW_INPUT_FOCUS) != 0)) {
          /* We will make a real capture in _wmMouseButton() */
      } else {
          WinSetCapture(HWND_DESKTOP, NULLHANDLE);
      }
  }
  
  
  /*  PM window procedure.
   *  --------------------
   */
  static int OS2_ResizeWindowShape(SDL_Window *window);
  
  static VOID _setVisibleRegion(WINDATA *pWinData, BOOL fVisible)
  {
      SDL_VideoDisplay *pSDLDisplay;
  
      if (! pWinData->pVOData)
          return;
  
       pSDLDisplay = (fVisible)? SDL_GetDisplayForWindow(pWinData->window) : NULL;
       pWinData->pOutput->SetVisibleRegion(pWinData->pVOData, pWinData->hwnd,
                                           (pSDLDisplay == NULL) ?
                                              NULL : &pSDLDisplay->current_mode,
                                           pWinData->hrgnShape, fVisible);
  }
  
  static VOID _wmPaint(WINDATA *pWinData, HWND hwnd)
  {
      if (pWinData->pVOData == NULL ||
          !pWinData->pOutput->Update(pWinData->pVOData, hwnd, NULL, 0)) {
          RECTL   rectl;
          HPS     hps;
  
          hps = WinBeginPaint(hwnd, 0, &rectl);
          WinFillRect(hps, &rectl, CLR_BLACK);
          WinEndPaint(hps);
      }
  }
  
  static VOID _wmMouseMove(WINDATA *pWinData, SHORT lX, SHORT lY)
  {
      SDL_Mouse *pSDLMouse = SDL_GetMouse();
      POINTL  pointl;
      BOOL    fWinActive = (pWinData->window->flags & SDL_WINDOW_INPUT_FOCUS) != 0;
  
      if (!pSDLMouse->relative_mode || pSDLMouse->relative_mode_warp) {
          if (!pSDLMouse->relative_mode && fWinActive &&
              ((pWinData->window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0) &&
              (WinQueryCapture(HWND_DESKTOP) == pWinData->hwnd)) {
  
              pointl.x = lX;
              pointl.y = lY;
  
              if (lX < 0)
                  lX = 0;
              else if (lX >= pWinData->window->w)
                  lX = pWinData->window->w - 1;
  
              if (lY < 0)
                  lY = 0;
              else if (lY >= pWinData->window->h)
                  lY = pWinData->window->h - 1;
  
              if (lX != pointl.x || lY != pointl.x) {
                  pointl.x = lX;
                  pointl.y = lY;
                  WinMapWindowPoints(pWinData->hwnd, HWND_DESKTOP, &pointl, 1);
                  pWinData->lSkipWMMouseMove++;
                  WinSetPointerPos(HWND_DESKTOP, pointl.x, pointl.y);
              }
          }
  
          SDL_SendMouseMotion(pWinData->window, 0, 0, lX,
                              pWinData->window->h - lY - 1);
          return;
      }
  
      if (fWinActive) {
          pointl.x = pWinData->window->w / 2;
          pointl.y = pWinData->window->h / 2;
          WinMapWindowPoints(pWinData->hwnd, HWND_DESKTOP, &pointl, 1);
  
          SDL_SendMouseMotion(pWinData->window, 0, 1,
                              lX - pointl.x, pointl.y - lY);
  
          pWinData->lSkipWMMouseMove++;
          WinSetPointerPos(HWND_DESKTOP, pointl.x, pointl.y);
      }
  }
  
  static VOID _wmMouseButton(WINDATA *pWinData, ULONG ulButton, BOOL fDown)
  {
      static ULONG  aBtnGROP2SDL[3] = { SDL_BUTTON_LEFT, SDL_BUTTON_RIGHT,
                                        SDL_BUTTON_MIDDLE };
      SDL_Mouse *pSDLMouse = SDL_GetMouse();
  
      if ((pSDLMouse->relative_mode || ((pWinData->window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0)) &&
          ((pWinData->window->flags & SDL_WINDOW_INPUT_FOCUS) != 0) &&
          (WinQueryCapture(HWND_DESKTOP) != pWinData->hwnd)) {
          /* Mouse should be captured. */
          if (pSDLMouse->relative_mode && !pSDLMouse->relative_mode_warp) {
              POINTL  pointl;
  
              pointl.x = pWinData->window->w / 2;
              pointl.y = pWinData->window->h / 2;
              WinMapWindowPoints(pWinData->hwnd, HWND_DESKTOP, &pointl, 1);
              pWinData->lSkipWMMouseMove++;
              WinSetPointerPos(HWND_DESKTOP, pointl.x, pointl.y);
          }
  
          WinSetCapture(HWND_DESKTOP, pWinData->hwnd);
      }
  
      SDL_SendMouseButton(pWinData->window, 0,
                          (fDown)? SDL_PRESSED : SDL_RELEASED,
                          aBtnGROP2SDL[ulButton]);
  }
  
  static VOID _wmChar(WINDATA *pWinData, MPARAM mp1, MPARAM mp2)
  {
      ULONG   ulFlags = SHORT1FROMMP(mp1);      /* WM_CHAR flags         */
      ULONG   ulVirtualKey = SHORT2FROMMP(mp2); /* Virtual key code VK_* */
      ULONG   ulCharCode = SHORT1FROMMP(mp2);   /* Character code        */
      ULONG   ulScanCode = CHAR4FROMMP(mp1);    /* Scan code             */
  
      if (((ulFlags & (KC_VIRTUALKEY | KC_KEYUP | KC_ALT)) == (KC_VIRTUALKEY | KC_ALT)) &&
          (ulVirtualKey == VK_F4)) {
          SDL_SendWindowEvent(pWinData->window, SDL_WINDOWEVENT_CLOSE, 0, 0);
      }
  
      if ((ulFlags & KC_SCANCODE) != 0) {
          SDL_SendKeyboardKey(((ulFlags & KC_KEYUP) == 0)? SDL_PRESSED : SDL_RELEASED, aSDLScancode[ulScanCode]);
      }
  
      if ((ulFlags & KC_CHAR) != 0) {
  #if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
          char *utf8 = SDL_iconv_string("UTF-8", "", (char *)&ulCharCode, 1);
          SDL_SendKeyboardText((utf8 && *utf8) ? utf8 : (char *)&ulCharCode);
          SDL_free(utf8);
  #else
          char utf8[4];
          int rc = StrUTF8(1, utf8, sizeof(utf8), (char *)&ulCharCode, 1);
          SDL_SendKeyboardText((rc > 0) ? utf8 : (char *) &ulCharCode);
  #endif
      }
  }
  
  static VOID _wmMove(WINDATA *pWinData)
  {
      SDL_DisplayMode *pSDLDisplayMode = _getDisplayModeForSDLWindow(pWinData->window);
      POINTL  pointl = { 0,0 };
      RECTL   rectl;
  
      WinQueryWindowRect(pWinData->hwnd, &rectl);
      WinMapWindowPoints(pWinData->hwnd, HWND_DESKTOP, (PPOINTL)&rectl, 2);
  
      WinMapWindowPoints(pWinData->hwnd, HWND_DESKTOP, &pointl, 1);
      SDL_SendWindowEvent(pWinData->window, SDL_WINDOWEVENT_MOVED, rectl.xLeft,
                         pSDLDisplayMode->h - rectl.yTop);
  }
  
  static MRESULT _wmDragOver(WINDATA *pWinData, PDRAGINFO pDragInfo)
  {
      ULONG       ulIdx;
      PDRAGITEM   pDragItem;
      USHORT      usDrag   = DOR_NEVERDROP;
      USHORT      usDragOp = DO_UNKNOWN;
  
      if (!DrgAccessDraginfo(pDragInfo))
          return MRFROM2SHORT(DOR_NEVERDROP, DO_UNKNOWN);
  
      for (ulIdx = 0; ulIdx < pDragInfo->cditem; ulIdx++) {
          pDragItem = DrgQueryDragitemPtr(pDragInfo, ulIdx);
  
          /* We accept WPS files only. */
          if (!DrgVerifyRMF(pDragItem, "DRM_OS2FILE", NULL)) {
              usDrag   = DOR_NEVERDROP;
              usDragOp = DO_UNKNOWN;
              break;
          }
  
          if (pDragInfo->usOperation == DO_DEFAULT &&
              (pDragItem->fsSupportedOps & DO_COPYABLE) != 0) {
              usDrag   = DOR_DROP;
              usDragOp = DO_COPY;
          } else
          if (pDragInfo->usOperation == DO_LINK &&
              (pDragItem->fsSupportedOps & DO_LINKABLE) != 0) {
              usDrag   = DOR_DROP;
              usDragOp = DO_LINK;
          } else {
              usDrag   = DOR_NODROPOP;
              usDragOp = DO_UNKNOWN;
              break;
          }
      }
  
      /* Update window (The DIVE surface spoiled while dragging) */
      WinInvalidateRect(pWinData->hwnd, NULL, FALSE);
      WinUpdateWindow(pWinData->hwnd);
  
      DrgFreeDraginfo(pDragInfo);
      return MPFROM2SHORT(usDrag, usDragOp);
  }
  
  static MRESULT _wmDrop(WINDATA *pWinData, PDRAGINFO pDragInfo)
  {
      ULONG       ulIdx;
      PDRAGITEM   pDragItem;
      CHAR        acFName[CCHMAXPATH];
      PCHAR       pcFName;
  
      if (!DrgAccessDraginfo(pDragInfo))
          return MRFROM2SHORT(DOR_NEVERDROP, 0);
  
      for (ulIdx = 0; ulIdx < pDragInfo->cditem; ulIdx++) {
          pDragItem = DrgQueryDragitemPtr(pDragInfo, ulIdx);
  
          if (DrgVerifyRMF(pDragItem, "DRM_OS2FILE", NULL) &&
              pDragItem->hstrContainerName != NULLHANDLE &&
              pDragItem->hstrSourceName != NULLHANDLE) {
              /* Get file name from the item. */
              DrgQueryStrName(pDragItem->hstrContainerName, sizeof(acFName), acFName);
              pcFName = SDL_strchr(acFName, '\0');
              DrgQueryStrName(pDragItem->hstrSourceName,
                              sizeof(acFName) - (pcFName - acFName), pcFName);
  
              /* Send to SDL full file name converted to UTF-8. */
              pcFName = OS2_SysToUTF8(acFName);
              SDL_SendDropFile(pWinData->window, pcFName);
              SDL_free(pcFName);
  
              /* Notify a source that a drag operation is complete. */
              if (pDragItem->hwndItem)
                  DrgSendTransferMsg(pDragItem->hwndItem, DM_ENDCONVERSATION,
                                     (MPARAM)pDragItem->ulItemID,
                                     (MPARAM)DMFL_TARGETSUCCESSFUL);
          }
      }
  
      DrgDeleteDraginfoStrHandles(pDragInfo);
      DrgFreeDraginfo(pDragInfo);
  
      SDL_SendDropComplete(pWinData->window);
  
      return (MRESULT)FALSE;
  }
  
  static MRESULT EXPENTRY wndFrameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  {
      HWND    hwndClient = WinQueryWindow(hwnd, QW_BOTTOM);
      WINDATA * pWinData = (WINDATA *)WinQueryWindowULong(hwndClient, 0);
  
      if (pWinData == NULL)
          return WinDefWindowProc(hwnd, msg, mp1, mp2);
  
      /* Send a SDL_SYSWMEVENT if the application wants them */
      if (SDL_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) {
          SDL_SysWMmsg wmmsg;
  
          SDL_VERSION(&wmmsg.version);
          wmmsg.subsystem = SDL_SYSWM_OS2;
          wmmsg.msg.os2.fFrame = TRUE;
          wmmsg.msg.os2.hwnd = hwnd;
          wmmsg.msg.os2.msg = msg;
          wmmsg.msg.os2.mp1 = mp1;
          wmmsg.msg.os2.mp2 = mp2;
          SDL_SendSysWMEvent(&wmmsg);
      }
  
      switch (msg) {
      case WM_MINMAXFRAME:
          if ((((PSWP)mp1)->fl & SWP_RESTORE) != 0) {
              pWinData->lSkipWMMove += 2;
              SDL_SendWindowEvent(pWinData->window, SDL_WINDOWEVENT_RESTORED, 0, 0);
          }
          if ((((PSWP)mp1)->fl & SWP_MINIMIZE) != 0) {
              pWinData->lSkipWMSize++;
              pWinData->lSkipWMMove += 2;
              SDL_SendWindowEvent(pWinData->window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
          }
          if ((((PSWP)mp1)->fl & SWP_MAXIMIZE) != 0) {
              SDL_SendWindowEvent(pWinData->window, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
          }
          break;
  
      case WM_ADJUSTFRAMEPOS:
          if (pWinData->lSkipWMAdjustFramePos > 0) {
              pWinData->lSkipWMAdjustFramePos++;
              break;
          }
          if ((pWinData->window->flags & SDL_WINDOW_FULLSCREEN) != 0 &&
              (((PSWP)mp1)->fl & SWP_RESTORE) != 0) {
              /* Keep fullscreen window size on restore. */
              RECTL rectl;
  
              rectl.xLeft = 0;
              rectl.yBottom = 0;
              rectl.xRight = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
              rectl.yTop = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
              WinCalcFrameRect(hwnd, &rectl, FALSE);
              ((PSWP)mp1)->x = rectl.xLeft;
              ((PSWP)mp1)->y = rectl.yBottom;
              ((PSWP)mp1)->cx = rectl.xRight - rectl.xLeft;
              ((PSWP)mp1)->cy = rectl.yTop - rectl.yBottom;
          }
          if ((((PSWP)mp1)->fl & (SWP_SIZE | SWP_MINIMIZE)) == SWP_SIZE) {
              if ((pWinData->window->flags & SDL_WINDOW_FULLSCREEN) != 0) {
                  /* SDL_WINDOW_FULLSCREEN_DESKTOP have flag SDL_WINDOW_FULLSCREEN... */
                  if (SDL_IsShapedWindow(pWinData->window))
                      OS2_ResizeWindowShape(pWinData->window);
                  break;
              }
              if ((SDL_GetWindowFlags(pWinData->window) & SDL_WINDOW_RESIZABLE) != 0) {
                  RECTL   rectl;
                  int     iMinW, iMinH, iMaxW, iMaxH;
                  int     iWinW, iWinH;
  
                  rectl.xLeft = 0;
                  rectl.yBottom = 0;
                  SDL_GetWindowSize(pWinData->window,
                                    (int *)&rectl.xRight, (int *)&rectl.yTop);
                  iWinW = rectl.xRight;
                  iWinH = rectl.yTop;
  
                  SDL_GetWindowMinimumSize(pWinData->window, &iMinW, &iMinH);
                  SDL_GetWindowMaximumSize(pWinData->window, &iMaxW, &iMaxH);
  
                  if (iWinW < iMinW)
                      rectl.xRight = iMinW;
                  else if (iMaxW != 0 && iWinW > iMaxW)
                      rectl.xRight = iMaxW;
  
                  if (iWinH < iMinH)
                      rectl.yTop = iMinW;
                  else if (iMaxH != 0 && iWinH > iMaxH)
                      rectl.yTop = iMaxH;
  
                  if (rectl.xRight == iWinW && rectl.yTop == iWinH) {
                      if (SDL_IsShapedWindow(pWinData->window))
                          OS2_ResizeWindowShape(pWinData->window);
                      break;
                  }
  
                  WinCalcFrameRect(hwnd, &rectl, FALSE);
                  ((PSWP)mp1)->cx = rectl.xRight - rectl.xLeft;
                  ((PSWP)mp1)->cy = rectl.yTop - rectl.yBottom;
              }
          }
          break;
      }
  
      return pWinData->fnWndFrameProc(hwnd, msg, mp1, mp2);
  }
  
  static MRESULT EXPENTRY wndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  {
      WINDATA *pWinData = (WINDATA *)WinQueryWindowULong(hwnd, 0);
  
      if (pWinData == NULL)
          return WinDefWindowProc(hwnd, msg, mp1, mp2);
  
      /* Send a SDL_SYSWMEVENT if the application wants them */
      if (SDL_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) {
          SDL_SysWMmsg wmmsg;
  
          SDL_VERSION(&wmmsg.version);
          wmmsg.subsystem = SDL_SYSWM_OS2;
          wmmsg.msg.os2.fFrame = FALSE;
          wmmsg.msg.os2.hwnd = hwnd;
          wmmsg.msg.os2.msg = msg;
          wmmsg.msg.os2.mp1 = mp1;
          wmmsg.msg.os2.mp2 = mp2;
          SDL_SendSysWMEvent(&wmmsg);
      }
  
      switch (msg) {
      case WM_CLOSE:
      case WM_QUIT:
          SDL_SendWindowEvent(pWinData->window, SDL_WINDOWEVENT_CLOSE, 0, 0);
          if (pWinData->fnUserWndProc == NULL)
              return (MRESULT)FALSE;
          break;
  
      case WM_PAINT:
          _wmPaint(pWinData, hwnd);
          break;
  
      case WM_SHOW:
          SDL_SendWindowEvent(pWinData->window, (SHORT1FROMMP(mp1) == 0)?
                                                 SDL_WINDOWEVENT_HIDDEN :
                                                 SDL_WINDOWEVENT_SHOWN   ,
                              0, 0);
          break;
  
      case WM_UPDATEFRAME:
          /* Return TRUE - no further action for the frame control window procedure */
          return (MRESULT)TRUE;
  
      case WM_ACTIVATE:
          if ((BOOL)mp1) {
              POINTL  pointl;
  
              if (SDL_GetKeyboardFocus() != pWinData->window)
                  SDL_SetKeyboardFocus(pWinData->window);
  
              WinQueryPointerPos(HWND_DESKTOP, &pointl);
              WinMapWindowPoints(HWND_DESKTOP, pWinData->hwnd, &pointl, 1);
              SDL_SendMouseMotion(pWinData->window, 0, 0,
                                  pointl.x, pWinData->window->h - pointl.y - 1);
          } else {
              if (SDL_GetKeyboardFocus() == pWinData->window)
                  SDL_SetKeyboardFocus(NULL);
  
              WinSetCapture(HWND_DESKTOP,  NULLHANDLE);
          }
          break;
  
      case WM_MOUSEMOVE:
          WinSetPointer(HWND_DESKTOP, hptrCursor);
  
          if (pWinData->lSkipWMMouseMove > 0)
              pWinData->lSkipWMMouseMove--;
          else {
              _wmMouseMove(pWinData, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1));
          }
          return (MRESULT)FALSE;
  
      case WM_BUTTON1DOWN:
      case WM_BUTTON1DBLCLK:
          _wmMouseButton(pWinData, 0, TRUE);
          break;
  
      case WM_BUTTON1UP:
          _wmMouseButton(pWinData, 0, FALSE);
          break;
  
      case WM_BUTTON2DOWN:
      case WM_BUTTON2DBLCLK:
          _wmMouseButton(pWinData, 1, TRUE);
          break;
  
      case WM_BUTTON2UP:
          _wmMouseButton(pWinData, 1, FALSE);
          break;
  
      case WM_BUTTON3DOWN:
      case WM_BUTTON3DBLCLK:
          _wmMouseButton(pWinData, 2, TRUE);
          break;
  
      case WM_BUTTON3UP:
          _wmMouseButton(pWinData, 2, FALSE);
          break;
  
      case WM_TRANSLATEACCEL:
          /* ALT and acceleration keys not allowed (must be processed in WM_CHAR) */
          if (mp1 == NULL || ((PQMSG)mp1)->msg != WM_CHAR)
              break;
          return (MRESULT)FALSE;
  
      case WM_CHAR:
          _wmChar(pWinData, mp1, mp2);
          break;
  
      case WM_SIZE:
          if (pWinData->lSkipWMSize > 0)
              pWinData->lSkipWMSize--;
          else {
              if ((pWinData->window->flags & SDL_WINDOW_FULLSCREEN) == 0) {
                  SDL_SendWindowEvent(pWinData->window, SDL_WINDOWEVENT_RESIZED,
                                      SHORT1FROMMP(mp2), SHORT2FROMMP(mp2));
              } else {
                  pWinData->lSkipWMVRNEnabled++;
              }
          }
          break;
  
      case WM_MOVE:
          if (pWinData->lSkipWMMove > 0)
              pWinData->lSkipWMMove--;
          else if ((pWinData->window->flags & SDL_WINDOW_FULLSCREEN) == 0) {
              _wmMove(pWinData);
          }
          break;
  
      case WM_VRNENABLED:
          if (pWinData->lSkipWMVRNEnabled > 0)
              pWinData->lSkipWMVRNEnabled--;
          else {
              _setVisibleRegion(pWinData, TRUE);
          }
          return (MRESULT)TRUE;
  
      case WM_VRNDISABLED:
          _setVisibleRegion(pWinData, FALSE);
          return (MRESULT)TRUE;
  
      case DM_DRAGOVER:
          return _wmDragOver(pWinData, (PDRAGINFO)PVOIDFROMMP(mp1));
  
      case DM_DROP:
          return _wmDrop(pWinData, (PDRAGINFO)PVOIDFROMMP(mp1));
      }
  
      return (pWinData->fnUserWndProc != NULL)?
              pWinData->fnUserWndProc(hwnd, msg, mp1, mp2) :
              WinDefWindowProc(hwnd, msg, mp1, mp2);
  }
  
  
  /*  SDL routines.
   *  ------------
   */
  
  static void OS2_PumpEvents(_THIS)
  {
      SDL_VideoData *pVData = (SDL_VideoData *)_this->driverdata;
      QMSG  qmsg;
  
      if (WinPeekMsg(pVData->hab, &qmsg, NULLHANDLE, 0, 0, PM_REMOVE))
          WinDispatchMsg(pVData->hab, &qmsg);
  }
  
  static WINDATA *_setupWindow(_THIS, SDL_Window *window, HWND hwndFrame,
                               HWND hwnd)
  {
      SDL_VideoData *pVData = (SDL_VideoData *)_this->driverdata;
      WINDATA       *pWinData = SDL_calloc(1, sizeof(WINDATA));
  
      if (pWinData == NULL) {
          SDL_OutOfMemory();
          return NULL;
       }
      pWinData->hwnd = hwnd;
      pWinData->hwndFrame = hwndFrame;
      pWinData->window = window;
      window->driverdata = pWinData;
  
      WinSetWindowULong(hwnd, 0, (ULONG)pWinData);
      pWinData->fnWndFrameProc = WinSubclassWindow(hwndFrame, wndFrameProc);
  
      pWinData->pOutput = pVData->pOutput;
      pWinData->pVOData = pVData->pOutput->Open();
  
      WinSetVisibleRegionNotify(hwnd, TRUE);
  
      return pWinData;
  }
  
  static int OS2_CreateWindow(_THIS, SDL_Window *window)
  {
      RECTL            rectl;
      HWND             hwndFrame, hwnd;
      SDL_DisplayMode *pSDLDisplayMode = _getDisplayModeForSDLWindow(window);
      ULONG            ulFrameFlags = FCF_TASKLIST  | FCF_TITLEBAR | FCF_SYSMENU |
                                      FCF_MINBUTTON | FCF_SHELLPOSITION;
      ULONG            ulSWPFlags   = SWP_SIZE | SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE;
      WINDATA         *pWinData;
  
      if (pSDLDisplayMode == NULL)
          return -1;
  
      /* Create a PM window */
      if ((window->flags & SDL_WINDOW_RESIZABLE) != 0)
          ulFrameFlags |= FCF_SIZEBORDER | FCF_DLGBORDER | FCF_MAXBUTTON;
      else if ((window->flags & SDL_WINDOW_BORDERLESS) == 0)
          ulFrameFlags |= FCF_DLGBORDER;
  
      if ((window->flags & SDL_WINDOW_MAXIMIZED) != 0)
          ulSWPFlags |= SWP_MAXIMIZE;
      else if ((window->flags & SDL_WINDOW_MINIMIZED) != 0)
          ulSWPFlags |= SWP_MINIMIZE;
  
      hwndFrame = WinCreateStdWindow(HWND_DESKTOP, 0, &ulFrameFlags,
                                     WIN_CLIENT_CLASS, "SDL2", 0, 0, 0, &hwnd);
      if (hwndFrame == NULLHANDLE)
          return SDL_SetError("Couldn't create window");
  
      /* Setup window data and frame window procedure */
      pWinData = _setupWindow(_this, window, hwndFrame, hwnd);
      if (pWinData == NULL) {
          WinDestroyWindow(hwndFrame);
          return -1;
      }
  
      /* Show window */
      rectl.xLeft   = 0;
      rectl.yBottom = 0;
      rectl.xRight  = window->w;
      rectl.yTop    = window->h;
      WinCalcFrameRect(hwndFrame, &rectl, FALSE);
      pWinData->lSkipWMSize++;
      pWinData->lSkipWMMove++;
      WinSetWindowPos(hwndFrame, HWND_TOP, rectl.xLeft, rectl.yBottom,
                      rectl.xRight - rectl.xLeft, rectl.yTop - rectl.yBottom,
                      ulSWPFlags);
  
      rectl.xLeft   = 0;
      rectl.yBottom = 0;
      WinMapWindowPoints(hwnd, HWND_DESKTOP, (PPOINTL)&rectl, 1);
      window->x = rectl.xLeft;
      window->y = pSDLDisplayMode->h - (rectl.yBottom + window->h);
  
      window->flags |= SDL_WINDOW_SHOWN;
  
      return 0;
  }
  
  static int OS2_CreateWindowFrom(_THIS, SDL_Window *window, const void *data)
  {
      SDL_VideoData   *pVData = (SDL_VideoData *)_this->driverdata;
      CHAR             acBuf[256];
      CLASSINFO        stCI;
      HWND             hwndUser = (HWND)data;
      HWND             hwndFrame, hwnd;
      ULONG            cbText;
      PSZ              pszText;
      WINDATA         *pWinData;
      SDL_DisplayMode *pSDLDisplayMode = _getDisplayModeForSDLWindow(window);
      SWP              swp;
      POINTL           pointl;
  
      debug_os2("Enter");
      if (pSDLDisplayMode == NULL)
          return -1;
  
      /* User can accept client OR frame window handle.
       * Get client and frame window handles. */
      WinQueryClassName(hwndUser, sizeof(acBuf), acBuf);
      if (!WinQueryClassInfo(pVData->hab, acBuf, &stCI))
          return SDL_SetError("Cannot get user window class information");
  
      if ((stCI.flClassStyle & CS_FRAME) == 0) {
          /* Client window handle is specified */
          hwndFrame = WinQueryWindow(hwndUser, QW_PARENT);
          if (hwndFrame == NULLHANDLE)
              return SDL_SetError("Cannot get parent window handle");
  
          if ((ULONG)WinSendMsg(hwndFrame, WM_QUERYFRAMEINFO, 0, 0) == 0)
              return SDL_SetError("Parent window is not a frame window");
  
          hwnd = hwndUser;
      } else {
          /* Frame window handle is specified */
          hwnd = WinWindowFromID(hwndUser, FID_CLIENT);
          if (hwnd == NULLHANDLE)
              return SDL_SetError("Cannot get client window handle");
  
          hwndFrame = hwndUser;
  
          WinQueryClassName(hwnd, sizeof(acBuf), acBuf);
          if (!WinQueryClassInfo(pVData->hab, acBuf, &stCI))
              return SDL_SetError("Cannot get client window class information");
      }
  
      /* Check window's reserved storage */
      if (stCI.cbWindowData < sizeof(ULONG))
          return SDL_SetError("Reserved storage of window must be at least %u bytes", sizeof(ULONG));
  
      /* Set SDL-window title */
      cbText = WinQueryWindowTextLength(hwndFrame);
      pszText = SDL_stack_alloc(CHAR, cbText + 1);
  
      if (pszText != NULL)
          cbText = (pszText != NULL)? WinQueryWindowText(hwndFrame, cbText, pszText) : 0;
  
      if (cbText != 0)
          window->title = OS2_SysToUTF8(pszText);
  
      if (pszText != NULL) {
          SDL_stack_free(pszText);
      }
  
      /* Set SDL-window flags */
      window->flags &= ~(SDL_WINDOW_SHOWN     | SDL_WINDOW_BORDERLESS |
                         SDL_WINDOW_RESIZABLE | SDL_WINDOW_MAXIMIZED  |
                         SDL_WINDOW_MINIMIZED | SDL_WINDOW_INPUT_FOCUS);
  
      if (WinIsWindowVisible(hwnd))
          window->flags |= SDL_WINDOW_SHOWN;
  
      WinSendMsg(hwndFrame, WM_QUERYBORDERSIZE, MPFROMP(&pointl), 0);
      if (pointl.y == WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER))
          window->flags |= SDL_WINDOW_RESIZABLE;
      else if (pointl.y <= WinQuerySysValue(HWND_DESKTOP, SV_CYBORDER))
          window->flags |= SDL_WINDOW_BORDERLESS;
  
      WinQueryWindowPos(hwndFrame, &swp);
  
      if ((swp.fl & SWP_MAXIMIZE) != 0)
          window->flags |= SDL_WINDOW_MAXIMIZED;
      if ((swp.fl & SWP_MINIMIZE) != 0)
          window->flags |= SDL_WINDOW_MINIMIZED;
  
      pointl.x = 0;
      pointl.y = 0;
      WinMapWindowPoints(hwnd, HWND_DESKTOP, &pointl, 1);
      window->x = pointl.x;
      window->y = pSDLDisplayMode->h - (pointl.y + swp.cy);
  
      WinQueryWindowPos(hwnd, &swp);
      window->w = swp.cx;
      window->h = swp.cy;
  
      /* Setup window data and frame window procedure */
      pWinData = _setupWindow(_this, window, hwndFrame, hwnd);
      if (pWinData == NULL) {
          SDL_free(window->title);
          window->title = NULL;
          return -1;
      }
      pWinData->fnUserWndProc = WinSubclassWindow(hwnd, wndProc);
  
      if (WinQueryActiveWindow(HWND_DESKTOP) == hwndFrame)
          SDL_SetKeyboardFocus(window);
  
      return 0;
  }
  
  static void OS2_DestroyWindow(_THIS, SDL_Window * window)
  {
      SDL_VideoData *pVData = (SDL_VideoData *)_this->driverdata;
      WINDATA       *pWinData = (WINDATA *)window->driverdata;
  
      debug_os2("Enter");
      if (pWinData == NULL)
          return;
  
      if (pWinData->hrgnShape != NULLHANDLE) {
          HPS hps = WinGetPS(pWinData->hwnd);
          GpiDestroyRegion(hps, pWinData->hrgnShape);
          WinReleasePS(hps);
      }
  
      if (window->shaper) {
          SDL_free(window->shaper);
          window->shaper = NULL;
      }
  
      if (pWinData->fnUserWndProc == NULL) {
          /* Window was created by SDL (OS2_CreateWindow()),
           * not by user (OS2_CreateWindowFrom()) */
          WinDestroyWindow(pWinData->hwndFrame);
      } else {
          WinSetWindowULong(pWinData->hwnd, 0, 0);
      }
  
      if ((pVData != NULL) && (pWinData->pVOData != NULL)) {
          pVData->pOutput->Close(pWinData->pVOData);
          pWinData->pVOData = NULL;
      }
  
      if (pWinData->hptrIcon != NULLHANDLE) {
          WinDestroyPointer(pWinData->hptrIcon);
          pWinData->hptrIcon = NULLHANDLE;
      }
  
      SDL_free(pWinData);
      window->driverdata = NULL;
  }
  
  static void OS2_SetWindowTitle(_THIS, SDL_Window *window)
  {
      PSZ pszTitle = (window->title == NULL)? NULL : OS2_UTF8ToSys(window->title);
  
      WinSetWindowText(((WINDATA *)window->driverdata)->hwndFrame, pszTitle);
      SDL_free(pszTitle);
  }
  
  static void OS2_SetWindowIcon(_THIS, SDL_Window *window, SDL_Surface *icon)
  {
      WINDATA  *pWinData = (WINDATA *)window->driverdata;
      HPOINTER  hptr = utilCreatePointer(icon, 0, 0);
  
      if (hptr == NULLHANDLE)
          return;
  
      /* Destroy old icon */
      if (pWinData->hptrIcon != NULLHANDLE)
          WinDestroyPointer(pWinData->hptrIcon);
  
      /* Set new window icon */
      pWinData->hptrIcon = hptr;
      if (!WinSendMsg(pWinData->hwndFrame, WM_SETICON, MPFROMLONG(hptr), 0)) {
          debug_os2("Cannot set icon for the window");
      }
  }
  
  static void OS2_SetWindowPosition(_THIS, SDL_Window *window)
  {
      WINDATA         *pWinData = (WINDATA *)window->driverdata;
      RECTL            rectl;
      ULONG            ulFlags;
      SDL_DisplayMode *pSDLDisplayMode = _getDisplayModeForSDLWindow(window);
  
      debug_os2("Enter");
      if (pSDLDisplayMode == NULL)
          return;
  
      rectl.xLeft = 0;
      rectl.yBottom = 0;
      rectl.xRight = window->w;
      rectl.yTop = window->h;
      WinCalcFrameRect(pWinData->hwndFrame, &rectl, FALSE);
  
      if (SDL_ShouldAllowTopmost() &&
          (window->flags & (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_INPUT_FOCUS)) ==
                           (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_INPUT_FOCUS) )
          ulFlags = SWP_ZORDER | SWP_MOVE | SWP_SIZE;
      else
          ulFlags = SWP_MOVE | SWP_SIZE;
  
      pWinData->lSkipWMSize++;
      pWinData->lSkipWMMove++;
      WinSetWindowPos(pWinData->hwndFrame, HWND_TOP,
                      window->x + rectl.xLeft,
                      (pSDLDisplayMode->h - window->y) - window->h + rectl.yBottom,
                      rectl.xRight - rectl.xLeft, rectl.yTop - rectl.yBottom,
                      ulFlags);
  }
  
  static void OS2_SetWindowSize(_THIS, SDL_Window *window)
  {
      debug_os2("Enter");
      OS2_SetWindowPosition(_this, window);
  }
  
  static void OS2_ShowWindow(_THIS, SDL_Window *window)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      debug_os2("Enter");
      WinShowWindow(pWinData->hwndFrame, TRUE);
  }
  
  static void OS2_HideWindow(_THIS, SDL_Window *window)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      debug_os2("Enter");
      WinShowWindow(pWinData->hwndFrame, FALSE);
  }
  
  static void OS2_RaiseWindow(_THIS, SDL_Window *window)
  {
      debug_os2("Enter");
      OS2_SetWindowPosition(_this, window);
  }
  
  static void OS2_MaximizeWindow(_THIS, SDL_Window *window)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      debug_os2("Enter");
      WinSetWindowPos(pWinData->hwndFrame, HWND_TOP, 0, 0, 0, 0, SWP_MAXIMIZE);
  }
  
  static void OS2_MinimizeWindow(_THIS, SDL_Window *window)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      debug_os2("Enter");
      WinSetWindowPos(pWinData->hwndFrame, HWND_TOP, 0, 0, 0, 0, SWP_MINIMIZE | SWP_DEACTIVATE);
  }
  
  static void OS2_RestoreWindow(_THIS, SDL_Window *window)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      debug_os2("Enter");
      WinSetWindowPos(pWinData->hwndFrame, HWND_TOP, 0, 0, 0, 0, SWP_RESTORE);
  }
  
  static void OS2_SetWindowBordered(_THIS, SDL_Window * window,
                                    SDL_bool bordered)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
      ULONG    ulStyle = WinQueryWindowULong(pWinData->hwndFrame, QWL_STYLE);
      RECTL    rectl;
  
      debug_os2("Enter");
  
      /* New frame sytle */
      if (bordered)
          ulStyle |= ((window->flags & SDL_WINDOW_RESIZABLE) != 0) ? FS_SIZEBORDER : FS_DLGBORDER;
      else
          ulStyle &= ~(FS_SIZEBORDER | FS_BORDER | FS_DLGBORDER);
  
      /* Save client window position */
      WinQueryWindowRect(pWinData->hwnd, &rectl);
      WinMapWindowPoints(pWinData->hwnd, HWND_DESKTOP, (PPOINTL)&rectl, 2);
  
      /* Change the frame */
      WinSetWindowULong(pWinData->hwndFrame, QWL_STYLE, ulStyle);
      WinSendMsg(pWinData->hwndFrame, WM_UPDATEFRAME, MPFROMLONG(FCF_BORDER), 0);
  
      /* Restore client window position */
      WinCalcFrameRect(pWinData->hwndFrame, &rectl, FALSE);
      pWinData->lSkipWMMove++;
      WinSetWindowPos(pWinData->hwndFrame, HWND_TOP, rectl.xLeft, rectl.yBottom,
                      rectl.xRight - rectl.xLeft,
                      rectl.yTop - rectl.yBottom,
                      SWP_SIZE | SWP_MOVE | SWP_NOADJUST);
  }
  
  static void OS2_SetWindowFullscreen(_THIS, SDL_Window *window,
                                      SDL_VideoDisplay *display,
                                      SDL_bool fullscreen)
  {
      RECTL            rectl;
      ULONG            ulFlags;
      WINDATA         *pWinData = (WINDATA *)window->driverdata;
      SDL_DisplayMode *pSDLDisplayMode = &display->current_mode;
  
      debug_os2("Enter, fullscreen: %u", fullscreen);
  
      if (pSDLDisplayMode == NULL)
          return;
  
      if (SDL_ShouldAllowTopmost() &&
          (window->flags & (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_INPUT_FOCUS)) == (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_INPUT_FOCUS))
          ulFlags = SWP_SIZE | SWP_MOVE | SWP_ZORDER | SWP_NOADJUST;
      else
          ulFlags = SWP_SIZE | SWP_MOVE | SWP_NOADJUST;
  
      if (fullscreen) {
          rectl.xLeft = 0;
          rectl.yBottom = 0;
          rectl.xRight = pSDLDisplayMode->w;
          rectl.yTop = pSDLDisplayMode->h;
          /* We need send the restore command now to allow WinCalcFrameRect() */
          WinSetWindowPos(pWinData->hwndFrame, HWND_TOP, 0, 0, 0, 0, SWP_RESTORE);
      } else {
          pWinData->lSkipWMMove++;
          rectl.xLeft = window->windowed.x;
          rectl.yTop = pSDLDisplayMode->h - window->windowed.y;
          rectl.xRight = rectl.xLeft + window->windowed.w;
          rectl.yBottom = rectl.yTop - window->windowed.h;
      }
  
      if (!WinCalcFrameRect(pWinData->hwndFrame, &rectl, FALSE)) {
          debug_os2("WinCalcFrameRect() failed");
      }
      else if (!WinSetWindowPos(pWinData->hwndFrame, HWND_TOP,
                                rectl.xLeft, rectl.yBottom,
                                rectl.xRight - rectl.xLeft, rectl.yTop - rectl.yBottom,
                                ulFlags)) {
          debug_os2("WinSetWindowPos() failed");
      }
  }
  
  static SDL_bool OS2_GetWindowWMInfo(_THIS, SDL_Window * window,
                                      struct SDL_SysWMinfo *info)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      if (info->version.major <= SDL_MAJOR_VERSION) {
          info->subsystem = SDL_SYSWM_OS2;
          info->info.os2.hwnd = pWinData->hwnd;
          info->info.os2.hwndFrame = pWinData->hwndFrame;
          return SDL_TRUE;
      }
  
      SDL_SetError("Application not compiled with SDL %u",
                   SDL_MAJOR_VERSION);
      return SDL_FALSE;
  }
  
  static void OS2_OnWindowEnter(_THIS, SDL_Window * window)
  {
  }
  
  static int OS2_SetWindowHitTest(SDL_Window *window, SDL_bool enabled)
  {
    debug_os2("Enter");
    return 0;
  }
  
  static void OS2_SetWindowMouseGrab(_THIS, SDL_Window *window, SDL_bool grabbed)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      debug_os2("Enter, %u", grabbed);
      _mouseCheck(pWinData);
  }
  
  
  /* Shaper
   */
  typedef struct _SHAPERECTS {
    PRECTL     pRects;
    ULONG      cRects;
    ULONG      ulWinHeight;
  } SHAPERECTS;
  
  static void _combineRectRegions(SDL_ShapeTree *node, void *closure)
  {
      SHAPERECTS *pShapeRects = (SHAPERECTS *)closure;
      PRECTL      pRect;
  
      /* Expand rectangles list */
      if ((pShapeRects->cRects & 0x0F) == 0) {
          pRect = SDL_realloc(pShapeRects->pRects, (pShapeRects->cRects + 0x10) * sizeof(RECTL));
          if (pRect == NULL)
              return;
          pShapeRects->pRects = pRect;
      }
  
      /* Add a new rectangle */
      pRect = &pShapeRects->pRects[pShapeRects->cRects];
      pShapeRects->cRects++;
      /* Fill rectangle data */
      pRect->xLeft = node->data.shape.x;
      pRect->yTop = pShapeRects->ulWinHeight - node->data.shape.y;
      pRect->xRight += node->data.shape.w;
      pRect->yBottom = pRect->yTop - node->data.shape.h;
  }
  
  static SDL_WindowShaper* OS2_CreateShaper(SDL_Window * window)
  {
      SDL_WindowShaper* pSDLShaper = SDL_malloc(sizeof(SDL_WindowShaper));
  
      debug_os2("Enter");
      pSDLShaper->window = window;
      pSDLShaper->mode.mode = ShapeModeDefault;
      pSDLShaper->mode.parameters.binarizationCutoff = 1;
      pSDLShaper->userx = 0;
      pSDLShaper->usery = 0;
      pSDLShaper->driverdata = (SDL_ShapeTree *)NULL;
      window->shaper = pSDLShaper;
  
      if (OS2_ResizeWindowShape(window) != 0) {
          window->shaper = NULL;
          SDL_free(pSDLShaper);
          return NULL;
      }
  
      return pSDLShaper;
  }
  
  static int OS2_SetWindowShape(SDL_WindowShaper *shaper, SDL_Surface *shape,
                                SDL_WindowShapeMode *shape_mode)
  {
      SDL_ShapeTree *pShapeTree;
      WINDATA       *pWinData;
      SHAPERECTS     stShapeRects;
      HPS            hps;
  
      debug_os2("Enter");
      if (shaper == NULL || shape == NULL ||
          (shape->format->Amask == 0 && shape_mode->mode != ShapeModeColorKey) ||
          shape->w != shaper->window->w || shape->h != shaper->window->h) {
          return SDL_INVALID_SHAPE_ARGUMENT;
      }
  
      if (shaper->driverdata != NULL)
          SDL_FreeShapeTree((SDL_ShapeTree **)&shaper->driverdata);
  
      pShapeTree = SDL_CalculateShapeTree(*shape_mode, shape);
      shaper->driverdata = pShapeTree;
  
      SDL_zero(stShapeRects);
      stShapeRects.ulWinHeight = shaper->window->h;
      SDL_TraverseShapeTree(pShapeTree, &_combineRectRegions, &stShapeRects);
  
      pWinData = (WINDATA *)shaper->window->driverdata;
      hps = WinGetPS(pWinData->hwnd);
  
      if (pWinData->hrgnShape != NULLHANDLE)
          GpiDestroyRegion(hps, pWinData->hrgnShape);
  
      pWinData->hrgnShape = (stShapeRects.pRects == NULL) ? NULLHANDLE :
                                  GpiCreateRegion(hps, stShapeRects.cRects, stShapeRects.pRects);
  
      WinReleasePS(hps);
      SDL_free(stShapeRects.pRects);
      WinSendMsg(pWinData->hwnd, WM_VRNENABLED, 0, 0);
  
      return 0;
  }
  
  static int OS2_ResizeWindowShape(SDL_Window *window)
  {
      debug_os2("Enter");
      if (window == NULL)
          return -1;
  
      if (window->x != -1000) {
          if (window->shaper->driverdata != NULL)
              SDL_FreeShapeTree((SDL_ShapeTree **)window->shaper->driverdata);
  
          if (window->shaper->hasshape == SDL_TRUE) {
              window->shaper->userx = window->x;
              window->shaper->usery = window->y;
              SDL_SetWindowPosition(window, -1000, -1000);
          }
      }
  
      return 0;
  }
  
  
  /* Frame buffer
   */
  static void OS2_DestroyWindowFramebuffer(_THIS, SDL_Window *window)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      debug_os2("Enter");
      if (pWinData != NULL && pWinData->pVOData != NULL)
          pWinData->pOutput->VideoBufFree(pWinData->pVOData);
  }
  
  static int OS2_CreateWindowFramebuffer(_THIS, SDL_Window *window,
                                         Uint32 *format, void **pixels,
                                         int *pitch)
  {
      WINDATA          *pWinData = (WINDATA *)window->driverdata;
      SDL_VideoDisplay *pSDLDisplay = SDL_GetDisplayForWindow(window);
      SDL_DisplayMode  *pSDLDisplayMode;
      MODEDATA         *pModeData;
      ULONG             ulWidth, ulHeight;
  
      debug_os2("Enter");
      if (pSDLDisplay == NULL) {
          debug_os2("No display for the window");
          return -1;
      }
  
      pSDLDisplayMode = &pSDLDisplay->current_mode;
      pModeData = (MODEDATA *)pSDLDisplayMode->driverdata;
      if (pModeData == NULL)
          return SDL_SetError("No mode data for the display");
  
      SDL_GetWindowSize(window, (int *)&ulWidth, (int *)&ulHeight);
      debug_os2("Window size: %u x %u", ulWidth, ulHeight);
  
      *pixels = pWinData->pOutput->VideoBufAlloc(
                          pWinData->pVOData, ulWidth, ulHeight, pModeData->ulDepth,
                          pModeData->fccColorEncoding, (PULONG)pitch);
      if (*pixels == NULL)
          return -1;
  
      *format = pSDLDisplayMode->format;
      debug_os2("Pitch: %u, frame buffer: 0x%X.", *pitch, *pixels);
      WinSendMsg(pWinData->hwnd, WM_VRNENABLED, 0, 0);
  
      return 0;
  }
  
  static int OS2_UpdateWindowFramebuffer(_THIS, SDL_Window * window,
                                         const SDL_Rect *rects, int numrects)
  {
      WINDATA *pWinData = (WINDATA *)window->driverdata;
  
      return pWinData->pOutput->Update(pWinData->pVOData, pWinData->hwnd,
                                       (SDL_Rect *)rects, (ULONG)numrects)
             ? 0 : -1;
  }
  
  
  /* Clipboard
   */
  static int OS2_SetClipboardText(_THIS, const char *text)
  {
      SDL_VideoData *pVData = (SDL_VideoData *)_this->driverdata;
      PSZ   pszClipboard;
      PSZ   pszText = (text == NULL)? NULL : OS2_UTF8ToSys(text);
      ULONG cbText;
      ULONG ulRC;
      BOOL  fSuccess;
  
      debug_os2("Enter");
      if (pszText == NULL)
          return -1;
      cbText = SDL_strlen(pszText) + 1;
  
      ulRC = DosAllocSharedMem((PPVOID)&pszClipboard, 0, cbText,
                                PAG_COMMIT | PAG_READ | PAG_WRITE |
                                OBJ_GIVEABLE | OBJ_GETTABLE | OBJ_TILE);
      if (ulRC != NO_ERROR) {
          debug_os2("DosAllocSharedMem() failed, rc = %u", ulRC);
          SDL_free(pszText);
          return -1;
      }
  
      SDL_memcpy(pszClipboard, pszText, cbText);
      SDL_free(pszText);
  
      if (!WinOpenClipbrd(pVData->hab)) {
          debug_os2("WinOpenClipbrd() failed");
          fSuccess = FALSE;
      } else {
          WinEmptyClipbrd(pVData->hab);
          fSuccess = WinSetClipbrdData(pVData->hab, (ULONG)pszClipboard, CF_TEXT, CFI_POINTER);
          if (!fSuccess) {
              debug_os2("WinOpenClipbrd() failed");
          }
          WinCloseClipbrd(pVData->hab);
      }
  
      if (!fSuccess) {
          DosFreeMem(pszClipboard);
          return -1;
      }
      return 0;
  }
  
  static char *OS2_GetClipboardText(_THIS)
  {
      SDL_VideoData *pVData = (SDL_VideoData *)_this->driverdata;
      PSZ pszClipboard = NULL;
  
      if (!WinOpenClipbrd(pVData->hab)) {
          debug_os2("WinOpenClipbrd() failed");
      } else {
          pszClipboard = (PSZ)WinQueryClipbrdData(pVData->hab, CF_TEXT);
          if (pszClipboard != NULL)
              pszClipboard = OS2_SysToUTF8(pszClipboard);
          WinCloseClipbrd(pVData->hab);
      }
  
      return (pszClipboard == NULL) ? SDL_strdup("") : pszClipboard;
  }
  
  static SDL_bool OS2_HasClipboardText(_THIS)
  {
      SDL_VideoData *pVData = (SDL_VideoData *)_this->driverdata;
      PSZ pszClipboard;
      SDL_bool  result;
  
      if (!WinOpenClipbrd(pVData->hab)) {
          debug_os2("WinOpenClipbrd() failed");
          return SDL_FALSE;
      }
  
      pszClipboard = (PSZ)WinQueryClipbrdData(pVData->hab, CF_TEXT);
      result = (pszClipboard && *pszClipboard) ? SDL_TRUE : SDL_FALSE;
      WinCloseClipbrd(pVData->hab);
  
      return result;
  }
  
  
  static int OS2_VideoInit(_THIS)
  {
      SDL_VideoData *pVData;
      PTIB  tib;
      PPIB  pib;
  
      /* Create SDL video driver private data */
      pVData = SDL_calloc(1, sizeof(SDL_VideoData));
      if (pVData == NULL)
          return SDL_OutOfMemory();
  
      /* Change process type code for use Win* API from VIO session */
      DosGetInfoBlocks(&tib, &pib);
      if (pib->pib_ultype == 2 || pib->pib_ultype == 0) {
          /* VIO windowable or fullscreen protect-mode session */
          pib->pib_ultype = 3; /* Presentation Manager protect-mode session */
      }
  
      /* PM initialization */
      pVData->hab = WinInitialize(0);
      pVData->hmq = WinCreateMsgQueue(pVData->hab, 0);
      if (pVData->hmq == NULLHANDLE) {
          SDL_free(pVData);
          return SDL_SetError("Message queue cannot be created.");
      }
  
      if (!WinRegisterClass(pVData->hab, WIN_CLIENT_CLASS, wndProc,
                            CS_SIZEREDRAW | CS_MOVENOTIFY | CS_SYNCPAINT,
                            sizeof(SDL_VideoData*))) {
          SDL_free(pVData);
          return SDL_SetError("Window class not successfully registered.");
      }
  
      if (SDL_strcasecmp(_this->name, OS2DRIVER_NAME_VMAN) == 0)
          pVData->pOutput = &voVMan;
      else
          pVData->pOutput = &voDive;
  
      _this->driverdata = pVData;
  
      /* Add display */
      {
          SDL_VideoDisplay    stSDLDisplay;
          SDL_DisplayMode     stSDLDisplayMode;
          DISPLAYDATA        *pDisplayData;
          MODEDATA           *pModeData;
          VIDEOOUTPUTINFO     stVOInfo;
  
          if (!pVData->pOutput->QueryInfo(&stVOInfo)) {
              SDL_free(pVData);
              return SDL_SetError("Video mode query failed.");
          }
  
          SDL_zero(stSDLDisplay); SDL_zero(stSDLDisplayMode);
  
          stSDLDisplayMode.format = _getSDLPixelFormat(stVOInfo.ulBPP,
                                                       stVOInfo.fccColorEncoding);
          stSDLDisplayMode.w = stVOInfo.ulHorizResolution;
          stSDLDisplayMode.h = stVOInfo.ulVertResolution;
          stSDLDisplayMode.refresh_rate = 0;
          stSDLDisplayMode.driverdata = NULL;
  
          pModeData = SDL_malloc(sizeof(MODEDATA));
          if (pModeData != NULL) {
              pModeData->ulDepth = stVOInfo.ulBPP;
              pModeData->fccColorEncoding = stVOInfo.fccColorEncoding;
              pModeData->ulScanLineBytes = stVOInfo.ulScanLineSize;
              stSDLDisplayMode.driverdata = pModeData;
          }
  
          stSDLDisplay.name = "Primary";
          stSDLDisplay.desktop_mode = stSDLDisplayMode;
          stSDLDisplay.current_mode = stSDLDisplayMode;
          stSDLDisplay.driverdata = NULL;
          stSDLDisplay.num_display_modes = 0;
  
          pDisplayData = SDL_malloc(sizeof(DISPLAYDATA));
          if (pDisplayData != NULL) {
              HPS hps = WinGetPS(HWND_DESKTOP);
              HDC hdc = GpiQueryDevice(hps);
  
              /* May be we can use CAPS_HORIZONTAL_RESOLUTION and
               * CAPS_VERTICAL_RESOLUTION - pels per meter?  */
              DevQueryCaps(hdc, CAPS_HORIZONTAL_FONT_RES, 1,
                            (PLONG)&pDisplayData->ulDPIHor);
              DevQueryCaps(hdc, CAPS_VERTICAL_FONT_RES, 1,
                            (PLONG)&pDisplayData->ulDPIVer);
              WinReleasePS(hps);
  
              pDisplayData->ulDPIDiag = SDL_ComputeDiagonalDPI(
                    stVOInfo.ulHorizResolution, stVOInfo.ulVertResolution,
                    (float)stVOInfo.ulHorizResolution / pDisplayData->ulDPIHor,
                    (float)stVOInfo.ulVertResolution / pDisplayData->ulDPIVer);
  
              stSDLDisplayMode.driverdata = pDisplayData;
          }
  
          SDL_AddVideoDisplay(&stSDLDisplay, SDL_FALSE);
      }
  
      OS2_InitMouse(_this, pVData->hab);
  
      return 0;
  }
  
  static void OS2_VideoQuit(_THIS)
  {
      SDL_VideoData *pVData = (SDL_VideoData *)_this->driverdata;
  
      OS2_QuitMouse(_this);
  
      WinDestroyMsgQueue(pVData->hmq);
      WinTerminate(pVData->hab);
  
      /* our caller SDL_VideoQuit() already frees display_modes, driverdata, etc. */
  }
  
  static int OS2_GetDisplayBounds(_THIS, SDL_VideoDisplay *display,
                                  SDL_Rect *rect)
  {
      debug_os2("Enter");
  
      rect->x = 0;
      rect->y = 0;
      rect->w = display->desktop_mode.w;
      rect->h = display->desktop_mode.h;
  
      return 0;
  }
  
  static int OS2_GetDisplayDPI(_THIS, SDL_VideoDisplay *display, float *ddpi,
                               float *hdpi, float *vdpi)
  {
      DISPLAYDATA *pDisplayData = (DISPLAYDATA *)display->driverdata;
  
      debug_os2("Enter");
      if (pDisplayData == NULL)
          return -1;
  
      if (ddpi != NULL)
          *hdpi = pDisplayData->ulDPIDiag;
      if (hdpi != NULL)
          *hdpi = pDisplayData->ulDPIHor;
      if (vdpi != NULL)
          *vdpi = pDisplayData->ulDPIVer;
  
      return 0;
  }
  
  static void OS2_GetDisplayModes(_THIS, SDL_VideoDisplay *display)
  {
      SDL_DisplayMode mode;
  
      debug_os2("Enter");
      SDL_copyp(&mode, &display->current_mode);
      mode.driverdata = (MODEDATA *) SDL_malloc(sizeof(MODEDATA));
      if (!mode.driverdata) return; /* yikes.. */
      SDL_memcpy(mode.driverdata, display->current_mode.driverdata, sizeof(MODEDATA));
      SDL_AddDisplayMode(display, &mode);
  }
  
  static int OS2_SetDisplayMode(_THIS, SDL_VideoDisplay *display,
                                SDL_DisplayMode *mode)
  {
      debug_os2("Enter");
      return -1;
  }
  
  
  static void OS2_DeleteDevice(SDL_VideoDevice *device)
  {
      SDL_free(device);
  }
  
  static SDL_VideoDevice *OS2_CreateDevice(void)
  {
      SDL_VideoDevice *device;
  
      /* Initialize all variables that we clean on shutdown */
      device = (SDL_VideoDevice *)SDL_calloc(1, sizeof(SDL_VideoDevice));
      if (!device) {
          SDL_OutOfMemory();
          return NULL;
      }
  
      /* Set the function pointers */
      device->VideoInit = OS2_VideoInit;
      device->VideoQuit = OS2_VideoQuit;
      device->GetDisplayBounds = OS2_GetDisplayBounds;
      device->GetDisplayDPI = OS2_GetDisplayDPI;
      device->GetDisplayModes = OS2_GetDisplayModes;
      device->SetDisplayMode = OS2_SetDisplayMode;
      device->PumpEvents = OS2_PumpEvents;
      device->CreateSDLWindow = OS2_CreateWindow;
      device->CreateSDLWindowFrom = OS2_CreateWindowFrom;
      device->DestroyWindow = OS2_DestroyWindow;
      device->SetWindowTitle = OS2_SetWindowTitle;
      device->SetWindowIcon = OS2_SetWindowIcon;
      device->SetWindowPosition = OS2_SetWindowPosition;
      device->SetWindowSize = OS2_SetWindowSize;
      device->ShowWindow = OS2_ShowWindow;
      device->HideWindow = OS2_HideWindow;
      device->RaiseWindow = OS2_RaiseWindow;
      device->MaximizeWindow = OS2_MaximizeWindow;
      device->MinimizeWindow = OS2_MinimizeWindow;
      device->RestoreWindow = OS2_RestoreWindow;
      device->SetWindowBordered = OS2_SetWindowBordered;
      device->SetWindowFullscreen = OS2_SetWindowFullscreen;
      device->GetWindowWMInfo = OS2_GetWindowWMInfo;
      device->OnWindowEnter = OS2_OnWindowEnter;
      device->SetWindowHitTest = OS2_SetWindowHitTest;
      device->SetWindowMouseGrab = OS2_SetWindowMouseGrab;
      device->CreateWindowFramebuffer = OS2_CreateWindowFramebuffer;
      device->UpdateWindowFramebuffer = OS2_UpdateWindowFramebuffer;
      device->DestroyWindowFramebuffer = OS2_DestroyWindowFramebuffer;
  
      device->SetClipboardText = OS2_SetClipboardText;
      device->GetClipboardText = OS2_GetClipboardText;
      device->HasClipboardText = OS2_HasClipboardText;
  
      device->shape_driver.CreateShaper = OS2_CreateShaper;
      device->shape_driver.SetWindowShape = OS2_SetWindowShape;
      device->shape_driver.ResizeWindowShape = OS2_ResizeWindowShape;
  
      device->free = OS2_DeleteDevice;
  
      return device;
  }
  
  static SDL_VideoDevice *OS2DIVE_CreateDevice(void)
  {
      VIDEOOUTPUTINFO stVOInfo;
      if (!voDive.QueryInfo(&stVOInfo)) {
          return NULL;
      }
      return OS2_CreateDevice();
  }
  
  static SDL_VideoDevice *OS2VMAN_CreateDevice(void)
  {
      VIDEOOUTPUTINFO stVOInfo;
      if (!voVMan.QueryInfo(&stVOInfo)) {
            return NULL;
      }
      return OS2_CreateDevice();
  }
  
  
  /* DIVE and VMAN bootstraps both call the same OS2_CreateDevice() function.
   * Video output system will be selected in OS2_VideoInit() by driver name.  */
  VideoBootStrap OS2DIVE_bootstrap =
  {
      OS2DRIVER_NAME_DIVE, "OS/2 video driver",
      OS2DIVE_CreateDevice
  };
  VideoBootStrap OS2VMAN_bootstrap =
  {
      OS2DRIVER_NAME_VMAN, "OS/2 video driver",
      OS2VMAN_CreateDevice
  };
  
  #endif /* SDL_VIDEO_DRIVER_OS2 */
  
  /* vi: set ts=4 sw=4 expandtab: */
  

Download