ddrawgdi.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DdCreateDirectDrawObject   GdiEntry1
#define	DdQueryDirectDrawObject   GdiEntry2
#define	DdDeleteDirectDrawObject   GdiEntry3
#define	DdCreateSurfaceObject   GdiEntry4
#define	DdDeleteSurfaceObject   GdiEntry5
#define	DdResetVisrgn   GdiEntry6
#define	DdGetDC   GdiEntry7
#define	DdReleaseDC   GdiEntry8
#define	DdCreateDIBSection   GdiEntry9
#define	DdReenableDirectDrawObject   GdiEntry10
#define	DdAttachSurface   GdiEntry11
#define	DdUnattachSurface   GdiEntry12
#define	DdQueryDisplaySettingsUniqueness   GdiEntry13
#define	DdGetDxHandle   GdiEntry14
#define	DdSetGammaRamp   GdiEntry15
#define	DdSwapTextureHandles   GdiEntry16
#define	D3DHAL_CALLBACKS_DEFINED
#define	D3DHAL_GLOBALDRIVERDATA_DEFINED

Typedefs
typedef struct _D3DHAL_CALLBACKS FAR *	LPD3DHAL_CALLBACKS
typedef struct _D3DHAL_GLOBALDRIVERDATA FAR *	LPD3DHAL_GLOBALDRIVERDATA

Functions
BOOL WINAPI	DdCreateDirectDrawObject (LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, HDC hdc)
BOOL WINAPI	DdQueryDirectDrawObject (LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, LPDDHALINFO pHalInfo, LPDDHAL_DDCALLBACKS pDDCallbacks, LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks, LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks, LPD3DHAL_CALLBACKS pD3dCallbacks, LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData, LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks, LPDDSURFACEDESC pD3dTextureFormats, LPDWORD pdwFourCC, LPVIDMEM pvmList)
BOOL WINAPI	DdDeleteDirectDrawObject (LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal)
BOOL WINAPI	DdCreateSurfaceObject (LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal, BOOL bPrimarySurface)
BOOL WINAPI	DdDeleteSurfaceObject (LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal)
BOOL WINAPI	DdResetVisrgn (LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal, HWND hWnd)
HDC WINAPI	DdGetDC (LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal, LPPALETTEENTRY pColorTable)
BOOL WINAPI	DdReleaseDC (LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal)
HBITMAP WINAPI	DdCreateDIBSection (HDC hdc, CONST BITMAPINFO *pbmi, UINT iUsage, VOID **ppvBits, HANDLE hSectionApp, DWORD dwOffset)
BOOL WINAPI	DdReenableDirectDrawObject (LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal, BOOL *pbNewMode)
BOOL WINAPI	DdAttachSurface (LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom, LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo)
VOID WINAPI	DdUnattachSurface (LPDDRAWI_DDRAWSURFACE_LCL pSurface, LPDDRAWI_DDRAWSURFACE_LCL pSurfaceAttached)
ULONG WINAPI	DdQueryDisplaySettingsUniqueness (VOID)
HANDLE WINAPI	DdGetDxHandle (LPDDRAWI_DIRECTDRAW_LCL pDDraw, LPDDRAWI_DDRAWSURFACE_LCL pSurface, BOOL bRelease)
BOOL WINAPI	DdSetGammaRamp (LPDDRAWI_DIRECTDRAW_LCL pDDraw, HDC hdc, LPVOID lpGammaRamp)
DWORD WINAPI	DdSwapTextureHandles (LPDDRAWI_DIRECTDRAW_LCL pDDraw, LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl1, LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl2)

Macro Definition Documentation

D3DHAL_CALLBACKS_DEFINED

#define D3DHAL_CALLBACKS_DEFINED

Definition at line 43 of file ddrawgdi.h.

D3DHAL_GLOBALDRIVERDATA_DEFINED

#define D3DHAL_GLOBALDRIVERDATA_DEFINED

Definition at line 48 of file ddrawgdi.h.

DdAttachSurface

#define DdAttachSurface   GdiEntry11

Definition at line 34 of file ddrawgdi.h.

DdCreateDIBSection

#define DdCreateDIBSection   GdiEntry9

Definition at line 32 of file ddrawgdi.h.

DdCreateDirectDrawObject

#define DdCreateDirectDrawObject   GdiEntry1

Definition at line 24 of file ddrawgdi.h.

DdCreateSurfaceObject

