BOOL INTERNAL_CALL
DD_Cleanup(PVOID ObjectBody)
{
- PDD_DIRECTDRAW pDD = (PDD_DIRECTDRAW)ObjectBody;
- pDD->DrvDisableDirectDraw(pDD->Global.dhpdev);
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(ObjectBody, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("DD_Cleanup\n");
+
+ if (!pDirectDraw)
+ return FALSE;
+
+ pDirectDraw->DrvDisableDirectDraw(pDirectDraw->Global.dhpdev);
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return TRUE;
}
DD_CALLBACKS callbacks;
DD_SURFACECALLBACKS surface_callbacks;
DD_PALETTECALLBACKS palette_callbacks;
-
- RtlZeroMemory(&callbacks, sizeof(callbacks));
- callbacks.dwSize = sizeof(callbacks);
- RtlZeroMemory(&surface_callbacks, sizeof(surface_callbacks));
- surface_callbacks.dwSize = sizeof(surface_callbacks);
- RtlZeroMemory(&palette_callbacks, sizeof(palette_callbacks));
- palette_callbacks.dwSize = sizeof(palette_callbacks);
-
+ DPRINT1("NtGdiDdCreateDirectDrawObject\n");
+
+ RtlZeroMemory(&callbacks, sizeof(DD_CALLBACKS));
+ callbacks.dwSize = sizeof(DD_CALLBACKS);
+ RtlZeroMemory(&surface_callbacks, sizeof(DD_SURFACECALLBACKS));
+ surface_callbacks.dwSize = sizeof(DD_SURFACECALLBACKS);
+ RtlZeroMemory(&palette_callbacks, sizeof(DD_PALETTECALLBACKS));
+ palette_callbacks.dwSize = sizeof(DD_PALETTECALLBACKS);
+
+ /* FIXME hdc can be zero for d3d9 */
+ /* we need create it, if in that case */
+ if (hdc == NULL)
+ {
+ return NULL;
+ }
+
DC *pDC = DC_LockDc(hdc);
if (!pDC)
return NULL;
if (!success)
{
+ DPRINT1("DirectDraw creation failed\n");
// DirectDraw creation failed
DC_UnlockDc(pDC);
return NULL;
if (!hDirectDraw)
{
/* No more memmory */
+ DPRINT1("No more memmory\n");
DC_UnlockDc(pDC);
return NULL;
}
if (!pDirectDraw)
{
/* invalid handle */
+ DPRINT1("invalid handle\n");
DC_UnlockDc(pDC);
return NULL;
}
pDirectDraw->DrvGetDirectDrawInfo = pDC->DriverFunctions.GetDirectDrawInfo;
pDirectDraw->DrvDisableDirectDraw = pDC->DriverFunctions.DisableDirectDraw;
+
+ /* DD_CALLBACKS setup */
+ RtlMoveMemory(&pDirectDraw->DD, &callbacks, sizeof(DD_CALLBACKS));
- /* DD_CALLBACKS setup */
- pDirectDraw->DD.dwFlags = callbacks.dwFlags;
-
- /* DestroyDriver Unsuse in win2k or higher */
- if (callbacks.dwFlags & DDHAL_CB32_DESTROYDRIVER)
- pDirectDraw->DD.DestroyDriver = callbacks.DestroyDriver;
- if (callbacks.dwFlags & DDHAL_CB32_CREATESURFACE)
- pDirectDraw->DD.CreateSurface = callbacks.CreateSurface;
- if (callbacks.dwFlags & DDHAL_CB32_SETCOLORKEY)
- pDirectDraw->DD.SetColorKey = callbacks.SetColorKey;
- if (callbacks.dwFlags & DDHAL_CB32_SETMODE)
- pDirectDraw->DD.SetMode = callbacks.SetMode;
- if (callbacks.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK)
- pDirectDraw->DD.WaitForVerticalBlank = callbacks.WaitForVerticalBlank;
- if (callbacks.dwFlags & DDHAL_CB32_CANCREATESURFACE)
- pDirectDraw->DD.CanCreateSurface = callbacks.CanCreateSurface;
- if (callbacks.dwFlags & DDHAL_CB32_CREATEPALETTE)
- pDirectDraw->DD.CreatePalette = callbacks.CreatePalette;
- if (callbacks.dwFlags & DDHAL_CB32_GETSCANLINE)
- pDirectDraw->DD.GetScanLine = callbacks.GetScanLine;
- if (callbacks.dwFlags & DDHAL_CB32_MAPMEMORY)
- pDirectDraw->DD.MapMemory = callbacks.MapMemory;
-
- /* Surface Callbacks */
- pDirectDraw->Surf.dwFlags = surface_callbacks.dwFlags;
-
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_DESTROYSURFACE)
- pDirectDraw->Surf.DestroySurface = surface_callbacks.DestroySurface;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_FLIP)
- pDirectDraw->Surf.Flip = surface_callbacks.Flip;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_SETCLIPLIST)
- pDirectDraw->Surf.SetClipList = surface_callbacks.SetClipList;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_LOCK)
- pDirectDraw->Surf.Lock = surface_callbacks.Lock;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_UNLOCK)
- pDirectDraw->Surf.Unlock = surface_callbacks.Unlock;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_BLT)
- pDirectDraw->Surf.Blt = surface_callbacks.Blt;
- /* DD Callbacks SetColorKey is same as Surface callback SetColorKey */
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)
- pDirectDraw->Surf.SetColorKey = surface_callbacks.SetColorKey;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_ADDATTACHEDSURFACE)
- pDirectDraw->Surf.AddAttachedSurface = surface_callbacks.AddAttachedSurface;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS)
- pDirectDraw->Surf.GetBltStatus = surface_callbacks.GetBltStatus;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS)
- pDirectDraw->Surf.GetFlipStatus = surface_callbacks.GetFlipStatus;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY)
- pDirectDraw->Surf.UpdateOverlay = surface_callbacks.UpdateOverlay;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
- pDirectDraw->Surf.SetOverlayPosition = surface_callbacks.SetOverlayPosition;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_SETPALETTE)
- pDirectDraw->Surf.SetPalette = surface_callbacks.SetPalette;
-
- /* Palette Callbacks */
- pDirectDraw->Pal.dwFlags = palette_callbacks.dwFlags;
- if (palette_callbacks.dwFlags & DDHAL_PALCB32_DESTROYPALETTE)
- pDirectDraw->Pal.DestroyPalette = palette_callbacks.DestroyPalette;
- if (palette_callbacks.dwFlags & DDHAL_PALCB32_SETENTRIES)
- pDirectDraw->Pal.SetEntries = palette_callbacks.SetEntries;
+ /* DD_SURFACECALLBACKS setup*/
+ RtlMoveMemory(&pDirectDraw->Surf, &surface_callbacks, sizeof(DD_SURFACECALLBACKS));
+ /* DD_PALETTECALLBACKS setup*/
+ RtlMoveMemory(&pDirectDraw->Pal, &surface_callbacks, sizeof(DD_PALETTECALLBACKS));
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
DC_UnlockDc(pDC);
HANDLE hDirectDrawLocal
)
{
+ DPRINT1("NtGdiDdDeleteDirectDrawObject\n");
return GDIOBJ_FreeObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
}
HANDLE hDirectDrawLocal,
DD_HALINFO *pHalInfo,
DWORD *pCallBackFlags,
- PD3DNTHAL_CALLBACKS puD3dCallbacks,
- PD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
+ LPD3DNTHAL_CALLBACKS puD3dCallbacks,
+ LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
LPDDSURFACEDESC puD3dTextureFormats,
DWORD *puNumHeaps,
)
{
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdQueryDirectDrawObject\n");
+
if (!pDirectDraw)
+ {
+ /* Fail to Lock DirectDraw handle */
+ DPRINT1(" Fail to Lock DirectDraw handle \n");
return FALSE;
+ }
BOOL success = pDirectDraw->DrvGetDirectDrawInfo(
pDirectDraw->Global.dhpdev,
if (!success)
{
+ DPRINT1(" Fail to get DirectDraw driver info \n");
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return FALSE;
}
- if (pHalInfo->lpD3DHALCallbacks)
+ if (pHalInfo)
{
- RtlMoveMemory(puD3dCallbacks, pHalInfo->lpD3DHALCallbacks, sizeof(D3DNTHAL_CALLBACKS));
- pDirectDraw->D3dContextCreate = puD3dCallbacks->ContextCreate;
- pDirectDraw->D3dContextDestroy = puD3dCallbacks->ContextDestroy;
- }
+ DPRINT1("Found DirectDraw CallBack for 2D Hal\n");
+ RtlMoveMemory(&pDirectDraw->Hal, pHalInfo, sizeof(DD_HALINFO));
+
+ if (pHalInfo->lpD3DHALCallbacks)
+ {
+ DPRINT1("Found DirectDraw CallBack for 3D Hal\n");
+ RtlMoveMemory(puD3dCallbacks, pHalInfo->lpD3DHALCallbacks, sizeof(D3DNTHAL_CALLBACKS));
+ }
+
+ if (pHalInfo->lpD3DGlobalDriverData)
+ {
+ DPRINT1("Found DirectDraw CallBack for 3D Hal Private \n");
+ RtlMoveMemory(puD3dDriverData, pHalInfo->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
+ }
+ if (pHalInfo->lpD3DBufCallbacks)
+ {
+ DPRINT1("Found DirectDraw CallBack for 3D Hal Bufffer \n");
+ RtlMoveMemory(puD3dBufferCallbacks, pHalInfo->lpD3DBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
+ }
+
+ }
+ else
+ {
+ DPRINT1("No DirectDraw Hal info have been found, it did not fail, it did gather some other info \n");
+ }
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
- if (pHalInfo->lpD3DGlobalDriverData)
- {
- RtlMoveMemory(puD3dDriverData, pHalInfo->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
- }
+ return TRUE;
+}
- if (pHalInfo->lpD3DBufCallbacks)
- {
- RtlMoveMemory(puD3dBufferCallbacks, pHalInfo->lpD3DBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
- pDirectDraw->DdCanCreateD3DBuffer = puD3dBufferCallbacks->CanCreateD3DBuffer;
- pDirectDraw->DdCreateD3DBuffer = puD3dBufferCallbacks->CreateD3DBuffer;
- pDirectDraw->DdDestroyD3DBuffer = puD3dBufferCallbacks->DestroyD3DBuffer;
- pDirectDraw->DdLockD3DBuffer = puD3dBufferCallbacks->LockD3DBuffer;
- pDirectDraw->DdUnlockD3DBuffer = puD3dBufferCallbacks->UnlockD3DBuffer;
- }
+DWORD STDCALL NtGdiDdGetDriverInfo(
+ HANDLE hDirectDrawLocal,
+ PDD_GETDRIVERINFODATA puGetDriverInfoData)
- GDIOBJ_UnlockObjByPtr(pDirectDraw);
+{
+ DWORD ddRVal;
- return TRUE;
-}
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetDriverInfo\n");
+
+ if (pDirectDraw == NULL)
+ {
+ DPRINT1("NtGdiDdGetDriverInfo DDHAL_DRIVER_NOTHANDLED\n");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
+ if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFOSET))
+ {
+ DPRINT1("NtGdiDdGetDriverInfo DDHAL_DRIVER_NOTHANDLED\n");
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ }
+ else
+ ddRVal = pDirectDraw->Hal.GetDriverInfo(puGetDriverInfoData);
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+
+ return ddRVal;
+}
/************************************************************************/
/* DD CALLBACKS */
)
{
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
- /* DD_CREATESURFACEDATA surf; */
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+ DPRINT1("NtGdiDdCreateSurface\n");
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puCreateSurfaceData->lpDD;
+
+ /* use our cache version instead */
+ puCreateSurfaceData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
- {
- UNIMPLEMENTED;
- /*
- ddRVal = pDirectDraw->DD.CreateSurface(&surf);
- */
+ {
+ ddRVal = pDirectDraw->DD.CreateSurface(puCreateSurfaceData);
}
+ /* But back the orignal PDev */
+ puCreateSurfaceData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+ DPRINT1("NtGdiDdWaitForVerticalBlank\n");
+
+
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puWaitForVerticalBlankData->lpDD;
+
+ /* use our cache version instead */
+ puWaitForVerticalBlankData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->DD.WaitForVerticalBlank(puWaitForVerticalBlankData);
+ /* But back the orignal PDev */
+ puWaitForVerticalBlankData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdCanCreateSurface\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puCanCreateSurfaceData->lpDD;
+
+ /* use our cache version instead */
+ puCanCreateSurfaceData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->DD.CanCreateSurface(puCanCreateSurfaceData);
+ /* But back the orignal PDev */
+ puCanCreateSurfaceData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetScanLine\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puGetScanLineData->lpDD;
+
+ /* use our cache version instead */
+ puGetScanLineData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_GETSCANLINE))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->DD.GetScanLine(puGetScanLineData);
+ /* But back the orignal PDev */
+ puGetScanLineData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdDestroySurface\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
{
- /* DD_DESTROYSURFACEDATA DestroySurf; */
- UNIMPLEMENTED;
- /* ddRVal = pDirectDraw->Surf.DestroySurface(DestroySurf); */
+ DD_DESTROYSURFACEDATA DestroySurf;
+
+ /* FIXME
+ * bRealDestroy
+ * are we doing right ??
+ */
+ DestroySurf.lpDD = &pDirectDraw->Global;
+
+ DestroySurf.lpDDSurface = hSurface; // ?
+ DestroySurf.DestroySurface = pDirectDraw->Surf.DestroySurface;
+
+ ddRVal = pDirectDraw->Surf.DestroySurface(&DestroySurf);
}
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceTarget, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdFlip\n");
+
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puFlipData->lpDD;
+
+ /* use our cache version instead */
+ puFlipData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_FLIP))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->Surf.Flip(puFlipData);
+ /* But back the orignal PDev */
+ puFlipData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdLock\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puLockData->lpDD;
+
+ /* use our cache version instead */
+ puLockData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_LOCK))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->Surf.Lock(puLockData);
+ /* But back the orignal PDev */
+ puLockData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdUnlock\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puUnlockData->lpDD;
+
+ /* use our cache version instead */
+ puUnlockData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UNLOCK))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->Surf.Unlock(puUnlockData);
+ /* But back the orignal PDev */
+ puUnlockData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDest, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdBlt\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puBltData->lpDD;
+
+ /* use our cache version instead */
+ puBltData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_BLT))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->Surf.Blt(puBltData);
+ /* But back the orignal PDev */
+ puBltData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdSetColorKey\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puSetColorKeyData->lpDD;
+
+ /* use our cache version instead */
+ puSetColorKeyData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETCOLORKEY))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->Surf.SetColorKey(puSetColorKeyData);
+ /* But back the orignal PDev */
+ puSetColorKeyData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceAttached, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdAddAttachedSurface\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puAddAttachedSurfaceData->lpDD;
+
+ /* use our cache version instead */
+ puAddAttachedSurfaceData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_ADDATTACHEDSURFACE))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->Surf.AddAttachedSurface(puAddAttachedSurfaceData);
+ /* But back the orignal PDev */
+ puAddAttachedSurfaceData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
+DWORD STDCALL NtGdiDdGetBltStatus(
+ HANDLE hSurface,
+ PDD_GETBLTSTATUSDATA puGetBltStatusData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetBltStatus\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puGetBltStatusData->lpDD;
+
+ /* use our cache version instead */
+ puGetBltStatusData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.GetBltStatus(puGetBltStatusData);
+
+ /* But back the orignal PDev */
+ puGetBltStatusData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdGetFlipStatus(
+ HANDLE hSurface,
+ PDD_GETFLIPSTATUSDATA puGetFlipStatusData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetFlipStatus\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puGetFlipStatusData->lpDD;
+
+ /* use our cache version instead */
+ puGetFlipStatusData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.GetFlipStatus(puGetFlipStatusData);
+
+ /* But back the orignal PDev */
+ puGetFlipStatusData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
DWORD STDCALL NtGdiDdUpdateOverlay(
HANDLE hSurfaceDestination,
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdUpdateOverlay\n");
if (pDirectDraw == NULL)
return DDHAL_DRIVER_NOTHANDLED;
+ /* backup the orignal PDev and info */
+ lgpl = puUpdateOverlayData->lpDD;
+
+ /* use our cache version instead */
+ puUpdateOverlayData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY))
ddRVal = DDHAL_DRIVER_NOTHANDLED;
else
ddRVal = pDirectDraw->Surf.UpdateOverlay(puUpdateOverlayData);
+ /* But back the orignal PDev */
+ puUpdateOverlayData->lpDD = lgpl;
+
GDIOBJ_UnlockObjByPtr(pDirectDraw);
return ddRVal;
}
+DWORD STDCALL NtGdiDdSetOverlayPosition(
+ HANDLE hSurfaceSource,
+ HANDLE hSurfaceDestination,
+ PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdSetOverlayPosition\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puSetOverlayPositionData->lpDD;
+
+ /* use our cache version instead */
+ puSetOverlayPositionData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.SetOverlayPosition(puSetOverlayPositionData);
+
+ /* But back the orignal PDev */
+ puSetOverlayPositionData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
/************************************************************************/
/* FIXME: implement
* PDD_SURFACE pDDSurf = PVOID pDDSurf
*/
+ DPRINT1("DDSURF_Cleanup\n");
return TRUE;
}
)
{
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdCreateSurfaceObject\n");
if (!pDirectDraw)
return NULL;
HANDLE hSurface
)
{
+ DPRINT1("NtGdiDdDeleteSurfaceObject\n");
return GDIOBJ_FreeObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
}
}
*/
-
-
-DWORD STDCALL NtGdiDdGetDriverInfo(
- HANDLE hDirectDrawLocal,
- PDD_GETDRIVERINFODATA puGetDriverInfoData)
-
-{
- DWORD ddRVal;
-
- PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
-
- ddRVal = pDirectDraw->DdGetDriverInfo(puGetDriverInfoData);
-
- GDIOBJ_UnlockObjByPtr(pDirectDraw);
-
- return ddRVal;
-}
-
-
-
-
-
-
-
-
-
-
-
-
DWORD STDCALL NtGdiDdGetAvailDriverMemory(
HANDLE hDirectDrawLocal,
PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData
)
{
- DWORD ddRVal;
+ DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetAvailDriverMemory\n");
+
+ /* backup the orignal PDev and info */
+ lgpl = puGetAvailDriverMemoryData->lpDD;
+
+ /* use our cache version instead */
+ puGetAvailDriverMemoryData->lpDD = &pDirectDraw->Global;
- ddRVal = pDirectDraw->DdGetAvailDriverMemory(puGetAvailDriverMemoryData);
+ /* make the call */
+ // ddRVal = pDirectDraw->DdGetAvailDriverMemory(puGetAvailDriverMemoryData);
GDIOBJ_UnlockObjByPtr(pDirectDraw);
+
+ /* But back the orignal PDev */
+ puGetAvailDriverMemoryData->lpDD = lgpl;
+
return ddRVal;
}
)
{
DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdSetExclusiveMode\n");
+
+ /* backup the orignal PDev and info */
+ lgpl = puSetExclusiveModeData->lpDD;
+ /* use our cache version instead */
+ puSetExclusiveModeData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
ddRVal = pDirectDraw->DdSetExclusiveMode(puSetExclusiveModeData);
GDIOBJ_UnlockObjByPtr(pDirectDraw);
+
+ /* But back the orignal PDev */
+ puSetExclusiveModeData->lpDD = lgpl;
return ddRVal;
}
projects / reactos.git / blobdiff