Changeset 5291 for trunk/src


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

Updates/cleanup for Watcom (not complete)

Location:
trunk/src/ddraw
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ddraw/OS2D3D.CPP

    r4136 r5291  
    1 /* $Id: OS2D3D.CPP,v 1.10 2000-08-31 17:57:09 sandervl Exp $ */
     1/* $Id: OS2D3D.CPP,v 1.11 2001-03-09 22:48:46 mike Exp $ */
    22
    33/*
    … …  
    2323#include <misc.h>
    2424#include <winerror.h>
    25 #include <builtin.h>
    2625#undef THIS
    2726#define THIS VOID*
    … …  
    3433  *ppvObj = NULL;
    3534
    36   if(IID_IDirect3D != (GUID &)&riid)
     35  if (!IsEqualGUID(riid, IID_IDirect3D))
    3736    return E_NOINTERFACE;
    3837

  • trunk/src/ddraw/OS2DDRAW.CPP

    r4139 r5291  
    1 /* $Id: OS2DDRAW.CPP,v 1.24 2000-08-31 21:03:14 sandervl Exp $ */
     1/* $Id: OS2DDRAW.CPP,v 1.25 2001-03-09 22:48:46 mike Exp $ */
    22
    33/*
    … …  
    1010 *
    1111 */
     12
    1213#include <stdlib.h>
    1314#include <string.h>
    … …  
    2627#include <winuser.h>
    2728#include <winerror.h>
    28 #include <builtin.h>
    2929#include "cio2.h"
    3030#include "os2util.h"
    … …  
    302302 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
    303303
    304   #ifdef DEBUG
    305     dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
    306   #endif
     304  dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
    307305
    308306  return ++me->Referenced;
    … …  
    315313 ULONG rc;
    316314
    317   #ifdef DEBUG
    318     dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
    319     dprintf(("DDRAW: OS2IDirectDraw::%X \n", me));
    320   #endif
     315  dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
     316  dprintf(("DDRAW: OS2IDirectDraw::%X \n", me));
    321317
    322318  if(me->Referenced)
    … …  
    341337HRESULT WIN32API DrawCompact(THIS)
    342338{
    343   #ifdef DEBUG
    344     dprintf(("DDRAW: Compact\n"));
    345   #endif
     339  dprintf(("DDRAW: Compact\n"));
    346340
    347341  return(DD_OK);
    … …  
    357351  newclip = new OS2IDirectDrawClipper(me);
    358352
    359   #ifdef DEBUG
    360     dprintf(("DDRAW: CreateClipper\n"));
    361   #endif
     353  dprintf(("DDRAW: CreateClipper\n"));
    362354
    363355  if(newclip == NULL)
    … …  
    413405  if(DD_OK == rc)
    414406  {
    415     #ifdef DEBUG
    416       dprintf(("DDRAW: CreatePalette with %d colors\n", palsize));
    417     #endif
     407    dprintf(("DDRAW: CreatePalette with %d colors\n", palsize));
    418408
    419409    newpal = new OS2IDirectDrawPalette((VOID*)me, palsize, lpColorTable, dwFlags);
    … …  
    450440 HRESULT                rc;
    451441
    452   #ifdef DEBUG
    453     dprintf(("DDRAW: CreateSurface\n"));
    454     dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc->dwSize));
    455     dprintf(("DDRAW: dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
    456     dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
    457     dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
    458     dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc->lPitch));
    459     dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
    460     dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
    461     dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
    462     dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
    463   #endif
     442  dprintf(("DDRAW: CreateSurface\n"));
     443  dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc->dwSize));
     444  dprintf(("DDRAW: dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
     445  dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
     446  dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
     447  dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc->lPitch));
     448  dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
     449  dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
     450  dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
     451  dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
    464452
    465453  newsurf = new OS2IDirectDrawSurface(me, (LPDDSURFACEDESC2)lpDDSurfaceDesc);
    … …  
    496484 HRESULT                rc;
    497485
    498   #ifdef DEBUG
    499     dprintf(("DDRAW: CreateSurface4\n"));
    500     dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc2->dwSize));
    501     dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
    502     dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
    503     dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc2->lPitch));
    504     dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
    505     dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
    506     dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
    507     dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
    508   #endif
     486  dprintf(("DDRAW: CreateSurface4\n"));
     487  dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc2->dwSize));
     488  dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
     489  dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
     490  dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc2->lPitch));
     491  dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
     492  dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
     493  dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
     494  dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
    509495
    510496  newsurf = new OS2IDirectDrawSurface(me, lpDDSurfaceDesc2);
    … …  
    537523HRESULT WIN32API DrawDuplicateSurface(THIS, LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * )
    538524{
    539   #ifdef DEBUG
    540     dprintf(("DDRAW: DuplicateSurface NIY\n"));
    541   #endif
     525  dprintf(("DDRAW: DuplicateSurface NIY\n"));
     526
    542527  return(DD_OK);
    543528}
    … …  
    546531HRESULT WIN32API DrawDuplicateSurface4(THIS, LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * )
    547532{
    548   #ifdef DEBUG
    549     dprintf(("DDRAW: DuplicateSurface4 NIY\n"));
    550   #endif
     533  dprintf(("DDRAW: DuplicateSurface4 NIY\n"));
    551534
    552535  return(DD_OK);
    … …  
    565548  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    566549
    567   #ifdef DEBUG
    568     dprintf(("DDRAW: EnumDisplayModes\n"));
    569   #endif
     550  dprintf(("DDRAW: EnumDisplayModes\n"));
    570551
    571552  // Check for Pointer to callback function
    572553  if (NULL == lpDDEnumModesCallback)
    573554  {
    574     #ifdef DEBUG
    575       dprintf(("DDRAW: EnumDisplayModes : Error NO EnumFunction passed in\n"));
    576     #endif
     555    dprintf(("DDRAW: EnumDisplayModes : Error NO EnumFunction passed in\n"));
    577556
    578557    return(DDERR_GENERIC);
    … …  
    595574    // DIVE modes
    596575
    597     #ifdef DEBUG
    598       dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
    599     #endif
     576    dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
    600577
    601578    // Enumerate all modes ?
    … …  
    604581      // Check if we shall report 320x200 mode
    605582
    606       #ifdef DEBUG
    607         dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
    608       #endif
     583      dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
    609584
    610585      if(dwFlags && DDEDM_STANDARDVGAMODES)
    611586      {
    612         #ifdef DEBUG
    613           dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
    614         #endif
     587        dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
     588
    615589        DDSurfAct.dwHeight = ModesDive[0].iYRes;
    616590        DDSurfAct.dwWidth  = ModesDive[0].iXRes;
    … …  
    619593        if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
    620594        {
    621           #ifdef DEBUG
    622             dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
    623           #endif
     595          dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
    624596          return (DD_OK);
    625597        }
    … …  
    662634              break;
    663635          }
    664           #ifdef DEBUG
    665             dprintf( ("EnumDisplayModes : Enum Mode %dx%d @ %d\n",
    666                       DDSurfAct.dwHeight,
    667                       DDSurfAct.dwWidth,
    668                       DDSurfAct.ddpfPixelFormat.dwRGBBitCount));
    669           #endif
     636          dprintf( ("EnumDisplayModes : Enum Mode %dx%d @ %d\n",
     637                    DDSurfAct.dwHeight,
     638                    DDSurfAct.dwWidth,
     639                    DDSurfAct.ddpfPixelFormat.dwRGBBitCount));
    670640          fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
    671           #ifdef DEBUG
    672             dprintf( ("EnumDisplayModes : Callback returned with %d\n",
    673                       fCallAgain));
    674           #endif
     641          dprintf( ("EnumDisplayModes : Callback returned with %d\n",
     642                    fCallAgain));
    675643        }
    676644        iMode++;
    … …  
    852820{
    853821  int iMode = 0;
     822#if 0
    854823  DDSURFACEDESC DDSurfAct;
    855824  BOOL fCallAgain;
     825#endif
    856826  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    857827
    858   #ifdef DEBUG
    859     dprintf(("DDRAW: EnumDisplayModes4 NIY\n"));
    860   #endif
    861   return(DD_OK);
    862 }
     828  dprintf(("DDRAW: EnumDisplayModes4 NIY\n"));
     829  return(DD_OK);
     830}
     831
    863832//******************************************************************************
    864833//******************************************************************************
    865834HRESULT WIN32API DrawEnumSurfaces(THIS, DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK )
    866835{
    867   #ifdef DEBUG
    868     dprintf(("DDRAW: EnumSurfaces NIY\n"));
    869   #endif
    870 
    871   return(DD_OK);
    872 }
     836  dprintf(("DDRAW: EnumSurfaces NIY\n"));
     837
     838  return(DD_OK);
     839}
     840
    873841//******************************************************************************
    874842//******************************************************************************
    875843HRESULT WIN32API DrawEnumSurfaces4(THIS, DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 )
    876844{
    877   #ifdef DEBUG
    878     dprintf(("DDRAW: EnumSurfaces4 NIY\n"));
    879   #endif
    880 
    881   return(DD_OK);
    882 }
     845  dprintf(("DDRAW: EnumSurfaces4 NIY\n"));
     846
     847  return(DD_OK);
     848}
     849
    883850//******************************************************************************
    884851//******************************************************************************
    885852HRESULT WIN32API DrawFlipToGDISurface(THIS)
    886853{
    887   #ifdef DEBUG
    888     dprintf(("DDRAW: FlipToGDISurface NIY\n"));
    889   #endif
    890 
    891   return(DD_OK);
    892 }
     854  dprintf(("DDRAW: FlipToGDISurface NIY\n"));
     855
     856  return(DD_OK);
     857}
     858
    893859//******************************************************************************
    894860//******************************************************************************
    … …  
    12621228      break;
    12631229    default:
    1264       #ifdef DEBUG
    1265         dprintf(("DDRAW: Unsupported mode\n"));
    1266       #endif
     1230      dprintf(("DDRAW: Unsupported mode\n"));
    12671231      return(DDERR_UNSUPPORTEDMODE);
    12681232  }
    … …  
    13771341      break;
    13781342    default:
    1379       #ifdef DEBUG
    1380         dprintf(("DDRAW: Unsupported mode\n"));
    1381       #endif
     1343      dprintf(("DDRAW: Unsupported mode\n"));
    13821344      return(DDERR_UNSUPPORTEDMODE);
    13831345  }
    … …  
    14161378HRESULT WIN32API DrawGetGDISurface(THIS, LPDIRECTDRAWSURFACE FAR *)
    14171379{
    1418   #ifdef DEBUG
    1419     dprintf(("DDRAW: GetGDISurface NYI\n"));
    1420   #endif
     1380  dprintf(("DDRAW: GetGDISurface NYI\n"));
    14211381
    14221382  return(DD_OK);
    … …  
    14261386HRESULT WIN32API DrawGetGDISurface4(THIS, LPDIRECTDRAWSURFACE4 FAR *)
    14271387{
    1428   #ifdef DEBUG
    1429     dprintf(("DDRAW: GetGDISurface NYI\n"));
    1430   #endif
     1388  dprintf(("DDRAW: GetGDISurface NYI\n"));
    14311389
    14321390  return(DD_OK);
    … …  
    14381396  ULONG ulTime1, ulTime2;
    14391397  DWORD dwFlags = DDWAITVB_BLOCKBEGIN;
    1440   #ifdef DEBUG
    1441     dprintf(("DDRAW: GetMonitorFrequency\n"));
    1442   #endif
     1398  dprintf(("DDRAW: GetMonitorFrequency\n"));
    14431399  if(NULL==lpdwFreq)
    14441400    return(DDERR_INVALIDPARAMS);
    … …  
    14751431HRESULT WIN32API DrawGetScanLine(THIS, LPDWORD lpdwLine)
    14761432{
    1477   BOOL bVertBlank;
    1478   #ifdef DEBUG
    1479     dprintf(("DDRAW: GetScanLine\n"));
    1480   #endif
     1433//  BOOL bVertBlank;
     1434  dprintf(("DDRAW: GetScanLine\n"));
    14811435  // ToDO find a way to get this position, so for now simply return DDERR_UNSUPPORTED
    14821436  // as we indicated in DDCAPS we don't support this.
    … …  
    14991453HRESULT WIN32API DrawGetVerticalBlankStatus(THIS , LPBOOL lpbIsInVB)
    15001454{
    1501   int rc;
    1502   #ifdef DEBUG
    1503     dprintf(("DDRAW: GetVerticalBlankStatus\n"));
    1504   #endif
     1455//  int rc;
     1456  dprintf(("DDRAW: GetVerticalBlankStatus\n"));
    15051457  if(NULL==lpbIsInVB)
    15061458    return(DDERR_INVALIDPARAMS);
    … …  
    15271479HRESULT WIN32API DrawInitialize(THIS, GUID FAR *)
    15281480{
    1529   #ifdef DEBUG
    1530     dprintf(("DDRAW: Initialize\n"));
    1531   #endif
     1481  dprintf(("DDRAW: Initialize\n"));
    15321482
    15331483  return(DD_OK);
    … …  
    15371487HRESULT WIN32API DrawRestoreDisplayMode(THIS)
    15381488{
    1539   #ifdef DEBUG
    1540     dprintf(("DDRAW: RestoreDisplayMod\n"));
    1541   #endif
     1489  dprintf(("DDRAW: RestoreDisplayMod\n"));
    15421490
    15431491  return(DD_OK);
    … …  
    15491497 OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    15501498
    1551   #ifdef DEBUG
    1552     dprintf(("DDRAW: SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
    1553   #endif
     1499  dprintf(("DDRAW: SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
    15541500  me->dwCoopMode = dwFlags;
    15551501  if(!(DDSCL_NORMAL & dwFlags))
    … …  
    15761522 SETUP_BLITTER sBlt;
    15771523
    1578   #ifdef DEBUG
    1579     dprintf(("DDRAW: SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
    1580   #endif
     1524  dprintf(("DDRAW: SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
    15811525
    15821526  me->screenwidth  = dwWidth;
    … …  
    16571601HRESULT WIN32API DrawWaitForVerticalBlank(THIS, DWORD dwFlags, HANDLE hEvent)
    16581602{
    1659   HRESULT rc;
    1660   int rci;
    1661   USHORT sel;
     1603//  HRESULT rc;
     1604//  int rci;
     1605//  USHORT sel;
    16621606  dprintf(("DDRAW: WaitForVerticalBlank\n"));
    16631607
    … …  
    16671611  return DD_OK;
    16681612
     1613#if 0
    16691614  rci = InitIO();
    16701615
    … …  
    17091654
    17101655  return (rc);
    1711 
    1712 }
     1656#endif
     1657}
     1658
    17131659//******************************************************************************
    17141660//*** Added in the v2 interface ***
    … …  
    17171663                                         LPDWORD lpdwTotal, LPDWORD lpdwFree)
    17181664{
    1719   #ifdef DEBUG
    1720     dprintf(("DDRAW: GetAvailableVidMem\n"));
    1721   #endif
     1665  dprintf(("DDRAW: GetAvailableVidMem\n"));
    17221666
    17231667  // Check parameters
    … …  
    17421686                                         LPDWORD lpdwTotal, LPDWORD lpdwFree)
    17431687{
    1744   #ifdef DEBUG
    1745     dprintf(("DDRAW: GetAvailableVidMem\n"));
    1746   #endif
     1688  dprintf(("DDRAW: GetAvailableVidMem\n"));
    17471689
    17481690  // Check parameters
    … …  
    17661708HRESULT WIN32API DrawGetSurfaceFromDC(THIS, HDC hdc, LPDIRECTDRAWSURFACE4 *)
    17671709{
    1768   #ifdef DEBUG
    1769     dprintf(("DDRAW: GetSurfaceFromDC NYI\n"));
    1770   #endif
     1710  dprintf(("DDRAW: GetSurfaceFromDC NYI\n"));
    17711711
    17721712  return(DD_OK);
    … …  
    17761716HRESULT WIN32API DrawRestoreAllSurfaces(THIS)
    17771717{
    1778   #ifdef DEBUG
    1779     dprintf(("DDRAW: RestoreAllSurfaces\n"));
    1780   #endif
     1718  dprintf(("DDRAW: RestoreAllSurfaces\n"));
    17811719
    17821720  return(DD_OK);
    … …  
    17861724HRESULT WIN32API DrawTestCooperativeLevel(THIS)
    17871725{
    1788   #ifdef DEBUG
    1789     dprintf(("DDRAW: TestCooperativeLevel\n"));
    1790   #endif
     1726  dprintf(("DDRAW: TestCooperativeLevel\n"));
    17911727
    17921728  return(DD_OK);
    … …  
    17971733                                           DWORD dwFlags)
    17981734{
    1799   #ifdef DEBUG
    1800     dprintf(("DDRAW: GetDeviceIdentifier Flags = %d\n",dwFlags));
    1801   #endif
     1735  dprintf(("DDRAW: GetDeviceIdentifier Flags = %d\n",dwFlags));
    18021736  if(NULL==lpdddi)
    18031737    return DDERR_INVALIDPARAMS;

  • trunk/src/ddraw/OS2PALETTE.CPP

    r2174 r5291  
    1 /* $Id: OS2PALETTE.CPP,v 1.12 1999-12-21 01:28:16 hugh Exp $ */
     1/* $Id: OS2PALETTE.CPP,v 1.13 2001-03-09 22:48:46 mike Exp $ */
    22
    33/*
    … …  
    9191HRESULT __stdcall PalQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
    9292{
    93   #ifdef DEBUG
    94     dprintf(("DDRAW: OS2IDirectDrawPalette::PalQueryInterface\n"));
    95   #endif
     93  dprintf(("DDRAW: OS2IDirectDrawPalette::PalQueryInterface\n"));
    9694
    9795  *ppvObj = NULL;
    … …  
    112110  OS2IDirectDrawPalette *me = (OS2IDirectDrawPalette *)This;
    113111
    114   #ifdef DEBUG
    115     dprintf(("DDRAW: OS2IDirectDrawPalette::PalAddRef %d\n", me->Referenced+1));
    116   #endif
     112  dprintf(("DDRAW: OS2IDirectDrawPalette::PalAddRef %d\n", me->Referenced+1));
    117113
    118114  return (++me->Referenced);
    … …  
    171167 OS2IDirectDrawPalette *me = (OS2IDirectDrawPalette *)This;
    172168
    173   #ifdef DEBUG
    174     dprintf(("DDRAW: OS2IDirectDrawPalette::PalGetEntries\n"));
    175   #endif
    176 
    177   if( (NULL== lpEntries) ||(0!=dwFlags) ||(dwBase<0) ||((dwBase + dwNumEntries)>me->dwSize) )
     169  dprintf(("DDRAW: OS2IDirectDrawPalette::PalGetEntries\n"));
     170
     171  if ((NULL == lpEntries) || (0 != dwFlags) || (dwBase > 65536)
     172      || ((dwBase + dwNumEntries) > me->dwSize))
    178173    return(DDERR_INVALIDPARAMS);
    179174
    … …  
    188183HRESULT __stdcall PalInitialize(THIS, LPDIRECTDRAW, DWORD, LPPALETTEENTRY)
    189184{
    190   #ifdef DEBUG
    191     dprintf(("DDRAW: OS2IDirectDrawPalette::PalInitialize\n"));
    192   #endif
     185  dprintf(("DDRAW: OS2IDirectDrawPalette::PalInitialize\n"));
    193186  return(DDERR_ALREADYINITIALIZED);
    194187}
    … …  
    202195 OS2IDirectDrawPalette *me = (OS2IDirectDrawPalette *)This;
    203196
    204   #ifdef DEBUG
    205     dprintf(("DDRAW: OS2IDirectDrawPalette::PalSetEntries\n"));
    206   #endif
    207   if( (NULL== lpNewEntries) ||(0!=dwFlags) ||(dwBase<0) ||((dwBase + dwNumEntries)>me->dwSize) )
     197  dprintf(("DDRAW: OS2IDirectDrawPalette::PalSetEntries\n"));
     198
     199  if ((NULL== lpNewEntries) || (0 != dwFlags) || (dwBase > 65536)
     200      || ((dwBase + dwNumEntries) > me->dwSize))
    208201    return(DDERR_INVALIDPARAMS);
    209202

  • trunk/src/ddraw/OS2PALSET.CPP

    r3149 r5291  
    1 /* $Id: OS2PALSET.CPP,v 1.8 2000-03-17 22:05:40 mike Exp $ */
     1/* $Id: OS2PALSET.CPP,v 1.9 2001-03-09 22:48:47 mike Exp $ */
    22
    33/*
    … …  
    4848                          0,
    4949                          256,
    50                           (PLONG)&os2rgb);
     50                          (PLONG)&os2rgb[0]);
    5151  Gre32Entry3( hdc,
    5252               0L,

  • trunk/src/ddraw/OS2SURFACE.CPP

    r4146 r5291  
    1 /* $Id: OS2SURFACE.CPP,v 1.27 2000-09-02 08:27:05 sandervl Exp $ */
     1/* $Id: OS2SURFACE.CPP,v 1.28 2001-03-09 22:48:47 mike Exp $ */
    22
    33/*
    … …  
    560560
    561561{
    562   ULONG rc;
    563   DWORD i;
    564   DIVE_CAPS dCaps;
     562  DWORD rc;
    565563  DDSURFACEDESC2 ComplexSurfaceDesc;
    566   OS2IDirectDrawSurface *AttachedSurface;
    567564  OS2IDirectDrawSurface *MipMapSurface;
    568565
    … …  
    14021399{
    14031400
    1404   int i, FillWidth, FillHeight, Top, Left;
     1401  int FillWidth, FillHeight, Top, Left;
    14051402  DWORD *pPal24;
    14061403  WORD  *pPal16;
    … …  
    16661663OS2IDirectDrawSurface::~OS2IDirectDrawSurface()
    16671664{
    1668   OS2IDirectDrawSurface  *AttachedSurface;
    1669 
    16701665
    16711666  if(DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    … …  
    17441739
    17451740  lpDraw->Vtbl.Release(lpDraw);
    1746 
    1747 }
     1741}
     1742
    17481743//******************************************************************************
    17491744//******************************************************************************
    … …  
    21252120 OS2IDirectDrawSurface *src  = (OS2IDirectDrawSurface *)lpDDSrcSurface;
    21262121
    2127  HRESULT                rc;
    2128  ULONG                  ulColor, *pColor;
    2129  RECTL                  cliprect;
    2130 
    2131  int                    x, y, i, j, BlitWidth, BlitHeight;
     2122 int                    x, i, BlitWidth, BlitHeight;
    21322123 PALETTEENTRY           SysPal[257];
    21332124 PLOGPALETTE            pLogPal = (PLOGPALETTE) SysPal;
    … …  
    24352426    dprintf(("DDRAW: Blitting with scaling\n Not supported.\n"));
    24362427
    2437     return DDERR_NOSTRETCHHW;
     2428//    return DDERR_NOSTRETCHHW;
    24382429  }
    24392430
    … …  
    26782669        {
    26792670          DWORD dwFx;
    2680           DWORD dwSrcColor, dwDestColor;
    26812671
    26822672          dwFlags &= ~DDBLT_DDFX; // remove the handled flag
    … …  
    31953185  RECTL SrcRect;
    31963186  char *pBltPos, *pSrcPos;
    3197   DWORD dwDestColor, dwSrcColor, BlitWidth, BlitHeight,x,y;
     3187  DWORD dwDestColor, dwSrcColor, BlitWidth, BlitHeight, x;
    31983188
    31993189  dprintf(("DDRAW: SurfBltFast4 %08X at(%d/%d) onto %08X with flags %08X\n",src, dwX,dwY, dest, dwTrans));
    32003190
    3201   if( (NULL==lpDDSrcSurface) ||
    3202       (dwX<0) || (dwY<0) ||
    3203       (dwX>dest->width) ||
    3204       (dwY>dest->height))
     3191  if( (NULL == lpDDSrcSurface) ||
     3192      ((LONG)dwX < 0) || ((LONG)dwY < 0) ||
     3193      (dwX > dest->width) ||
     3194      (dwY > dest->height))
    32053195  {
    32063196    dprintf(("DDRAW: Invalid Parameters %08X, %d %d", lpDDSrcSurface ,dest->width , dest->height));
    … …  
    32083198  }
    32093199
    3210   if (NULL!=lpSrcRect)
     3200  if (NULL != lpSrcRect)
    32113201  {
    32123202    memcpy(&SrcRect,lpSrcRect,sizeof(RECTL) );
    … …  
    33683358        {
    33693359          case 1:
    3370             if(CPUHasMMX())
    3371               while(BlitHeight--)
     3360            if (CPUHasMMX())
     3361              while (BlitHeight--)
    33723362              {
    33733363                BlitColorKey8MMX((PBYTE)pBltPos,(PBYTE)pSrcPos,dwSrcColor,BlitWidth);
    … …  
    33763366              }
    33773367            else
    3378               while(BlitHeight--)
     3368              while (BlitHeight--)
    33793369              {
    33803370                BlitColorKey8((PBYTE)pBltPos,(PBYTE)pSrcPos,dwSrcColor,BlitWidth);
    … …  
    33853375          case 2:
    33863376
    3387             if(CPUHasMMX())
     3377            if (CPUHasMMX())
    33883378              while(BlitHeight--)
    33893379              {
    … …  
    34333423    else
    34343424    {
    3435       if(dwTrans & DDBLTFAST_DESTCOLORKEY)
     3425      if (dwTrans & DDBLTFAST_DESTCOLORKEY)
    34363426      {
    34373427        dprintf(("DDRAW: DestColorKey\n"));
    … …  
    35233513  //   dest->Vtbl4->ChangeUniquenessValue(dest);
    35243514
    3525   return(DD_OK);
     3515  return DD_OK;
    35263516}
    35273517//******************************************************************************
    … …  
    38013791  LPVOID Data;
    38023792  char *pcrFB,*pcFB,*pcrDB,*pcDB;
    3803   ULONG rc;
    38043793
    38053794  dprintf(("DDRAW: SurfFlip4\n"));
    … …  
    38493838  }
    38503839
    3851   if(-1 != me->diveBufNr)
     3840  if (-1 != me->diveBufNr)
    38523841  {
    38533842    //dprintf(("DDRAW: DIVE Flipchain DiveBuffer #%d",FlipSurface->diveBufNr));
    … …  
    39003889    me->pDiveBuffer             = FlipSurface->pDiveBuffer;
    39013890
    3902     if(NULL==lpDDSurf)
    3903     {
    3904       while(NULL!=FlipSurface->BackBuffer)
     3891    if (NULL==lpDDSurf)
     3892    {
     3893      while (NULL!=FlipSurface->BackBuffer)
    39053894      {
    39063895        FlipSurface->DDSurfaceDesc.lpSurface = FlipSurface->BackBuffer->DDSurfaceDesc.lpSurface;
    … …  
    39193908  }
    39203909
    3921   return(DD_OK);
    3922 }
     3910  return DD_OK;
     3911}
     3912
    39233913//******************************************************************************
    39243914//******************************************************************************
    … …  
    41714161    BitmapInfo.bmiHead.biHeight   = LockedSurfaceDesc.dwHeight;
    41724162    BitmapInfo.bmiHead.biPlanes   = 1;
    4173     BitmapInfo.bmiHead.biBitCount = LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
     4163    BitmapInfo.bmiHead.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
    41744164    memset(&bmihHdr, 0, sizeof(bmihHdr));
    41754165    bmihHdr.biSize     = sizeof(BITMAPINFOHEADER);
    … …  
    41774167    bmihHdr.biHeight   = LockedSurfaceDesc.dwHeight;
    41784168    bmihHdr.biPlanes   = 1;
    4179     bmihHdr.biBitCount = LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
     4169    bmihHdr.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
    41804170    #else
    41814171    bmpSurface.bmType       = 0;
    … …  
    42674257      BitmapInfo.bmiHead.biHeight   = LockedSurfaceDesc.dwHeight;
    42684258      BitmapInfo.bmiHead.biPlanes   = 1;
    4269       BitmapInfo.bmiHead.biBitCount = LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
     4259      BitmapInfo.bmiHead.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
    42704260
    42714261      switch(LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
    … …  
    45044494
    45054495  BOOL Found;
    4506   ULONG  nrScanLines;
    4507   char *pBuffer;
    45084496  DDRectangle *pIRectCurrent,*pIRectNew;
    4509   static int times = 0;
    45104497  HRESULT rc;
    45114498
    … …  
    46194606   RGBQUAD           bmiCols[256];
    46204607 } BitmapInfo;
    4621  BITMAP bmpData;
    4622  char szError[256];
    4623  int i,rc;
     4608// BITMAP bmpData;
     4609 int rc;
    46244610
    46254611  dprintf(("DDRAW: SurfReleaseDC\n"));
    … …  
    57785764  DWORD dwTLineStart;     // # DWORD in which the first transinfo is
    57795765  DWORD dwTDWStart;       // byte in which the firs transinfo is
    5780   DWORD dwTrans;          // current transparentvalue
    5781   DWORD BlitWidth;
     5766
    57825767  dwTLineLen = 1 + ((pSrcDesc->dwWidth + 31) & ~31);
    57835768  pdwTLine = (DWORD*)pAlpha + (dwTLineLen* lpSrcRect->top);

  • trunk/src/ddraw/colorconv.cpp

    r2987 r5291  
    1 /* $Id: colorconv.cpp,v 1.3 2000-03-03 19:21:21 hugh Exp $ */
     1/* $Id: colorconv.cpp,v 1.4 2001-03-09 22:48:47 mike Exp $ */
    22
    33/*
    … …  
    295295  WORD  *pDstLine;
    296296
    297   dprintf(("DDRAW: Conv32to16 (assuming R565) \n"));
     297  dprintf(("DDRAW: Conv32to16 (assuming R565)"));
    298298
    299299  pSrcLine = (DWORD*)(pFB + (dwTop*dwPitchDB) + (dwLeft*4));
    … …  
    305305    for(int x=0;x<dwWidth;x++)
    306306    {
    307       pDstLine[x] = ((pSrcLine[x] & 0xF8000000) >> 16) +
    308                     ((pSrcLine[x] & 0x00FE0000) >> 13) +
     307      DWORD tmp;
     308      tmp         = ((pSrcLine[x] & 0xF8000000) >> 16) |
     309                    ((pSrcLine[x] & 0x00FC0000) >> 13) |
    309310                    ((pSrcLine[x] & 0x0000F800) >> 11);
     311      pDstLine[x] = (WORD)tmp;
    310312    }
    311313    pSrcLine = (DWORD*)((char*)pSrcLine + dwPitchFB);

  • trunk/src/ddraw/ddraw.CPP

    r4139 r5291  
    1 /* $Id: ddraw.CPP,v 1.15 2000-08-31 21:03:14 sandervl Exp $ */
     1/* $Id: ddraw.CPP,v 1.16 2001-03-09 22:48:47 mike Exp $ */
    22
    33/*
    … …  
    1616#include <memory.h>
    1717#include <stdio.h>
    18 #include <builtin.h>
     18
    1919#define INITGUID
    2020#define ICOM_CINTERFACE 1
    … …  
    2929#include <misc.h>
    3030
     31extern "C" {
     32
    3133//******************************************************************************
    3234//******************************************************************************
    … …  
    7173
    7274//******************************************************************************
    73 typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKA)(GUID FAR *, LPSTR, LPSTR, LPVOID);
     75//typedef BOOL (FAR PASCAL * LPDDENUMCALLBACKA)(GUID FAR *, LPSTR, LPSTR, LPVOID);
    7476//******************************************************************************
    7577HRESULT WIN32API OS2DirectDrawEnumerateA(LPDDENUMCALLBACKA lpCallback,
    … …  
    284286  return S_FALSE;
    285287}//******************************************************************************
    286 
     288}

  • trunk/src/ddraw/ddraw.DEF

    r4135 r5291  
    1 ; $Id: ddraw.DEF,v 1.6 2000-08-31 12:48:42 sandervl Exp $
     1; $Id: ddraw.DEF,v 1.7 2001-03-09 22:48:47 mike Exp $
    22
    33;
    … …  
    55;
    66LIBRARY DDRAW INITINSTANCE TERMINSTANCE
    7 PROTMODE
    87DATA MULTIPLE NONSHARED READWRITE LOADONCALL
    98CODE LOADONCALL

  • trunk/src/ddraw/initterm.cpp

    r5135 r5291  
    5151   {
    5252   case DLL_PROCESS_ATTACH:
    53         return TRUE;
     53        return TRUE;
    5454
    5555   case DLL_THREAD_ATTACH:
    5656   case DLL_THREAD_DETACH:
    57         return TRUE;
     57        return TRUE;
    5858
    5959   case DLL_PROCESS_DETACH:
    60         ctordtorTerm();
    61         return TRUE;
     60#ifdef __IBMCPP__
     61        ctordtorTerm();
     62#endif
     63        return TRUE;
    6264   }
    6365   return FALSE;
    … …  
    7476                                   ulFlag)
    7577{
    76    size_t i;
    77    APIRET rc;
    7878
    7979   /*-------------------------------------------------------------------------*/
    … …  
    8686      case 0 :
    8787      {
     88#ifdef __IBMCPP__
    8889         ctordtorInit();
    89 
    90          DosQueryModuleName(hModule, CCHMAXPATH, ddrawPath);
     90#endif
     91         DosQueryModuleName(hModule, CCHMAXPATH, ddrawPath);
    9192         char *endofpath = strrchr(ddrawPath, '\\');
    9293         if(endofpath) *(endofpath+1) = 0;
    … …  
    9495         CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
    9596
    96         dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab,
     97        dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab,
    9798                                   DDRAW_MAJORIMAGE_VERSION, DDRAW_MINORIMAGE_VERSION,
    9899                                   IMAGE_SUBSYSTEM_WINDOWS_GUI);
    99          if(dllHandle == 0) 
    100                 return 0UL;
     100         if(dllHandle == 0)
     101                return 0UL;
    101102
    102103         break;
    … …  
    104105      case 1 :
    105106         if(dllHandle) {
    106                 UnregisterLxDll(dllHandle);
     107                UnregisterLxDll(dllHandle);
    107108         }
    108109         break;

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

    r3345 r5291  
    1 /* $Id: OS2D3D.CPP,v 1.1 2000-04-07 18:21:04 mike Exp $ */
     1/* $Id: OS2D3D.CPP,v 1.2 2001-03-09 22:48:47 mike Exp $ */
    22
    33/*
    … …  
    55 *
    66 * Copyright 1998 Sander van Leeuwen
     7 *
     8 * Note: MUST use DDraw3D_GetThisPtr macro to access DirectDraw object!
    79 *
    810 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    2123#include <misc.h>
    2224#include <winerror.h>
    23 #include <builtin.h>
    2425#undef THIS
    2526#define THIS VOID*
    … …  
    3233  *ppvObj = NULL;
    3334
    34   if(IID_IDirect3D != (GUID &)&riid)
     35  if (!IsEqualGUID(riid, IID_IDirect3D))
    3536    return E_NOINTERFACE;
    3637
    … …  
    4445ULONG __stdcall D3DAddRef(THIS This)
    4546{
    46  OS2IDirectDraw *me = (OS2IDirectDraw *)This;
     47 OS2IDirectDraw *me = DDraw3D_GetThisPtr(This);
    4748
    4849  dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
    … …  
    5354ULONG __stdcall D3DRelease(THIS This)
    5455{
    55  OS2IDirectDraw *me = (OS2IDirectDraw *)This;
     56 OS2IDirectDraw *me = DDraw3D_GetThisPtr(This);
    5657
    5758  dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
    … …  
    7576HRESULT __stdcall D3DInitialize(THIS This, REFIID)
    7677{
     78 OS2IDirectDraw *me = DDraw3D_GetThisPtr(This);
     79
    7780  dprintf(("DDRAW: D3DInitialize\n"));
    7881  return(D3D_OK);
    … …  
    8285HRESULT __stdcall D3DEnumDevices(THIS This, LPD3DENUMDEVICESCALLBACK, LPVOID)
    8386{
     87 OS2IDirectDraw *me = DDraw3D_GetThisPtr(This);
     88
    8489  dprintf(("DDRAW: D3DEnumDevices\n"));
    8590  return(D3D_OK);
    … …  
    8994HRESULT __stdcall D3DCreateLight(THIS This, LPDIRECT3DLIGHT*, IUnknown*)
    9095{
     96 OS2IDirectDraw *me = DDraw3D_GetThisPtr(This);
     97
    9198  dprintf(("DDRAW: D3DCreateLight\n"));
    9299  return(D3D_OK);
    … …  
    96103HRESULT __stdcall D3DCreateMaterial(THIS This, LPDIRECT3DMATERIAL*, IUnknown*)
    97104{
     105 OS2IDirectDraw *me = DDraw3D_GetThisPtr(This);
     106
    98107  dprintf(("DDRAW: D3DCreateMaterial\n"));
    99108  return(D3D_OK);
    … …  
    103112HRESULT __stdcall D3DCreateViewport(THIS This, LPDIRECT3DVIEWPORT*, IUnknown*)
    104113{
     114 OS2IDirectDraw *me = DDraw3D_GetThisPtr(This);
     115
    105116  dprintf(("DDRAW: D3DCreateViewport\n"));
    106117  return(D3D_OK);
    … …  
    110121HRESULT __stdcall D3DFindDevice(THIS This, LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT)
    111122{
     123 OS2IDirectDraw *me = DDraw3D_GetThisPtr(This);
     124
    112125  dprintf(("DDRAW: D3DCreateFindDevice\n"));
    113126  return(D3D_OK);

  • 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;

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

    r3345 r5291  
    1 /* $Id: OS2DDRAW.H,v 1.1 2000-04-07 18:21:04 mike Exp $ */
     1/* $Id: OS2DDRAW.H,v 1.2 2001-03-09 22:48:48 mike Exp $ */
    22
    33/*
    … …  
    1919#define APIENTRY _System
    2020#include "divewrap.h"
    21 //#define DEBUG 1
    2221#define mmioFOURCC( ch0, ch1, ch2, ch3 )                         \
    2322                  ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |    \
    … …  
    2625#undef THIS
    2726#define THIS VOID*
     27
     28#define MAX_FOURCC_CODES        3
     29
    2830class OS2IDirectDraw
    2931{
    … …  
    4042                                       // ToDO :
    4143                                       // debug into DirectDrawCreate and se what MS is doing !
    42     IDirectDraw2Vtbl  Vtbl;
     44    //Use for Direct3D interface (This != this)
     45    IDirect3DVtbl    *lpVtbl3D;
     46    IDirect3DVtbl    *lpVtbl3D2;
     47    DWORD            *pdwUnknownData3D;
     48
     49    IDirectDrawVtbl  Vtbl;
     50    IDirectDraw2Vtbl  Vtbl2;
    4351    // MS did it again with direct/X 6 they changed the behavior of the directdraw component
    4452    // So we now need 2 Virt. Tables one for the old and one for the new so we return the
    … …  
    8189    DWORD   dwCoopMode;
    8290    int     screenwidth, screenheight, screenbpp;
     91    BOOL    PrimaryExists;
     92    BOOL    bScale;
    8393    int     oldwidth, oldheight, oldbpp, oldscanlines;
    84     BOOL    PrimaryExists;
    8594    BOOL    bPMILoaded;
    8695    BOOL    bInFullScreen;
    87     BOOL    bScale;
     96
    8897
    8998   // Linked list management
    … …  
    141150};
    142151
     152#define OFFSET_D3DVTABLE        (LONG)(&((OS2IDirectDraw *)NULL)->lpVtbl3D)
     153#define DDraw3D_GetThisPtr(a)   (OS2IDirectDraw *)((ULONG)a-OFFSET_D3DVTABLE)
     154
    143155//******************************************************************************
    144156HRESULT __stdcall DrawQueryInterface(THIS, REFIID riid, LPVOID  * ppvObj);
    … …  
    194206HRESULT __stdcall D3DFindDevice(THIS, LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT);
    195207
     208#define FOURCC_YUY2  mmioFOURCC( 'Y', 'U', 'Y', '2' )
     209#define FOURCC_UYVY  mmioFOURCC( 'U', 'Y', 'V', 'Y' )
     210
    196211#endif

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

    r4326 r5291  
    1 /* $Id: OS2SURFACE.CPP,v 1.2 2000-09-25 20:54:01 mike Exp $ */
     1/* $Id: OS2SURFACE.CPP,v 1.3 2001-03-09 22:48:48 mike Exp $ */
    22
    33/*
    4  * Direct/X Surface class implementaion
     4 * DirectDraw Surface class implementaion
    55 *
    66 * Copyright 1999 Markus Montkowski
     7 * Copyright 2000 Michal Necasek
    78 *
    89 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    302303
    303304#define CBM_CREATEDIB   0x02L   /* create DIB bitmap */
     305
    304306#ifdef DEBUG
    305 
    306307// ******************************************************************************
    307308// *    internal helper functions from WINE
    … …  
    536537  _dump_DDPIXELFORMAT(pf->dwFlags);
    537538  dprintf(("DDRAW: dwFourCC : %ld\n", pf->dwFourCC));
    538   dprintf(("DDRAW: RBG bit cbout : %ld\n", pf->dwRGBBitCount));
     539  dprintf(("DDRAW: RBG bit count : %ld\n", pf->dwRGBBitCount));
    539540  dprintf(("DDRAW: Masks : R %08lx  G %08lx  B %08lx  A %08lx\n",
    540541       pf->dwRBitMask, pf->dwGBitMask, pf->dwBBitMask, pf->dwRGBAlphaBitMask));
    … …  
    559560
    560561{
    561   ULONG rc;
    562   DWORD i;
    563   DIVE_CAPS dCaps;
     562  DWORD rc;
    564563  DDSURFACEDESC2 ComplexSurfaceDesc;
    565   OS2IDirectDrawSurface *AttachedSurface;
    566564  OS2IDirectDrawSurface *MipMapSurface;
    567565
    … …  
    721719  if(NULL==DPA_SurfaceMipMaps)
    722720  {
    723     #ifdef DEBUG
    724       dprintf(("DDRAW: Internal : Error creating DPA for MipMaps\n"));
    725     #endif
     721    dprintf(("DDRAW: Internal : Error creating DPA for MipMaps\n"));
    726722    lastError = DDERR_OUTOFMEMORY ;
    727723    return;
    … …  
    747743  if(NULL==DPA_SurfacePrivateData)
    748744  {
    749     dprintf(("DDRAW: Internal : Error creating DPA for priva surface Data\n"));
     745    dprintf(("DDRAW: Internal : Error creating DPA for private surface Data\n"));
    750746    lastError = DDERR_OUTOFMEMORY ;
    751747    return;
    … …  
    778774          break;
    779775        default:
    780           dprintf(("DDRAW: Unsupported System ColorDeapth %d",lpDraw->dCaps.ulDepth));
     776          dprintf(("DDRAW: Unsupported System ColorDepth %d",lpDraw->dCaps.ulDepth));
    781777          BltSolid  = NULL;
    782778          ColorConv = NULL;
    … …  
    809805          break;
    810806        default:
    811           dprintf(("DDRAW: Unsupported System ColorDeapth %d",lpDraw->dCaps.ulDepth));
     807          dprintf(("DDRAW: Unsupported System ColorDepth %d",lpDraw->dCaps.ulDepth));
    812808          BltSolid  = NULL;
    813809          ColorConv = NULL;
    … …  
    840836          break;
    841837        default:
    842           dprintf(("DDRAW: Unsupported System ColorDeapth %d",lpDraw->dCaps.ulDepth));
     838          dprintf(("DDRAW: Unsupported System ColorDepth %d",lpDraw->dCaps.ulDepth));
    843839          BltSolid  = NULL;
    844840          ColorConv = NULL;
    … …  
    871867          break;
    872868        default:
    873           dprintf(("DDRAW: Unsupported System ColorDeapth %d",lpDraw->dCaps.ulDepth));
     869          dprintf(("DDRAW: Unsupported System ColorDepth %d",lpDraw->dCaps.ulDepth));
    874870          BltSolid  = NULL;
    875871          ColorConv = NULL;
    … …  
    879875      break;
    880876    default:
    881       dprintf(("DDRAW: Unsupported DX ColorDeapth %d",lpDraw->GetScreenBpp()));
     877      dprintf(("DDRAW: Unsupported DX ColorDepth %d",lpDraw->GetScreenBpp()));
    882878      BltSolid  = NULL;
    883879      ColorConv = NULL;
    … …  
    896892    if( surfaceType & DDSCAPS_PRIMARYSURFACE)
    897893    {
    898       #ifdef DEBUG
    899         dprintf(("DDRAW: Primary surface!\n"));
    900       #endif
    901 
     894      dprintf(("DDRAW: Primary surface!\n"));
    902895      if( lpDraw->HasPrimarySurface())
    903896      {
    904         #ifdef DEBUG
    905           dprintf(("DDRAW: Primary surface already exits!\n"));
    906         #endif
     897        dprintf(("DDRAW: Primary surface already exits!\n"));
    907898        lastError = DDERR_PRIMARYSURFACEALREADYEXISTS;
    908899        return;
    … …  
    925916      if( lpDraw->dCaps.ulDepth == lpDraw->GetScreenBpp() )
    926917      {
    927         dprintf(("DDRAW: DirectScreenAccess possible\n"));
     918        dprintf(("DDRAW: Direct Screen Access possible\n"));
    928919
    929920        // Yes so direct access to framebuffer is possible
    … …  
    940931        // and blit to the real framebuffer on Unlock to do color conversion
    941932
    942         dprintf( ("Need Color conversation %d => %d Bit\n",
     933        dprintf( ("Need Color conversion %d => %d Bit\n",
    943934                  lpDraw->GetScreenBpp(),
    944935                  lpDraw->dCaps.ulDepth
    … …  
    962953
    963954      dprintf(("DDRAW: Setting up Surface\n"));
    964 
    965955      DDSurfaceDesc.dwFlags     |= DDSD_WIDTH | DDSD_HEIGHT |
    966956                                   DDSD_PITCH | DDSD_LPSURFACE |
    … …  
    10561046          dprintf(("DDRAW: Unsupported Complex Surface\n"));
    10571047          #ifdef DEBUG
    1058             _dump_DDSCAPS(DDSurfaceDesc.dwFlags);
     1048          _dump_DDSCAPS(DDSurfaceDesc.dwFlags);
    10591049          #endif
    10601050          lastError = DDERR_OUTOFMEMORY;
    … …  
    14091399{
    14101400
    1411   int i, FillWidth, FillHeight, Top, Left;
     1401  int FillWidth, FillHeight, Top, Left;
    14121402  DWORD *pPal24;
    14131403  WORD  *pPal16;
    1414   #ifdef DEBUG
    1415     dprintf(("DDRAW: ColorFill with %08X\n", dwFillColor));
    1416   #endif
     1404  dprintf(("DDRAW: ColorFill with %08X\n", dwFillColor));
    14171405
    14181406  if(NULL!=lpDestRect)
    … …  
    14361424  //dprintf(("DDRAW: 0x%08X (%d/%d) at\n", pLine,FillWidth,FillHeight));
    14371425
    1438   // Better safe then sorry
    1439   if(FillHeight<=0)
     1426  // Better safe than sorry
     1427  if (FillHeight <= 0)
    14401428    return(DD_OK);
    14411429
    … …  
    16471635      break;
    16481636    default:
    1649       #ifdef DEBUG
    16501637        dprintf( ("Unexpected Screen Bitdepth %d\n",
    16511638                  lpDraw->dCaps.ulDepth));
    1652       #endif
    16531639      break;
    16541640  }
    … …  
    16771663OS2IDirectDrawSurface::~OS2IDirectDrawSurface()
    16781664{
    1679   OS2IDirectDrawSurface  *AttachedSurface;
    1680 
    16811665
    16821666  if(DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    … …  
    17551739
    17561740  lpDraw->Vtbl.Release(lpDraw);
    1757 
    1758 }
     1741}
     1742
    17591743//******************************************************************************
    17601744//******************************************************************************
    … …  
    17941778    else
    17951779    {
    1796       dprintf(("DDRAW: We are oe of many buffers\n"));
     1780      dprintf(("DDRAW: We are one of many buffers\n"));
    17971781      DDSurfaceDesc.ddsCaps.dwCaps &=  ~DDSCAPS_BACKBUFFER ;
    17981782      DDSurfaceDesc.ddsCaps.dwCaps |=  DDSCAPS_FLIP;
    … …  
    18071791//******************************************************************************
    18081792//******************************************************************************
    1809 HRESULT __stdcall SurfQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
     1793HRESULT WIN32API SurfQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
    18101794{
    18111795  // ToDo: Add Interface handling for D3D Textures
    … …  
    18261810  if(IsEqualGUID(riid, IID_IDirectDrawSurface))
    18271811  {
    1828     *ppvObj = &me->Vtbl2;  // ToDo DO a real V1 table
     1812    *ppvObj = &me->lpVtbl;  // ToDo DO a real V1 table
    18291813    rc = DD_OK;
    18301814    goto RetFn;
    … …  
    18321816  if(IsEqualGUID(riid, IID_IDirectDrawSurface2))
    18331817  {
    1834     *ppvObj = &me->Vtbl2;
     1818    *ppvObj = &me->lpVtbl2;
    18351819    rc = DD_OK;
    18361820    goto RetFn;
    … …  
    18591843//******************************************************************************
    18601844//******************************************************************************
    1861 ULONG __stdcall SurfAddRef(THIS This)
     1845ULONG WIN32API SurfAddRef(THIS This)
    18621846{
    18631847 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    18641848
    1865   #ifdef DEBUG
    1866     dprintf(("DDRAW: OS2IDirectDrawSurface::SurfAddRef %d\n", me->Referenced+1));
    1867   #endif
     1849  dprintf(("DDRAW: OS2IDirectDrawSurface::SurfAddRef %d\n", me->Referenced+1));
    18681850
    18691851  return ++me->Referenced;
    … …  
    18711853//******************************************************************************
    18721854//******************************************************************************
    1873 ULONG __stdcall SurfRelease(THIS This)
     1855ULONG WIN32API SurfRelease(THIS This)
    18741856{
    18751857 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    18761858
    1877   #ifdef DEBUG
    1878     dprintf(("DDRAW: OS2IDirectDrawSurface::SurfRelease %d\n", me->Referenced-1));
    1879     dprintf(("DDRAW: OS2IDirectDrawSurface::Surface %X\n", me));
    1880   #endif
     1859  dprintf(("DDRAW: OS2IDirectDrawSurface::SurfRelease %d\n", me->Referenced-1));
     1860  dprintf(("DDRAW: OS2IDirectDrawSurface::Surface %X\n", me));
    18811861  if(me->Referenced)
    18821862  {
    … …  
    18981878//******************************************************************************
    18991879//******************************************************************************
    1900 HRESULT __stdcall SurfAddAttachedSurface(THIS This, LPDIRECTDRAWSURFACE2 lpDDSurface)
    1901 {
    1902 
    1903   #ifdef DEBUG
    1904     dprintf(("DDRAW: SurfAddAttachedSurface\n"));
    1905   #endif
     1880HRESULT WIN32API SurfAddAttachedSurface(THIS This, LPDIRECTDRAWSURFACE2 lpDDSurface)
     1881{
     1882
     1883  dprintf(("DDRAW: SurfAddAttachedSurface\n"));
    19061884  return SurfAddAttachedSurface4(This, (LPDIRECTDRAWSURFACE4)lpDDSurface);
    19071885}
    19081886//******************************************************************************
    19091887//******************************************************************************
    1910 HRESULT __stdcall SurfAddAttachedSurface3(THIS This, LPDIRECTDRAWSURFACE3 lpDDSurface)
    1911 {
    1912 
    1913   #ifdef DEBUG
    1914     dprintf(("DDRAW: SurfAddAttachedSurface\n"));
    1915   #endif
     1888HRESULT WIN32API SurfAddAttachedSurface3(THIS This, LPDIRECTDRAWSURFACE3 lpDDSurface)
     1889{
     1890
     1891  dprintf(("DDRAW: SurfAddAttachedSurface\n"));
    19161892  return SurfAddAttachedSurface4(This, (LPDIRECTDRAWSURFACE4)lpDDSurface);
    19171893}
    19181894//******************************************************************************
    19191895//******************************************************************************
    1920 HRESULT __stdcall SurfAddAttachedSurface4(THIS This, LPDIRECTDRAWSURFACE4 lpDDSurface)
     1896HRESULT WIN32API SurfAddAttachedSurface4(THIS This, LPDIRECTDRAWSURFACE4 lpDDSurface)
    19211897{
    19221898  OS2IDirectDrawSurface *AttachedSurface;
    … …  
    19251901  int rc;
    19261902
    1927   #ifdef DEBUG
    1928     dprintf(("DDRAW: SurfAddAttachedSurface4\n"));
    1929   #endif
     1903  dprintf(("DDRAW: SurfAddAttachedSurface4\n"));
    19301904
    19311905  if (NULL==lpDDSurface)
    … …  
    19361910  if(AttachedSurface->IsImplicitSurface())
    19371911  {
    1938     #ifdef DEBUG
    1939      dprintf(("DDRAW: Internal : Can't attach an implicit created surface to an other surface\n"));
    1940     #endif
     1912    dprintf(("DDRAW: Internal : Can't attach an implicitly created surface to another surface\n"));
    19411913    return(DDERR_CANNOTATTACHSURFACE);
    19421914  }
    … …  
    19441916  if(This == AttachedSurface)
    19451917  {
    1946     #ifdef DEBUG
    1947      dprintf(("DDRAW: Can't attach an surface to itself\n"));
    1948     #endif
     1918    dprintf(("DDRAW: Can't attach a surface to itself\n"));
    19491919    return(DDERR_CANNOTATTACHSURFACE);
    19501920  }
    … …  
    19691939        else
    19701940        {
    1971           #ifdef DEBUG
    1972             dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
    1973           #endif
     1941          dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
    19741942          return(DDERR_CANNOTATTACHSURFACE);
    19751943        }
    … …  
    19771945      else
    19781946      {
    1979         #ifdef DEBUG
    1980           dprintf(("DDRAW: Target Surface isn't a MipMap\n"));
    1981         #endif
     1947        dprintf(("DDRAW: Target Surface isn't a MipMap\n"));
    19821948        return(DDERR_CANNOTATTACHSURFACE);
    19831949      }
    … …  
    19951961      else
    19961962      {
    1997         #ifdef DEBUG
    1998           dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
    1999         #endif
     1963        dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
    20001964        return(DDERR_CANNOTATTACHSURFACE);
    20011965      }
    … …  
    20101974       )
    20111975    {
    2012       #ifdef DEBUG
    2013         dprintf(("DDRAW: Surfaces don't have same dimensions\n"));
    2014       #endif
     1976      dprintf(("DDRAW: Surfaces don't have equal dimensions\n"));
    20151977      return(DDERR_CANNOTATTACHSURFACE);
    20161978    }
    … …  
    20211983        if( (AttachedSurface->GetFrontBuffer()!=NULL) || (AttachedSurface->BackBuffer!= NULL))
    20221984        {
    2023           #ifdef DEBUG
    2024             dprintf(("DDRAW: Surfaces already has a front/backbuffer\n"));
    2025           #endif
     1985          dprintf(("DDRAW: Surface already has a front/backbuffer\n"));
    20261986          return(DDERR_SURFACEALREADYATTACHED);
    20271987        }
    … …  
    20562016        else
    20572017        {
    2058           #ifdef DEBUG
    2059             dprintf(("DDRAW: Can't attach backbuffer to anything but a frontbuffer\n"));
    2060           #endif
    2061          return(DDERR_CANNOTATTACHSURFACE);
     2018          dprintf(("DDRAW: Can't attach backbuffer to anything but a frontbuffer\n"));
     2019          return(DDERR_CANNOTATTACHSURFACE);
    20622020        }
    20632021      }
    … …  
    20802038            else
    20812039            {
    2082               #ifdef DEBUG
    2083                 dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
    2084               #endif
     2040              dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
    20852041              return(DDERR_CANNOTATTACHSURFACE);
    20862042            }
    … …  
    20882044          else
    20892045          {
    2090             #ifdef DEBUG
    2091               dprintf(("DDRAW: Tagget Surface isn't a MipMap\n"));
    2092             #endif
     2046            dprintf(("DDRAW: Target Surface isn't a MipMap\n"));
    20932047           return(DDERR_CANNOTATTACHSURFACE);
    20942048          }
    … …  
    21042058          else
    21052059          {
    2106             #ifdef DEBUG
    2107               dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
    2108             #endif
     2060            dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
    21092061            return(DDERR_CANNOTATTACHSURFACE);
    21102062          }
    … …  
    21182070//******************************************************************************
    21192071//******************************************************************************
    2120 HRESULT __stdcall SurfAddOverlayDirtyRect(THIS, LPRECT)
    2121 {
    2122   #ifdef DEBUG
    2123     dprintf(("DDRAW: SurfAddOverlayDirtyRect Not implemented by M$ in V 6.0! \n"));
    2124   #endif
     2072HRESULT WIN32API SurfAddOverlayDirtyRect(THIS, LPRECT)
     2073{
     2074  dprintf(("DDRAW: SurfAddOverlayDirtyRect Not implemented by M$ in DX 6.0!\n"));
    21252075
    21262076  return(DD_OK);
    … …  
    21282078//******************************************************************************
    21292079//******************************************************************************
    2130 HRESULT __stdcall SurfBlt(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE2 lpDDSrcSurface,
     2080HRESULT WIN32API SurfBlt(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE2 lpDDSrcSurface,
    21312081        LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
    21322082{
    … …  
    21402090//******************************************************************************
    21412091//******************************************************************************
    2142 HRESULT __stdcall SurfBlt3(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE3 lpDDSrcSurface,
     2092HRESULT WIN32API SurfBlt3(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE3 lpDDSrcSurface,
    21432093        LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
    21442094{
    … …  
    21522102//******************************************************************************
    21532103//******************************************************************************
    2154 HRESULT __stdcall SurfBlt4(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE4 lpDDSrcSurface,
     2104HRESULT WIN32API SurfBlt4(THIS This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE4 lpDDSrcSurface,
    21552105        LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
    21562106{
    … …  
    21702120 OS2IDirectDrawSurface *src  = (OS2IDirectDrawSurface *)lpDDSrcSurface;
    21712121
    2172  HRESULT                rc;
    2173  ULONG                  ulColor, *pColor;
    2174  RECTL                  cliprect;
    2175 
    2176  int                    x, y, i, j, BlitWidth, BlitHeight;
     2122 int                    x, i, BlitWidth, BlitHeight;
    21772123 PALETTEENTRY           SysPal[257];
    21782124 PLOGPALETTE            pLogPal = (PLOGPALETTE) SysPal;
    … …  
    21852131
    21862132  #ifdef DEBUG
    2187     dprintf(("DDRAW: SurfBlt4 To Surf %08X, from Surf %08X, flags %08X", dest, src, dwFlags));
     2133    dprintf(("DDRAW: SurfBlt4 To Surf %08X, from Surf %08X\n",dest,src));
    21882134    if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
    21892135      dprintf(("DDRAW: SurfBlt4 to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
    … …  
    22892235    {
    22902236      delete pIRectDest;
    2291       dprintf(("DDRAW: Blt: Dest Surface partly locked\n"));
     2237      dprintf(("DDRAW: Blt: Dest Surface partially locked\n"));
    22922238      return(DDERR_SURFACEBUSY);
    22932239    }
    … …  
    24742420    }
    24752421  }
    2476 /*
     2422
    24772423  if( ( (NULL==lpDestRect) && (NULL!=lpSrcRect) ) ||
    24782424      ( (NULL==lpSrcRect) && (NULL!=lpDestRect) ) )
    24792425  {
    2480     dprintf(("DDRAW: Blitting with scaleing\n Not supported.\n"));
    2481 
    2482     return DDERR_NOSTRETCHHW;
     2426    dprintf(("DDRAW: Blitting with scaling\n Not supported.\n"));
     2427
     2428//    return DDERR_NOSTRETCHHW;
    24832429  }
    24842430
    … …  
    24922438    return DDERR_NOSTRETCHHW;
    24932439  }
    2494 */
     2440
    24952441  if (dest->DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    24962442  {
    … …  
    25932539    {
    25942540      // copy from the screen to a buffer
    2595       dprintf(("DDRAW: Screen to buffer"));
    25962541
    25972542      if( (NULL==lpDestRect) &&
    … …  
    26592604    {
    26602605      // DIVE => DIVE  or Mem => Dive can be handelt in the same way
    2661       dprintf(("DDRAW: Buffer to screen"));
    26622606
    26632607      if( (src->pDiveBuffer == dest->pDiveBuffer) &&
    … …  
    27252669        {
    27262670          DWORD dwFx;
    2727           DWORD dwSrcColor, dwDestColor;
    27282671
    27292672          dwFlags &= ~DDBLT_DDFX; // remove the handled flag
    … …  
    31893132//******************************************************************************
    31903133//******************************************************************************
    3191 HRESULT __stdcall SurfBltBatch(THIS, LPDDBLTBATCH, DWORD, DWORD )
    3192 {
    3193   #ifdef DEBUG
    3194     dprintf(("DDRAW: SurfBltBatch Not implemented by M$\n"));
    3195   #endif
     3134HRESULT WIN32API SurfBltBatch(THIS, LPDDBLTBATCH, DWORD, DWORD )
     3135{
     3136  dprintf(("DDRAW: SurfBltBatch Not implemented by M$\n"));
    31963137
    31973138  return(DD_OK);
    … …  
    31993140//******************************************************************************
    32003141//******************************************************************************
    3201 HRESULT __stdcall SurfBltFast( THIS This ,
     3142HRESULT WIN32API SurfBltFast( THIS This ,
    32023143                               DWORD dwX,
    32033144                               DWORD dwY,
    … …  
    32163157//******************************************************************************
    32173158//******************************************************************************
    3218 HRESULT __stdcall SurfBltFast3(THIS This ,
     3159HRESULT WIN32API SurfBltFast3(THIS This ,
    32193160                               DWORD dwX,
    32203161                               DWORD dwY,
    … …  
    32333174//******************************************************************************
    32343175//******************************************************************************
    3235 HRESULT __stdcall SurfBltFast4( THIS This,
     3176HRESULT WIN32API SurfBltFast4( THIS This,
    32363177                                DWORD dwX,
    32373178                                DWORD dwY,
    … …  
    32443185  RECTL SrcRect;
    32453186  char *pBltPos, *pSrcPos;
    3246   DWORD dwDestColor, dwSrcColor, BlitWidth, BlitHeight,x,y;
     3187  DWORD dwDestColor, dwSrcColor, BlitWidth, BlitHeight, x;
    32473188
    32483189  dprintf(("DDRAW: SurfBltFast4 %08X at(%d/%d) onto %08X with flags %08X\n",src, dwX,dwY, dest, dwTrans));
    32493190
    3250   if( (NULL==lpDDSrcSurface) ||
    3251       (dwX<0) || (dwY<0) ||
    3252       (dwX>dest->width) ||
    3253       (dwY>dest->height))
     3191  if( (NULL == lpDDSrcSurface) ||
     3192      ((LONG)dwX < 0) || ((LONG)dwY < 0) ||
     3193      (dwX > dest->width) ||
     3194      (dwY > dest->height))
    32543195  {
    32553196    dprintf(("DDRAW: Invalid Parameters %08X, %d %d", lpDDSrcSurface ,dest->width , dest->height));
    … …  
    32573198  }
    32583199
    3259   if (NULL!=lpSrcRect)
     3200  if (NULL != lpSrcRect)
    32603201  {
    32613202    memcpy(&SrcRect,lpSrcRect,sizeof(RECTL) );
    … …  
    32853226  if(DDBLTFAST_NOCOLORKEY == dwTrans )
    32863227  {
    3287     dprintf(( "Solid Blit, %d pels wide => %d bytes per line\n",
     3228    dprintf(( "Solid Blit, %d bits => %d bytes per line\n",
    32883229              (SrcRect.right - SrcRect.left),
    32893230              BlitWidth) );
    32903231    #ifdef USE_ASM
    32913232      BltRec(pBltPos, pSrcPos, BlitWidth, BlitHeight,
    3292              dest->dwPitchDB, src->dwPitchDB);
     3233             dest->dwPitchDB,
     3234             src->dwPitchDB);
    32933235    #else
    32943236      // Solid Blit
    32953237      while(1)
    32963238      {
    3297         memcpy(pBltPos, pSrcPos, BlitWidth);
     3239        memcpy(pBltPos,pSrcPos,BlitWidth);
    32983240        pBltPos += dest->dwPitchDB;
    32993241        pSrcPos += src->dwPitchDB;
    … …  
    33083250    dprintf(("DDRAW: TransBlit\n"));
    33093251
    3310     if (dwTrans & DDBLTFAST_SRCCOLORKEY)
     3252    if(dwTrans & DDBLTFAST_SRCCOLORKEY)
    33113253    {
    33123254      dprintf(("DDRAW: Trans SRC\n"));
    … …  
    34163358        {
    34173359          case 1:
    3418             if(CPUHasMMX())
    3419               while(BlitHeight--)
     3360            if (CPUHasMMX())
     3361              while (BlitHeight--)
    34203362              {
    34213363                BlitColorKey8MMX((PBYTE)pBltPos,(PBYTE)pSrcPos,dwSrcColor,BlitWidth);
    … …  
    34243366              }
    34253367            else
    3426               while(BlitHeight--)
     3368              while (BlitHeight--)
    34273369              {
    34283370                BlitColorKey8((PBYTE)pBltPos,(PBYTE)pSrcPos,dwSrcColor,BlitWidth);
    … …  
    34333375          case 2:
    34343376
    3435             if(CPUHasMMX())
     3377            if (CPUHasMMX())
    34363378              while(BlitHeight--)
    34373379              {
    … …  
    34813423    else
    34823424    {
    3483       if(dwTrans & DDBLTFAST_DESTCOLORKEY)
     3425      if (dwTrans & DDBLTFAST_DESTCOLORKEY)
    34843426      {
    34853427        dprintf(("DDRAW: DestColorKey\n"));
    … …  
    35713513  //   dest->Vtbl4->ChangeUniquenessValue(dest);
    35723514
    3573   return(DD_OK);
    3574 }
    3575 
    3576 //******************************************************************************
    3577 //******************************************************************************
    3578 HRESULT __stdcall SurfDeleteAttachedSurface(THIS This, DWORD dwFlags, LPDIRECTDRAWSURFACE2 lpDDSurface)
     3515  return DD_OK;
     3516}
     3517//******************************************************************************
     3518//******************************************************************************
     3519HRESULT WIN32API SurfDeleteAttachedSurface(THIS This, DWORD dwFlags, LPDIRECTDRAWSURFACE2 lpDDSurface)
    35793520{
    35803521  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    35833524  return(SurfDeleteAttachedSurface4(me, dwFlags, (LPDIRECTDRAWSURFACE4)lpDDSurface));
    35843525}
    3585 
    3586 //******************************************************************************
    3587 //******************************************************************************
    3588 HRESULT __stdcall SurfDeleteAttachedSurface3(THIS This, DWORD dwFlags, LPDIRECTDRAWSURFACE3 lpDDSurface)
     3526//******************************************************************************
     3527//******************************************************************************
     3528HRESULT WIN32API SurfDeleteAttachedSurface3(THIS This, DWORD dwFlags, LPDIRECTDRAWSURFACE3 lpDDSurface)
    35893529{
    35903530  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    3591   #ifdef DEBUG
    3592     dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
    3593   #endif
     3531  dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
    35943532
    35953533  return(SurfDeleteAttachedSurface4(me, dwFlags, (LPDIRECTDRAWSURFACE4)lpDDSurface));
    … …  
    35973535//******************************************************************************
    35983536//******************************************************************************
    3599 HRESULT __stdcall SurfDeleteAttachedSurface4(THIS This, DWORD dwFlags , LPDIRECTDRAWSURFACE4 lpDDSurface)
     3537HRESULT WIN32API SurfDeleteAttachedSurface4(THIS This, DWORD dwFlags , LPDIRECTDRAWSURFACE4 lpDDSurface)
    36003538{
    36013539
    … …  
    36063544
    36073545  BOOL Found = FALSE;
    3608   #ifdef DEBUG
    3609     dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
    3610   #endif
     3546  dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
    36113547
    36123548  if((0!=dwFlags)||(NULL==lpDDSurface))
    … …  
    37453681//******************************************************************************
    37463682//******************************************************************************
    3747 HRESULT __stdcall SurfEnumAttachedSurfaces(THIS This, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpCallBack)
     3683HRESULT WIN32API SurfEnumAttachedSurfaces(THIS This, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpCallBack)
    37483684{
    37493685  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    3750   #ifdef DEBUG
    3751     dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
    3752   #endif
     3686  dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
    37533687
    37543688  return(SurfEnumAttachedSurfaces4(me,lpContext, (LPDDENUMSURFACESCALLBACK2) lpCallBack));
    … …  
    37563690//******************************************************************************
    37573691//******************************************************************************
    3758 HRESULT __stdcall SurfEnumAttachedSurfaces4(THIS This, LPVOID lpContext ,LPDDENUMSURFACESCALLBACK2 lpCallBack)
     3692HRESULT WIN32API SurfEnumAttachedSurfaces4(THIS This, LPVOID lpContext ,LPDDENUMSURFACESCALLBACK2 lpCallBack)
    37593693{
    37603694  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    37643698  HRESULT rc;
    37653699
    3766   #ifdef DEBUG
    3767     dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
    3768   #endif
     3700  dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
    37693701  if (NULL==lpCallBack)
    37703702    return (DDERR_INVALIDPARAMS);
    … …  
    38163748//******************************************************************************
    38173749//******************************************************************************
    3818 HRESULT __stdcall SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK)
     3750HRESULT WIN32API SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK)
    38193751{
    38203752  dprintf(("DDRAW: SurfEnumOverlayZOrders\n"));
    … …  
    38243756//******************************************************************************
    38253757//******************************************************************************
    3826 HRESULT __stdcall SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2)
     3758HRESULT WIN32API SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2)
    38273759{
    38283760  dprintf(("DDRAW: SurfEnumOverlayZOrders\n"));
    … …  
    38323764//******************************************************************************
    38333765//******************************************************************************
    3834 HRESULT __stdcall SurfFlip(THIS This, LPDIRECTDRAWSURFACE2 lpDDSurf, DWORD dwFlags)
     3766HRESULT WIN32API SurfFlip(THIS This, LPDIRECTDRAWSURFACE2 lpDDSurf, DWORD dwFlags)
    38353767{
    38363768  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    38423774//******************************************************************************
    38433775//******************************************************************************
    3844 HRESULT __stdcall SurfFlip3(THIS This, LPDIRECTDRAWSURFACE3 lpDDSurf, DWORD dwFlags)
     3776HRESULT WIN32API SurfFlip3(THIS This, LPDIRECTDRAWSURFACE3 lpDDSurf, DWORD dwFlags)
    38453777{
    38463778  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    38523784//******************************************************************************
    38533785//******************************************************************************
    3854 HRESULT __stdcall SurfFlip4(THIS This, LPDIRECTDRAWSURFACE4 lpDDSurf, DWORD dwFlags)
     3786HRESULT WIN32API SurfFlip4(THIS This, LPDIRECTDRAWSURFACE4 lpDDSurf, DWORD dwFlags)
    38553787{
    38563788  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    38593791  LPVOID Data;
    38603792  char *pcrFB,*pcFB,*pcrDB,*pcDB;
    3861   ULONG rc;
    38623793
    38633794  dprintf(("DDRAW: SurfFlip4\n"));
    … …  
    39073838  }
    39083839
    3909   if(-1 != me->diveBufNr)
     3840  if (-1 != me->diveBufNr)
    39103841  {
    39113842    //dprintf(("DDRAW: DIVE Flipchain DiveBuffer #%d",FlipSurface->diveBufNr));
    … …  
    39343865  else
    39353866  {
    3936     #ifdef DEBUG
    3937       dprintf(("DDRAW: Memory Flipchain"));
    3938     #endif
     3867    dprintf(("DDRAW: Memory Flipchain"));
    39393868    // Memory Flipchain
    39403869    //
    … …  
    39603889    me->pDiveBuffer             = FlipSurface->pDiveBuffer;
    39613890
    3962     if(NULL==lpDDSurf)
    3963     {
    3964       while(NULL!=FlipSurface->BackBuffer)
     3891    if (NULL==lpDDSurf)
     3892    {
     3893      while (NULL!=FlipSurface->BackBuffer)
    39653894      {
    39663895        FlipSurface->DDSurfaceDesc.lpSurface = FlipSurface->BackBuffer->DDSurfaceDesc.lpSurface;
    … …  
    39793908  }
    39803909
    3981   return(DD_OK);
    3982 }
    3983 //******************************************************************************
    3984 //******************************************************************************
    3985 HRESULT __stdcall SurfGetAttachedSurface(THIS This, LPDDSCAPS lpDDCaps,
     3910  return DD_OK;
     3911}
     3912
     3913//******************************************************************************
     3914//******************************************************************************
     3915HRESULT WIN32API SurfGetAttachedSurface(THIS This, LPDDSCAPS lpDDCaps,
    39863916                                         LPDIRECTDRAWSURFACE2 FAR * lpDDSurf)
    39873917{
    39883918  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    3989   #ifdef DEBUG
    3990     dprintf(("DDRAW: SurfGetAttachedSurface\n"));
    3991   #endif
     3919  dprintf(("DDRAW: SurfGetAttachedSurface\n"));
    39923920
    39933921  return(SurfGetAttachedSurface4(me, (LPDDSCAPS2)lpDDCaps , (LPDIRECTDRAWSURFACE4*)lpDDSurf));
    … …  
    39953923//******************************************************************************
    39963924//******************************************************************************
    3997 HRESULT __stdcall SurfGetAttachedSurface3(THIS This, LPDDSCAPS lpDDCaps,
     3925HRESULT WIN32API SurfGetAttachedSurface3(THIS This, LPDDSCAPS lpDDCaps,
    39983926                                         LPDIRECTDRAWSURFACE3 FAR * lpDDSurf)
    39993927{
    40003928  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    4001   #ifdef DEBUG
    4002     dprintf(("DDRAW: SurfGetAttachedSurface3\n"));
    4003   #endif
     3929  dprintf(("DDRAW: SurfGetAttachedSurface3\n"));
    40043930
    40053931  return(SurfGetAttachedSurface4(me, (LPDDSCAPS2)lpDDCaps , (LPDIRECTDRAWSURFACE4*)lpDDSurf));
    … …  
    40073933//******************************************************************************
    40083934//******************************************************************************
    4009 HRESULT __stdcall SurfGetAttachedSurface4(THIS This, LPDDSCAPS2 lpDDCaps,
     3935HRESULT WIN32API SurfGetAttachedSurface4(THIS This, LPDDSCAPS2 lpDDCaps,
    40103936                                          LPDIRECTDRAWSURFACE4 FAR * lpDDSurf)
    40113937{
    … …  
    40944020//******************************************************************************
    40954021//******************************************************************************
    4096 HRESULT __stdcall SurfGetBltStatus(THIS This, DWORD)
    4097 {
    4098   #ifdef DEBUG
    4099     dprintf(("DDRAW: SurfGetBltStatus\n"));
    4100   #endif
     4022HRESULT WIN32API SurfGetBltStatus(THIS This, DWORD)
     4023{
     4024  dprintf(("DDRAW: SurfGetBltStatus\n"));
    41014025
    41024026  return(DD_OK);
    … …  
    41044028//******************************************************************************
    41054029//******************************************************************************
    4106 HRESULT __stdcall SurfGetCaps(THIS This, LPDDSCAPS lpDDCaps)
     4030HRESULT WIN32API SurfGetCaps(THIS This, LPDDSCAPS lpDDCaps)
    41074031{
    41084032  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    41094033
    4110   #ifdef DEBUG
    4111     dprintf(("DDRAW: SurfGetCaps\n"));
    4112   #endif
     4034  dprintf(("DDRAW: SurfGetCaps\n"));
    41134035
    41144036  if(NULL==lpDDCaps)
    … …  
    41234045//******************************************************************************
    41244046//******************************************************************************
    4125 HRESULT __stdcall SurfGetCaps4(THIS This, LPDDSCAPS2 lpDDCaps)
     4047HRESULT WIN32API SurfGetCaps4(THIS This, LPDDSCAPS2 lpDDCaps)
    41264048{
    41274049  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    4128   #ifdef DEBUG
    4129     dprintf(("DDRAW: SurfGetCaps4\n"));
    4130   #endif
     4050  dprintf(("DDRAW: SurfGetCaps4\n"));
    41314051
    41324052  if(NULL==lpDDCaps)
    … …  
    41374057    _dump_DDSCAPS(lpDDCaps->dwCaps);
    41384058    _dump_DDSCAPS2(lpDDCaps->dwCaps2);
    4139 
    41404059  #endif
    41414060
    … …  
    41444063//******************************************************************************
    41454064//******************************************************************************
    4146 HRESULT __stdcall SurfGetClipper(THIS This, LPDIRECTDRAWCLIPPER FAR *lplpClipper)
     4065HRESULT WIN32API SurfGetClipper(THIS This, LPDIRECTDRAWCLIPPER FAR *lplpClipper)
    41474066{
    41484067  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    41494068
    4150   #ifdef DEBUG
    4151     dprintf(("DDRAW: SurfGetClipper\n"));
    4152   #endif
     4069  dprintf(("DDRAW: SurfGetClipper\n"));
    41534070
    41544071  if(me->lpClipper)
    … …  
    41624079//******************************************************************************
    41634080//******************************************************************************
    4164 HRESULT __stdcall SurfGetColorKey(THIS This, DWORD dwFlags, LPDDCOLORKEY lpDDColKey)
     4081HRESULT WIN32API SurfGetColorKey(THIS This, DWORD dwFlags, LPDDCOLORKEY lpDDColKey)
    41654082{
    41664083  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    4167 
    4168 #ifdef DEBUG
    41694084  dprintf(("DDRAW: SurfGetColorKey\n"));
    4170 #endif
    41714085
    41724086  if ((0==dwFlags) || (NULL==lpDDColKey))
    … …  
    41934107//******************************************************************************
    41944108//******************************************************************************
    4195 HRESULT __stdcall SurfGetDC(THIS This, HDC FAR *hdc)
     4109HRESULT WIN32API SurfGetDC(THIS This, HDC FAR *hdc)
    41964110{
    41974111 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    41984112 DDSURFACEDESC2        LockedSurfaceDesc;
    4199  HRESULT rc;
     4113 HRESULT               rc;
     4114 BITMAPINFOHEADER      bmihHdr;
    42004115 BITMAP bmpSurface;
    42014116 struct
    … …  
    42054120 } BitmapInfo;
    42064121
    4207   #ifdef DEBUG
    4208     dprintf(("DDRAW: SurfGetDC\n"));
    4209   #endif
    4210 
    4211   if (NULL==hdc)
     4122  dprintf(("DDRAW: SurfGetDC\n"));
     4123
     4124  if (hdc == NULL)
    42124125    return(DDERR_INVALIDPARAMS);
    42134126
    … …  
    42274140    if(me->hdcImage == NULL)
    42284141    {
    4229       #ifdef DEBUG
    4230         dprintf(("DDRAW: Can't create compatible DC!\n"));
    4231       #endif
     4142      dprintf(("DDRAW: Can't create compatible DC!\n"));
    42324143      me->Vtbl.Unlock(me,NULL);
    42334144      rc = DDERR_GENERIC;
    42344145    }
    4235     InverseDC(me->hdcImage, LockedSurfaceDesc.dwHeight);
    4236   }
    4237 
    4238   if( (DD_OK==rc) &&
    4239       (me->hbmImage == NULL) )
    4240   {
     4146  }
     4147
     4148  if( (DD_OK==rc) && (me->hbmImage == NULL) )
     4149  {
     4150    OS2IDirectDrawPalette *ddpal = NULL;
     4151
    42414152    dprintf( ("Trying to create Bitmap (%d/%d) at %d Bit\n",
    4242               LockedSurfaceDesc.lPitch/ (LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount>>3),
     4153              LockedSurfaceDesc.dwWidth,
    42434154              LockedSurfaceDesc.dwHeight,
    42444155              LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount
    42454156            ));
    4246     #if 0
     4157    #if 1
    42474158    memset(&BitmapInfo, 0, sizeof(BitmapInfo));
    4248     BitmapInfo.bmiHead.biSize   = sizeof(BITMAPINFOHEADER);
    4249     BitmapInfo.bmiHead.biWidth  = LockedSurfaceDesc.lPitch/ (LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount>>3);
    4250     BitmapInfo.bmiHead.biHeight = LockedSurfaceDesc.dwHeight;
    4251     BitmapInfo.bmiHead.biPlanes = 1;
    4252     BitmapInfo.bmiHead.biBitCount    = LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
     4159    BitmapInfo.bmiHead.biSize     = sizeof(BITMAPINFOHEADER);
     4160    BitmapInfo.bmiHead.biWidth    = LockedSurfaceDesc.dwWidth;
     4161    BitmapInfo.bmiHead.biHeight   = LockedSurfaceDesc.dwHeight;
     4162    BitmapInfo.bmiHead.biPlanes   = 1;
     4163    BitmapInfo.bmiHead.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
     4164    memset(&bmihHdr, 0, sizeof(bmihHdr));
     4165    bmihHdr.biSize     = sizeof(BITMAPINFOHEADER);
     4166    bmihHdr.biWidth    = LockedSurfaceDesc.dwWidth;
     4167    bmihHdr.biHeight   = LockedSurfaceDesc.dwHeight;
     4168    bmihHdr.biPlanes   = 1;
     4169    bmihHdr.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
    42534170    #else
    42544171    bmpSurface.bmType       = 0;
    … …  
    42664183        break;
    42674184      case 8:
    4268         #if 0
     4185        #if 1
    42694186        BitmapInfo.bmiHead.biCompression = BI_RGB;
    4270         GetSystemPaletteEntries(me->hdcImage,0,255,(PPALETTEENTRY)&BitmapInfo.bmiCols[0]);
     4187        if (me->lpPalette != NULL)
     4188           ddpal = me->lpPalette;
     4189        if ((me->FrontBuffer != NULL) && (me->FrontBuffer->lpPalette != NULL))
     4190           ddpal = me->FrontBuffer->lpPalette;
     4191        if (ddpal != NULL) {
     4192           ddpal->Vtbl.GetEntries((IDirectDrawPalette*)ddpal,
     4193              0, 0, 256, (PPALETTEENTRY)&BitmapInfo.bmiCols[0]);
     4194        }
     4195        else {
     4196           dprintf(("DDRAW: Using default palette\n"));
     4197           for (DWORD i = 0; i < 256; i++) {
     4198              BitmapInfo.bmiCols[i].rgbBlue  = DefaultPalette[i*3+2];
     4199              BitmapInfo.bmiCols[i].rgbGreen = DefaultPalette[i*3+1];
     4200              BitmapInfo.bmiCols[i].rgbRed   = DefaultPalette[i*3];
     4201              BitmapInfo.bmiCols[i].rgbReserved = 0;
     4202           }
     4203        }
    42714204        me->hbmImage = CreateDIBitmap( me->hdcImage,
    4272                                        NULL,
    4273                                        CBM_CREATEDIB,
     4205                                       &bmihHdr,
     4206                                       CBM_INIT,
    42744207                                       LockedSurfaceDesc.lpSurface,
    42754208                                       (PBITMAPINFO)&BitmapInfo,
    … …  
    42924225                                       LockedSurfaceDesc.lpSurface,
    42934226                                       (PBITMAPINFO)&BitmapInfo,
    4294                                        DIB_RGB_COLORS);
     4227                                       DIB_RGB_COLORS );
    42954228        #else
    42964229        bmpSurface.bmBitsPixel  = 24;
    … …  
    42994232        break;
    43004233      default:
    4301         #ifdef DEBUG
    4302           dprintf( ("Unexptected BitCount %d \n",
     4234        dprintf( ("Unexpected BitCount %d \n",
    43034235                    LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
    4304         #endif
    43054236        me->hbmImage=NULL;
    43064237    } // end switch (me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
    … …  
    43084239    if(me->hbmImage == NULL)
    43094240    {
    4310       #ifdef DEBUG
    4311         dprintf(("DDRAW: Can't create bitmap!\n"));
    4312       #endif
     4241      dprintf(("DDRAW: Can't create bitmap!\n"));
    43134242      DeleteDC(me->hdcImage);
    43144243      me->hdcImage = NULL;
    … …  
    43194248  else
    43204249  {
    4321     if( (DD_OK==rc) &&
    4322         (me->dwLastDCUnique != me->dwUniqueValue) )
    4323     {
    4324       #ifdef DEBUG
    4325         dprintf(("DDRAW: The Surface was locked/unlocked after the last DC was created =>Update Bitmap!\n"));
    4326       #endif
     4250    if( (DD_OK==rc) && (me->dwLastDCUnique != me->dwUniqueValue) )
     4251    {
     4252      dprintf(("DDRAW: The Surface was locked/unlocked after the last DC was created =>Update Bitmap!\n"));
    43274253
    43284254      memset(&BitmapInfo,0, sizeof(BitmapInfo));
    43294255      BitmapInfo.bmiHead.biSize     = sizeof(BITMAPINFOHEADER);
    4330       BitmapInfo.bmiHead.biWidth    = LockedSurfaceDesc.lPitch/ (LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount>>3);
     4256      BitmapInfo.bmiHead.biWidth    = LockedSurfaceDesc.dwWidth;
    43314257      BitmapInfo.bmiHead.biHeight   = LockedSurfaceDesc.dwHeight;
    43324258      BitmapInfo.bmiHead.biPlanes   = 1;
    4333       BitmapInfo.bmiHead.biBitCount = LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
     4259      BitmapInfo.bmiHead.biBitCount = (WORD)LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount;
    43344260
    43354261      switch(LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
    … …  
    43594285          break;
    43604286        default:
    4361           #ifdef DEBUG
    4362             dprintf(("DDRAW: Unexptected BitCount %d => Bitmap not updated!\n",LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
    4363           #endif
     4287          dprintf(("DDRAW: Unexpected BitCount %d => Bitmap not updated!\n",LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
    43644288          break;
    43654289      } // end switch (me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
    … …  
    43704294  // Allways select the bitmap into the DC! No matter if the old or a new one
    43714295
    4372   if(DD_OK==rc)
    4373   {
    4374     if((me->hgdiOld = SelectObject(me->hdcImage, me->hbmImage)) == NULL)
    4375     {
    4376       #ifdef DEBUG
    4377         dprintf(("DDRAW: Can't select bitmap into dc!\n"));
    4378       #endif
     4296  if (DD_OK==rc)
     4297  {
     4298    if ((me->hgdiOld = SelectObject(me->hdcImage, me->hbmImage)) == NULL)
     4299    {
     4300      dprintf(("DDRAW: Can't select bitmap into DC!\n"));
    43794301      DeleteDC(me->hdcImage);
    43804302      me->hdcImage = NULL;
    … …  
    43944316//******************************************************************************
    43954317//******************************************************************************
    4396 HRESULT __stdcall SurfGetFlipStatus(THIS This, DWORD dwFlags)
    4397 {
    4398   #ifdef DEBUG
    4399     dprintf(("DDRAW: SurfGetFlipStatus\n"));
    4400   #endif
     4318HRESULT WIN32API SurfGetFlipStatus(THIS This, DWORD dwFlags)
     4319{
     4320  dprintf(("DDRAW: SurfGetFlipStatus\n"));
    44014321
    44024322  if( (DDGFS_CANFLIP!=dwFlags) && (DDGFS_ISFLIPDONE!=dwFlags) )
    … …  
    44074327//******************************************************************************
    44084328//******************************************************************************
    4409 HRESULT __stdcall SurfGetOverlayPosition(THIS This, LPLONG lplX, LPLONG lplY)
     4329HRESULT WIN32API SurfGetOverlayPosition(THIS This, LPLONG lplX, LPLONG lplY)
    44104330{
    44114331  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    4412   #ifdef DEBUG
    4413     dprintf(("DDRAW: SurfGetOverlayPosition\n"));
    4414   #endif
     4332  dprintf(("DDRAW: SurfGetOverlayPosition\n"));
    44154333
    44164334  // Maybe simply return dderr_notsupported as we retun a max overlay value of 0 in the caps ?
    … …  
    44354353//******************************************************************************
    44364354//******************************************************************************
    4437 HRESULT __stdcall SurfGetPalette(THIS This, LPDIRECTDRAWPALETTE FAR *lplpPalette)
     4355HRESULT WIN32API SurfGetPalette(THIS This, LPDIRECTDRAWPALETTE FAR *lplpPalette)
    44384356{
    44394357 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    44404358
    4441   #ifdef DEBUG
    4442     dprintf(("DDRAW: SurfGetPalette\n"));
    4443   #endif
     4359  dprintf(("DDRAW: SurfGetPalette\n"));
    44444360
    44454361  if(me->lpPalette)
    … …  
    44534369//******************************************************************************
    44544370//******************************************************************************
    4455 HRESULT __stdcall SurfGetPixelFormat(THIS This, LPDDPIXELFORMAT lpPixelFormat)
     4371HRESULT WIN32API SurfGetPixelFormat(THIS This, LPDDPIXELFORMAT lpPixelFormat)
    44564372{
    44574373  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    44584374
    4459   #ifdef DEBUG
    4460     dprintf(("DDRAW: SurfGetPixelFormat\n"));
    4461   #endif
     4375  dprintf(("DDRAW: SurfGetPixelFormat %x %x", This, lpPixelFormat));
    44624376
    44634377  if(NULL==lpPixelFormat)
    … …  
    44724386//******************************************************************************
    44734387//******************************************************************************
    4474 HRESULT __stdcall SurfGetSurfaceDesc(THIS This, LPDDSURFACEDESC lpSurface)
     4388HRESULT WIN32API SurfGetSurfaceDesc(THIS This, LPDDSURFACEDESC lpSurface)
    44754389{
    44764390  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    44774391
    4478   #ifdef DEBUG
    4479     dprintf(("DDRAW: SurfGetSurfaceDesc\n"));
    4480   #endif
     4392  dprintf(("DDRAW: SurfGetSurfaceDesc\n"));
    44814393
    44824394  if((lpSurface == NULL)||(lpSurface->dwSize != sizeof(DDSURFACEDESC)) )
    … …  
    44914403//******************************************************************************
    44924404//******************************************************************************
    4493 HRESULT __stdcall SurfGetSurfaceDesc4(THIS This, LPDDSURFACEDESC2 lpSurface)
     4405HRESULT WIN32API SurfGetSurfaceDesc4(THIS This, LPDDSURFACEDESC2 lpSurface)
    44944406{
    44954407  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    44964408
    4497   #ifdef DEBUG
    4498     dprintf(("DDRAW: SurfGetSurfaceDesc4\n"));
    4499   #endif
     4409  dprintf(("DDRAW: SurfGetSurfaceDesc4\n"));
    45004410
    45014411  if((lpSurface == NULL)||(lpSurface->dwSize != sizeof(DDSURFACEDESC2)) )
    … …  
    45104420//******************************************************************************
    45114421//******************************************************************************
    4512 HRESULT __stdcall SurfInitialize(THIS, LPDIRECTDRAW, LPDDSURFACEDESC)
    4513 {
    4514   #ifdef DEBUG
    4515     dprintf(("DDRAW: SurfInitialize\n"));
    4516   #endif
     4422HRESULT WIN32API SurfInitialize(THIS, LPDIRECTDRAW, LPDDSURFACEDESC)
     4423{
     4424  dprintf(("DDRAW: SurfInitialize\n"));
    45174425
    45184426  return(DDERR_ALREADYINITIALIZED); // Init is done during creation see M$ Doc
    … …  
    45204428//******************************************************************************
    45214429//******************************************************************************
    4522 HRESULT __stdcall SurfInitialize4(THIS, LPDIRECTDRAW, LPDDSURFACEDESC2)
    4523 {
    4524   #ifdef DEBUG
    4525     dprintf(("DDRAW: SurfInitialize\n"));
    4526   #endif
     4430HRESULT WIN32API SurfInitialize4(THIS, LPDIRECTDRAW, LPDDSURFACEDESC2)
     4431{
     4432  dprintf(("DDRAW: SurfInitialize\n"));
    45274433
    45284434  return(DDERR_ALREADYINITIALIZED); // Init is done during creation see M$ Doc
    … …  
    45304436//******************************************************************************
    45314437//******************************************************************************
    4532 HRESULT __stdcall SurfIsLost(THIS)
     4438HRESULT WIN32API SurfIsLost(THIS)
    45334439{
    45344440  // We don't loose any surface ;)
    … …  
    45364442  // if  they are preserved if switching to a FS DOS/OS2 session
    45374443  //
    4538   #ifdef DEBUG
    4539     dprintf(("DDRAW: SurfIsLost\n"));
    4540   #endif
     4444  dprintf(("DDRAW: SurfIsLost\n"));
    45414445
    45424446  return(DD_OK);
    … …  
    45444448//******************************************************************************
    45454449//******************************************************************************
    4546 HRESULT __stdcall SurfLock( THIS This,
     4450HRESULT WIN32API SurfLock( THIS This,
    45474451                            LPRECT lpRect,
    45484452                            LPDDSURFACEDESC lpSurfaceDesc,
    … …  
    45534457  HRESULT rc;
    45544458
    4555   #ifdef DEBUG
    4556     dprintf(("DDRAW: SurfLock %d %08X %d %d\n", (int)lpRect, (int)lpSurfaceDesc, dwFlags, hEvent));
    4557   #endif
     4459  dprintf(("DDRAW: SurfLock %d %08X %d %d\n", (int)lpRect, (int)lpSurfaceDesc, dwFlags, hEvent));
    45584460
    45594461  if((NULL==lpSurfaceDesc)||(NULL!=hEvent))
    … …  
    45814483//******************************************************************************
    45824484//******************************************************************************
    4583 HRESULT __stdcall SurfLock4( THIS This,
     4485HRESULT WIN32API SurfLock4( THIS This,
    45844486                             LPRECT lpRect,
    45854487                             LPDDSURFACEDESC2 lpSurfaceDesc,
    … …  
    45924494
    45934495  BOOL Found;
    4594   ULONG  nrScanLines;
    4595   char *pBuffer;
    45964496  DDRectangle *pIRectCurrent,*pIRectNew;
    4597   static int times = 0;
    45984497  HRESULT rc;
    45994498
    4600   #ifdef DEBUG
    4601     dprintf( ("SurfLock4 %08X %08X %08X %d %d\n",
    4602               me,
    4603               (int)lpRect,
    4604               (int)lpSurfaceDesc,
    4605               dwFlags,
    4606               hEvent) );
    4607   #endif
     4499  dprintf( ("SurfLock4 %08X %08X %08X %d %d\n",
     4500            me,
     4501            (int)lpRect,
     4502            (int)lpSurfaceDesc,
     4503            dwFlags,
     4504            hEvent) );
    46084505
    46094506  if( (NULL==lpSurfaceDesc) ||
    … …  
    46334530    if (NULL==lpRect)
    46344531    {
    4635       // If anything is locked we can't locke the complete surface
    4636       dprintf(("DDRAW: Surface has locked Rectangles, and we want to complete lock it\n"));
     4532      // If anything is locked we can't lock the complete surface
     4533      dprintf(("DDRAW: Surface has locked Rectangles and we want to completely lock it\n"));
    46374534      Found = TRUE;
    46384535    }
    … …  
    46424539      // be locked so check for this
    46434540
    4644       dprintf(("DDRAW: Surface has locked Rectangles, check if the overlap\n"));
     4541      dprintf(("DDRAW: Surface has locked Rectangles, check if they overlap\n"));
    46454542
    46464543      i=0;
    … …  
    46644561    {
    46654562      delete pIRectNew;
    4666       #ifdef DEBUG
    4667         dprintf(("DDRAW: SurfLock4: Surface already locked\n\n"));
    4668       #endif
     4563      dprintf(("DDRAW: SurfLock4: Surface already locked\n\n"));
    46694564      rc = DDERR_SURFACEBUSY;
    46704565    }
    … …  
    46814576                                  (lpRect->top * me->dwPitchFB) +
    46824577                                  (lpRect->left * (lpSurfaceDesc->ddpfPixelFormat.dwRGBBitCount>>3)));
    4683       #ifdef DEBUG
    4684         dprintf(("DDRAW: SurfLock4 %08X (x,y) = (%d,%d)\n\n", lpSurfaceDesc->lpSurface, lpRect->top, lpRect->left));
    4685       #endif
     4578      dprintf(("DDRAW: SurfLock4 %08X (x,y) = (%d,%d)\n\n", lpSurfaceDesc->lpSurface, lpRect->top, lpRect->left));
    46864579    }
    46874580    else
    46884581    {
    4689       #ifdef DEBUG
    4690         dprintf(("DDRAW: SurfLock4 %08X \n\n", lpSurfaceDesc->lpSurface));
    4691       #endif
     4582      dprintf(("DDRAW: SurfLock4 %08X \n\n", lpSurfaceDesc->lpSurface));
    46924583    }
    46934584    // Add the rectangle to the list of locked rectangles
    … …  
    47074598//******************************************************************************
    47084599//******************************************************************************
    4709 HRESULT __stdcall SurfReleaseDC(THIS This, HDC hdc)
     4600HRESULT WIN32API SurfReleaseDC(THIS This, HDC hdc)
    47104601{
    47114602 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    47154606   RGBQUAD           bmiCols[256];
    47164607 } BitmapInfo;
    4717  BITMAP bmpData;
    4718  char szError[256];
    4719  int i,rc;
    4720 
    4721   #ifdef DEBUG
    4722     dprintf(("DDRAW: SurfReleaseDC\n"));
    4723   #endif
     4608// BITMAP bmpData;
     4609 int rc;
     4610
     4611  dprintf(("DDRAW: SurfReleaseDC\n"));
    47244612
    47254613  if(hdc != me->hdcImage)
    … …  
    47514639                      (PBITMAPINFO)&BitmapInfo,
    47524640                      DIB_RGB_COLORS);
     4641//      BitmapInfo.bmiHead.biHeight = -BitmapInfo.bmiHead.biHeight;
    47534642      dprintf( ("GetDIBits rc=%d\n Size   :%d\n Width  :%d\n Height :%d\n"
    47544643                " Planes :%d\n BitCount :%d\nLastEror = %d\nPixel[0,0] = 0x%02X\n",
    … …  
    47614650                GetLastError(),
    47624651                ((char*)me->DDSurfaceDesc.lpSurface)[0]));
     4652
    47634653      rc = GetDIBits( hdc,
    47644654                      me->hbmImage,
    … …  
    47894679      break;
    47904680    default:
    4791       #ifdef DEBUG
    4792         dprintf(("DDRAW: Unexptected BitCount %d => Surface unlocked but no data copied back\n",me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
    4793       #endif
     4681      dprintf(("DDRAW: Unexpected BitCount %d => Surface unlocked but no data copied back\n",me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
    47944682      // we might could keep the surface locked and return an error but this is more "safe"
    47954683      break;
    … …  
    48144702//******************************************************************************
    48154703//******************************************************************************
    4816 HRESULT __stdcall SurfRestore(THIS)
    4817 {
    4818   #ifdef DEBUG
    4819     dprintf(("DDRAW: SurfRestore\n"));
    4820   #endif
     4704HRESULT WIN32API SurfRestore(THIS)
     4705{
     4706  dprintf(("DDRAW: SurfRestore\n"));
    48214707
    48224708  return(DD_OK);
    … …  
    48244710//******************************************************************************
    48254711//******************************************************************************
    4826 HRESULT __stdcall SurfSetClipper(THIS This, LPDIRECTDRAWCLIPPER lpClipper)
     4712HRESULT WIN32API SurfSetClipper(THIS This, LPDIRECTDRAWCLIPPER lpClipper)
    48274713{
    48284714 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    48294715
    4830   #ifdef DEBUG
    4831     dprintf(("DDRAW: SurfSetClipper\n"));
    4832   #endif
     4716  dprintf(("DDRAW: SurfSetClipper %x %x", This, lpClipper));
    48334717
    48344718  if(lpClipper == NULL)
    … …  
    48614745//******************************************************************************
    48624746//******************************************************************************
    4863 HRESULT __stdcall SurfSetColorKey(THIS  This, DWORD dwFlags, LPDDCOLORKEY lpDDColKey)
     4747HRESULT WIN32API SurfSetColorKey(THIS  This, DWORD dwFlags, LPDDCOLORKEY lpDDColKey)
    48644748{
    48654749  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    49134797//******************************************************************************
    49144798//******************************************************************************
    4915 HRESULT __stdcall SurfSetOverlayPosition(THIS This, LONG lX, LONG lY)
     4799HRESULT WIN32API SurfSetOverlayPosition(THIS This, LONG lX, LONG lY)
    49164800{
    49174801  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    49184802
    4919   #ifdef DEBUG
    4920     dprintf(("DDRAW: SurfSetOverlayPosition\n"));
    4921   #endif
     4803  dprintf(("DDRAW: SurfSetOverlayPosition\n"));
    49224804
    49234805  if( (me->DDSurfaceDesc.dwFlags & DDSD_CAPS) &&
    … …  
    49424824//******************************************************************************
    49434825//******************************************************************************
    4944 HRESULT __stdcall SurfSetPalette(THIS This, LPDIRECTDRAWPALETTE lpPalette)
     4826HRESULT WIN32API SurfSetPalette(THIS This, LPDIRECTDRAWPALETTE lpPalette)
    49454827{
    49464828  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    49474829
    4948   #ifdef DEBUG
    4949     dprintf(("DDRAW: SurfSetPalette\n"));
    4950   #endif
     4830  dprintf(("DDRAW: SurfSetPalette\n"));
    49514831
    49524832  if(lpPalette == NULL)
    … …  
    49994879//******************************************************************************
    50004880//******************************************************************************
    5001 HRESULT __stdcall SurfUnlock(THIS This, LPVOID lpSurfaceData)
     4881HRESULT WIN32API SurfUnlock(THIS This, LPVOID lpSurfaceData)
    50024882{
    50034883
    … …  
    50094889  HRESULT rc;
    50104890
    5011   #ifdef DEBUG
    5012     dprintf(("DDRAW: SurfUnlock at %08X\n",lpSurfaceData));
    5013   #endif
     4891  dprintf(("DDRAW: SurfUnlock at %08X\n",lpSurfaceData));
    50144892
    50154893  if(me->fLocked == FALSE)
    50164894  {
    5017     #ifdef DEBUG
    5018       dprintf(("DDRAW: Surface not locked!\n"));
    5019     #endif
     4895    dprintf(("DDRAW: Surface not locked!\n"));
    50204896    return(DDERR_NOTLOCKED);
    50214897  }
    5022 
    5023   #ifdef DEBUG
    5024     dprintf(("DDRAW: Start Emuneration of Locked Rects\n"));
    5025   #endif
    50264898
    50274899  i=0;
    … …  
    50334905    // this pointer in the locked rects DPA to unlock the right rect.
    50344906
    5035     while(i<DPA_GetPtrCount(me->DPA_LockedRects) && !Found)
     4907    while(i < DPA_GetPtrCount(me->DPA_LockedRects) && !Found)
    50364908    {
    50374909      pIRectEnum = (DDRectangle*)DPA_FastGetPtr(me->DPA_LockedRects,i);
    … …  
    50474919      if(!Found)
    50484920      {
    5049         #ifdef DEBUG
    5050           dprintf(("DDRAW: Not Found, try Next rect\n"));
    5051         #endif
     4921        dprintf(("DDRAW: Not Found, try Next rect\n"));
    50524922        i++;
    50534923      }
    5054       #ifdef DEBUG
    50554924      else
    50564925      {
    50574926        dprintf(("DDRAW: Found Rect\n"));
    50584927      }
    5059       #endif
    50604928    }
    50614929  }
    … …  
    50824950      if(!Found)
    50834951      {
    5084         #ifdef DEBUG
    5085           dprintf(("DDRAW: Not Found, try Next rect\n"));
    5086         #endif
     4952        dprintf(("DDRAW: Not Found, try Next rect\n"));
    50874953        i++;
    50884954      }
    5089       #ifdef DEBUG
    50904955      else
    50914956      {
    50924957        dprintf(("DDRAW: Found Rect\n"));
    50934958      }
    5094       #endif
    50954959    }
    50964960    delete pIRectUnlock;
    … …  
    50994963  if(!Found)
    51004964  {
    5101     #ifdef DEBUG
    5102       dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
    5103     #endif
     4965    dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
    51044966    rc = DDERR_INVALIDRECT;
    51054967  }
    51064968  else
    51074969  {
    5108     #ifdef DEBUG
    5109       dprintf(("DDRAW: Remove Rect %d from Seq.\n",i));
    5110     #endif
     4970    dprintf(("DDRAW: Remove Rect %d from Seq.\n",i));
    51114971
    51124972    DPA_DeletePtr(me->DPA_LockedRects,i);
    51134973
    5114     #ifdef DEBUG
    5115       dprintf(("DDRAW: Test if locked Rects main\n"));
    5116     #endif
     4974    dprintf(("DDRAW: Test if locked Rects main\n"));
    51174975
    51184976    if(0==DPA_GetPtrCount(me->DPA_LockedRects))  // Do we have unlocked last rectangle
    51194977    {
    5120       #ifdef DEBUG
    5121         dprintf(("DDRAW: No Locked Rects left for surface\n"));
    5122       #endif
     4978      dprintf(("DDRAW: No Locked Rects left for surface\n"));
    51234979      me->fLocked = FALSE;
    51244980    }
    … …  
    51314987    if(me->pFrameBuffer != me->pDiveBuffer)
    51324988    {
    5133       #ifdef DEBUG
    5134         dprintf(( "ColorConversion Needed %08X != %08X\n",
    5135                   me->pFrameBuffer,
    5136                   me->pDiveBuffer));
    5137       #endif
     4989      dprintf(( "ColorConversion Needed %08X != %08X\n",
     4990                me->pFrameBuffer,
     4991                me->pDiveBuffer));
    51384992      if(NULL!=lpSurfaceData)
    51394993      {
    … …  
    51505004      }
    51515005    }
    5152     #ifdef DEBUG
    51535006    else
    51545007      dprintf( ("No ColorConversion Needed"));
    5155     #endif
    51565008
    51575009    // delete tne DDRectobject of the found rectangle
    … …  
    51695021//******************************************************************************
    51705022//******************************************************************************
    5171 HRESULT __stdcall SurfUnlock4(THIS This, LPRECT lpSurfaceRect)
     5023HRESULT WIN32API SurfUnlock4(THIS This, LPRECT lpSurfaceRect)
    51725024{
    51735025  // MS changed the parameter from LPVOID to LPRECT with DX6
    … …  
    51855037  HRESULT rc;
    51865038
    5187   #ifdef DEBUG
    5188     dprintf(("DDRAW: SurfUnlock4\n"));
    5189   #endif
     5039  dprintf(("DDRAW: SurfUnlock4\n"));
    51905040
    51915041  if(me->fLocked == FALSE)
    51925042  {
    5193     #ifdef DEBUG
    5194       dprintf(("DDRAW: Surface not locked!\n"));
    5195     #endif
     5043    dprintf(("DDRAW: Surface not locked!\n"));
    51965044    return(DDERR_NOTLOCKED);
    51975045  }
    … …  
    52175065            pIRectUnlock->Right() ));
    52185066
    5219   #ifdef DEBUG
    5220     dprintf(("DDRAW: Start Emuneration of Locked Rects\n"));
    5221   #endif
     5067  dprintf(("DDRAW: Start Enumeration of Locked Rects\n"));
    52225068
    52235069  i=0;
    … …  
    52345080    if(!Found)
    52355081    {
    5236       #ifdef DEBUG
    5237         dprintf(("DDRAW: Not Found, try Next rect\n"));
    5238       #endif
     5082      dprintf(("DDRAW: Not Found, try Next rect\n"));
    52395083      i++;
    52405084    }
    5241     #ifdef DEBUG
    52425085    else
    52435086    {
    52445087      dprintf(("DDRAW: Found Rect\n"));
    52455088    }
    5246     #endif
    52475089  }
    52485090
    … …  
    52525094    if(NULL==lpSurfaceRect)
    52535095    {
    5254       #ifdef DEBUG
    5255         dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
    5256       #endif
     5096      dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
    52575097      return(DDERR_INVALIDRECT);
    52585098    }
    … …  
    52625102  else
    52635103  {
    5264     #ifdef DEBUG
    5265       dprintf(("DDRAW: Remove Rect from Seq.\n"));
    5266     #endif
     5104    dprintf(("DDRAW: Remove Rect from Seq.\n"));
    52675105
    52685106    DPA_DeletePtr(me->DPA_LockedRects,i);
    … …  
    52705108    if(0==DPA_GetPtrCount(me->DPA_LockedRects))  // Do we have unlocked last rectangle
    52715109    {
    5272       #ifdef DEBUG
    5273         dprintf(("DDRAW: No Locked Rects left for surface\n"));
    5274       #endif
     5110      dprintf(("DDRAW: No Locked Rects left for surface\n"));
    52755111      me->fLocked = FALSE;
    52765112    }
    … …  
    52785114    if(me->pFrameBuffer != me->pDiveBuffer)
    52795115    {
    5280       #ifdef DEBUG
    5281         dprintf(( "ColorConversion Needed %08X != %08X\n",
    5282                   me->pFrameBuffer,
    5283                   me->pDiveBuffer));
    5284       #endif
     5116      dprintf(( "ColorConversion Needed %08X != %08X\n",
     5117                me->pFrameBuffer,
     5118                me->pDiveBuffer));
    52855119      me->ColorConversion(lpSurfaceRect);
    52865120    }
    … …  
    52965130//******************************************************************************
    52975131//******************************************************************************
    5298 HRESULT __stdcall SurfUpdateOverlay(THIS This, LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX)
    5299 {
    5300   #ifdef DEBUG
    5301     dprintf(("DDRAW: SurfUpdateOverlay\n"));
    5302   #endif
     5132HRESULT WIN32API SurfUpdateOverlay(THIS This, LPRECT, LPDIRECTDRAWSURFACE2,LPRECT,DWORD, LPDDOVERLAYFX)
     5133{
     5134  dprintf(("DDRAW: SurfUpdateOverlay\n"));
    53035135  return(DD_OK);
    53045136}
    53055137//******************************************************************************
    53065138//******************************************************************************
    5307 HRESULT __stdcall SurfUpdateOverlay3(THIS This, LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX)
    5308 {
    5309   #ifdef DEBUG
    5310     dprintf(("DDRAW: SurfUpdateOverlay\n"));
    5311   #endif
     5139HRESULT WIN32API SurfUpdateOverlay3(THIS This, LPRECT, LPDIRECTDRAWSURFACE3,LPRECT,DWORD, LPDDOVERLAYFX)
     5140{
     5141  dprintf(("DDRAW: SurfUpdateOverlay\n"));
    53125142  return(DD_OK);
    53135143}
    53145144//******************************************************************************
    53155145//******************************************************************************
    5316 HRESULT __stdcall SurfUpdateOverlay4(THIS, LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX)
    5317 {
    5318   #ifdef DEBUG
    5319     dprintf(("DDRAW: SurfUpdateOverlay\n"));
    5320   #endif
     5146HRESULT WIN32API SurfUpdateOverlay4(THIS, LPRECT, LPDIRECTDRAWSURFACE4,LPRECT,DWORD, LPDDOVERLAYFX)
     5147{
     5148  dprintf(("DDRAW: SurfUpdateOverlay\n"));
    53215149  return(DD_OK);
    53225150}
    53235151//******************************************************************************
    53245152//******************************************************************************
    5325 HRESULT __stdcall SurfUpdateOverlayDisplay(THIS, DWORD)
    5326 {
    5327   #ifdef DEBUG
    5328     dprintf(("DDRAW: SurfUpdateOverlayDisplay\n"));
    5329   #endif
     5153HRESULT WIN32API SurfUpdateOverlayDisplay(THIS, DWORD)
     5154{
     5155  dprintf(("DDRAW: SurfUpdateOverlayDisplay\n"));
    53305156  return(DD_OK);
    53315157}
    53325158//******************************************************************************
    53335159//******************************************************************************
    5334 HRESULT __stdcall SurfUpdateOverlayZOrder(THIS, DWORD, LPDIRECTDRAWSURFACE2)
    5335 {
    5336   #ifdef DEBUG
    5337     dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
    5338   #endif
     5160HRESULT WIN32API SurfUpdateOverlayZOrder(THIS, DWORD, LPDIRECTDRAWSURFACE2)
     5161{
     5162  dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
    53395163  return(DD_OK);
    53405164}
    53415165//******************************************************************************
    53425166//******************************************************************************
    5343 HRESULT __stdcall SurfUpdateOverlayZOrder3(THIS, DWORD, LPDIRECTDRAWSURFACE3)
    5344 {
    5345   #ifdef DEBUG
    5346     dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
    5347   #endif
     5167HRESULT WIN32API SurfUpdateOverlayZOrder3(THIS, DWORD, LPDIRECTDRAWSURFACE3)
     5168{
     5169  dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
    53485170  return(DD_OK);
    53495171}
    53505172//******************************************************************************
    53515173//******************************************************************************
    5352 HRESULT __stdcall SurfUpdateOverlayZOrder4(THIS, DWORD, LPDIRECTDRAWSURFACE4)
    5353 {
    5354   #ifdef DEBUG
    5355     dprintf(("DDRAW: SurfUpdateOverlayZOrder4\n"));
    5356   #endif
     5174HRESULT WIN32API SurfUpdateOverlayZOrder4(THIS, DWORD, LPDIRECTDRAWSURFACE4)
     5175{
     5176  dprintf(("DDRAW: SurfUpdateOverlayZOrder4\n"));
    53575177  return(DD_OK);
    53585178}
    53595179//******************************************************************************
    53605180//******************************************************************************
    5361 HRESULT __stdcall SurfGetDDInterface(THIS This, LPVOID FAR *lplpDirectDraw)
     5181HRESULT WIN32API SurfGetDDInterface(THIS This, LPVOID FAR *lplpDirectDraw)
    53625182{
    53635183 OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    53645184
    5365   #ifdef DEBUG
    5366     dprintf(("DDRAW: SurfGetDDInterface\n"));
    5367   #endif
     5185  dprintf(("DDRAW: SurfGetDDInterface\n"));
    53685186  *lplpDirectDraw = (LPVOID FAR *)me->lpDraw;
    53695187  return(DD_OK);
    … …  
    53715189//******************************************************************************
    53725190//******************************************************************************
    5373 HRESULT __stdcall SurfPageLock(THIS, DWORD)
     5191HRESULT WIN32API SurfPageLock(THIS, DWORD)
    53745192{
    53755193  // Only used for DMA memory access
    53765194  // If we implement this for the None dive buffers with a pdd the we must change
    53775195  // from malloc to DosAllocMem and use OBJ_TILE flag
    5378   #ifdef DEBUG
    5379     dprintf(("DDRAW: SurfPageLock\n"));
    5380   #endif
     5196  dprintf(("DDRAW: SurfPageLock\n"));
    53815197  return(DD_OK);
    53825198}
    53835199//******************************************************************************
    53845200//******************************************************************************
    5385 HRESULT __stdcall SurfPageUnlock(THIS, DWORD)
    5386 {
    5387   #ifdef DEBUG
    5388     dprintf(("DDRAW: SurfPageUnlock\n"));
    5389   #endif
     5201HRESULT WIN32API SurfPageUnlock(THIS, DWORD)
     5202{
     5203  dprintf(("DDRAW: SurfPageUnlock\n"));
    53905204  return(DD_OK);
    53915205}
    … …  
    53945208// V3 Interface Functions
    53955209
    5396 HRESULT __stdcall SurfSetSurfaceDesc(THIS This, LPDDSURFACEDESC lpSurfDesc, DWORD dwFlags)
    5397 {
    5398   #ifdef DEBUG
    5399     dprintf(("DDRAW: SurfSetSurfaceDesc\n"));
    5400   #endif
     5210HRESULT WIN32API SurfSetSurfaceDesc(THIS This, LPDDSURFACEDESC lpSurfDesc, DWORD dwFlags)
     5211{
     5212  dprintf(("DDRAW: SurfSetSurfaceDesc\n"));
    54015213
    54025214  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    54415253//******************************************************************************
    54425254//******************************************************************************
    5443 HRESULT __stdcall SurfSetSurfaceDesc4(THIS This, LPDDSURFACEDESC2 lpSurfDesc, DWORD dwFlags)
    5444 {
    5445   #ifdef DEBUG
    5446     dprintf(("DDRAW: SurfSetSurfaceDesc4\n"));
    5447   #endif
     5255HRESULT WIN32API SurfSetSurfaceDesc4(THIS This, LPDDSURFACEDESC2 lpSurfDesc, DWORD dwFlags)
     5256{
     5257  dprintf(("DDRAW: SurfSetSurfaceDesc4\n"));
    54485258
    54495259  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    54915301// V4 Interface Functions
    54925302
    5493 HRESULT __stdcall SurfSetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData,
     5303HRESULT WIN32API SurfSetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData,
    54945304                                     DWORD dwDataSize, DWORD dwFlags)
    54955305{
    … …  
    55015311  HRESULT rc;
    55025312
    5503   #ifdef DEBUG
    5504     dprintf(("DDRAW: SurfSetPrivateData\n"));
    5505   #endif
     5313  dprintf(("DDRAW: SurfSetPrivateData\n"));
    55065314
    55075315  if(NULL==me)
    … …  
    56765484//******************************************************************************
    56775485//******************************************************************************
    5678 HRESULT __stdcall SurfGetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData, LPDWORD lpDataSize)
     5486HRESULT WIN32API SurfGetPrivateData(THIS This, REFGUID refGUID, LPVOID lpData, LPDWORD lpDataSize)
    56795487{
    56805488  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    56845492  BOOL bFound = FALSE;
    56855493
    5686   #ifdef DEBUG
    5687     dprintf(("DDRAW: SurfGetPrivateData\n"));
    5688   #endif
     5494  dprintf(("DDRAW: SurfGetPrivateData\n"));
    56895495
    56905496  if(NULL==me)
    … …  
    57375543//******************************************************************************
    57385544//******************************************************************************
    5739 HRESULT __stdcall SurfFreePrivateData(THIS This, REFGUID refGUID)
     5545HRESULT WIN32API SurfFreePrivateData(THIS This, REFGUID refGUID)
    57405546{
    57415547  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    57445550  BOOL bFound = FALSE;
    57455551
    5746   #ifdef DEBUG
    5747     dprintf(("DDRAW: SurfFreePrivateData\n"));
    5748   #endif
     5552  dprintf(("DDRAW: SurfFreePrivateData\n"));
    57495553
    57505554  if(NULL==me)
    … …  
    57875591//******************************************************************************
    57885592//******************************************************************************
    5789 HRESULT __stdcall SurfGetUniquenessValue(THIS This, LPDWORD lpValue)
    5790 {
    5791   #ifdef DEBUG
    5792     dprintf(("DDRAW: SurfGetUniquenessValue\n"));
    5793   #endif
     5593HRESULT WIN32API SurfGetUniquenessValue(THIS This, LPDWORD lpValue)
     5594{
     5595  dprintf(("DDRAW: SurfGetUniquenessValue\n"));
    57945596  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    57955597  if (NULL==lpValue)
    … …  
    58015603//******************************************************************************
    58025604//******************************************************************************
    5803 HRESULT __stdcall SurfChangeUniquenessValue(THIS This)
     5605HRESULT WIN32API SurfChangeUniquenessValue(THIS This)
    58045606{
    58055607  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    58085610
    58095611
    5810   #ifdef DEBUG
    5811     dprintf(("DDRAW: SurfChangeUniquenessValue\n"));
    5812   #endif
     5612  dprintf(("DDRAW: SurfChangeUniquenessValue\n"));
    58135613  me->dwUniqueValue++;
    58145614
    … …  
    59645764  DWORD dwTLineStart;     // # DWORD in which the first transinfo is
    59655765  DWORD dwTDWStart;       // byte in which the firs transinfo is
    5966   DWORD dwTrans;          // current transparentvalue
    5967   DWORD BlitWidth;
     5766
    59685767  dwTLineLen = 1 + ((pSrcDesc->dwWidth + 31) & ~31);
    59695768  pdwTLine = (DWORD*)pAlpha + (dwTLineLen* lpSrcRect->top);

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

    r3345 r5291  
    1 /* $Id: OS2UTIL.CPP,v 1.1 2000-04-07 18:21:08 mike Exp $ */
     1/* $Id: OS2UTIL.CPP,v 1.2 2001-03-09 22:48:48 mike Exp $ */
    22
    33/*
    … …  
    5757 USHORT sel = RestoreOS2FS();
    5858
    59  _GpiEnableYInversion( WinGetPS( Win32ToOS2Handle( WindowFromDC(hdc) ) ), lHeight);
     59// _GpiEnableYInversion( WinGetPS( Win32ToOS2Handle( WindowFromDC(hdc) ) ), lHeight);
    6060 SetFS(sel);
    6161

  • trunk/src/ddraw/new/ddraw.DEF

    r4970 r5291  
    1 ; $Id: ddraw.DEF,v 1.2 2001-01-19 02:06:55 mike Exp $
     1; $Id: ddraw.DEF,v 1.3 2001-03-09 22:48:48 mike Exp $
    22
    33;
    … …  
    55;
    66LIBRARY DDRAW INITINSTANCE TERMINSTANCE
    7 PROTMODE
    87DATA MULTIPLE NONSHARED READWRITE LOADONCALL
    98CODE LOADONCALL

  • trunk/src/ddraw/new/initterm.cpp

    r5135 r5291  
    5454   {
    5555   case DLL_PROCESS_ATTACH:
    56         return TRUE;
     56        return TRUE;
    5757
    5858   case DLL_THREAD_ATTACH:
    5959   case DLL_THREAD_DETACH:
    60         return TRUE;
     60        return TRUE;
    6161
    6262   case DLL_PROCESS_DETACH:
    63         ctordtorTerm();
    64         return TRUE;
     63        ctordtorTerm();
     64        return TRUE;
    6565   }
    6666   return FALSE;
    … …  
    9191         ctordtorInit();
    9292
    93          DosQueryModuleName(hModule, CCHMAXPATH, ddrawPath);
     93         DosQueryModuleName(hModule, CCHMAXPATH, ddrawPath);
    9494         char *endofpath = strrchr(ddrawPath, '\\');
    9595         if(endofpath) *(endofpath+1) = 0;
    … …  
    9797         CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
    9898
    99          if(RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab) == FALSE)
    100                 return 0UL;
     99         if(RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab) == FALSE)
     100                return 0UL;
    101101
    102102         rc = DosExitList(EXITLIST_NONCOREDLL|EXLST_ADD, cleanup);
    … …  
    108108      case 1 :
    109109         // TODO: We must restore display, only when display was changed.
    110         UnregisterLxDll(hModule);
     110        UnregisterLxDll(hModule);
    111111         break;
    112112      default  :
    … …  
    126126   dprintf(("ddraw exit\n"));
    127127   RestorePM();
    128    _ctordtorTerm();
     128   ctordtorTerm();
    129129   dprintf(("ddraw exit done\n"));
    130130
Note: See TracChangeset for help on using the changeset viewer.