Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-01 03:29:37 +00:00
Code Issues Projects Releases Packages Wiki Activity

fixing more format from tab to space

Browse source 
svn path=/trunk/; revision=25148
This commit is contained in:
Magnus Olsen 2006-12-13 21:28:52 +00:00
parent ca82e66f85
commit b7bb710426
4 changed files with 430 additions and 445 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

60
reactos/dll/directx/ddraw/callbacks_hel.c
View file

@ -20,82 +20,82 @@ extern DWORD pixelformatsCount;
DWORD CALLBACK HelDdDestroyDriver(LPDDHAL_DESTROYDRIVERDATA lpDestroyDriver) DWORD CALLBACK HelDdDestroyDriver(LPDDHAL_DESTROYDRIVERDATA lpDestroyDriver)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdCreateSurface(LPDDHAL_CREATESURFACEDATA lpCreateSurface) DWORD CALLBACK HelDdCreateSurface(LPDDHAL_CREATESURFACEDATA lpCreateSurface)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSetColorKey(LPDDHAL_DRVSETCOLORKEYDATA lpDrvSetColorKey) DWORD CALLBACK HelDdSetColorKey(LPDDHAL_DRVSETCOLORKEYDATA lpDrvSetColorKey)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSetMode(LPDDHAL_SETMODEDATA SetMode) DWORD CALLBACK HelDdSetMode(LPDDHAL_SETMODEDATA SetMode)
{ {
DEVMODE DevMode; DEVMODE DevMode;
DX_STUB_str("in hel"); DX_STUB_str("in hel");
DevMode.dmSize = (WORD)sizeof(DEVMODE); DevMode.dmSize = (WORD)sizeof(DEVMODE);
DevMode.dmDriverExtra = 0; DevMode.dmDriverExtra = 0;
SetMode->ddRVal = DDERR_UNSUPPORTEDMODE; SetMode->ddRVal = DDERR_UNSUPPORTEDMODE;
if (EnumDisplaySettingsEx(NULL, SetMode->dwModeIndex, &DevMode, 0 ) != 0) if (EnumDisplaySettingsEx(NULL, SetMode->dwModeIndex, &DevMode, 0 ) != 0)
{ {
DX_WINDBG_trace_res((int)DevMode.dmPelsWidth, (int)DevMode.dmPelsHeight, (int)DevMode.dmBitsPerPel ); DX_WINDBG_trace_res((int)DevMode.dmPelsWidth, (int)DevMode.dmPelsHeight, (int)DevMode.dmBitsPerPel );
if (ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) if (ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{ {
DX_STUB_str("FAIL"); DX_STUB_str("FAIL");
SetMode->ddRVal = DDERR_UNSUPPORTEDMODE; SetMode->ddRVal = DDERR_UNSUPPORTEDMODE;
} }
else else
{ {
DX_STUB_str("OK"); DX_STUB_str("OK");
SetMode->ddRVal = DD_OK; SetMode->ddRVal = DD_OK;
} }
} }
return DDHAL_DRIVER_HANDLED; return DDHAL_DRIVER_HANDLED;
} }
DWORD CALLBACK HelDdWaitForVerticalBlank(LPDDHAL_WAITFORVERTICALBLANKDATA lpWaitForVerticalBlank) DWORD CALLBACK HelDdWaitForVerticalBlank(LPDDHAL_WAITFORVERTICALBLANKDATA lpWaitForVerticalBlank)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdCanCreateSurface(LPDDHAL_CANCREATESURFACEDATA lpCanCreateSurface) DWORD CALLBACK HelDdCanCreateSurface(LPDDHAL_CANCREATESURFACEDATA lpCanCreateSurface)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdCreatePalette(LPDDHAL_CREATEPALETTEDATA lpCreatePalette) DWORD CALLBACK HelDdCreatePalette(LPDDHAL_CREATEPALETTEDATA lpCreatePalette)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdGetScanLine(LPDDHAL_GETSCANLINEDATA lpGetScanLine) DWORD CALLBACK HelDdGetScanLine(LPDDHAL_GETSCANLINEDATA lpGetScanLine)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSetExclusiveMode(LPDDHAL_SETEXCLUSIVEMODEDATA lpSetExclusiveMode) DWORD CALLBACK HelDdSetExclusiveMode(LPDDHAL_SETEXCLUSIVEMODEDATA lpSetExclusiveMode)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB_str("Not implement yet, return DD_OK for not bsod\n"); DX_STUB_str("Not implement yet, return DD_OK for not bsod\n");
lpSetExclusiveMode->ddRVal = DD_OK; lpSetExclusiveMode->ddRVal = DD_OK;
return DDHAL_DRIVER_HANDLED; return DDHAL_DRIVER_HANDLED;
} }
DWORD CALLBACK HelDdFlipToGDISurface(LPDDHAL_FLIPTOGDISURFACEDATA lpFlipToGDISurface) DWORD CALLBACK HelDdFlipToGDISurface(LPDDHAL_FLIPTOGDISURFACEDATA lpFlipToGDISurface)
{ {
DX_STUB; DX_STUB;
} }

35
reactos/dll/directx/ddraw/callbacks_surf_hel.c
View file