#define DdCreateSurfaceObject   GdiEntry4

Definition at line 27 of file ddrawgdi.h.

DdDeleteDirectDrawObject

#define DdDeleteDirectDrawObject   GdiEntry3

Definition at line 26 of file ddrawgdi.h.

DdDeleteSurfaceObject

#define DdDeleteSurfaceObject   GdiEntry5

Definition at line 28 of file ddrawgdi.h.

DdGetDC

#define DdGetDC   GdiEntry7

Definition at line 30 of file ddrawgdi.h.

DdGetDxHandle

#define DdGetDxHandle   GdiEntry14

Definition at line 37 of file ddrawgdi.h.

DdQueryDirectDrawObject

#define DdQueryDirectDrawObject   GdiEntry2

Definition at line 25 of file ddrawgdi.h.

DdQueryDisplaySettingsUniqueness

#define DdQueryDisplaySettingsUniqueness   GdiEntry13

Definition at line 36 of file ddrawgdi.h.

DdReenableDirectDrawObject

#define DdReenableDirectDrawObject   GdiEntry10

Definition at line 33 of file ddrawgdi.h.

DdReleaseDC

#define DdReleaseDC   GdiEntry8

Definition at line 31 of file ddrawgdi.h.

DdResetVisrgn

#define DdResetVisrgn   GdiEntry6

Definition at line 29 of file ddrawgdi.h.

DdSetGammaRamp

#define DdSetGammaRamp   GdiEntry15

Definition at line 38 of file ddrawgdi.h.

DdSwapTextureHandles

#define DdSwapTextureHandles   GdiEntry16

Definition at line 39 of file ddrawgdi.h.

DdUnattachSurface

#define DdUnattachSurface   GdiEntry12

Definition at line 35 of file ddrawgdi.h.

Typedef Documentation

LPD3DHAL_CALLBACKS

typedef struct _D3DHAL_CALLBACKS FAR* LPD3DHAL_CALLBACKS

Definition at line 42 of file ddrawgdi.h.

LPD3DHAL_GLOBALDRIVERDATA

typedef struct _D3DHAL_GLOBALDRIVERDATA FAR* LPD3DHAL_GLOBALDRIVERDATA

Definition at line 47 of file ddrawgdi.h.

Function Documentation

DdAttachSurface()

BOOL WINAPI DdAttachSurface	(	LPDDRAWI_DDRAWSURFACE_LCL	pSurfaceFrom,
		LPDDRAWI_DDRAWSURFACE_LCL	pSurfaceTo
	)

Definition at line 1983 of file gdientry.c.

{
    /* Create Surface if it does not exits one */
    if (!pSurfaceFrom->hDDSurface)
    {
        if (!bDDCreateSurface(pSurfaceFrom, FALSE))
        {
            return FALSE;
        }
    }
 
    /* Create Surface if it does not exits one */
    if (!pSurfaceTo->hDDSurface)
    {
        if (!bDDCreateSurface(pSurfaceTo, FALSE))
        {
            return FALSE;
        }
    }
 
    /* Call win32k */
    return NtGdiDdAttachSurface((HANDLE)pSurfaceFrom->hDDSurface,
                                (HANDLE)pSurfaceTo->hDDSurface);
}

DdCreateDIBSection()

HBITMAP WINAPI DdCreateDIBSection	(	HDC	hdc,
		CONST BITMAPINFO *	pbmi,
		UINT	iUsage,
		VOID **	ppvBits,
		HANDLE	hSectionApp,
		DWORD	dwOffset
	)

Definition at line 1949 of file gdientry.c.

