Ignore:
Timestamp:
Mar 9, 2001, 11:48:48 PM (25 years ago)
Author:
mike
Message:

Updates/cleanup for Watcom (not complete)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ddraw/new/OS2DDRAW.CPP

    r4970 r5291  
    1 /* $Id: OS2DDRAW.CPP,v 1.2 2001-01-19 02:06:55 mike Exp $ */
     1/* $Id: OS2DDRAW.CPP,v 1.3 2001-03-09 22:48:47 mike Exp $ */
    22
    33/*
    … …  
    66 * Copyright 1998 Sander van Leeuwen
    77 * Copyright 1999 Markus Montkowski
    8  * Copyright 2000 Michal Necasek
    98 * Copyright 2000 Przemyslaw Dobrowolski
     9 * Copyright 2001 Michal Necasek
    1010 *
    1111 * Project Odin Software License can be found in LICENSE.TXT
    1212 *
    1313 */
     14
    1415#include <stdlib.h>
    1516#include <string.h>
    … …  
    2829#include <winuser.h>
    2930#include <winerror.h>
    30 #include <builtin.h>
    3131#include "cio2.h"
    3232#include "os2util.h"
    … …  
    3838#include "os2DDWindow.h"
    3939#include "os2palset.h"
    40 #include "os2fsdd.h"
    4140
    4241#define KEY_DIRECT2 "\\Software\\Win32OS2\\Direct2"
    … …  
    4948     Referenced(0), lastError(DD_OK),
    5049     pFrameBuffer(NULL), hwndClient(0), screenwidth(640),
    51      screenheight(480), screenbpp(16),PrimaryExists(FALSE),pPrimSurf(NULL)
     50     screenheight(480), screenbpp(8),PrimaryExists(FALSE),pPrimSurf(NULL)
    5251
    5352{
    … …  
    6867  Vtbl3D.FindDevice     = D3DFindDevice;
    6968
    70   // old V2 Interface
     69  // Org Interface
    7170  Vtbl.AddRef                 = DrawAddRef;
    7271  Vtbl.Release                = DrawRelease;
    … …  
    9089  Vtbl.RestoreDisplayMode     = DrawRestoreDisplayMode;
    9190  Vtbl.SetCooperativeLevel    = DrawSetCooperativeLevel;
    92   if(lpGUID && *lpGUID == IID_IDirectDraw2)
    93     *(ULONG *)&Vtbl.SetDisplayMode = (ULONG)DrawSetDisplayMode2;
    94   else
    95     *(ULONG *)&Vtbl.SetDisplayMode = (ULONG)DrawSetDisplayMode;
     91  Vtbl.SetDisplayMode         = DrawSetDisplayMode;
    9692  Vtbl.WaitForVerticalBlank   = DrawWaitForVerticalBlank;
    97   Vtbl.GetAvailableVidMem     = DrawGetAvailableVidMem;
     93
     94  // V2 Interface
     95
     96  Vtbl2.AddRef                 = DrawAddRef;
     97  Vtbl2.Release                = DrawRelease;
     98  Vtbl2.QueryInterface         = DrawQueryInterface;
     99  Vtbl2.Compact                = DrawCompact;
     100  Vtbl2.CreateClipper          = DrawCreateClipper;
     101  Vtbl2.CreatePalette          = DrawCreatePalette;
     102  Vtbl2.CreateSurface          = DrawCreateSurface;
     103  Vtbl2.DuplicateSurface       = DrawDuplicateSurface;
     104  Vtbl2.EnumDisplayModes       = DrawEnumDisplayModes;
     105  Vtbl2.EnumSurfaces           = DrawEnumSurfaces;
     106  Vtbl2.FlipToGDISurface       = DrawFlipToGDISurface;
     107  Vtbl2.GetCaps                = DrawGetCaps;
     108  Vtbl2.GetDisplayMode         = DrawGetDisplayMode;
     109  Vtbl2.GetFourCCCodes         = DrawGetFourCCCodes;
     110  Vtbl2.GetGDISurface          = DrawGetGDISurface;
     111  Vtbl2.GetMonitorFrequency    = DrawGetMonitorFrequency;
     112  Vtbl2.GetScanLine            = DrawGetScanLine;
     113  Vtbl2.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
     114  Vtbl2.Initialize             = DrawInitialize;
     115  Vtbl2.RestoreDisplayMode     = DrawRestoreDisplayMode;
     116  Vtbl2.SetCooperativeLevel    = DrawSetCooperativeLevel;
     117  Vtbl2.SetDisplayMode         = DrawSetDisplayMode2;
     118  Vtbl2.WaitForVerticalBlank   = DrawWaitForVerticalBlank;
     119  Vtbl2.GetAvailableVidMem     = DrawGetAvailableVidMem;
    98120
    99121  // New V4 interface
    … …  
    103125  Vtbl4.Compact                = DrawCompact;
    104126  Vtbl4.CreateClipper          = DrawCreateClipper;
     127  Vtbl4.CreatePalette          = DrawCreatePalette;
    105128  Vtbl4.CreateSurface          = DrawCreateSurface4;//
    106129  Vtbl4.DuplicateSurface       = DrawDuplicateSurface4;//
    … …  
    128151  if(lpGUID && *lpGUID == IID_IDirect3D)
    129152  {
    130     dprintf(("DDRAW: D3D Interface\n"));
    131 
    132     lpVtbl = (IDirectDraw4Vtbl *)&Vtbl3D;
     153    dprintf(("DDRAW: D3D Interface -> using V4 Interface"));
     154
     155    lpVtbl = &Vtbl4;
    133156  }
    134157  else
    … …  
    203226  }
    204227
     228  // FSDDRAW additions
    205229  rc = LoadPMIService();
    206230
    … …  
    219243{
    220244  dprintf(("DDRAW: OS2IDirectDraw::~OS2IDirectDraw()\n"));
    221 
    222   if(hDive) DiveClose(hDive);
     245  if(hDive)
     246    DiveClose(hDive);
    223247
    224248  // Safty call in case the program did set the pal to all black
    … …  
    226250  OS2ResetPhysPalette();
    227251
    228   // we need this in Full Screen, but don't create any effect in windowed
     252  // FSDDRAW additions
     253  // we need this in Full Screen, but don't do anything in windowed
    229254  // session.
    230255  if (bPMILoaded)
    … …  
    242267//******************************************************************************
    243268//******************************************************************************
    244 HRESULT __stdcall DrawQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
     269HRESULT WIN32API DrawQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
    245270{
    246271 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
    247   #ifdef DEBUG
    248     dprintf(("DDRAW: OS2IDirectDraw::QueryInterface\n"));
    249   #endif
     272
     273  dprintf(("DDRAW: OS2IDirectDraw::QueryInterface %x %x %x", This, riid, ppvObj));
    250274
    251275  *ppvObj = NULL;
    … …  
    254278     !IsEqualGUID(riid, IID_IDirectDraw) &&
    255279     !IsEqualGUID(riid, IID_IDirectDraw2) &&
    256      !IsEqualGUID(riid, IID_IDirectDraw4))
    257 //&& !IsEqualGUID(riid, IID_IUnknown))
     280     !IsEqualGUID(riid, IID_IDirectDraw4) &&
     281     !IsEqualGUID(riid, IID_IDirect3D))
     282//     !IsEqualGUID(riid, IID_IUnknown))
    258283  return E_NOINTERFACE;
    259284
    260   // ToDo Better way of returning differnent intterfaces for same class
    261 
    262   if(IsEqualGUID(riid, IID_IDirectDraw4))
    263   {
    264     dprintf(("DDRAW: IID_IDirectDraw4 Interface\n"));
    265     me->lpVtbl = &me->Vtbl4;
     285  // ToDo Better way of returning differnent interfaces for same class
     286  if(IsEqualGUID(riid, IID_IDirect3D))
     287  {
     288    me->lpVtbl3D         = &me->Vtbl3D;
     289    me->lpVtbl3D2        = me->lpVtbl3D;
     290    me->pdwUnknownData3D = me->pdwUnknownData;
     291    *ppvObj = (LPVOID)&me->lpVtbl3D;
     292    DrawAddRef(This);
     293    return DD_OK;
    266294  }
    267295  else
    268296  {
    269     dprintf(("DDRAW: No IID_IDirectDraw4 Interface\n"));
    270     me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl;
    271   }
     297    if(IsEqualGUID(riid, IID_IDirectDraw4))
     298    {
     299      dprintf(("DDRAW: IID_IDirectDraw4 Interface\n"));
     300      me->lpVtbl = &me->Vtbl4;
     301    }
     302    else
     303    {
     304      if(IsEqualGUID(riid, IID_IDirectDraw2))
     305      {
     306        dprintf(("DDRAW: IID_IDirectDraw2 Interface\n"));
     307        me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl2;
     308      }
     309      else
     310      {
     311        dprintf(("DDRAW: IID_IDirectDraw Interface\n"));
     312        me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl;
     313      }
     314    }
     315  }
     316  me->lpVtbl2 = me->lpVtbl;
    272317  *ppvObj = This;
    273318  DrawAddRef(This);
    … …  
    277322//******************************************************************************
    278323//******************************************************************************
    279 ULONG __stdcall DrawAddRef(THIS This)
     324ULONG WIN32API DrawAddRef(THIS This)
    280325{
    281326 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
    282327
    283   #ifdef DEBUG
    284     dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
    285   #endif
     328  dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
    286329
    287330  return ++me->Referenced;
    … …  
    289332//******************************************************************************
    290333//******************************************************************************
    291 ULONG __stdcall DrawRelease(THIS This)
     334ULONG WIN32API DrawRelease(THIS This)
    292335{
    293336 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
    294337 ULONG rc;
    295338
    296   #ifdef DEBUG
    297     dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
    298     dprintf(("DDRAW: OS2IDirectDraw::%X \n", me));
    299   #endif
     339  dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
     340  dprintf(("DDRAW: OS2IDirectDraw::%X \n", me));
    300341
    301342  if(me->Referenced)
    … …  
    318359//******************************************************************************
    319360//******************************************************************************
    320 HRESULT __stdcall DrawCompact(THIS)
    321 {
    322   #ifdef DEBUG
    323     dprintf(("DDRAW: Compact\n"));
    324   #endif
    325 
    326   return(DD_OK);
    327 }
    328 //******************************************************************************
    329 //******************************************************************************
    330 HRESULT __stdcall DrawCreateClipper(THIS This, DWORD, LPDIRECTDRAWCLIPPER FAR *lplpDD, IUnknown FAR * )
     361HRESULT WIN32API DrawCompact(THIS)
     362{
     363  dprintf(("DDRAW: Compact\n"));
     364
     365  return(DD_OK);
     366}
     367//******************************************************************************
     368//******************************************************************************
     369HRESULT WIN32API DrawCreateClipper(THIS This, DWORD, LPDIRECTDRAWCLIPPER FAR *lplpDD, IUnknown FAR * )
    331370{
    332371 OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    … …  
    336375  newclip = new OS2IDirectDrawClipper(me);
    337376
    338   #ifdef DEBUG
    339     dprintf(("DDRAW: CreateClipper\n"));
    340   #endif
     377  dprintf(("DDRAW: CreateClipper\n"));
    341378
    342379  if(newclip == NULL)
    … …  
    361398//******************************************************************************
    362399//******************************************************************************
    363 HRESULT __stdcall DrawCreatePalette(THIS This, DWORD dwFlags,
     400HRESULT WIN32API DrawCreatePalette(THIS This, DWORD dwFlags,
    364401            LPPALETTEENTRY lpColorTable,
    365402            LPDIRECTDRAWPALETTE FAR *lplpDD,
    … …  
    392429  if(DD_OK == rc)
    393430  {
    394     #ifdef DEBUG
    395       dprintf(("DDRAW: CreatePalette with %d colors\n", palsize));
    396     #endif
     431    dprintf(("DDRAW: CreatePalette with %d colors\n", palsize));
    397432
    398433    newpal = new OS2IDirectDrawPalette((VOID*)me, palsize, lpColorTable, dwFlags);
    … …  
    421456//******************************************************************************
    422457//******************************************************************************
    423 HRESULT __stdcall DrawCreateSurface(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc,
     458HRESULT WIN32API DrawCreateSurface(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc,
    424459            LPDIRECTDRAWSURFACE FAR *lplpDD,
    425460            IUnknown FAR *pUnkOuter)
    … …  
    429464 HRESULT                rc;
    430465
    431   #ifdef DEBUG
    432     dprintf(("DDRAW: CreateSurface\n"));
    433     dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc->dwSize));
    434     dprintf(("DDRAW: dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
    435     dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
    436     dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
    437     dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc->lPitch));
    438     dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
    439     dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
    440     dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
    441     dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
    442   #endif
     466  dprintf(("DDRAW: CreateSurface\n"));
     467  dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc->dwSize));
     468  dprintf(("DDRAW: dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
     469  dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
     470  dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
     471  dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc->lPitch));
     472  dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
     473  dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
     474  dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
     475  dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
    443476
    444477  newsurf = new OS2IDirectDrawSurface(me, (LPDDSURFACEDESC2)lpDDSurfaceDesc);
    … …  
    467500//******************************************************************************
    468501//******************************************************************************
    469 HRESULT __stdcall DrawCreateSurface4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
     502HRESULT WIN32API DrawCreateSurface4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
    470503            LPDIRECTDRAWSURFACE4 FAR *lplpDD,
    471504            IUnknown FAR *pUnkOuter)
    … …  
    475508 HRESULT                rc;
    476509
    477   #ifdef DEBUG
    478     dprintf(("DDRAW: CreateSurface4\n"));
    479     dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc2->dwSize));
    480     dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
    481     dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
    482     dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc2->lPitch));
    483     dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
    484     dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
    485     dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
    486     dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
    487   #endif
     510  dprintf(("DDRAW: CreateSurface4\n"));
     511  dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc2->dwSize));
     512  dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
     513  dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
     514  dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc2->lPitch));
     515  dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
     516  dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
     517  dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
     518  dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
    488519
    489520  newsurf = new OS2IDirectDrawSurface(me, lpDDSurfaceDesc2);
    … …  
    514545//******************************************************************************
    515546//******************************************************************************
    516 HRESULT __stdcall DrawDuplicateSurface(THIS, LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * )
    517 {
    518   #ifdef DEBUG
    519     dprintf(("DDRAW: DuplicateSurface NIY\n"));
    520   #endif
    521   return(DD_OK);
    522 }
    523 //******************************************************************************
    524 //******************************************************************************
    525 HRESULT __stdcall DrawDuplicateSurface4(THIS, LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * )
    526 {
    527   #ifdef DEBUG
    528     dprintf(("DDRAW: DuplicateSurface4 NIY\n"));
    529   #endif
    530 
    531   return(DD_OK);
    532 }
    533 //******************************************************************************
    534 //******************************************************************************
    535 HRESULT __stdcall DrawEnumDisplayModes( THIS This,
     547HRESULT WIN32API DrawDuplicateSurface(THIS, LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * )
     548{
     549  dprintf(("DDRAW: DuplicateSurface NIY\n"));
     550
     551  return(DD_OK);
     552}
     553//******************************************************************************
     554//******************************************************************************
     555HRESULT WIN32API DrawDuplicateSurface4(THIS, LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * )
     556{
     557  dprintf(("DDRAW: DuplicateSurface4 NIY\n"));
     558
     559  return(DD_OK);
     560}
     561//******************************************************************************
     562//******************************************************************************
     563HRESULT WIN32API DrawEnumDisplayModes( THIS This,
    536564                                        DWORD dwFlags,
    537565                                        LPDDSURFACEDESC lpDDSurfaceDesc,
    … …  
    544572  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    545573
    546   #ifdef DEBUG
    547     dprintf(("DDRAW: EnumDisplayModes\n"));
    548   #endif
     574  dprintf(("DDRAW: EnumDisplayModes\n"));
    549575
    550576  // Check for Pointer to callback function
    551577  if (NULL == lpDDEnumModesCallback)
    552578  {
    553     #ifdef DEBUG
    554       dprintf(("DDRAW: EnumDisplayModes : Error NO EnumFunction passed in\n"));
    555     #endif
     579    dprintf(("DDRAW: EnumDisplayModes : Error NO EnumFunction passed in\n"));
    556580
    557581    return(DDERR_GENERIC);
    … …  
    574598    // DIVE modes
    575599
    576     #ifdef DEBUG
    577       dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
    578     #endif
     600    dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
    579601
    580602    // Enumerate all modes ?
    … …  
    583605      // Check if we shall report 320x200 mode
    584606
    585       #ifdef DEBUG
    586         dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
    587       #endif
     607      dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
    588608
    589609      if(dwFlags && DDEDM_STANDARDVGAMODES)
    590610      {
    591         #ifdef DEBUG
    592           dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
    593         #endif
     611        dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
     612
    594613        DDSurfAct.dwHeight = ModesDive[0].iYRes;
    595614        DDSurfAct.dwWidth  = ModesDive[0].iXRes;
    … …  
    598617        if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
    599618        {
    600           #ifdef DEBUG
    601             dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
    602           #endif
     619          dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
    603620          return (DD_OK);
    604621        }
    … …  
    641658              break;
    642659          }
    643           #ifdef DEBUG
    644             dprintf( ("EnumDisplayModes : Enum Mode %dx%d @ %d\n",
    645                       DDSurfAct.dwHeight,
    646                       DDSurfAct.dwWidth,
    647                       DDSurfAct.ddpfPixelFormat.dwRGBBitCount));
    648           #endif
     660          dprintf( ("EnumDisplayModes : Enum Mode %dx%d @ %d\n",
     661                    DDSurfAct.dwHeight,
     662                    DDSurfAct.dwWidth,
     663                    DDSurfAct.ddpfPixelFormat.dwRGBBitCount));
    649664          fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
    650           #ifdef DEBUG
    651             dprintf( ("EnumDisplayModes : Callback returned with %d\n",
    652                       fCallAgain));
    653           #endif
     665          dprintf( ("EnumDisplayModes : Callback returned with %d\n",
     666                    fCallAgain));
    654667        }
    655668        iMode++;
    … …  
    827840//******************************************************************************
    828841//******************************************************************************
    829 HRESULT __stdcall DrawEnumDisplayModes4(THIS This, DWORD dwFlags, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
     842HRESULT WIN32API DrawEnumDisplayModes4(THIS This, DWORD dwFlags, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
    830843                                       LPVOID lpContext, LPDDENUMMODESCALLBACK2 lpDDEnumModesCallback2)
    831844{
    832845  int iMode = 0;
     846#if 0
    833847  DDSURFACEDESC DDSurfAct;
    834848  BOOL fCallAgain;
     849#endif
    835850  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    836851
    837   #ifdef DEBUG
    838     dprintf(("DDRAW: EnumDisplayModes4 NIY\n"));
    839   #endif
    840   return(DD_OK);
    841 }
    842 //******************************************************************************
    843 //******************************************************************************
    844 HRESULT __stdcall DrawEnumSurfaces(THIS, DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK )
    845 {
    846   #ifdef DEBUG
    847     dprintf(("DDRAW: EnumSurfaces NIY\n"));
    848   #endif
    849 
    850   return(DD_OK);
    851 }
    852 //******************************************************************************
    853 //******************************************************************************
    854 HRESULT __stdcall DrawEnumSurfaces4(THIS, DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 )
    855 {
    856   #ifdef DEBUG
    857     dprintf(("DDRAW: EnumSurfaces4 NIY\n"));
    858   #endif
    859 
    860   return(DD_OK);
    861 }
    862 //******************************************************************************
    863 //******************************************************************************
    864 HRESULT __stdcall DrawFlipToGDISurface(THIS)
    865 {
    866   #ifdef DEBUG
    867     dprintf(("DDRAW: FlipToGDISurface NIY\n"));
    868   #endif
    869 
    870   return(DD_OK);
    871 }
    872 //******************************************************************************
    873 //******************************************************************************
    874 HRESULT __stdcall DrawGetCaps(THIS, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
    875 {
    876   DWORD dwSize;
    877 
    878   #ifdef DEBUG
    879     dprintf(("DDRAW: DDGetCaps of "));
    880   #endif
     852  dprintf(("DDRAW: EnumDisplayModes4 NIY\n"));
     853  return(DD_OK);
     854}
     855
     856//******************************************************************************
     857//******************************************************************************
     858HRESULT WIN32API DrawEnumSurfaces(THIS, DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK )
     859{
     860  dprintf(("DDRAW: EnumSurfaces NIY\n"));
     861
     862  return(DD_OK);
     863}
     864
     865//******************************************************************************
     866//******************************************************************************
     867HRESULT WIN32API DrawEnumSurfaces4(THIS, DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 )
     868{
     869  dprintf(("DDRAW: EnumSurfaces4 NIY\n"));
     870
     871  return(DD_OK);
     872}
     873
     874//******************************************************************************
     875//******************************************************************************
     876HRESULT WIN32API DrawFlipToGDISurface(THIS)
     877{
     878  dprintf(("DDRAW: FlipToGDISurface NIY\n"));
     879
     880  return(DD_OK);
     881}
     882
     883//******************************************************************************
     884//******************************************************************************
     885HRESULT WIN32API DrawGetCaps(THIS This, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
     886{
     887 DWORD dwSize;
     888 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
     889
     890  dprintf(("DDRAW: DDGetCaps %x %x %x", This, lpDDDriverCaps, lpDDHELCaps));
    881891
    882892  if( (NULL==lpDDDriverCaps) && (NULL==lpDDHELCaps) )
    … …  
    910920    // Now report the CAPs back which we support
    911921    lpDDDriverCaps->dwCaps = DDCAPS_BLT |              // We do blitting
     922                             DDCAPS_BLTSTRETCH |
    912923                             DDCAPS_BLTCOLORFILL |     // We do colorfills
     924                             DDCAPS_BLTDEPTHFILL |
    913925                             DDCAPS_COLORKEY |         // We support Colorkeying
    914926                             DDCAPS_COLORKEYHWASSIST | // But we (may) use the CPU
    915927                             DDCAPS_GDI |              // Maybe check if we are on Voodoo ?
    916                              DDCAPS_PALETTEVSYNC;      // Got VSync
     928                             DDCAPS_PALETTEVSYNC |     // Got VSync
     929//                             DDCAPS_READSCANLINE |
     930                             DDCAPS_BLTFOURCC;
    917931
    918932    lpDDDriverCaps->dwCaps2 = DDCAPS2_CERTIFIED |         // Who cares so say yes
    919                               //DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
     933                              DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
    920934                              DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
    921935                              DDCAPS2_NONLOCALVIDMEM |    // All surfaces are in memory
    … …  
    924938    lpDDDriverCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
    925939
    926 //    lpDDDriverCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN; // DIVE supports this, do we also ?
     940    lpDDDriverCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN |
     941                               DDFXCAPS_BLTMIRRORLEFTRIGHT; // DIVE supports this, do we also ?
    927942                                                         // Maybe later add stretching support?
    928943
    … …  
    931946                                DDPCAPS_VSYNC  |        // Vsync yet
    932947                                DDPCAPS_PRIMARYSURFACE; //
    933     lpDDDriverCaps->dwVidMemTotal = 4096*1024;          // total video memory
    934     lpDDDriverCaps->dwVidMemFree  = 4096*1024;          // total free video memory
    935     lpDDDriverCaps->dwNumFourCCCodes;        // number of supported FOURCC codes
     948    lpDDDriverCaps->dwVidMemTotal = me->dCaps.ulApertureSize;          // total video memory
     949    lpDDDriverCaps->dwVidMemFree  = me->dCaps.ulApertureSize;          // total free video memory
     950    lpDDDriverCaps->dwNumFourCCCodes = MAX_FOURCC_CODES;        // number of supported FOURCC codes
    936951/*
    937952    ToDo: must finde out ow the array is used for this
    … …  
    10331048  {
    10341049    // Caller wants HEL Caps
    1035     dprintf(("DDRAW:  HEL\n"));
    1036 
    1037     if(sizeof(DDCAPS)!=lpDDHELCaps->dwSize)
    1038     {
    1039       dprintf(("DDRAW: Size Not Set\n"));
     1050    dprintf(("DDRAW: CHEL\n"));
     1051
     1052    //SvL: PowerDVD uses size 316
     1053    if( (sizeof(DDCAPS)     != lpDDHELCaps->dwSize) &&
     1054        (sizeof(DDCAPS_DX5) != lpDDHELCaps->dwSize) &&
     1055        (sizeof(DDCAPS_DX3) != lpDDHELCaps->dwSize) )
     1056    {
     1057      dprintf( ("Size %d Not supported ",
     1058                lpDDHELCaps->dwSize));
    10401059      return(DDERR_INVALIDPARAMS);
    10411060    }
    10421061    // Clear structure so we only have to set the supported flags
    10431062
    1044 
    1045     memset(lpDDHELCaps,0,sizeof(DDCAPS));
    1046 
     1063    dwSize = lpDDHELCaps->dwSize;
     1064    memset( lpDDHELCaps,
     1065            0,
     1066            lpDDHELCaps->dwSize);
    10471067
    10481068    // Reset the size
    1049     lpDDHELCaps->dwSize = sizeof(DDCAPS);
     1069    lpDDHELCaps->dwSize = dwSize;
    10501070
    10511071    // Now report the CAPs back which we support
    10521072    lpDDHELCaps->dwCaps = DDCAPS_BLT |              // We do blitting
    1053                              DDCAPS_BLTCOLORFILL |     // We do colorfills
    1054                              DDCAPS_COLORKEY |         // We support Colorkeying
    1055                              DDCAPS_COLORKEYHWASSIST | // But we (may) use the CPU
    1056                              DDCAPS_GDI |              // Maybe check if we are on Voodoo ?
    1057                              DDCAPS_PALETTEVSYNC;      // Got VSync
     1073                          DDCAPS_BLTCOLORFILL |     // We do colorfills
     1074                          DDCAPS_COLORKEY |         // We support Colorkeying
     1075//SvL: This is the emulation layer; no hw support here
     1076//                          DDCAPS_COLORKEYHWASSIST | // But we (may) use the CPU
     1077                          DDCAPS_GDI |              // Maybe check if we are on Voodoo ?
     1078                          DDCAPS_PALETTEVSYNC |     // Got VSync
     1079                          DDCAPS_BLTFOURCC;
    10581080
    10591081    lpDDHELCaps->dwCaps2 = DDCAPS2_CERTIFIED |         // Who cares so say yes
    1060                               DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
    1061                               DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
    1062                               DDCAPS2_NONLOCALVIDMEM |    // All surfaces are in memory
    1063                               DDCAPS2_WIDESURFACES;       // Any size you want!
     1082                           DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
     1083                           DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
     1084                           DDCAPS2_NONLOCALVIDMEM |    // All surfaces are in memory
     1085                           DDCAPS2_WIDESURFACES;       // Any size you want!
    10641086
    10651087    lpDDHELCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
    10661088
    1067 //    lpDDDriverCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN; // DIVE supports this, do we also ?
     1089    lpDDHELCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN |
     1090                            DDFXCAPS_BLTMIRRORLEFTRIGHT; // DIVE supports this, do we also ?
    10681091                                                         // Maybe later add stretching support?
    10691092
    10701093    lpDDHELCaps->dwPalCaps = DDPCAPS_8BIT |          // Only 8 Bits pals
    1071                                 DDPCAPS_ALLOW256 |      // But all 256 colors
    1072                                 DDPCAPS_VSYNC  |        // Vsync yet
    1073                                 DDPCAPS_PRIMARYSURFACE; //
    1074     lpDDHELCaps->dwVidMemTotal = 2048*1024;           // total video memory
    1075     lpDDHELCaps->dwVidMemFree  = 2048*1024;            // total free video memory
    1076     lpDDHELCaps->dwNumFourCCCodes;        // number of supported FOURCC codes
     1094                             DDPCAPS_ALLOW256 |      // But all 256 colors
     1095                             DDPCAPS_VSYNC  |        // Vsync yet
     1096                             DDPCAPS_PRIMARYSURFACE;
     1097
     1098    //Video memory for emulation layer must be 0 (verified in NT)
     1099    lpDDHELCaps->dwVidMemTotal = 0;           // total video memory
     1100    lpDDHELCaps->dwVidMemFree  = 0;           // total free video memory
     1101
     1102    lpDDHELCaps->dwNumFourCCCodes = MAX_FOURCC_CODES;        // number of supported FOURCC codes
    10771103    lpDDHELCaps->dwRops[DD_ROP_SPACE];    // supported raster ops
    10781104    lpDDHELCaps->dwSVBCaps = DDCAPS_BLT |              // We do blitting
    … …  
    10971123    lpDDHELCaps->dwSSBFXCaps;            //  .
    10981124    lpDDHELCaps->dwSSBRops[DD_ROP_SPACE]; //  .
    1099     lpDDHELCaps->dwSVBCaps2 = DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
    1100                                  DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
    1101                                  DDCAPS2_WIDESURFACES;       // Any size you want!
    1102     lpDDHELCaps->dwNLVBCaps = DDCAPS_BLT |              // We do blitting
    1103                                  DDCAPS_BLTCOLORFILL |     // We do colorfills
    1104                                  DDCAPS_COLORKEY |         // We support Colorkeying
    1105                                  DDCAPS_COLORKEYHWASSIST;
    1106     lpDDHELCaps->dwNLVBCaps2 = DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
    1107                                   DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
    1108                                   DDCAPS2_WIDESURFACES;       // Any size you want!
    1109     lpDDHELCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
    1110     lpDDHELCaps->dwNLVBFXCaps;            //  .
    1111     lpDDHELCaps->dwNLVBRops[DD_ROP_SPACE];//  .
    1112 
    1113   }
    1114 
    1115   return(DD_OK);
    1116 }
    1117 //******************************************************************************
    1118 //******************************************************************************
    1119 HRESULT __stdcall DrawGetDisplayMode(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc)
     1125    // These are ony in >DX5
     1126    if(dwSize>sizeof(DDCAPS_DX3))
     1127    {
     1128      lpDDHELCaps->dwSVBCaps2 = DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
     1129                            DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
     1130                            DDCAPS2_WIDESURFACES;       // Any size you want!
     1131      lpDDHELCaps->dwNLVBCaps = DDCAPS_BLT |              // We do blitting
     1132                                  DDCAPS_BLTCOLORFILL |     // We do colorfills
     1133                                  DDCAPS_COLORKEY |         // We support Colorkeying
     1134                                  DDCAPS_COLORKEYHWASSIST;
     1135      lpDDHELCaps->dwNLVBCaps2 = DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
     1136                                   DDCAPS2_COPYFOURCC |        // yepp memcpy will do this
     1137                                   DDCAPS2_WIDESURFACES;       // Any size you want!
     1138      lpDDHELCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT;      // Only source transparent blitting
     1139      lpDDHELCaps->dwNLVBFXCaps;            //  .
     1140      lpDDHELCaps->dwNLVBRops[DD_ROP_SPACE];//  .
     1141    }
     1142
     1143  }
     1144
     1145  return(DD_OK);
     1146}
     1147//******************************************************************************
     1148//******************************************************************************
     1149HRESULT WIN32API DrawGetDisplayMode(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc)
    11201150{
    11211151  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    1122   #ifdef DEBUG
    1123     dprintf(("DDRAW: GetDisplayMode\n"));
    1124   #endif
     1152
     1153  dprintf(("DDRAW: GetDisplayMode %x %x", This, lpDDSurfaceDesc));
    11251154
    11261155  // Check Parameter
    … …  
    12231252      break;
    12241253    default:
    1225       #ifdef DEBUG
    1226         dprintf(("DDRAW: Unsupported mode\n"));
    1227       #endif
     1254      dprintf(("DDRAW: Unsupported mode\n"));
    12281255      return(DDERR_UNSUPPORTEDMODE);
    12291256  }
    … …  
    12331260//******************************************************************************
    12341261//******************************************************************************
    1235 HRESULT __stdcall DrawGetDisplayMode4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2)
     1262HRESULT WIN32API DrawGetDisplayMode4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2)
    12361263{
    12371264  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    1238   #ifdef DEBUG
    1239     dprintf(("DDRAW: GetDisplayMode\n"));
    1240   #endif
     1265
     1266  dprintf(("DDRAW: GetDisplayMode4 %x %x", This, lpDDSurfaceDesc2));
    12411267
    12421268  // Check Parameter
    … …  
    13391365      break;
    13401366    default:
    1341       #ifdef DEBUG
    1342         dprintf(("DDRAW: Unsupported mode\n"));
    1343       #endif
     1367      dprintf(("DDRAW: Unsupported mode\n"));
    13441368      return(DDERR_UNSUPPORTEDMODE);
    13451369  }
    … …  
    13491373//******************************************************************************
    13501374//******************************************************************************
    1351 HRESULT __stdcall DrawGetFourCCCodes(THIS, LPDWORD lpNumCodes, LPDWORD lpCodes)
    1352 {
    1353   DWORD dwFCC[3] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3};
    1354   #ifdef DEBUG
    1355     dprintf(("DDRAW: GetFourCCCodes\n"));
    1356   #endif
     1375HRESULT WIN32API DrawGetFourCCCodes(THIS This, LPDWORD lpNumCodes, LPDWORD lpCodes)
     1376{
     1377//  DWORD dwFCC[MAX_FOURCC_CODES] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3,FOURCC_YUY2};
     1378  DWORD dwFCC[MAX_FOURCC_CODES] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3};
     1379
     1380  dprintf(("DDRAW: GetFourCCCodes %x %x %x", This, lpNumCodes, lpCodes));
    13571381
    13581382  if(NULL==lpNumCodes)
    … …  
    13611385  if(NULL==lpCodes)
    13621386  {
    1363     *lpNumCodes = 3; // LUT8, R565, RGB3 are the FourCC we support for now
     1387    *lpNumCodes = MAX_FOURCC_CODES; // LUT8, R565, RGB3 are the FourCC we support for now
    13641388  }
    13651389  else
    13661390  {
    1367     for(int i=0;(i<3)&&(i<*lpNumCodes);i++)
     1391    for(int i=0;(i<MAX_FOURCC_CODES)&&(i<*lpNumCodes);i++)
    13681392    {
    13691393      *lpCodes = dwFCC[i];
    1370       lpCodes +=4;
    1371     }
    1372     if(*lpNumCodes < 3)
    1373       *lpNumCodes = 3;
    1374   }
    1375   return(DD_OK);
    1376 }
    1377 //******************************************************************************
    1378 //******************************************************************************
    1379 HRESULT __stdcall DrawGetGDISurface(THIS, LPDIRECTDRAWSURFACE FAR *)
    1380 {
    1381   #ifdef DEBUG
    1382     dprintf(("DDRAW: GetGDISurface NYI\n"));
    1383   #endif
    1384 
    1385   return(DD_OK);
    1386 }
    1387 //******************************************************************************
    1388 //******************************************************************************
    1389 HRESULT __stdcall DrawGetGDISurface4(THIS, LPDIRECTDRAWSURFACE4 FAR *)
    1390 {
    1391   #ifdef DEBUG
    1392     dprintf(("DDRAW: GetGDISurface NYI\n"));
    1393   #endif
    1394 
    1395   return(DD_OK);
    1396 }
    1397 //******************************************************************************
    1398 //******************************************************************************
    1399 HRESULT __stdcall DrawGetMonitorFrequency(THIS This, LPDWORD lpdwFreq)
     1394      lpCodes++;
     1395    }
     1396    *lpNumCodes = MAX_FOURCC_CODES;
     1397  }
     1398  return(DD_OK);
     1399}
     1400//******************************************************************************
     1401//******************************************************************************
     1402HRESULT WIN32API DrawGetGDISurface(THIS, LPDIRECTDRAWSURFACE FAR *)
     1403{
     1404  dprintf(("DDRAW: GetGDISurface NYI\n"));
     1405
     1406  return(DD_OK);
     1407}
     1408//******************************************************************************
     1409//******************************************************************************
     1410HRESULT WIN32API DrawGetGDISurface4(THIS, LPDIRECTDRAWSURFACE4 FAR *)
     1411{
     1412  dprintf(("DDRAW: GetGDISurface NYI\n"));
     1413
     1414  return(DD_OK);
     1415}
     1416//******************************************************************************
     1417//******************************************************************************
     1418HRESULT WIN32API DrawGetMonitorFrequency(THIS This, LPDWORD lpdwFreq)
    14001419{
    14011420  ULONG ulTime1, ulTime2;
    14021421  DWORD dwFlags = DDWAITVB_BLOCKBEGIN;
    1403   #ifdef DEBUG
    1404     dprintf(("DDRAW: GetMonitorFrequency\n"));
    1405   #endif
     1422  dprintf(("DDRAW: GetMonitorFrequency\n"));
    14061423  if(NULL==lpdwFreq)
    14071424    return(DDERR_INVALIDPARAMS);
    … …  
    14361453//******************************************************************************
    14371454//******************************************************************************
    1438 HRESULT __stdcall DrawGetScanLine(THIS, LPDWORD lpdwLine)
    1439 {
    1440   BOOL bVertBlank;
    1441   #ifdef DEBUG
    1442     dprintf(("DDRAW: GetScanLine\n"));
    1443   #endif
     1455HRESULT WIN32API DrawGetScanLine(THIS, LPDWORD lpdwLine)
     1456{
     1457//  BOOL bVertBlank;
     1458  dprintf(("DDRAW: GetScanLine\n"));
    14441459  // ToDO find a way to get this position, so for now simply return DDERR_UNSUPPORTED
    14451460  // as we indicated in DDCAPS we don't support this.
    … …  
    14601475//******************************************************************************
    14611476//******************************************************************************
    1462 HRESULT __stdcall DrawGetVerticalBlankStatus(THIS , LPBOOL lpbIsInVB)
    1463 {
    1464   int rc;
    1465   #ifdef DEBUG
    1466     dprintf(("DDRAW: GetVerticalBlankStatus\n"));
    1467   #endif
     1477HRESULT WIN32API DrawGetVerticalBlankStatus(THIS , LPBOOL lpbIsInVB)
     1478{
     1479//  int rc;
     1480  dprintf(("DDRAW: GetVerticalBlankStatus\n"));
    14681481  if(NULL==lpbIsInVB)
    14691482    return(DDERR_INVALIDPARAMS);
    14701483
    1471 
     1484  #if 0
    14721485    rc = io_init1();
    14731486
    … …  
    14811494    return(DD_OK);
    14821495  }
    1483 
     1496  #else
     1497    *lpbIsInVB = ! (*lpbIsInVB);
     1498  #endif
    14841499  return(DDERR_UNSUPPORTED);
    14851500}
    14861501//******************************************************************************
    14871502//******************************************************************************
    1488 HRESULT __stdcall DrawInitialize(THIS, GUID FAR *)
    1489 {
    1490   #ifdef DEBUG
    1491     dprintf(("DDRAW: Initialize\n"));
    1492   #endif
    1493 
    1494   return(DD_OK);
    1495 }
    1496 //******************************************************************************
    1497 //******************************************************************************
    1498 HRESULT __stdcall DrawRestoreDisplayMode(THIS This)
     1503HRESULT WIN32API DrawInitialize(THIS, GUID FAR *)
     1504{
     1505  dprintf(("DDRAW: Initialize\n"));
     1506
     1507  return(DD_OK);
     1508}
     1509//******************************************************************************
     1510//******************************************************************************
     1511HRESULT WIN32API DrawRestoreDisplayMode(THIS This)
    14991512{
    15001513  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    1501   ULONG ulModeInd;
    1502 
    1503   #ifdef DEBUG
    1504     dprintf(("DDRAW: RestoreDisplayMode\n"));
    1505   #endif
    1506        /* restore previous screen mode */
     1514
     1515  dprintf(("DDRAW: RestoreDisplayMode"));
     1516
     1517  // FSDDRAW additions
     1518  ULONG  ulModeInd;
     1519  /* restore previous screen mode */
    15071520  if ((me->bPMILoaded) && (me->bInFullScreen))
    15081521  {
    … …  
    15151528    me->dCaps.ulDepth                = me->oldbpp;
    15161529  }
    1517   return(DD_OK);
    1518 }
    1519 //******************************************************************************
    1520 //******************************************************************************
    1521 HRESULT __stdcall DrawSetCooperativeLevel(THIS This, HWND hwndClient, DWORD dwFlags)
     1530
     1531  return(DD_OK);
     1532}
     1533//******************************************************************************
     1534//******************************************************************************
     1535HRESULT WIN32API DrawSetCooperativeLevel(THIS This, HWND hwndClient, DWORD dwFlags)
    15221536{
    15231537 OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    15241538
    1525   #ifdef DEBUG
    1526     dprintf(("DDRAW: SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
    1527   #endif
     1539  dprintf(("DDRAW: SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
    15281540  me->dwCoopMode = dwFlags;
    15291541  if(!(DDSCL_NORMAL & dwFlags))
    … …  
    15421554//Backwards compatibility, what's that??
    15431555//******************************************************************************
    1544 HRESULT __stdcall DrawSetDisplayMode2(THIS This, DWORD dwWidth, DWORD dwHeight,
     1556HRESULT WIN32API DrawSetDisplayMode2(THIS This, DWORD dwWidth, DWORD dwHeight,
    15451557              DWORD dwBPP, DWORD dwRefreshRate,
    15461558              DWORD dwFlags)
    … …  
    15501562 SETUP_BLITTER sBlt;
    15511563
    1552   #ifdef DEBUG
    1553     dprintf(("DDRAW: SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
    1554   #endif
     1564  dprintf(("DDRAW: SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
    15551565
    15561566  me->screenwidth  = dwWidth;
    … …  
    15601570  if(me->dwCoopMode & DDSCL_FULLSCREEN)
    15611571  {
    1562     SetWindowPos(me->hwndClient, HWND_TOP, 0, 0, dwWidth, dwHeight, 0);
     1572    // FSDDRAW additions
     1573    ULONG  ulModeInd;
     1574
     1575    SetWindowPos(me->hwndClient, HWND_TOP,0,0,dwWidth,dwHeight,0);
     1576    SetCursorPos(dwWidth / 2, dwHeight / 2);
     1577
     1578    if ((me->bPMILoaded) && (ModeInSVGAModeTable(dwWidth,dwHeight,dwBPP)))
     1579    {
     1580      KillPM();
     1581
     1582      rc=SetSVGAMode(dwWidth, dwHeight, dwBPP, 0xFF, &ulModeInd, NULL);
     1583
     1584      if (!rc) // When mode switched successfully
     1585      {
     1586        /* save old screen values */
     1587        me->bInFullScreen=TRUE;
     1588        me->oldwidth     = me->dCaps.ulHorizontalResolution;
     1589        me->oldheight    = me->dCaps.ulVerticalResolution;
     1590        me->oldscanlines = me->dCaps.ulScanLineBytes;
     1591        me->oldbpp       = me->dCaps.ulDepth;
     1592
     1593        /* now 'fix' some DIVE caps entries */
     1594        me->dCaps.ulScanLineBytes        = dwWidth * (dwBPP >> 3); /* FIX: use real value */
     1595        me->dCaps.ulHorizontalResolution = dwWidth;
     1596        me->dCaps.ulVerticalResolution   = dwHeight;
     1597        me->dCaps.ulDepth                = dwBPP;
     1598      }
     1599      else
     1600      // Display must be return to PM Session
     1601      RestorePM();
     1602    }
    15631603  }
    15641604
    … …  
    15811621  rc = DiveSetupBlitter( me->hDive,
    15821622                         &sBlt);
    1583 
    1584   return(DD_OK);
    1585 }
    1586 //******************************************************************************
    1587 //******************************************************************************
    1588 HRESULT __stdcall DrawSetDisplayMode(THIS This, DWORD dwWidth, DWORD dwHeight,
     1623  dprintf(("       DiveSetupBlitter rc=%d",rc));
     1624
     1625  return(DD_OK);
     1626}
     1627//******************************************************************************
     1628//******************************************************************************
     1629HRESULT WIN32API DrawSetDisplayMode(THIS This, DWORD dwWidth, DWORD dwHeight,
    15891630             DWORD dwBPP)
    15901631{
    15911632 ULONG rc;
    1592  ULONG ulModeInd;
    1593 
    15941633 OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    15951634 SETUP_BLITTER sBlt;
    15961635
    1597 #ifdef DEBUG
    15981636  dprintf(("DDRAW: SetDisplayMode to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
    1599 #endif
     1637
    16001638  me->screenwidth  = dwWidth;
    16011639  me->screenheight = dwHeight;
    … …  
    16041642  if(me->dwCoopMode & DDSCL_FULLSCREEN)
    16051643  {
    1606       SetWindowPos(me->hwndClient, HWND_TOP,0,0,dwWidth,dwHeight,0);
    1607       SetCursorPos(dwWidth / 2, dwHeight / 2);
     1644    // FSDDRAW additions
     1645    ULONG  ulModeInd;
     1646
     1647    SetWindowPos(me->hwndClient, HWND_TOP,0,0,dwWidth,dwHeight,0);
     1648    SetCursorPos(dwWidth / 2, dwHeight / 2);
    16081649
    16091650    if ((me->bPMILoaded) && (ModeInSVGAModeTable(dwWidth,dwHeight,dwBPP)))
    … …  
    16331674    }
    16341675  }
     1676
    16351677  memset(&sBlt,0,sizeof(sBlt));
    16361678  sBlt.ulStructLen = sizeof(sBlt);
    … …  
    16511693  rc = DiveSetupBlitter( me->hDive,
    16521694                         &sBlt);
    1653 
    1654   dprintf(("Mode set successful!\n"));
    1655   return(DD_OK);
    1656 }
    1657 //******************************************************************************
    1658 //******************************************************************************
    1659 HRESULT __stdcall DrawWaitForVerticalBlank(THIS, DWORD dwFlags, HANDLE hEvent)
    1660 {
    1661   HRESULT rc;
    1662   int rci;
    1663   USHORT sel;
     1695  dprintf(("       DiveSetupBlitter rc=%d",rc));
     1696
     1697  return(DD_OK);
     1698}
     1699//******************************************************************************
     1700//******************************************************************************
     1701HRESULT WIN32API DrawWaitForVerticalBlank(THIS, DWORD dwFlags, HANDLE hEvent)
     1702{
     1703//  HRESULT rc;
     1704//  int rci;
     1705//  USHORT sel;
    16641706  dprintf(("DDRAW: WaitForVerticalBlank\n"));
    16651707
    … …  
    16691711  return DD_OK;
    16701712
     1713#if 0
    16711714  rci = InitIO();
    16721715
    … …  
    17111754
    17121755  return (rc);
    1713 
    1714 }
     1756#endif
     1757}
     1758
    17151759//******************************************************************************
    17161760//*** Added in the v2 interface ***
    17171761//******************************************************************************
    1718 HRESULT __stdcall DrawGetAvailableVidMem(THIS, LPDDSCAPS lpDDSCaps,
     1762HRESULT WIN32API DrawGetAvailableVidMem(THIS, LPDDSCAPS lpDDSCaps,
    17191763                                         LPDWORD lpdwTotal, LPDWORD lpdwFree)
    17201764{
    1721   #ifdef DEBUG
    1722     dprintf(("DDRAW: GetAvailableVidMem\n"));
    1723   #endif
     1765  dprintf(("DDRAW: GetAvailableVidMem\n"));
    17241766
    17251767  // Check parameters
    … …  
    17411783//
    17421784//******************************************************************************
    1743 HRESULT __stdcall DrawGetAvailableVidMem4(THIS, LPDDSCAPS2 lpDDSCaps2,
     1785HRESULT WIN32API DrawGetAvailableVidMem4(THIS, LPDDSCAPS2 lpDDSCaps2,
    17441786                                         LPDWORD lpdwTotal, LPDWORD lpdwFree)
    17451787{
    1746   #ifdef DEBUG
    1747     dprintf(("DDRAW: GetAvailableVidMem\n"));
    1748   #endif
     1788  dprintf(("DDRAW: GetAvailableVidMem\n"));
    17491789
    17501790  // Check parameters
    … …  
    17661806//*** Added in the v4 interface ***
    17671807//******************************************************************************
    1768 HRESULT __stdcall DrawGetSurfaceFromDC(THIS, HDC hdc, LPDIRECTDRAWSURFACE4 *)
    1769 {
    1770   #ifdef DEBUG
    1771     dprintf(("DDRAW: GetSurfaceFromDC NYI\n"));
    1772   #endif
    1773 
    1774   return(DD_OK);
    1775 }
    1776 //******************************************************************************
    1777 //******************************************************************************
    1778 HRESULT __stdcall DrawRestoreAllSurfaces(THIS)
    1779 {
    1780   #ifdef DEBUG
    1781     dprintf(("DDRAW: RestoreAllSurfaces\n"));
    1782   #endif
    1783 
    1784   return(DD_OK);
    1785 }
    1786 //******************************************************************************
    1787 //******************************************************************************
    1788 HRESULT __stdcall DrawTestCooperativeLevel(THIS)
    1789 {
    1790   #ifdef DEBUG
    1791     dprintf(("DDRAW: TestCooperativeLevel\n"));
    1792   #endif
    1793 
    1794   return(DD_OK);
    1795 }
    1796 //******************************************************************************
    1797 //******************************************************************************
    1798 HRESULT __stdcall DrawGetDeviceIdentifier( THIS, LPDDDEVICEIDENTIFIER lpdddi,
     1808HRESULT WIN32API DrawGetSurfaceFromDC(THIS, HDC hdc, LPDIRECTDRAWSURFACE4 *)
     1809{
     1810  dprintf(("DDRAW: GetSurfaceFromDC NYI\n"));
     1811
     1812  return(DD_OK);
     1813}
     1814//******************************************************************************
     1815//******************************************************************************
     1816HRESULT WIN32API DrawRestoreAllSurfaces(THIS)
     1817{
     1818  dprintf(("DDRAW: RestoreAllSurfaces\n"));
     1819
     1820  return(DD_OK);
     1821}
     1822//******************************************************************************
     1823//******************************************************************************
     1824HRESULT WIN32API DrawTestCooperativeLevel(THIS)
     1825{
     1826  dprintf(("DDRAW: TestCooperativeLevel\n"));
     1827
     1828  return(DD_OK);
     1829}
     1830//******************************************************************************
     1831//******************************************************************************
     1832HRESULT WIN32API DrawGetDeviceIdentifier( THIS, LPDDDEVICEIDENTIFIER lpdddi,
    17991833                                           DWORD dwFlags)
    18001834{
    1801   #ifdef DEBUG
    1802     dprintf(("DDRAW: GetDeviceIdentifier Flags = %d\n",dwFlags));
    1803   #endif
     1835  dprintf(("DDRAW: GetDeviceIdentifier Flags = %d\n",dwFlags));
    18041836  if(NULL==lpdddi)
    18051837    return DDERR_INVALIDPARAMS;
Note: See TracChangeset for help on using the changeset viewer.