@ -16,78 +16,77 @@
DWORD CALLBACK HelDdSurfAddAttachedSurface(LPDDHAL_ADDATTACHEDSURFACEDATA lpDestroySurface) DWORD CALLBACK HelDdSurfAddAttachedSurface(LPDDHAL_ADDATTACHEDSURFACEDATA lpDestroySurface)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfBlt(LPDDHAL_BLTDATA lpBltData) DWORD CALLBACK HelDdSurfBlt(LPDDHAL_BLTDATA lpBltData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfDestroySurface(LPDDHAL_DESTROYSURFACEDATA lpDestroySurfaceData) DWORD CALLBACK HelDdSurfDestroySurface(LPDDHAL_DESTROYSURFACEDATA lpDestroySurfaceData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfFlip(LPDDHAL_FLIPDATA lpFlipData) DWORD CALLBACK HelDdSurfFlip(LPDDHAL_FLIPDATA lpFlipData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfGetBltStatus(LPDDHAL_GETBLTSTATUSDATA lpGetBltStatusData) DWORD CALLBACK HelDdSurfGetBltStatus(LPDDHAL_GETBLTSTATUSDATA lpGetBltStatusData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfGetFlipStatus(LPDDHAL_GETFLIPSTATUSDATA lpGetFlipStatusData) DWORD CALLBACK HelDdSurfGetFlipStatus(LPDDHAL_GETFLIPSTATUSDATA lpGetFlipStatusData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfLock(LPDDHAL_LOCKDATA lpLockData) DWORD CALLBACK HelDdSurfLock(LPDDHAL_LOCKDATA lpLockData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfreserved4(DWORD *lpPtr) DWORD CALLBACK HelDdSurfreserved4(DWORD *lpPtr)
{ {
/* /*
This api is not doucment by MS So I leave it This api is not doucment by MS So I leave it
as stub. as stub.
*/ */
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfSetClipList(LPDDHAL_SETCLIPLISTDATA lpSetClipListData) DWORD CALLBACK HelDdSurfSetClipList(LPDDHAL_SETCLIPLISTDATA lpSetClipListData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfSetColorKey(LPDDHAL_SETCOLORKEYDATA lpSetColorKeyData) DWORD CALLBACK HelDdSurfSetColorKey(LPDDHAL_SETCOLORKEYDATA lpSetColorKeyData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfSetOverlayPosition(LPDDHAL_SETOVERLAYPOSITIONDATA lpSetOverlayPositionData) DWORD CALLBACK HelDdSurfSetOverlayPosition(LPDDHAL_SETOVERLAYPOSITIONDATA lpSetOverlayPositionData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfSetPalette(LPDDHAL_SETPALETTEDATA lpSetPaletteData) DWORD CALLBACK HelDdSurfSetPalette(LPDDHAL_SETPALETTEDATA lpSetPaletteData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfUnlock(LPDDHAL_UNLOCKDATA lpUnLockData) DWORD CALLBACK HelDdSurfUnlock(LPDDHAL_UNLOCKDATA lpUnLockData)
{ {
DX_STUB; DX_STUB;
} }
DWORD CALLBACK HelDdSurfUpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA lpUpDateOveryLayData) DWORD CALLBACK HelDdSurfUpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA lpUpDateOveryLayData)
{ {
DX_STUB; DX_STUB;
} }

2
reactos/dll/directx/ddraw/cleanup.c
View file

@ -21,5 +21,3 @@ Cleanup(LPDIRECTDRAW7 iface)
} }

670
reactos/dll/directx/ddraw/main/ddraw_main.c
View file

@ -8,34 +8,27 @@
* *
*/ */
/*
* IMPLEMENT
* Status ok
*/
#include "../rosdraw.h" #include "../rosdraw.h"
HRESULT HRESULT
WINAPI WINAPI
Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 iface, Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 iface,
REFIID id, REFIID id,
LPVOID *obj) LPVOID *obj)
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
/* fixme /* fixme
the D3D object cab be optain from here the D3D object cab be optain from here
Direct3D7 Direct3D7
*/ */
if (IsEqualGUID(&IID_IDirectDraw7, id)) if (IsEqualGUID(&IID_IDirectDraw7, id))
{ {
/* DirectDraw7 Vtable */ /* DirectDraw7 Vtable */
This->lpVtbl = &DirectDraw7_Vtable; This->lpVtbl = &DirectDraw7_Vtable;
*obj = &This->lpVtbl; *obj = &This->lpVtbl;
} }
else else
@ -47,6 +40,7 @@ Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 iface,
Main_DirectDraw_AddRef(iface); Main_DirectDraw_AddRef(iface);
return S_OK; return S_OK;
} }
/* /*
* IMPLEMENT * IMPLEMENT
* Status ok * Status ok
@ -57,59 +51,56 @@ Main_DirectDraw_AddRef (LPDIRECTDRAW7 iface)
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
This->dwIntRefCnt++; This->dwIntRefCnt++;
This->lpLcl->dwLocalRefCnt++; This->lpLcl->dwLocalRefCnt++;
if (This->lpLcl->lpGbl != NULL) if (This->lpLcl->lpGbl != NULL)
{ {
This->lpLcl->lpGbl->dwRefCnt++; This->lpLcl->lpGbl->dwRefCnt++;
} }
} }
return This->dwIntRefCnt; return This->dwIntRefCnt;
} }
/*
* IMPLEMENT
* Status ok
*/
ULONG ULONG
WINAPI WINAPI
Main_DirectDraw_Release (LPDIRECTDRAW7 iface) Main_DirectDraw_Release (LPDIRECTDRAW7 iface)
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
This->lpLcl->dwLocalRefCnt--; This->lpLcl->dwLocalRefCnt--;
This->dwIntRefCnt--; This->dwIntRefCnt--;
if (This->lpLcl->lpGbl != NULL) if (This->lpLcl->lpGbl != NULL)
{ {
This->lpLcl->lpGbl->dwRefCnt--; This->lpLcl->lpGbl->dwRefCnt--;
} }
if ( This->dwIntRefCnt == 0) if ( This->dwIntRefCnt == 0)
{ {
// set resoltion back to the one in registry // set resoltion back to the one in registry
/*if(This->cooperative_level & DDSCL_EXCLUSIVE) /*if(This->cooperative_level & DDSCL_EXCLUSIVE)
{ {
ChangeDisplaySettings(NULL, 0); ChangeDisplaySettings(NULL, 0);
}*/ }*/
Cleanup(iface); Cleanup(iface);
if (This!=NULL) if (This!=NULL)
{ {
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
} }
} }
} }
return This ? This->dwIntRefCnt : 0; return This ? This->dwIntRefCnt : 0;
} }
/* /*
@ -120,7 +111,7 @@ HRESULT
WINAPI WINAPI
Main_DirectDraw_Compact(LPDIRECTDRAW7 iface) Main_DirectDraw_Compact(LPDIRECTDRAW7 iface)
{ {
/* MSDN say not implement but my question what does it return then */ /* MSDN say not implement but my question what does it return then */
DX_WINDBG_trace(); DX_WINDBG_trace();
return DD_OK; return DD_OK;
} }
@ -132,44 +123,41 @@ Main_DirectDraw_Compact(LPDIRECTDRAW7 iface)
HRESULT HRESULT
WINAPI WINAPI
Main_DirectDraw_CreateClipper(LPDIRECTDRAW7 iface, Main_DirectDraw_CreateClipper(LPDIRECTDRAW7 iface,
DWORD dwFlags, DWORD dwFlags,
LPDIRECTDRAWCLIPPER *ppClipper, LPDIRECTDRAWCLIPPER *ppClipper,
IUnknown *pUnkOuter) IUnknown *pUnkOuter)
{ {
//LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; //LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
LPDDRAWI_DDRAWCLIPPER_INT That; LPDDRAWI_DDRAWCLIPPER_INT That;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (pUnkOuter!=NULL) if (pUnkOuter!=NULL)
{ {
return CLASS_E_NOAGGREGATION; return CLASS_E_NOAGGREGATION;
} }
That = (LPDDRAWI_DDRAWCLIPPER_INT) DxHeapMemAlloc(sizeof(DDRAWI_DDRAWCLIPPER_INT));
That = (LPDDRAWI_DDRAWCLIPPER_INT) DxHeapMemAlloc(sizeof(DDRAWI_DDRAWCLIPPER_INT));
if (That == NULL) if (That == NULL)
{ {
return DDERR_OUTOFMEMORY; //E_OUTOFMEMORY; return DDERR_OUTOFMEMORY; //E_OUTOFMEMORY;
} }
That->lpVtbl = &DirectDrawClipper_Vtable; That->lpVtbl = &DirectDrawClipper_Vtable;
*ppClipper = (LPDIRECTDRAWCLIPPER)That; *ppClipper = (LPDIRECTDRAWCLIPPER)That;
DirectDrawClipper_AddRef((LPDIRECTDRAWCLIPPER)That); DirectDrawClipper_AddRef((LPDIRECTDRAWCLIPPER)That);
return DirectDrawClipper_Initialize((LPDIRECTDRAWCLIPPER)That, (LPDIRECTDRAW)iface, dwFlags); return DirectDrawClipper_Initialize((LPDIRECTDRAWCLIPPER)That, (LPDIRECTDRAW)iface, dwFlags);
} }
HRESULT WINAPI Main_DirectDraw_CreatePalette(LPDIRECTDRAW7 iface, DWORD dwFlags, HRESULT WINAPI Main_DirectDraw_CreatePalette(LPDIRECTDRAW7 iface, DWORD dwFlags,
LPPALETTEENTRY palent, LPDIRECTDRAWPALETTE* ppPalette, LPUNKNOWN pUnkOuter) LPPALETTEENTRY palent, LPDIRECTDRAWPALETTE* ppPalette, LPUNKNOWN pUnkOuter)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
@ -181,144 +169,142 @@ HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDE
LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter) LPDIRECTDRAWSURFACE7 *ppSurf, IUnknown *pUnkOuter)
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
LPDDRAWI_DDRAWSURFACE_INT That; LPDDRAWI_DDRAWSURFACE_INT That;
DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface; DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface;
DDHAL_CREATESURFACEDATA mDdCreateSurface; DDHAL_CREATESURFACEDATA mDdCreateSurface;
/* /*
* check if pUnkOuter is NULL if it is not fail * check if pUnkOuter is NULL if it is not fail
* for accrdiong msdn and own test this member is not * for accrdiong msdn and own test this member is not
* set. * set.
*/ */
if (pUnkOuter!=NULL) if (pUnkOuter!=NULL)
{ {
return CLASS_E_NOAGGREGATION; return CLASS_E_NOAGGREGATION;
} }
/* Check so it is vaild pointer we got of ppSurf */ /* Check so it is vaild pointer we got of ppSurf */
if (IsBadWritePtr( ppSurf, sizeof( LPDIRECTDRAWSURFACE7 )) ) if (IsBadWritePtr( ppSurf, sizeof( LPDIRECTDRAWSURFACE7 )) )
{ {
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
/* Check so it is vaild pointer we got of pDDSD /* Check so it is vaild pointer we got of pDDSD
*/ */
if (IsBadWritePtr( pDDSD, sizeof( LPDDSURFACEDESC2 )) ) if (IsBadWritePtr( pDDSD, sizeof( LPDDSURFACEDESC2 )) )
{ {
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
if (IsBadReadPtr(pDDSD, sizeof( LPDDSURFACEDESC2 )) ) if (IsBadReadPtr(pDDSD, sizeof( LPDDSURFACEDESC2 )) )
{ {
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
/* Check if it version 1 or version 2 of the DDSURFACEDESC struct /* Check if it version 1 or version 2 of the DDSURFACEDESC struct
* both struct are vaild. * both struct are vaild.
*/ */
if (sizeof(DDSURFACEDESC2)!=pDDSD->dwSize) if (sizeof(DDSURFACEDESC2)!=pDDSD->dwSize)
{ {
return DDERR_UNSUPPORTED; return DDERR_UNSUPPORTED;
} }
/* here we need start fixing bugs /* here we need start fixing bugs
* the code above is 100% correct behovir * the code above is 100% correct behovir
* checked how ms ddraw behivor * checked how ms ddraw behivor
*/ */
/* FIXME
/* FIXME * Alloc memory for the ppSurf pointer
* Alloc memory for the ppSurf pointer * we expect it is NULL, But we maybe should add a NULL check
* we expect it is NULL, But we maybe should add a NULL check * for it, so we do not over write it, and also add a pointer vaildate
* for it, so we do not over write it, and also add a pointer vaildate * for it.
* for it. */
*/
That = (LPDDRAWI_DDRAWSURFACE_INT)DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_INT)); That = (LPDDRAWI_DDRAWSURFACE_INT)DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_INT));
if (That == NULL) if (That == NULL)
{ {
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
/* FIXME /* FIXME
Alloc memory for the local surface struct we need Alloc memory for the local surface struct we need
we should check if NULL or not see comment above we should check if NULL or not see comment above
*/ */
That->lpLcl = (LPDDRAWI_DDRAWSURFACE_LCL)DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_LCL)); That->lpLcl = (LPDDRAWI_DDRAWSURFACE_LCL)DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_LCL));
if (That->lpLcl == NULL) if (That->lpLcl == NULL)
{ {
/* shall we free it if it fail ?? */ /* shall we free it if it fail ?? */
DxHeapMemFree(That); DxHeapMemFree(That);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
/* Alloc memory for DDRAWI_DDRAWSURFACE_MORE */ /* Alloc memory for DDRAWI_DDRAWSURFACE_MORE */
That->lpLcl->lpSurfMore = DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_MORE)); That->lpLcl->lpSurfMore = DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_MORE));
if (That->lpLcl->lpSurfMore == NULL) if (That->lpLcl->lpSurfMore == NULL)
{ {
/* shall we free it if it fail ?? */ /* shall we free it if it fail ?? */
DxHeapMemFree(That->lpLcl); DxHeapMemFree(That->lpLcl);
DxHeapMemFree(That); DxHeapMemFree(That);
return DDERR_OUTOFMEMORY; return DDERR_OUTOFMEMORY;
} }
That->lpLcl->lpSurfMore->slist = DxHeapMemAlloc(sizeof(LPDDRAWI_DDRAWSURFACE_LCL)<<1); That->lpLcl->lpSurfMore->slist = DxHeapMemAlloc(sizeof(LPDDRAWI_DDRAWSURFACE_LCL)<<1);
if (That->lpLcl->lpSurfMore->slist == NULL) if (That->lpLcl->lpSurfMore->slist == NULL)
{ {
/* shall we free it if it fail ?? */ /* shall we free it if it fail ?? */
DxHeapMemFree(That->lpLcl->lpSurfMore); DxHeapMemFree(That->lpLcl->lpSurfMore);
DxHeapMemFree(That->lpLcl); DxHeapMemFree(That->lpLcl);
DxHeapMemFree(That); DxHeapMemFree(That);
return DDERR_OUTOFMEMORY; return DDERR_OUTOFMEMORY;
} }
/* setup some value */
*ppSurf = (LPDIRECTDRAWSURFACE7)That;
/* setup some value */ That->lpVtbl = &DirectDrawSurface7_Vtable;
*ppSurf = (LPDIRECTDRAWSURFACE7)That; That->lpLcl->lpGbl = &ddSurfGbl;
That->lpLcl->lpGbl->lpDD = &ddgbl;
That->lpLcl->lpSurfMore->dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);
That->lpLcl->lpSurfMore->lpDD_int = This;
That->lpLcl->lpSurfMore->lpDD_lcl = This->lpLcl;
That->lpLcl->lpSurfMore->slist[0] = That->lpLcl;
That->lpLcl->dwProcessId = GetCurrentProcessId();
That->lpVtbl = &DirectDrawSurface7_Vtable; /* this two line should be move to startup code */
That->lpLcl->lpGbl = &ddSurfGbl;
That->lpLcl->lpGbl->lpDD = &ddgbl;
That->lpLcl->lpSurfMore->dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);
That->lpLcl->lpSurfMore->lpDD_int = This;
That->lpLcl->lpSurfMore->lpDD_lcl = This->lpLcl;
That->lpLcl->lpSurfMore->slist[0] = That->lpLcl;
That->lpLcl->dwProcessId = GetCurrentProcessId();
/* this two line should be move to startup code */
That->lpLcl->lpGbl->lpDD = This->lpLcl->lpGbl; That->lpLcl->lpGbl->lpDD = This->lpLcl->lpGbl;
That->lpLcl->lpGbl->lpDDHandle = This->lpLcl->lpGbl; That->lpLcl->lpGbl->lpDDHandle = This->lpLcl->lpGbl;
/* setup the callback struct right /* setup the callback struct right
* maybe we should fill in * maybe we should fill in
* xx.lpDD, xx.function, xx.ddRVal * xx.lpDD, xx.function, xx.ddRVal
* in startup and do a cache of it * in startup and do a cache of it
* to save time ?? * to save time ??
*/ */
mDdCanCreateSurface.lpDD = This->lpLcl->lpGbl; mDdCanCreateSurface.lpDD = This->lpLcl->lpGbl;
mDdCanCreateSurface.bIsDifferentPixelFormat = FALSE; //isDifferentPixelFormat; mDdCanCreateSurface.bIsDifferentPixelFormat = FALSE; //isDifferentPixelFormat;
mDdCanCreateSurface.lpDDSurfaceDesc = (LPDDSURFACEDESC) pDDSD; mDdCanCreateSurface.lpDDSurfaceDesc = (LPDDSURFACEDESC) pDDSD;
mDdCanCreateSurface.CanCreateSurface = This->lpLcl->lpDDCB->cbDDCallbacks.CanCreateSurface; mDdCanCreateSurface.CanCreateSurface = This->lpLcl->lpDDCB->cbDDCallbacks.CanCreateSurface;
mDdCanCreateSurface.ddRVal = DDERR_GENERIC; mDdCanCreateSurface.ddRVal = DDERR_GENERIC;
mDdCreateSurface.lpDD = This->lpLcl->lpGbl; mDdCreateSurface.lpDD = This->lpLcl->lpGbl;
mDdCreateSurface.CreateSurface = This->lpLcl->lpDDCB->cbDDCallbacks.CreateSurface; mDdCreateSurface.CreateSurface = This->lpLcl->lpDDCB->cbDDCallbacks.CreateSurface;
mDdCreateSurface.ddRVal = DDERR_GENERIC; mDdCreateSurface.ddRVal = DDERR_GENERIC;
mDdCreateSurface.dwSCnt = That->dwIntRefCnt + 1; // is this correct mDdCreateSurface.dwSCnt = That->dwIntRefCnt + 1; // is this correct
mDdCreateSurface.lpDDSurfaceDesc = (LPDDSURFACEDESC) pDDSD; mDdCreateSurface.lpDDSurfaceDesc = (LPDDSURFACEDESC) pDDSD;
mDdCreateSurface.lplpSList = That->lpLcl->lpSurfMore->slist; mDdCreateSurface.lplpSList = That->lpLcl->lpSurfMore->slist;
if (pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) if (pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
{ {
This->lpLcl->lpPrimary = That; This->lpLcl->lpPrimary = That;
if (mDdCanCreateSurface.CanCreateSurface(&mDdCanCreateSurface)== DDHAL_DRIVER_NOTHANDLED) if (mDdCanCreateSurface.CanCreateSurface(&mDdCanCreateSurface)== DDHAL_DRIVER_NOTHANDLED)
{ {
@ -330,27 +316,26 @@ HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDE
return DDERR_NOTINITIALIZED; return DDERR_NOTINITIALIZED;
} }
/* FIXME /* FIXME
* check the value from pDDSD and use it as size * check the value from pDDSD and use it as size
*/ */
if (This->lpLcl->dwLocalFlags & DDRAWILCL_ISFULLSCREEN) if (This->lpLcl->dwLocalFlags & DDRAWILCL_ISFULLSCREEN)
{ {
That->lpLcl->lpGbl->wWidth = This->lpLcl->lpGbl->vmiData.dwDisplayWidth; That->lpLcl->lpGbl->wWidth = This->lpLcl->lpGbl->vmiData.dwDisplayWidth;
That->lpLcl->lpGbl->wHeight = This->lpLcl->lpGbl->vmiData.dwDisplayHeight; That->lpLcl->lpGbl->wHeight = This->lpLcl->lpGbl->vmiData.dwDisplayHeight;
That->lpLcl->lpGbl->lPitch = This->lpLcl->lpGbl->vmiData.lDisplayPitch; That->lpLcl->lpGbl->lPitch = This->lpLcl->lpGbl->vmiData.lDisplayPitch;
} }
else else
{ {
RECT rect; RECT rect;
if(GetWindowRect((HWND)This->lpLcl->hWnd, &rect))
if(GetWindowRect((HWND)This->lpLcl->hWnd, &rect)) {
{ That->lpLcl->lpGbl->wWidth = rect.right - rect.left;
That->lpLcl->lpGbl->wWidth = rect.right - rect.left; That->lpLcl->lpGbl->wHeight = rect.bottom - rect.top;
That->lpLcl->lpGbl->wHeight = rect.bottom - rect.top; That->lpLcl->lpGbl->lPitch = This->lpLcl->lpGbl->vmiData.lDisplayPitch;
That->lpLcl->lpGbl->lPitch = This->lpLcl->lpGbl->vmiData.lDisplayPitch; }
} }
}
// That->lpLcl->dwFlags = DDRAWISURF_PARTOFPRIMARYCHAIN|DDRAWISURF_HASOVERLAYDATA; // That->lpLcl->dwFlags = DDRAWISURF_PARTOFPRIMARYCHAIN|DDRAWISURF_HASOVERLAYDATA;
@ -360,7 +345,7 @@ HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDE
if (mDdCreateSurface.CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED) if (mDdCreateSurface.CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED)
{ {
return DDERR_NOTINITIALIZED; return DDERR_NOTINITIALIZED;
} }
if (mDdCreateSurface.ddRVal != DD_OK) if (mDdCreateSurface.ddRVal != DD_OK)
@ -391,7 +376,7 @@ HRESULT WINAPI Main_DirectDraw_CreateSurface (LPDIRECTDRAW7 iface, LPDDSURFACEDE
DX_STUB_str( "Can not create offscreenplain surface"); DX_STUB_str( "Can not create offscreenplain surface");
} }
DX_STUB_str("DDERR_INVALIDSURFACETYPE"); DX_STUB_str("DDERR_INVALIDSURFACETYPE");
return DDERR_INVALIDSURFACETYPE; return DDERR_INVALIDSURFACETYPE;
} }
@ -416,7 +401,7 @@ HRESULT WINAPI Main_DirectDraw_EnumDisplayModes(LPDIRECTDRAW7 iface, DWORD dwFla
LPDDSURFACEDESC2 pDDSD, LPVOID context, LPDDENUMMODESCALLBACK2 callback) LPDDSURFACEDESC2 pDDSD, LPVOID context, LPDDENUMMODESCALLBACK2 callback)
{ {
DX_STUB_DD_OK; DX_STUB_DD_OK;
// IDirectDrawImpl* This = (IDirectDrawImpl*)iface; // IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
// DDSURFACEDESC2 desc_callback; // DDSURFACEDESC2 desc_callback;
@ -583,26 +568,26 @@ HRESULT WINAPI
Main_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 iface) Main_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7 iface)
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DDHAL_FLIPTOGDISURFACEDATA mDdFlipToGDISurface; DDHAL_FLIPTOGDISURFACEDATA mDdFlipToGDISurface;
DX_WINDBG_trace(); DX_WINDBG_trace();
mDdFlipToGDISurface.ddRVal = DDERR_NOTINITIALIZED; mDdFlipToGDISurface.ddRVal = DDERR_NOTINITIALIZED;
mDdFlipToGDISurface.dwReserved = 0; mDdFlipToGDISurface.dwReserved = 0;
mDdFlipToGDISurface.dwToGDI = TRUE; mDdFlipToGDISurface.dwToGDI = TRUE;
mDdFlipToGDISurface.FlipToGDISurface = This->lpLcl->lpDDCB->cbDDCallbacks.FlipToGDISurface; mDdFlipToGDISurface.FlipToGDISurface = This->lpLcl->lpDDCB->cbDDCallbacks.FlipToGDISurface;
if (mDdFlipToGDISurface.FlipToGDISurface == NULL) if (mDdFlipToGDISurface.FlipToGDISurface == NULL)
{
return DDERR_NODRIVERSUPPORT;
}
if (mDdFlipToGDISurface.FlipToGDISurface(&mDdFlipToGDISurface)==DDHAL_DRIVER_HANDLED);
{ {
return mDdFlipToGDISurface.ddRVal; return DDERR_NODRIVERSUPPORT;
} }
return DDERR_NODRIVERSUPPORT; if (mDdFlipToGDISurface.FlipToGDISurface(&mDdFlipToGDISurface)==DDHAL_DRIVER_HANDLED);
{
return mDdFlipToGDISurface.ddRVal;
}
return DDERR_NODRIVERSUPPORT;
} }
/* /*
@ -614,37 +599,35 @@ Main_DirectDraw_GetCaps(LPDIRECTDRAW7 iface, LPDDCAPS pDriverCaps,
LPDDCAPS pHELCaps) LPDDCAPS pHELCaps)
{ {
DDSCAPS2 ddscaps = {0}; DDSCAPS2 ddscaps = {0};
DWORD status = DD_FALSE; DWORD status = DD_FALSE;
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (pDriverCaps != NULL) if (pDriverCaps != NULL)
{ {
Main_DirectDraw_GetAvailableVidMem(iface, Main_DirectDraw_GetAvailableVidMem(iface,
&ddscaps, &ddscaps,
&This->lpLcl->lpGbl->ddCaps.dwVidMemTotal, &This->lpLcl->lpGbl->ddCaps.dwVidMemTotal,
&This->lpLcl->lpGbl->ddCaps.dwVidMemFree); &This->lpLcl->lpGbl->ddCaps.dwVidMemFree);
RtlCopyMemory(pDriverCaps,&This->lpLcl->lpGbl->ddCaps,sizeof(DDCORECAPS)); RtlCopyMemory(pDriverCaps,&This->lpLcl->lpGbl->ddCaps,sizeof(DDCORECAPS));
pDriverCaps->dwSize=sizeof(DDCAPS); pDriverCaps->dwSize=sizeof(DDCAPS);
status = DD_OK; status = DD_OK;
} }
if (pHELCaps != NULL) if (pHELCaps != NULL)
{ {
Main_DirectDraw_GetAvailableVidMem(iface, Main_DirectDraw_GetAvailableVidMem(iface,
&ddscaps, &ddscaps,
&This->lpLcl->lpGbl->ddHELCaps.dwVidMemTotal, &This->lpLcl->lpGbl->ddHELCaps.dwVidMemTotal,
&This->lpLcl->lpGbl->ddHELCaps.dwVidMemFree); &This->lpLcl->lpGbl->ddHELCaps.dwVidMemFree);
RtlCopyMemory(pDriverCaps,&This->lpLcl->lpGbl->ddHELCaps,sizeof(DDCORECAPS)); RtlCopyMemory(pDriverCaps,&This->lpLcl->lpGbl->ddHELCaps,sizeof(DDCORECAPS));
status = DD_OK; status = DD_OK;
} }
return status; return status;
} }
@ -721,7 +704,7 @@ Main_DirectDraw_GetMonitorFrequency(LPDIRECTDRAW7 iface,LPDWORD freq)
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (freq == NULL) if (freq == NULL)
{ {
@ -740,32 +723,32 @@ HRESULT WINAPI
Main_DirectDraw_GetScanLine(LPDIRECTDRAW7 iface, LPDWORD lpdwScanLine) Main_DirectDraw_GetScanLine(LPDIRECTDRAW7 iface, LPDWORD lpdwScanLine)
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DDHAL_GETSCANLINEDATA mDdGetScanLine; DDHAL_GETSCANLINEDATA mDdGetScanLine;
DX_WINDBG_trace(); DX_WINDBG_trace();
*lpdwScanLine = 0; *lpdwScanLine = 0;
mDdGetScanLine.ddRVal = DDERR_NOTINITIALIZED; mDdGetScanLine.ddRVal = DDERR_NOTINITIALIZED;
mDdGetScanLine.dwScanLine = 0; mDdGetScanLine.dwScanLine = 0;
mDdGetScanLine.GetScanLine = This->lpLcl->lpDDCB->cbDDCallbacks.GetScanLine; mDdGetScanLine.GetScanLine = This->lpLcl->lpDDCB->cbDDCallbacks.GetScanLine;
mDdGetScanLine.lpDD = This->lpLcl->lpGbl; mDdGetScanLine.lpDD = This->lpLcl->lpGbl;
if (mDdGetScanLine.GetScanLine == NULL) if (mDdGetScanLine.GetScanLine == NULL)
{
return DDERR_NODRIVERSUPPORT;
}
mDdGetScanLine.ddRVal = DDERR_NOTPALETTIZED;
mDdGetScanLine.dwScanLine = 0;
if (mDdGetScanLine.GetScanLine(&mDdGetScanLine)==DDHAL_DRIVER_HANDLED);
{ {
*lpdwScanLine = mDdGetScanLine.dwScanLine; return DDERR_NODRIVERSUPPORT;
return mDdGetScanLine.ddRVal; }
}
return DDERR_NODRIVERSUPPORT; mDdGetScanLine.ddRVal = DDERR_NOTPALETTIZED;
mDdGetScanLine.dwScanLine = 0;
if (mDdGetScanLine.GetScanLine(&mDdGetScanLine)==DDHAL_DRIVER_HANDLED);
{
*lpdwScanLine = mDdGetScanLine.dwScanLine;
return mDdGetScanLine.ddRVal;
}
return DDERR_NODRIVERSUPPORT;
} }
/* /*
@ -819,19 +802,25 @@ Main_DirectDraw_RestoreDisplayMode(LPDIRECTDRAW7 iface)
HRESULT WINAPI HRESULT WINAPI
Main_DirectDraw_SetCooperativeLevel (LPDIRECTDRAW7 iface, HWND hwnd, DWORD cooplevel) Main_DirectDraw_SetCooperativeLevel (LPDIRECTDRAW7 iface, HWND hwnd, DWORD cooplevel)
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (cooplevel & DDSCL_FULLSCREEN) if (cooplevel & DDSCL_FULLSCREEN)
{ {
This->lpLcl->dwLocalFlags |= DDRAWILCL_ISFULLSCREEN; This->lpLcl->dwLocalFlags |= DDRAWILCL_ISFULLSCREEN;
} }
/* This code should be a callback */ if (cooplevel & DDSCL_EXCLUSIVE)
This->lpLcl->hWnd = hwnd; {
This->lpLcl->hFocusWnd = hwnd; This->lpLcl->lpGbl->lpExclusiveOwner = This->lpLcl;
ReCreateDirectDraw((LPDIRECTDRAW*)iface); }
/* This code should be a callback */
This->lpLcl->hWnd = hwnd;
This->lpLcl->hFocusWnd = hwnd;
ReCreateDirectDraw((LPDIRECTDRAW*)iface);
// TODO: // TODO:
// - create a scaner that check which driver we should get the HDC from // - create a scaner that check which driver we should get the HDC from
@ -843,9 +832,9 @@ Main_DirectDraw_SetCooperativeLevel (LPDIRECTDRAW7 iface, HWND hwnd, DWORD coopl
// //
// DDHAL_SETEXCLUSIVEMODEDATA SetExclusiveMode; // DDHAL_SETEXCLUSIVEMODEDATA SetExclusiveMode;
//DX_WINDBG_trace(); //DX_WINDBG_trace();
// //
// //
// // check the parameters // // check the parameters
// if ((HWND)This->lpLcl->lpGbl->lpExclusiveOwner->hWnd == hwnd) // if ((HWND)This->lpLcl->lpGbl->lpExclusiveOwner->hWnd == hwnd)
// return DD_OK; // return DD_OK;
@ -862,13 +851,13 @@ Main_DirectDraw_SetCooperativeLevel (LPDIRECTDRAW7 iface, HWND hwnd, DWORD coopl
// This->lpLcl->lpGbl->lpExclusiveOwner->hWnd = (ULONG_PTR) hwnd; // This->lpLcl->lpGbl->lpExclusiveOwner->hWnd = (ULONG_PTR) hwnd;
// This->lpLcl->lpGbl->lpExclusiveOwner->hDC = (ULONG_PTR)GetDC(hwnd); // This->lpLcl->lpGbl->lpExclusiveOwner->hDC = (ULONG_PTR)GetDC(hwnd);
// //
///* FIXME : fill the mDDrawGlobal.lpExclusiveOwner->dwLocalFlags right */ ///* FIXME : fill the mDDrawGlobal.lpExclusiveOwner->dwLocalFlags right */
////mDDrawGlobal.lpExclusiveOwner->dwLocalFlags ////mDDrawGlobal.lpExclusiveOwner->dwLocalFlags
// SetExclusiveMode.ddRVal = DDERR_NOTPALETTIZED; // SetExclusiveMode.ddRVal = DDERR_NOTPALETTIZED;
//if ((This->lpLcl->lpGbl->lpDDCBtmp->cbDDCallbacks.dwFlags & DDHAL_CB32_SETEXCLUSIVEMODE)) //if ((This->lpLcl->lpGbl->lpDDCBtmp->cbDDCallbacks.dwFlags & DDHAL_CB32_SETEXCLUSIVEMODE))
// { // {
// //
// SetExclusiveMode.SetExclusiveMode = This->lpLcl->lpGbl->lpDDCBtmp->cbDDCallbacks.SetExclusiveMode; // SetExclusiveMode.SetExclusiveMode = This->lpLcl->lpGbl->lpDDCBtmp->cbDDCallbacks.SetExclusiveMode;
@ -896,76 +885,73 @@ Main_DirectDraw_SetDisplayMode (LPDIRECTDRAW7 iface, DWORD dwWidth, DWORD dwHeig
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
BOOL dummy = TRUE; BOOL dummy = TRUE;
DEVMODE DevMode; DEVMODE DevMode;
int iMode=0; int iMode=0;
int Width=0; int Width=0;
int Height=0; int Height=0;
int BPP=0; int BPP=0;
DDHAL_SETMODEDATA mDdSetMode; DDHAL_SETMODEDATA mDdSetMode;
DX_WINDBG_trace(); DX_WINDBG_trace();
/* FIXME check the refresrate if it same if it not same do the mode switch */ /* FIXME check the refresrate if it same if it not same do the mode switch */
if ((This->lpLcl->lpGbl->vmiData.dwDisplayHeight == dwHeight) && if ((This->lpLcl->lpGbl->vmiData.dwDisplayHeight == dwHeight) &&
(This->lpLcl->lpGbl->vmiData.dwDisplayWidth == dwWidth) && (This->lpLcl->lpGbl->vmiData.dwDisplayWidth == dwWidth) &&
(This->lpLcl->lpGbl->vmiData.ddpfDisplay.dwRGBBitCount == dwBPP)) (This->lpLcl->lpGbl->vmiData.ddpfDisplay.dwRGBBitCount == dwBPP))
{ {
return DD_OK;
}
return DD_OK; mDdSetMode.ddRVal = DDERR_NOTINITIALIZED;
} mDdSetMode.dwModeIndex = 0;
mDdSetMode.inexcl = 0;
mDdSetMode.lpDD = This->lpLcl->lpGbl;
mDdSetMode.useRefreshRate = FALSE;
mDdSetMode.SetMode = This->lpLcl->lpDDCB->cbDDCallbacks.SetMode;
mDdSetMode.ddRVal = DDERR_NOTINITIALIZED; if (mDdSetMode.SetMode == NULL)
mDdSetMode.dwModeIndex = 0; {
mDdSetMode.inexcl = 0; return DDERR_NODRIVERSUPPORT;
mDdSetMode.lpDD = This->lpLcl->lpGbl; }
mDdSetMode.useRefreshRate = FALSE;
mDdSetMode.SetMode = This->lpLcl->lpDDCB->cbDDCallbacks.SetMode;
if (mDdSetMode.SetMode == NULL) /* Check use the Hal or Hel for SetMode */
{ // this only for exclusive mode
return DDERR_NODRIVERSUPPORT; /*if(!(This->cooperative_level & DDSCL_EXCLUSIVE))
} {
return DDERR_NOEXCLUSIVEMODE;
}*/
/* Check use the Hal or Hel for SetMode */ DevMode.dmSize = (WORD)sizeof(DEVMODE);
// this only for exclusive mode DevMode.dmDriverExtra = 0;
/*if(!(This->cooperative_level & DDSCL_EXCLUSIVE))
{
return DDERR_NOEXCLUSIVEMODE;
}*/
DevMode.dmSize = (WORD)sizeof(DEVMODE);
DevMode.dmDriverExtra = 0;
while (EnumDisplaySettingsEx(NULL, iMode, &DevMode, 0 ) != 0) while (EnumDisplaySettingsEx(NULL, iMode, &DevMode, 0 ) != 0)
{ {
if ((dwWidth == DevMode.dmPelsWidth) && (dwHeight == DevMode.dmPelsHeight) && ( dwBPP == DevMode.dmBitsPerPel)) if ((dwWidth == DevMode.dmPelsWidth) && (dwHeight == DevMode.dmPelsHeight) && ( dwBPP == DevMode.dmBitsPerPel))
{ {
Width = DevMode.dmPelsWidth; Width = DevMode.dmPelsWidth;
Height = DevMode.dmPelsHeight; Height = DevMode.dmPelsHeight;
BPP = DevMode.dmBitsPerPel; BPP = DevMode.dmBitsPerPel;
break; break;
} }
iMode++; iMode++;
} }
if ((dwWidth != DevMode.dmPelsWidth) || (dwHeight != DevMode.dmPelsHeight) || ( dwBPP != DevMode.dmBitsPerPel)) if ((dwWidth != DevMode.dmPelsWidth) || (dwHeight != DevMode.dmPelsHeight) || ( dwBPP != DevMode.dmBitsPerPel))
{ {
return DDERR_UNSUPPORTEDMODE; return DDERR_UNSUPPORTEDMODE;
} }
mDdSetMode.dwModeIndex = iMode;
mDdSetMode.dwModeIndex = iMode;
mDdSetMode.SetMode(&mDdSetMode); mDdSetMode.SetMode(&mDdSetMode);
DdReenableDirectDrawObject(This->lpLcl->lpGbl, &dummy); DdReenableDirectDrawObject(This->lpLcl->lpGbl, &dummy);
/* FIXME fill the This->DirectDrawGlobal.vmiData right */ /* FIXME fill the This->DirectDrawGlobal.vmiData right */
//This->lpLcl->lpGbl->lpExclusiveOwner->hDC = (ULONG_PTR)GetDC( (HWND)This->lpLcl->lpGbl->lpExclusiveOwner->hWnd); //This->lpLcl->lpGbl->lpExclusiveOwner->hDC = (ULONG_PTR)GetDC( (HWND)This->lpLcl->lpGbl->lpExclusiveOwner->hWnd);
return mDdSetMode.ddRVal; return mDdSetMode.ddRVal;
} }
/* /*
@ -978,33 +964,35 @@ Main_DirectDraw_WaitForVerticalBlank(LPDIRECTDRAW7 iface, DWORD dwFlags,
{ {
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DDHAL_WAITFORVERTICALBLANKDATA mDdWaitForVerticalBlank; DDHAL_WAITFORVERTICALBLANKDATA mDdWaitForVerticalBlank;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (!(This->lpLcl->lpDDCB->cbDDCallbacks.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK)) if (!(This->lpLcl->lpDDCB->cbDDCallbacks.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK))
{
return DDERR_NODRIVERSUPPORT;
}
if (mDdWaitForVerticalBlank.WaitForVerticalBlank == NULL)
{
return DDERR_NODRIVERSUPPORT;
}
mDdWaitForVerticalBlank.bIsInVB = DDWAITVB_BLOCKBEGIN ; /* return begin ? */
mDdWaitForVerticalBlank.ddRVal = DDERR_NOTINITIALIZED;
mDdWaitForVerticalBlank.dwFlags = dwFlags;
mDdWaitForVerticalBlank.hEvent = (DWORD)h;
mDdWaitForVerticalBlank.lpDD = This->lpLcl->lpGbl;
mDdWaitForVerticalBlank.WaitForVerticalBlank = This->lpLcl->lpDDCB->cbDDCallbacks.WaitForVerticalBlank;
if (mDdWaitForVerticalBlank.WaitForVerticalBlank(&mDdWaitForVerticalBlank)==DDHAL_DRIVER_HANDLED);
{ {
return mDdWaitForVerticalBlank.ddRVal; return DDERR_NODRIVERSUPPORT;
} }
return DDERR_NODRIVERSUPPORT; if (mDdWaitForVerticalBlank.WaitForVerticalBlank == NULL)
{
return DDERR_NODRIVERSUPPORT;
}
mDdWaitForVerticalBlank.bIsInVB = DDWAITVB_BLOCKBEGIN ; /* return begin ? */
mDdWaitForVerticalBlank.ddRVal = DDERR_NOTINITIALIZED;
mDdWaitForVerticalBlank.dwFlags = dwFlags;
mDdWaitForVerticalBlank.hEvent = (DWORD)h;
mDdWaitForVerticalBlank.lpDD = This->lpLcl->lpGbl;
mDdWaitForVerticalBlank.WaitForVerticalBlank = This->lpLcl->lpDDCB->cbDDCallbacks.WaitForVerticalBlank;
if (mDdWaitForVerticalBlank.WaitForVerticalBlank(&mDdWaitForVerticalBlank)
!= DDHAL_DRIVER_HANDLED)
{
return DDERR_NODRIVERSUPPORT;
}
return mDdWaitForVerticalBlank.ddRVal;
} }
/* /*
@ -1015,38 +1003,38 @@ HRESULT WINAPI
Main_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 ddscaps, Main_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 ddscaps,
LPDWORD total, LPDWORD free) LPDWORD total, LPDWORD free)
{ {
DDHAL_GETAVAILDRIVERMEMORYDATA mem; DDHAL_GETAVAILDRIVERMEMORYDATA mem;
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
/* Only Hal version exists acodring msdn */ /* Only Hal version exists acodring msdn */
if (!(This->lpLcl->lpDDCB->cbDDMiscellaneousCallbacks.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY)) if (!(This->lpLcl->lpDDCB->cbDDMiscellaneousCallbacks.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY))
{ {
return DDERR_NODRIVERSUPPORT; return DDERR_NODRIVERSUPPORT;
} }
mem.lpDD = This->lpLcl->lpGbl; mem.lpDD = This->lpLcl->lpGbl;
mem.ddRVal = DDERR_NOTPALETTIZED; mem.ddRVal = DDERR_NOTPALETTIZED;
mem.DDSCaps.dwCaps = ddscaps->dwCaps; mem.DDSCaps.dwCaps = ddscaps->dwCaps;
mem.ddsCapsEx.dwCaps2 = ddscaps->dwCaps2; mem.ddsCapsEx.dwCaps2 = ddscaps->dwCaps2;
mem.ddsCapsEx.dwCaps3 = ddscaps->dwCaps3; mem.ddsCapsEx.dwCaps3 = ddscaps->dwCaps3;
mem.ddsCapsEx.dwCaps4 = ddscaps->dwCaps4; mem.ddsCapsEx.dwCaps4 = ddscaps->dwCaps4;
if (This->lpLcl->lpDDCB->cbDDMiscellaneousCallbacks.GetAvailDriverMemory(&mem) == DDHAL_DRIVER_HANDLED); if (This->lpLcl->lpDDCB->cbDDMiscellaneousCallbacks.GetAvailDriverMemory(&mem) == DDHAL_DRIVER_HANDLED);
{ {
if (total !=NULL) if (total !=NULL)
{ {
*total = mem.dwTotal; *total = mem.dwTotal;
} }
*free = mem.dwFree; *free = mem.dwFree;
return mem.ddRVal; return mem.ddRVal;
} }
return DDERR_NODRIVERSUPPORT; return DDERR_NODRIVERSUPPORT;
} }
/* /*