{
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

DdCreateDirectDrawObject()

BOOL WINAPI DdCreateDirectDrawObject	(	LPDDRAWI_DIRECTDRAW_GBL	pDirectDrawGlobal,
		HDC	hdc
	)

Definition at line 1455 of file gdientry.c.

{
    BOOL Return = FALSE;
 
    /* Check if the global hDC (hdc == 0) is being used */
    if (!hdc)
    {
        /* We'll only allow this if the global object doesn't exist yet */
        if (!ghDirectDraw)
        {
            /* Create the DC */
            if ((hdc = CreateDCW(L"Display", NULL, NULL, NULL)))
            {
                /* Create the DDraw Object */
                ghDirectDraw = NtGdiDdCreateDirectDrawObject(hdc);
 
                /* Delete our DC */
                DeleteDC(hdc);
            }
        }
 
        /* If we created the object, or had one ...*/
        if (ghDirectDraw)
        {
            /* Increase count and set success */
            gcDirectDraw++;
            Return = TRUE;
        }
 
        /* Zero the handle */
        pDirectDrawGlobal->hDD = 0;
    }
    else
    {
        /* Using the per-process object, so create it */
        pDirectDrawGlobal->hDD = (ULONG_PTR)NtGdiDdCreateDirectDrawObject(hdc);
 
        /* Set the return value */
        Return = pDirectDrawGlobal->hDD ? TRUE : FALSE;
    }
 
    /* Return to caller */
    return Return;
}

DdCreateSurfaceObject()

BOOL WINAPI DdCreateSurfaceObject	(	LPDDRAWI_DDRAWSURFACE_LCL	pSurfaceLocal,
		BOOL	bPrimarySurface
	)

Definition at line 1873 of file gdientry.c.

{
    return bDDCreateSurface(pSurfaceLocal, TRUE);
}

DdDeleteDirectDrawObject()

BOOL WINAPI DdDeleteDirectDrawObject

(

LPDDRAWI_DIRECTDRAW_GBL

pDirectDrawGlobal

)

Definition at line 1831 of file gdientry.c.

{
    BOOL Return = FALSE;
 
    /* If this is the global object */
    if(pDirectDrawGlobal->hDD)
    {
        /* Free it */
        Return = NtGdiDdDeleteDirectDrawObject((HANDLE)pDirectDrawGlobal->hDD);
        if (Return)
        {
            pDirectDrawGlobal->hDD = 0;
        }
    }
    else if (ghDirectDraw)
    {
        /* Always success here */
        Return = TRUE;
 
        /* Make sure this is the last instance */
        if (!(--gcDirectDraw))
        {
            /* Delete the object */
            Return = NtGdiDdDeleteDirectDrawObject(ghDirectDraw);
            if (Return)
            {
                ghDirectDraw = 0;
            }
        }
    }
 
    /* Return */
    return Return;
}

DdDeleteSurfaceObject()

BOOL WINAPI DdDeleteSurfaceObject

(

LPDDRAWI_DDRAWSURFACE_LCL

pSurfaceLocal

)

Definition at line 1887 of file gdientry.c.

{
    BOOL Return = FALSE;
 
    /* Make sure there is one */
    if (pSurfaceLocal->hDDSurface)
    {
        /* Delete it */
        Return = NtGdiDdDeleteSurfaceObject((HANDLE)pSurfaceLocal->hDDSurface);
        pSurfaceLocal->hDDSurface = 0;
    }
 
    return Return;
}

DdGetDC()

HDC WINAPI DdGetDC	(	LPDDRAWI_DDRAWSURFACE_LCL	pSurfaceLocal,
		LPPALETTEENTRY	pColorTable
	)

Definition at line 1923 of file gdientry.c.

{
    /* Call win32k directly */
    return NtGdiDdGetDC((HANDLE)pSurfaceLocal->hDDSurface, pColorTable);
}

DdGetDxHandle()

HANDLE WINAPI DdGetDxHandle	(	LPDDRAWI_DIRECTDRAW_LCL	pDDraw,
		LPDDRAWI_DDRAWSURFACE_LCL	pSurface,
		BOOL	bRelease
	)

Definition at line 2043 of file gdientry.c.

{
    HANDLE hDD = NULL;
    HANDLE hSurface = NULL;
 
    /* Check if we already have a surface */
    if (!pSurface)
    {
        /* We don't have one, use the DirectDraw Object handle instead */
        hDD = GetDdHandle(pDDraw->lpGbl->hDD);
    }
    else
    {
        hSurface = (HANDLE)pSurface->hDDSurface;
    }
 
    /* Call the API */
    return (HANDLE)NtGdiDdGetDxHandle(hDD, hSurface, bRelease);
}

DdQueryDirectDrawObject()

BOOL WINAPI DdQueryDirectDrawObject	(	LPDDRAWI_DIRECTDRAW_GBL	pDirectDrawGlobal,
		LPDDHALINFO	pHalInfo,
		LPDDHAL_DDCALLBACKS	pDDCallbacks,
		LPDDHAL_DDSURFACECALLBACKS	pDDSurfaceCallbacks,
		LPDDHAL_DDPALETTECALLBACKS	pDDPaletteCallbacks,
		LPD3DHAL_CALLBACKS	pD3dCallbacks,
		LPD3DHAL_GLOBALDRIVERDATA	pD3dDriverData,
		LPDDHAL_DDEXEBUFCALLBACKS	pD3dBufferCallbacks,
		LPDDSURFACEDESC	pD3dTextureFormats,
		LPDWORD	pdwFourCC,
		LPVIDMEM	pvmList
	)

Definition at line 1508 of file gdientry.c.

{
    PVIDEOMEMORY VidMemList = NULL;
    DD_HALINFO HalInfo;
    D3DNTHAL_CALLBACKS D3dCallbacks;
    D3DNTHAL_GLOBALDRIVERDATA D3dDriverData;
    DD_D3DBUFCALLBACKS D3dBufferCallbacks;
    DWORD CallbackFlags[3];
    DWORD dwNumHeaps=0, FourCCs=0;
    DWORD Flags;
    BOOL retVal = TRUE;
 
    /* Clear the structures */
    RtlZeroMemory(&HalInfo, sizeof(DD_HALINFO));
    RtlZeroMemory(&D3dCallbacks, sizeof(D3DNTHAL_CALLBACKS));
    RtlZeroMemory(&D3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
    RtlZeroMemory(&D3dBufferCallbacks, sizeof(DD_D3DBUFCALLBACKS));
    RtlZeroMemory(CallbackFlags, sizeof(DWORD)*3);
 
    /* Note : XP always alloc 24*sizeof(VIDEOMEMORY) of pvmlist so we change it to it */
    if ( (pvmList != NULL) &&
            (pHalInfo->vmiData.dwNumHeaps != 0) )
    {
        VidMemList = (PVIDEOMEMORY) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(VIDEOMEMORY) * 24 ) * pHalInfo->vmiData.dwNumHeaps);
    }
 
 
    /* Do the query */
    if (!NtGdiDdQueryDirectDrawObject(GetDdHandle(pDirectDrawGlobal->hDD),
                                      &HalInfo,
                                      CallbackFlags,
                                      &D3dCallbacks,
                                      &D3dDriverData,
                                      &D3dBufferCallbacks,
                                      pD3dTextureFormats,
                                      &dwNumHeaps,
                                      VidMemList,
                                      &FourCCs,
                                      pdwFourCC))
    {
        /* We failed, free the memory and return */
        retVal = FALSE;
        goto cleanup;
    }
 
    /* Clear the incoming pointer */
    RtlZeroMemory(pHalInfo, sizeof(DDHALINFO));
 
    /* Convert all the data */
    pHalInfo->dwSize = sizeof(DDHALINFO);
    pHalInfo->lpDDCallbacks = pDDCallbacks;
    pHalInfo->lpDDSurfaceCallbacks = pDDSurfaceCallbacks;
    pHalInfo->lpDDPaletteCallbacks = pDDPaletteCallbacks;
 
    /* Check for NT5+ D3D Data */
    if ( (D3dCallbacks.dwSize != 0) &&
            (D3dDriverData.dwSize != 0) )
    {
        /* Write these down */
        pHalInfo->lpD3DGlobalDriverData = (ULONG_PTR)pD3dDriverData;
        pHalInfo->lpD3DHALCallbacks = (ULONG_PTR)pD3dCallbacks;
 
        /* Check for Buffer Callbacks */
        if (D3dBufferCallbacks.dwSize)
        {
            /* Write this one too */
            pHalInfo->lpDDExeBufCallbacks = pD3dBufferCallbacks;
        }
    }
 
    /* Continue converting the rest */
    pHalInfo->vmiData.dwFlags = HalInfo.vmiData.dwFlags;
    pHalInfo->vmiData.dwDisplayWidth = HalInfo.vmiData.dwDisplayWidth;
    pHalInfo->vmiData.dwDisplayHeight = HalInfo.vmiData.dwDisplayHeight;
    pHalInfo->vmiData.lDisplayPitch = HalInfo.vmiData.lDisplayPitch;
    pHalInfo->vmiData.fpPrimary = 0;
 
    RtlCopyMemory( &pHalInfo->vmiData.ddpfDisplay,
                   &HalInfo.vmiData.ddpfDisplay,
                   sizeof(DDPIXELFORMAT));
 
    pHalInfo->vmiData.dwOffscreenAlign = HalInfo.vmiData.dwOffscreenAlign;
    pHalInfo->vmiData.dwOverlayAlign = HalInfo.vmiData.dwOverlayAlign;
    pHalInfo->vmiData.dwTextureAlign = HalInfo.vmiData.dwTextureAlign;
    pHalInfo->vmiData.dwZBufferAlign = HalInfo.vmiData.dwZBufferAlign;
    pHalInfo->vmiData.dwAlphaAlign = HalInfo.vmiData.dwAlphaAlign;
 
    pHalInfo->vmiData.dwNumHeaps = dwNumHeaps;
    pHalInfo->vmiData.pvmList = pvmList;
 
    RtlCopyMemory( &pHalInfo->ddCaps,
                   &HalInfo.ddCaps,
                   sizeof(DDCORECAPS ));
 
    pHalInfo->ddCaps.dwNumFourCCCodes = FourCCs;
    pHalInfo->lpdwFourCC = pdwFourCC;
 
    /* always force rope 0x1000 for hal it mean only source copy is supported */
    pHalInfo->ddCaps.dwRops[6] = 0x1000;
 
    /* Set the HAL flags what ReactX got from the driver
     * Windows XP force setting DDHALINFO_GETDRIVERINFOSET if the driver does not set it
     * and ReactX doing same to keep compatible with drivers, but the driver are
     * force support DdGetDriverInfo acoriding MSDN but it seam some driver do not set
     * this flag even it is being supported. that is mean. It is small hack to keep
     * bad driver working, that trust this is always being setting by it self at end
     */
    pHalInfo->dwFlags = (HalInfo.dwFlags & ~DDHALINFO_GETDRIVERINFOSET) | DDHALINFO_GETDRIVERINFOSET;
    pHalInfo->GetDriverInfo = (LPDDHAL_GETDRIVERINFO) DdGetDriverInfo;
 
    /* Now check if we got any DD callbacks */
    if (pDDCallbacks)
    {
        /* Zero the structure */
        RtlZeroMemory(pDDCallbacks, sizeof(DDHAL_DDCALLBACKS));
        pDDCallbacks->dwSize = sizeof(DDHAL_DDCALLBACKS);
 
        /* Set the flags for this structure
         * Windows XP force setting DDHAL_CB32_CREATESURFACE if the driver does not set it
         * and ReactX doing same to keep compatible with drivers, but the driver are
         * force support pDDCallbacks acoriding MSDN but it seam some driver do not set
         * this flag even it is being supported. that is mean. It is small hack to keep
         * bad driver working, that trust this is always being setting by it self at end
        */
        Flags = (CallbackFlags[0] & ~DDHAL_CB32_CREATESURFACE) | DDHAL_CB32_CREATESURFACE;
        pDDCallbacks->dwFlags = Flags;
 
        /* Write the always-on functions */
        pDDCallbacks->CreateSurface = DdCreateSurface;
 
        /* Now write the pointers, if applicable */
        if (Flags & DDHAL_CB32_WAITFORVERTICALBLANK)
        {
            pDDCallbacks->WaitForVerticalBlank = DdWaitForVerticalBlank;
        }
        if (Flags & DDHAL_CB32_CANCREATESURFACE)
        {
            pDDCallbacks->CanCreateSurface = DdCanCreateSurface;
        }
        if (Flags & DDHAL_CB32_GETSCANLINE)
        {
            pDDCallbacks->GetScanLine = DdGetScanLine;
        }
    }
 
    /* Check for DD Surface Callbacks */
    if (pDDSurfaceCallbacks)
    {
        /* Zero the structures */
        RtlZeroMemory(pDDSurfaceCallbacks, sizeof(DDHAL_DDSURFACECALLBACKS));
        pDDSurfaceCallbacks->dwSize  = sizeof(DDHAL_DDSURFACECALLBACKS);
 
        /* Set the flags for this structure
         * Windows XP force setting DDHAL_SURFCB32_LOCK, DDHAL_SURFCB32_UNLOCK,
         * DDHAL_SURFCB32_SETCOLORKEY, DDHAL_SURFCB32_DESTROYSURFACE if the driver
         * does not set it and ReactX doing same to keep compatible with drivers,
         * but the driver are force support pDDSurfaceCallbacks acoriding MSDN but it seam
         * some driver do not set this flag even it is being supported. that is mean.
         * It is small hack to keep bad driver working, that trust this is always being
         * setting by it self at end
         */
 
        Flags = (CallbackFlags[1] & ~(DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK |
                                      DDHAL_SURFCB32_SETCOLORKEY | DDHAL_SURFCB32_DESTROYSURFACE)) |
                (DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK |
                 DDHAL_SURFCB32_SETCOLORKEY | DDHAL_SURFCB32_DESTROYSURFACE);
 
        pDDSurfaceCallbacks->dwFlags = Flags;
 
        /* Write the always-on functions */
        pDDSurfaceCallbacks->Lock = DdLock;
        pDDSurfaceCallbacks->Unlock = DdUnlock;
        pDDSurfaceCallbacks->SetColorKey = DdSetColorKey;
        pDDSurfaceCallbacks->DestroySurface = DdDestroySurface;
 
        /* Write the optional ones */
        if (Flags & DDHAL_SURFCB32_FLIP)
        {
            pDDSurfaceCallbacks->Flip = DdFlip;
        }
        if (Flags & DDHAL_SURFCB32_BLT)
        {
            pDDSurfaceCallbacks->Blt = DdBlt;
        }
        if (Flags & DDHAL_SURFCB32_GETBLTSTATUS)
        {
            pDDSurfaceCallbacks->GetBltStatus = DdGetBltStatus;
        }
        if (Flags & DDHAL_SURFCB32_GETFLIPSTATUS)
        {
            pDDSurfaceCallbacks->GetFlipStatus = DdGetFlipStatus;
        }
        if (Flags & DDHAL_SURFCB32_UPDATEOVERLAY)
        {
            pDDSurfaceCallbacks->UpdateOverlay = DdUpdateOverlay;
        }
        if (Flags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
        {
            pDDSurfaceCallbacks->SetOverlayPosition = DdSetOverlayPosition;
        }
        if (Flags & DDHAL_SURFCB32_ADDATTACHEDSURFACE)
        {
            pDDSurfaceCallbacks->AddAttachedSurface = DdAddAttachedSurface;
        }
    }
 
    /* Check for DD Palette Callbacks, This interface are dead for user mode,
     * only what it can support are being report back.
     */
    if (pDDPaletteCallbacks)
    {
        /* Zero the struct */
        RtlZeroMemory(pDDPaletteCallbacks, sizeof(DDHAL_DDPALETTECALLBACKS));
 
        /* Write the header */
        pDDPaletteCallbacks->dwSize  = sizeof(DDHAL_DDPALETTECALLBACKS);
        pDDPaletteCallbacks->dwFlags = CallbackFlags[2];
    }
 
    if (pD3dCallbacks)
    {
        /* Zero the struct */
        RtlZeroMemory(pD3dCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS));
 
        /* Check if we have one */
        if (D3dCallbacks.dwSize)
        {
            /* Write the header */
            pD3dCallbacks->dwSize = sizeof(DDHAL_DDEXEBUFCALLBACKS);
 
            /* Now check for each callback */
            if (D3dCallbacks.ContextCreate)
            {
                pD3dCallbacks->ContextCreate = (LPD3DHAL_CONTEXTCREATECB) D3dContextCreate;
            }
            if (D3dCallbacks.ContextDestroy)
            {
                pD3dCallbacks->ContextDestroy = (LPD3DHAL_CONTEXTDESTROYCB) NtGdiD3dContextDestroy;
            }
            if (D3dCallbacks.ContextDestroyAll)
            {
                pD3dCallbacks->ContextDestroyAll = (LPD3DHAL_CONTEXTDESTROYALLCB) NtGdiD3dContextDestroyAll;
            }
        }
    }
 
    /* Check for D3D Driver Data */
    if (pD3dDriverData)
    {
        /* Copy the struct */
        RtlMoveMemory(pD3dDriverData, &D3dDriverData, sizeof(D3DHAL_GLOBALDRIVERDATA));
 
        /* Write the pointer to the texture formats */
        pD3dDriverData->lpTextureFormats = pD3dTextureFormats;
    }
 
    /* Check for D3D Buffer Callbacks */
    if (pD3dBufferCallbacks)
    {
        /* Zero the struct */
        RtlZeroMemory(pD3dBufferCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS));
 
        if ( D3dBufferCallbacks.dwSize)
        {
            pD3dBufferCallbacks->dwSize = D3dBufferCallbacks.dwSize;
 
            pD3dBufferCallbacks->dwFlags = D3dBufferCallbacks.dwFlags;
            if ( D3dBufferCallbacks.CanCreateD3DBuffer)
            {
                pD3dBufferCallbacks->CanCreateExecuteBuffer = (LPDDHALEXEBUFCB_CANCREATEEXEBUF)DdCanCreateD3DBuffer;
            }
 
            if (D3dBufferCallbacks.CreateD3DBuffer)
            {
                pD3dBufferCallbacks->CreateExecuteBuffer = (LPDDHALEXEBUFCB_CREATEEXEBUF) DdCreateD3DBuffer;
            }
 
            if ( D3dBufferCallbacks.DestroyD3DBuffer )
            {
                pD3dBufferCallbacks->DestroyExecuteBuffer = (LPDDHALEXEBUFCB_DESTROYEXEBUF) DdDestroyD3DBuffer;
            }
 
            if ( D3dBufferCallbacks.LockD3DBuffer )
            {
                pD3dBufferCallbacks->LockExecuteBuffer = (LPDDHALEXEBUFCB_LOCKEXEBUF) DdLockD3D;
            }
 
            if ( D3dBufferCallbacks.UnlockD3DBuffer )
            {
                pD3dBufferCallbacks->UnlockExecuteBuffer = (LPDDHALEXEBUFCB_UNLOCKEXEBUF) DdUnlockD3D;
            }
 
        }
    }
 
    /* FIXME VidMemList */
 
