Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 19:52:56 +00:00
Code Issues Projects Releases Packages Wiki Activity

the new desgin of ddraw are in place some files need be rename.

Browse source 
1. this version does not working and contain allot of bugs
2. HAL are not setup right yet
3. HEL are not setup right yet
4. crashing VS when u try debug it from vs if it compile with gcc. 
5. implement HEL in user mode. 
6. remove some code that was working for it is not longer compatible with new desgin

svn path=/trunk/; revision=24782
This commit is contained in:
Magnus Olsen 2006-11-19 19:13:35 +00:00
parent d926e80e5c
commit 67e5e2ef0a
20 changed files with 3161 additions and 4141 deletions
Download patch file Download diff file Expand all files Collapse all files

2
reactos/dll/directx/ddraw/soft/surface_callbacks_hel.c → reactos/dll/directx/ddraw/callbacks_hel.c
View file

@ -8,7 +8,7 @@
* *
*/ */
#include "../rosdraw.h" #include "rosdraw.h"
extern DDPIXELFORMAT pixelformats[]; extern DDPIXELFORMAT pixelformats[];

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

@ -15,37 +15,11 @@
VOID VOID
Cleanup(LPDIRECTDRAW7 iface) Cleanup(LPDIRECTDRAW7 iface)
{ {
IDirectDrawImpl* This = (IDirectDrawImpl*)iface; /* FIXME
free all memory and delete all dx stuff
if (This->mDDrawGlobal.hDD != 0) */
{
DdDeleteDirectDrawObject (&This->mDDrawGlobal);
}
if (This->mpTextures != NULL)
{
DxHeapMemFree(This->mpTextures);
}
if (This->mpFourCC != NULL)
{
DxHeapMemFree(This->mpFourCC);
}
if (This->mpvmList != NULL)
{
DxHeapMemFree(This->mpvmList);
}
if (This->mpModeInfos != NULL)
{
DxHeapMemFree(This->mpModeInfos);
}
if (This->hdc != NULL)
{
DeleteDC(This->hdc);
}
} }

30
reactos/dll/directx/ddraw/ddraw.rbuild
View file

@ -1,12 +1,12 @@
<module name="ddraw" type="win32dll" entrypoint="0" installbase="system32" installname="ddraw.dll"> <module name="ddraw" type="win32dll" entrypoint="0" installbase="system32" installname="ddraw.dll" allowwarnings ="true">
<importlibrary definition="ddraw.def" /> <importlibrary definition="ddraw.def" />
<include base="ddraw">.</include> <include base="ddraw">.</include>
<define name="UNICODE" /> <define name="UNICODE" />
<define name="__USE_W32API" /> <define name="__USE_W32API" />
<define name="WINVER">0x0600</define> <define name="WINVER">0x0600</define>
<define name="_WIN32_WINNT">0x0501</define> <define name="_WIN32_WINNT">0x0501</define>
<library>ntdll</library> <library>ntdll</library>
<library>kernel32</library> <library>kernel32</library>
<library>gdi32</library> <library>gdi32</library>
<library>d3d8thk</library> <library>d3d8thk</library>
@ -17,30 +17,22 @@
<file>ddraw.rc</file> <file>ddraw.rc</file>
<file>main.c</file> <file>main.c</file>
<file>regsvr.c</file>
<file>startup.c</file> <file>startup.c</file>
<file>cleanup.c</file> <file>cleanup.c</file>
<file>clipper.c</file> <file>iface_clipper.c</file>
<file>color.c</file> <file>iface_color.c</file>
<file>gamma.c</file> <file>iface_gamma.c</file>
<file>palette.c</file> <file>iface_palette.c</file>
<file>videoport.c</file> <file>iface_videoport.c</file>
<file>kernel.c</file> <file>iface_kernel.c</file>
<directory name="hal"> <file>callbacks_hel.c</file>
<file>surface_hal.c</file>
</directory>
<directory name="main"> <directory name="main">
<file>ddraw_main.c</file> <file>ddraw_main.c</file>
<file>surface_main.c</file> <file>surface_main.c</file>
</directory> </directory>
<directory name="soft">
<file>surface_hel.c</file>
<file>surface_callbacks_hel.c</file>
</directory>
<directory name="thunks"> <directory name="thunks">
<file>ddraw_thunk.c</file> <file>ddraw_thunk.c</file>

206
reactos/dll/directx/ddraw/hal/surface_hal.c
View file

