Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-05 13:11:22 +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
Show stats 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[];

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

@ -15,37 +15,11 @@
VOID
Cleanup(LPDIRECTDRAW7 iface)
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
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);
}
/* FIXME
free all memory and delete all dx stuff
*/
}

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" />
<include base="ddraw">.</include>
<define name="UNICODE" />
<define name="__USE_W32API" />
<define name="WINVER">0x0600</define>
<define name="_WIN32_WINNT">0x0501</define>
<library>ntdll</library>
<library>ntdll</library>
<library>kernel32</library>
<library>gdi32</library>
<library>d3d8thk</library>
@ -17,30 +17,22 @@
<file>ddraw.rc</file>
<file>main.c</file>
<file>regsvr.c</file>
<file>startup.c</file>
<file>cleanup.c</file>
<file>clipper.c</file>
<file>color.c</file>
<file>gamma.c</file>
<file>palette.c</file>
<file>videoport.c</file>
<file>kernel.c</file>
<file>iface_clipper.c</file>
<file>iface_color.c</file>
<file>iface_gamma.c</file>
<file>iface_palette.c</file>
<file>iface_videoport.c</file>
<file>iface_kernel.c</file>
<directory name="hal">
<file>surface_hal.c</file>
</directory>
<file>callbacks_hel.c</file>
<directory name="main">
<file>ddraw_main.c</file>
<file>surface_main.c</file>
</directory>
<directory name="soft">
<file>surface_hel.c</file>
<file>surface_callbacks_hel.c</file>
</directory>
</directory>
<directory name="thunks">
<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$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/clipper.c
* PURPOSE: IDirectDrawClipper Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
ULONG WINAPI
DirectDrawClipper_Release(LPDIRECTDRAWCLIPPER iface)
{
IDirectDrawClipperImpl* This = (IDirectDrawClipperImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedDecrement( (PLONG) &This->ref);
if (ref == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
HeapFree(GetProcessHeap(), 0, This);
}
}
}
return ref;
}
ULONG WINAPI
DirectDrawClipper_AddRef (LPDIRECTDRAWCLIPPER iface)
{
IDirectDrawClipperImpl * This = (IDirectDrawClipperImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedIncrement( (PLONG) &This->ref);
}
return ref;
}
HRESULT WINAPI
DirectDrawClipper_Initialize( LPDIRECTDRAWCLIPPER iface,
LPDIRECTDRAW lpDD,
DWORD dwFlags)
{
/* FIXME not implment */
DX_WINDBG_trace();
DX_STUB_DD_OK;
}
HRESULT WINAPI
DirectDrawClipper_SetHwnd( LPDIRECTDRAWCLIPPER iface,
DWORD dwFlags,
HWND hWnd)
{
/* FIXME not implment */
DX_WINDBG_trace();
DX_STUB_DD_OK;
}
HRESULT WINAPI
DirectDrawClipper_GetClipList( LPDIRECTDRAWCLIPPER iface,
LPRECT lpRect,
LPRGNDATA lpClipList,
LPDWORD lpdwSize)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawClipper_SetClipList( LPDIRECTDRAWCLIPPER iface,
LPRGNDATA lprgn,
DWORD dwFlag)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawClipper_QueryInterface( LPDIRECTDRAWCLIPPER iface,
REFIID riid,
LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawClipper_GetHWnd( LPDIRECTDRAWCLIPPER iface,
HWND* hWndPtr)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawClipper_IsClipListChanged( LPDIRECTDRAWCLIPPER iface,
BOOL* lpbChanged)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawClipperVtbl DirectDrawClipper_Vtable =
{
DirectDrawClipper_QueryInterface,
DirectDrawClipper_AddRef,
DirectDrawClipper_Release,
DirectDrawClipper_GetClipList,
DirectDrawClipper_GetHWnd,
DirectDrawClipper_Initialize,
DirectDrawClipper_IsClipListChanged,
DirectDrawClipper_SetClipList,
DirectDrawClipper_SetHwnd
};
/* $Id: clipper.c 24690 2006-11-05 21:19:53Z greatlrd $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/clipper.c
* PURPOSE: IDirectDrawClipper Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
ULONG WINAPI
DirectDrawClipper_Release(LPDIRECTDRAWCLIPPER iface)
{
LPDDRAWI_DDRAWCLIPPER_INT This = (LPDDRAWI_DDRAWCLIPPER_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedDecrement( (PLONG) &This->dwIntRefCnt);
if (ref == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
HeapFree(GetProcessHeap(), 0, This);
}
}
}
return ref;
}
ULONG WINAPI
DirectDrawClipper_AddRef (LPDIRECTDRAWCLIPPER iface)
{
LPDDRAWI_DDRAWCLIPPER_INT This = (LPDDRAWI_DDRAWCLIPPER_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedIncrement( (PLONG) &This->dwIntRefCnt);
}
return ref;
}
HRESULT WINAPI
DirectDrawClipper_Initialize( LPDIRECTDRAWCLIPPER iface,
LPDIRECTDRAW lpDD,
DWORD dwFlags)
{
/* FIXME not implment */
DX_WINDBG_trace();
DX_STUB_DD_OK;
}
HRESULT WINAPI
DirectDrawClipper_SetHwnd( LPDIRECTDRAWCLIPPER iface,
DWORD dwFlags,
HWND hWnd)
{
/* FIXME not implment */
DX_WINDBG_trace();
DX_STUB_DD_OK;
}
HRESULT WINAPI
DirectDrawClipper_GetClipList( LPDIRECTDRAWCLIPPER iface,
LPRECT lpRect,
LPRGNDATA lpClipList,
LPDWORD lpdwSize)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawClipper_SetClipList( LPDIRECTDRAWCLIPPER iface,
LPRGNDATA lprgn,
DWORD dwFlag)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawClipper_QueryInterface( LPDIRECTDRAWCLIPPER iface,
REFIID riid,
LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawClipper_GetHWnd( LPDIRECTDRAWCLIPPER iface,
HWND* hWndPtr)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawClipper_IsClipListChanged( LPDIRECTDRAWCLIPPER iface,
BOOL* lpbChanged)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawClipperVtbl DirectDrawClipper_Vtable =
{
DirectDrawClipper_QueryInterface,
DirectDrawClipper_AddRef,
DirectDrawClipper_Release,
DirectDrawClipper_GetClipList,
DirectDrawClipper_GetHWnd,
DirectDrawClipper_Initialize,
DirectDrawClipper_IsClipListChanged,
DirectDrawClipper_SetClipList,
DirectDrawClipper_SetHwnd
};

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

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

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

@ -1,89 +1,92 @@
/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/gamma.c
* PURPOSE: IDirectDrawGamma Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
ULONG WINAPI
DirectDrawGammaControl_AddRef( LPDIRECTDRAWGAMMACONTROL iface)
{
IDirectDrawGammaImpl * This = (IDirectDrawGammaImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedIncrement( (PLONG) &This->ref);
}
return ref;
}
ULONG WINAPI
DirectDrawGammaControl_Release( LPDIRECTDRAWGAMMACONTROL iface)
{
IDirectDrawGammaImpl* This = (IDirectDrawGammaImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedDecrement( (PLONG) &This->ref);
if (ref == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
HeapFree(GetProcessHeap(), 0, This);
}
}
}
return ref;
}
HRESULT WINAPI
DirectDrawGammaControl_QueryInterface( LPDIRECTDRAWGAMMACONTROL iface,
REFIID riid,
LPVOID *ppObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawGammaControl_GetGammaRamp( LPDIRECTDRAWGAMMACONTROL iface,
DWORD dwFlags,
LPDDGAMMARAMP lpGammaRamp)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawGammaControl_SetGammaRamp( LPDIRECTDRAWGAMMACONTROL iface,
DWORD dwFlags,
LPDDGAMMARAMP lpGammaRamp)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawGammaControlVtbl DirectDrawGammaControl_Vtable =
{
DirectDrawGammaControl_QueryInterface,
DirectDrawGammaControl_AddRef,
DirectDrawGammaControl_Release,
DirectDrawGammaControl_GetGammaRamp,
DirectDrawGammaControl_SetGammaRamp
};
/* $Id: gamma.c 24690 2006-11-05 21:19:53Z greatlrd $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/gamma.c
* PURPOSE: IDirectDrawGamma Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
ULONG WINAPI
DirectDrawGammaControl_AddRef( LPDIRECTDRAWGAMMACONTROL iface)
{
LPDDRAWI_DDGAMMACONTROL_INT This = (LPDDRAWI_DDGAMMACONTROL_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
This->dwIntRefCnt++;
ref = This->dwIntRefCnt;
}
return ref;
}
ULONG WINAPI
DirectDrawGammaControl_Release( LPDIRECTDRAWGAMMACONTROL iface)
{
LPDDRAWI_DDGAMMACONTROL_INT This = (LPDDRAWI_DDGAMMACONTROL_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
This->dwIntRefCnt--;
if (This->dwIntRefCnt == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
HeapFree(GetProcessHeap(), 0, This);
}
}
ref = This->dwIntRefCnt;
}
return ref;
}
HRESULT WINAPI
DirectDrawGammaControl_QueryInterface( LPDIRECTDRAWGAMMACONTROL iface,
REFIID riid,
LPVOID *ppObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawGammaControl_GetGammaRamp( LPDIRECTDRAWGAMMACONTROL iface,
DWORD dwFlags,
LPDDGAMMARAMP lpGammaRamp)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawGammaControl_SetGammaRamp( LPDIRECTDRAWGAMMACONTROL iface,
DWORD dwFlags,
LPDDGAMMARAMP lpGammaRamp)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawGammaControlVtbl DirectDrawGammaControl_Vtable =
{
DirectDrawGammaControl_QueryInterface,
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$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/kernel.c
* PURPOSE: IDirectDrawKernel and IDirectDrawSurfaceKernel Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
/***** IDirectDrawKernel ****/
ULONG WINAPI
DirectDrawKernel_AddRef ( LPDIRECTDRAWKERNEL iface)
{
IDirectDrawKernelImpl * This = (IDirectDrawKernelImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedIncrement( (PLONG) &This->ref);
}
return ref;
}
ULONG WINAPI
DirectDrawKernel_Release ( LPDIRECTDRAWKERNEL iface)
{
IDirectDrawKernelImpl* This = (IDirectDrawKernelImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedDecrement( (PLONG) &This->ref);
if (ref == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
HeapFree(GetProcessHeap(), 0, This);
}
}
}
return ref;
}
HRESULT WINAPI
DirectDrawKernel_QueryInterface ( LPDIRECTDRAWKERNEL iface,
REFIID riid,
LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawKernel_GetKernelHandle ( LPDIRECTDRAWKERNEL iface,
ULONG* handle)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawKernel_ReleaseKernelHandle ( LPDIRECTDRAWKERNEL iface)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
DDSurfaceKernel_AddRef ( LPDIRECTDRAWSURFACEKERNEL iface)
{
IDirectDrawSurfaceKernelImpl * This = (IDirectDrawSurfaceKernelImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedIncrement( (PLONG) &This->ref);
}
return ref;
}
ULONG WINAPI
DDSurfaceKernel_Release ( LPDIRECTDRAWSURFACEKERNEL iface)
{
IDirectDrawSurfaceKernelImpl* This = (IDirectDrawSurfaceKernelImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedDecrement( (PLONG) &This->ref);
if (ref == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
HeapFree(GetProcessHeap(), 0, This);
}
}
}
return ref;
}
HRESULT WINAPI
DDSurfaceKernel_QueryInterface ( LPDIRECTDRAWSURFACEKERNEL iface,
REFIID riid,
LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DDSurfaceKernel_GetKernelHandle ( LPDIRECTDRAWSURFACEKERNEL iface,
ULONG* handle)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DDSurfaceKernel_ReleaseKernelHandle ( LPDIRECTDRAWSURFACEKERNEL iface)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawKernelVtbl DirectDrawKernel_Vtable =
{
DirectDrawKernel_QueryInterface,
DirectDrawKernel_AddRef,
DirectDrawKernel_Release,
DirectDrawKernel_GetKernelHandle,
DirectDrawKernel_ReleaseKernelHandle
};
IDirectDrawSurfaceKernelVtbl DirectDrawSurfaceKernel_Vtable =
{
DDSurfaceKernel_QueryInterface,
DDSurfaceKernel_AddRef,
DDSurfaceKernel_Release,
DDSurfaceKernel_GetKernelHandle,
DDSurfaceKernel_ReleaseKernelHandle
};
/* $Id: kernel.c 24690 2006-11-05 21:19:53Z greatlrd $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/kernel.c
* PURPOSE: IDirectDrawKernel and IDirectDrawSurfaceKernel Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
/***** IDirectDrawKernel ****/
ULONG WINAPI
DirectDrawKernel_AddRef ( LPDIRECTDRAWKERNEL iface)
{
LPDDRAWI_KERNEL_INT This = (LPDDRAWI_KERNEL_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
This->dwIntRefCnt++;
ref = This->dwIntRefCnt;
}
return ref;
}
ULONG WINAPI
DirectDrawKernel_Release ( LPDIRECTDRAWKERNEL iface)
{
LPDDRAWI_KERNEL_INT This = (LPDDRAWI_KERNEL_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
This->dwIntRefCnt--;
if (This->dwIntRefCnt == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
HeapFree(GetProcessHeap(), 0, This);
}
}
ref = This->dwIntRefCnt;
}
return ref;
}
HRESULT WINAPI
DirectDrawKernel_QueryInterface ( LPDIRECTDRAWKERNEL iface,
REFIID riid,
LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawKernel_GetKernelHandle ( LPDIRECTDRAWKERNEL iface,
ULONG* handle)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawKernel_ReleaseKernelHandle ( LPDIRECTDRAWKERNEL iface)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
DDSurfaceKernel_AddRef ( LPDIRECTDRAWSURFACEKERNEL iface)
{
LPDDRAWI_DDKERNELSURFACE_INT This = (LPDDRAWI_DDKERNELSURFACE_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
This->dwIntRefCnt++;
ref = This->dwIntRefCnt;
}
return ref;
}
ULONG WINAPI
DDSurfaceKernel_Release ( LPDIRECTDRAWSURFACEKERNEL iface)
{
LPDDRAWI_DDKERNELSURFACE_INT This = (LPDDRAWI_DDKERNELSURFACE_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
This->dwIntRefCnt--;
if (This->dwIntRefCnt == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
HeapFree(GetProcessHeap(), 0, This);
}
}
ref = This->dwIntRefCnt;
}
return ref;
}
HRESULT WINAPI
DDSurfaceKernel_QueryInterface ( LPDIRECTDRAWSURFACEKERNEL iface,
REFIID riid,
LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DDSurfaceKernel_GetKernelHandle ( LPDIRECTDRAWSURFACEKERNEL iface,
ULONG* handle)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DDSurfaceKernel_ReleaseKernelHandle ( LPDIRECTDRAWSURFACEKERNEL iface)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawKernelVtbl DirectDrawKernel_Vtable =
{
DirectDrawKernel_QueryInterface,
DirectDrawKernel_AddRef,
DirectDrawKernel_Release,
DirectDrawKernel_GetKernelHandle,
DirectDrawKernel_ReleaseKernelHandle
};
IDirectDrawSurfaceKernelVtbl DirectDrawSurfaceKernel_Vtable =
{
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$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/palette.c
* PURPOSE: IDirectDrawPalette Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
ULONG WINAPI
DirectDrawPalette_Release( LPDIRECTDRAWPALETTE iface)
{
IDirectDrawPaletteImpl* This = (IDirectDrawPaletteImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedDecrement( (PLONG) &This->DDPalette.dwRefCnt);
if (ref == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
DxHeapMemFree(This);
}
}
}
return ref;
}
ULONG WINAPI
DirectDrawPalette_AddRef( LPDIRECTDRAWPALETTE iface)
{
IDirectDrawPaletteImpl * This = (IDirectDrawPaletteImpl*)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedIncrement( (PLONG) &This->DDPalette.dwRefCnt);
}
return ref;
}
HRESULT WINAPI
DirectDrawPalette_Initialize( LPDIRECTDRAWPALETTE iface,
LPDIRECTDRAW ddraw,
DWORD dwFlags,
LPPALETTEENTRY palent)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawPalette_GetEntries( LPDIRECTDRAWPALETTE iface,
DWORD dwFlags,
DWORD dwStart, DWORD dwCount,
LPPALETTEENTRY palent)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawPalette_SetEntries( LPDIRECTDRAWPALETTE iface,
DWORD dwFlags,
DWORD dwStart,
DWORD dwCount,
LPPALETTEENTRY palent)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawPalette_GetCaps( LPDIRECTDRAWPALETTE iface,
LPDWORD lpdwCaps)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawPalette_QueryInterface( LPDIRECTDRAWPALETTE iface,
REFIID refiid,
LPVOID *obj)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawPaletteVtbl DirectDrawPalette_Vtable =
{
DirectDrawPalette_QueryInterface,
DirectDrawPalette_AddRef,
DirectDrawPalette_Release,
DirectDrawPalette_GetCaps,
DirectDrawPalette_GetEntries,
DirectDrawPalette_Initialize,
DirectDrawPalette_SetEntries
};
/* $Id: palette.c 24690 2006-11-05 21:19:53Z greatlrd $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/palette.c
* PURPOSE: IDirectDrawPalette Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
ULONG WINAPI
DirectDrawPalette_Release( LPDIRECTDRAWPALETTE iface)
{
LPDDRAWI_DDRAWPALETTE_INT This = (LPDDRAWI_DDRAWPALETTE_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedDecrement( (PLONG) &This->dwIntRefCnt);
if (ref == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
DxHeapMemFree(This);
}
}
}
return ref;
}
ULONG WINAPI
DirectDrawPalette_AddRef( LPDIRECTDRAWPALETTE iface)
{
LPDDRAWI_DDRAWPALETTE_INT This = (LPDDRAWI_DDRAWPALETTE_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedIncrement( (PLONG) &This->dwIntRefCnt);
}
return ref;
}
HRESULT WINAPI
DirectDrawPalette_Initialize( LPDIRECTDRAWPALETTE iface,
LPDIRECTDRAW ddraw,
DWORD dwFlags,
LPPALETTEENTRY palent)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawPalette_GetEntries( LPDIRECTDRAWPALETTE iface,
DWORD dwFlags,
DWORD dwStart, DWORD dwCount,
LPPALETTEENTRY palent)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawPalette_SetEntries( LPDIRECTDRAWPALETTE iface,
DWORD dwFlags,
DWORD dwStart,
DWORD dwCount,
LPPALETTEENTRY palent)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawPalette_GetCaps( LPDIRECTDRAWPALETTE iface,
LPDWORD lpdwCaps)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
DirectDrawPalette_QueryInterface( LPDIRECTDRAWPALETTE iface,
REFIID refiid,
LPVOID *obj)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawPaletteVtbl DirectDrawPalette_Vtable =
{
DirectDrawPalette_QueryInterface,
DirectDrawPalette_AddRef,
DirectDrawPalette_Release,
DirectDrawPalette_GetCaps,
DirectDrawPalette_GetEntries,
DirectDrawPalette_Initialize,
DirectDrawPalette_SetEntries
};

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

@ -1,261 +1,289 @@
/* $Id$
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/videoport.c
* PURPOSE: IDirectDrawVideoPort, DDVideoPortContainer and IDirectDrawVideoPortNotify Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
/************* IDirectDrawVideoPort *************/
HRESULT WINAPI
Main_DirectDrawVideoPort_QueryInterface (LPDIRECTDRAWVIDEOPORT iface, REFIID riid, LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_DirectDrawVideoPort_AddRef (LPDIRECTDRAWVIDEOPORT iface)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_DirectDrawVideoPort_Release (LPDIRECTDRAWVIDEOPORT iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DirectDrawVideoPort_Flip (LPDIRECTDRAWVIDEOPORT iface, LPDIRECTDRAWSURFACE lpDDSurface, DWORD dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DirectDrawVideoPort_GetBandwidthInfo (LPDIRECTDRAWVIDEOPORT iface, LPDDPIXELFORMAT lpddpfFormat, DWORD dwWidth,
DWORD dwHeight, DWORD dwFlags, LPDDVIDEOPORTBANDWIDTH lpBandwidth)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DirectDrawVideoPort_GetColorControls (LPDIRECTDRAWVIDEOPORT iface, LPDDCOLORCONTROL lpColorControl)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetInputFormats (LPDIRECTDRAWVIDEOPORT iface, LPDWORD lpNumFormats,
LPDDPIXELFORMAT lpFormats, DWORD dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetOutputFormats (LPDIRECTDRAWVIDEOPORT iface, LPDDPIXELFORMAT lpInputFormat,
LPDWORD lpNumFormats, LPDDPIXELFORMAT lpFormats, DWORD dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetFieldPolarity (LPDIRECTDRAWVIDEOPORT iface, LPBOOL lpbFieldPolarity)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetVideoLine (LPDIRECTDRAWVIDEOPORT This, LPDWORD lpdwLine)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetVideoSignalStatus (LPDIRECTDRAWVIDEOPORT iface, LPDWORD lpdwStatus)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_SetColorControls (LPDIRECTDRAWVIDEOPORT iface, LPDDCOLORCONTROL lpColorControl)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_SetTargetSurface (LPDIRECTDRAWVIDEOPORT iface, LPDIRECTDRAWSURFACE lpDDSurface,
DWORD dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_StartVideo (LPDIRECTDRAWVIDEOPORT iface, LPDDVIDEOPORTINFO dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_StopVideo (LPDIRECTDRAWVIDEOPORT iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_UpdateVideo (LPDIRECTDRAWVIDEOPORT iface, LPDDVIDEOPORTINFO dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_WaitForSync (LPDIRECTDRAWVIDEOPORT iface, DWORD dwFlags, DWORD dwLine,
DWORD dwTimeout)
{
DX_WINDBG_trace();
DX_STUB;
}
/************* IDDVideoPortContainer *************/
HRESULT WINAPI Main_DDVideoPortContainer_QueryInterface (LPDDVIDEOPORTCONTAINER iface, REFIID riid, LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI Main_DDVideoPortContainer_AddRef (LPDDVIDEOPORTCONTAINER iface)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI Main_DDVideoPortContainer_Release (LPDDVIDEOPORTCONTAINER iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DDVideoPortContainer_CreateVideoPort (LPDDVIDEOPORTCONTAINER iface, DWORD dwFlags, LPDDVIDEOPORTDESC pPortDesc,
LPDIRECTDRAWVIDEOPORT* DDVideoPort, IUnknown* pUnkOuter)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDVideoPortContainer_EnumVideoPorts (LPDDVIDEOPORTCONTAINER iface,
DWORD dwFlags,
LPDDVIDEOPORTCAPS pCaps,
LPVOID pContext,
LPDDENUMVIDEOCALLBACK pEnumVideoCallback)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDVideoPortContainer_GetVideoPortConnectInfo (LPDDVIDEOPORTCONTAINER iface,
DWORD PortId, DWORD* pNumEntries,
LPDDVIDEOPORTCONNECT pConnectInfo)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDVideoPortContainer_QueryVideoPortStatus (LPDDVIDEOPORTCONTAINER iface,
DWORD PortId,
LPDDVIDEOPORTSTATUS pStatus)
{
DX_WINDBG_trace();
DX_STUB;
}
/************* IDirectDrawVideoPortNotify *************/
HRESULT WINAPI
Main_DDVideoPortNotify_QueryInterface (LPDIRECTDRAWVIDEOPORTNOTIFY iface, REFIID
riid, LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_DDVideoPortNotify_AddRef (LPDIRECTDRAWVIDEOPORTNOTIFY iface)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_DDVideoPortNotify_Release (LPDIRECTDRAWVIDEOPORTNOTIFY iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DDVideoPortNotify_AcquireNotification (LPDIRECTDRAWVIDEOPORTNOTIFY iface, HANDLE* h, LPDDVIDEOPORTNOTIFY pVideoPortNotify)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DDVideoPortNotify_ReleaseNotification (LPDIRECTDRAWVIDEOPORTNOTIFY iface, HANDLE h)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawVideoPortVtbl DirectDrawVideoPort_Vtable =
{
Main_DirectDrawVideoPort_QueryInterface,
Main_DirectDrawVideoPort_AddRef,
Main_DirectDrawVideoPort_Release,
Main_DirectDrawVideoPort_Flip,
Main_DirectDrawVideoPort_GetBandwidthInfo,
Main_DirectDrawVideoPort_GetColorControls,
Main_DirectDrawVideoPort_GetInputFormats,
Main_DirectDrawVideoPort_GetOutputFormats,
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
};
/* $Id: videoport.c 22739 2006-07-01 12:08:35Z greatlrd $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
* FILE: lib/ddraw/main/videoport.c
* PURPOSE: IDirectDrawVideoPort, DDVideoPortContainer and IDirectDrawVideoPortNotify Implementation
* PROGRAMMER: Maarten Bosma
*
*/
#include "rosdraw.h"
/************* IDirectDrawVideoPort *************/
HRESULT WINAPI
Main_DirectDrawVideoPort_QueryInterface (LPDIRECTDRAWVIDEOPORT iface, REFIID riid, LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_DirectDrawVideoPort_AddRef (LPDIRECTDRAWVIDEOPORT iface)
{
LPDDRAWI_DDVIDEOPORT_INT This = (LPDDRAWI_DDVIDEOPORT_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedIncrement( (PLONG) &This->dwIntRefCnt);
}
return ref;
}
ULONG WINAPI
Main_DirectDrawVideoPort_Release (LPDIRECTDRAWVIDEOPORT iface)
{
LPDDRAWI_DDVIDEOPORT_INT This = (LPDDRAWI_DDVIDEOPORT_INT)iface;
ULONG ref=0;
DX_WINDBG_trace();
if (iface!=NULL)
{
ref = InterlockedDecrement( (PLONG) &This->dwIntRefCnt);
if (ref == 0)
{
/* Add here if we need releae some memory pointer before
* exists
*/
if (This!=NULL)
{
DxHeapMemFree(This);
}
}
}
return ref;
}
HRESULT WINAPI
Main_DirectDrawVideoPort_Flip (LPDIRECTDRAWVIDEOPORT iface, LPDIRECTDRAWSURFACE lpDDSurface, DWORD dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DirectDrawVideoPort_GetBandwidthInfo (LPDIRECTDRAWVIDEOPORT iface, LPDDPIXELFORMAT lpddpfFormat, DWORD dwWidth,
DWORD dwHeight, DWORD dwFlags, LPDDVIDEOPORTBANDWIDTH lpBandwidth)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DirectDrawVideoPort_GetColorControls (LPDIRECTDRAWVIDEOPORT iface, LPDDCOLORCONTROL lpColorControl)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetInputFormats (LPDIRECTDRAWVIDEOPORT iface, LPDWORD lpNumFormats,
LPDDPIXELFORMAT lpFormats, DWORD dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetOutputFormats (LPDIRECTDRAWVIDEOPORT iface, LPDDPIXELFORMAT lpInputFormat,
LPDWORD lpNumFormats, LPDDPIXELFORMAT lpFormats, DWORD dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetFieldPolarity (LPDIRECTDRAWVIDEOPORT iface, LPBOOL lpbFieldPolarity)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetVideoLine (LPDIRECTDRAWVIDEOPORT This, LPDWORD lpdwLine)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_GetVideoSignalStatus (LPDIRECTDRAWVIDEOPORT iface, LPDWORD lpdwStatus)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_SetColorControls (LPDIRECTDRAWVIDEOPORT iface, LPDDCOLORCONTROL lpColorControl)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_SetTargetSurface (LPDIRECTDRAWVIDEOPORT iface, LPDIRECTDRAWSURFACE lpDDSurface,
DWORD dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_StartVideo (LPDIRECTDRAWVIDEOPORT iface, LPDDVIDEOPORTINFO dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_StopVideo (LPDIRECTDRAWVIDEOPORT iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_UpdateVideo (LPDIRECTDRAWVIDEOPORT iface, LPDDVIDEOPORTINFO dwFlags)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DirectDrawVideoPort_WaitForSync (LPDIRECTDRAWVIDEOPORT iface, DWORD dwFlags, DWORD dwLine,
DWORD dwTimeout)
{
DX_WINDBG_trace();
DX_STUB;
}
/************* IDDVideoPortContainer *************/
HRESULT WINAPI Main_DDVideoPortContainer_QueryInterface (LPDDVIDEOPORTCONTAINER iface, REFIID riid, LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI Main_DDVideoPortContainer_AddRef (LPDDVIDEOPORTCONTAINER iface)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI Main_DDVideoPortContainer_Release (LPDDVIDEOPORTCONTAINER iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DDVideoPortContainer_CreateVideoPort (LPDDVIDEOPORTCONTAINER iface, DWORD dwFlags, LPDDVIDEOPORTDESC pPortDesc,
LPDIRECTDRAWVIDEOPORT* DDVideoPort, IUnknown* pUnkOuter)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDVideoPortContainer_EnumVideoPorts (LPDDVIDEOPORTCONTAINER iface,
DWORD dwFlags,
LPDDVIDEOPORTCAPS pCaps,
LPVOID pContext,
LPDDENUMVIDEOCALLBACK pEnumVideoCallback)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDVideoPortContainer_GetVideoPortConnectInfo (LPDDVIDEOPORTCONTAINER iface,
DWORD PortId, DWORD* pNumEntries,
LPDDVIDEOPORTCONNECT pConnectInfo)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI
Main_DDVideoPortContainer_QueryVideoPortStatus (LPDDVIDEOPORTCONTAINER iface,
DWORD PortId,
LPDDVIDEOPORTSTATUS pStatus)
{
DX_WINDBG_trace();
DX_STUB;
}
/************* IDirectDrawVideoPortNotify *************/
HRESULT WINAPI
Main_DDVideoPortNotify_QueryInterface (LPDIRECTDRAWVIDEOPORTNOTIFY iface, REFIID
riid, LPVOID* ppvObj)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_DDVideoPortNotify_AddRef (LPDIRECTDRAWVIDEOPORTNOTIFY iface)
{
DX_WINDBG_trace();
DX_STUB;
}
ULONG WINAPI
Main_DDVideoPortNotify_Release (LPDIRECTDRAWVIDEOPORTNOTIFY iface)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DDVideoPortNotify_AcquireNotification (LPDIRECTDRAWVIDEOPORTNOTIFY iface, HANDLE* h, LPDDVIDEOPORTNOTIFY pVideoPortNotify)
{
DX_WINDBG_trace();
DX_STUB;
}
HRESULT WINAPI Main_DDVideoPortNotify_ReleaseNotification (LPDIRECTDRAWVIDEOPORTNOTIFY iface, HANDLE h)
{
DX_WINDBG_trace();
DX_STUB;
}
IDirectDrawVideoPortVtbl DirectDrawVideoPort_Vtable =
{
Main_DirectDrawVideoPort_QueryInterface,
Main_DirectDrawVideoPort_AddRef,
Main_DirectDrawVideoPort_Release,
Main_DirectDrawVideoPort_Flip,
Main_DirectDrawVideoPort_GetBandwidthInfo,
Main_DirectDrawVideoPort_GetColorControls,
Main_DirectDrawVideoPort_GetInputFormats,
Main_DirectDrawVideoPort_GetOutputFormats,
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 "d3dhal.h"
#undef DirectDrawCreate
CRITICAL_SECTION ddcs;
@ -165,8 +166,7 @@ DirectDrawEnumerateExW(LPDDENUMCALLBACKEXW lpCallback,
to get the xxxx end positions.
*/
HRESULT
WINAPI
HRESULT WINAPI
D3DParseUnknownCommand( LPVOID lpCmd,
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)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DX_WINDBG_trace();
return InterlockedIncrement((PLONG)&This->Owner->mDDrawGlobal.dsList->dwIntRefCnt);
DX_WINDBG_trace();
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)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
ULONG ref = InterlockedDecrement((PLONG)&This->Owner->mDDrawGlobal.dsList->dwIntRefCnt);
if (ref == 0)
HeapFree(GetProcessHeap(), 0, This);
LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
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
Main_DDrawSurface_QueryInterface(LPDIRECTDRAWSURFACE7 iface, REFIID riid,
LPVOID* ppObj)
{
DX_WINDBG_trace();
DX_STUB_str("Unimplement\n");
return E_NOINTERFACE;
}
HRESULT WINAPI Main_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst,
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();
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)
{
return Hal_DDrawSurface_Blt( iface, rdst, src, rsrc, dwFlags, lpbltfx);
}
if (rdst != NULL)
{
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,
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();
if (event != NULL)
if (events != NULL)
{
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)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DDHAL_UNLOCKDATA unLock;
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
Main_DDrawSurface_AddAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
LPDIRECTDRAWSURFACE7 pAttach)
{
DWORD ret;
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
IDirectDrawSurfaceImpl* That = (IDirectDrawSurfaceImpl*)pAttach;
// LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
// LPDDRAWI_DDRAWSURFACE_INT That = (LPDDRAWI_DDRAWSURFACE_INT)pAttach;
DX_WINDBG_trace();
if (pAttach==NULL)
{
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;
DX_STUB;
}
/* MSDN: "not currently implemented." */
@ -219,45 +285,9 @@ Main_DDrawSurface_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE7 iface,
LPVOID context,
LPDDENUMSURFACESCALLBACK7 cb)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
IDirectDrawSurfaceImpl *surf;
DDSURFACEDESC2 desc;
DX_WINDBG_trace();
DX_WINDBG_trace();
/*
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;
DX_STUB;
}
HRESULT WINAPI
@ -272,18 +302,11 @@ Main_DDrawSurface_EnumOverlayZOrders(LPDIRECTDRAWSURFACE7 iface,
HRESULT WINAPI
Main_DDrawSurface_Flip(LPDIRECTDRAWSURFACE7 iface,
LPDIRECTDRAWSURFACE7 override, DWORD dwFlags)
LPDIRECTDRAWSURFACE7 lpDDSurfaceTargetOverride, DWORD dwFlags)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
DX_WINDBG_trace();
DX_WINDBG_trace();
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_FLIP)
{
return Hal_DDrawSurface_Flip(iface, override, dwFlags);
}
return Hel_DDrawSurface_Flip(iface, override, dwFlags);
DX_STUB;
}
HRESULT WINAPI
@ -299,86 +322,33 @@ Main_DDrawSurface_GetAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
LPDDSCAPS2 pCaps,
LPDIRECTDRAWSURFACE7* ppSurface)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
IDirectDrawSurfaceImpl *surf;
DDSCAPS2 our_caps;
//LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
//LPDDRAWI_DDRAWSURFACE_INT surf;
DX_WINDBG_trace();
/*
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;
DX_STUB;
}
HRESULT WINAPI
Main_DDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
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
Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps)
{
IDirectDrawSurfaceImpl* This;
LPDDRAWI_DDRAWSURFACE_INT This;
DX_WINDBG_trace();
@ -392,10 +362,11 @@ Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps)
return DDERR_INVALIDPARAMS;
}
This = (IDirectDrawSurfaceImpl*)iface;
This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
RtlZeroMemory(pCaps,sizeof(DDSCAPS2));
pCaps->dwCaps = This->Surf->mddsdPrimary.ddsCaps.dwCaps;
pCaps->dwCaps = This->lpLcl->ddsCaps.dwCaps;
return DD_OK;
}
@ -403,8 +374,7 @@ Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps)
HRESULT WINAPI
Main_DDrawSurface_GetClipper(LPDIRECTDRAWSURFACE7 iface,
LPDIRECTDRAWCLIPPER* ppClipper)
{
DX_WINDBG_trace();
{
DX_STUB;
}
@ -413,7 +383,9 @@ HRESULT WINAPI
Main_DDrawSurface_GetColorKey(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags,
LPDDCOLORKEY pCKey)
{
DX_WINDBG_trace();
//LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DX_WINDBG_trace();
DX_STUB;
}
@ -421,7 +393,7 @@ Main_DDrawSurface_GetColorKey(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags,
HRESULT WINAPI
Main_DDrawSurface_GetDC(LPDIRECTDRAWSURFACE7 iface, HDC *phDC)
{
IDirectDrawSurfaceImpl* This;
LPDDRAWI_DDRAWSURFACE_INT This;
DX_WINDBG_trace();
@ -435,21 +407,21 @@ Main_DDrawSurface_GetDC(LPDIRECTDRAWSURFACE7 iface, HDC *phDC)
return DDERR_INVALIDPARAMS;
}
This = (IDirectDrawSurfaceImpl*)iface;
This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
/*
FIXME check if the surface exists or not
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);
*phDC = (HDC)This->Surf->mPrimaryLocal.hDC;
This->lpLcl->hDC = (ULONG_PTR)GetDC((HWND)This->lpLcl->lpGbl->lpDD->lpExclusiveOwner->hWnd);
*phDC = (HDC)This->lpLcl->hDC;
}
else
{
*phDC = (HDC)This->Surf->mpPrimaryLocals[0]->hDC;
*phDC = (HDC)This->lpLcl->hDC;
}
return DD_OK;
@ -528,7 +500,9 @@ Main_DDrawSurface_GetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface,
LPDDSURFACEDESC2 pDDSD)
{
DWORD dwSize;
IDirectDrawSurfaceImpl *This = (IDirectDrawSurfaceImpl *)iface;
LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DX_WINDBG_trace();
dwSize = pDDSD->dwSize;
@ -538,10 +512,87 @@ Main_DDrawSurface_GetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface,
{
return DDERR_GENERIC;
}
RtlZeroMemory(pDDSD,dwSize);
memcpy(pDDSD, &This->Surf->mddsdPrimary, sizeof(DDSURFACEDESC));
pDDSD->dwSize = dwSize;
ZeroMemory(pDDSD,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;
}
@ -584,7 +635,7 @@ Main_DDrawSurface_PageUnlock(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
HRESULT WINAPI
Main_DDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7 iface, HDC hDC)
{
IDirectDrawSurfaceImpl* This;
LPDDRAWI_DDRAWSURFACE_INT This;
DX_WINDBG_trace();
if (iface == NULL)
@ -597,17 +648,16 @@ Main_DDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7 iface, HDC hDC)
return DDERR_INVALIDPARAMS;
}
This = (IDirectDrawSurfaceImpl*)iface;
This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
/* FIXME check if surface exits or not */
if ((HDC)This->Surf->mPrimaryLocal.hDC == NULL)
if ((HDC)This->lpLcl->hDC == NULL)
{
return DDERR_GENERIC;
}
ReleaseDC((HWND)This->Owner->mDDrawGlobal.lpExclusiveOwner->hWnd,hDC);
return DD_OK;
}
@ -624,27 +674,72 @@ HRESULT WINAPI
Main_DDrawSurface_SetColorKey (LPDIRECTDRAWSURFACE7 iface,
DWORD dwFlags, LPDDCOLORKEY pCKey)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
DDHAL_SETCOLORKEYDATA ColorKeyData;
DX_WINDBG_trace();
if (This->Owner->mCallbacks.HALDDSurface.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)
{
return Hal_DDrawSurface_SetColorKey (iface, dwFlags, pCKey);
}
ColorKeyData.ddRVal = DDERR_COLORKEYNOTSET;
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
Main_DDrawSurface_SetOverlayPosition (LPDIRECTDRAWSURFACE7 iface,
LONG X, LONG Y)
Main_DDrawSurface_SetOverlayPosition (LPDIRECTDRAWSURFACE7 iface, 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
@ -692,16 +787,16 @@ HRESULT WINAPI
Main_DDrawSurface_UpdateOverlayDisplay (LPDIRECTDRAWSURFACE7 iface,
DWORD dwFlags)
{
IDirectDrawSurfaceImpl* This = (IDirectDrawSurfaceImpl*)iface;
LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
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,
@ -712,11 +807,29 @@ HRESULT WINAPI Main_DDrawSurface_UpdateOverlayZOrder (LPDIRECTDRAWSURFACE7 iface
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 =
{
/*** IUnknown ***/
Main_DDrawSurface_QueryInterface,
Main_DDrawSurface_AddRef,
Main_DDrawSurface_Release,
/*** IDirectDrawSurface ***/
Main_DDrawSurface_AddAttachedSurface,
Main_DDrawSurface_AddOverlayDirtyRect,
Main_DDrawSurface_Blt,
@ -749,5 +862,22 @@ IDirectDrawSurface7Vtbl DirectDrawSurface7_Vtable =
Main_DDrawSurface_Unlock,
Main_DDrawSurface_UpdateOverlay,
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 <stdio.h>
#include <ddraw.h>
#include <ddrawi.h>
#include <d3dhal.h>
#include <ddrawgdi.h>
/* 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 StartDirectDrawHel(LPDIRECTDRAW* iface);
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 ReleaseDDThreadLock();
HRESULT WINAPI Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 iface, REFIID id, LPVOID *obj);
ULONG WINAPI Main_DirectDraw_AddRef (LPDIRECTDRAW7 iface);
ULONG WINAPI Main_DirectDraw_Release (LPDIRECTDRAW7 iface);
HRESULT WINAPI Main_DirectDraw_Compact (LPDIRECTDRAW7 iface);
HRESULT WINAPI Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 , REFIID , LPVOID *);
ULONG WINAPI Main_DirectDraw_AddRef(LPDIRECTDRAW7 );
ULONG WINAPI Main_DirectDraw_Release(LPDIRECTDRAW7 );
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,
DWORD dwFlags,
LPDIRECTDRAWCLIPPER *ppClipper,
IUnknown *pUnkOuter);
HRESULT WINAPI Main_DirectDraw_EnumSurfaces(LPDIRECTDRAW7, DWORD, LPDDSURFACEDESC2, LPVOID,
LPDDENUMSURFACESCALLBACK7);
HRESULT WINAPI Main_DirectDraw_CreatePalette (LPDIRECTDRAW7 iface,
DWORD dwFlags,
LPPALETTEENTRY palent,
LPDIRECTDRAWPALETTE* ppPalette,
LPUNKNOWN pUnkOuter);
HRESULT WINAPI Main_DirectDraw_FlipToGDISurface(LPDIRECTDRAW7);
HRESULT WINAPI Main_DirectDraw_GetDisplayMode(LPDIRECTDRAW7, LPDDSURFACEDESC2);
HRESULT WINAPI Main_DirectDraw_GetSurfaceFromDC(LPDIRECTDRAW7, HDC, LPDIRECTDRAWSURFACE7 *);
HRESULT WINAPI Main_DirectDraw_GetCaps(LPDIRECTDRAW7, LPDDCAPS pDriverCaps, LPDDCAPS);
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
{
/* Setup the Vtbl COM table */
IDirectDraw7Vtbl* lpVtbl;
IDirectDraw4Vtbl* lpVtbl_v4;
IDirectDraw2Vtbl* lpVtbl_v2;
IDirectDrawVtbl* lpVtbl_v1;
ULONG Ref;
/* The main struct that contain all info from the HAL and HEL */
HDC hdc;
DDRAWI_DIRECTDRAW_GBL mDDrawGlobal;
DDRAWI_DIRECTDRAW_LCL mDDrawLocal;
DDHALINFO mHALInfo;
DDHAL_CALLBACKS mCallbacks;
DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks;
D3DHAL_CALLBACKS mD3dCallbacks;
D3DHAL_GLOBALDRIVERDATA mD3dDriverData;
UINT mcModeInfos;
DDHALMODEINFO *mpModeInfos;
UINT mcvmList;
VIDMEM *mpvmList;
UINT mcFourCC;
DWORD *mpFourCC;
UINT mcTextures;
DDSURFACEDESC *mpTextures;
ULONG WINAPI Main_DDrawSurface_AddRef(LPDIRECTDRAWSURFACE7);
ULONG WINAPI Main_DDrawSurface_Release(LPDIRECTDRAWSURFACE7);
HRESULT WINAPI Main_DDrawSurface_QueryInterface(LPDIRECTDRAWSURFACE7, REFIID, LPVOID*);
HRESULT WINAPI Main_DDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7, HDC);
HRESULT WINAPI Main_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7, LPRECT, LPDIRECTDRAWSURFACE7, LPRECT, DWORD, LPDDBLTFX);
HRESULT WINAPI Main_DDrawSurface_BltBatch(LPDIRECTDRAWSURFACE7, LPDDBLTBATCH, DWORD, DWORD);
HRESULT WINAPI Main_DDrawSurface_BltFast(LPDIRECTDRAWSURFACE7, DWORD, DWORD, LPDIRECTDRAWSURFACE7, LPRECT, DWORD);
HRESULT WINAPI Main_DDrawSurface_DeleteAttachedSurface(LPDIRECTDRAWSURFACE7, DWORD, LPDIRECTDRAWSURFACE7);
HRESULT WINAPI Main_DDrawSurface_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE7, LPVOID, LPDDENUMSURFACESCALLBACK7);
HRESULT WINAPI Main_DDrawSurface_EnumOverlayZOrders(LPDIRECTDRAWSURFACE7, DWORD, LPVOID,LPDDENUMSURFACESCALLBACK7);
HRESULT WINAPI Main_DDrawSurface_Flip(LPDIRECTDRAWSURFACE7 , LPDIRECTDRAWSURFACE7, DWORD);
HRESULT WINAPI Main_DDrawSurface_FreePrivateData(LPDIRECTDRAWSURFACE7, REFGUID);
HRESULT WINAPI Main_DDrawSurface_GetAttachedSurface(LPDIRECTDRAWSURFACE7, LPDDSCAPS2, LPDIRECTDRAWSURFACE7*);
HRESULT WINAPI Main_DDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7, DWORD dwFlags);
HRESULT WINAPI Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7, LPDDSCAPS2 pCaps);
HRESULT WINAPI Main_DDrawSurface_GetClipper(LPDIRECTDRAWSURFACE7, LPDIRECTDRAWCLIPPER*);
HRESULT WINAPI Main_DDrawSurface_GetColorKey(LPDIRECTDRAWSURFACE7, DWORD, LPDDCOLORKEY);
HRESULT WINAPI Main_DDrawSurface_GetDC(LPDIRECTDRAWSURFACE7, HDC *);
HRESULT WINAPI Main_DDrawSurface_GetDDInterface(LPDIRECTDRAWSURFACE7, LPVOID*);
HRESULT WINAPI Main_DDrawSurface_GetFlipStatus(LPDIRECTDRAWSURFACE7, DWORD);
HRESULT WINAPI Main_DDrawSurface_GetLOD(LPDIRECTDRAWSURFACE7, LPDWORD);
HRESULT WINAPI Main_DDrawSurface_GetOverlayPosition(LPDIRECTDRAWSURFACE7, LPLONG, LPLONG);
HRESULT WINAPI Main_DDrawSurface_GetPalette(LPDIRECTDRAWSURFACE7, LPDIRECTDRAWPALETTE*);
HRESULT WINAPI Main_DDrawSurface_GetPixelFormat(LPDIRECTDRAWSURFACE7, LPDDPIXELFORMAT);
HRESULT WINAPI Main_DDrawSurface_GetPriority(LPDIRECTDRAWSURFACE7, LPDWORD);
HRESULT WINAPI Main_DDrawSurface_GetPrivateData(LPDIRECTDRAWSURFACE7, REFGUID, LPVOID, LPDWORD);
HRESULT WINAPI Main_DDrawSurface_GetSurfaceDesc(LPDIRECTDRAWSURFACE7, LPDDSURFACEDESC2);
HRESULT WINAPI Main_DDrawSurface_GetUniquenessValue(LPDIRECTDRAWSURFACE7, LPDWORD);
HRESULT WINAPI Main_DDrawSurface_IsLost(LPDIRECTDRAWSURFACE7);
HRESULT WINAPI Main_DDrawSurface_PageLock(LPDIRECTDRAWSURFACE7, DWORD);
HRESULT WINAPI Main_DDrawSurface_PageUnlock(LPDIRECTDRAWSURFACE7, DWORD);
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 */
DWORD cooperative_level;
ULONG WINAPI DirectDrawClipper_AddRef (LPDIRECTDRAWCLIPPER iface);
HRESULT WINAPI DirectDrawClipper_Initialize( LPDIRECTDRAWCLIPPER iface, LPDIRECTDRAW lpDD, DWORD dwFlags);
BOOL InitializeDraw;
/* HEL stuff */
DWORD HELMemoryAvilable;
/* DirectDraw Object struct
/* DD Callbacks info */
DDHAL_DESTROYDRIVERDATA mDdDestroyDriver;
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_DIRECTDRAW_INT
it is the the return pointer from ddraw.dll to the program
DDRAWI_DDRAWSURFACE_MORE mPrimaryMore;
DDRAWI_DDRAWSURFACE_LCL mPrimaryLocal;
DDRAWI_DDRAWSURFACE_LCL *mpPrimaryLocals[1];
DDRAWI_DDRAWCLIPPER_LCL mPrimaryClipperLocal;
DDRAWI_DDRAWCLIPPER_GBL mPrimaryClipperGlobal;
DDRAWI_DIRECTDRAW_LCL
It is the program own private data
DDSURFACEDESC2 mddsdPrimary;
DDRAWI_DDRAWSURFACE_LCL *mpInUseSurfaceLocals[1];
/*
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;
DDRAWI_DIRECTDRAW_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
IDirectDrawImpl* Owner;
The struct
DDRAWI_DDRAWSURFACE_GBL Global;
DDRAWI_DDRAWSURFACE_MORE More;
DDRAWI_DDRAWSURFACE_LCL Local;
DDRAWI_DDRAWSURFACE_LCL *pLocal[2];
DDSURFACEDESC ddsd;
from http://msdn2.microsoft.com/en-us/library/ms898267.aspx
it was not document for windows 2000/xp/2003 but ms did document it
for windows ce 5.0 the link are to windows ce 5.0 arch
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;
LONG ref;
LPVOID lpVtbl;
LPDDRAWI_DDGAMMACONTROL_LCL lpLcl;
LPDDRAWI_DDGAMMACONTROL_INT lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DDGAMMACONTROL_INT, *LPDDRAWI_DDGAMMACONTROL_INT
IDirectDrawImpl* owner;
} IDirectDrawClipperImpl;
/******** Palette Object ********/
typedef struct
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
the DDRAWI_DDGAMMACONTROL_LCL works and DDRAWI_DDCOLORCONTROL_GBL
our internal struct will look like this
typedef struct _DDRAWI_DDGAMMACONTROL_INT
{
IDirectDrawPaletteVtbl* lpVtbl;
IDirectDrawImpl* owner;
DDRAWI_DDRAWPALETTE_GBL DDPalette;
} IDirectDrawPaletteImpl;
LPVOID lpVtbl;
LPVOID lpLcl;
LPVOID lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DDGAMMACONTROL_INT, *LPDDRAWI_DDGAMMACONTROL_INT
/******** Gamma Object ********/
same goes for DDRAWI_DDCOLORCONTROL_INT
typedef struct
typedef struct DDRAWI_DDCOLORCONTROL_INT
{
IDirectDrawGammaControlVtbl* lpVtbl;
LONG ref;
IDirectDrawImpl* Owner;
IDirectDrawSurfaceImpl* Surf;
LPVOID lpVtbl;
LPVOID lpLcl;
LPVOID lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DDCOLORCONTROL_INT, *LPDDRAWI_DDCOLORCONTROL_INT
*/
} IDirectDrawGammaImpl;
/******** Color Object ********/
typedef struct
typedef struct DDRAWI_DDCOLORCONTROL_INT
{
IDirectDrawColorControlVtbl* lpVtbl;
LONG ref;
IDirectDrawImpl* Owner;
IDirectDrawSurfaceImpl* Surf;
LPVOID lpVtbl;
LPVOID lpLcl;
LPVOID lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DDCOLORCONTROL_INT, *LPDDRAWI_DDCOLORCONTROL_INT;
} IDirectDrawColorImpl;
/******** Kernel Object ********/
typedef struct
typedef struct _DDRAWI_DDGAMMACONTROL_INT
{
IDirectDrawKernelVtbl* lpVtbl;
LONG ref;
IDirectDrawImpl* Owner;
IDirectDrawSurfaceImpl* Surf;
LPVOID lpVtbl;
LPVOID lpLcl;
LPVOID lpLink;
DWORD dwIntRefCnt;
} DDRAWI_DDGAMMACONTROL_INT, *LPDDRAWI_DDGAMMACONTROL_INT;
} IDirectDrawKernelImpl;
/******** SurfaceKernel Object ********/
typedef struct
typedef struct _DDRAWI_DDKERNEL_INT
{
IDirectDrawSurfaceKernelVtbl* lpVtbl;
LONG ref;
IDirectDrawImpl* Owner;
IDirectDrawSurfaceImpl* Surf;
IDirectDrawKernelImpl * Kernl;
LPVOID lpVtbl;
LPVOID lpLcl;
LPVOID lpLink;
DWORD dwIntRefCnt;
} 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 ************/
extern IDirectDrawVtbl DirectDraw_Vtable;
extern IDirectDraw2Vtbl DirectDraw2_Vtable;
extern IDirectDraw4Vtbl DirectDraw4_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 IDirectDrawSurface3Vtbl DDRAW_IDDS3_Thunk_VTable;
extern IDirectDrawSurface3Vtbl DirectDrawSurface3_VTable;
extern IDirectDrawPaletteVtbl DirectDrawPalette_Vtable;
extern IDirectDrawClipperVtbl DirectDrawClipper_Vtable;
@ -265,6 +519,12 @@ extern IDirectDrawKernelVtbl DirectDrawKernel_Vtable;
extern IDirectDrawSurfaceKernelVtbl DirectDrawSurfaceKernel_Vtable;
/********* 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);

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 "d3dhal.h"
DDRAWI_DIRECTDRAW_GBL ddgbl;
DDRAWI_DDRAWSURFACE_GBL ddSurfGbl;
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 hel_ret;
DEVMODE devmode;
@ -24,22 +27,27 @@ StartDirectDraw(LPDIRECTDRAW* iface)
const UINT bmiSize = sizeof(BITMAPINFOHEADER) + 0x10;
UCHAR *pbmiData;
BITMAPINFO *pbmi;
DWORD *pMasks;
DWORD Flags;
DWORD *pMasks;
INT devicetypes = 0;
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 */
This->mcModeInfos = 1;
This->mpModeInfos = (DDHALMODEINFO*) DxHeapMemAlloc(This->mcModeInfos * sizeof(DDHALMODEINFO));
if (This->mpModeInfos == NULL)
This->lpLcl->lpGbl->lpModeInfo = (DDHALMODEINFO*) DxHeapMemAlloc(1 * sizeof(DDHALMODEINFO));
if (This->lpLcl->lpGbl->lpModeInfo == NULL)
{
DX_STUB_str("DD_FALSE");
return DD_FALSE;
@ -47,37 +55,68 @@ StartDirectDraw(LPDIRECTDRAW* iface)
EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode);
This->mpModeInfos[0].dwWidth = devmode.dmPelsWidth;
This->mpModeInfos[0].dwHeight = devmode.dmPelsHeight;
This->mpModeInfos[0].dwBPP = devmode.dmBitsPerPel;
This->mpModeInfos[0].lPitch = (devmode.dmPelsWidth*devmode.dmBitsPerPel)/8;
This->mpModeInfos[0].wRefreshRate = (WORD)devmode.dmDisplayFrequency;
This->lpLcl->lpGbl->lpModeInfo[0].dwWidth = devmode.dmPelsWidth;
This->lpLcl->lpGbl->lpModeInfo[0].dwHeight = devmode.dmPelsHeight;
This->lpLcl->lpGbl->lpModeInfo[0].dwBPP = devmode.dmBitsPerPel;
This->lpLcl->lpGbl->lpModeInfo[0].lPitch = (devmode.dmPelsWidth*devmode.dmBitsPerPel)/8;
This->lpLcl->lpGbl->lpModeInfo[0].wRefreshRate = (WORD)devmode.dmDisplayFrequency;
if ( This->devicetype <3 )
{
/* Create HDC for default, hal and hel driver */
This->hdc = CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL);
if (lpGuid == 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
{
/* FIXME : need getting driver from the GUID that have been pass in from
the register. we do not support that yet
*/
This->hdc = NULL ;
devicetypes = 4;
This->lpLcl->hDC = (ULONG_PTR) NULL ;
}
if (This->hdc == NULL)
if ( (HDC)This->lpLcl->hDC == NULL)
{
DX_STUB_str("DDERR_OUTOFMEMORY");
return DDERR_OUTOFMEMORY ;
}
hbmp = CreateCompatibleBitmap(This->hdc, 1, 1);
hbmp = CreateCompatibleBitmap((HDC) This->lpLcl->hDC, 1, 1);
if (hbmp==NULL)
{
DxHeapMemFree(This->mpModeInfos);
DeleteDC(This->hdc);
DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC) This->lpLcl->hDC);
DX_STUB_str("DDERR_OUTOFMEMORY");
return DDERR_OUTOFMEMORY;
}
@ -87,8 +126,8 @@ StartDirectDraw(LPDIRECTDRAW* iface)
if (pbmiData==NULL)
{
DxHeapMemFree(This->mpModeInfos);
DeleteDC(This->hdc);
DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC) This->lpLcl->hDC);
DeleteObject(hbmp);
DX_STUB_str("DDERR_OUTOFMEMORY");
return DDERR_OUTOFMEMORY;
@ -100,28 +139,24 @@ StartDirectDraw(LPDIRECTDRAW* iface)
pbmi->bmiHeader.biWidth = 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);
pMasks = (DWORD*)(pbmiData + sizeof(BITMAPINFOHEADER));
This->mpModeInfos[0].dwRBitMask = pMasks[0];
This->mpModeInfos[0].dwGBitMask = pMasks[1];
This->mpModeInfos[0].dwBBitMask = pMasks[2];
This->mpModeInfos[0].dwAlphaBitMask = pMasks[3];
This->lpLcl->lpGbl->lpModeInfo[0].dwRBitMask = pMasks[0];
This->lpLcl->lpGbl->lpModeInfo[0].dwGBitMask = pMasks[1];
This->lpLcl->lpGbl->lpModeInfo[0].dwBBitMask = pMasks[2];
This->lpLcl->lpGbl->lpModeInfo[0].dwAlphaBitMask = pMasks[3];
DxHeapMemFree(pbmiData);
/* Startup HEL and HAL */
RtlZeroMemory(&This->mDDrawGlobal, sizeof(DDRAWI_DIRECTDRAW_GBL));
RtlZeroMemory(&This->mHALInfo, sizeof(DDHALINFO));
RtlZeroMemory(&This->mCallbacks, sizeof(DDHAL_CALLBACKS));
// RtlZeroMemory(&ddgbl, sizeof(DDRAWI_DIRECTDRAW_GBL));
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);
hel_ret = StartDirectDrawHel(iface);
@ -131,101 +166,16 @@ StartDirectDraw(LPDIRECTDRAW* iface)
return DDERR_NODIRECTDRAWSUPPORT;
}
/*
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;
}
This->lpLcl->hDD = This->lpLcl->lpGbl->hDD;
if (Flags & DDHAL_CB32_SETCOLORKEY)
{
// This->mDdSetColorKey.SetColorKey = This->mCallbacks.HALDD.SetColorKey;
}
}
/*
Setup HEL or HAL for SURFACE CALLBACK
*/
/* Fixme the mix betwin hel and hal */
// FIXME
/* Setup calback struct so we do not need refill same info again */
This->mDdCreateSurface.lpDD = &This->mDDrawGlobal;
This->mDdCanCreateSurface.lpDD = &This->mDDrawGlobal;
This->mDDrawLocal.lpGbl = &This->mDDrawGlobal;
/* Fill some basic info for Surface */
ddSurfGbl.lpDD = &ddgbl;
return DD_OK;
}
@ -233,30 +183,46 @@ StartDirectDraw(LPDIRECTDRAW* iface)
HRESULT WINAPI
StartDirectDrawHal(LPDIRECTDRAW* iface)
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
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 */
BOOL newmode = FALSE;
RtlZeroMemory(&mHALInfo, sizeof(DDHALINFO));
RtlZeroMemory(&mCallbacks, sizeof(DDHAL_CALLBACKS));
/*
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);
DeleteDC(This->hdc);
DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC)This->lpLcl->hDC);
return DD_FALSE;
}
// Do not relase HDC it have been map in kernel mode
// DeleteDC(hdc);
if (!DdReenableDirectDrawObject(&This->mDDrawGlobal, &newmode))
if (!DdReenableDirectDrawObject(This->lpLcl->lpGbl, &newmode))
{
DxHeapMemFree(This->mpModeInfos);
DeleteDC(This->hdc);
DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC)This->lpLcl->hDC);
return DD_FALSE;
}
@ -265,80 +231,80 @@ StartDirectDrawHal(LPDIRECTDRAW* iface)
Startup DX HAL step two of three
*/
if (!DdQueryDirectDrawObject(&This->mDDrawGlobal,
&This->mHALInfo,
&This->mCallbacks.HALDD,
&This->mCallbacks.HALDDSurface,
&This->mCallbacks.HALDDPalette,
&This->mD3dCallbacks,
&This->mD3dDriverData,
&This->mD3dBufferCallbacks,
if (!DdQueryDirectDrawObject(This->lpLcl->lpGbl,
&mHALInfo,
&mCallbacks.HALDD,
&mCallbacks.HALDDSurface,
&mCallbacks.HALDDPalette,
&mD3dCallbacks,
&mD3dDriverData,
&mD3dBufferCallbacks,
NULL,
NULL,
NULL))
{
DxHeapMemFree(This->mpModeInfos);
DeleteDC(This->hdc);
DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call
return DD_FALSE;
}
This->mcvmList = This->mHALInfo.vmiData.dwNumHeaps;
This->mpvmList = (VIDMEM*) DxHeapMemAlloc(sizeof(VIDMEM) * This->mcvmList);
if (This->mpvmList == NULL)
mcvmList = mHALInfo.vmiData.dwNumHeaps;
mpvmList = (VIDMEM*) DxHeapMemAlloc(sizeof(VIDMEM) * mcvmList);
if (mpvmList == NULL)
{
DxHeapMemFree(This->mpModeInfos);
DeleteDC(This->hdc);
DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call
return DD_FALSE;
}
This->mcFourCC = This->mHALInfo.ddCaps.dwNumFourCCCodes;
This->mpFourCC = (DWORD *) DxHeapMemAlloc(sizeof(DWORD) * This->mcFourCC);
if (This->mpFourCC == NULL)
mcFourCC = mHALInfo.ddCaps.dwNumFourCCCodes;
mpFourCC = (DWORD *) DxHeapMemAlloc(sizeof(DWORD) * mcFourCC);
if (mpFourCC == NULL)
{
DxHeapMemFree(This->mpvmList);
DxHeapMemFree(This->mpModeInfos);
DeleteDC(This->hdc);
DxHeapMemFree(mpvmList);
DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call
return DD_FALSE;
}
This->mcTextures = This->mD3dDriverData.dwNumTextureFormats;
This->mpTextures = (DDSURFACEDESC*) DxHeapMemAlloc(sizeof(DDSURFACEDESC) * This->mcTextures);
if (This->mpTextures == NULL)
mcTextures = mD3dDriverData.dwNumTextureFormats;
mpTextures = (DDSURFACEDESC*) DxHeapMemAlloc(sizeof(DDSURFACEDESC) * mcTextures);
if (mpTextures == NULL)
{
DxHeapMemFree( This->mpFourCC);
DxHeapMemFree( This->mpvmList);
DxHeapMemFree( This->mpModeInfos);
DeleteDC(This->hdc);
DxHeapMemFree( mpFourCC);
DxHeapMemFree( mpvmList);
DxHeapMemFree( This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call
return DD_FALSE;
}
This->mHALInfo.vmiData.pvmList = This->mpvmList;
This->mHALInfo.lpdwFourCC = This->mpFourCC;
This->mD3dDriverData.lpTextureFormats = (DDSURFACEDESC*) This->mpTextures;
mHALInfo.vmiData.pvmList = mpvmList;
mHALInfo.lpdwFourCC = mpFourCC;
mD3dDriverData.lpTextureFormats = (DDSURFACEDESC*) mpTextures;
if (!DdQueryDirectDrawObject(
&This->mDDrawGlobal,
&This->mHALInfo,
&This->mCallbacks.HALDD,
&This->mCallbacks.HALDDSurface,
&This->mCallbacks.HALDDPalette,
&This->mD3dCallbacks,
&This->mD3dDriverData,
&This->mCallbacks.HALDDExeBuf,
(DDSURFACEDESC*)This->mpTextures,
This->mpFourCC,
This->mpvmList))
This->lpLcl->lpGbl,
&mHALInfo,
&mCallbacks.HALDD,
&mCallbacks.HALDDSurface,
&mCallbacks.HALDDPalette,
&mD3dCallbacks,
&mD3dDriverData,
&mCallbacks.HALDDExeBuf,
(DDSURFACEDESC*)mpTextures,
mpFourCC,
mpvmList))
{
DxHeapMemFree(This->mpTextures);
DxHeapMemFree(This->mpFourCC);
DxHeapMemFree(This->mpvmList);
DxHeapMemFree(This->mpModeInfos);
DeleteDC(This->hdc);
DxHeapMemFree(mpTextures);
DxHeapMemFree(mpFourCC);
DxHeapMemFree(mpvmList);
DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
DeleteDC((HDC)This->lpLcl->hDC);
// FIXME Close DX fristcall and second call
return DD_FALSE;
}
@ -350,84 +316,69 @@ StartDirectDrawHal(LPDIRECTDRAW* iface)
// this is wrong, cDriverName need be in ASC code not UNICODE
//memcpy(mDDrawGlobal.cDriverName, mDisplayAdapter, sizeof(wchar)*MAX_DRIVER_NAME);
memcpy(&This->mDDrawGlobal.vmiData, &This->mHALInfo.vmiData,sizeof(VIDMEMINFO));
memcpy(&This->mDDrawGlobal.ddCaps, &This->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;
memcpy(&ddgbl.vmiData, &mHALInfo.vmiData,sizeof(VIDMEMINFO));
memcpy(&ddgbl.ddCaps, &mHALInfo.ddCaps,sizeof(DDCORECAPS));
This->mDDrawGlobal.lp16DD = &This->mDDrawGlobal;
//DeleteDC(This->hdc);
mHALInfo.dwNumModes = 1;
mHALInfo.lpModeInfo = This->lpLcl->lpGbl->lpModeInfo;
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));
DriverInfo.dwSize = sizeof(DDHAL_GETDRIVERINFODATA);
DriverInfo.dwContext = This->mDDrawGlobal.hDD;
DriverInfo.dwContext = This->lpLcl->lpGbl->hDD;
/* Get the MiscellaneousCallbacks */
DriverInfo.guidInfo = GUID_MiscellaneousCallbacks;
DriverInfo.lpvData = &This->mDDrawGlobal.lpDDCBtmp->HALDDMiscellaneous;
DriverInfo.lpvData = &ddgbl.lpDDCBtmp->HALDDMiscellaneous;
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;
}
HRESULT WINAPI
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->mCallbacks.HELDD.dwFlags = DDHAL_CB32_DESTROYDRIVER;
This->mCallbacks.HELDD.DestroyDriver = HelDdDestroyDriver;
This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_CREATESURFACE;
This->mCallbacks.HELDD.CreateSurface = HelDdCreateSurface;
// DDHAL_CB32_
//This->mCallbacks.HELDD.SetColorKey = HelDdSetColorKey;
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;
This->lpLcl->lpDDCB->HELDD.dwFlags = DDHAL_CB32_CANCREATESURFACE |
DDHAL_CB32_CREATESURFACE |
DDHAL_CB32_CREATEPALETTE |
DDHAL_CB32_DESTROYDRIVER |
// DDHAL_CB32_FLIPTOGDISURFACE |
DDHAL_CB32_GETSCANLINE |
// DDHAL_CB32_SETCOLORKEY |
DDHAL_CB32_SETEXCLUSIVEMODE |
DDHAL_CB32_SETMODE |
DDHAL_CB32_WAITFORVERTICALBLANK ;
return DD_OK;
}
@ -437,64 +388,43 @@ Create_DirectDraw (LPGUID pGUID,
LPDIRECTDRAW* pIface,
REFIID id,
BOOL ex)
{
IDirectDrawImpl* This;
{
LPDDRAWI_DIRECTDRAW_INT This;
DX_WINDBG_trace();
//AcquireDDThreadLock();
This = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
This = DxHeapMemAlloc(sizeof(DDRAWI_DIRECTDRAW_INT));
if (This == NULL)
{
ReleaseDDThreadLock();
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->lpVtbl_v1 = &DDRAW_IDirectDraw_VTable;
This->lpVtbl_v2 = &DDRAW_IDirectDraw2_VTable;
This->lpVtbl_v4 = &DDRAW_IDirectDraw4_VTable;
This->lpLcl->lpGbl = &ddgbl;
*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)
{
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();
if(Main_DirectDraw_QueryInterface((LPDIRECTDRAW7)This, id, (void**)&pIface) != S_OK)
{
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;
}

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
IDirectDrawSurface3Impl_QueryInterface(LPDIRECTDRAWSURFACE3 This, REFIID iid,
HRESULT WINAPI
Thunk_DDrawSurface3_QueryInterface(LPDIRECTDRAWSURFACE3 iface, REFIID iid,
LPVOID *ppObj)
{
return IDirectDrawSurface7_QueryInterface(CONVERT(This), iid, ppObj);
DX_WINDBG_trace();
return Main_DDrawSurface_QueryInterface((LPDIRECTDRAWSURFACE7) iface, iid, ppObj);
}
static ULONG WINAPI
IDirectDrawSurface3Impl_AddRef(LPDIRECTDRAWSURFACE3 This)
ULONG WINAPI
Thunk_DDrawSurface3_AddRef(LPDIRECTDRAWSURFACE3 iface)
{
return IDirectDrawSurface7_AddRef(CONVERT(This));
DX_WINDBG_trace();
return Main_DDrawSurface_AddRef((LPDIRECTDRAWSURFACE7) iface);
}
static ULONG WINAPI
IDirectDrawSurface3Impl_Release(LPDIRECTDRAWSURFACE3 This)
ULONG WINAPI
Thunk_DDrawSurface3_Release(LPDIRECTDRAWSURFACE3 iface)
{
return IDirectDrawSurface7_Release(CONVERT(This));
DX_WINDBG_trace();
return Main_DDrawSurface_Release((LPDIRECTDRAWSURFACE7) iface);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_AddAttachedSurface(LPDIRECTDRAWSURFACE3 This,
LPDIRECTDRAWSURFACE3 pAttach)
HRESULT WINAPI
Thunk_DDrawSurface3_AddAttachedSurface(LPDIRECTDRAWSURFACE3 iface, LPDIRECTDRAWSURFACE3 pAttach)
{
return IDirectDrawSurface7_AddAttachedSurface(CONVERT(This),
CONVERT(pAttach));
DX_WINDBG_trace();
return Main_DDrawSurface_AddAttachedSurface((LPDIRECTDRAWSURFACE7) iface, (LPDIRECTDRAWSURFACE7) pAttach);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_AddOverlayDirtyRect(LPDIRECTDRAWSURFACE3 This,
LPRECT pRect)
HRESULT WINAPI
Thunk_DDrawSurface3_AddOverlayDirtyRect(LPDIRECTDRAWSURFACE3 iface, LPRECT pRect)
{
return IDirectDrawSurface7_AddOverlayDirtyRect(CONVERT(This), pRect);
DX_WINDBG_trace();
return Main_DDrawSurface_AddOverlayDirtyRect((LPDIRECTDRAWSURFACE7) iface, pRect);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_Blt(LPDIRECTDRAWSURFACE3 This, LPRECT prcDst,
LPDIRECTDRAWSURFACE3 pSrcSurf, LPRECT prcSrc,
HRESULT WINAPI
Thunk_DDrawSurface3_Blt(LPDIRECTDRAWSURFACE3 iface, LPRECT rdst,
LPDIRECTDRAWSURFACE3 src, LPRECT rsrc,
DWORD dwFlags, LPDDBLTFX pFX)
{
return IDirectDrawSurface7_Blt(CONVERT(This), prcDst, CONVERT(pSrcSurf),
prcSrc, dwFlags, pFX);
DX_WINDBG_trace();
return Main_DDrawSurface_Blt((LPDIRECTDRAWSURFACE7) iface, rdst,(LPDIRECTDRAWSURFACE7) src, rsrc, dwFlags, pFX);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_BltBatch(LPDIRECTDRAWSURFACE3 This,
LPDDBLTBATCH pBatch, DWORD dwCount,
DWORD dwFlags)
HRESULT WINAPI
Thunk_DDrawSurface3_BltBatch(LPDIRECTDRAWSURFACE3 iface, LPDDBLTBATCH pBatch, DWORD dwCount, DWORD dwFlags)
{
return IDirectDrawSurface7_BltBatch(CONVERT(This), pBatch, dwCount,
dwFlags);
DX_WINDBG_trace();
return Main_DDrawSurface_BltBatch((LPDIRECTDRAWSURFACE7) iface, pBatch, dwCount, dwFlags);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_BltFast(LPDIRECTDRAWSURFACE3 This, DWORD x, DWORD y,
LPDIRECTDRAWSURFACE3 pSrcSurf, LPRECT prcSrc,
DWORD dwTrans)
HRESULT WINAPI
Thunk_DDrawSurface3_BltFast(LPDIRECTDRAWSURFACE3 iface, DWORD dstx, DWORD dsty,
LPDIRECTDRAWSURFACE3 src, LPRECT rsrc, DWORD dwTrans)
{
return IDirectDrawSurface7_BltFast(CONVERT(This), x, y, CONVERT(pSrcSurf),
prcSrc, dwTrans);
DX_WINDBG_trace();
return Main_DDrawSurface_BltFast((LPDIRECTDRAWSURFACE7) iface, dstx, dsty,
(LPDIRECTDRAWSURFACE7)src, rsrc, dwTrans);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_DeleteAttachedSurface(LPDIRECTDRAWSURFACE3 This,
DWORD dwFlags,
LPDIRECTDRAWSURFACE3 pAttached)
HRESULT WINAPI
Thunk_DDrawSurface3_DeleteAttachedSurface(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags, LPDIRECTDRAWSURFACE3 pAttached)
{
return IDirectDrawSurface7_DeleteAttachedSurface(CONVERT(This), dwFlags,
CONVERT(pAttached));
DX_WINDBG_trace();
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
/* This is an outgoing conversion so we have to do it. */
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,
HRESULT WINAPI
Thunk_DDrawSurface3_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE3 iface,
LPVOID context,
LPDDENUMSURFACESCALLBACK callback)
{
struct callback_info info;
LPDDENUMSURFACESCALLBACK cb)
{
DX_WINDBG_trace();
info.callback = callback;
info.context = context;
return IDirectDrawSurface7_EnumAttachedSurfaces(CONVERT(This), &info,
EnumCallback);
return Main_DDrawSurface_EnumAttachedSurfaces((LPDIRECTDRAWSURFACE7) iface,
context, (LPDDENUMSURFACESCALLBACK7)cb);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_EnumOverlayZOrders(LPDIRECTDRAWSURFACE3 This,
HRESULT WINAPI
Thunk_DDrawSurface3_EnumOverlayZOrders(LPDIRECTDRAWSURFACE3 iface,
DWORD dwFlags, LPVOID context,
LPDDENUMSURFACESCALLBACK callback)
LPDDENUMSURFACESCALLBACK cb)
{
struct callback_info info;
DX_WINDBG_trace();
info.callback = callback;
info.context = context;
return IDirectDrawSurface7_EnumOverlayZOrders(CONVERT(This), dwFlags,
&info, EnumCallback);
return Main_DDrawSurface_EnumOverlayZOrders( (LPDIRECTDRAWSURFACE7) iface, dwFlags, context,
(LPDDENUMSURFACESCALLBACK7) cb);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_Flip(LPDIRECTDRAWSURFACE3 This,
LPDIRECTDRAWSURFACE3 pOverride, DWORD dwFlags)
HRESULT WINAPI
Thunk_DDrawSurface3_Flip(LPDIRECTDRAWSURFACE3 iface,
LPDIRECTDRAWSURFACE3 lpDDSurfaceTargetOverride, DWORD dwFlags)
{
return IDirectDrawSurface7_Flip(CONVERT(This), CONVERT(pOverride),
dwFlags);
DX_WINDBG_trace();
return Main_DDrawSurface_Flip( (LPDIRECTDRAWSURFACE7)iface, (LPDIRECTDRAWSURFACE7) lpDDSurfaceTargetOverride,
dwFlags);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetAttachedSurface(LPDIRECTDRAWSURFACE3 This,
HRESULT WINAPI
Thunk_DDrawSurface3_GetAttachedSurface(LPDIRECTDRAWSURFACE3 iface,
LPDDSCAPS pCaps,
LPDIRECTDRAWSURFACE3* ppAttached)
{
DDSCAPS2 caps;
LPDIRECTDRAWSURFACE7 pAttached7;
HRESULT hr;
DDSCAPS2 caps;
HRESULT hr = DDERR_GENERIC;
caps.dwCaps = pCaps->dwCaps;
caps.dwCaps2 = 0;
caps.dwCaps3 = 0;
caps.dwCaps4 = 0;
DX_WINDBG_trace();
hr = IDirectDrawSurface7_GetAttachedSurface(CONVERT(This), &caps,
&pAttached7);
if (FAILED(hr)) return hr;
ZeroMemory(&caps,sizeof(DDSCAPS2));
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;
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetBltStatus(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags)
HRESULT WINAPI
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
IDirectDrawSurface3Impl_GetCaps(LPDIRECTDRAWSURFACE3 This, LPDDSCAPS pCaps)
HRESULT WINAPI
Thunk_DDrawSurface3_GetCaps(LPDIRECTDRAWSURFACE3 iface, LPDDSCAPS pCaps)
{
DDSCAPS2 caps;
HRESULT hr;
HRESULT hr = DDERR_GENERIC;
hr = IDirectDrawSurface7_GetCaps(CONVERT(This), &caps);
if (FAILED(hr)) return hr;
DX_WINDBG_trace();
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;
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetClipper(LPDIRECTDRAWSURFACE3 This,
HRESULT WINAPI
Thunk_DDrawSurface3_GetClipper(LPDIRECTDRAWSURFACE3 iface,
LPDIRECTDRAWCLIPPER* ppClipper)
{
return IDirectDrawSurface7_GetClipper(CONVERT(This), ppClipper);
DX_WINDBG_trace();
return Main_DDrawSurface_GetClipper((LPDIRECTDRAWSURFACE7) iface, ppClipper);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetColorKey(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags,
HRESULT WINAPI
Thunk_DDrawSurface3_GetColorKey(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags,
LPDDCOLORKEY pCKey)
{
return IDirectDrawSurface7_GetColorKey(CONVERT(This), dwFlags, pCKey);
DX_WINDBG_trace();
return Main_DDrawSurface_GetColorKey( (LPDIRECTDRAWSURFACE7) iface, dwFlags, pCKey);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetDC(LPDIRECTDRAWSURFACE3 This, HDC* phDC)
HRESULT WINAPI
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
IDirectDrawSurface3Impl_GetFlipStatus(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags)
HRESULT WINAPI
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
IDirectDrawSurface3Impl_GetOverlayPosition(LPDIRECTDRAWSURFACE3 This, LPLONG pX,
LPLONG pY)
HRESULT WINAPI
Thunk_DDrawSurface3_GetOverlayPosition(LPDIRECTDRAWSURFACE3 iface, LPLONG pX, LPLONG pY)
{
return IDirectDrawSurface7_GetOverlayPosition(CONVERT(This), pX, pY);
DX_WINDBG_trace();
return Main_DDrawSurface_GetOverlayPosition((LPDIRECTDRAWSURFACE7) iface, pX, pY);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetPalette(LPDIRECTDRAWSURFACE3 This,
HRESULT WINAPI
Thunk_DDrawSurface3_GetPalette(LPDIRECTDRAWSURFACE3 iface,
LPDIRECTDRAWPALETTE* ppPalette)
{
return IDirectDrawSurface7_GetPalette(CONVERT(This), ppPalette);
DX_WINDBG_trace();
return Main_DDrawSurface_GetPalette((LPDIRECTDRAWSURFACE7) iface, ppPalette);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetPixelFormat(LPDIRECTDRAWSURFACE3 This,
LPDDPIXELFORMAT pPixelFormat)
HRESULT WINAPI
Thunk_DDrawSurface3_GetPixelFormat(LPDIRECTDRAWSURFACE3 iface,
LPDDPIXELFORMAT pDDPixelFormat)
{
return IDirectDrawSurface7_GetPixelFormat(CONVERT(This), pPixelFormat);
DX_WINDBG_trace();
return Main_DDrawSurface_GetPixelFormat((LPDIRECTDRAWSURFACE7) iface, pDDPixelFormat);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetSurfaceDesc(LPDIRECTDRAWSURFACE3 This,
HRESULT WINAPI
Thunk_DDrawSurface3_GetSurfaceDesc(LPDIRECTDRAWSURFACE3 iface,
LPDDSURFACEDESC pDDSD)
{
return IDirectDrawSurface7_GetSurfaceDesc(CONVERT(This),
(LPDDSURFACEDESC2)pDDSD);
HRESULT retValue = DDERR_GENERIC;
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
IDirectDrawSurface3Impl_Initialize(LPDIRECTDRAWSURFACE3 This, LPDIRECTDRAW pDD,
HRESULT WINAPI
Thunk_DDrawSurface3_Initialize(LPDIRECTDRAWSURFACE3 iface, LPDIRECTDRAW pDD,
LPDDSURFACEDESC pDDSD)
{
return IDirectDrawSurface7_Initialize(CONVERT(This), pDD,
(LPDDSURFACEDESC2)pDDSD);
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_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
IDirectDrawSurface3Impl_IsLost(LPDIRECTDRAWSURFACE3 This)
HRESULT WINAPI
Thunk_DDrawSurface3_IsLost(LPDIRECTDRAWSURFACE3 iface)
{
return IDirectDrawSurface7_IsLost(CONVERT(This));
DX_WINDBG_trace();
return Main_DDrawSurface_IsLost((LPDIRECTDRAWSURFACE7) iface);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_Lock(LPDIRECTDRAWSURFACE3 This, LPRECT pRect,
LPDDSURFACEDESC pDDSD, DWORD dwFlags, HANDLE h)
HRESULT WINAPI
Thunk_DDrawSurface3_Lock(LPDIRECTDRAWSURFACE3 iface, LPRECT pRect,
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
IDirectDrawSurface3Impl_ReleaseDC(LPDIRECTDRAWSURFACE3 This, HDC hDC)
HRESULT WINAPI
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
IDirectDrawSurface3Impl_Restore(LPDIRECTDRAWSURFACE3 This)
HRESULT WINAPI
Thunk_DDrawSurface3_Restore(LPDIRECTDRAWSURFACE3 iface)
{
return IDirectDrawSurface7_Restore(CONVERT(This));
DX_WINDBG_trace();
return Main_DDrawSurface_Restore((LPDIRECTDRAWSURFACE7) iface);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_SetClipper(LPDIRECTDRAWSURFACE3 This,
LPDIRECTDRAWCLIPPER pClipper)
HRESULT WINAPI
Thunk_DDrawSurface3_SetClipper(LPDIRECTDRAWSURFACE3 iface, LPDIRECTDRAWCLIPPER pDDClipper)
{
return IDirectDrawSurface7_SetClipper(CONVERT(This), pClipper);
DX_WINDBG_trace();
return Main_DDrawSurface_SetClipper ((LPDIRECTDRAWSURFACE7) iface, pDDClipper);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_SetColorKey(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags,
HRESULT WINAPI
Thunk_DDrawSurface3_SetColorKey(LPDIRECTDRAWSURFACE3 iface, DWORD dwFlags,
LPDDCOLORKEY pCKey)
{
return IDirectDrawSurface7_SetColorKey(CONVERT(This), dwFlags, pCKey);
DX_WINDBG_trace();
return Main_DDrawSurface_SetColorKey ((LPDIRECTDRAWSURFACE7) iface, dwFlags, pCKey);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_SetOverlayPosition(LPDIRECTDRAWSURFACE3 This, LONG x,
LONG y)
HRESULT WINAPI
Thunk_DDrawSurface3_SetOverlayPosition(LPDIRECTDRAWSURFACE3 iface, LONG X,LONG Y)
{
return IDirectDrawSurface7_SetOverlayPosition(CONVERT(This), x, y);
DX_WINDBG_trace();
return Main_DDrawSurface_SetOverlayPosition ((LPDIRECTDRAWSURFACE7) iface, X, Y);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_SetPalette(LPDIRECTDRAWSURFACE3 This,
HRESULT WINAPI
Thunk_DDrawSurface3_SetPalette(LPDIRECTDRAWSURFACE3 iface,
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. */
return IDirectDrawSurface7_Unlock(CONVERT(This), NULL);
}
DX_WINDBG_trace();
return Main_DDrawSurface_Unlock ((LPDIRECTDRAWSURFACE7) iface, pRect);
} */
static HRESULT WINAPI
IDirectDrawSurface3Impl_UpdateOverlay(LPDIRECTDRAWSURFACE3 This, LPRECT prcSrc,
LPDIRECTDRAWSURFACE3 pDstSurf,
LPRECT prcDst, DWORD dwFlags,
LPDDOVERLAYFX pFX)
HRESULT WINAPI
Thunk_DDrawSurface3_Unlock(LPVOID iface, LPVOID pRect)
{
return IDirectDrawSurface7_UpdateOverlay(CONVERT(This), prcSrc,
CONVERT(pDstSurf), prcDst,
dwFlags, pFX);
DX_WINDBG_trace();
DX_STUB;
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_UpdateOverlayDisplay(LPDIRECTDRAWSURFACE3 This,
DWORD dwFlags)
HRESULT WINAPI
Thunk_DDrawSurface3_UpdateOverlay(LPDIRECTDRAWSURFACE3 iface, LPRECT pSrcRect, LPDIRECTDRAWSURFACE3 pDstSurface,
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
IDirectDrawSurface3Impl_UpdateOverlayZOrder(LPDIRECTDRAWSURFACE3 This,
HRESULT WINAPI
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,
LPDIRECTDRAWSURFACE3 pSurfReference)
{
return IDirectDrawSurface7_UpdateOverlayZOrder(CONVERT(This), dwFlags,
CONVERT(pSurfReference));
DX_WINDBG_trace();
return Main_DDrawSurface_UpdateOverlayZOrder((LPDIRECTDRAWSURFACE7) iface, dwFlags,
(LPDIRECTDRAWSURFACE7) pSurfReference);
}
static HRESULT WINAPI
IDirectDrawSurface3Impl_GetDDInterface(LPDIRECTDRAWSURFACE3 This, LPVOID* ppDD)
HRESULT WINAPI
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
IDirectDrawSurface3Impl_PageLock(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags)
HRESULT WINAPI
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
IDirectDrawSurface3Impl_PageUnlock(LPDIRECTDRAWSURFACE3 This, DWORD dwFlags)
HRESULT WINAPI
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
IDirectDrawSurface3Impl_SetSurfaceDesc(LPDIRECTDRAWSURFACE3 This,
HRESULT WINAPI
Thunk_DDrawSurface3_SetSurfaceDesc(LPDIRECTDRAWSURFACE3 iface,
LPDDSURFACEDESC pDDSD, DWORD dwFlags)
{
return IDirectDrawSurface7_SetSurfaceDesc(CONVERT(This),
(LPDDSURFACEDESC2)pDDSD,
dwFlags);
HRESULT retValue = DDERR_GENERIC;
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,
IDirectDrawSurface3Impl_AddRef,
IDirectDrawSurface3Impl_Release,
IDirectDrawSurface3Impl_AddAttachedSurface,
IDirectDrawSurface3Impl_AddOverlayDirtyRect,
IDirectDrawSurface3Impl_Blt,
IDirectDrawSurface3Impl_BltBatch,
IDirectDrawSurface3Impl_BltFast,
IDirectDrawSurface3Impl_DeleteAttachedSurface,
IDirectDrawSurface3Impl_EnumAttachedSurfaces,
IDirectDrawSurface3Impl_EnumOverlayZOrders,
IDirectDrawSurface3Impl_Flip,
IDirectDrawSurface3Impl_GetAttachedSurface,
IDirectDrawSurface3Impl_GetBltStatus,
IDirectDrawSurface3Impl_GetCaps,
IDirectDrawSurface3Impl_GetClipper,
IDirectDrawSurface3Impl_GetColorKey,
IDirectDrawSurface3Impl_GetDC,
IDirectDrawSurface3Impl_GetFlipStatus,
IDirectDrawSurface3Impl_GetOverlayPosition,
IDirectDrawSurface3Impl_GetPalette,
IDirectDrawSurface3Impl_GetPixelFormat,
IDirectDrawSurface3Impl_GetSurfaceDesc,
IDirectDrawSurface3Impl_Initialize,
IDirectDrawSurface3Impl_IsLost,
IDirectDrawSurface3Impl_Lock,
IDirectDrawSurface3Impl_ReleaseDC,
IDirectDrawSurface3Impl_Restore,
IDirectDrawSurface3Impl_SetClipper,
IDirectDrawSurface3Impl_SetColorKey,
IDirectDrawSurface3Impl_SetOverlayPosition,
IDirectDrawSurface3Impl_SetPalette,
IDirectDrawSurface3Impl_Unlock,
IDirectDrawSurface3Impl_UpdateOverlay,
IDirectDrawSurface3Impl_UpdateOverlayDisplay,
IDirectDrawSurface3Impl_UpdateOverlayZOrder,
IDirectDrawSurface3Impl_GetDDInterface,
IDirectDrawSurface3Impl_PageLock,
IDirectDrawSurface3Impl_PageUnlock,
IDirectDrawSurface3Impl_SetSurfaceDesc
Thunk_DDrawSurface3_QueryInterface,
Thunk_DDrawSurface3_AddRef,
Thunk_DDrawSurface3_Release,
Thunk_DDrawSurface3_AddAttachedSurface,
Thunk_DDrawSurface3_AddOverlayDirtyRect,
Thunk_DDrawSurface3_Blt,
Thunk_DDrawSurface3_BltBatch,
Thunk_DDrawSurface3_BltFast,
Thunk_DDrawSurface3_DeleteAttachedSurface,
Thunk_DDrawSurface3_EnumAttachedSurfaces,
Thunk_DDrawSurface3_EnumOverlayZOrders,
Thunk_DDrawSurface3_Flip,
Thunk_DDrawSurface3_GetAttachedSurface,
Thunk_DDrawSurface3_GetBltStatus,
Thunk_DDrawSurface3_GetCaps,
Thunk_DDrawSurface3_GetClipper,
Thunk_DDrawSurface3_GetColorKey,
Thunk_DDrawSurface3_GetDC,
Thunk_DDrawSurface3_GetFlipStatus,
Thunk_DDrawSurface3_GetOverlayPosition,
Thunk_DDrawSurface3_GetPalette,
Thunk_DDrawSurface3_GetPixelFormat,
Thunk_DDrawSurface3_GetSurfaceDesc,
Thunk_DDrawSurface3_Initialize,
Thunk_DDrawSurface3_IsLost,
Thunk_DDrawSurface3_Lock,
Thunk_DDrawSurface3_ReleaseDC,
Thunk_DDrawSurface3_Restore,
Thunk_DDrawSurface3_SetClipper,
Thunk_DDrawSurface3_SetColorKey,
Thunk_DDrawSurface3_SetOverlayPosition,
Thunk_DDrawSurface3_SetPalette,
Thunk_DDrawSurface3_Unlock,
Thunk_DDrawSurface3_UpdateOverlay,
Thunk_DDrawSurface3_UpdateOverlayDisplay,
Thunk_DDrawSurface3_UpdateOverlayZOrder,
Thunk_DDrawSurface3_GetDDInterface,
Thunk_DDrawSurface3_PageLock,
Thunk_DDrawSurface3_PageUnlock,
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 */