cleanup:
    if (VidMemList)
    {
        HeapFree(GetProcessHeap(), 0, VidMemList);
    }
 
    return retVal;
}

DdQueryDisplaySettingsUniqueness()

ULONG WINAPI DdQueryDisplaySettingsUniqueness

(

VOID

)

Definition at line 2031 of file gdientry.c.

{
    return GdiSharedHandleTable->flDeviceUniq;
}

DdReenableDirectDrawObject()

BOOL WINAPI DdReenableDirectDrawObject	(	LPDDRAWI_DIRECTDRAW_GBL	pDirectDrawGlobal,
		BOOL *	pbNewMode
	)

Definition at line 1967 of file gdientry.c.

{
    /* Call win32k directly */
    return NtGdiDdReenableDirectDrawObject(GetDdHandle(pDirectDrawGlobal->hDD),
                                           pbNewMode);
}

DdReleaseDC()

BOOL WINAPI DdReleaseDC

(

LPDDRAWI_DDRAWSURFACE_LCL

pSurfaceLocal

)

Definition at line 1937 of file gdientry.c.

{
    /* Call win32k directly */
    return NtGdiDdReleaseDC((HANDLE) pSurfaceLocal->hDDSurface);
}

DdResetVisrgn()

BOOL WINAPI DdResetVisrgn	(	LPDDRAWI_DDRAWSURFACE_LCL	pSurfaceLocal,
		HWND	hWnd
	)