@ -1,206 +0,0 @@
/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/hal/surface.c
* PURPOSE: DirectDraw HAL Implementation
* PROGRAMMER: Magnus Olsen, Maarten Bosma
*
*/
#include "../rosdraw.h"
HRESULT Hal_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rDest,
LPDIRECTDRAWSURFACE7 src, LPRECT rSrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
{
DDHAL_BLTDATA mDdBlt;
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
IDirectDrawSurfaceImpl* That = NULL;
if (src!=NULL)
{
That = (IDirectDrawSurfaceImpl*)src;
}
if (This==NULL)
{
return DD_FALSE;
}
if (!(This->Owner->mDDrawGlobal.lpDDCBtmp->HALDDSurface.dwFlags & DDHAL_SURFCB32_BLT))
{
return DDERR_NODRIVERSUPPORT;
}
mDdBlt.lpDDDestSurface = This->Surf->mpPrimaryLocals[0];
if (!DdResetVisrgn(This->Surf->mpPrimaryLocals[0], NULL))
{
return DDERR_NOGDI;
}
memset(&mDdBlt, 0, sizeof(DDHAL_BLTDATA));
memset(&mDdBlt.bltFX, 0, sizeof(DDBLTFX));
if (lpbltfx!=NULL)
{
memcpy(&mDdBlt.bltFX, lpbltfx, sizeof(DDBLTFX));
}
if (rDest!=NULL)
{
memcpy(& mDdBlt.rDest, rDest, sizeof(RECTL));
}
if (rSrc!=NULL)
{
memcpy(& mDdBlt.rDest, rSrc, sizeof(RECTL));
}
if (src != NULL)
{
mDdBlt.lpDDSrcSurface = That->Surf->mpSurfLocals[0];
}
mDdBlt.lpDD = &This->Owner->mDDrawGlobal;
mDdBlt.Blt = This->Owner->mCallbacks.HALDDSurface.Blt;
mDdBlt.lpDDDestSurface = This->Surf->mpInUseSurfaceLocals[0];
mDdBlt.dwFlags = dwFlags;
// FIXME dectect if it clipped or not
mDdBlt.IsClipped = FALSE;
if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
{
return DDHAL_DRIVER_HANDLED;
}
if (mDdBlt.ddRVal!=DD_OK)
{
return mDdBlt.ddRVal;
}
return DD_OK;
}
HRESULT Hal_DDrawSurface_Lock(LPDIRECTDRAWSURFACE7 iface, LPRECT prect, LPDDSURFACEDESC2
pDDSD, DWORD flags, HANDLE event)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
DDHAL_LOCKDATA Lock;
if (prect!=NULL)
{
Lock.bHasRect = TRUE;
memcpy(&Lock.rArea,prect,sizeof(RECTL));
}
else
{
Lock.bHasRect = FALSE;
}
Lock.ddRVal = DDERR_NOTPALETTIZED;
Lock.Lock = This->Owner->mCallbacks.HALDDSurface.Lock;
Lock.dwFlags = flags;
Lock.lpDDSurface = This->Surf->mpInUseSurfaceLocals[0];
Lock.lpDD = &This->Owner->mDDrawGlobal;
Lock.lpSurfData = NULL;
if (!DdResetVisrgn(&This->Surf->mPrimaryLocal, NULL))
{
OutputDebugStringA("Here DdResetVisrgn lock");
return DDERR_UNSUPPORTED;
}
if (Lock.Lock(&Lock)!= DDHAL_DRIVER_HANDLED)
{
OutputDebugStringA("Here DDHAL_DRIVER_HANDLED lock");
return DDERR_UNSUPPORTED;
}
if (Lock.ddRVal!= DD_OK)
{
OutputDebugStringA("Here ddRVal lock");
return Lock.ddRVal;
}
// FIXME ??? is this right ??
if (pDDSD != NULL)
{
if (pDDSD->dwSize == sizeof(DDSURFACEDESC2))
{
RtlZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
// FIXME the interanl mddsdPrimary shall be DDSURFACEDESC2
memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
pDDSD->dwSize = sizeof(DDSURFACEDESC2);
}
if (pDDSD->dwSize == sizeof(DDSURFACEDESC))
{
RtlZeroMemory(pDDSD,sizeof(DDSURFACEDESC));
memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
pDDSD->dwSize = sizeof(DDSURFACEDESC);
}
pDDSD->lpSurface = (LPVOID) Lock.lpSurfData;
}
return DD_OK;
}
HRESULT Hal_DDrawSurface_Unlock(LPDIRECTDRAWSURFACE7 iface, LPRECT pRect)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
DDHAL_UNLOCKDATA unLock;
unLock.ddRVal = DDERR_NOTPALETTIZED;
unLock.lpDD = &This->Owner->mDDrawGlobal;
unLock.lpDDSurface = This->Surf->mpInUseSurfaceLocals[0];
unLock.Unlock = This->Owner->mCallbacks.HALDDSurface.Unlock;
if (!DdResetVisrgn( unLock.lpDDSurface, NULL))
{
return DDERR_UNSUPPORTED;
}
if (unLock.Unlock(&unLock)!= DDHAL_DRIVER_HANDLED)
{
return DDERR_UNSUPPORTED;
}
if (unLock.ddRVal!= DD_OK)
{
return unLock.ddRVal;
}
return DD_OK;
}
HRESULT Hal_DDrawSurface_Flip(LPDIRECTDRAWSURFACE7 iface, LPDIRECTDRAWSURFACE7 override, DWORD dwFlags)
{
DX_STUB;
}
HRESULT Hal_DDrawSurface_SetColorKey (LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags, LPDDCOLORKEY pCKey)
{
DX_STUB;
}
HRESULT Hal_DDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
{
DX_STUB;
}
HRESULT Hal_DDrawSurface_UpdateOverlayDisplay (LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
{
DX_STUB;
}

264
reactos/dll/directx/ddraw/clipper.c → reactos/dll/directx/ddraw/iface_clipper.c
View file

@ -1,132 +1,132 @@
/* $Id$ /* $Id: clipper.c 24690 2006-11-05 21:19:53Z greatlrd $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS * PROJECT: ReactOS
* FILE: lib/ddraw/main/clipper.c * FILE: lib/ddraw/main/clipper.c
* PURPOSE: IDirectDrawClipper Implementation * PURPOSE: IDirectDrawClipper Implementation
* PROGRAMMER: Maarten Bosma * PROGRAMMER: Maarten Bosma
* *
*/ */
#include "rosdraw.h" #include "rosdraw.h"
ULONG WINAPI ULONG WINAPI
DirectDrawClipper_Release(LPDIRECTDRAWCLIPPER iface) DirectDrawClipper_Release(LPDIRECTDRAWCLIPPER iface)
{ {
IDirectDrawClipperImpl* This = (IDirectDrawClipperImpl*)iface; LPDDRAWI_DDRAWCLIPPER_INT This = (LPDDRAWI_DDRAWCLIPPER_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
ref = InterlockedDecrement( (PLONG) &This->ref); ref = InterlockedDecrement( (PLONG) &This->dwIntRefCnt);
if (ref == 0) if (ref == 0)
{ {
/* Add here if we need releae some memory pointer before /* Add here if we need releae some memory pointer before
* exists * exists
*/ */
if (This!=NULL) if (This!=NULL)
{ {
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
} }
} }
} }
return ref; return ref;
} }
ULONG WINAPI ULONG WINAPI
DirectDrawClipper_AddRef (LPDIRECTDRAWCLIPPER iface) DirectDrawClipper_AddRef (LPDIRECTDRAWCLIPPER iface)
{ {
IDirectDrawClipperImpl * This = (IDirectDrawClipperImpl*)iface; LPDDRAWI_DDRAWCLIPPER_INT This = (LPDDRAWI_DDRAWCLIPPER_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
ref = InterlockedIncrement( (PLONG) &This->ref); ref = InterlockedIncrement( (PLONG) &This->dwIntRefCnt);
} }
return ref; return ref;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawClipper_Initialize( LPDIRECTDRAWCLIPPER iface, DirectDrawClipper_Initialize( LPDIRECTDRAWCLIPPER iface,
LPDIRECTDRAW lpDD, LPDIRECTDRAW lpDD,
DWORD dwFlags) DWORD dwFlags)
{ {
/* FIXME not implment */ /* FIXME not implment */
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB_DD_OK; DX_STUB_DD_OK;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawClipper_SetHwnd( LPDIRECTDRAWCLIPPER iface, DirectDrawClipper_SetHwnd( LPDIRECTDRAWCLIPPER iface,
DWORD dwFlags, DWORD dwFlags,
HWND hWnd) HWND hWnd)
{ {
/* FIXME not implment */ /* FIXME not implment */
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB_DD_OK; DX_STUB_DD_OK;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawClipper_GetClipList( LPDIRECTDRAWCLIPPER iface, DirectDrawClipper_GetClipList( LPDIRECTDRAWCLIPPER iface,
LPRECT lpRect, LPRECT lpRect,
LPRGNDATA lpClipList, LPRGNDATA lpClipList,
LPDWORD lpdwSize) LPDWORD lpdwSize)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawClipper_SetClipList( LPDIRECTDRAWCLIPPER iface, DirectDrawClipper_SetClipList( LPDIRECTDRAWCLIPPER iface,
LPRGNDATA lprgn, LPRGNDATA lprgn,
DWORD dwFlag) DWORD dwFlag)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawClipper_QueryInterface( LPDIRECTDRAWCLIPPER iface, DirectDrawClipper_QueryInterface( LPDIRECTDRAWCLIPPER iface,
REFIID riid, REFIID riid,
LPVOID* ppvObj) LPVOID* ppvObj)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawClipper_GetHWnd( LPDIRECTDRAWCLIPPER iface, DirectDrawClipper_GetHWnd( LPDIRECTDRAWCLIPPER iface,
HWND* hWndPtr) HWND* hWndPtr)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawClipper_IsClipListChanged( LPDIRECTDRAWCLIPPER iface, DirectDrawClipper_IsClipListChanged( LPDIRECTDRAWCLIPPER iface,
BOOL* lpbChanged) BOOL* lpbChanged)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
IDirectDrawClipperVtbl DirectDrawClipper_Vtable = IDirectDrawClipperVtbl DirectDrawClipper_Vtable =
{ {
DirectDrawClipper_QueryInterface, DirectDrawClipper_QueryInterface,
DirectDrawClipper_AddRef, DirectDrawClipper_AddRef,
DirectDrawClipper_Release, DirectDrawClipper_Release,
DirectDrawClipper_GetClipList, DirectDrawClipper_GetClipList,
DirectDrawClipper_GetHWnd, DirectDrawClipper_GetHWnd,
DirectDrawClipper_Initialize, DirectDrawClipper_Initialize,
DirectDrawClipper_IsClipListChanged, DirectDrawClipper_IsClipListChanged,
DirectDrawClipper_SetClipList, DirectDrawClipper_SetClipList,
DirectDrawClipper_SetHwnd DirectDrawClipper_SetHwnd
}; };

174
reactos/dll/directx/ddraw/color.c → reactos/dll/directx/ddraw/iface_color.c
View file

@ -1,87 +1,87 @@
/* $Id$ /* $Id: color.c 24690 2006-11-05 21:19:53Z greatlrd $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS * PROJECT: ReactOS
* FILE: lib/ddraw/main/color.c * FILE: lib/ddraw/main/color.c
* PURPOSE: IDirectDrawColorControl Implementation * PURPOSE: IDirectDrawColorControl Implementation
* PROGRAMMER: Maarten Bosma * PROGRAMMER: Maarten Bosma
* *
*/ */
#include "rosdraw.h" #include "rosdraw.h"
ULONG WINAPI ULONG WINAPI
DirectDrawColorControl_AddRef( LPDIRECTDRAWCOLORCONTROL iface) DirectDrawColorControl_AddRef( LPDIRECTDRAWCOLORCONTROL iface)
{ {
IDirectDrawColorImpl * This = (IDirectDrawColorImpl*)iface; LPDDRAWI_DDCOLORCONTROL_INT This = (LPDDRAWI_DDCOLORCONTROL_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
ref = InterlockedIncrement( (PLONG) &This->ref); ref = InterlockedIncrement( (PLONG) &This->dwIntRefCnt);
} }
return ref; return ref;
} }
ULONG WINAPI ULONG WINAPI
DirectDrawColorControl_Release( LPDIRECTDRAWCOLORCONTROL iface) DirectDrawColorControl_Release( LPDIRECTDRAWCOLORCONTROL iface)
{ {
IDirectDrawColorImpl* This = (IDirectDrawColorImpl*)iface; LPDDRAWI_DDCOLORCONTROL_INT This = (LPDDRAWI_DDCOLORCONTROL_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
ref = InterlockedDecrement( (PLONG) &This->ref); ref = InterlockedDecrement( (PLONG) &This->dwIntRefCnt);
if (ref == 0) if (ref == 0)
{ {
/* Add here if we need releae some memory pointer before /* Add here if we need releae some memory pointer before
* exists * exists
*/ */
if (This!=NULL) if (This!=NULL)
{ {
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
} }
} }
} }
return ref; return ref;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawColorControl_QueryInterface( LPDIRECTDRAWCOLORCONTROL iface, DirectDrawColorControl_QueryInterface( LPDIRECTDRAWCOLORCONTROL iface,
REFIID riid, REFIID riid,
LPVOID* ppvObj) LPVOID* ppvObj)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawColorControl_GetColorControls( LPDIRECTDRAWCOLORCONTROL iface, DirectDrawColorControl_GetColorControls( LPDIRECTDRAWCOLORCONTROL iface,
LPDDCOLORCONTROL lpColorControl) LPDDCOLORCONTROL lpColorControl)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawColorControl_SetColorControls( LPDIRECTDRAWCOLORCONTROL iface, DirectDrawColorControl_SetColorControls( LPDIRECTDRAWCOLORCONTROL iface,
LPDDCOLORCONTROL lpColorControl) LPDDCOLORCONTROL lpColorControl)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
IDirectDrawColorControlVtbl DirectDrawColorControl_Vtable = IDirectDrawColorControlVtbl DirectDrawColorControl_Vtable =
{ {
DirectDrawColorControl_QueryInterface, DirectDrawColorControl_QueryInterface,
DirectDrawColorControl_AddRef, DirectDrawColorControl_AddRef,
DirectDrawColorControl_Release, DirectDrawColorControl_Release,
DirectDrawColorControl_GetColorControls, DirectDrawColorControl_GetColorControls,
DirectDrawColorControl_SetColorControls DirectDrawColorControl_SetColorControls
}; };

181
reactos/dll/directx/ddraw/gamma.c → reactos/dll/directx/ddraw/iface_gamma.c
View file

@ -1,89 +1,92 @@
/* $Id$ /* $Id: gamma.c 24690 2006-11-05 21:19:53Z greatlrd $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS * PROJECT: ReactOS
* FILE: lib/ddraw/main/gamma.c * FILE: lib/ddraw/main/gamma.c
* PURPOSE: IDirectDrawGamma Implementation * PURPOSE: IDirectDrawGamma Implementation
* PROGRAMMER: Maarten Bosma * PROGRAMMER: Maarten Bosma
* *
*/ */
#include "rosdraw.h" #include "rosdraw.h"
ULONG WINAPI ULONG WINAPI
DirectDrawGammaControl_AddRef( LPDIRECTDRAWGAMMACONTROL iface) DirectDrawGammaControl_AddRef( LPDIRECTDRAWGAMMACONTROL iface)
{ {
IDirectDrawGammaImpl * This = (IDirectDrawGammaImpl*)iface; LPDDRAWI_DDGAMMACONTROL_INT This = (LPDDRAWI_DDGAMMACONTROL_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace();
DX_WINDBG_trace();
if (iface!=NULL)
if (iface!=NULL) {
{ This->dwIntRefCnt++;
ref = InterlockedIncrement( (PLONG) &This->ref); ref = This->dwIntRefCnt;
} }
return ref; return ref;
} }
ULONG WINAPI ULONG WINAPI
DirectDrawGammaControl_Release( LPDIRECTDRAWGAMMACONTROL iface) DirectDrawGammaControl_Release( LPDIRECTDRAWGAMMACONTROL iface)
{ {
IDirectDrawGammaImpl* This = (IDirectDrawGammaImpl*)iface; LPDDRAWI_DDGAMMACONTROL_INT This = (LPDDRAWI_DDGAMMACONTROL_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace();
DX_WINDBG_trace();
if (iface!=NULL)
{ if (iface!=NULL)
ref = InterlockedDecrement( (PLONG) &This->ref); {
This->dwIntRefCnt--;
if (ref == 0)
{ if (This->dwIntRefCnt == 0)
/* Add here if we need releae some memory pointer before {
* exists /* Add here if we need releae some memory pointer before
*/ * exists
*/
if (This!=NULL)
{ if (This!=NULL)
HeapFree(GetProcessHeap(), 0, This); {
} HeapFree(GetProcessHeap(), 0, This);
} }
} }
return ref;
} ref = This->dwIntRefCnt;
}
HRESULT WINAPI return ref;
DirectDrawGammaControl_QueryInterface( LPDIRECTDRAWGAMMACONTROL iface, }
REFIID riid,
LPVOID *ppObj) HRESULT WINAPI
{ DirectDrawGammaControl_QueryInterface( LPDIRECTDRAWGAMMACONTROL iface,
DX_WINDBG_trace(); REFIID riid,
DX_STUB; LPVOID *ppObj)
} {
DX_WINDBG_trace();
HRESULT WINAPI DX_STUB;
DirectDrawGammaControl_GetGammaRamp( LPDIRECTDRAWGAMMACONTROL iface, }
DWORD dwFlags,
LPDDGAMMARAMP lpGammaRamp) HRESULT WINAPI
{ DirectDrawGammaControl_GetGammaRamp( LPDIRECTDRAWGAMMACONTROL iface,
DX_WINDBG_trace(); DWORD dwFlags,
DX_STUB; LPDDGAMMARAMP lpGammaRamp)
} {
DX_WINDBG_trace();
HRESULT WINAPI DX_STUB;
DirectDrawGammaControl_SetGammaRamp( LPDIRECTDRAWGAMMACONTROL iface, }
DWORD dwFlags,
LPDDGAMMARAMP lpGammaRamp) HRESULT WINAPI
{ DirectDrawGammaControl_SetGammaRamp( LPDIRECTDRAWGAMMACONTROL iface,
DX_WINDBG_trace(); DWORD dwFlags,
DX_STUB; LPDDGAMMARAMP lpGammaRamp)
} {
DX_WINDBG_trace();
IDirectDrawGammaControlVtbl DirectDrawGammaControl_Vtable = DX_STUB;
{ }
DirectDrawGammaControl_QueryInterface,
DirectDrawGammaControl_AddRef, IDirectDrawGammaControlVtbl DirectDrawGammaControl_Vtable =
DirectDrawGammaControl_Release, {
DirectDrawGammaControl_GetGammaRamp, DirectDrawGammaControl_QueryInterface,
DirectDrawGammaControl_SetGammaRamp DirectDrawGammaControl_AddRef,
}; DirectDrawGammaControl_Release,
DirectDrawGammaControl_GetGammaRamp,
DirectDrawGammaControl_SetGammaRamp
};

341
reactos/dll/directx/ddraw/kernel.c → reactos/dll/directx/ddraw/iface_kernel.c
View file

@ -1,168 +1,173 @@
/* $Id$ /* $Id: kernel.c 24690 2006-11-05 21:19:53Z greatlrd $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS * PROJECT: ReactOS
* FILE: lib/ddraw/main/kernel.c * FILE: lib/ddraw/main/kernel.c
* PURPOSE: IDirectDrawKernel and IDirectDrawSurfaceKernel Implementation * PURPOSE: IDirectDrawKernel and IDirectDrawSurfaceKernel Implementation
* PROGRAMMER: Maarten Bosma * PROGRAMMER: Maarten Bosma
* *
*/ */
#include "rosdraw.h" #include "rosdraw.h"
/***** IDirectDrawKernel ****/ /***** IDirectDrawKernel ****/
ULONG WINAPI ULONG WINAPI
DirectDrawKernel_AddRef ( LPDIRECTDRAWKERNEL iface) DirectDrawKernel_AddRef ( LPDIRECTDRAWKERNEL iface)
{ {
IDirectDrawKernelImpl * This = (IDirectDrawKernelImpl*)iface; LPDDRAWI_KERNEL_INT This = (LPDDRAWI_KERNEL_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace();
DX_WINDBG_trace();
if (iface!=NULL)
if (iface!=NULL) {
{ This->dwIntRefCnt++;
ref = InterlockedIncrement( (PLONG) &This->ref); ref = This->dwIntRefCnt;
} }
return ref; return ref;
} }
ULONG WINAPI ULONG WINAPI
DirectDrawKernel_Release ( LPDIRECTDRAWKERNEL iface) DirectDrawKernel_Release ( LPDIRECTDRAWKERNEL iface)
{ {
IDirectDrawKernelImpl* This = (IDirectDrawKernelImpl*)iface; LPDDRAWI_KERNEL_INT This = (LPDDRAWI_KERNEL_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
ref = InterlockedDecrement( (PLONG) &This->ref); This->dwIntRefCnt--;
if (ref == 0) if (This->dwIntRefCnt == 0)
{ {
/* Add here if we need releae some memory pointer before /* Add here if we need releae some memory pointer before
* exists * exists
*/ */
if (This!=NULL) if (This!=NULL)
{ {
HeapFree(GetProcessHeap(), 0, This); HeapFree(GetProcessHeap(), 0, This);
} }
} }
}
return ref; ref = This->dwIntRefCnt;
} }
return ref;
HRESULT WINAPI }
DirectDrawKernel_QueryInterface ( LPDIRECTDRAWKERNEL iface,
REFIID riid, HRESULT WINAPI
LPVOID* ppvObj) DirectDrawKernel_QueryInterface ( LPDIRECTDRAWKERNEL iface,
{ REFIID riid,
DX_WINDBG_trace(); LPVOID* ppvObj)
DX_STUB; {
} DX_WINDBG_trace();
DX_STUB;
HRESULT WINAPI }
DirectDrawKernel_GetKernelHandle ( LPDIRECTDRAWKERNEL iface,
ULONG* handle) HRESULT WINAPI
{ DirectDrawKernel_GetKernelHandle ( LPDIRECTDRAWKERNEL iface,
DX_WINDBG_trace(); ULONG* handle)
DX_STUB; {
} DX_WINDBG_trace();
DX_STUB;
HRESULT WINAPI }
DirectDrawKernel_ReleaseKernelHandle ( LPDIRECTDRAWKERNEL iface)
{ HRESULT WINAPI
DX_WINDBG_trace(); DirectDrawKernel_ReleaseKernelHandle ( LPDIRECTDRAWKERNEL iface)
DX_STUB; {
} DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
DDSurfaceKernel_AddRef ( LPDIRECTDRAWSURFACEKERNEL iface)
{ ULONG WINAPI
IDirectDrawSurfaceKernelImpl * This = (IDirectDrawSurfaceKernelImpl*)iface; DDSurfaceKernel_AddRef ( LPDIRECTDRAWSURFACEKERNEL iface)
{
ULONG ref=0; LPDDRAWI_DDKERNELSURFACE_INT This = (LPDDRAWI_DDKERNELSURFACE_INT)iface;
DX_WINDBG_trace();
ULONG ref=0;
if (iface!=NULL) DX_WINDBG_trace();
{
ref = InterlockedIncrement( (PLONG) &This->ref); if (iface!=NULL)
} {
return ref; This->dwIntRefCnt++;
} ref = This->dwIntRefCnt;
}
ULONG WINAPI return ref;
DDSurfaceKernel_Release ( LPDIRECTDRAWSURFACEKERNEL iface) }
{
IDirectDrawSurfaceKernelImpl* This = (IDirectDrawSurfaceKernelImpl*)iface; ULONG WINAPI
ULONG ref=0; DDSurfaceKernel_Release ( LPDIRECTDRAWSURFACEKERNEL iface)
{
DX_WINDBG_trace(); LPDDRAWI_DDKERNELSURFACE_INT This = (LPDDRAWI_DDKERNELSURFACE_INT)iface;
ULONG ref=0;
if (iface!=NULL)
{ DX_WINDBG_trace();
ref = InterlockedDecrement( (PLONG) &This->ref);
if (iface!=NULL)
if (ref == 0) {
{ This->dwIntRefCnt--;
/* Add here if we need releae some memory pointer before
* exists if (This->dwIntRefCnt == 0)
*/ {
/* Add here if we need releae some memory pointer before
if (This!=NULL) * exists
{ */
HeapFree(GetProcessHeap(), 0, This);
} if (This!=NULL)
} {
} HeapFree(GetProcessHeap(), 0, This);
return ref; }
} }
HRESULT WINAPI ref = This->dwIntRefCnt;
DDSurfaceKernel_QueryInterface ( LPDIRECTDRAWSURFACEKERNEL iface, }
REFIID riid, return ref;
LPVOID* ppvObj) }
{
DX_WINDBG_trace(); HRESULT WINAPI
DX_STUB; DDSurfaceKernel_QueryInterface ( LPDIRECTDRAWSURFACEKERNEL iface,
} REFIID riid,
LPVOID* ppvObj)
HRESULT WINAPI {
DDSurfaceKernel_GetKernelHandle ( LPDIRECTDRAWSURFACEKERNEL iface, DX_WINDBG_trace();
ULONG* handle) DX_STUB;
{ }
DX_WINDBG_trace();
DX_STUB; HRESULT WINAPI
} DDSurfaceKernel_GetKernelHandle ( LPDIRECTDRAWSURFACEKERNEL iface,
ULONG* handle)
HRESULT WINAPI {
DDSurfaceKernel_ReleaseKernelHandle ( LPDIRECTDRAWSURFACEKERNEL iface) DX_WINDBG_trace();
{ DX_STUB;
DX_WINDBG_trace(); }
DX_STUB;
} HRESULT WINAPI
DDSurfaceKernel_ReleaseKernelHandle ( LPDIRECTDRAWSURFACEKERNEL iface)
{
IDirectDrawKernelVtbl DirectDrawKernel_Vtable = DX_WINDBG_trace();
{ DX_STUB;
DirectDrawKernel_QueryInterface, }
DirectDrawKernel_AddRef,
DirectDrawKernel_Release,
DirectDrawKernel_GetKernelHandle, IDirectDrawKernelVtbl DirectDrawKernel_Vtable =
DirectDrawKernel_ReleaseKernelHandle {
}; DirectDrawKernel_QueryInterface,
DirectDrawKernel_AddRef,
IDirectDrawSurfaceKernelVtbl DirectDrawSurfaceKernel_Vtable = DirectDrawKernel_Release,
{ DirectDrawKernel_GetKernelHandle,
DDSurfaceKernel_QueryInterface, DirectDrawKernel_ReleaseKernelHandle
DDSurfaceKernel_AddRef, };
DDSurfaceKernel_Release,
DDSurfaceKernel_GetKernelHandle, IDirectDrawSurfaceKernelVtbl DirectDrawSurfaceKernel_Vtable =
DDSurfaceKernel_ReleaseKernelHandle {
}; DDSurfaceKernel_QueryInterface,
DDSurfaceKernel_AddRef,
DDSurfaceKernel_Release,
DDSurfaceKernel_GetKernelHandle,
DDSurfaceKernel_ReleaseKernelHandle
};

222
reactos/dll/directx/ddraw/palette.c → reactos/dll/directx/ddraw/iface_palette.c
View file

@ -1,111 +1,111 @@
/* $Id$ /* $Id: palette.c 24690 2006-11-05 21:19:53Z greatlrd $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS * PROJECT: ReactOS
* FILE: lib/ddraw/main/palette.c * FILE: lib/ddraw/main/palette.c
* PURPOSE: IDirectDrawPalette Implementation * PURPOSE: IDirectDrawPalette Implementation
* PROGRAMMER: Maarten Bosma * PROGRAMMER: Maarten Bosma
* *
*/ */
#include "rosdraw.h" #include "rosdraw.h"
ULONG WINAPI ULONG WINAPI
DirectDrawPalette_Release( LPDIRECTDRAWPALETTE iface) DirectDrawPalette_Release( LPDIRECTDRAWPALETTE iface)
{ {
IDirectDrawPaletteImpl* This = (IDirectDrawPaletteImpl*)iface; LPDDRAWI_DDRAWPALETTE_INT This = (LPDDRAWI_DDRAWPALETTE_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
ref = InterlockedDecrement( (PLONG) &This->DDPalette.dwRefCnt); ref = InterlockedDecrement( (PLONG) &This->dwIntRefCnt);
if (ref == 0) if (ref == 0)
{ {
/* Add here if we need releae some memory pointer before /* Add here if we need releae some memory pointer before
* exists * exists
*/ */
if (This!=NULL) if (This!=NULL)
{ {
DxHeapMemFree(This); DxHeapMemFree(This);
} }
} }
} }
return ref; return ref;
} }
ULONG WINAPI ULONG WINAPI
DirectDrawPalette_AddRef( LPDIRECTDRAWPALETTE iface) DirectDrawPalette_AddRef( LPDIRECTDRAWPALETTE iface)
{ {
IDirectDrawPaletteImpl * This = (IDirectDrawPaletteImpl*)iface; LPDDRAWI_DDRAWPALETTE_INT This = (LPDDRAWI_DDRAWPALETTE_INT)iface;
ULONG ref=0; ULONG ref=0;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface!=NULL) if (iface!=NULL)
{ {
ref = InterlockedIncrement( (PLONG) &This->DDPalette.dwRefCnt); ref = InterlockedIncrement( (PLONG) &This->dwIntRefCnt);
} }
return ref; return ref;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawPalette_Initialize( LPDIRECTDRAWPALETTE iface, DirectDrawPalette_Initialize( LPDIRECTDRAWPALETTE iface,
LPDIRECTDRAW ddraw, LPDIRECTDRAW ddraw,
DWORD dwFlags, DWORD dwFlags,
LPPALETTEENTRY palent) LPPALETTEENTRY palent)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawPalette_GetEntries( LPDIRECTDRAWPALETTE iface, DirectDrawPalette_GetEntries( LPDIRECTDRAWPALETTE iface,
DWORD dwFlags, DWORD dwFlags,
DWORD dwStart, DWORD dwCount, DWORD dwStart, DWORD dwCount,
LPPALETTEENTRY palent) LPPALETTEENTRY palent)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawPalette_SetEntries( LPDIRECTDRAWPALETTE iface, DirectDrawPalette_SetEntries( LPDIRECTDRAWPALETTE iface,
DWORD dwFlags, DWORD dwFlags,
DWORD dwStart, DWORD dwStart,
DWORD dwCount, DWORD dwCount,
LPPALETTEENTRY palent) LPPALETTEENTRY palent)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawPalette_GetCaps( LPDIRECTDRAWPALETTE iface, DirectDrawPalette_GetCaps( LPDIRECTDRAWPALETTE iface,
LPDWORD lpdwCaps) LPDWORD lpdwCaps)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
DirectDrawPalette_QueryInterface( LPDIRECTDRAWPALETTE iface, DirectDrawPalette_QueryInterface( LPDIRECTDRAWPALETTE iface,
REFIID refiid, REFIID refiid,
LPVOID *obj) LPVOID *obj)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
IDirectDrawPaletteVtbl DirectDrawPalette_Vtable = IDirectDrawPaletteVtbl DirectDrawPalette_Vtable =
{ {
DirectDrawPalette_QueryInterface, DirectDrawPalette_QueryInterface,
DirectDrawPalette_AddRef, DirectDrawPalette_AddRef,
DirectDrawPalette_Release, DirectDrawPalette_Release,
DirectDrawPalette_GetCaps, DirectDrawPalette_GetCaps,
DirectDrawPalette_GetEntries, DirectDrawPalette_GetEntries,
DirectDrawPalette_Initialize, DirectDrawPalette_Initialize,
DirectDrawPalette_SetEntries DirectDrawPalette_SetEntries
}; };

550
reactos/dll/directx/ddraw/videoport.c → reactos/dll/directx/ddraw/iface_videoport.c
View file

@ -1,261 +1,289 @@
/* $Id$ /* $Id: videoport.c 22739 2006-07-01 12:08:35Z greatlrd $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS * PROJECT: ReactOS
* FILE: lib/ddraw/main/videoport.c * FILE: lib/ddraw/main/videoport.c
* PURPOSE: IDirectDrawVideoPort, DDVideoPortContainer and IDirectDrawVideoPortNotify Implementation * PURPOSE: IDirectDrawVideoPort, DDVideoPortContainer and IDirectDrawVideoPortNotify Implementation
* PROGRAMMER: Maarten Bosma * PROGRAMMER: Maarten Bosma
* *
*/ */
#include "rosdraw.h" #include "rosdraw.h"
/************* IDirectDrawVideoPort *************/ /************* IDirectDrawVideoPort *************/
HRESULT WINAPI HRESULT WINAPI
Main_DirectDrawVideoPort_QueryInterface (LPDIRECTDRAWVIDEOPORT iface, REFIID riid, LPVOID* ppvObj) Main_DirectDrawVideoPort_QueryInterface (LPDIRECTDRAWVIDEOPORT iface, REFIID riid, LPVOID* ppvObj)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
ULONG WINAPI ULONG WINAPI
Main_DirectDrawVideoPort_AddRef (LPDIRECTDRAWVIDEOPORT iface) Main_DirectDrawVideoPort_AddRef (LPDIRECTDRAWVIDEOPORT iface)
{ {
DX_WINDBG_trace(); LPDDRAWI_DDVIDEOPORT_INT This = (LPDDRAWI_DDVIDEOPORT_INT)iface;
DX_STUB; ULONG ref=0;
}
DX_WINDBG_trace();
ULONG WINAPI
Main_DirectDrawVideoPort_Release (LPDIRECTDRAWVIDEOPORT iface) if (iface!=NULL)
{ {
DX_WINDBG_trace(); ref = InterlockedIncrement( (PLONG) &This->dwIntRefCnt);
DX_STUB; }
} return ref;
}
HRESULT WINAPI
Main_DirectDrawVideoPort_Flip (LPDIRECTDRAWVIDEOPORT iface, LPDIRECTDRAWSURFACE lpDDSurface, DWORD dwFlags) ULONG WINAPI
{ Main_DirectDrawVideoPort_Release (LPDIRECTDRAWVIDEOPORT iface)
DX_WINDBG_trace(); {
DX_STUB; LPDDRAWI_DDVIDEOPORT_INT This = (LPDDRAWI_DDVIDEOPORT_INT)iface;
} ULONG ref=0;
HRESULT WINAPI DX_WINDBG_trace();
Main_DirectDrawVideoPort_GetBandwidthInfo (LPDIRECTDRAWVIDEOPORT iface, LPDDPIXELFORMAT lpddpfFormat, DWORD dwWidth,
DWORD dwHeight, DWORD dwFlags, LPDDVIDEOPORTBANDWIDTH lpBandwidth) if (iface!=NULL)
{ {
DX_WINDBG_trace(); ref = InterlockedDecrement( (PLONG) &This->dwIntRefCnt);
DX_STUB;
} if (ref == 0)
{
HRESULT WINAPI /* Add here if we need releae some memory pointer before
Main_DirectDrawVideoPort_GetColorControls (LPDIRECTDRAWVIDEOPORT iface, LPDDCOLORCONTROL lpColorControl) * exists
{ */
DX_WINDBG_trace();
DX_STUB; if (This!=NULL)
} {
DxHeapMemFree(This);
HRESULT WINAPI Main_DirectDrawVideoPort_GetInputFormats (LPDIRECTDRAWVIDEOPORT iface, LPDWORD lpNumFormats, }
LPDDPIXELFORMAT lpFormats, DWORD dwFlags) }
{ }
DX_WINDBG_trace(); return ref;
DX_STUB; }
}
HRESULT WINAPI
HRESULT WINAPI Main_DirectDrawVideoPort_GetOutputFormats (LPDIRECTDRAWVIDEOPORT iface, LPDDPIXELFORMAT lpInputFormat, Main_DirectDrawVideoPort_Flip (LPDIRECTDRAWVIDEOPORT iface, LPDIRECTDRAWSURFACE lpDDSurface, DWORD dwFlags)
LPDWORD lpNumFormats, LPDDPIXELFORMAT lpFormats, DWORD dwFlags) {
{ DX_WINDBG_trace();
DX_WINDBG_trace(); DX_STUB;
DX_STUB; }
}
HRESULT WINAPI
HRESULT WINAPI Main_DirectDrawVideoPort_GetFieldPolarity (LPDIRECTDRAWVIDEOPORT iface, LPBOOL lpbFieldPolarity) Main_DirectDrawVideoPort_GetBandwidthInfo (LPDIRECTDRAWVIDEOPORT iface, LPDDPIXELFORMAT lpddpfFormat, DWORD dwWidth,
{ DWORD dwHeight, DWORD dwFlags, LPDDVIDEOPORTBANDWIDTH lpBandwidth)
DX_WINDBG_trace(); {
DX_STUB; DX_WINDBG_trace();
} DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetVideoLine (LPDIRECTDRAWVIDEOPORT This, LPDWORD lpdwLine)
{ HRESULT WINAPI
DX_WINDBG_trace(); Main_DirectDrawVideoPort_GetColorControls (LPDIRECTDRAWVIDEOPORT iface, LPDDCOLORCONTROL lpColorControl)
DX_STUB; {
} DX_WINDBG_trace();
DX_STUB;
HRESULT WINAPI Main_DirectDrawVideoPort_GetVideoSignalStatus (LPDIRECTDRAWVIDEOPORT iface, LPDWORD lpdwStatus) }
{
DX_WINDBG_trace(); HRESULT WINAPI Main_DirectDrawVideoPort_GetInputFormats (LPDIRECTDRAWVIDEOPORT iface, LPDWORD lpNumFormats,
DX_STUB; LPDDPIXELFORMAT lpFormats, DWORD dwFlags)
} {
DX_WINDBG_trace();
HRESULT WINAPI Main_DirectDrawVideoPort_SetColorControls (LPDIRECTDRAWVIDEOPORT iface, LPDDCOLORCONTROL lpColorControl) DX_STUB;
{ }
DX_WINDBG_trace();
DX_STUB; HRESULT WINAPI Main_DirectDrawVideoPort_GetOutputFormats (LPDIRECTDRAWVIDEOPORT iface, LPDDPIXELFORMAT lpInputFormat,
} LPDWORD lpNumFormats, LPDDPIXELFORMAT lpFormats, DWORD dwFlags)
{
HRESULT WINAPI Main_DirectDrawVideoPort_SetTargetSurface (LPDIRECTDRAWVIDEOPORT iface, LPDIRECTDRAWSURFACE lpDDSurface, DX_WINDBG_trace();
DWORD dwFlags) DX_STUB;
{ }
DX_WINDBG_trace();
DX_STUB; HRESULT WINAPI Main_DirectDrawVideoPort_GetFieldPolarity (LPDIRECTDRAWVIDEOPORT iface, LPBOOL lpbFieldPolarity)
} {
DX_WINDBG_trace();
HRESULT WINAPI Main_DirectDrawVideoPort_StartVideo (LPDIRECTDRAWVIDEOPORT iface, LPDDVIDEOPORTINFO dwFlags) DX_STUB;
{ }
DX_WINDBG_trace();
DX_STUB; HRESULT WINAPI Main_DirectDrawVideoPort_GetVideoLine (LPDIRECTDRAWVIDEOPORT This, LPDWORD lpdwLine)
} {
DX_WINDBG_trace();
HRESULT WINAPI Main_DirectDrawVideoPort_StopVideo (LPDIRECTDRAWVIDEOPORT iface) DX_STUB;
{ }
DX_WINDBG_trace();
DX_STUB; HRESULT WINAPI Main_DirectDrawVideoPort_GetVideoSignalStatus (LPDIRECTDRAWVIDEOPORT iface, LPDWORD lpdwStatus)
} {
DX_WINDBG_trace();
HRESULT WINAPI Main_DirectDrawVideoPort_UpdateVideo (LPDIRECTDRAWVIDEOPORT iface, LPDDVIDEOPORTINFO dwFlags) DX_STUB;
{ }
DX_WINDBG_trace();
DX_STUB; HRESULT WINAPI Main_DirectDrawVideoPort_SetColorControls (LPDIRECTDRAWVIDEOPORT iface, LPDDCOLORCONTROL lpColorControl)
} {
DX_WINDBG_trace();
HRESULT WINAPI Main_DirectDrawVideoPort_WaitForSync (LPDIRECTDRAWVIDEOPORT iface, DWORD dwFlags, DWORD dwLine, DX_STUB;
DWORD dwTimeout) }
{
DX_WINDBG_trace(); HRESULT WINAPI Main_DirectDrawVideoPort_SetTargetSurface (LPDIRECTDRAWVIDEOPORT iface, LPDIRECTDRAWSURFACE lpDDSurface,
DX_STUB; DWORD dwFlags)
} {
DX_WINDBG_trace();
/************* IDDVideoPortContainer *************/ DX_STUB;
}
HRESULT WINAPI Main_DDVideoPortContainer_QueryInterface (LPDDVIDEOPORTCONTAINER iface, REFIID riid, LPVOID* ppvObj)
{ HRESULT WINAPI Main_DirectDrawVideoPort_StartVideo (LPDIRECTDRAWVIDEOPORT iface, LPDDVIDEOPORTINFO dwFlags)
DX_WINDBG_trace(); {
DX_STUB; DX_WINDBG_trace();
} DX_STUB;
}
ULONG WINAPI Main_DDVideoPortContainer_AddRef (LPDDVIDEOPORTCONTAINER iface)
{ HRESULT WINAPI Main_DirectDrawVideoPort_StopVideo (LPDIRECTDRAWVIDEOPORT iface)
DX_WINDBG_trace(); {
DX_STUB; DX_WINDBG_trace();
} DX_STUB;
}
ULONG WINAPI Main_DDVideoPortContainer_Release (LPDDVIDEOPORTCONTAINER iface)
{ HRESULT WINAPI Main_DirectDrawVideoPort_UpdateVideo (LPDIRECTDRAWVIDEOPORT iface, LPDDVIDEOPORTINFO dwFlags)
DX_WINDBG_trace(); {
DX_STUB; DX_WINDBG_trace();
} DX_STUB;
}
HRESULT WINAPI Main_DDVideoPortContainer_CreateVideoPort (LPDDVIDEOPORTCONTAINER iface, DWORD dwFlags, LPDDVIDEOPORTDESC pPortDesc,
LPDIRECTDRAWVIDEOPORT* DDVideoPort, IUnknown* pUnkOuter) HRESULT WINAPI Main_DirectDrawVideoPort_WaitForSync (LPDIRECTDRAWVIDEOPORT iface, DWORD dwFlags, DWORD dwLine,
{ DWORD dwTimeout)
DX_WINDBG_trace(); {
DX_STUB; DX_WINDBG_trace();
} DX_STUB;
}
HRESULT WINAPI
Main_DDVideoPortContainer_EnumVideoPorts (LPDDVIDEOPORTCONTAINER iface, /************* IDDVideoPortContainer *************/
DWORD dwFlags,
LPDDVIDEOPORTCAPS pCaps, HRESULT WINAPI Main_DDVideoPortContainer_QueryInterface (LPDDVIDEOPORTCONTAINER iface, REFIID riid, LPVOID* ppvObj)
LPVOID pContext, {
LPDDENUMVIDEOCALLBACK pEnumVideoCallback) DX_WINDBG_trace();
{ DX_STUB;
DX_WINDBG_trace(); }
DX_STUB;
} ULONG WINAPI Main_DDVideoPortContainer_AddRef (LPDDVIDEOPORTCONTAINER iface)
{
HRESULT WINAPI DX_WINDBG_trace();
Main_DDVideoPortContainer_GetVideoPortConnectInfo (LPDDVIDEOPORTCONTAINER iface, DX_STUB;
DWORD PortId, DWORD* pNumEntries, }
LPDDVIDEOPORTCONNECT pConnectInfo)
{ ULONG WINAPI Main_DDVideoPortContainer_Release (LPDDVIDEOPORTCONTAINER iface)
DX_WINDBG_trace(); {
DX_STUB; DX_WINDBG_trace();
} DX_STUB;
}
HRESULT WINAPI
Main_DDVideoPortContainer_QueryVideoPortStatus (LPDDVIDEOPORTCONTAINER iface, HRESULT WINAPI Main_DDVideoPortContainer_CreateVideoPort (LPDDVIDEOPORTCONTAINER iface, DWORD dwFlags, LPDDVIDEOPORTDESC pPortDesc,
DWORD PortId, LPDIRECTDRAWVIDEOPORT* DDVideoPort, IUnknown* pUnkOuter)
LPDDVIDEOPORTSTATUS pStatus) {
{ DX_WINDBG_trace();
DX_WINDBG_trace(); DX_STUB;
DX_STUB; }
}
HRESULT WINAPI
/************* IDirectDrawVideoPortNotify *************/ Main_DDVideoPortContainer_EnumVideoPorts (LPDDVIDEOPORTCONTAINER iface,
DWORD dwFlags,
HRESULT WINAPI LPDDVIDEOPORTCAPS pCaps,
Main_DDVideoPortNotify_QueryInterface (LPDIRECTDRAWVIDEOPORTNOTIFY iface, REFIID LPVOID pContext,
riid, LPVOID* ppvObj) LPDDENUMVIDEOCALLBACK pEnumVideoCallback)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
ULONG WINAPI HRESULT WINAPI
Main_DDVideoPortNotify_AddRef (LPDIRECTDRAWVIDEOPORTNOTIFY iface) Main_DDVideoPortContainer_GetVideoPortConnectInfo (LPDDVIDEOPORTCONTAINER iface,
{ DWORD PortId, DWORD* pNumEntries,
DX_WINDBG_trace(); LPDDVIDEOPORTCONNECT pConnectInfo)
DX_STUB; {
} DX_WINDBG_trace();
DX_STUB;
ULONG WINAPI }
Main_DDVideoPortNotify_Release (LPDIRECTDRAWVIDEOPORTNOTIFY iface)
{ HRESULT WINAPI
DX_WINDBG_trace(); Main_DDVideoPortContainer_QueryVideoPortStatus (LPDDVIDEOPORTCONTAINER iface,
DX_STUB; DWORD PortId,
} LPDDVIDEOPORTSTATUS pStatus)
{
HRESULT WINAPI Main_DDVideoPortNotify_AcquireNotification (LPDIRECTDRAWVIDEOPORTNOTIFY iface, HANDLE* h, LPDDVIDEOPORTNOTIFY pVideoPortNotify) DX_WINDBG_trace();
{ DX_STUB;
DX_WINDBG_trace(); }
DX_STUB;
} /************* IDirectDrawVideoPortNotify *************/
HRESULT WINAPI Main_DDVideoPortNotify_ReleaseNotification (LPDIRECTDRAWVIDEOPORTNOTIFY iface, HANDLE h) HRESULT WINAPI
{ Main_DDVideoPortNotify_QueryInterface (LPDIRECTDRAWVIDEOPORTNOTIFY iface, REFIID
DX_WINDBG_trace(); riid, LPVOID* ppvObj)
DX_STUB; {
} DX_WINDBG_trace();
DX_STUB;
IDirectDrawVideoPortVtbl DirectDrawVideoPort_Vtable = }
{
Main_DirectDrawVideoPort_QueryInterface, ULONG WINAPI
Main_DirectDrawVideoPort_AddRef, Main_DDVideoPortNotify_AddRef (LPDIRECTDRAWVIDEOPORTNOTIFY iface)
Main_DirectDrawVideoPort_Release, {
Main_DirectDrawVideoPort_Flip, DX_WINDBG_trace();
Main_DirectDrawVideoPort_GetBandwidthInfo, DX_STUB;
Main_DirectDrawVideoPort_GetColorControls, }
Main_DirectDrawVideoPort_GetInputFormats,
Main_DirectDrawVideoPort_GetOutputFormats, ULONG WINAPI
Main_DirectDrawVideoPort_GetFieldPolarity, Main_DDVideoPortNotify_Release (LPDIRECTDRAWVIDEOPORTNOTIFY iface)
Main_DirectDrawVideoPort_GetVideoLine, {
Main_DirectDrawVideoPort_GetVideoSignalStatus, DX_WINDBG_trace();
Main_DirectDrawVideoPort_SetColorControls, DX_STUB;
Main_DirectDrawVideoPort_SetTargetSurface, }
Main_DirectDrawVideoPort_StartVideo,
Main_DirectDrawVideoPort_StopVideo, HRESULT WINAPI Main_DDVideoPortNotify_AcquireNotification (LPDIRECTDRAWVIDEOPORTNOTIFY iface, HANDLE* h, LPDDVIDEOPORTNOTIFY pVideoPortNotify)
Main_DirectDrawVideoPort_UpdateVideo, {
Main_DirectDrawVideoPort_WaitForSync DX_WINDBG_trace();
}; DX_STUB;
}
IDDVideoPortContainerVtbl DDVideoPortContainer_Vtable =
{ HRESULT WINAPI Main_DDVideoPortNotify_ReleaseNotification (LPDIRECTDRAWVIDEOPORTNOTIFY iface, HANDLE h)
Main_DDVideoPortContainer_QueryInterface, {
Main_DDVideoPortContainer_AddRef, DX_WINDBG_trace();
Main_DDVideoPortContainer_Release, DX_STUB;
Main_DDVideoPortContainer_CreateVideoPort, }
Main_DDVideoPortContainer_EnumVideoPorts,
Main_DDVideoPortContainer_GetVideoPortConnectInfo, IDirectDrawVideoPortVtbl DirectDrawVideoPort_Vtable =
Main_DDVideoPortContainer_QueryVideoPortStatus {
}; Main_DirectDrawVideoPort_QueryInterface,
Main_DirectDrawVideoPort_AddRef,
IDirectDrawVideoPortNotifyVtbl DDVideoPortNotify_Vtable = Main_DirectDrawVideoPort_Release,
{ Main_DirectDrawVideoPort_Flip,
Main_DDVideoPortNotify_QueryInterface, Main_DirectDrawVideoPort_GetBandwidthInfo,
Main_DDVideoPortNotify_AddRef, Main_DirectDrawVideoPort_GetColorControls,
Main_DDVideoPortNotify_Release, Main_DirectDrawVideoPort_GetInputFormats,
Main_DDVideoPortNotify_AcquireNotification, Main_DirectDrawVideoPort_GetOutputFormats,
Main_DDVideoPortNotify_ReleaseNotification Main_DirectDrawVideoPort_GetFieldPolarity,
}; Main_DirectDrawVideoPort_GetVideoLine,
Main_DirectDrawVideoPort_GetVideoSignalStatus,
Main_DirectDrawVideoPort_SetColorControls,
Main_DirectDrawVideoPort_SetTargetSurface,
Main_DirectDrawVideoPort_StartVideo,
Main_DirectDrawVideoPort_StopVideo,
Main_DirectDrawVideoPort_UpdateVideo,
Main_DirectDrawVideoPort_WaitForSync
};
IDDVideoPortContainerVtbl DDVideoPortContainer_Vtable =
{
Main_DDVideoPortContainer_QueryInterface,
Main_DDVideoPortContainer_AddRef,
Main_DDVideoPortContainer_Release,
Main_DDVideoPortContainer_CreateVideoPort,
Main_DDVideoPortContainer_EnumVideoPorts,
Main_DDVideoPortContainer_GetVideoPortConnectInfo,
Main_DDVideoPortContainer_QueryVideoPortStatus
};
IDirectDrawVideoPortNotifyVtbl DDVideoPortNotify_Vtable =
{
Main_DDVideoPortNotify_QueryInterface,
Main_DDVideoPortNotify_AddRef,
Main_DDVideoPortNotify_Release,
Main_DDVideoPortNotify_AcquireNotification,
Main_DDVideoPortNotify_ReleaseNotification
};

8
reactos/dll/directx/ddraw/main.c
View file

@ -9,9 +9,10 @@
* *
*/ */
#include <windows.h>
#include "rosdraw.h" #include "rosdraw.h"
#include "d3dhal.h"
#undef DirectDrawCreate
CRITICAL_SECTION ddcs; CRITICAL_SECTION ddcs;
@ -165,8 +166,7 @@ DirectDrawEnumerateExW(LPDDENUMCALLBACKEXW lpCallback,
to get the xxxx end positions. to get the xxxx end positions.
*/ */
HRESULT HRESULT WINAPI
WINAPI
D3DParseUnknownCommand( LPVOID lpCmd, D3DParseUnknownCommand( LPVOID lpCmd,
LPVOID *lpRetCmd) LPVOID *lpRetCmd)
{ {

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

File diff suppressed because it is too large Load diff

562
reactos/dll/directx/ddraw/main/surface_main.c
View file

@ -28,133 +28,199 @@ HRESULT WINAPI Main_DDrawSurface_Initialize (LPDIRECTDRAWSURFACE7 iface, LPDIREC
ULONG WINAPI Main_DDrawSurface_AddRef(LPDIRECTDRAWSURFACE7 iface) ULONG WINAPI Main_DDrawSurface_AddRef(LPDIRECTDRAWSURFACE7 iface)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
return InterlockedIncrement((PLONG)&This->Owner->mDDrawGlobal.dsList->dwIntRefCnt); if (iface!=NULL)
{
This->dwIntRefCnt++;
This->lpLcl->dwLocalRefCnt++;
if (This->lpLcl->lpGbl != NULL)
{
This->lpLcl->lpGbl->dwRefCnt++;
}
}
return This->dwIntRefCnt;
} }
ULONG WINAPI Main_DDrawSurface_Release(LPDIRECTDRAWSURFACE7 iface) ULONG WINAPI Main_DDrawSurface_Release(LPDIRECTDRAWSURFACE7 iface)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
ULONG ref = InterlockedDecrement((PLONG)&This->Owner->mDDrawGlobal.dsList->dwIntRefCnt);
if (ref == 0)
HeapFree(GetProcessHeap(), 0, This);
return ref; /* FIXME
This is not right exiame how it should be done
*/
DX_STUB_str("FIXME This is not right exiame how it should be done\n");
return This->dwIntRefCnt;
} }
/**** Stubs ****/
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_QueryInterface(LPDIRECTDRAWSURFACE7 iface, REFIID riid, Main_DDrawSurface_QueryInterface(LPDIRECTDRAWSURFACE7 iface, REFIID riid,
LPVOID* ppObj) LPVOID* ppObj)
{ {
DX_WINDBG_trace(); DX_WINDBG_trace();
DX_STUB_str("Unimplement\n");
return E_NOINTERFACE; return E_NOINTERFACE;
} }
HRESULT WINAPI Main_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst, HRESULT WINAPI Main_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst,
LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx) LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; LPDDRAWI_DDRAWSURFACE_INT ThisDest = (LPDDRAWI_DDRAWSURFACE_INT)iface;
LPDDRAWI_DDRAWSURFACE_INT ThisSrc = (LPDDRAWI_DDRAWSURFACE_INT)src;
DDHAL_BLTDATA BltData;
DX_WINDBG_trace(); DX_WINDBG_trace();
RtlZeroMemory(&BltData,sizeof(DDHAL_BLTDATA));
BltData.ddRVal = DDERR_GENERIC;
if (ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_BLT)
{
BltData.lpDD = ThisDest->lpLcl->lpGbl->lpDD;
BltData.Blt = ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.Blt;
BltData.lpDDDestSurface = ThisDest->lpLcl;
BltData.lpDDSrcSurface = ThisSrc->lpLcl;
BltData.dwFlags = dwFlags;
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_BLT) if (rdst != NULL)
{ {
return Hal_DDrawSurface_Blt( iface, rdst, src, rsrc, dwFlags, lpbltfx); memmove (&BltData.rSrc, rdst, sizeof (RECTL));
} }
return Hel_DDrawSurface_Blt( iface, rdst, src, rsrc, dwFlags, lpbltfx); if (rsrc != NULL)
{
memmove (&BltData.rDest, rsrc, sizeof (RECTL));
}
if (lpbltfx != NULL)
{
memmove (&BltData.bltFX, lpbltfx, sizeof (DDBLTFX));
}
DX_STUB_str("FIXME : Fill the BltData member dwRectCnt, dwROPFlags, IsClipped, prDestRects, rOrigDest, rOrigSrc before calling Blt\n");
/* FIXME
// BltData.dwRectCnt
// BltData.dwROPFlags
// BltData.IsClipped
// BltData.prDestRects
// BltData.rOrigDest
// BltData.rOrigSrc
*/
if (!DdResetVisrgn( ThisDest->lpLcl, NULL))
{
return DDERR_NOGDI;
}
if (BltData.Blt(&BltData) == DDHAL_DRIVER_HANDLED)
{
return BltData.ddRVal;
}
}
return DDERR_GENERIC;
} }
HRESULT WINAPI Main_DDrawSurface_Lock (LPDIRECTDRAWSURFACE7 iface, LPRECT prect, HRESULT WINAPI Main_DDrawSurface_Lock (LPDIRECTDRAWSURFACE7 iface, LPRECT prect,
LPDDSURFACEDESC2 pDDSD, DWORD flags, HANDLE event) LPDDSURFACEDESC2 pDDSD, DWORD flags, HANDLE events)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DDHAL_LOCKDATA LockData;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (event != NULL) if (events != NULL)
{ {
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_LOCK) RtlZeroMemory(&LockData,sizeof(DDHAL_LOCKDATA));
LockData.ddRVal = DDERR_GENERIC;
if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_LOCK)
{ {
return Hal_DDrawSurface_Lock( iface, prect, pDDSD, flags, event); LockData.lpDD = This->lpLcl->lpGbl->lpDD;
LockData.Lock = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.Lock;
//LockData.lpDDSurface;
//LockData.bHasRect;
//LockData.rArea;
//LockData.lpSurfData;
LockData.dwFlags = flags;
if (LockData.Lock(&LockData) == DDHAL_DRIVER_HANDLED)
{
return LockData.ddRVal;
}
} }
return Hel_DDrawSurface_Lock( iface, prect, pDDSD, flags, event);
return DDERR_GENERIC;
} }
HRESULT WINAPI Main_DDrawSurface_Unlock (LPDIRECTDRAWSURFACE7 iface, LPRECT pRect) HRESULT WINAPI Main_DDrawSurface_Unlock (LPDIRECTDRAWSURFACE7 iface, LPRECT pRect)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DDHAL_UNLOCKDATA unLock;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_LOCK) if (!This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_UNLOCK)
{ {
return Hal_DDrawSurface_Unlock( iface, pRect); return DDERR_UNSUPPORTED;
} }
return Hel_DDrawSurface_Unlock( iface, pRect); unLock.ddRVal = DDERR_NOTPALETTIZED;
unLock.lpDD = This->lpLcl->lpGbl->lpDD;
unLock.lpDDSurface = This->lpLcl;
unLock.Unlock = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.Unlock;
if (!DdResetVisrgn( unLock.lpDDSurface, NULL))
{
return DDERR_UNSUPPORTED;
}
if (unLock.Unlock(&unLock)!= DDHAL_DRIVER_HANDLED)
{
return DDERR_UNSUPPORTED;
}
if (unLock.ddRVal!= DD_OK)
{
return unLock.ddRVal;
}
return DD_OK;
} }
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_AddAttachedSurface(LPDIRECTDRAWSURFACE7 iface, Main_DDrawSurface_AddAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
LPDIRECTDRAWSURFACE7 pAttach) LPDIRECTDRAWSURFACE7 pAttach)
{ {
DWORD ret;
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; // LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
IDirectDrawSurfaceImpl* That = (IDirectDrawSurfaceImpl*)pAttach; // LPDDRAWI_DDRAWSURFACE_INT That = (LPDDRAWI_DDRAWSURFACE_INT)pAttach;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (pAttach==NULL) DX_STUB;
{
return DDERR_CANNOTATTACHSURFACE;
}
ret = DdAttachSurface( That->Surf->mpPrimaryLocals[0],This->Surf->mpPrimaryLocals[0]);
if (ret == DD_OK)
{
/*
Here we put in wine code
Wine Code from wine cvs 27/7-2006
with small changes to fith into our ddraw desgin
*/
if (This->Surf->mddsdPrimary.ddsCaps.dwCaps & That->Surf->mddsdPrimary.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
{
That->Surf->mddsdPrimary.ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
}
if( (That->Surf->next_attached != NULL) || (That->Surf->first_attached != (DWORD*)That) )
{
DX_STUB_str("Wine Code fails");
return DDERR_CANNOTATTACHSURFACE;
}
That->Surf->next_attached = This->Surf->next_attached;
That->Surf->first_attached = This->Surf->first_attached;
This->Surf->next_attached = (DWORD*)That;
Main_DDrawSurface_AddRef((LPDIRECTDRAWSURFACE7)pAttach);
return DD_OK;
}
return ret;
} }
/* MSDN: "not currently implemented." */ /* MSDN: "not currently implemented." */
@ -219,45 +285,9 @@ Main_DDrawSurface_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE7 iface,
LPVOID context, LPVOID context,
LPDDENUMSURFACESCALLBACK7 cb) LPDDENUMSURFACESCALLBACK7 cb)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; DX_WINDBG_trace();
IDirectDrawSurfaceImpl *surf;
DDSURFACEDESC2 desc;
DX_WINDBG_trace(); DX_STUB;
/*
Wine Code from wine cvs 27/7-2006
with small changes to fith into our ddraw desgin
*/
if(cb == NULL)
{
return DDERR_INVALIDPARAMS;
}
for (surf = (IDirectDrawSurfaceImpl*)This->Surf->next_complex; surf != NULL; surf = (IDirectDrawSurfaceImpl*)surf->Surf->next_complex)
{
Main_DDrawSurface_AddRef((LPDIRECTDRAWSURFACE7)surf);
desc = surf->Surf->mddsdPrimary;
/* check: != DDENUMRET_OK or == DDENUMRET_CANCEL? */
if (cb((LPDIRECTDRAWSURFACE7)surf, &desc, context) == DDENUMRET_CANCEL)
{
return DD_OK;
}
}
for (surf = (IDirectDrawSurfaceImpl*)This->Surf->next_attached; surf != NULL; surf = (IDirectDrawSurfaceImpl*)surf->Surf->next_attached)
{
Main_DDrawSurface_AddRef((LPDIRECTDRAWSURFACE7)surf);
desc = surf->Surf->mddsdPrimary;
/* check: != DDENUMRET_OK or == DDENUMRET_CANCEL? */
if (cb((LPDIRECTDRAWSURFACE7)surf, &desc, context) == DDENUMRET_CANCEL)
{
return DD_OK;
}
}
return DD_OK;
} }
HRESULT WINAPI HRESULT WINAPI
@ -272,18 +302,11 @@ Main_DDrawSurface_EnumOverlayZOrders(LPDIRECTDRAWSURFACE7 iface,
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_Flip(LPDIRECTDRAWSURFACE7 iface, Main_DDrawSurface_Flip(LPDIRECTDRAWSURFACE7 iface,
LPDIRECTDRAWSURFACE7 override, DWORD dwFlags) LPDIRECTDRAWSURFACE7 lpDDSurfaceTargetOverride, DWORD dwFlags)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; DX_WINDBG_trace();
DX_WINDBG_trace(); DX_STUB;
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_FLIP)
{
return Hal_DDrawSurface_Flip(iface, override, dwFlags);
}
return Hel_DDrawSurface_Flip(iface, override, dwFlags);
} }
HRESULT WINAPI HRESULT WINAPI
@ -299,86 +322,33 @@ Main_DDrawSurface_GetAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
LPDDSCAPS2 pCaps, LPDDSCAPS2 pCaps,
LPDIRECTDRAWSURFACE7* ppSurface) LPDIRECTDRAWSURFACE7* ppSurface)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; //LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
IDirectDrawSurfaceImpl *surf; //LPDDRAWI_DDRAWSURFACE_INT surf;
DDSCAPS2 our_caps;
DX_WINDBG_trace(); DX_WINDBG_trace();
/* DX_STUB;
Wine Code from wine cvs 27/7-2006
with small changes to fith into our ddraw desgin
*/
our_caps = *pCaps;
/*
FIXME adding version check
Earlier dx apps put garbage into these members, clear them
*/
our_caps.dwCaps2 = 0;
our_caps.dwCaps3 = 0;
our_caps.dwCaps4 = 0;
//surf = (IDirectDrawSurfaceImpl*)This->Surf->next_complex;
if (This->Surf->next_complex != NULL)
{
surf = (IDirectDrawSurfaceImpl*)This->Surf->next_complex;
while( surf != NULL )
{
if (((surf->Surf->mddsdPrimary.ddsCaps.dwCaps & our_caps.dwCaps) == our_caps.dwCaps) &&
((surf->Surf->mddsdPrimary.ddsCaps.dwCaps2 & our_caps.dwCaps2) == our_caps.dwCaps2))
{
*ppSurface = (LPDIRECTDRAWSURFACE7)surf;
Main_DDrawSurface_AddRef(*ppSurface);
DX_STUB_str("surf->Surf->next_complex ok");
return DD_OK;
}
surf = (IDirectDrawSurfaceImpl*)This->Surf->next_complex;
}
}
if (This->Surf->next_attached != NULL)
{
surf = (IDirectDrawSurfaceImpl*)This->Surf->next_attached;
while(surf != NULL)
{
if (((surf->Surf->mddsdPrimary.ddsCaps.dwCaps & our_caps.dwCaps) == our_caps.dwCaps) &&
((surf->Surf->mddsdPrimary.ddsCaps.dwCaps2 & our_caps.dwCaps2) == our_caps.dwCaps2))
{
*ppSurface = (LPDIRECTDRAWSURFACE7)surf;
Main_DDrawSurface_AddRef(*ppSurface);
DX_STUB_str("surf->Surf->next_attached ok");
return DD_OK;
}
surf = (IDirectDrawSurfaceImpl*)This->Surf->next_attached;
}
}
DX_STUB_str("Fail");
return DDERR_NOTFOUND;
} }
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags) Main_DDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_FLIP) if (!This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_FLIP)
{ {
return Hal_DDrawSurface_GetBltStatus( iface, dwFlags); return DDERR_GENERIC;
} }
return Hel_DDrawSurface_GetBltStatus( iface, dwFlags); DX_STUB;
} }
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps) Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps)
{ {
IDirectDrawSurfaceImpl* This; LPDDRAWI_DDRAWSURFACE_INT This;
DX_WINDBG_trace(); DX_WINDBG_trace();
@ -392,10 +362,11 @@ Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps)
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
This = (IDirectDrawSurfaceImpl*)iface; This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
RtlZeroMemory(pCaps,sizeof(DDSCAPS2)); RtlZeroMemory(pCaps,sizeof(DDSCAPS2));
pCaps->dwCaps = This->Surf->mddsdPrimary.ddsCaps.dwCaps;
pCaps->dwCaps = This->lpLcl->ddsCaps.dwCaps;
return DD_OK; return DD_OK;
} }
@ -403,8 +374,7 @@ Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps)
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_GetClipper(LPDIRECTDRAWSURFACE7 iface, Main_DDrawSurface_GetClipper(LPDIRECTDRAWSURFACE7 iface,
LPDIRECTDRAWCLIPPER* ppClipper) LPDIRECTDRAWCLIPPER* ppClipper)
{ {
DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
@ -413,7 +383,9 @@ HRESULT WINAPI
Main_DDrawSurface_GetColorKey(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags, Main_DDrawSurface_GetColorKey(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags,
LPDDCOLORKEY pCKey) LPDDCOLORKEY pCKey)
{ {
DX_WINDBG_trace(); //LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DX_WINDBG_trace();
DX_STUB; DX_STUB;
} }
@ -421,7 +393,7 @@ Main_DDrawSurface_GetColorKey(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags,
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_GetDC(LPDIRECTDRAWSURFACE7 iface, HDC *phDC) Main_DDrawSurface_GetDC(LPDIRECTDRAWSURFACE7 iface, HDC *phDC)
{ {
IDirectDrawSurfaceImpl* This; LPDDRAWI_DDRAWSURFACE_INT This;
DX_WINDBG_trace(); DX_WINDBG_trace();
@ -435,21 +407,21 @@ Main_DDrawSurface_GetDC(LPDIRECTDRAWSURFACE7 iface, HDC *phDC)
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
This = (IDirectDrawSurfaceImpl*)iface; This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
/* /*
FIXME check if the surface exists or not FIXME check if the surface exists or not
for now we aussme the surface exits and create the hDC for it for now we aussme the surface exits and create the hDC for it
*/ */
if ((HDC)This->Surf->mPrimaryLocal.hDC == NULL) if ((HDC)This->lpLcl->hDC == NULL)
{ {
This->Surf->mPrimaryLocal.hDC = (ULONG_PTR)GetDC((HWND)This->Owner->mDDrawGlobal.lpExclusiveOwner->hWnd); This->lpLcl->hDC = (ULONG_PTR)GetDC((HWND)This->lpLcl->lpGbl->lpDD->lpExclusiveOwner->hWnd);
*phDC = (HDC)This->Surf->mPrimaryLocal.hDC; *phDC = (HDC)This->lpLcl->hDC;
} }
else else
{ {
*phDC = (HDC)This->Surf->mpPrimaryLocals[0]->hDC; *phDC = (HDC)This->lpLcl->hDC;
} }
return DD_OK; return DD_OK;
@ -528,7 +500,9 @@ Main_DDrawSurface_GetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface,
LPDDSURFACEDESC2 pDDSD) LPDDSURFACEDESC2 pDDSD)
{ {
DWORD dwSize; DWORD dwSize;
IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
dwSize = pDDSD->dwSize; dwSize = pDDSD->dwSize;
@ -538,10 +512,87 @@ Main_DDrawSurface_GetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface,
{ {
return DDERR_GENERIC; return DDERR_GENERIC;
} }
RtlZeroMemory(pDDSD,dwSize); ZeroMemory(pDDSD,dwSize);
memcpy(pDDSD, &This->Surf->mddsdPrimary, sizeof(DDSURFACEDESC));
pDDSD->dwSize = dwSize; if (dwSize == sizeof(DDSURFACEDESC))
{
LPDDSURFACEDESC lpDS = (LPDDSURFACEDESC) pDDSD;
memcpy(&lpDS->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
memcpy(&lpDS->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
memcpy(&lpDS->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
memcpy(&lpDS->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
memcpy(&lpDS->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
memcpy(&lpDS->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));
lpDS->dwAlphaBitDepth = This->lpLcl->dwAlpha;
lpDS->dwBackBufferCount = This->lpLcl->dwBackBufferCount;
/* FIXME setting the flags right */
// lpDS->dwFlags = This->lpLcl->dwFlags;
lpDS->dwHeight = This->lpLcl->lpGbl->wHeight;
lpDS->dwWidth = This->lpLcl->lpGbl->wWidth;
/* This two are a union in lpDS and in This->lpLcl->lpGbl
so I comment out lPitch
lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
*/
lpDS->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;
/* This tree are a union */
//lpDS->dwMipMapCount
//lpDS->dwRefreshRate
//lpDS->dwZBufferBitDepth
/* Unknown */
// lpDS->dwReserved
// lpDS->lpSurface
}
else
{
memcpy(&pDDSD->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
/*
pDDSD->dwEmptyFaceColor is a union to ddckCKDestOverlay
*/
memcpy(&pDDSD->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
memcpy(&pDDSD->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
memcpy(&pDDSD->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
/*
pDDSD->dwFVF is a union to ddpfPixelFormat
*/
memcpy(&pDDSD->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
memcpy(&pDDSD->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));
pDDSD->dwAlphaBitDepth = This->lpLcl->dwAlpha;
pDDSD->dwBackBufferCount = This->lpLcl->dwBackBufferCount;
/* FIXME setting the flags right */
// lpDS->dwFlags = This->lpLcl->dwFlags;
pDDSD->dwHeight = This->lpLcl->lpGbl->wHeight;
pDDSD->dwWidth = This->lpLcl->lpGbl->wWidth;
/* This two are a union in lpDS and in This->lpLcl->lpGbl
so I comment out lPitch
lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
*/
pDDSD->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;
/* This tree are a union */
// pDDSD->dwMipMapCount
// pDDSD->dwRefreshRate
// pDDSD->dwSrcVBHandle
/* Unknown */
// lpDS->dwReserved
// lpDS->lpSurface
// pDDSD->dwTextureStage
}
return DD_OK; return DD_OK;
} }
@ -584,7 +635,7 @@ Main_DDrawSurface_PageUnlock(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7 iface, HDC hDC) Main_DDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7 iface, HDC hDC)
{ {
IDirectDrawSurfaceImpl* This; LPDDRAWI_DDRAWSURFACE_INT This;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (iface == NULL) if (iface == NULL)
@ -597,17 +648,16 @@ Main_DDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7 iface, HDC hDC)
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
This = (IDirectDrawSurfaceImpl*)iface; This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
/* FIXME check if surface exits or not */ /* FIXME check if surface exits or not */
if ((HDC)This->Surf->mPrimaryLocal.hDC == NULL)
if ((HDC)This->lpLcl->hDC == NULL)
{ {
return DDERR_GENERIC; return DDERR_GENERIC;
} }
ReleaseDC((HWND)This->Owner->mDDrawGlobal.lpExclusiveOwner->hWnd,hDC);
return DD_OK; return DD_OK;
} }
@ -624,27 +674,72 @@ HRESULT WINAPI
Main_DDrawSurface_SetColorKey (LPDIRECTDRAWSURFACE7 iface, Main_DDrawSurface_SetColorKey (LPDIRECTDRAWSURFACE7 iface,
DWORD dwFlags, LPDDCOLORKEY pCKey) DWORD dwFlags, LPDDCOLORKEY pCKey)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DDHAL_SETCOLORKEYDATA ColorKeyData;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_SETCOLORKEY) ColorKeyData.ddRVal = DDERR_COLORKEYNOTSET;
{
return Hal_DDrawSurface_SetColorKey (iface, dwFlags, pCKey);
}
return Hel_DDrawSurface_SetColorKey (iface, dwFlags, pCKey); if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)
{
ColorKeyData.lpDD = This->lpLcl->lpGbl->lpDD;
ColorKeyData.SetColorKey = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetColorKey;
//ColorKeyData.lpDDSurface = &This->lpLcl->hDDSurface;
ColorKeyData.dwFlags = dwFlags;
/* FIXME
ColorKeyData.ckNew = ?
add / move dwFlags to This->lpLcl->dwFlags ??
*/
if (ColorKeyData.SetColorKey(&ColorKeyData) == DDHAL_DRIVER_HANDLED )
{
return ColorKeyData.ddRVal;
}
}
return DDERR_COLORKEYNOTSET;
} }
HRESULT WINAPI HRESULT WINAPI
Main_DDrawSurface_SetOverlayPosition (LPDIRECTDRAWSURFACE7 iface, Main_DDrawSurface_SetOverlayPosition (LPDIRECTDRAWSURFACE7 iface, LONG X, LONG Y)
LONG X, LONG Y)
{ {
DX_WINDBG_trace(); LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DDHAL_SETOVERLAYPOSITIONDATA OverLayPositionData;
DX_STUB; DX_WINDBG_trace();
OverLayPositionData.ddRVal = DDERR_COLORKEYNOTSET;
if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
{
OverLayPositionData.lpDD = This->lpLcl->lpGbl->lpDD;
OverLayPositionData.SetOverlayPosition = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetOverlayPosition;
//OverLayPositionData.lpDDSrcSurface = This->lpLcl->lpSurfaceOverlaying->lpLcl->hDDSurface;
//OverLayPositionData.lpDDDestSurface = This->lpLcl->hDDSurface;
OverLayPositionData.lXPos = X;
OverLayPositionData.lYPos = Y;
/* FIXME
Should X and Y be save ??
*/
if (OverLayPositionData.SetOverlayPosition(&OverLayPositionData) == DDHAL_DRIVER_HANDLED )
{
return OverLayPositionData.ddRVal;
}
}
return DDERR_GENERIC;
} }
HRESULT WINAPI HRESULT WINAPI
@ -692,16 +787,16 @@ HRESULT WINAPI
Main_DDrawSurface_UpdateOverlayDisplay (LPDIRECTDRAWSURFACE7 iface, Main_DDrawSurface_UpdateOverlayDisplay (LPDIRECTDRAWSURFACE7 iface,
DWORD dwFlags) DWORD dwFlags)
{ {
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface; LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DX_WINDBG_trace(); DX_WINDBG_trace();
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY) if (!This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY)
{ {
return Hal_DDrawSurface_UpdateOverlayDisplay ( iface, dwFlags); return DDERR_GENERIC;
} }
return Hel_DDrawSurface_UpdateOverlayDisplay ( iface, dwFlags); DX_STUB;
} }
HRESULT WINAPI Main_DDrawSurface_UpdateOverlayZOrder (LPDIRECTDRAWSURFACE7 iface, HRESULT WINAPI Main_DDrawSurface_UpdateOverlayZOrder (LPDIRECTDRAWSURFACE7 iface,
@ -712,11 +807,29 @@ HRESULT WINAPI Main_DDrawSurface_UpdateOverlayZOrder (LPDIRECTDRAWSURFACE7 iface
DX_STUB; DX_STUB;
} }
HRESULT WINAPI
Main_DDrawSurface_SetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface, DDSURFACEDESC2 *DDSD, DWORD Flags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDrawSurface_SetLOD(LPDIRECTDRAWSURFACE7 iface, DWORD MaxLOD)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawSurface7Vtbl DirectDrawSurface7_Vtable = IDirectDrawSurface7Vtbl DirectDrawSurface7_Vtable =
{ {
/*** IUnknown ***/
Main_DDrawSurface_QueryInterface, Main_DDrawSurface_QueryInterface,
Main_DDrawSurface_AddRef, Main_DDrawSurface_AddRef,
Main_DDrawSurface_Release, Main_DDrawSurface_Release,
/*** IDirectDrawSurface ***/
Main_DDrawSurface_AddAttachedSurface, Main_DDrawSurface_AddAttachedSurface,
Main_DDrawSurface_AddOverlayDirtyRect, Main_DDrawSurface_AddOverlayDirtyRect,
Main_DDrawSurface_Blt, Main_DDrawSurface_Blt,
@ -749,5 +862,22 @@ IDirectDrawSurface7Vtbl DirectDrawSurface7_Vtable =
Main_DDrawSurface_Unlock, Main_DDrawSurface_Unlock,
Main_DDrawSurface_UpdateOverlay, Main_DDrawSurface_UpdateOverlay,
Main_DDrawSurface_UpdateOverlayDisplay, Main_DDrawSurface_UpdateOverlayDisplay,
Main_DDrawSurface_UpdateOverlayZOrder Main_DDrawSurface_UpdateOverlayZOrder,
/*** IDirectDrawSurface2 ***/
Main_DDrawSurface_GetDDInterface,
Main_DDrawSurface_PageLock,
Main_DDrawSurface_PageUnlock,
/*** IDirectDrawSurface3 ***/
Main_DDrawSurface_SetSurfaceDesc,
/*** IDirectDrawSurface4 ***/
Main_DDrawSurface_SetPrivateData,
Main_DDrawSurface_GetPrivateData,
Main_DDrawSurface_FreePrivateData,
Main_DDrawSurface_GetUniquenessValue,
Main_DDrawSurface_ChangeUniquenessValue,
/*** IDirectDrawSurface7 ***/
Main_DDrawSurface_SetPriority,
Main_DDrawSurface_GetPriority,
Main_DDrawSurface_SetLOD,
Main_DDrawSurface_GetLOD
}; };

497
reactos/dll/directx/ddraw/regsvr.c
View file

@ -1,497 +0,0 @@
/*
* self-registerable dll functions for ddraw.dll
*
* Copyright (C) 2003 John K. Hohm
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* this file are from wine ddraw with some modification
*/
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "ddraw.h"
//#include "wine/debug.h"
//WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
/*
* Near the bottom of this file are the exported DllRegisterServer and
* DllUnregisterServer, which make all this worthwhile.
*/
/***********************************************************************
* interface for self-registering
*/
struct regsvr_interface
{
IID const *iid; /* NULL for end of list */
LPCSTR name; /* can be NULL to omit */
IID const *base_iid; /* can be NULL to omit */
int num_methods; /* can be <0 to omit */
CLSID const *ps_clsid; /* can be NULL to omit */
CLSID const *ps_clsid32; /* can be NULL to omit */
};
static HRESULT register_interfaces(struct regsvr_interface const *list);
static HRESULT unregister_interfaces(struct regsvr_interface const *list);
struct regsvr_coclass
{
CLSID const *clsid; /* NULL for end of list */
LPCSTR name; /* can be NULL to omit */
LPCSTR ips; /* can be NULL to omit */
LPCSTR ips32; /* can be NULL to omit */
LPCSTR ips32_tmodel; /* can be NULL to omit */
LPCSTR clsid_str; /* can be NULL to omit */
LPCSTR progid; /* can be NULL to omit */
};
static HRESULT register_coclasses(struct regsvr_coclass const *list);
static HRESULT unregister_coclasses(struct regsvr_coclass const *list);
/***********************************************************************
* static string constants
*/
static WCHAR const interface_keyname[10] = {
'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e', 0 };
static WCHAR const base_ifa_keyname[14] = {
'B', 'a', 's', 'e', 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c',
'e', 0 };
static WCHAR const num_methods_keyname[11] = {
'N', 'u', 'm', 'M', 'e', 't', 'h', 'o', 'd', 's', 0 };
static WCHAR const ps_clsid_keyname[15] = {
'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
'i', 'd', 0 };
static WCHAR const ps_clsid32_keyname[17] = {
'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's',
'i', 'd', '3', '2', 0 };
static WCHAR const clsid_keyname[6] = {
'C', 'L', 'S', 'I', 'D', 0 };
static WCHAR const ips_keyname[13] = {
'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
0 };
static WCHAR const ips32_keyname[15] = {
'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r',
'3', '2', 0 };
static WCHAR const progid_keyname[7] = {
'P', 'r', 'o', 'g', 'I', 'D', 0 };
static char const tmodel_valuename[] = "ThreadingModel";
/***********************************************************************
* static helper functions
*/
static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid);
static LONG register_key_defvalueW(HKEY base, WCHAR const *name,
WCHAR const *value);
static LONG register_key_defvalueA(HKEY base, WCHAR const *name,
char const *value);
static LONG recursive_delete_key(HKEY key);
static LONG recursive_delete_keyA(HKEY base, char const *name);
static LONG recursive_delete_keyW(HKEY base, WCHAR const *name);
/***********************************************************************
* register_interfaces
*/
static HRESULT register_interfaces(struct regsvr_interface const *list)
{
LONG res = ERROR_SUCCESS;
HKEY interface_key;
res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &interface_key, NULL);
if (res != ERROR_SUCCESS) goto error_return;
for (; res == ERROR_SUCCESS && list->iid; ++list) {
WCHAR buf[39];
HKEY iid_key;
StringFromGUID2(list->iid, buf, 39);
res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &iid_key, NULL);
if (res != ERROR_SUCCESS) goto error_close_interface_key;
if (list->name) {
res = RegSetValueExA(iid_key, NULL, 0, REG_SZ,
(CONST BYTE*)(list->name),
strlen(list->name) + 1);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
if (list->base_iid) {
register_key_guid(iid_key, base_ifa_keyname, list->base_iid);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
if (0 <= list->num_methods) {
static WCHAR const fmt[3] = { '%', 'd', 0 };
HKEY key;
res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &key, NULL);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
wsprintfW(buf, fmt, list->num_methods);
res = RegSetValueExW(key, NULL, 0, REG_SZ,
(CONST BYTE*)buf,
(lstrlenW(buf) + 1) * sizeof(WCHAR));
RegCloseKey(key);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
if (list->ps_clsid) {
register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
if (list->ps_clsid32) {
register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32);
if (res != ERROR_SUCCESS) goto error_close_iid_key;
}
error_close_iid_key:
RegCloseKey(iid_key);
}
error_close_interface_key:
RegCloseKey(interface_key);
error_return:
return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
}
/***********************************************************************
* unregister_interfaces
*/
static HRESULT unregister_interfaces(struct regsvr_interface const *list)
{
LONG res = ERROR_SUCCESS;
HKEY interface_key;
res = RegOpenKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0,
KEY_READ | KEY_WRITE, &interface_key);
if (res == ERROR_FILE_NOT_FOUND) return S_OK;
if (res != ERROR_SUCCESS) goto error_return;
for (; res == ERROR_SUCCESS && list->iid; ++list) {
WCHAR buf[39];
StringFromGUID2(list->iid, buf, 39);
res = recursive_delete_keyW(interface_key, buf);
}
RegCloseKey(interface_key);
error_return:
return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
}
/***********************************************************************
* register_coclasses
*/
static HRESULT register_coclasses(struct regsvr_coclass const *list)
{
LONG res = ERROR_SUCCESS;
HKEY coclass_key;
res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL);
if (res != ERROR_SUCCESS) goto error_return;
for (; res == ERROR_SUCCESS && list->clsid; ++list) {
WCHAR buf[39];
HKEY clsid_key;
StringFromGUID2(list->clsid, buf, 39);
res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
if (res != ERROR_SUCCESS) goto error_close_coclass_key;
if (list->name) {
res = RegSetValueExA(clsid_key, NULL, 0, REG_SZ,
(CONST BYTE*)(list->name),
strlen(list->name) + 1);
if (res != ERROR_SUCCESS) goto error_close_clsid_key;
}
if (list->ips) {
res = register_key_defvalueA(clsid_key, ips_keyname, list->ips);
if (res != ERROR_SUCCESS) goto error_close_clsid_key;
}
if (list->ips32) {
HKEY ips32_key;
res = RegCreateKeyExW(clsid_key, ips32_keyname, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL,
&ips32_key, NULL);
if (res != ERROR_SUCCESS) goto error_close_clsid_key;
res = RegSetValueExA(ips32_key, NULL, 0, REG_SZ,
(CONST BYTE*)list->ips32,
lstrlenA(list->ips32) + 1);
if (res == ERROR_SUCCESS && list->ips32_tmodel)
res = RegSetValueExA(ips32_key, tmodel_valuename, 0, REG_SZ,
(CONST BYTE*)list->ips32_tmodel,
strlen(list->ips32_tmodel) + 1);
RegCloseKey(ips32_key);
if (res != ERROR_SUCCESS) goto error_close_clsid_key;
}
if (list->clsid_str) {
res = register_key_defvalueA(clsid_key, clsid_keyname,
list->clsid_str);
if (res != ERROR_SUCCESS) goto error_close_clsid_key;
}
if (list->progid) {
HKEY progid_key;
res = register_key_defvalueA(clsid_key, progid_keyname,
list->progid);
if (res != ERROR_SUCCESS) goto error_close_clsid_key;
res = RegCreateKeyExA(HKEY_CLASSES_ROOT, list->progid, 0,
NULL, 0, KEY_READ | KEY_WRITE, NULL,
&progid_key, NULL);
if (res != ERROR_SUCCESS) goto error_close_clsid_key;
res = register_key_defvalueW(progid_key, clsid_keyname, buf);
RegCloseKey(progid_key);
if (res != ERROR_SUCCESS) goto error_close_clsid_key;
}
error_close_clsid_key:
RegCloseKey(clsid_key);
}
error_close_coclass_key:
RegCloseKey(coclass_key);
error_return:
return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
}
/***********************************************************************
* unregister_coclasses
*/
static HRESULT unregister_coclasses(struct regsvr_coclass const *list)
{
LONG res = ERROR_SUCCESS;
HKEY coclass_key;
res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0,
KEY_READ | KEY_WRITE, &coclass_key);
if (res == ERROR_FILE_NOT_FOUND) return S_OK;
if (res != ERROR_SUCCESS) goto error_return;
for (; res == ERROR_SUCCESS && list->clsid; ++list) {
WCHAR buf[39];
StringFromGUID2(list->clsid, buf, 39);
res = recursive_delete_keyW(coclass_key, buf);
if (res != ERROR_SUCCESS) goto error_close_coclass_key;
if (list->progid) {
res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->progid);
if (res != ERROR_SUCCESS) goto error_close_coclass_key;
}
}
error_close_coclass_key:
RegCloseKey(coclass_key);
error_return:
return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK;
}
/***********************************************************************
* regsvr_key_guid
*/
static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid)
{
WCHAR buf[39];
StringFromGUID2(guid, buf, 39);
return register_key_defvalueW(base, name, buf);
}
/***********************************************************************
* regsvr_key_defvalueW
*/
static LONG register_key_defvalueW(
HKEY base,
WCHAR const *name,
WCHAR const *value)
{
LONG res;
HKEY key;
res = RegCreateKeyExW(base, name, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &key, NULL);
if (res != ERROR_SUCCESS) return res;
res = RegSetValueExW(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
(lstrlenW(value) + 1) * sizeof(WCHAR));
RegCloseKey(key);
return res;
}
/***********************************************************************
* regsvr_key_defvalueA
*/
static LONG register_key_defvalueA(
HKEY base,
WCHAR const *name,
char const *value)
{
LONG res;
HKEY key;
res = RegCreateKeyExW(base, name, 0, NULL, 0,
KEY_READ | KEY_WRITE, NULL, &key, NULL);
if (res != ERROR_SUCCESS) return res;
res = RegSetValueExA(key, NULL, 0, REG_SZ, (CONST BYTE*)value,
lstrlenA(value) + 1);
RegCloseKey(key);
return res;
}
/***********************************************************************
* recursive_delete_key
*/
static LONG recursive_delete_key(HKEY key)
{
LONG res;
WCHAR subkey_name[MAX_PATH];
DWORD cName;
HKEY subkey;
for (;;) {
cName = sizeof(subkey_name) / sizeof(WCHAR);
res = RegEnumKeyExW(key, 0, subkey_name, &cName,
NULL, NULL, NULL, NULL);
if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) {
res = ERROR_SUCCESS; /* presumably we're done enumerating */
break;
}
res = RegOpenKeyExW(key, subkey_name, 0,
KEY_READ | KEY_WRITE, &subkey);
if (res == ERROR_FILE_NOT_FOUND) continue;
if (res != ERROR_SUCCESS) break;
res = recursive_delete_key(subkey);
RegCloseKey(subkey);
if (res != ERROR_SUCCESS) break;
}
if (res == ERROR_SUCCESS) res = RegDeleteKeyW(key, 0);
return res;
}
/***********************************************************************
* recursive_delete_keyA
*/
static LONG recursive_delete_keyA(HKEY base, char const *name)
{
LONG res;
HKEY key;
res = RegOpenKeyExA(base, name, 0, KEY_READ | KEY_WRITE, &key);
if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS;
if (res != ERROR_SUCCESS) return res;
res = recursive_delete_key(key);
RegCloseKey(key);
return res;
}
/***********************************************************************
* recursive_delete_keyW
*/
static LONG recursive_delete_keyW(HKEY base, WCHAR const *name)
{
LONG res;
HKEY key;
res = RegOpenKeyExW(base, name, 0, KEY_READ | KEY_WRITE, &key);
if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS;
if (res != ERROR_SUCCESS) return res;
res = recursive_delete_key(key);
RegCloseKey(key);
return res;
}
/***********************************************************************
* coclass list
*/
static struct regsvr_coclass const coclass_list[] = {
{ &CLSID_DirectDraw,
"DirectDraw Object",
NULL,
"ddraw.dll",
"Both"
},
{ &CLSID_DirectDrawClipper,
"DirectDraw Clipper Object",
NULL,
"ddraw.dll",
"Both"
},
{ NULL } /* list terminator */
};
/***********************************************************************
* interface list
*/
static struct regsvr_interface const interface_list[] = {
{ NULL } /* list terminator */
};
/***********************************************************************
* DllRegisterServer (DDRAW.@)
*/
HRESULT WINAPI DDRAW_DllRegisterServer()
{
HRESULT hr;
//TRACE("\n");
hr = register_coclasses(coclass_list);
if (SUCCEEDED(hr))
hr = register_interfaces(interface_list);
return hr;
}
/***********************************************************************
* DllUnregisterServer (DDRAW.@)
*/
HRESULT WINAPI DDRAW_DllUnregisterServer()
{
HRESULT hr;
//TRACE("\n");
hr = unregister_coclasses(coclass_list);
if (SUCCEEDED(hr))
hr = unregister_interfaces(interface_list);
return hr;
}