Definition at line 1909 of file gdientry.c.

{
    /* Call win32k directly */
    return NtGdiDdResetVisrgn((HANDLE) pSurfaceLocal->hDDSurface, hWnd);
}

DdSetGammaRamp()

BOOL WINAPI DdSetGammaRamp	(	LPDDRAWI_DIRECTDRAW_LCL	pDDraw,
		HDC	hdc,
		LPVOID	lpGammaRamp
	)

Definition at line 2072 of file gdientry.c.

{
    /* Call win32k directly */
    return NtGdiDdSetGammaRamp(GetDdHandle(pDDraw->lpGbl->hDD),
                               hdc,
                               lpGammaRamp);
}

DdSwapTextureHandles()

DWORD WINAPI DdSwapTextureHandles	(	LPDDRAWI_DIRECTDRAW_LCL	pDDraw,
		LPDDRAWI_DDRAWSURFACE_LCL	pDDSLcl1,
		LPDDRAWI_DDRAWSURFACE_LCL	pDDSLcl2
	)

Definition at line 222 of file historic.c.

{
    /* Note Windows 2000/XP/VISTA always returns success */
    return TRUE;
}

DdUnattachSurface()

VOID WINAPI DdUnattachSurface	(	LPDDRAWI_DDRAWSURFACE_LCL	pSurface,
		LPDDRAWI_DDRAWSURFACE_LCL	pSurfaceAttached
	)

Definition at line 2016 of file gdientry.c.

{
    /* Call win32k */
    NtGdiDdUnattachSurface((HANDLE)pSurface->hDDSurface,
                           (HANDLE)pSurfaceAttached->hDDSurface);
}