634
reactos/dll/directx/ddraw/rosdraw.h
View file

@ -5,13 +5,23 @@
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
#include <ddraw.h> #include <ddraw.h>
#include <ddrawi.h> #include <ddrawi.h>
#include <d3dhal.h> #include <d3dhal.h>
#include <ddrawgdi.h> #include <ddrawgdi.h>
/* DirectDraw startup code only internal use */ /* DirectDraw startup code only internal use */
HRESULT WINAPI StartDirectDraw(LPDIRECTDRAW* iface); extern DDRAWI_DIRECTDRAW_GBL ddgbl;
extern DDRAWI_DDRAWSURFACE_GBL ddSurfGbl;
HRESULT WINAPI StartDirectDraw(LPDIRECTDRAW* iface, LPGUID pGUID);
HRESULT WINAPI StartDirectDrawHal(LPDIRECTDRAW* iface); HRESULT WINAPI StartDirectDrawHal(LPDIRECTDRAW* iface);
HRESULT WINAPI StartDirectDrawHel(LPDIRECTDRAW* iface); HRESULT WINAPI StartDirectDrawHel(LPDIRECTDRAW* iface);
HRESULT WINAPI Create_DirectDraw (LPGUID pGUID, LPDIRECTDRAW* pIface, REFIID id, BOOL ex); HRESULT WINAPI Create_DirectDraw (LPGUID pGUID, LPDIRECTDRAW* pIface, REFIID id, BOOL ex);
@ -28,234 +38,478 @@ VOID Cleanup(LPDIRECTDRAW7 iface);
VOID WINAPI AcquireDDThreadLock(); VOID WINAPI AcquireDDThreadLock();
VOID WINAPI ReleaseDDThreadLock(); VOID WINAPI ReleaseDDThreadLock();
HRESULT WINAPI Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 iface, REFIID id, LPVOID *obj); HRESULT WINAPI Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 , REFIID , LPVOID *);
ULONG WINAPI Main_DirectDraw_AddRef (LPDIRECTDRAW7 iface); ULONG WINAPI Main_DirectDraw_AddRef(LPDIRECTDRAW7 );
ULONG WINAPI Main_DirectDraw_Release (LPDIRECTDRAW7 iface); ULONG WINAPI Main_DirectDraw_Release(LPDIRECTDRAW7 );
HRESULT WINAPI Main_DirectDraw_Compact (LPDIRECTDRAW7 iface); HRESULT WINAPI Main_DirectDraw_Compact(LPDIRECTDRAW7 );
HRESULT WINAPI Main_DirectDraw_CreateClipper(LPDIRECTDRAW7, DWORD, LPDIRECTDRAWCLIPPER *, IUnknown *);
HRESULT WINAPI Main_DirectDraw_CreatePalette(LPDIRECTDRAW7, DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE*, LPUNKNOWN);
HRESULT WINAPI Main_DirectDraw_CreateSurface(LPDIRECTDRAW7, LPDDSURFACEDESC2, LPDIRECTDRAWSURFACE7 *, IUnknown *);
HRESULT WINAPI Main_DirectDraw_DuplicateSurface(LPDIRECTDRAW7, LPDIRECTDRAWSURFACE7, LPDIRECTDRAWSURFACE7*);
HRESULT WINAPI Main_DirectDraw_GetDeviceIdentifier(LPDIRECTDRAW7, LPDDDEVICEIDENTIFIER2, DWORD);
HRESULT WINAPI Main_DirectDraw_CreateClipper (LPDIRECTDRAW7 iface, HRESULT WINAPI Main_DirectDraw_EnumSurfaces(LPDIRECTDRAW7, DWORD, LPDDSURFACEDESC2, LPVOID,
DWORD dwFlags, LPDDENUMSURFACESCALLBACK7);
LPDIRECTDRAWCLIPPER *ppClipper,
IUnknown *pUnkOuter);
HRESULT WINAPI Main_DirectDraw_CreatePalette (LPDIRECTDRAW7 iface, HRESULT WINAPI Main_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7);
DWORD dwFlags, HRESULT WINAPI Main_DirectDraw_GetDisplayMode(LPDIRECTDRAW7, LPDDSURFACEDESC2);
LPPALETTEENTRY palent, HRESULT WINAPI Main_DirectDraw_GetSurfaceFromDC(LPDIRECTDRAW7, HDC, LPDIRECTDRAWSURFACE7 *);
LPDIRECTDRAWPALETTE* ppPalette, HRESULT WINAPI Main_DirectDraw_GetCaps(LPDIRECTDRAW7, LPDDCAPS pDriverCaps, LPDDCAPS);
LPUNKNOWN pUnkOuter); HRESULT WINAPI Main_DirectDraw_GetFourCCCodes(LPDIRECTDRAW7, LPDWORD pNumCodes, LPDWORD);
HRESULT WINAPI Main_DirectDraw_GetGDISurface(LPDIRECTDRAW7, LPDIRECTDRAWSURFACE7 *);
HRESULT WINAPI Main_DirectDraw_WaitForVerticalBlank(LPDIRECTDRAW7, DWORD dwFlags, HANDLE);
HRESULT WINAPI Main_DirectDraw_GetMonitorFrequency(LPDIRECTDRAW7, LPDWORD);
HRESULT WINAPI Main_DirectDraw_GetScanLine(LPDIRECTDRAW7, LPDWORD);
HRESULT WINAPI Main_DirectDraw_GetVerticalBlankStatus(LPDIRECTDRAW7, LPBOOL);
HRESULT WINAPI Main_DirectDraw_RestoreDisplayMode(LPDIRECTDRAW7);
HRESULT WINAPI Main_DirectDraw_SetCooperativeLevel (LPDIRECTDRAW7, HWND, DWORD);
HRESULT WINAPI Main_DirectDraw_SetDisplayMode (LPDIRECTDRAW7, DWORD, DWORD, DWORD, DWORD, DWORD);
HRESULT WINAPI Main_DirectDraw_RestoreAllSurfaces(LPDIRECTDRAW7 iface);
HRESULT WINAPI Main_DirectDraw_TestCooperativeLevel(LPDIRECTDRAW7 iface);
typedef struct ULONG WINAPI Main_DDrawSurface_AddRef(LPDIRECTDRAWSURFACE7);
{ ULONG WINAPI Main_DDrawSurface_Release(LPDIRECTDRAWSURFACE7);
/* Setup the Vtbl COM table */ HRESULT WINAPI Main_DDrawSurface_QueryInterface(LPDIRECTDRAWSURFACE7, REFIID, LPVOID*);
IDirectDraw7Vtbl* lpVtbl; HRESULT WINAPI Main_DDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7, HDC);
IDirectDraw4Vtbl* lpVtbl_v4; HRESULT WINAPI Main_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7, LPRECT, LPDIRECTDRAWSURFACE7, LPRECT, DWORD, LPDDBLTFX);
IDirectDraw2Vtbl* lpVtbl_v2; HRESULT WINAPI Main_DDrawSurface_BltBatch(LPDIRECTDRAWSURFACE7, LPDDBLTBATCH, DWORD, DWORD);
IDirectDrawVtbl* lpVtbl_v1; HRESULT WINAPI Main_DDrawSurface_BltFast(LPDIRECTDRAWSURFACE7, DWORD, DWORD, LPDIRECTDRAWSURFACE7, LPRECT, DWORD);
HRESULT WINAPI Main_DDrawSurface_DeleteAttachedSurface(LPDIRECTDRAWSURFACE7, DWORD, LPDIRECTDRAWSURFACE7);
ULONG Ref; HRESULT WINAPI Main_DDrawSurface_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE7, LPVOID, LPDDENUMSURFACESCALLBACK7);
HRESULT WINAPI Main_DDrawSurface_EnumOverlayZOrders(LPDIRECTDRAWSURFACE7, DWORD, LPVOID,LPDDENUMSURFACESCALLBACK7);
/* The main struct that contain all info from the HAL and HEL */ HRESULT WINAPI Main_DDrawSurface_Flip(LPDIRECTDRAWSURFACE7 , LPDIRECTDRAWSURFACE7, DWORD);
HDC hdc; HRESULT WINAPI Main_DDrawSurface_FreePrivateData(LPDIRECTDRAWSURFACE7, REFGUID);
DDRAWI_DIRECTDRAW_GBL mDDrawGlobal; HRESULT WINAPI Main_DDrawSurface_GetAttachedSurface(LPDIRECTDRAWSURFACE7, LPDDSCAPS2, LPDIRECTDRAWSURFACE7*);
DDRAWI_DIRECTDRAW_LCL mDDrawLocal; HRESULT WINAPI Main_DDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7, DWORD dwFlags);
DDHALINFO mHALInfo; HRESULT WINAPI Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7, LPDDSCAPS2 pCaps);
HRESULT WINAPI Main_DDrawSurface_GetClipper(LPDIRECTDRAWSURFACE7, LPDIRECTDRAWCLIPPER*);
DDHAL_CALLBACKS mCallbacks; HRESULT WINAPI Main_DDrawSurface_GetColorKey(LPDIRECTDRAWSURFACE7, DWORD, LPDDCOLORKEY);
DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks; HRESULT WINAPI Main_DDrawSurface_GetDC(LPDIRECTDRAWSURFACE7, HDC *);
D3DHAL_CALLBACKS mD3dCallbacks; HRESULT WINAPI Main_DDrawSurface_GetDDInterface(LPDIRECTDRAWSURFACE7, LPVOID*);
D3DHAL_GLOBALDRIVERDATA mD3dDriverData; HRESULT WINAPI Main_DDrawSurface_GetFlipStatus(LPDIRECTDRAWSURFACE7, DWORD);
HRESULT WINAPI Main_DDrawSurface_GetLOD(LPDIRECTDRAWSURFACE7, LPDWORD);
UINT mcModeInfos; HRESULT WINAPI Main_DDrawSurface_GetOverlayPosition(LPDIRECTDRAWSURFACE7, LPLONG, LPLONG);
DDHALMODEINFO *mpModeInfos; HRESULT WINAPI Main_DDrawSurface_GetPalette(LPDIRECTDRAWSURFACE7, LPDIRECTDRAWPALETTE*);
HRESULT WINAPI Main_DDrawSurface_GetPixelFormat(LPDIRECTDRAWSURFACE7, LPDDPIXELFORMAT);
UINT mcvmList; HRESULT WINAPI Main_DDrawSurface_GetPriority(LPDIRECTDRAWSURFACE7, LPDWORD);
VIDMEM *mpvmList; HRESULT WINAPI Main_DDrawSurface_GetPrivateData(LPDIRECTDRAWSURFACE7, REFGUID, LPVOID, LPDWORD);
HRESULT WINAPI Main_DDrawSurface_GetSurfaceDesc(LPDIRECTDRAWSURFACE7, LPDDSURFACEDESC2);
UINT mcFourCC; HRESULT WINAPI Main_DDrawSurface_GetUniquenessValue(LPDIRECTDRAWSURFACE7, LPDWORD);
DWORD *mpFourCC; HRESULT WINAPI Main_DDrawSurface_IsLost(LPDIRECTDRAWSURFACE7);
HRESULT WINAPI Main_DDrawSurface_PageLock(LPDIRECTDRAWSURFACE7, DWORD);
UINT mcTextures; HRESULT WINAPI Main_DDrawSurface_PageUnlock(LPDIRECTDRAWSURFACE7, DWORD);
DDSURFACEDESC *mpTextures; HRESULT WINAPI Main_DDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7, HDC);
HRESULT WINAPI Main_DDrawSurface_SetClipper (LPDIRECTDRAWSURFACE7, LPDIRECTDRAWCLIPPER);
HRESULT WINAPI Main_DDrawSurface_SetColorKey (LPDIRECTDRAWSURFACE7, DWORD, LPDDCOLORKEY);
HRESULT WINAPI Main_DDrawSurface_SetOverlayPosition (LPDIRECTDRAWSURFACE7, LONG, LONG);
HRESULT WINAPI Main_DDrawSurface_SetPalette (LPDIRECTDRAWSURFACE7, LPDIRECTDRAWPALETTE);
HRESULT WINAPI Main_DDrawSurface_SetPriority (LPDIRECTDRAWSURFACE7, DWORD);
HRESULT WINAPI Main_DDrawSurface_SetPrivateData (LPDIRECTDRAWSURFACE7, REFGUID, LPVOID, DWORD, DWORD);
HRESULT WINAPI Main_DDrawSurface_UpdateOverlayDisplay (LPDIRECTDRAWSURFACE7, DWORD);
HRESULT WINAPI Main_DDrawSurface_UpdateOverlayZOrder (LPDIRECTDRAWSURFACE7, DWORD, LPDIRECTDRAWSURFACE7);
HRESULT WINAPI Main_DDrawSurface_SetSurfaceDesc(LPDIRECTDRAWSURFACE7, DDSURFACEDESC2 *, DWORD);
HRESULT WINAPI Main_DDrawSurface_SetLOD(LPDIRECTDRAWSURFACE7, DWORD);
HRESULT WINAPI Main_DDrawSurface_Unlock (LPDIRECTDRAWSURFACE7, LPRECT);
HRESULT WINAPI Main_DDrawSurface_Initialize (LPDIRECTDRAWSURFACE7, LPDIRECTDRAW, LPDDSURFACEDESC2);
HRESULT WINAPI Main_DDrawSurface_Lock (LPDIRECTDRAWSURFACE7, LPRECT, LPDDSURFACEDESC2, DWORD, HANDLE);
HRESULT WINAPI Main_DDrawSurface_Restore(LPDIRECTDRAWSURFACE7);
HRESULT WINAPI Main_DDrawSurface_UpdateOverlay (LPDIRECTDRAWSURFACE7, LPRECT, LPDIRECTDRAWSURFACE7, LPRECT,
DWORD, LPDDOVERLAYFX);
/* ExclusiveOwner */ ULONG WINAPI DirectDrawClipper_AddRef (LPDIRECTDRAWCLIPPER iface);
HRESULT WINAPI DirectDrawClipper_Initialize( LPDIRECTDRAWCLIPPER iface, LPDIRECTDRAW lpDD, DWORD dwFlags);
DWORD cooperative_level;
BOOL InitializeDraw;
/* HEL stuff */ /* DirectDraw Object struct
DWORD HELMemoryAvilable;
/* DD Callbacks info */ DDRAWI_DIRECTDRAW_INT
DDHAL_DESTROYDRIVERDATA mDdDestroyDriver; it is the the return pointer from ddraw.dll to the program
DDHAL_CREATESURFACEDATA mDdCreateSurface;
DDHAL_SETCOLORKEYDATA mDdSetColorKey;
DDHAL_SETMODEDATA mDdSetMode;
DDHAL_WAITFORVERTICALBLANKDATA mDdWaitForVerticalBlank;
DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface;
DDHAL_CREATEPALETTEDATA mDdCreatePalette;
DDHAL_GETSCANLINEDATA mDdGetScanLine;
DDHAL_SETEXCLUSIVEMODEDATA mDdSetExclusiveMode;
DDHAL_FLIPTOGDISURFACEDATA mDdFlipToGDISurface;
DDRAWI_DDRAWSURFACE_GBL mPrimaryGlobal;
/* adding a switch */
DWORD devicetype;
} IDirectDrawImpl;
/******** Surface Object ********/
typedef struct
{
/* Primarey surface we must reach it from every where */
DDRAWI_DDRAWSURFACE_MORE mPrimaryMore; DDRAWI_DIRECTDRAW_LCL
DDRAWI_DDRAWSURFACE_LCL mPrimaryLocal; It is the program own private data
DDRAWI_DDRAWSURFACE_LCL *mpPrimaryLocals[1];
DDRAWI_DDRAWCLIPPER_LCL mPrimaryClipperLocal;
DDRAWI_DDRAWCLIPPER_GBL mPrimaryClipperGlobal;
DDSURFACEDESC2 mddsdPrimary; DDRAWI_DIRECTDRAW_GBL
This struct is gboal for whole ddraw.dll for all program
DDRAWI_DDRAWSURFACE_LCL *mpInUseSurfaceLocals[1]; it is static in ddraw if it change it change for all
program
/*
AttachList We need getting surface pointer
of already create surface that have some private
data msdn ATTACHLIST can not provide all info
we need with our desgin therfor we are using
wine desgin for it
type IDirectDrawSurfaceImpl;
*/
DWORD* next_attached;
DWORD* first_attached;
DWORD* next_complex;
DWORD* first_complex;
DWORD* next;
DWORD* prev;
/* Need be delete later */
DDRAWI_DDRAWSURFACE_GBL mSurfGlobal;
DDRAWI_DDRAWSURFACE_MORE mSurfMore;
DDRAWI_DDRAWSURFACE_LCL mSurfLocal;
DDRAWI_DDRAWSURFACE_LCL *mpSurfLocals[1];
DDRAWI_DDRAWCLIPPER_LCL mSurfClipperLocal;
DDRAWI_DDRAWCLIPPER_GBL mSurfClipperGlobal;
DDRAWI_DDRAWSURFACE_GBL mOverlayGlobal;
DDRAWI_DDRAWSURFACE_LCL mOverlayLocal[6];
DDRAWI_DDRAWSURFACE_LCL *mpOverlayLocals[6];
DDRAWI_DDRAWSURFACE_MORE mOverlayMore[6];
DDSURFACEDESC mddsdOverlay;
} DxSurf;
typedef struct
{
IDirectDrawSurface7Vtbl* lpVtbl;
IDirectDrawSurface3Vtbl* lpVtbl_v3;
IDirectDrawImpl* Owner; The struct
DDRAWI_DDRAWSURFACE_GBL Global; from http://msdn2.microsoft.com/en-us/library/ms898267.aspx
DDRAWI_DDRAWSURFACE_MORE More; it was not document for windows 2000/xp/2003 but ms did document it
DDRAWI_DDRAWSURFACE_LCL Local; for windows ce 5.0 the link are to windows ce 5.0 arch
DDRAWI_DDRAWSURFACE_LCL *pLocal[2];
DDSURFACEDESC ddsd;
DxSurf *Surf; typedef struct _DDRAWI_DIRECTDRAW_INT {
LPVOID lpVtbl;
LPDDRAWI_DIRECTDRAW_LCL lpLcl;
LPDDRAWI_DIRECTDRAW_INT lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DIRECTDRAW_INT;
} IDirectDrawSurfaceImpl; rest of the struct are from msdn for windows 2000/xp/2003
typedef struct _DDRAWI_DIRECTDRAW_LCL {
DWORD lpDDMore;
LPDDRAWI_DIRECTDRAW_GBL lpGbl; // fill it from function Create_DirectDraw with static pointer ddgbl
DWORD dwUnused0;
DWORD dwLocalFlags;
DWORD dwLocalRefCnt;
DWORD dwProcessId;
IUnknown FAR *pUnkOuter;
DWORD dwObsolete1;
ULONG_PTR hWnd;
ULONG_PTR hDC; // create HDC and save it to this pointer
DWORD dwErrorMode;
LPDDRAWI_DDRAWSURFACE_INT lpPrimary;
LPDDRAWI_DDRAWSURFACE_INT lpCB;
DWORD dwPreferredMode;
HINSTANCE hD3DInstance;
IUnknown FAR *pD3DIUnknown;
LPDDHAL_CALLBACKS lpDDCB; // same memory pointer as DDRAWI_DIRECTDRAW_GBL->lpDDCBtmp, setup by function StartDirectDraw
ULONG_PTR hDDVxd;
DWORD dwAppHackFlags;
ULONG_PTR hFocusWnd;
DWORD dwHotTracking;
DWORD dwIMEState;
ULONG_PTR hWndPopup;
ULONG_PTR hDD;
ULONG_PTR hGammaCalibrator;
LPDDGAMMACALIBRATORPROC lpGammaCalibrator;
} DDRAWI_DIRECTDRAW_LCL;
typedef struct _DDRAWI_DIRECTDRAW_GBL {
DWORD dwRefCnt;
DWORD dwFlags;
FLATPTR fpPrimaryOrig;
DDCORECAPS ddCaps;
DWORD dwInternal1;
DWORD dwUnused1[9];
LPDDHAL_CALLBACKS lpDDCBtmp;
LPDDRAWI_DDRAWSURFACE_INT dsList;
LPDDRAWI_DDRAWPALETTE_INT palList;
LPDDRAWI_DDRAWCLIPPER_INT clipperList;
LPDDRAWI_DIRECTDRAW_GBL lp16DD; // pointer to it self (DDRAWI_DIRECTDRAW_GBL)
DWORD dwMaxOverlays;
DWORD dwCurrOverlays;
DWORD dwMonitorFrequency;
DDCORECAPS ddHELCaps;
DWORD dwUnused2[50];
DDCOLORKEY ddckCKDestOverlay;
DDCOLORKEY ddckCKSrcOverlay;
VIDMEMINFO vmiData;
LPVOID lpDriverHandle;
LPDDRAWI_DIRECTDRAW_LCL lpExclusiveOwner;
DWORD dwModeIndex;
DWORD dwModeIndexOrig;
DWORD dwNumFourCC;
DWORD FAR *lpdwFourCC;
DWORD dwNumModes;
LPDDHALMODEINFO lpModeInfo;
PROCESS_LIST plProcessList;
DWORD dwSurfaceLockCount;
DWORD dwAliasedLockCnt;
ULONG_PTR dwReserved3;
ULONG_PTR hDD; // GdiEntry1 are filling this pointer
char cObsolete[12];
DWORD dwReserved1;
DWORD dwReserved2;
DBLNODE dbnOverlayRoot;
volatile LPWORD lpwPDeviceFlags;
DWORD dwPDevice;
DWORD dwWin16LockCnt;
DWORD dwUnused3;
DWORD hInstance;
DWORD dwEvent16;
DWORD dwSaveNumModes;
ULONG_PTR lpD3DGlobalDriverData;
ULONG_PTR lpD3DHALCallbacks;
DDCORECAPS ddBothCaps;
LPDDVIDEOPORTCAPS lpDDVideoPortCaps;
LPDDRAWI_DDVIDEOPORT_INT dvpList;
ULONG_PTR lpD3DHALCallbacks2;
RECT rectDevice;
DWORD cMonitors;
LPVOID gpbmiSrc;
LPVOID gpbmiDest;
LPHEAPALIASINFO phaiHeapAliases;
ULONG_PTR hKernelHandle;
ULONG_PTR pfnNotifyProc;
LPDDKERNELCAPS lpDDKernelCaps;
LPDDNONLOCALVIDMEMCAPS lpddNLVCaps;
LPDDNONLOCALVIDMEMCAPS lpddNLVHELCaps;
LPDDNONLOCALVIDMEMCAPS lpddNLVBothCaps;
ULONG_PTR lpD3DExtendedCaps;
DWORD dwDOSBoxEvent;
RECT rectDesktop;
char cDriverName[MAX_DRIVER_NAME];
ULONG_PTR lpD3DHALCallbacks3;
DWORD dwNumZPixelFormats;
LPDDPIXELFORMAT lpZPixelFormats;
LPDDRAWI_DDMOTIONCOMP_INT mcList;
DWORD hDDVxd;
DDSCAPSEX ddsCapsMore;
} DDRAWI_DIRECTDRAW_GBL;
*/
/* Clipper Object struct
DDRAWI_DDRAWCLIPPER_INT
it is the the return pointer from ddraw.dll to the program
DDRAWI_DDRAWCLIPPER_LCL
It is the program own private data
DDRAWI_DDRAWCLIPPER_GBL
This struct is gboal for whole ddraw.dll for all program
it is static in ddraw if it change it change for all
program
The struct
typedef struct _DDRAWI_DDRAWCLIPPER_INT {
LPVOID lpVtbl;
LPDDRAWI_DDRAWCLIPPER_LCL lpLcl;
LPDDRAWI_DDRAWCLIPPER_INT lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DDRAWCLIPPER_INT;
typedef struct _DDRAWI_DDRAWCLIPPER_LCL {
DWORD lpClipMore;
LPDDRAWI_DDRAWCLIPPER_GBL lpGbl;
LPDDRAWI_DIRECTDRAW_LCL lpDD_lcl;
DWORD dwLocalRefCnt;
IUnknown FAR *pUnkOuter;
LPDDRAWI_DIRECTDRAW_INT lpDD_int;
ULONG_PTR dwReserved1;
IUnknown *pAddrefedThisOwner;
} DDRAWI_DDRAWCLIPPER_LCL;
typedef struct _DDRAWI_DDRAWCLIPPER_GBL {
DWORD dwRefCnt;
DWORD dwFlags;
LPDDRAWI_DIRECTDRAW_GBL lpDD;
DWORD dwProcessId;
ULONG_PTR dwReserved1;
ULONG_PTR hWnd;
LPRGNDATA lpStaticClipList;
} DDRAWI_DDRAWCLIPPER_GBL;
*/
/*
typedef struct _DDRAWI_DDRAWPALETTE_INT {
LPVOID lpVtbl;
LPDDRAWI_DDRAWPALETTE_LCL lpLcl;
LPDDRAWI_DDRAWPALETTE_INT lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DDRAWPALETTE_INT;
typedef struct _DDRAWI_DDRAWPALETTE_LCL {
DWORD lpPalMore;
LPDDRAWI_DDRAWPALETTE_GBL lpGbl;
ULONG_PTR dwUnused0;
DWORD dwLocalRefCnt;
IUnknown FAR *pUnkOuter;
LPDDRAWI_DIRECTDRAW_LCL lpDD_lcl;
ULONG_PTR dwReserved1;
ULONG_PTR dwDDRAWReserved1;
ULONG_PTR dwDDRAWReserved2;
ULONG_PTR dwDDRAWReserved3;
} DDRAWI_DDRAWPALETTE_LCL;
typedef struct _DDRAWI_DDRAWPALETTE_GBL {
DWORD dwRefCnt;
DWORD dwFlags;
LPDDRAWI_DIRECTDRAW_LCL lpDD_lcl;
DWORD dwProcessId;
LPPALETTEENTRY lpColorTable;
union {
ULONG_PTR dwReserved1;
HPALETTE hHELGDIPalette;
};
DWORD dwDriverReserved;
DWORD dwContentsStamp;
DWORD dwSaveStamp;
DWORD dwHandle;
} DDRAWI_DDRAWPALETTE_GBL;
*/
/*
typedef struct _DDRAWI_DDVIDEOPORT_INT {
LPVOID lpVtbl;
LPDDRAWI_DDVIDEOPORT_LCL lpLcl;
LPDDRAWI_DDVIDEOPORT_INT lpLink;
DWORD dwIntRefCnt;
DWORD dwFlags;
} DDRAWI_DDVIDEOPORT_INT;
typedef struct _DDRAWI_DDVIDEOPORT_LCL {
LPDDRAWI_DIRECTDRAW_LCL lpDD;
DDVIDEOPORTDESC ddvpDesc;
DDVIDEOPORTINFO ddvpInfo;
LPDDRAWI_DDRAWSURFACE_INT lpSurface;
LPDDRAWI_DDRAWSURFACE_INT lpVBISurface;
LPDDRAWI_DDRAWSURFACE_INT *lpFlipInts;
DWORD dwNumAutoflip;
DWORD dwProcessID;
DWORD dwStateFlags;
DWORD dwFlags;
DWORD dwRefCnt;
FLATPTR fpLastFlip;
ULONG_PTR dwReserved1;
ULONG_PTR dwReserved2;
HANDLE hDDVideoPort;
DWORD dwNumVBIAutoflip;
LPDDVIDEOPORTDESC lpVBIDesc;
LPDDVIDEOPORTDESC lpVideoDesc;
LPDDVIDEOPORTINFO lpVBIInfo;
LPDDVIDEOPORTINFO lpVideoInfo;
DWORD dwVBIProcessID;
} DDRAWI_DDVIDEOPORT_LCL;
/******** Clipper Object ********/ Surface
typedef struct _DDRAWI_DDRAWSURFACE_GBL {
DWORD dwRefCnt;
DWORD dwGlobalFlags;
union {
LPACCESSRECTLIST lpRectList;
DWORD dwBlockSizeY;
};
union {
LPVMEMHEAP lpVidMemHeap;
DWORD dwBlockSizeX;
};
union {
LPDDRAWI_DIRECTDRAW_GBL lpDD;
LPVOID lpDDHandle;
};
FLATPTR fpVidMem;
union {
LONG lPitch;
DWORD dwLinearSize;
};
WORD wHeight;
WORD wWidth;
DWORD dwUsageCount;
ULONG_PTR dwReserved1;
DDPIXELFORMAT ddpfSurface;
} DDRAWI_DDRAWSURFACE_GBL;
typedef struct */
/* This comment info maybe is wrong
bare in mind I am using logic thinking
for follow info does not exists in MSDN
so I am drawing clude how previews stuffs
works that are document in MSDN/DDK
follow struct should exists ???
DDRAWI_DDVIDEOPORT_GBL
DDRAWI_DDGAMMACONTROL_INT
DDRAWI_DDGAMMACONTROL_LCL
DDRAWI_DDGAMMACONTROL_GBL
DDRAWI_DDCOLORCONTROL_INT
DDRAWI_DDCOLORCONTROL_LCL
DDRAWI_DDCOLORCONTROL_GBL
DDRAWI_KERNEL_INT
DDRAWI_KERNEL_LCL
DDRAWI_KERNEL_GBL
DDRAWI_DDKERNELSURFACE_INT
DDRAWI_DDKERNELSURFACE_LCL
DDRAWI_DDKERNELSURFACE_GBL
follow struct can be easy create
DDRAWI_DDGAMMACONTROL_INT
DDRAWI_DDCOLORCONTROL_INT
DDRAWI_KERNEL_INT
the DDRAWI_DDGAMMACONTROL_INT should looking like this
typedef struct _DDRAWI_DDGAMMACONTROL_INT
{ {
IDirectDrawClipperVtbl* lpVtbl; LPVOID lpVtbl;
LONG ref; LPDDRAWI_DDGAMMACONTROL_LCL lpLcl;
LPDDRAWI_DDGAMMACONTROL_INT lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DDGAMMACONTROL_INT, *LPDDRAWI_DDGAMMACONTROL_INT
IDirectDrawImpl* owner; how did I got this struct I looked at all other INT struct how they where
build. But it is not 100% sure this one is right untill I/we known how
} IDirectDrawClipperImpl; the DDRAWI_DDGAMMACONTROL_LCL works and DDRAWI_DDCOLORCONTROL_GBL
our internal struct will look like this
/******** Palette Object ********/ typedef struct _DDRAWI_DDGAMMACONTROL_INT
typedef struct
{ {
IDirectDrawPaletteVtbl* lpVtbl; LPVOID lpVtbl;
LPVOID lpLcl;
IDirectDrawImpl* owner; LPVOID lpLink;
DDRAWI_DDRAWPALETTE_GBL DDPalette; DWORD dwIntRefCnt;
} IDirectDrawPaletteImpl; } DDRAWI_DDGAMMACONTROL_INT, *LPDDRAWI_DDGAMMACONTROL_INT
/******** Gamma Object ********/ same goes for DDRAWI_DDCOLORCONTROL_INT
typedef struct typedef struct DDRAWI_DDCOLORCONTROL_INT
{ {
IDirectDrawGammaControlVtbl* lpVtbl; LPVOID lpVtbl;
LONG ref; LPVOID lpLcl;
IDirectDrawImpl* Owner; LPVOID lpLink;
IDirectDrawSurfaceImpl* Surf; DWORD dwIntRefCnt;
} DDRAWI_DDCOLORCONTROL_INT, *LPDDRAWI_DDCOLORCONTROL_INT
*/
typedef struct DDRAWI_DDCOLORCONTROL_INT
} IDirectDrawGammaImpl;
/******** Color Object ********/
typedef struct
{ {
IDirectDrawColorControlVtbl* lpVtbl; LPVOID lpVtbl;
LONG ref; LPVOID lpLcl;
IDirectDrawImpl* Owner; LPVOID lpLink;
IDirectDrawSurfaceImpl* Surf; DWORD dwIntRefCnt;
} DDRAWI_DDCOLORCONTROL_INT, *LPDDRAWI_DDCOLORCONTROL_INT;
} IDirectDrawColorImpl; typedef struct _DDRAWI_DDGAMMACONTROL_INT
/******** Kernel Object ********/
typedef struct
{ {
IDirectDrawKernelVtbl* lpVtbl; LPVOID lpVtbl;
LONG ref; LPVOID lpLcl;
IDirectDrawImpl* Owner; LPVOID lpLink;
IDirectDrawSurfaceImpl* Surf; DWORD dwIntRefCnt;
} DDRAWI_DDGAMMACONTROL_INT, *LPDDRAWI_DDGAMMACONTROL_INT;
} IDirectDrawKernelImpl; typedef struct _DDRAWI_DDKERNEL_INT
/******** SurfaceKernel Object ********/
typedef struct
{ {
IDirectDrawSurfaceKernelVtbl* lpVtbl; LPVOID lpVtbl;
LONG ref; LPVOID lpLcl;
IDirectDrawImpl* Owner; LPVOID lpLink;
IDirectDrawSurfaceImpl* Surf; DWORD dwIntRefCnt;
IDirectDrawKernelImpl * Kernl; } DDRAWI_KERNEL_INT, *LPDDRAWI_KERNEL_INT;
typedef struct _DDRAWI_DDKERNELSURFACE_INT
{
LPVOID lpVtbl;
LPVOID lpLcl;
LPVOID lpLink;
DWORD dwIntRefCnt;
} _DDRAWI_DDKERNELSURFACE_INT, *LPDDRAWI_DDKERNELSURFACE_INT;
/* now to real info that are for private use and are our own */
} IDirectDrawSurfaceKernelImpl;
/*********** VTables ************/ /*********** VTables ************/
extern IDirectDrawVtbl DirectDraw_Vtable;
extern IDirectDraw2Vtbl DirectDraw2_Vtable;
extern IDirectDraw4Vtbl DirectDraw4_Vtable;
extern IDirectDraw7Vtbl DirectDraw7_Vtable; extern IDirectDraw7Vtbl DirectDraw7_Vtable;
extern IDirectDrawVtbl DDRAW_IDirectDraw_VTable;
extern IDirectDraw2Vtbl DDRAW_IDirectDraw2_VTable;
extern IDirectDraw4Vtbl DDRAW_IDirectDraw4_VTable;
extern IDirectDrawSurface7Vtbl DirectDrawSurface7_Vtable; extern IDirectDrawSurface7Vtbl DirectDrawSurface7_Vtable;
extern IDirectDrawSurface3Vtbl DDRAW_IDDS3_Thunk_VTable; extern IDirectDrawSurface3Vtbl DirectDrawSurface3_VTable;
extern IDirectDrawPaletteVtbl DirectDrawPalette_Vtable; extern IDirectDrawPaletteVtbl DirectDrawPalette_Vtable;
extern IDirectDrawClipperVtbl DirectDrawClipper_Vtable; extern IDirectDrawClipperVtbl DirectDrawClipper_Vtable;
@ -265,6 +519,12 @@ extern IDirectDrawKernelVtbl DirectDrawKernel_Vtable;
extern IDirectDrawSurfaceKernelVtbl DirectDrawSurfaceKernel_Vtable; extern IDirectDrawSurfaceKernelVtbl DirectDrawSurfaceKernel_Vtable;
/********* Prototypes **********/ /********* Prototypes **********/
HRESULT WINAPI Main_DDrawSurface_AddAttachedSurface(LPDIRECTDRAWSURFACE7 iface, LPDIRECTDRAWSURFACE7 pAttach);
HRESULT WINAPI Main_DDrawSurface_AddOverlayDirtyRect(LPDIRECTDRAWSURFACE7 iface, LPRECT pRect);
HRESULT WINAPI Main_DDrawSurface_GetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface, LPDDSURFACEDESC2 pDDSD);
HRESULT WINAPI Main_DirectDraw_EnumDisplayModes(LPDIRECTDRAW7 iface, DWORD dwFlags, LPDDSURFACEDESC2 pDDSD, LPVOID context, LPDDENUMMODESCALLBACK2 callback);
HRESULT WINAPI Main_DDrawSurface_SetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface, DDSURFACEDESC2 *DDSD, DWORD Flags);
HRESULT WINAPI Main_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 ddscaps, LPDWORD total, LPDWORD free); HRESULT WINAPI Main_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 ddscaps, LPDWORD total, LPDWORD free);

59
reactos/dll/directx/ddraw/soft/surface_hel.c
View file

@ -1,59 +0,0 @@
/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/soft/surface.c
* PURPOSE: DirectDraw Software Implementation
* PROGRAMMER: Magnus Olsen, Maarten Bosma
*
*/
#include "../rosdraw.h"
HRESULT Hel_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst,
LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
{
DX_STUB;
}
HRESULT Hel_DDrawSurface_Lock(LPDIRECTDRAWSURFACE7 iface, LPRECT prect, LPDDSURFACEDESC2
pDDSD, DWORD flags, HANDLE event)
{
DX_STUB;
}
HRESULT Hel_DDrawSurface_Unlock(LPDIRECTDRAWSURFACE7 iface, LPRECT pRect)
{
DX_STUB;
}
HRESULT Hel_DDrawSurface_Flip(LPDIRECTDRAWSURFACE7 iface, LPDIRECTDRAWSURFACE7 override, DWORD dwFlags)
{
DX_STUB;
}
HRESULT Hel_DDrawSurface_SetColorKey (LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags, LPDDCOLORKEY pCKey)
{
DX_STUB;
}
HRESULT Hel_DDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
{
DX_STUB;
}
HRESULT Hel_DDrawSurface_UpdateOverlayDisplay (LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
{
DX_STUB;
}

512
reactos/dll/directx/ddraw/startup.c
View file

@ -12,11 +12,14 @@
#include "rosdraw.h" #include "rosdraw.h"
#include "d3dhal.h" #include "d3dhal.h"
DDRAWI_DIRECTDRAW_GBL ddgbl;
DDRAWI_DDRAWSURFACE_GBL ddSurfGbl;
HRESULT WINAPI HRESULT WINAPI
StartDirectDraw(LPDIRECTDRAW* iface) StartDirectDraw(LPDIRECTDRAW* iface, LPGUID lpGuid)
{ {
IDirectDrawImpl* This = (IDirectDrawImpl*)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DWORD hal_ret; DWORD hal_ret;
DWORD hel_ret; DWORD hel_ret;
DEVMODE devmode; DEVMODE devmode;
@ -24,22 +27,27 @@ StartDirectDraw(LPDIRECTDRAW* iface)
const UINT bmiSize = sizeof(BITMAPINFOHEADER) + 0x10; const UINT bmiSize = sizeof(BITMAPINFOHEADER) + 0x10;
UCHAR *pbmiData; UCHAR *pbmiData;
BITMAPINFO *pbmi; BITMAPINFO *pbmi;
DWORD *pMasks; DWORD *pMasks;
DWORD Flags; INT devicetypes = 0;
DX_WINDBG_trace(); DX_WINDBG_trace();
RtlZeroMemory(&This->mDDrawGlobal, sizeof(DDRAWI_DIRECTDRAW_GBL)); RtlZeroMemory(&ddgbl, sizeof(DDRAWI_DIRECTDRAW_GBL));
ddgbl.lpDDCBtmp = (LPDDHAL_CALLBACKS) DxHeapMemAlloc(sizeof(DDHAL_CALLBACKS));
if (ddgbl.lpDDCBtmp == NULL)
{
DX_STUB_str("Out of memmory");
return DD_FALSE;
}
This->lpLcl->lpDDCB = ddgbl.lpDDCBtmp;
/* cObsolete is undoc in msdn it being use in CreateDCA */
RtlCopyMemory(&This->mDDrawGlobal.cObsolete,&"DISPLAY",7);
RtlCopyMemory(&This->mDDrawGlobal.cDriverName,&"DISPLAY",7);
/* Same for HEL and HAL */ /* Same for HEL and HAL */
This->mcModeInfos = 1; This->lpLcl->lpGbl->lpModeInfo = (DDHALMODEINFO*) DxHeapMemAlloc(1 * sizeof(DDHALMODEINFO));
This->mpModeInfos = (DDHALMODEINFO*) DxHeapMemAlloc(This->mcModeInfos * sizeof(DDHALMODEINFO));
if (This->lpLcl->lpGbl->lpModeInfo == NULL)
if (This->mpModeInfos == NULL)
{ {
DX_STUB_str("DD_FALSE"); DX_STUB_str("DD_FALSE");
return DD_FALSE; return DD_FALSE;
@ -47,37 +55,68 @@ StartDirectDraw(LPDIRECTDRAW* iface)
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode); EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode);
This->mpModeInfos[0].dwWidth = devmode.dmPelsWidth; This->lpLcl->lpGbl->lpModeInfo[0].dwWidth = devmode.dmPelsWidth;
This->mpModeInfos[0].dwHeight = devmode.dmPelsHeight; This->lpLcl->lpGbl->lpModeInfo[0].dwHeight = devmode.dmPelsHeight;
This->mpModeInfos[0].dwBPP = devmode.dmBitsPerPel; This->lpLcl->lpGbl->lpModeInfo[0].dwBPP = devmode.dmBitsPerPel;
This->mpModeInfos[0].lPitch = (devmode.dmPelsWidth*devmode.dmBitsPerPel)/8; This->lpLcl->lpGbl->lpModeInfo[0].lPitch = (devmode.dmPelsWidth*devmode.dmBitsPerPel)/8;
This->mpModeInfos[0].wRefreshRate = (WORD)devmode.dmDisplayFrequency; This->lpLcl->lpGbl->lpModeInfo[0].wRefreshRate = (WORD)devmode.dmDisplayFrequency;
if ( This->devicetype <3 )
{ if (lpGuid == NULL)
/* Create HDC for default, hal and hel driver */ {
This->hdc = CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL); devicetypes = 1;
/* Create HDC for default, hal and hel driver */
This->lpLcl->hDC = (ULONG_PTR) CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL);
/* cObsolete is undoc in msdn it being use in CreateDCA */
RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
}
else if (lpGuid == (LPGUID) DDCREATE_HARDWAREONLY)
{
devicetypes = 2;
/* Create HDC for default, hal and hel driver */
This->lpLcl->hDC = (ULONG_PTR)CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL);
/* cObsolete is undoc in msdn it being use in CreateDCA */
RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
}
else if (lpGuid == (LPGUID) DDCREATE_EMULATIONONLY)
{
devicetypes = 3;
/* Create HDC for default, hal and hel driver */
This->lpLcl->hDC = (ULONG_PTR) CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL);
/* cObsolete is undoc in msdn it being use in CreateDCA */
RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
} }
else else
{ {
/* FIXME : need getting driver from the GUID that have been pass in from /* FIXME : need getting driver from the GUID that have been pass in from
the register. we do not support that yet the register. we do not support that yet
*/ */
This->hdc = NULL ; devicetypes = 4;
This->lpLcl->hDC = (ULONG_PTR) NULL ;
} }
if ( (HDC)This->lpLcl->hDC == NULL)
if (This->hdc == NULL)
{ {
DX_STUB_str("DDERR_OUTOFMEMORY"); DX_STUB_str("DDERR_OUTOFMEMORY");
return DDERR_OUTOFMEMORY ; return DDERR_OUTOFMEMORY ;
} }
hbmp = CreateCompatibleBitmap(This->hdc, 1, 1); hbmp = CreateCompatibleBitmap((HDC) This->lpLcl->hDC, 1, 1);
if (hbmp==NULL) if (hbmp==NULL)
{ {
DxHeapMemFree(This->mpModeInfos); DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC) This->lpLcl->hDC);
DX_STUB_str("DDERR_OUTOFMEMORY"); DX_STUB_str("DDERR_OUTOFMEMORY");
return DDERR_OUTOFMEMORY; return DDERR_OUTOFMEMORY;
} }
@ -87,8 +126,8 @@ StartDirectDraw(LPDIRECTDRAW* iface)
if (pbmiData==NULL) if (pbmiData==NULL)
{ {
DxHeapMemFree(This->mpModeInfos); DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC) This->lpLcl->hDC);
DeleteObject(hbmp); DeleteObject(hbmp);
DX_STUB_str("DDERR_OUTOFMEMORY"); DX_STUB_str("DDERR_OUTOFMEMORY");
return DDERR_OUTOFMEMORY; return DDERR_OUTOFMEMORY;
@ -100,28 +139,24 @@ StartDirectDraw(LPDIRECTDRAW* iface)
pbmi->bmiHeader.biWidth = 1; pbmi->bmiHeader.biWidth = 1;
pbmi->bmiHeader.biHeight = 1; pbmi->bmiHeader.biHeight = 1;
GetDIBits(This->hdc, hbmp, 0, 0, NULL, pbmi, 0); GetDIBits((HDC) This->lpLcl->hDC, hbmp, 0, 0, NULL, pbmi, 0);
DeleteObject(hbmp); DeleteObject(hbmp);
pMasks = (DWORD*)(pbmiData + sizeof(BITMAPINFOHEADER)); pMasks = (DWORD*)(pbmiData + sizeof(BITMAPINFOHEADER));
This->mpModeInfos[0].dwRBitMask = pMasks[0]; This->lpLcl->lpGbl->lpModeInfo[0].dwRBitMask = pMasks[0];
This->mpModeInfos[0].dwGBitMask = pMasks[1]; This->lpLcl->lpGbl->lpModeInfo[0].dwGBitMask = pMasks[1];
This->mpModeInfos[0].dwBBitMask = pMasks[2]; This->lpLcl->lpGbl->lpModeInfo[0].dwBBitMask = pMasks[2];
This->mpModeInfos[0].dwAlphaBitMask = pMasks[3]; This->lpLcl->lpGbl->lpModeInfo[0].dwAlphaBitMask = pMasks[3];
DxHeapMemFree(pbmiData); DxHeapMemFree(pbmiData);
/* Startup HEL and HAL */ /* Startup HEL and HAL */
RtlZeroMemory(&This->mDDrawGlobal, sizeof(DDRAWI_DIRECTDRAW_GBL)); // RtlZeroMemory(&ddgbl, sizeof(DDRAWI_DIRECTDRAW_GBL));
RtlZeroMemory(&This->mHALInfo, sizeof(DDHALINFO));
RtlZeroMemory(&This->mCallbacks, sizeof(DDHAL_CALLBACKS)); This->lpLcl->lpDDCB = This->lpLcl->lpGbl->lpDDCBtmp;
This->lpLcl->dwProcessId = GetCurrentProcessId();
This->mDDrawLocal.lpDDCB = &This->mCallbacks;
This->mDDrawLocal.lpGbl = &This->mDDrawGlobal;
This->mDDrawLocal.dwProcessId = GetCurrentProcessId();
This->mDDrawGlobal.lpDDCBtmp = &This->mCallbacks;
This->mDDrawGlobal.lpExclusiveOwner = &This->mDDrawLocal;
hal_ret = StartDirectDrawHal(iface); hal_ret = StartDirectDrawHal(iface);
hel_ret = StartDirectDrawHel(iface); hel_ret = StartDirectDrawHel(iface);
@ -131,101 +166,16 @@ StartDirectDraw(LPDIRECTDRAW* iface)
return DDERR_NODIRECTDRAWSUPPORT; return DDERR_NODIRECTDRAWSUPPORT;
} }
/* This->lpLcl->hDD = This->lpLcl->lpGbl->hDD;
Setup HEL or HAL for DD_CALLBACKS
*/
This->mDdCanCreateSurface.lpDD = &This->mDDrawGlobal;
This->mDdCreatePalette.lpDD = &This->mDDrawGlobal;
This->mDdCreateSurface.lpDD = &This->mDDrawGlobal;
This->mDdFlipToGDISurface.lpDD = &This->mDDrawGlobal;
This->mDdDestroyDriver.lpDD = &This->mDDrawGlobal;
This->mDdGetScanLine.lpDD = &This->mDDrawGlobal;
This->mDdSetExclusiveMode.lpDD = &This->mDDrawGlobal;
This->mDdSetMode.lpDD = &This->mDDrawGlobal;
This->mDdWaitForVerticalBlank.lpDD = &This->mDDrawGlobal;
This->mDdSetColorKey.lpDD = &This->mDDrawGlobal;
if (This->devicetype!=1)
{
/* both or only hel */
This->mDdCanCreateSurface.CanCreateSurface = This->mCallbacks.HELDD.CanCreateSurface;
This->mDdCreatePalette.CreatePalette = This->mCallbacks.HELDD.CreatePalette;
This->mDdCreateSurface.CreateSurface = This->mCallbacks.HELDD.CreateSurface;
This->mDdDestroyDriver.DestroyDriver = This->mCallbacks.HELDD.DestroyDriver;
This->mDdFlipToGDISurface.FlipToGDISurface = This->mCallbacks.HELDD.FlipToGDISurface;
This->mDdGetScanLine.GetScanLine = This->mCallbacks.HELDD.GetScanLine;
This->mDdSetExclusiveMode.SetExclusiveMode = This->mCallbacks.HELDD.SetExclusiveMode;
This->mDdSetMode.SetMode = This->mCallbacks.HELDD.SetMode;
This->mDdWaitForVerticalBlank.WaitForVerticalBlank = This->mCallbacks.HELDD.WaitForVerticalBlank;
// This->mDdSetColorKey.SetColorKey = This->mCallbacks.HELDD.SetColorKey;
}
if (This->devicetype!=2)
{
Flags = This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags;
if (Flags & DDHAL_CB32_CANCREATESURFACE)
{
This->mDdCanCreateSurface.CanCreateSurface = This->mCallbacks.HALDD.CanCreateSurface;
}
if (Flags & DDHAL_CB32_CREATEPALETTE)
{
This->mDdCreatePalette.CreatePalette = This->mCallbacks.HALDD.CreatePalette;
}
if (Flags & DDHAL_CB32_CREATESURFACE)
{
This->mDdCreateSurface.CreateSurface = This->mCallbacks.HALDD.CreateSurface;
}
if (Flags & DDHAL_CB32_DESTROYDRIVER)
{
This->mDdDestroyDriver.DestroyDriver = This->mCallbacks.HALDD.DestroyDriver;
}
if (Flags & DDHAL_CB32_FLIPTOGDISURFACE)
{
This->mDdFlipToGDISurface.FlipToGDISurface = This->mCallbacks.HALDD.FlipToGDISurface;
}
if (Flags & DDHAL_CB32_GETSCANLINE)
{
This->mDdGetScanLine.GetScanLine = This->mCallbacks.HALDD.GetScanLine;
}
if (Flags & DDHAL_CB32_SETEXCLUSIVEMODE)
{
This->mDdSetExclusiveMode.SetExclusiveMode = This->mCallbacks.HALDD.SetExclusiveMode;
}
if (Flags & DDHAL_CB32_SETMODE)
{
This->mDdSetMode.SetMode = This->mCallbacks.HALDD.SetMode;
}
if (Flags & DDHAL_CB32_WAITFORVERTICALBLANK)
{
This->mDdWaitForVerticalBlank.WaitForVerticalBlank = This->mCallbacks.HALDD.WaitForVerticalBlank;
}
if (Flags & DDHAL_CB32_SETCOLORKEY)
{
// This->mDdSetColorKey.SetColorKey = This->mCallbacks.HALDD.SetColorKey;
}
}
/* /* Fixme the mix betwin hel and hal */
Setup HEL or HAL for SURFACE CALLBACK
*/
// FIXME
/* Fill some basic info for Surface */
/* Setup calback struct so we do not need refill same info again */ ddSurfGbl.lpDD = &ddgbl;
This->mDdCreateSurface.lpDD = &This->mDDrawGlobal;
This->mDdCanCreateSurface.lpDD = &This->mDDrawGlobal;
This->mDDrawLocal.lpGbl = &This->mDDrawGlobal;
return DD_OK; return DD_OK;
} }
@ -233,30 +183,46 @@ StartDirectDraw(LPDIRECTDRAW* iface)
HRESULT WINAPI HRESULT WINAPI
StartDirectDrawHal(LPDIRECTDRAW* iface) StartDirectDrawHal(LPDIRECTDRAW* iface)
{ {
IDirectDrawImpl* This = (IDirectDrawImpl*)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
DDHAL_GETDRIVERINFODATA DriverInfo; DDHAL_GETDRIVERINFODATA DriverInfo;
DDHALINFO mHALInfo;
DDHAL_CALLBACKS mCallbacks;
DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks;
D3DHAL_CALLBACKS mD3dCallbacks;
D3DHAL_GLOBALDRIVERDATA mD3dDriverData;
UINT mcvmList;
VIDMEM *mpvmList;
UINT mcFourCC;
DWORD *mpFourCC;
UINT mcTextures;
DDSURFACEDESC *mpTextures;
/* HAL Startup process */ /* HAL Startup process */
BOOL newmode = FALSE; BOOL newmode = FALSE;
RtlZeroMemory(&mHALInfo, sizeof(DDHALINFO));
RtlZeroMemory(&mCallbacks, sizeof(DDHAL_CALLBACKS));
/* /*
Startup DX HAL step one of three Startup DX HAL step one of three
*/ */
if (!DdCreateDirectDrawObject(&This->mDDrawGlobal, This->hdc)) if (!DdCreateDirectDrawObject(This->lpLcl->lpGbl, (HDC)This->lpLcl->hDC))
{ {
DxHeapMemFree(This->mpModeInfos); DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC)This->lpLcl->hDC);
return DD_FALSE; return DD_FALSE;
} }
// Do not relase HDC it have been map in kernel mode // Do not relase HDC it have been map in kernel mode
// DeleteDC(hdc); // DeleteDC(hdc);
if (!DdReenableDirectDrawObject(&This->mDDrawGlobal, &newmode)) if (!DdReenableDirectDrawObject(This->lpLcl->lpGbl, &newmode))
{ {
DxHeapMemFree(This->mpModeInfos); DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC)This->lpLcl->hDC);
return DD_FALSE; return DD_FALSE;
} }
@ -265,80 +231,80 @@ StartDirectDrawHal(LPDIRECTDRAW* iface)
Startup DX HAL step two of three Startup DX HAL step two of three
*/ */
if (!DdQueryDirectDrawObject(&This->mDDrawGlobal, if (!DdQueryDirectDrawObject(This->lpLcl->lpGbl,
&This->mHALInfo, &mHALInfo,
&This->mCallbacks.HALDD, &mCallbacks.HALDD,
&This->mCallbacks.HALDDSurface, &mCallbacks.HALDDSurface,
&This->mCallbacks.HALDDPalette, &mCallbacks.HALDDPalette,
&This->mD3dCallbacks, &mD3dCallbacks,
&This->mD3dDriverData, &mD3dDriverData,
&This->mD3dBufferCallbacks, &mD3dBufferCallbacks,
NULL, NULL,
NULL, NULL,
NULL)) NULL))
{ {
DxHeapMemFree(This->mpModeInfos); DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call // FIXME Close DX fristcall and second call
return DD_FALSE; return DD_FALSE;
} }
This->mcvmList = This->mHALInfo.vmiData.dwNumHeaps; mcvmList = mHALInfo.vmiData.dwNumHeaps;
This->mpvmList = (VIDMEM*) DxHeapMemAlloc(sizeof(VIDMEM) * This->mcvmList); mpvmList = (VIDMEM*) DxHeapMemAlloc(sizeof(VIDMEM) * mcvmList);
if (This->mpvmList == NULL) if (mpvmList == NULL)
{ {
DxHeapMemFree(This->mpModeInfos); DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call // FIXME Close DX fristcall and second call
return DD_FALSE; return DD_FALSE;
} }
This->mcFourCC = This->mHALInfo.ddCaps.dwNumFourCCCodes; mcFourCC = mHALInfo.ddCaps.dwNumFourCCCodes;
This->mpFourCC = (DWORD *) DxHeapMemAlloc(sizeof(DWORD) * This->mcFourCC); mpFourCC = (DWORD *) DxHeapMemAlloc(sizeof(DWORD) * mcFourCC);
if (This->mpFourCC == NULL) if (mpFourCC == NULL)
{ {
DxHeapMemFree(This->mpvmList); DxHeapMemFree(mpvmList);
DxHeapMemFree(This->mpModeInfos); DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call // FIXME Close DX fristcall and second call
return DD_FALSE; return DD_FALSE;
} }
This->mcTextures = This->mD3dDriverData.dwNumTextureFormats; mcTextures = mD3dDriverData.dwNumTextureFormats;
This->mpTextures = (DDSURFACEDESC*) DxHeapMemAlloc(sizeof(DDSURFACEDESC) * This->mcTextures); mpTextures = (DDSURFACEDESC*) DxHeapMemAlloc(sizeof(DDSURFACEDESC) * mcTextures);
if (This->mpTextures == NULL) if (mpTextures == NULL)
{ {
DxHeapMemFree( This->mpFourCC); DxHeapMemFree( mpFourCC);
DxHeapMemFree( This->mpvmList); DxHeapMemFree( mpvmList);
DxHeapMemFree( This->mpModeInfos); DxHeapMemFree( This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call // FIXME Close DX fristcall and second call
return DD_FALSE; return DD_FALSE;
} }
This->mHALInfo.vmiData.pvmList = This->mpvmList; mHALInfo.vmiData.pvmList = mpvmList;
This->mHALInfo.lpdwFourCC = This->mpFourCC; mHALInfo.lpdwFourCC = mpFourCC;
This->mD3dDriverData.lpTextureFormats = (DDSURFACEDESC*) This->mpTextures; mD3dDriverData.lpTextureFormats = (DDSURFACEDESC*) mpTextures;
if (!DdQueryDirectDrawObject( if (!DdQueryDirectDrawObject(
&This->mDDrawGlobal, This->lpLcl->lpGbl,
&This->mHALInfo, &mHALInfo,
&This->mCallbacks.HALDD, &mCallbacks.HALDD,
&This->mCallbacks.HALDDSurface, &mCallbacks.HALDDSurface,
&This->mCallbacks.HALDDPalette, &mCallbacks.HALDDPalette,
&This->mD3dCallbacks, &mD3dCallbacks,
&This->mD3dDriverData, &mD3dDriverData,
&This->mCallbacks.HALDDExeBuf, &mCallbacks.HALDDExeBuf,
(DDSURFACEDESC*)This->mpTextures, (DDSURFACEDESC*)mpTextures,
This->mpFourCC, mpFourCC,
This->mpvmList)) mpvmList))
{ {
DxHeapMemFree(This->mpTextures); DxHeapMemFree(mpTextures);
DxHeapMemFree(This->mpFourCC); DxHeapMemFree(mpFourCC);
DxHeapMemFree(This->mpvmList); DxHeapMemFree(mpvmList);
DxHeapMemFree(This->mpModeInfos); DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC(This->hdc); DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call // FIXME Close DX fristcall and second call
return DD_FALSE; return DD_FALSE;
} }
@ -350,84 +316,69 @@ StartDirectDrawHal(LPDIRECTDRAW* iface)
// this is wrong, cDriverName need be in ASC code not UNICODE // this is wrong, cDriverName need be in ASC code not UNICODE
//memcpy(mDDrawGlobal.cDriverName, mDisplayAdapter, sizeof(wchar)*MAX_DRIVER_NAME); //memcpy(mDDrawGlobal.cDriverName, mDisplayAdapter, sizeof(wchar)*MAX_DRIVER_NAME);
memcpy(&This->mDDrawGlobal.vmiData, &This->mHALInfo.vmiData,sizeof(VIDMEMINFO)); memcpy(&ddgbl.vmiData, &mHALInfo.vmiData,sizeof(VIDMEMINFO));
memcpy(&This->mDDrawGlobal.ddCaps, &This->mHALInfo.ddCaps,sizeof(DDCORECAPS)); memcpy(&ddgbl.ddCaps, &mHALInfo.ddCaps,sizeof(DDCORECAPS));
This->mHALInfo.dwNumModes = This->mcModeInfos;
This->mHALInfo.lpModeInfo = This->mpModeInfos;
This->mHALInfo.dwMonitorFrequency = This->mpModeInfos[0].wRefreshRate;
This->mDDrawGlobal.dwMonitorFrequency = This->mHALInfo.dwMonitorFrequency;
This->mDDrawGlobal.dwModeIndex = This->mHALInfo.dwModeIndex;
This->mDDrawGlobal.dwNumModes = This->mHALInfo.dwNumModes;
This->mDDrawGlobal.lpModeInfo = This->mHALInfo.lpModeInfo;
This->mDDrawGlobal.hInstance = This->mHALInfo.hInstance;
This->mDDrawGlobal.lp16DD = &This->mDDrawGlobal; mHALInfo.dwNumModes = 1;
mHALInfo.lpModeInfo = This->lpLcl->lpGbl->lpModeInfo;
//DeleteDC(This->hdc); mHALInfo.dwMonitorFrequency = This->lpLcl->lpGbl->lpModeInfo[0].wRefreshRate;
This->lpLcl->lpGbl->dwMonitorFrequency = mHALInfo.dwMonitorFrequency;
This->lpLcl->lpGbl->dwModeIndex = mHALInfo.dwModeIndex;
This->lpLcl->lpGbl->dwNumModes = mHALInfo.dwNumModes;
This->lpLcl->lpGbl->lpModeInfo = mHALInfo.lpModeInfo;
This->lpLcl->lpGbl->hInstance = mHALInfo.hInstance;
This->lpLcl->lpGbl->lp16DD = This->lpLcl->lpGbl;
memset(&DriverInfo,0, sizeof(DDHAL_GETDRIVERINFODATA)); memset(&DriverInfo,0, sizeof(DDHAL_GETDRIVERINFODATA));
DriverInfo.dwSize = sizeof(DDHAL_GETDRIVERINFODATA); DriverInfo.dwSize = sizeof(DDHAL_GETDRIVERINFODATA);
DriverInfo.dwContext = This->mDDrawGlobal.hDD; DriverInfo.dwContext = This->lpLcl->lpGbl->hDD;
/* Get the MiscellaneousCallbacks */ /* Get the MiscellaneousCallbacks */
DriverInfo.guidInfo = GUID_MiscellaneousCallbacks; DriverInfo.guidInfo = GUID_MiscellaneousCallbacks;
DriverInfo.lpvData = &This->mDDrawGlobal.lpDDCBtmp->HALDDMiscellaneous; DriverInfo.lpvData = &ddgbl.lpDDCBtmp->HALDDMiscellaneous;
DriverInfo.dwExpectedSize = sizeof(DDHAL_DDMISCELLANEOUSCALLBACKS); DriverInfo.dwExpectedSize = sizeof(DDHAL_DDMISCELLANEOUSCALLBACKS);
This->mHALInfo.GetDriverInfo(&DriverInfo); mHALInfo.GetDriverInfo(&DriverInfo);
/* Setup global surface */
/*This->mPrimaryGlobal.dwGlobalFlags = DDRAWISURFGBL_ISGDISURFACE;
This->mPrimaryGlobal.lpDD = &This->mDDrawGlobal;
This->mPrimaryGlobal.lpDDHandle = &This->mDDrawGlobal;
This->mPrimaryGlobal.wWidth = (WORD)This->mpModeInfos[0].dwWidth;
This->mPrimaryGlobal.wHeight = (WORD)This->mpModeInfos[0].dwHeight;
This->mPrimaryGlobal.lPitch = This->mpModeInfos[0].lPitch;*/
/* FIXME free it in cleanup */
// This->mDDrawGlobal.dsList = (LPDDRAWI_DDRAWSURFACE_INT)DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_INT));
return DD_OK; return DD_OK;
} }
HRESULT WINAPI HRESULT WINAPI
StartDirectDrawHel(LPDIRECTDRAW* iface) StartDirectDrawHel(LPDIRECTDRAW* iface)
{ {
IDirectDrawImpl* This = (IDirectDrawImpl*)iface; LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
/*
FIXME :
FlipToGDISurface
SetColorKey
Hel api
*/
This->lpLcl->lpDDCB->HELDD.CanCreateSurface = HelDdCanCreateSurface;
This->lpLcl->lpDDCB->HELDD.CreateSurface = HelDdCreateSurface;
This->lpLcl->lpDDCB->HELDD.CreatePalette = HelDdCreatePalette;
This->lpLcl->lpDDCB->HELDD.DestroyDriver = HelDdDestroyDriver;
//This->lpLcl->lpDDCB->HELDD.FlipToGDISurface = HelDdFlipToGDISurface
This->lpLcl->lpDDCB->HELDD.GetScanLine = HelDdGetScanLine;
// This->lpLcl->lpDDCB->HELDD.SetColorKey = HelDdSetColorKey;
This->lpLcl->lpDDCB->HELDD.SetExclusiveMode = HelDdSetExclusiveMode;
This->lpLcl->lpDDCB->HELDD.SetMode = HelDdSetMode;
This->lpLcl->lpDDCB->HELDD.WaitForVerticalBlank = HelDdWaitForVerticalBlank;
This->HELMemoryAvilable = HEL_GRAPHIC_MEMORY_MAX; This->lpLcl->lpDDCB->HELDD.dwFlags = DDHAL_CB32_CANCREATESURFACE |
DDHAL_CB32_CREATESURFACE |
This->mCallbacks.HELDD.dwFlags = DDHAL_CB32_DESTROYDRIVER; DDHAL_CB32_CREATEPALETTE |
This->mCallbacks.HELDD.DestroyDriver = HelDdDestroyDriver; DDHAL_CB32_DESTROYDRIVER |
// DDHAL_CB32_FLIPTOGDISURFACE |
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_CREATESURFACE; DDHAL_CB32_GETSCANLINE |
This->mCallbacks.HELDD.CreateSurface = HelDdCreateSurface; // DDHAL_CB32_SETCOLORKEY |
DDHAL_CB32_SETEXCLUSIVEMODE |
// DDHAL_CB32_ DDHAL_CB32_SETMODE |
//This->mCallbacks.HELDD.SetColorKey = HelDdSetColorKey; DDHAL_CB32_WAITFORVERTICALBLANK ;
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_SETMODE;
This->mCallbacks.HELDD.SetMode = HelDdSetMode;
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_WAITFORVERTICALBLANK;
This->mCallbacks.HELDD.WaitForVerticalBlank = HelDdWaitForVerticalBlank;
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_CANCREATESURFACE;
This->mCallbacks.HELDD.CanCreateSurface = HelDdCanCreateSurface;
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_CREATEPALETTE;
This->mCallbacks.HELDD.CreatePalette = HelDdCreatePalette;
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_GETSCANLINE;
This->mCallbacks.HELDD.GetScanLine = HelDdGetScanLine;
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_SETEXCLUSIVEMODE;
This->mCallbacks.HELDD.SetExclusiveMode = HelDdSetExclusiveMode;
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_FLIPTOGDISURFACE;
This->mCallbacks.HELDD.FlipToGDISurface = HelDdFlipToGDISurface;
return DD_OK; return DD_OK;
} }
@ -437,64 +388,43 @@ Create_DirectDraw (LPGUID pGUID,
LPDIRECTDRAW* pIface, LPDIRECTDRAW* pIface,
REFIID id, REFIID id,
BOOL ex) BOOL ex)
{ {
IDirectDrawImpl* This; LPDDRAWI_DIRECTDRAW_INT This;
DX_WINDBG_trace(); DX_WINDBG_trace();
//AcquireDDThreadLock(); This = DxHeapMemAlloc(sizeof(DDRAWI_DIRECTDRAW_INT));
This = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
if (This == NULL) if (This == NULL)
{ {
ReleaseDDThreadLock();
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
This->lpLcl = DxHeapMemAlloc(sizeof(DDRAWI_DIRECTDRAW_INT));
ZeroMemory(This,sizeof(IDirectDrawImpl)); if (This->lpLcl == NULL)
{
/* FIXME cleanup */
return DDERR_OUTOFMEMORY;
}
This->lpVtbl = &DirectDraw7_Vtable; This->lpLcl->lpGbl = &ddgbl;
This->lpVtbl_v1 = &DDRAW_IDirectDraw_VTable;
This->lpVtbl_v2 = &DDRAW_IDirectDraw2_VTable;
This->lpVtbl_v4 = &DDRAW_IDirectDraw4_VTable;
*pIface = (LPDIRECTDRAW)This; *pIface = (LPDIRECTDRAW)This;
if (pGUID == 0)
{
This->devicetype = 0; /* both hal and hel default driver "DISPLAY" */
}
else if (pGUID == (LPGUID) DDCREATE_HARDWAREONLY)
{
This->devicetype = 1; /* hal only default driver "DISPLAY" */
}
else if (pGUID == (LPGUID) DDCREATE_EMULATIONONLY) if(Main_DirectDraw_QueryInterface((LPDIRECTDRAW7)This, id, (void**)&pIface) != S_OK)
{ {
This->devicetype = 2; /* hel only default driver "DISPLAY" */
}
else
{
This->devicetype = 3; /* Read from the register which driver it should be */
}
if(This->lpVtbl->QueryInterface ((LPDIRECTDRAW7)This, id, (void**)&pIface) != S_OK)
{
ReleaseDDThreadLock();
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }
if (StartDirectDraw((LPDIRECTDRAW*)This) == DD_OK); if (StartDirectDraw((LPDIRECTDRAW*)This, pGUID) == DD_OK);
{ {
//ReleaseDDThreadLock();
return This->lpVtbl->Initialize ((LPDIRECTDRAW7)This, pGUID);
}
//ReleaseDDThreadLock(); return ((LPDIRECTDRAW7)This)->lpVtbl->Initialize ((LPDIRECTDRAW7)This, pGUID);
}
return DDERR_INVALIDPARAMS; return DDERR_INVALIDPARAMS;
} }

1440
reactos/dll/directx/ddraw/thunks/ddraw_thunk.c
View file

File diff suppressed because it is too large Load diff

646
reactos/dll/directx/ddraw/thunks/surface_thunk.c
View file

@ -1,430 +1,522 @@
/* IDirectDrawSurface3 -> IDirectDrawSurface7 thunks
* Copyright 2000 TransGaming Technologies Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* Taken form wine (wine/dlls/ddraw/surface_thunks.c rev 1.2)
* with some little changes
*
*/
#include "../winedraw.h" #include "../rosdraw.h"
#define CONVERT(pdds) COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, \
IDirectDrawSurface3, \
IDirectDrawSurface7, \
(pdds))
#define CONVERT_REV(pdds) COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, \
IDirectDrawSurface7, \
IDirectDrawSurface3, \
(pdds))
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_QueryInterface(LPDIRECTDRAWSURFACE3 This, REFIID iid, Thunk_DDrawSurface3_QueryInterface(LPDIRECTDRAWSURFACE3 iface, REFIID iid,
LPVOID *ppObj) LPVOID *ppObj)
{ {
return IDirectDrawSurface7_QueryInterface(CONVERT(This), iid, ppObj); DX_WINDBG_trace();
return Main_DDrawSurface_QueryInterface((LPDIRECTDRAWSURFACE7) iface, iid, ppObj);
} }
static ULONG WINAPI ULONG WINAPI
IDirectDrawSurface3Impl_AddRef(LPDIRECTDRAWSURFACE3 This) Thunk_DDrawSurface3_AddRef(LPDIRECTDRAWSURFACE3 iface)
{ {
return IDirectDrawSurface7_AddRef(CONVERT(This)); DX_WINDBG_trace();
return Main_DDrawSurface_AddRef((LPDIRECTDRAWSURFACE7) iface);
} }
static ULONG WINAPI ULONG WINAPI
IDirectDrawSurface3Impl_Release(LPDIRECTDRAWSURFACE3 This) Thunk_DDrawSurface3_Release(LPDIRECTDRAWSURFACE3 iface)
{ {
return IDirectDrawSurface7_Release(CONVERT(This)); DX_WINDBG_trace();
return Main_DDrawSurface_Release((LPDIRECTDRAWSURFACE7) iface);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_AddAttachedSurface(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_AddAttachedSurface(LPDIRECTDRAWSURFACE3 iface, LPDIRECTDRAWSURFACE3 pAttach)
LPDIRECTDRAWSURFACE3 pAttach)
{ {
return IDirectDrawSurface7_AddAttachedSurface(CONVERT(This), DX_WINDBG_trace();
CONVERT(pAttach));
return Main_DDrawSurface_AddAttachedSurface((LPDIRECTDRAWSURFACE7) iface, (LPDIRECTDRAWSURFACE7) pAttach);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_AddOverlayDirtyRect(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_AddOverlayDirtyRect(LPDIRECTDRAWSURFACE3 iface, LPRECT pRect)
LPRECT pRect)
{ {
return IDirectDrawSurface7_AddOverlayDirtyRect(CONVERT(This), pRect); DX_WINDBG_trace();
return Main_DDrawSurface_AddOverlayDirtyRect((LPDIRECTDRAWSURFACE7) iface, pRect);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_Blt(LPDIRECTDRAWSURFACE3 This, LPRECT prcDst, Thunk_DDrawSurface3_Blt(LPDIRECTDRAWSURFACE3 iface, LPRECT rdst,
LPDIRECTDRAWSURFACE3 pSrcSurf, LPRECT prcSrc, LPDIRECTDRAWSURFACE3 src, LPRECT rsrc,
DWORD dwFlags, LPDDBLTFX pFX) DWORD dwFlags, LPDDBLTFX pFX)
{ {
return IDirectDrawSurface7_Blt(CONVERT(This), prcDst, CONVERT(pSrcSurf), DX_WINDBG_trace();
prcSrc, dwFlags, pFX);
return Main_DDrawSurface_Blt((LPDIRECTDRAWSURFACE7) iface, rdst,(LPDIRECTDRAWSURFACE7) src, rsrc, dwFlags, pFX);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_BltBatch(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_BltBatch(LPDIRECTDRAWSURFACE3 iface, LPDDBLTBATCH pBatch, DWORD dwCount, DWORD dwFlags)
LPDDBLTBATCH pBatch, DWORD dwCount,
DWORD dwFlags)
{ {
return IDirectDrawSurface7_BltBatch(CONVERT(This), pBatch, dwCount, DX_WINDBG_trace();
dwFlags);
return Main_DDrawSurface_BltBatch((LPDIRECTDRAWSURFACE7) iface, pBatch, dwCount, dwFlags);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_BltFast(LPDIRECTDRAWSURFACE3 This, DWORD x, DWORD y, Thunk_DDrawSurface3_BltFast(LPDIRECTDRAWSURFACE3 iface, DWORD dstx, DWORD dsty,
LPDIRECTDRAWSURFACE3 pSrcSurf, LPRECT prcSrc, LPDIRECTDRAWSURFACE3 src, LPRECT rsrc, DWORD dwTrans)
DWORD dwTrans)
{ {
return IDirectDrawSurface7_BltFast(CONVERT(This), x, y, CONVERT(pSrcSurf), DX_WINDBG_trace();
prcSrc, dwTrans);
return Main_DDrawSurface_BltFast((LPDIRECTDRAWSURFACE7) iface, dstx, dsty,
(LPDIRECTDRAWSURFACE7)src, rsrc, dwTrans);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_DeleteAttachedSurface(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_DeleteAttachedSurface(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags, LPDIRECTDRAWSURFACE3 pAttached)
DWORD dwFlags,
LPDIRECTDRAWSURFACE3 pAttached)
{ {
return IDirectDrawSurface7_DeleteAttachedSurface(CONVERT(This), dwFlags, DX_WINDBG_trace();
CONVERT(pAttached));
return Main_DDrawSurface_DeleteAttachedSurface((LPDIRECTDRAWSURFACE7) iface, dwFlags,
(LPDIRECTDRAWSURFACE7) pAttached);
} }
struct callback_info
{
LPDDENUMSURFACESCALLBACK callback;
LPVOID context;
};
static HRESULT CALLBACK
EnumCallback(LPDIRECTDRAWSURFACE7 iface, LPDDSURFACEDESC2 pDDSD,
LPVOID context)
{
const struct callback_info* info = context;
#if 0 HRESULT WINAPI
/* This is an outgoing conversion so we have to do it. */ Thunk_DDrawSurface3_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE3 iface,
DDSURFACEDESC ddsd;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
DDRAW_Convert_DDSURFACEDESC_2_To_1(pDDSD, &ddsd);
#endif
/* the LPDDSURFACEDESC2 -> LPDDSURFACEDESC coercion is safe, since
* the data format is compatible with older enum procs */
return info->callback((LPDIRECTDRAWSURFACE)CONVERT_REV(iface), (LPDDSURFACEDESC)pDDSD,
info->context);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE3 This,
LPVOID context, LPVOID context,
LPDDENUMSURFACESCALLBACK callback) LPDDENUMSURFACESCALLBACK cb)
{ {
struct callback_info info; DX_WINDBG_trace();
info.callback = callback; return Main_DDrawSurface_EnumAttachedSurfaces((LPDIRECTDRAWSURFACE7) iface,
info.context = context; context, (LPDDENUMSURFACESCALLBACK7)cb);
return IDirectDrawSurface7_EnumAttachedSurfaces(CONVERT(This), &info,
EnumCallback);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_EnumOverlayZOrders(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_EnumOverlayZOrders(LPDIRECTDRAWSURFACE3 iface,
DWORD dwFlags, LPVOID context, DWORD dwFlags, LPVOID context,
LPDDENUMSURFACESCALLBACK callback) LPDDENUMSURFACESCALLBACK cb)
{ {
struct callback_info info; DX_WINDBG_trace();
info.callback = callback; return Main_DDrawSurface_EnumOverlayZOrders( (LPDIRECTDRAWSURFACE7) iface, dwFlags, context,
info.context = context; (LPDDENUMSURFACESCALLBACK7) cb);
return IDirectDrawSurface7_EnumOverlayZOrders(CONVERT(This), dwFlags,
&info, EnumCallback);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_Flip(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_Flip(LPDIRECTDRAWSURFACE3 iface,
LPDIRECTDRAWSURFACE3 pOverride, DWORD dwFlags) LPDIRECTDRAWSURFACE3 lpDDSurfaceTargetOverride, DWORD dwFlags)
{ {
return IDirectDrawSurface7_Flip(CONVERT(This), CONVERT(pOverride), DX_WINDBG_trace();
dwFlags);
return Main_DDrawSurface_Flip( (LPDIRECTDRAWSURFACE7)iface, (LPDIRECTDRAWSURFACE7) lpDDSurfaceTargetOverride,
dwFlags);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetAttachedSurface(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_GetAttachedSurface(LPDIRECTDRAWSURFACE3 iface,
LPDDSCAPS pCaps, LPDDSCAPS pCaps,
LPDIRECTDRAWSURFACE3* ppAttached) LPDIRECTDRAWSURFACE3* ppAttached)
{ {
DDSCAPS2 caps; DDSCAPS2 caps;
LPDIRECTDRAWSURFACE7 pAttached7; HRESULT hr = DDERR_GENERIC;
HRESULT hr;
caps.dwCaps = pCaps->dwCaps; DX_WINDBG_trace();
caps.dwCaps2 = 0;
caps.dwCaps3 = 0;
caps.dwCaps4 = 0;
hr = IDirectDrawSurface7_GetAttachedSurface(CONVERT(This), &caps, ZeroMemory(&caps,sizeof(DDSCAPS2));
&pAttached7);
if (FAILED(hr)) return hr; if (pCaps != NULL)
{
caps.dwCaps = pCaps->dwCaps;
hr = Main_DDrawSurface_GetAttachedSurface( (LPDIRECTDRAWSURFACE7) iface,
&caps, (LPDIRECTDRAWSURFACE7 *) ppAttached);
pCaps->dwCaps = caps.dwCaps;
}
else
{
hr = Main_DDrawSurface_GetAttachedSurface( (LPDIRECTDRAWSURFACE7) iface,
NULL, (LPDIRECTDRAWSURFACE7 *) ppAttached);
}
*ppAttached = CONVERT_REV(pAttached7);
return hr; return hr;
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetBltStatus(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags) Thunk_DDrawSurface3_GetBltStatus(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags)
{ {
return IDirectDrawSurface7_GetBltStatus(CONVERT(This), dwFlags); DX_WINDBG_trace();
return Main_DDrawSurface_GetBltStatus((LPDIRECTDRAWSURFACE7) iface, dwFlags);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetCaps(LPDIRECTDRAWSURFACE3 This, LPDDSCAPS pCaps) Thunk_DDrawSurface3_GetCaps(LPDIRECTDRAWSURFACE3 iface, LPDDSCAPS pCaps)
{ {
DDSCAPS2 caps; DDSCAPS2 caps;
HRESULT hr; HRESULT hr = DDERR_GENERIC;
hr = IDirectDrawSurface7_GetCaps(CONVERT(This), &caps); DX_WINDBG_trace();
if (FAILED(hr)) return hr;
ZeroMemory(&caps,sizeof(DDSCAPS2));
if (pCaps != NULL)
{
hr = Main_DDrawSurface_GetCaps((LPDIRECTDRAWSURFACE7) iface, &caps);
pCaps->dwCaps = caps.dwCaps;
}
else
{
hr = Main_DDrawSurface_GetCaps((LPDIRECTDRAWSURFACE7) iface, NULL);
}
pCaps->dwCaps = caps.dwCaps;
return hr; return hr;
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetClipper(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_GetClipper(LPDIRECTDRAWSURFACE3 iface,
LPDIRECTDRAWCLIPPER* ppClipper) LPDIRECTDRAWCLIPPER* ppClipper)
{ {
return IDirectDrawSurface7_GetClipper(CONVERT(This), ppClipper); DX_WINDBG_trace();
return Main_DDrawSurface_GetClipper((LPDIRECTDRAWSURFACE7) iface, ppClipper);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetColorKey(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags, Thunk_DDrawSurface3_GetColorKey(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags,
LPDDCOLORKEY pCKey) LPDDCOLORKEY pCKey)
{ {
return IDirectDrawSurface7_GetColorKey(CONVERT(This), dwFlags, pCKey); DX_WINDBG_trace();
return Main_DDrawSurface_GetColorKey( (LPDIRECTDRAWSURFACE7) iface, dwFlags, pCKey);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetDC(LPDIRECTDRAWSURFACE3 This, HDC* phDC) Thunk_DDrawSurface3_GetDC(LPDIRECTDRAWSURFACE3 iface, HDC* phDC)
{ {
return IDirectDrawSurface7_GetDC(CONVERT(This), phDC); DX_WINDBG_trace();
return Main_DDrawSurface_GetDC((LPDIRECTDRAWSURFACE7) iface, phDC);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetFlipStatus(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags) Thunk_DDrawSurface3_GetFlipStatus(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags)
{ {
return IDirectDrawSurface7_GetFlipStatus(CONVERT(This), dwFlags); DX_WINDBG_trace();
return Main_DDrawSurface_GetFlipStatus((LPDIRECTDRAWSURFACE7) iface, dwFlags);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetOverlayPosition(LPDIRECTDRAWSURFACE3 This, LPLONG pX, Thunk_DDrawSurface3_GetOverlayPosition(LPDIRECTDRAWSURFACE3 iface, LPLONG pX, LPLONG pY)
LPLONG pY)
{ {
return IDirectDrawSurface7_GetOverlayPosition(CONVERT(This), pX, pY); DX_WINDBG_trace();
return Main_DDrawSurface_GetOverlayPosition((LPDIRECTDRAWSURFACE7) iface, pX, pY);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetPalette(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_GetPalette(LPDIRECTDRAWSURFACE3 iface,
LPDIRECTDRAWPALETTE* ppPalette) LPDIRECTDRAWPALETTE* ppPalette)
{ {
return IDirectDrawSurface7_GetPalette(CONVERT(This), ppPalette); DX_WINDBG_trace();
return Main_DDrawSurface_GetPalette((LPDIRECTDRAWSURFACE7) iface, ppPalette);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetPixelFormat(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_GetPixelFormat(LPDIRECTDRAWSURFACE3 iface,
LPDDPIXELFORMAT pPixelFormat) LPDDPIXELFORMAT pDDPixelFormat)
{ {
return IDirectDrawSurface7_GetPixelFormat(CONVERT(This), pPixelFormat); DX_WINDBG_trace();
return Main_DDrawSurface_GetPixelFormat((LPDIRECTDRAWSURFACE7) iface, pDDPixelFormat);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetSurfaceDesc(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_GetSurfaceDesc(LPDIRECTDRAWSURFACE3 iface,
LPDDSURFACEDESC pDDSD) LPDDSURFACEDESC pDDSD)
{ {
return IDirectDrawSurface7_GetSurfaceDesc(CONVERT(This), HRESULT retValue = DDERR_GENERIC;
(LPDDSURFACEDESC2)pDDSD);
DX_WINDBG_trace();
if (pDDSD != NULL)
{
DDSURFACEDESC2 pDDSD2;
ZeroMemory(&pDDSD2,sizeof(DDSURFACEDESC2));
memcpy(&pDDSD2, pDDSD, sizeof(DDSURFACEDESC));
pDDSD2.dwSize = sizeof(DDSURFACEDESC2);
retValue = Main_DDrawSurface_GetSurfaceDesc((LPDIRECTDRAWSURFACE7) iface, &pDDSD2);
memcpy(pDDSD, &pDDSD2, sizeof(DDSURFACEDESC));
pDDSD->dwSize = sizeof(DDSURFACEDESC);
}
else
{
retValue = Main_DDrawSurface_GetSurfaceDesc((LPDIRECTDRAWSURFACE7) iface, NULL);
}
return retValue;
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_Initialize(LPDIRECTDRAWSURFACE3 This, LPDIRECTDRAW pDD, Thunk_DDrawSurface3_Initialize(LPDIRECTDRAWSURFACE3 iface, LPDIRECTDRAW pDD,
LPDDSURFACEDESC pDDSD) LPDDSURFACEDESC pDDSD)
{ {
return IDirectDrawSurface7_Initialize(CONVERT(This), pDD, HRESULT retValue = DDERR_GENERIC;
(LPDDSURFACEDESC2)pDDSD); DDSURFACEDESC2 pDDSD2;
DX_WINDBG_trace();
ZeroMemory(&pDDSD2,sizeof(DDSURFACEDESC2));
if (pDDSD != NULL)
{
DDSURFACEDESC2 pDDSD2;
ZeroMemory(&pDDSD2,sizeof(DDSURFACEDESC2));
memcpy(&pDDSD2, pDDSD, sizeof(DDSURFACEDESC));
pDDSD2.dwSize = sizeof(DDSURFACEDESC2);
retValue = Main_DDrawSurface_Initialize((LPDIRECTDRAWSURFACE7) iface, pDD, &pDDSD2);
memcpy(pDDSD, &pDDSD2, sizeof(DDSURFACEDESC));
pDDSD->dwSize = sizeof(DDSURFACEDESC);
}
else
{
retValue = Main_DDrawSurface_Initialize ((LPDIRECTDRAWSURFACE7) iface, pDD, NULL);
}
return retValue;
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_IsLost(LPDIRECTDRAWSURFACE3 This) Thunk_DDrawSurface3_IsLost(LPDIRECTDRAWSURFACE3 iface)
{ {
return IDirectDrawSurface7_IsLost(CONVERT(This)); DX_WINDBG_trace();
return Main_DDrawSurface_IsLost((LPDIRECTDRAWSURFACE7) iface);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_Lock(LPDIRECTDRAWSURFACE3 This, LPRECT pRect, Thunk_DDrawSurface3_Lock(LPDIRECTDRAWSURFACE3 iface, LPRECT pRect,
LPDDSURFACEDESC pDDSD, DWORD dwFlags, HANDLE h) LPDDSURFACEDESC pDDSD, DWORD dwFlags, HANDLE events)
{ {
return IDirectDrawSurface7_Lock(CONVERT(This), pRect,
(LPDDSURFACEDESC2)pDDSD, dwFlags, h); HRESULT retValue = DDERR_GENERIC;
DDSURFACEDESC2 pDDSD2;
DX_WINDBG_trace();
ZeroMemory(&pDDSD2,sizeof(DDSURFACEDESC2));
if (pDDSD != NULL)
{
DDSURFACEDESC2 pDDSD2;
ZeroMemory(&pDDSD2,sizeof(DDSURFACEDESC2));
memcpy(&pDDSD2, pDDSD, sizeof(DDSURFACEDESC));
pDDSD2.dwSize = sizeof(DDSURFACEDESC2);
retValue = Main_DDrawSurface_Lock ( (LPDIRECTDRAWSURFACE7) iface, pRect, &pDDSD2, dwFlags, events);
memcpy(pDDSD, &pDDSD2, sizeof(DDSURFACEDESC));
pDDSD->dwSize = sizeof(DDSURFACEDESC);
}
else
{
retValue = Main_DDrawSurface_Lock ( (LPDIRECTDRAWSURFACE7) iface, pRect, NULL, dwFlags, events);
}
return retValue;
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_ReleaseDC(LPDIRECTDRAWSURFACE3 This, HDC hDC) Thunk_DDrawSurface3_ReleaseDC(LPDIRECTDRAWSURFACE3 iface, HDC hDC)
{ {
return IDirectDrawSurface7_ReleaseDC(CONVERT(This), hDC); DX_WINDBG_trace();
return Main_DDrawSurface_ReleaseDC((LPDIRECTDRAWSURFACE7) iface, hDC);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_Restore(LPDIRECTDRAWSURFACE3 This) Thunk_DDrawSurface3_Restore(LPDIRECTDRAWSURFACE3 iface)
{ {
return IDirectDrawSurface7_Restore(CONVERT(This)); DX_WINDBG_trace();
return Main_DDrawSurface_Restore((LPDIRECTDRAWSURFACE7) iface);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_SetClipper(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_SetClipper(LPDIRECTDRAWSURFACE3 iface, LPDIRECTDRAWCLIPPER pDDClipper)
LPDIRECTDRAWCLIPPER pClipper)
{ {
return IDirectDrawSurface7_SetClipper(CONVERT(This), pClipper); DX_WINDBG_trace();
return Main_DDrawSurface_SetClipper ((LPDIRECTDRAWSURFACE7) iface, pDDClipper);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_SetColorKey(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags, Thunk_DDrawSurface3_SetColorKey(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags,
LPDDCOLORKEY pCKey) LPDDCOLORKEY pCKey)
{ {
return IDirectDrawSurface7_SetColorKey(CONVERT(This), dwFlags, pCKey); DX_WINDBG_trace();
return Main_DDrawSurface_SetColorKey ((LPDIRECTDRAWSURFACE7) iface, dwFlags, pCKey);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_SetOverlayPosition(LPDIRECTDRAWSURFACE3 This, LONG x, Thunk_DDrawSurface3_SetOverlayPosition(LPDIRECTDRAWSURFACE3 iface, LONG X,LONG Y)
LONG y)
{ {
return IDirectDrawSurface7_SetOverlayPosition(CONVERT(This), x, y); DX_WINDBG_trace();
return Main_DDrawSurface_SetOverlayPosition ((LPDIRECTDRAWSURFACE7) iface, X, Y);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_SetPalette(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_SetPalette(LPDIRECTDRAWSURFACE3 iface,
LPDIRECTDRAWPALETTE pPalette) LPDIRECTDRAWPALETTE pPalette)
{ {
return IDirectDrawSurface7_SetPalette(CONVERT(This), pPalette); DX_WINDBG_trace();
return Main_DDrawSurface_SetPalette ((LPDIRECTDRAWSURFACE7) iface, pPalette);
} }
static HRESULT WINAPI /*
IDirectDrawSurface3Impl_Unlock(LPDIRECTDRAWSURFACE3 This, LPVOID data) HRESULT WINAPI
Thunk_DDrawSurface3_Unlock(LPDIRECTDRAWSURFACE3 iface, LPRECT pRect)
{ {
/* data might not be the LPRECT of later versions, so drop it. */ DX_WINDBG_trace();
return IDirectDrawSurface7_Unlock(CONVERT(This), NULL);
} return Main_DDrawSurface_Unlock ((LPDIRECTDRAWSURFACE7) iface, pRect);
} */
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_UpdateOverlay(LPDIRECTDRAWSURFACE3 This, LPRECT prcSrc, Thunk_DDrawSurface3_Unlock(LPVOID iface, LPVOID pRect)
LPDIRECTDRAWSURFACE3 pDstSurf,
LPRECT prcDst, DWORD dwFlags,
LPDDOVERLAYFX pFX)
{ {
return IDirectDrawSurface7_UpdateOverlay(CONVERT(This), prcSrc, DX_WINDBG_trace();
CONVERT(pDstSurf), prcDst, DX_STUB;
dwFlags, pFX);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_UpdateOverlayDisplay(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_UpdateOverlay(LPDIRECTDRAWSURFACE3 iface, LPRECT pSrcRect, LPDIRECTDRAWSURFACE3 pDstSurface,
DWORD dwFlags) LPRECT pDstRect, DWORD dwFlags, LPDDOVERLAYFX pFX)
{ {
return IDirectDrawSurface7_UpdateOverlayDisplay(CONVERT(This), dwFlags);
DX_WINDBG_trace();
return Main_DDrawSurface_UpdateOverlay ( (LPDIRECTDRAWSURFACE7) iface, pSrcRect,
(LPDIRECTDRAWSURFACE7) pDstSurface, pDstRect, dwFlags, pFX);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_UpdateOverlayZOrder(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_UpdateOverlayDisplay(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags)
{
DX_WINDBG_trace();
return Main_DDrawSurface_UpdateOverlayDisplay((LPDIRECTDRAWSURFACE7) iface, dwFlags);
}
HRESULT WINAPI
Thunk_DDrawSurface3_UpdateOverlayZOrder(LPDIRECTDRAWSURFACE3 iface,
DWORD dwFlags, DWORD dwFlags,
LPDIRECTDRAWSURFACE3 pSurfReference) LPDIRECTDRAWSURFACE3 pSurfReference)
{ {
return IDirectDrawSurface7_UpdateOverlayZOrder(CONVERT(This), dwFlags, DX_WINDBG_trace();
CONVERT(pSurfReference)); return Main_DDrawSurface_UpdateOverlayZOrder((LPDIRECTDRAWSURFACE7) iface, dwFlags,
(LPDIRECTDRAWSURFACE7) pSurfReference);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_GetDDInterface(LPDIRECTDRAWSURFACE3 This, LPVOID* ppDD) Thunk_DDrawSurface3_GetDDInterface(LPDIRECTDRAWSURFACE3 iface, LPVOID* ppDD)
{ {
return IDirectDrawSurface7_GetDDInterface(CONVERT(This), ppDD); DX_WINDBG_trace();
return Main_DDrawSurface_GetDDInterface((LPDIRECTDRAWSURFACE7) iface, ppDD);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_PageLock(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags) Thunk_DDrawSurface3_PageLock(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags)
{ {
return IDirectDrawSurface7_PageLock(CONVERT(This), dwFlags); DX_WINDBG_trace();
return Main_DDrawSurface_PageLock((LPDIRECTDRAWSURFACE7) iface, dwFlags);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_PageUnlock(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags) Thunk_DDrawSurface3_PageUnlock(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags)
{ {
return IDirectDrawSurface7_PageUnlock(CONVERT(This), dwFlags); DX_WINDBG_trace();
return Main_DDrawSurface_PageUnlock((LPDIRECTDRAWSURFACE7) iface, dwFlags);
} }
static HRESULT WINAPI HRESULT WINAPI
IDirectDrawSurface3Impl_SetSurfaceDesc(LPDIRECTDRAWSURFACE3 This, Thunk_DDrawSurface3_SetSurfaceDesc(LPDIRECTDRAWSURFACE3 iface,
LPDDSURFACEDESC pDDSD, DWORD dwFlags) LPDDSURFACEDESC pDDSD, DWORD dwFlags)
{ {
return IDirectDrawSurface7_SetSurfaceDesc(CONVERT(This), HRESULT retValue = DDERR_GENERIC;
(LPDDSURFACEDESC2)pDDSD,
dwFlags); DX_WINDBG_trace();
if (pDDSD != NULL)
{
DDSURFACEDESC2 pDDSD2;
ZeroMemory(&pDDSD2,sizeof(DDSURFACEDESC2));
memcpy(&pDDSD2, pDDSD, sizeof(DDSURFACEDESC));
pDDSD2.dwSize = sizeof(DDSURFACEDESC2);
retValue = Main_DDrawSurface_SetSurfaceDesc((LPDIRECTDRAWSURFACE7) iface, &pDDSD2, dwFlags);
memcpy(pDDSD, &pDDSD2, sizeof(DDSURFACEDESC));
pDDSD->dwSize = sizeof(DDSURFACEDESC);
}
else
{
retValue = Main_DDrawSurface_SetSurfaceDesc((LPDIRECTDRAWSURFACE7) iface, NULL, dwFlags);
}
return retValue;
} }
IDirectDrawSurface3Vtbl DDRAW_IDDS3_Thunk_VTable = IDirectDrawSurface3Vtbl DirectDrawSurface3_VTable =
{ {
IDirectDrawSurface3Impl_QueryInterface, Thunk_DDrawSurface3_QueryInterface,
IDirectDrawSurface3Impl_AddRef, Thunk_DDrawSurface3_AddRef,
IDirectDrawSurface3Impl_Release, Thunk_DDrawSurface3_Release,
IDirectDrawSurface3Impl_AddAttachedSurface, Thunk_DDrawSurface3_AddAttachedSurface,
IDirectDrawSurface3Impl_AddOverlayDirtyRect, Thunk_DDrawSurface3_AddOverlayDirtyRect,
IDirectDrawSurface3Impl_Blt, Thunk_DDrawSurface3_Blt,
IDirectDrawSurface3Impl_BltBatch, Thunk_DDrawSurface3_BltBatch,
IDirectDrawSurface3Impl_BltFast, Thunk_DDrawSurface3_BltFast,
IDirectDrawSurface3Impl_DeleteAttachedSurface, Thunk_DDrawSurface3_DeleteAttachedSurface,
IDirectDrawSurface3Impl_EnumAttachedSurfaces, Thunk_DDrawSurface3_EnumAttachedSurfaces,
IDirectDrawSurface3Impl_EnumOverlayZOrders, Thunk_DDrawSurface3_EnumOverlayZOrders,
IDirectDrawSurface3Impl_Flip, Thunk_DDrawSurface3_Flip,
IDirectDrawSurface3Impl_GetAttachedSurface, Thunk_DDrawSurface3_GetAttachedSurface,
IDirectDrawSurface3Impl_GetBltStatus, Thunk_DDrawSurface3_GetBltStatus,
IDirectDrawSurface3Impl_GetCaps, Thunk_DDrawSurface3_GetCaps,
IDirectDrawSurface3Impl_GetClipper, Thunk_DDrawSurface3_GetClipper,
IDirectDrawSurface3Impl_GetColorKey, Thunk_DDrawSurface3_GetColorKey,
IDirectDrawSurface3Impl_GetDC, Thunk_DDrawSurface3_GetDC,
IDirectDrawSurface3Impl_GetFlipStatus, Thunk_DDrawSurface3_GetFlipStatus,
IDirectDrawSurface3Impl_GetOverlayPosition, Thunk_DDrawSurface3_GetOverlayPosition,
IDirectDrawSurface3Impl_GetPalette, Thunk_DDrawSurface3_GetPalette,
IDirectDrawSurface3Impl_GetPixelFormat, Thunk_DDrawSurface3_GetPixelFormat,
IDirectDrawSurface3Impl_GetSurfaceDesc, Thunk_DDrawSurface3_GetSurfaceDesc,
IDirectDrawSurface3Impl_Initialize, Thunk_DDrawSurface3_Initialize,
IDirectDrawSurface3Impl_IsLost, Thunk_DDrawSurface3_IsLost,
IDirectDrawSurface3Impl_Lock, Thunk_DDrawSurface3_Lock,
IDirectDrawSurface3Impl_ReleaseDC, Thunk_DDrawSurface3_ReleaseDC,
IDirectDrawSurface3Impl_Restore, Thunk_DDrawSurface3_Restore,
IDirectDrawSurface3Impl_SetClipper, Thunk_DDrawSurface3_SetClipper,
IDirectDrawSurface3Impl_SetColorKey, Thunk_DDrawSurface3_SetColorKey,
IDirectDrawSurface3Impl_SetOverlayPosition, Thunk_DDrawSurface3_SetOverlayPosition,
IDirectDrawSurface3Impl_SetPalette, Thunk_DDrawSurface3_SetPalette,
IDirectDrawSurface3Impl_Unlock, Thunk_DDrawSurface3_Unlock,
IDirectDrawSurface3Impl_UpdateOverlay, Thunk_DDrawSurface3_UpdateOverlay,
IDirectDrawSurface3Impl_UpdateOverlayDisplay, Thunk_DDrawSurface3_UpdateOverlayDisplay,
IDirectDrawSurface3Impl_UpdateOverlayZOrder, Thunk_DDrawSurface3_UpdateOverlayZOrder,
IDirectDrawSurface3Impl_GetDDInterface, Thunk_DDrawSurface3_GetDDInterface,
IDirectDrawSurface3Impl_PageLock, Thunk_DDrawSurface3_PageLock,
IDirectDrawSurface3Impl_PageUnlock, Thunk_DDrawSurface3_PageUnlock,
IDirectDrawSurface3Impl_SetSurfaceDesc Thunk_DDrawSurface3_SetSurfaceDesc
}; };

101
reactos/dll/directx/ddraw/winedraw.h
View file

@ -1,101 +0,0 @@
/*
* Copyright 2000-2001 TransGaming Technologies Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef _DDCOMIMPL_H_
#define _DDCOMIMPL_H_
#include <stddef.h>
/* Generates the name for a vtable pointer for a given interface. */
/* The canonical name for a single interface is "lpVtbl". */
#define ICOM_VFIELD_MULTI_NAME2(iface) ITF_##iface
#define ICOM_VFIELD_MULTI_NAME(iface) ICOM_VFIELD_MULTI_NAME2(iface)
/* Declares a vtable pointer field in an implementation. */
#define ICOM_VFIELD_MULTI(iface) \
iface ICOM_VFIELD_MULTI_NAME(iface)
/* Returns the offset of a vtable pointer within an implementation object. */
#define ICOM_VFIELD_OFFSET(impltype, iface) \
offsetof(impltype, ICOM_VFIELD_MULTI_NAME(iface))
/* Given an interface pointer, returns the implementation pointer. */
#define ICOM_OBJECT(impltype, ifacename, ifaceptr) \
(impltype*)((ifaceptr) == NULL ? NULL \
: (char*)(ifaceptr) - ICOM_VFIELD_OFFSET(impltype,ifacename))
#define ICOM_THIS_FROM(impltype, ifacename, ifaceptr) \
impltype* This = ICOM_OBJECT(impltype, ifacename, ifaceptr)
/* Given an object and interface name, returns a pointer to that interface. */
#define ICOM_INTERFACE(implobj, iface) \
(&((implobj)->ICOM_VFIELD_MULTI_NAME(iface)))
#define ICOM_INIT_INTERFACE(implobj, ifacename, vtblname) \
do { \
(implobj)->ICOM_VFIELD_MULTI_NAME(ifacename).lpVtbl = &(vtblname); \
} while (0)
#define COM_INTERFACE_CAST(impltype, ifnamefrom, ifnameto, ifaceptr) \
ICOM_INTERFACE(ICOM_OBJECT(impltype, ifnamefrom, ifaceptr), ifnameto)
#endif /* _DDCOMIMPL_H_ */
#ifndef __WINE_DLLS_DDRAW_DDRAW_PRIVATE_H
#define __WINE_DLLS_DDRAW_DDRAW_PRIVATE_H
/* MAY NOT CONTAIN X11 or DGA specific includes/defines/structs! */
#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "wtypes.h"
#include "wingdi.h"
#include "winuser.h"
#include "ddraw.h"
#include "d3d.h"
#include "ddrawi.h"
/*****************************************************************************
* IDirectDraw implementation structure
*/
typedef struct IDirectDrawImpl IDirectDrawImpl;
typedef struct IDirectDrawSurfaceImpl IDirectDrawSurfaceImpl;
struct IDirectDrawImpl
{
ICOM_VFIELD_MULTI(IDirectDraw7);
ICOM_VFIELD_MULTI(IDirectDraw4);
ICOM_VFIELD_MULTI(IDirectDraw2);
ICOM_VFIELD_MULTI(IDirectDraw);
};
/*****************************************************************************
* IDirectDrawSurface implementation structure
*/
struct IDirectDrawSurfaceImpl
{
/* IUnknown fields */
ICOM_VFIELD_MULTI(IDirectDrawSurface7);
ICOM_VFIELD_MULTI(IDirectDrawSurface3);
};
#endif /* __WINE_DLLS_DDRAW_DDRAW_PRIVATE_H */