ddraw.h File Reference

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

Go to the source code of this file.

Functions
HRESULT WINAPI	Main_DirectDraw_QueryInterface (LPDDRAWI_DIRECTDRAW_INT This, REFIID id, LPVOID *obj)
ULONG WINAPI	Main_DirectDraw_AddRef (LPDDRAWI_DIRECTDRAW_INT This)
ULONG WINAPI	Main_DirectDraw_Release (LPDDRAWI_DIRECTDRAW_INT This)
HRESULT WINAPI	Main_DirectDraw_Compact (LPDDRAWI_DIRECTDRAW_INT This)
HRESULT WINAPI	Main_DirectDraw_CreateClipper (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags, LPDIRECTDRAWCLIPPER *ppClipper, IUnknown *pUnkOuter)
HRESULT WINAPI	Main_DirectDraw_CreatePalette (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags, LPPALETTEENTRY palent, LPDIRECTDRAWPALETTE *ppPalette, LPUNKNOWN pUnkOuter)
HRESULT WINAPI	Main_DirectDraw_CreateSurface (LPDDRAWI_DIRECTDRAW_INT This, LPDDSURFACEDESC pDDSD, LPDDRAWI_DDRAWSURFACE_INT *ppSurf, IUnknown *pUnkOuter)
HRESULT WINAPI	Main_DirectDraw_CreateSurface4 (LPDDRAWI_DIRECTDRAW_INT This, LPDDSURFACEDESC2 pDDSD, LPDDRAWI_DDRAWSURFACE_INT *ppSurf, IUnknown *pUnkOuter)
HRESULT WINAPI	Main_DirectDraw_DuplicateSurface (LPDDRAWI_DIRECTDRAW_INT This, LPDIRECTDRAWSURFACE7 src, LPDIRECTDRAWSURFACE7 *dst)
HRESULT WINAPI	Main_DirectDraw_EnumDisplayModes (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags, LPDDSURFACEDESC pDDSD, LPVOID pContext, LPDDENUMMODESCALLBACK pCallback)
HRESULT WINAPI	Main_DirectDraw_EnumDisplayModes4 (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags, LPDDSURFACEDESC2 pDDSD, LPVOID pContext, LPDDENUMMODESCALLBACK2 pCallback)
HRESULT WINAPI	Main_DirectDraw_EnumSurfaces (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags, LPDDSURFACEDESC lpDDSD2, LPVOID context, LPDDENUMSURFACESCALLBACK callback)
HRESULT WINAPI	Main_DirectDraw_EnumSurfaces4 (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags, LPDDSURFACEDESC2 lpDDSD2, LPVOID context, LPDDENUMSURFACESCALLBACK2 callback)
HRESULT WINAPI	Main_DirectDraw_EnumSurfaces7 (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags, LPDDSURFACEDESC2 lpDDSD2, LPVOID context, LPDDENUMSURFACESCALLBACK7 callback)
HRESULT WINAPI	Main_DirectDraw_FlipToGDISurface (LPDDRAWI_DIRECTDRAW_INT This)
HRESULT WINAPI	Main_DirectDraw_GetCaps (LPDDRAWI_DIRECTDRAW_INT This, LPDDCAPS pDriverCaps, LPDDCAPS pHELCaps)
HRESULT WINAPI	Main_DirectDraw_GetDisplayMode (LPDDRAWI_DIRECTDRAW_INT This, LPDDSURFACEDESC pDDSD)
HRESULT WINAPI	Main_DirectDraw_GetDisplayMode4 (LPDDRAWI_DIRECTDRAW_INT This, LPDDSURFACEDESC2 pDDSD)
HRESULT WINAPI	Main_DirectDraw_GetFourCCCodes (LPDDRAWI_DIRECTDRAW_INT This, LPDWORD lpNumCodes, LPDWORD lpCodes)
HRESULT WINAPI	Main_DirectDraw_GetGDISurface (LPDDRAWI_DIRECTDRAW_INT This, LPDIRECTDRAWSURFACE7 *lplpGDIDDSSurface)
HRESULT WINAPI	Main_DirectDraw_GetMonitorFrequency (LPDDRAWI_DIRECTDRAW_INT This, LPDWORD lpFreq)
HRESULT WINAPI	Main_DirectDraw_GetScanLine (LPDDRAWI_DIRECTDRAW_INT This, LPDWORD lpdwScanLine)
HRESULT WINAPI	Main_DirectDraw_GetVerticalBlankStatus (LPDDRAWI_DIRECTDRAW_INT This, LPBOOL lpbIsInVB)
HRESULT WINAPI	Main_DirectDraw_Initialize (LPDDRAWI_DIRECTDRAW_INT This, LPGUID lpGUID)
HRESULT WINAPI	Main_DirectDraw_RestoreDisplayMode (LPDDRAWI_DIRECTDRAW_INT This)
HRESULT WINAPI	Main_DirectDraw_SetCooperativeLevel (LPDDRAWI_DIRECTDRAW_INT This, HWND hwnd, DWORD cooplevel)
HRESULT WINAPI	Main_DirectDraw_SetDisplayMode (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
HRESULT WINAPI	Main_DirectDraw_SetDisplayMode2 (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP, DWORD dwRefreshRate, DWORD dwFlags)
HRESULT WINAPI	Main_DirectDraw_WaitForVerticalBlank (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwFlags, HANDLE h)
HRESULT WINAPI	Main_DirectDraw_GetAvailableVidMem4 (LPDDRAWI_DIRECTDRAW_INT This, LPDDSCAPS2 ddscaps, LPDWORD dwTotal, LPDWORD dwFree)
HRESULT WINAPI	Main_DirectDraw_GetSurfaceFromDC (LPDDRAWI_DIRECTDRAW_INT This, HDC hdc, LPDIRECTDRAWSURFACE7 *lpDDS)
HRESULT WINAPI	Main_DirectDraw_RestoreAllSurfaces (LPDDRAWI_DIRECTDRAW_INT This)
HRESULT WINAPI	Main_DirectDraw_TestCooperativeLevel (LPDDRAWI_DIRECTDRAW_INT This)
HRESULT WINAPI	Main_DirectDraw_GetDeviceIdentifier7 (LPDDRAWI_DIRECTDRAW_INT This, LPDDDEVICEIDENTIFIER2 pDDDI, DWORD dwFlags)
HRESULT WINAPI	Main_DirectDraw_StartModeTest (LPDDRAWI_DIRECTDRAW_INT This, LPSIZE pModes, DWORD dwNumModes, DWORD dwFlags)
HRESULT WINAPI	Main_DirectDraw_EvaluateMode (LPDDRAWI_DIRECTDRAW_INT This, DWORD a, DWORD *b)
DWORD CALLBACK	HelDdSurfAddAttachedSurface (LPDDHAL_ADDATTACHEDSURFACEDATA lpDestroySurface)
DWORD CALLBACK	HelDdSurfBlt (LPDDHAL_BLTDATA lpBltData)
DWORD CALLBACK	HelDdSurfDestroySurface (LPDDHAL_DESTROYSURFACEDATA lpDestroySurfaceData)
DWORD CALLBACK	HelDdSurfFlip (LPDDHAL_FLIPDATA lpFlipData)
DWORD CALLBACK	HelDdSurfGetBltStatus (LPDDHAL_GETBLTSTATUSDATA lpGetBltStatusData)
DWORD CALLBACK	HelDdSurfGetFlipStatus (LPDDHAL_GETFLIPSTATUSDATA lpGetFlipStatusData)
DWORD CALLBACK	HelDdSurfLock (LPDDHAL_LOCKDATA lpLockData)
DWORD CALLBACK	HelDdSurfreserved4 (DWORD *lpPtr)
DWORD CALLBACK	HelDdSurfSetClipList (LPDDHAL_SETCLIPLISTDATA lpSetClipListData)
DWORD CALLBACK	HelDdSurfSetColorKey (LPDDHAL_SETCOLORKEYDATA lpSetColorKeyData)
DWORD CALLBACK	HelDdSurfSetOverlayPosition (LPDDHAL_SETOVERLAYPOSITIONDATA lpSetOverlayPositionData)
DWORD CALLBACK	HelDdSurfSetPalette (LPDDHAL_SETPALETTEDATA lpSetPaletteData)
DWORD CALLBACK	HelDdSurfUnlock (LPDDHAL_UNLOCKDATA lpUnLockData)
DWORD CALLBACK	HelDdSurfUpdateOverlay (LPDDHAL_UPDATEOVERLAYDATA lpUpDateOverLayData)

Function Documentation

HelDdSurfAddAttachedSurface()

DWORD CALLBACK HelDdSurfAddAttachedSurface

(

LPDDHAL_ADDATTACHEDSURFACEDATA

lpDestroySurface

)

Definition at line 12 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfBlt()

DWORD CALLBACK HelDdSurfBlt

(

LPDDHAL_BLTDATA

lpBltData

)

Definition at line 17 of file callbacks_surf_hel.c.

{
    DX_WINDBG_trace();
 
    if (lpBltData->dwFlags & DDBLT_COLORFILL)
    {
        HBRUSH hbr = CreateSolidBrush(lpBltData->bltFX.dwFillColor );
        FillRect( (HDC)lpBltData->lpDDDestSurface->lpSurfMore->lpDD_lcl->hDC,
                  (CONST RECT *)&lpBltData->rDest,
                  hbr);
        DeleteObject(hbr);
        lpBltData->ddRVal = DD_OK;
    }
    else if (lpBltData->dwFlags & DDBLT_ROP)
    {
        BitBlt( (HDC)lpBltData->lpDDDestSurface->lpSurfMore->lpDD_lcl->hDC,
                lpBltData->rDest.top,
                lpBltData->rDest.left,
                lpBltData->rDest.right,
                lpBltData->rDest.bottom,
                (HDC)lpBltData->lpDDSrcSurface->lpSurfMore->lpDD_lcl->hDC,
                lpBltData->rSrc.top,
                lpBltData->rSrc.right,
                lpBltData->bltFX.dwROP);
                lpBltData->ddRVal = DD_OK;
    }
    return DDHAL_DRIVER_HANDLED;
}

Referenced by StartDirectDrawHel().

HelDdSurfDestroySurface()

DWORD CALLBACK HelDdSurfDestroySurface

(

LPDDHAL_DESTROYSURFACEDATA

lpDestroySurfaceData

)

Definition at line 46 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfFlip()

DWORD CALLBACK HelDdSurfFlip

(

LPDDHAL_FLIPDATA

lpFlipData

)

Definition at line 51 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfGetBltStatus()

DWORD CALLBACK HelDdSurfGetBltStatus

(

LPDDHAL_GETBLTSTATUSDATA

lpGetBltStatusData

)

Definition at line 56 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfGetFlipStatus()

DWORD CALLBACK HelDdSurfGetFlipStatus

(

LPDDHAL_GETFLIPSTATUSDATA

lpGetFlipStatusData

)

Definition at line 61 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfLock()

DWORD CALLBACK HelDdSurfLock

(

LPDDHAL_LOCKDATA

lpLockData

)

Definition at line 66 of file callbacks_surf_hel.c.

{
 
    HDC hDC;
    HBITMAP hImage = NULL;
 
    LONG cbBuffer = 0;
    LPDWORD pixels = NULL;
 
    HDC hMemDC = NULL;
    HBITMAP hDCBmp = NULL;
    BITMAP bm = {0};
 
    DX_WINDBG_trace();
 
    /* ToDo tell ddraw internal this surface is locked */
    /* ToDo add support for dwFlags */
 
 
    /* Get our hdc for the active window */
    hDC = GetDC((HWND)lpLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
 
    if (hDC != NULL)
    {
        /* Create a memory bitmap to store a copy of current hdc surface */
 
        if (!lpLockData->bHasRect)
        {
            hImage = CreateCompatibleBitmap (hDC, lpLockData->lpDDSurface->lpGbl->wWidth, lpLockData->lpDDSurface->lpGbl->wHeight);
        }
        else
        {
            hImage = CreateCompatibleBitmap (hDC, lpLockData->rArea.right, lpLockData->rArea.bottom);
        }
 
        /* Create a memory hdc so we can draw on our current memory bitmap */
        hMemDC = CreateCompatibleDC(hDC);
 
        if (hMemDC != NULL)
        {
            /* Select our memory bitmap to our memory hdc */
            hDCBmp = (HBITMAP) SelectObject (hMemDC, hImage);
 
            /* Get our memory bitmap information */
            GetObject(hImage, sizeof(BITMAP), &bm);
 
            if (!lpLockData->bHasRect)
            {
                BitBlt (hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY);
            }
            else
            {
                BitBlt (hMemDC, lpLockData->rArea.top, lpLockData->rArea.left, lpLockData->rArea.right, lpLockData->rArea.bottom, hDC, 0, 0, SRCCOPY);
            }
 
            SelectObject (hMemDC, hDCBmp);
 
            /* Allocate memory buffer for the bitmap pixel data  */
            cbBuffer = bm.bmWidthBytes * bm.bmHeight ;
            pixels = (PDWORD) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbBuffer );
 
            if (pixels != NULL)
            {
                /* Get the bitmap bits */
                GetBitmapBits(hImage,cbBuffer,pixels);
 
                /* Fixme HACK - check which member stores the HEL bitmap buffer */
                lpLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 = pixels;
 
                /* Setup return value */
                lpLockData->ddRVal = DD_OK;
                lpLockData->lpSurfData = pixels;
            }
        }
    }
 
 
    /* Free the pixels buffer if we fail */
    if ( (pixels != NULL) &&
         (lpLockData->ddRVal != DD_OK) )
    {
        HeapFree(GetProcessHeap(), 0, pixels );
    }
 
    /* Cleanup after us */
    if (hImage != NULL)
    {
        DeleteObject (hImage);
    }
 
    if (hMemDC != NULL)
    {
        DeleteDC (hMemDC);
    }
 
    return DDHAL_DRIVER_HANDLED;
}

Referenced by StartDirectDrawHel().

HelDdSurfreserved4()

DWORD CALLBACK HelDdSurfreserved4

(

DWORD *

lpPtr

)

Definition at line 164 of file callbacks_surf_hel.c.

{
    /* This api is not documented by MS, keep it stubbed */
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfSetClipList()

DWORD CALLBACK HelDdSurfSetClipList

(

LPDDHAL_SETCLIPLISTDATA

lpSetClipListData

)

Definition at line 170 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfSetColorKey()

DWORD CALLBACK HelDdSurfSetColorKey

(

LPDDHAL_SETCOLORKEYDATA

lpSetColorKeyData

)

Definition at line 175 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfSetOverlayPosition()

DWORD CALLBACK HelDdSurfSetOverlayPosition

(

LPDDHAL_SETOVERLAYPOSITIONDATA

lpSetOverlayPositionData

)

Definition at line 180 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfSetPalette()

DWORD CALLBACK HelDdSurfSetPalette

(

LPDDHAL_SETPALETTEDATA

lpSetPaletteData

)

Definition at line 185 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSurfUnlock()

DWORD CALLBACK HelDdSurfUnlock

(

LPDDHAL_UNLOCKDATA

lpUnLockData

)

Definition at line 190 of file callbacks_surf_hel.c.

{
    HDC hDC;
    HBITMAP hImage = NULL;
 
    HDC hMemDC = NULL;
    HBITMAP hDCBmp = NULL;
    BITMAP bm = {0};
 
    DX_WINDBG_trace();
 
    /* Get our hdc for the active window */
    hDC = GetDC((HWND)lpUnLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
 
    if (hDC != NULL)
    {
        /* Create a memory bitmap to store a copy of current hdc surface */
 
        /* fixme the rcarea are not store in the struct yet so the data will look corrupted */
        hImage = CreateCompatibleBitmap (hDC, lpUnLockData->lpDDSurface->lpGbl->wWidth, lpUnLockData->lpDDSurface->lpGbl->wHeight);
 
        /* Create a memory hdc so we can draw on our current memory bitmap */
        hMemDC = CreateCompatibleDC(hDC);
 
        if (hMemDC != NULL)
        {
            /* Select our memory bitmap to our memory hdc */
            hDCBmp = (HBITMAP) SelectObject (hMemDC, hImage);
 
            /* Get our memory bitmap information */
            GetObject(hImage, sizeof(BITMAP), &bm);
 
            SetBitmapBits(hImage,bm.bmWidthBytes * bm.bmHeight, lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2);
 
            BitBlt (hDC, 0, 0, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
 
            SelectObject (hMemDC, hDCBmp);
 
            /* Setup return value */
             lpUnLockData->ddRVal = DD_OK;
        }
    }
 
    /* Cleanup after us */
    if (hImage != NULL)
    {
        DeleteObject (hImage);
    }
 
    if (hMemDC != NULL)
    {
        DeleteDC (hMemDC);
    }
 
    if (lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 != NULL)
    {
        HeapFree(GetProcessHeap(), 0, lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 );
    }
 
    return DDHAL_DRIVER_HANDLED;
}

Referenced by StartDirectDrawHel().

HelDdSurfUpdateOverlay()

DWORD CALLBACK HelDdSurfUpdateOverlay

(

LPDDHAL_UPDATEOVERLAYDATA

lpUpDateOverLayData

)

Definition at line 252 of file callbacks_surf_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

Main_DirectDraw_AddRef()

ULONG WINAPI Main_DirectDraw_AddRef

(

LPDDRAWI_DIRECTDRAW_INT

This

)

Definition at line 145 of file ddraw_main.c.

{
    ULONG retValue = 0;
 
    DX_WINDBG_trace();
 
    /* Lock the thread */
    AcquireDDThreadLock();
 
    _SEH2_TRY
    {
        /* Increment the internal ref counter */
        This->dwIntRefCnt++;
 
        /* Increment the local internal ref counter */
        This->lpLcl->dwLocalRefCnt++;
 
        if (This->lpLcl->lpGbl != NULL)
        {
            /* Increment the global internal ref counter */
            This->lpLcl->lpGbl->dwRefCnt++;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    _SEH2_TRY
    {
        retValue = This->dwIntRefCnt;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        retValue = 0;
    }
    _SEH2_END;
 
    /* Release the thread lock */
    ReleaseDDThreadLock();
 
    /* Return the local Ref counter */
    return retValue;
}

Referenced by Create_DirectDraw(), Main_DirectDraw_CreatePalette(), Main_DirectDraw_CreateSurface4(), Main_DirectDraw_QueryInterface(), ThunkDirectDraw2_AddRef(), ThunkDirectDraw4_AddRef(), and ThunkDirectDraw_AddRef().

Main_DirectDraw_Compact()

HRESULT WINAPI Main_DirectDraw_Compact

(

LPDDRAWI_DIRECTDRAW_INT

This

)

Definition at line 267 of file ddraw_main.c.

{
    HRESULT retVal = DD_OK;
 
    DX_WINDBG_trace();
 
    /* Lock the thread */
    AcquireDDThreadLock();
 
    _SEH2_TRY
    {
        /* Check if Exclusive mode has been activated */
        if (This->lpLcl->lpGbl->lpExclusiveOwner != This->lpLcl)
        {
            retVal = DDERR_NOEXCLUSIVEMODE;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    /* Release the thread lock */
    ReleaseDDThreadLock();
 
    return retVal;
}

Referenced by ThunkDirectDraw2_Compact(), ThunkDirectDraw4_Compact(), and ThunkDirectDraw_Compact().

Main_DirectDraw_CreateClipper()

HRESULT WINAPI Main_DirectDraw_CreateClipper	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwFlags,
		LPDIRECTDRAWCLIPPER *	ppClipper,
		IUnknown *	pUnkOuter
	)

Definition at line 17 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by DirectDrawCreateClipper(), ThunkDirectDraw2_CreateClipper(), ThunkDirectDraw4_CreateClipper(), and ThunkDirectDraw_CreateClipper().

Main_DirectDraw_CreatePalette()

HRESULT WINAPI Main_DirectDraw_CreatePalette	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwFlags,
		LPPALETTEENTRY	palent,
		LPDIRECTDRAWPALETTE *	ppPalette,
		LPUNKNOWN	pUnkOuter
	)

Definition at line 545 of file ddraw_main.c.

{
    HRESULT ret = DD_OK;
    DX_WINDBG_trace();
 
    EnterCriticalSection(&ddcs);
    *ppPalette = NULL;
 
    _SEH2_TRY
    {
        ret = Internal_CreatePalette(This, dwFlags, palent, ppPalette, pUnkOuter);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = DDERR_INVALIDPARAMS;
    }
    _SEH2_END;
 
    //Versions 7 and 4 are addref'ed
    if((This->lpVtbl == &DirectDraw7_Vtable || This->lpVtbl == &DirectDraw4_Vtable) && *ppPalette != NULL)
        Main_DirectDraw_AddRef(This) ;
 
    LeaveCriticalSection(&ddcs);
    return ret;
}

Referenced by ThunkDirectDraw2_CreatePalette(), ThunkDirectDraw4_CreatePalette(), and ThunkDirectDraw_CreatePalette().

Main_DirectDraw_CreateSurface()

HRESULT WINAPI Main_DirectDraw_CreateSurface	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDDSURFACEDESC	pDDSD,
		LPDDRAWI_DDRAWSURFACE_INT *	ppSurf,
		IUnknown *	pUnkOuter
	)

Definition at line 478 of file ddraw_main.c.

{
   HRESULT ret = DDERR_GENERIC;
   DDSURFACEDESC2 dd_desc_v2;
 
   DX_WINDBG_trace();
 
    EnterCriticalSection(&ddcs);
    *ppSurf = NULL;
 
    _SEH2_TRY
    {
        if (pDDSD->dwSize == sizeof(DDSURFACEDESC))
        {
            CopyDDSurfDescToDDSurfDesc2(&dd_desc_v2, (LPDDSURFACEDESC)pDDSD);
            ret = Internal_CreateSurface(This,
                                         &dd_desc_v2,
                                         ppSurf,
                                         pUnkOuter);
        }
        else
        {
            ret = DDERR_INVALIDPARAMS;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = DDERR_INVALIDPARAMS;
    }
    _SEH2_END;
    LeaveCriticalSection(&ddcs);
    return ret;
}

Referenced by ThunkDirectDraw2_CreateSurface(), ThunkDirectDraw4_CreateSurface(), and ThunkDirectDraw_CreateSurface().

Main_DirectDraw_CreateSurface4()

HRESULT WINAPI Main_DirectDraw_CreateSurface4	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDDSURFACEDESC2	pDDSD,
		LPDDRAWI_DDRAWSURFACE_INT *	ppSurf,
		IUnknown *	pUnkOuter
	)

Definition at line 516 of file ddraw_main.c.

{
    HRESULT ret = DD_OK;
    DX_WINDBG_trace();
 
    EnterCriticalSection(&ddcs);
    *ppSurf = NULL;
 
    _SEH2_TRY
    {
        ret = Internal_CreateSurface(This, pDDSD, ppSurf, pUnkOuter);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ret = DDERR_INVALIDPARAMS;
    }
    _SEH2_END;
 
    if(*ppSurf != NULL)
        Main_DirectDraw_AddRef(This);
 
    LeaveCriticalSection(&ddcs);
    return ret;
}

Main_DirectDraw_DuplicateSurface()

HRESULT WINAPI Main_DirectDraw_DuplicateSurface	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDIRECTDRAWSURFACE7	src,
		LPDIRECTDRAWSURFACE7 *	dst
	)

Definition at line 26 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw2_DuplicateSurface(), ThunkDirectDraw4_DuplicateSurface(), and ThunkDirectDraw_DuplicateSurface().

Main_DirectDraw_EnumDisplayModes()

HRESULT WINAPI Main_DirectDraw_EnumDisplayModes	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwFlags,
		LPDDSURFACEDESC	pDDSD,
		LPVOID	pContext,
		LPDDENUMMODESCALLBACK	pCallback
	)

Definition at line 14 of file ddraw_displaymode.c.

{
    HRESULT ret = DD_OK;
    INT iMode = 0;
    DEVMODE DevMode;
 
    DX_WINDBG_trace();
 
    ZeroMemory(&DevMode, sizeof(DEVMODE));
 
    _SEH2_TRY
    {
 
        if (pDDSD != NULL)
        {
            if (pDDSD->dwSize != sizeof(DDSURFACEDESC))
            {
                 ret = DDERR_INVALIDPARAMS;
            }
        }
 
        if (IsBadCodePtr((LPVOID)pCallback))
        {
            ret = DDERR_INVALIDPARAMS;
        }
        else if ( ret == DD_OK)
        {
 
            DevMode.dmSize = sizeof(DEVMODE);
 
            while (EnumDisplaySettingsEx(NULL, iMode, &DevMode, 0) != FALSE)
            {
                DDSURFACEDESC SurfaceDesc;
 
                ZeroMemory(&SurfaceDesc, sizeof(DDSURFACEDESC));
 
                iMode++;
 
                SurfaceDesc.dwSize = sizeof (DDSURFACEDESC);
                SurfaceDesc.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
                SurfaceDesc.dwHeight = DevMode.dmPelsHeight;
                SurfaceDesc.dwWidth = DevMode.dmPelsWidth;
                SurfaceDesc.lPitch = DevMode.dmPelsWidth * DevMode.dmBitsPerPel / 8;
                SurfaceDesc.dwRefreshRate = DevMode.dmDisplayFrequency;
 
                SurfaceDesc.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
                SurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_RGB;
                // FIXME: get these
                /*
                    SurfaceDesc.ddpfPixelFormat.dwRBitMask =
                    SurfaceDesc.ddpfPixelFormat.dwGBitMask =
                    SurfaceDesc.ddpfPixelFormat.dwBBitMask =
                    SurfaceDesc.ddpfPixelFormat.dwRGBAlphaBitMask =
                */
                SurfaceDesc.ddpfPixelFormat.dwRGBBitCount = DevMode.dmBitsPerPel;
 
                // FIXME1: This->lpLcl->lpGbl->dwMonitorFrequency is not set !
                if(dwFlags & DDEDM_REFRESHRATES && SurfaceDesc.dwRefreshRate != This->lpLcl->lpGbl->dwMonitorFrequency)
                {
                    //continue;  // FIXME2: what is SurfaceDesc.dwRefreshRate supposed to be set to ?
                }
 
                // FIXME: Take case when DDEDM_STANDARDVGAMODES flag is not set in account
 
                if(pDDSD)
                {
                    if (pDDSD->dwFlags & DDSD_HEIGHT && pDDSD->dwHeight != SurfaceDesc.dwHeight)
                        continue;
 
                    if (pDDSD->dwFlags & DDSD_WIDTH && pDDSD->dwWidth != SurfaceDesc.dwWidth)
                        continue;
 
                    if (pDDSD->dwFlags & DDSD_PITCH && pDDSD->lPitch != SurfaceDesc.lPitch)
                        continue;
 
                    if (pDDSD->dwFlags & DDSD_REFRESHRATE && pDDSD->dwRefreshRate != SurfaceDesc.dwRefreshRate)
                        continue;
 
                    if (pDDSD->dwFlags & DDSD_PIXELFORMAT && pDDSD->ddpfPixelFormat.dwRGBBitCount != SurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
                        continue;  // FIXME: test for the other members of ddpfPixelFormat as well
                }
 
                if((*pCallback)(&SurfaceDesc, pContext) == DDENUMRET_CANCEL)
                    break;
            }
        }
 
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return ret;
}

Referenced by ThunkDirectDraw2_EnumDisplayModes(), ThunkDirectDraw4_EnumDisplayModes(), and ThunkDirectDraw_EnumDisplayModes().

Main_DirectDraw_EnumDisplayModes4()

HRESULT WINAPI Main_DirectDraw_EnumDisplayModes4	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwFlags,
		LPDDSURFACEDESC2	pDDSD,
		LPVOID	pContext,
		LPDDENUMMODESCALLBACK2	pCallback
	)

Definition at line 112 of file ddraw_displaymode.c.

{
    HRESULT ret = DD_OK;
    INT iMode = 0;
    DEVMODE DevMode;
 
    DX_WINDBG_trace();
 
    ZeroMemory(&DevMode, sizeof(DEVMODE));
 
    _SEH2_TRY
    {
 
        if (pDDSD != NULL)
        {
            if (pDDSD->dwSize != sizeof(DDSURFACEDESC2))
            {
                 ret = DDERR_INVALIDPARAMS;
            }
        }
 
        if (IsBadCodePtr((LPVOID)pCallback))
        {
            ret = DDERR_INVALIDPARAMS;
        }
        else if ( ret == DD_OK)
        {
 
            DevMode.dmSize = sizeof(DEVMODE);
 
            while (EnumDisplaySettingsEx(NULL, iMode, &DevMode, 0) != FALSE)
            {
                DDSURFACEDESC2 SurfaceDesc;
 
                ZeroMemory(&SurfaceDesc, sizeof(DDSURFACEDESC2));
 
                iMode++;
 
                SurfaceDesc.dwSize = sizeof (DDSURFACEDESC2);
                SurfaceDesc.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
                SurfaceDesc.dwHeight = DevMode.dmPelsHeight;
                SurfaceDesc.dwWidth = DevMode.dmPelsWidth;
                SurfaceDesc.lPitch = DevMode.dmPelsWidth * DevMode.dmBitsPerPel / 8;
                SurfaceDesc.dwRefreshRate = DevMode.dmDisplayFrequency;
 
                SurfaceDesc.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
                SurfaceDesc.ddpfPixelFormat.dwFlags = DDPF_RGB;
                // FIXME: get these
                /*
                    SurfaceDesc.ddpfPixelFormat.dwRBitMask =
                    SurfaceDesc.ddpfPixelFormat.dwGBitMask =
                    SurfaceDesc.ddpfPixelFormat.dwBBitMask =
                    SurfaceDesc.ddpfPixelFormat.dwRGBAlphaBitMask =
                */
                SurfaceDesc.ddpfPixelFormat.dwRGBBitCount = DevMode.dmBitsPerPel;
 
                // FIXME1: This->lpLcl->lpGbl->dwMonitorFrequency is not set !
                if(dwFlags & DDEDM_REFRESHRATES && SurfaceDesc.dwRefreshRate != This->lpLcl->lpGbl->dwMonitorFrequency)
                {
                    //continue;  // FIXME2: what is SurfaceDesc.dwRefreshRate supposed to be set to ?
                }
 
                // FIXME: Take case when DDEDM_STANDARDVGAMODES flag is not set in account
 
                if(pDDSD)
                {
                    if (pDDSD->dwFlags & DDSD_HEIGHT && pDDSD->dwHeight != SurfaceDesc.dwHeight)
                        continue;
 
                    if (pDDSD->dwFlags & DDSD_WIDTH && pDDSD->dwWidth != SurfaceDesc.dwWidth)
                        continue;
 
                    if (pDDSD->dwFlags & DDSD_PITCH && pDDSD->lPitch != SurfaceDesc.lPitch)
                        continue;
 
                    if (pDDSD->dwFlags & DDSD_REFRESHRATE && pDDSD->dwRefreshRate != SurfaceDesc.dwRefreshRate)
                        continue;
 
                    if (pDDSD->dwFlags & DDSD_PIXELFORMAT && pDDSD->ddpfPixelFormat.dwRGBBitCount != SurfaceDesc.ddpfPixelFormat.dwRGBBitCount)
                        continue;  // FIXME: test for the other members of ddpfPixelFormat as well
                }
 
                if((*pCallback)(&SurfaceDesc, pContext) == DDENUMRET_CANCEL)
                    break;
            }
        }
 
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return ret;
}

Main_DirectDraw_EnumSurfaces()

HRESULT WINAPI Main_DirectDraw_EnumSurfaces	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwFlags,
		LPDDSURFACEDESC	lpDDSD2,
		LPVOID	context,
		LPDDENUMSURFACESCALLBACK	callback
	)

Definition at line 34 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw2_EnumSurfaces(), ThunkDirectDraw4_EnumSurfaces(), and ThunkDirectDraw_EnumSurfaces().

Main_DirectDraw_EnumSurfaces4()

HRESULT WINAPI Main_DirectDraw_EnumSurfaces4	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwFlags,
		LPDDSURFACEDESC2	lpDDSD2,
		LPVOID	context,
		LPDDENUMSURFACESCALLBACK2	callback
	)

Definition at line 43 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Main_DirectDraw_EnumSurfaces7()

HRESULT WINAPI Main_DirectDraw_EnumSurfaces7	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwFlags,
		LPDDSURFACEDESC2	lpDDSD2,
		LPVOID	context,
		LPDDENUMSURFACESCALLBACK7	callback
	)

Definition at line 52 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Main_DirectDraw_EvaluateMode()

HRESULT WINAPI Main_DirectDraw_EvaluateMode	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	a,
		DWORD *	b
	)

Definition at line 131 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Main_DirectDraw_FlipToGDISurface()

HRESULT WINAPI Main_DirectDraw_FlipToGDISurface

(

LPDDRAWI_DIRECTDRAW_INT

This

)

Definition at line 64 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw2_FlipToGDISurface(), ThunkDirectDraw4_FlipToGDISurface(), and ThunkDirectDraw_FlipToGDISurface().

Main_DirectDraw_GetAvailableVidMem4()

HRESULT WINAPI Main_DirectDraw_GetAvailableVidMem4	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDDSCAPS2	ddscaps,
		LPDWORD	dwTotal,
		LPDWORD	dwFree
	)

Definition at line 318 of file ddraw_main.c.

{
    HRESULT retVal = DD_OK;
    DDHAL_GETAVAILDRIVERMEMORYDATA  memdata;
 
    DX_WINDBG_trace();
 
    _SEH2_TRY
    {
        // There is no HEL implementation of this api
        if (!(This->lpLcl->lpDDCB->HALDDMiscellaneous.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY) ||
            (This->lpLcl->lpGbl->dwFlags & DDRAWI_NOHARDWARE) )
        {
            retVal = DDERR_NODIRECTDRAWHW;
        }
        else
        {
            if ((!dwTotal && !dwFree) || !ddscaps)
            {
                retVal = DDERR_INVALIDPARAMS;
                _SEH2_LEAVE;
            }
 
            if ( ddscaps->dwCaps & (DDSCAPS_BACKBUFFER  | DDSCAPS_COMPLEX   | DDSCAPS_FLIP |
                                    DDSCAPS_FRONTBUFFER | DDSCAPS_PALETTE   | DDSCAPS_SYSTEMMEMORY |
                                    DDSCAPS_VISIBLE     | DDSCAPS_WRITEONLY | DDSCAPS_OWNDC))
            {
                retVal = DDERR_INVALIDPARAMS;
                _SEH2_LEAVE;
            }
 
 
            /*   ddscaps->dwCaps2 & 0x01
                this flag is outdate and are
                set to 0 in ms dxsdk  the name of
                this flag is DDSCAPS2_HARDWAREDEINTERLACE
            */
 
            if ( ddscaps->dwCaps2 & 0x01)
            {
                retVal = DDERR_INVALIDCAPS;
                _SEH2_LEAVE;
            }
 
            if ( ddscaps->dwCaps3 & ~( DDSCAPS3_MULTISAMPLE_QUALITY_MASK | DDSCAPS3_MULTISAMPLE_MASK |
                                       DDSCAPS3_RESERVED1                | DDSCAPS3_RESERVED2        |
                                       DDSCAPS3_LIGHTWEIGHTMIPMAP        | DDSCAPS3_AUTOGENMIPMAP    |
                                       DDSCAPS3_DMAP))
            {
                retVal = DDERR_INVALIDCAPS;
                _SEH2_LEAVE;
            }
 
            if ( ddscaps->dwCaps4)
            {
                retVal = DDERR_INVALIDCAPS;
                _SEH2_LEAVE;
            }
 
            ZeroMemory(&memdata, sizeof(DDHAL_GETAVAILDRIVERMEMORYDATA));
            memdata.lpDD = This->lpLcl->lpGbl;
            memdata.ddRVal = DDERR_INVALIDPARAMS;
 
            memdata.ddsCapsEx.dwCaps2 = ddscaps->dwCaps2;
            memdata.ddsCapsEx.dwCaps3 = ddscaps->dwCaps3;
 
            This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
 
            if (This->lpLcl->lpDDCB->HALDDMiscellaneous.GetAvailDriverMemory(&memdata) == DDHAL_DRIVER_NOTHANDLED)
            {
                retVal = DDERR_NODIRECTDRAWHW;
 
                if (dwTotal)
                    *dwTotal = 0;
 
                if (dwFree)
                    *dwFree = 0;
            }
            else
            {
                if (dwTotal)
                    *dwTotal = memdata.dwTotal;
 
                if (dwFree)
                    *dwFree = memdata.dwFree;
 
                retVal = memdata.ddRVal;
            }
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return retVal;
}

Referenced by Main_DirectDraw_GetAvailableVidMem(), and Main_DirectDraw_GetCaps().

Main_DirectDraw_GetCaps()

HRESULT WINAPI Main_DirectDraw_GetCaps	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDDCAPS	pDriverCaps,
		LPDDCAPS	pHELCaps
	)

Definition at line 23 of file GetCaps.c.

{
    HRESULT retVal = DDERR_INVALIDPARAMS;
 
    DX_WINDBG_trace();
 
    EnterCriticalSection( &ddcs );
 
    _SEH2_TRY
    {
        if ((!pDriverCaps) && (!pHELCaps))
        {
                retVal = DDERR_INVALIDPARAMS;
                _SEH2_LEAVE;
        }
 
        /*
         * DDCAPS_DX6 and DDCAPS_DX7 have same size so
         * we do not need check both only one of them
         */
        if ( (pDriverCaps) &&
             (pDriverCaps->dwSize != sizeof(DDCAPS_DX1) ) &&
             (pDriverCaps->dwSize != sizeof(DDCAPS_DX3) ) &&
             (pDriverCaps->dwSize != sizeof(DDCAPS_DX5) ) &&
             (pDriverCaps->dwSize !=  sizeof(DDCAPS_DX7 )) )
        {
                retVal = DDERR_INVALIDPARAMS;
                _SEH2_LEAVE;
        }
 
        /*
         * DDCAPS_DX6 and DDCAPS_DX7 have same size so
         * we do not need check both only one of them
         */
        if ( (pHELCaps) &&
             (pHELCaps->dwSize != sizeof(DDCAPS_DX1) ) &&
             (pHELCaps->dwSize != sizeof(DDCAPS_DX3) ) &&
             (pHELCaps->dwSize != sizeof(DDCAPS_DX5) ) &&
             (pHELCaps->dwSize != sizeof(DDCAPS_DX7 )) )
        {
                retVal = DDERR_INVALIDPARAMS;
                _SEH2_LEAVE;
        }
 
        if (pDriverCaps)
        {
            /* Setup hardware caps */
            DDSCAPS2 ddscaps = { 0 };
            LPDDCORECAPS CoreCaps = (LPDDCORECAPS)&This->lpLcl->lpGbl->ddCaps;
 
            DWORD dwTotal = 0;
            DWORD dwFree = 0;
 
            Main_DirectDraw_GetAvailableVidMem4(This, &ddscaps, &dwTotal, &dwFree);
 
            switch (pDriverCaps->dwSize)
            {
                case sizeof(DDCAPS_DX1):
                {
                    LPDDCAPS_DX1 myCaps = (LPDDCAPS_DX1) pDriverCaps;
 
                    if (CoreCaps->dwSize == sizeof(DDCORECAPS))
                    {
                        memcpy(myCaps, CoreCaps, sizeof(DDCAPS_DX1));
                    }
 
                    myCaps->dwVidMemFree = dwFree;
                    myCaps->dwVidMemTotal = dwTotal;
                    myCaps->dwSize = sizeof(DDCAPS_DX1);
 
                    retVal = DD_OK;
                }
                break;
 
                case sizeof(DDCAPS_DX3):
                {
                    LPDDCAPS_DX3 myCaps = (LPDDCAPS_DX3) pDriverCaps;
 
                    if (CoreCaps->dwSize == sizeof(DDCORECAPS))
                    {
                        memcpy(myCaps, CoreCaps, sizeof(DDCAPS_DX3));
                    }
 
                    myCaps->dwVidMemFree = dwFree;
                    myCaps->dwVidMemTotal = dwTotal;
                    myCaps->dwSize = sizeof(DDCAPS_DX3);
 
                    retVal = DD_OK;
                }
                break;
 
                case sizeof(DDCAPS_DX5):
                {
                    LPDDCAPS_DX5 myCaps = (LPDDCAPS_DX5) pDriverCaps;
 
                    /* FIXME  This->lpLcl->lpGbl->lpddNLVCaps are not set in startup.c
                    if (This->lpLcl->lpGbl->lpddNLVCaps->dwSize == sizeof(DDNONLOCALVIDMEMCAPS))
                    {
                        memcpy(&myCaps->dwNLVBCaps, This->lpLcl->lpGbl->lpddNLVCaps, sizeof(DDNONLOCALVIDMEMCAPS));
                    }
                    */
                    memset(&myCaps->dwNLVBCaps,0,sizeof(DDNONLOCALVIDMEMCAPS));
 
                    if (CoreCaps->dwSize == sizeof(DDCORECAPS))
                    {
                        memcpy(myCaps, CoreCaps, sizeof(DDCORECAPS));
                    }
 
                    myCaps->dwVidMemFree = dwFree;
                    myCaps->dwVidMemTotal = dwTotal;
                    myCaps->dwSize = sizeof(DDCAPS_DX5);
 
                    retVal = DD_OK;
                }
                break;
 
                /* DDCAPS_DX6 is same as DDCAPS_DX7 */
                case sizeof(DDCAPS_DX7):
                {
                    LPDDCAPS_DX7 myCaps = (LPDDCAPS_DX7) pDriverCaps;
 
                    /* FIXME  This->lpLcl->lpGbl->lpddNLVCaps are not set in startup.c
                    if (This->lpLcl->lpGbl->lpddNLVCaps->dwSize == sizeof(DDNONLOCALVIDMEMCAPS))
                    {
                        memcpy(&myCaps->dwNLVBCaps, This->lpLcl->lpGbl->lpddNLVCaps, sizeof(DDNONLOCALVIDMEMCAPS));
                    }
                    */
                    memset(&myCaps->dwNLVBCaps,0,sizeof(DDNONLOCALVIDMEMCAPS));
 
                    if (CoreCaps->dwSize == sizeof(DDCORECAPS))
                    {
                        memcpy(myCaps, CoreCaps, sizeof(DDCORECAPS));
                    }
 
                    myCaps->dwVidMemFree = dwFree;
                    myCaps->dwVidMemTotal = dwTotal;
 
                    myCaps->ddsCaps.dwCaps = myCaps->ddsOldCaps.dwCaps;
                    myCaps->ddsCaps.dwCaps2 = 0;
                    myCaps->ddsCaps.dwCaps3 = 0;
                    myCaps->ddsCaps.dwCaps4 = 0;
                    myCaps->dwSize = sizeof(DDCAPS_DX7);
 
                    retVal = DD_OK;
 
                }
                break;
 
                default:
                    retVal = DDERR_INVALIDPARAMS;
                    break;
            }
        }
 
        if (pHELCaps)
        {
            /* Setup software caps */
            LPDDCORECAPS CoreCaps = (LPDDCORECAPS)&This->lpLcl->lpGbl->ddHELCaps;
 
            DWORD dwTotal = 0;
            DWORD dwFree = 0;
 
            switch (pHELCaps->dwSize)
            {
                case sizeof(DDCAPS_DX1):
                {
                    LPDDCAPS_DX1 myCaps = (LPDDCAPS_DX1) pHELCaps;
 
                    if (CoreCaps->dwSize == sizeof(DDCORECAPS))
                    {
                        memcpy(myCaps, CoreCaps, sizeof(DDCAPS_DX1));
                    }
 
                    myCaps->dwVidMemFree = dwFree;
                    myCaps->dwVidMemTotal = dwTotal;
                    myCaps->dwSize = sizeof(DDCAPS_DX1);
 
                    retVal = DD_OK;
                }
                break;
 
                case sizeof(DDCAPS_DX3):
                {
                    LPDDCAPS_DX3 myCaps = (LPDDCAPS_DX3) pHELCaps;
 
                    if (CoreCaps->dwSize == sizeof(DDCORECAPS))
                    {
                        memcpy(myCaps, CoreCaps, sizeof(DDCAPS_DX3));
                    }
 
                    myCaps->dwVidMemFree = dwFree;
                    myCaps->dwVidMemTotal = dwTotal;
                    myCaps->dwSize = sizeof(DDCAPS_DX3);
 
                    retVal = DD_OK;
                }
                break;
 
                case sizeof(DDCAPS_DX5):
                {
                    LPDDCAPS_DX5 myCaps = (LPDDCAPS_DX5) pHELCaps;
 
                    /* FIXME  This->lpLcl->lpGbl->lpddNLVHELCaps are not set in startup.c
                    if (This->lpLcl->lpGbl->lpddNLVHELCaps->dwSize == sizeof(DDNONLOCALVIDMEMCAPS))
                    {
                        memcpy(&myCaps->dwNLVBCaps, This->lpLcl->lpGbl->lpddNLVHELCaps, sizeof(DDNONLOCALVIDMEMCAPS));
                    }
                    */
                    memset(&myCaps->dwNLVBCaps,0,sizeof(DDNONLOCALVIDMEMCAPS));
 
                    if (CoreCaps->dwSize == sizeof(DDCORECAPS))
                    {
                        memcpy(myCaps, CoreCaps, sizeof(DDCORECAPS));
                    }
 
                    myCaps->dwVidMemFree = dwFree;
                    myCaps->dwVidMemTotal = dwTotal;
                    myCaps->dwSize = sizeof(DDCAPS_DX5);
 
                    retVal = DD_OK;
                }
                break;
 
                /* DDCAPS_DX6 is same as DDCAPS_DX7 */
                case sizeof(DDCAPS_DX7):
                {
                    LPDDCAPS_DX7 myCaps = (LPDDCAPS_DX7) pHELCaps;
 
                    /* FIXME  This->lpLcl->lpGbl->lpddNLVHELCaps are not set in startup.c
                    if (This->lpLcl->lpGbl->lpddNLVHELCaps->dwSize == sizeof(DDNONLOCALVIDMEMCAPS))
                    {
                        memcpy(&myCaps->dwNLVBCaps, This->lpLcl->lpGbl->lpddNLVHELCaps, sizeof(DDNONLOCALVIDMEMCAPS));
                    }
                    */
                    memset(&myCaps->dwNLVBCaps,0,sizeof(DDNONLOCALVIDMEMCAPS));
 
                    if (CoreCaps->dwSize == sizeof(DDCORECAPS))
                    {
                        memcpy(myCaps, CoreCaps, sizeof(DDCORECAPS));
                    }
 
                    myCaps->dwVidMemFree = dwFree;
                    myCaps->dwVidMemTotal = dwTotal;
 
                    myCaps->ddsCaps.dwCaps = myCaps->ddsOldCaps.dwCaps;
                    myCaps->ddsCaps.dwCaps2 = 0;
                    myCaps->ddsCaps.dwCaps3 = 0;
                    myCaps->ddsCaps.dwCaps4 = 0;
                    myCaps->dwSize = sizeof(DDCAPS_DX7);
 
                    retVal = DD_OK;
 
                }
                break;
 
                default:
                    retVal = DDERR_INVALIDPARAMS;
                    break;
            }
        }
 
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        retVal = DD_FALSE;
    }
    _SEH2_END;
 
    LeaveCriticalSection( &ddcs );
    return  retVal;
}

Referenced by ThunkDirectDraw2_GetCaps(), ThunkDirectDraw4_GetCaps(), and ThunkDirectDraw_GetCaps().

Main_DirectDraw_GetDeviceIdentifier7()

HRESULT WINAPI Main_DirectDraw_GetDeviceIdentifier7	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDDDEVICEIDENTIFIER2	pDDDI,
		DWORD	dwFlags
	)

Definition at line 58 of file GetDeviceIdentifier.c.

{
    HRESULT retVal = DDERR_INVALIDPARAMS;
 
    BOOL found = FALSE;
    DWORD iDevNum = 0;
    DISPLAY_DEVICEA DisplayDeviceA;
    HKEY hKey;
    DWORD lpType = 0;
    DWORD strSize = MAX_DDDEVICEID_STRING;
    char *pdest;
    char* pcCnvEnd;
    long *lpdata;
 
    DX_WINDBG_trace();
 
    EnterCriticalSection( &ddcs );
 
    _SEH2_TRY
    {
        if ( (IsBadWritePtr( pDDDI, sizeof(DDDEVICEIDENTIFIER2) ) ) ||
             (dwFlags & ~DDGDI_GETHOSTIDENTIFIER))
        {
            retVal = DDERR_INVALIDPARAMS;
            _SEH2_LEAVE;
        }
 
        /* now we can start getting the driver data */
 
        while (1)
        {
            ZeroMemory(&DisplayDeviceA,sizeof(DISPLAY_DEVICEA));
 
            DisplayDeviceA.cb = sizeof(DISPLAY_DEVICEA);
 
            if ( EnumDisplayDevicesA( NULL, iDevNum, &DisplayDeviceA, 0) == 0)
            {
                retVal = DDERR_INVALIDPARAMS;
                break;
            }
 
            if (_stricmp(DisplayDeviceA.DeviceName, This->lpLcl->lpGbl->cDriverName) != 0)
            {
                /* if we got another device like hardware mpeg decoder or video card or another drv */
                found = TRUE;
            }
            else if (DisplayDeviceA.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
            {
                /* double check if it primary driver we just found */
                if (!_stricmp( This->lpLcl->lpGbl->cDriverName, "DISPLAY"))
                {
                    /* yeah we found it */
                    found = TRUE;
                }
            }
 
            if (found != FALSE)
            {
                /* we found our driver now we start setup it */
                if (!_strnicmp(DisplayDeviceA.DeviceKey,"\\REGISTRY\\Machine\\",18))
                {
                    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, &DisplayDeviceA.DeviceKey[18], 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS )
                    {
 
                        if (RegQueryValueExA(hKey, "InstalledDisplayDrivers",0, &lpType, (LPBYTE)pDDDI->szDriver, &strSize) != ERROR_SUCCESS)
                        {
                            ZeroMemory(pDDDI->szDriver,MAX_DDDEVICEID_STRING);
                        }
                        else
                        {
                            strcat(pDDDI->szDriver,".dll");
                        }
                        RegCloseKey(hKey);
                    }
 
                    strcpy( pDDDI->szDescription, DisplayDeviceA.DeviceString);
                    pDDDI->liDriverVersion.HighPart = 0;
                    pDDDI->liDriverVersion.LowPart = 0;
 
                    pdest = strstr(DisplayDeviceA.DeviceID,"REV_");
                    pDDDI->dwRevision =  strtol ( &pdest[4], &pcCnvEnd, 16);
 
                    pdest = strstr(DisplayDeviceA.DeviceID,"SUBSYS_");
                    pDDDI->dwSubSysId =  strtol ( &pdest[7], &pcCnvEnd, 16);
 
                    pdest = strstr(DisplayDeviceA.DeviceID,"DEV_");
                    pDDDI->dwDeviceId = strtol ( &pdest[4], &pcCnvEnd, 16);
 
                    pdest = strstr(DisplayDeviceA.DeviceID,"VEN_");
                    pDDDI->dwVendorId =strtol ( &pdest[4], &pcCnvEnd, 16);
 
                    /* Count out the guidDeviceIdentifier */
                    memcpy(&pDDDI->guidDeviceIdentifier, &CLSID_DirectDraw,sizeof(GUID));
 
                    pDDDI->guidDeviceIdentifier.Data1 ^= pDDDI->dwVendorId;
 
                    lpdata = (long *)&pDDDI->guidDeviceIdentifier.Data2;
                    *lpdata ^= pDDDI->dwDeviceId;
 
                    lpdata = (long *)&pDDDI->guidDeviceIdentifier.Data4;
                    *lpdata = (*lpdata ^ pDDDI->dwSubSysId) ^ pDDDI->liDriverVersion.LowPart;
 
                    lpdata = (long *)&pDDDI->guidDeviceIdentifier.Data4[4];
                    *lpdata = (*lpdata ^ pDDDI->dwRevision) ^ pDDDI->liDriverVersion.HighPart;
 
                    /* FIXME pDDDI->dwWHQLLevel
                     * we leave this with no informations, I do not known
                     * if program care for it, I mark this api done, and
                     * tested, no bugs was found in it
                     */
                    pDDDI->dwWHQLLevel = 0;
                    retVal = DD_OK;
                }
 
                break;
            }
 
            iDevNum++;
         }
 
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        retVal = DD_FALSE;
    }
    _SEH2_END;
 
    LeaveCriticalSection( &ddcs );
    return retVal;
}

Referenced by Main_DirectDraw_GetDeviceIdentifier().

Main_DirectDraw_GetDisplayMode()

HRESULT WINAPI Main_DirectDraw_GetDisplayMode	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDDSURFACEDESC	pDDSD
	)

Definition at line 366 of file ddraw_displaymode.c.

{
    HRESULT retVal = DD_OK;
    DX_WINDBG_trace();
 
    _SEH2_TRY
    {
        if(IsBadWritePtr(pDDSD,sizeof(LPDDSURFACEDESC)))
        {
            retVal = DDERR_INVALIDPARAMS;
        }
        else if (pDDSD->dwSize != sizeof(DDSURFACEDESC))
        {
             retVal = DDERR_INVALIDPARAMS;
        }
        else
        {
            // FIXME: More structure members might need to be filled
 
            pDDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
            pDDSD->dwHeight = This->lpLcl->lpGbl->vmiData.dwDisplayHeight;
            pDDSD->dwWidth = This->lpLcl->lpGbl->vmiData.dwDisplayWidth;
            pDDSD->ddpfPixelFormat = This->lpLcl->lpGbl->vmiData.ddpfDisplay;
            pDDSD->dwRefreshRate = This->lpLcl->lpGbl->dwMonitorFrequency;
            pDDSD->lPitch = This->lpLcl->lpGbl->vmiData.lDisplayPitch;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return retVal;
}

Referenced by ThunkDirectDraw2_GetDisplayMode(), ThunkDirectDraw4_GetDisplayMode(), and ThunkDirectDraw_GetDisplayMode().

Main_DirectDraw_GetDisplayMode4()

HRESULT WINAPI Main_DirectDraw_GetDisplayMode4	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDDSURFACEDESC2	pDDSD
	)

Definition at line 402 of file ddraw_displaymode.c.

{
    HRESULT retVal = DD_OK;
    DX_WINDBG_trace();
 
    _SEH2_TRY
    {
        if(IsBadWritePtr(pDDSD,sizeof(LPDDSURFACEDESC2)))
        {
            retVal = DDERR_INVALIDPARAMS;
        }
        else if (pDDSD->dwSize != sizeof(DDSURFACEDESC2))
        {
             retVal = DDERR_INVALIDPARAMS;
        }
        else
        {
            // FIXME: More structure members might need to be filled
 
            pDDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
            pDDSD->dwHeight = This->lpLcl->lpGbl->vmiData.dwDisplayHeight;
            pDDSD->dwWidth = This->lpLcl->lpGbl->vmiData.dwDisplayWidth;
            pDDSD->ddpfPixelFormat = This->lpLcl->lpGbl->vmiData.ddpfDisplay;
            pDDSD->dwRefreshRate = This->lpLcl->lpGbl->dwMonitorFrequency;
            pDDSD->lPitch = This->lpLcl->lpGbl->vmiData.lDisplayPitch;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return retVal;
}

Main_DirectDraw_GetFourCCCodes()

HRESULT WINAPI Main_DirectDraw_GetFourCCCodes	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDWORD	lpNumCodes,
		LPDWORD	lpCodes
	)

Definition at line 418 of file ddraw_main.c.

{
    HRESULT retVal = DD_OK;
 
    DX_WINDBG_trace();
 
 
     // EnterCriticalSection(&ddcs);
 
    _SEH2_TRY
    {
        if(IsBadWritePtr(lpNumCodes,sizeof(LPDWORD)))
        {
            retVal = DDERR_INVALIDPARAMS;
        }
        else
        {
            if(!(IsBadWritePtr(lpNumCodes,sizeof(LPDWORD))))
            {
                DWORD size;
 
                if (*lpNumCodes > This->lpLcl->lpGbl->dwNumFourCC)
                {
                    *lpNumCodes = This->lpLcl->lpGbl->dwNumFourCC;
                }
 
                size =  *lpNumCodes * sizeof(DWORD);
 
                if(!IsBadWritePtr(lpCodes, size ))
                {
                    memcpy(lpCodes, This->lpLcl->lpGbl->lpdwFourCC, size );
                }
                else
                {
                    *lpNumCodes = This->lpLcl->lpGbl->dwNumFourCC;
                }
            }
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    //LeaveCriticalSection(&ddcs);
    return retVal;
}

Referenced by ThunkDirectDraw2_GetFourCCCodes(), ThunkDirectDraw4_GetFourCCCodes(), and ThunkDirectDraw_GetFourCCCodes().

Main_DirectDraw_GetGDISurface()

HRESULT WINAPI Main_DirectDraw_GetGDISurface	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDIRECTDRAWSURFACE7 *	lplpGDIDDSSurface
	)

Definition at line 72 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw2_GetGDISurface(), ThunkDirectDraw4_GetGDISurface(), and ThunkDirectDraw_GetGDISurface().

Main_DirectDraw_GetMonitorFrequency()

HRESULT WINAPI Main_DirectDraw_GetMonitorFrequency	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDWORD	lpFreq
	)

Definition at line 333 of file ddraw_displaymode.c.

{
    HRESULT retVal = DD_OK;
    DX_WINDBG_trace();
 
    _SEH2_TRY
    {
        if(IsBadWritePtr(lpFreq,sizeof(LPDWORD)))
        {
            retVal = DDERR_INVALIDPARAMS;
        }
        else
        {
            if (This->lpLcl->lpGbl->dwMonitorFrequency)
            {
                *lpFreq = This->lpLcl->lpGbl->dwMonitorFrequency;
            }
            else
            {
                retVal = DDERR_UNSUPPORTED;
            }
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
      retVal = DD_FALSE;
    }
    _SEH2_END;
 
    return retVal;
}

Referenced by ThunkDirectDraw2_GetMonitorFrequency(), ThunkDirectDraw4_GetMonitorFrequency(), and ThunkDirectDraw_GetMonitorFrequency().

Main_DirectDraw_GetScanLine()

HRESULT WINAPI Main_DirectDraw_GetScanLine	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPDWORD	lpdwScanLine
	)

Definition at line 80 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw2_GetScanLine(), ThunkDirectDraw4_GetScanLine(), and ThunkDirectDraw_GetScanLine().

Main_DirectDraw_GetSurfaceFromDC()

HRESULT WINAPI Main_DirectDraw_GetSurfaceFromDC	(	LPDDRAWI_DIRECTDRAW_INT	This,
		HDC	hdc,
		LPDIRECTDRAWSURFACE7 *	lpDDS
	)

Definition at line 104 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw4_GetSurfaceFromDC().

Main_DirectDraw_GetVerticalBlankStatus()

HRESULT WINAPI Main_DirectDraw_GetVerticalBlankStatus	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPBOOL	lpbIsInVB
	)

Definition at line 87 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw2_GetVerticalBlankStatus(), ThunkDirectDraw4_GetVerticalBlankStatus(), and ThunkDirectDraw_GetVerticalBlankStatus().

Main_DirectDraw_Initialize()

HRESULT WINAPI Main_DirectDraw_Initialize	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPGUID	lpGUID
	)

Definition at line 247 of file ddraw_main.c.

{
    return DDERR_ALREADYINITIALIZED;
}

Main_DirectDraw_QueryInterface()

HRESULT WINAPI Main_DirectDraw_QueryInterface	(	LPDDRAWI_DIRECTDRAW_INT	This,
		REFIID	id,
		LPVOID *	obj
	)

Definition at line 37 of file ddraw_main.c.

{
    HRESULT retVal = DD_OK;
 
    DX_WINDBG_trace();
 
    _SEH2_TRY
    {
        /* FIXME
            the D3D object can be obtained from here
            Direct3D7
        */
        if (IsEqualGUID(&IID_IDirectDraw7, id))
        {
            if (This->lpVtbl != &DirectDraw7_Vtable)
            {
                This = internal_directdraw_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
 
            This->lpVtbl = &DirectDraw7_Vtable;
            *obj = This;
            Main_DirectDraw_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDraw4, id))
        {
            if (This->lpVtbl != &DirectDraw4_Vtable)
            {
                This = internal_directdraw_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
 
            This->lpVtbl = &DirectDraw4_Vtable;
            *obj = This;
            Main_DirectDraw_AddRef(This);
        }
 
        else if (IsEqualGUID(&IID_IDirectDraw2, id))
        {
            if (This->lpVtbl != &DirectDraw2_Vtable)
            {
                This = internal_directdraw_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
 
            This->lpVtbl = &DirectDraw2_Vtable;
            *obj = This;
            Main_DirectDraw_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDraw, id))
        {
            if (This->lpVtbl != &DirectDraw_Vtable)
            {
                This = internal_directdraw_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
 
            This->lpVtbl = &DirectDraw_Vtable;
            *obj = This;
            Main_DirectDraw_AddRef(This);
        }
        else
        {
            *obj = NULL;
            DX_STUB_str("E_NOINTERFACE");
            retVal = E_NOINTERFACE;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return retVal;
}

Referenced by ThunkDirectDraw2_QueryInterface(), ThunkDirectDraw4_QueryInterface(), and ThunkDirectDraw_QueryInterface().

Main_DirectDraw_Release()

ULONG WINAPI Main_DirectDraw_Release

(

LPDDRAWI_DIRECTDRAW_INT

This

)

Definition at line 194 of file ddraw_main.c.

{
    ULONG Counter = 0;
 
    DX_WINDBG_trace();
 
    /* Lock the thread */
    AcquireDDThreadLock();
 
    _SEH2_TRY
    {
        if (This!=NULL)
        {
            This->lpLcl->dwLocalRefCnt--;
            This->dwIntRefCnt--;
 
            if (This->lpLcl->lpGbl != NULL)
            {
                This->lpLcl->lpGbl->dwRefCnt--;
            }
 
            if ( This->lpLcl->lpGbl->dwRefCnt == 0)
            {
                // set resolution back to the one in registry
                /*if(This->cooperative_level & DDSCL_EXCLUSIVE)
                {
                    ChangeDisplaySettings(NULL, 0);
                }*/
 
                Cleanup(This);
            }
 
            /* FIXME cleanup being not call why ?? */
            Counter = This->dwIntRefCnt;
        }
        else
        {
            Counter = This->dwIntRefCnt;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    /* Release the thread lock */
    ReleaseDDThreadLock();
 
    return Counter;
}

Referenced by DirectDrawPalette_Release(), Main_DDrawSurface_Release4(), ThunkDirectDraw2_Release(), ThunkDirectDraw4_Release(), and ThunkDirectDraw_Release().

Main_DirectDraw_RestoreAllSurfaces()

HRESULT WINAPI Main_DirectDraw_RestoreAllSurfaces

(

LPDDRAWI_DIRECTDRAW_INT

This

)

Definition at line 111 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw4_RestoreAllSurfaces().

Main_DirectDraw_RestoreDisplayMode()

HRESULT WINAPI Main_DirectDraw_RestoreDisplayMode

(

LPDDRAWI_DIRECTDRAW_INT

This

)

Definition at line 306 of file ddraw_displaymode.c.

{
    DX_WINDBG_trace();
 
    _SEH2_TRY
    {
        BOOL ModeChanged;
 
        ChangeDisplaySettings(NULL, 0);
 
        // Update Interals
 
 
        This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
        DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
        StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
 
    return DD_OK;
}

Referenced by ThunkDirectDraw2_RestoreDisplayMode(), ThunkDirectDraw4_RestoreDisplayMode(), and ThunkDirectDraw_RestoreDisplayMode().

Main_DirectDraw_SetCooperativeLevel()

HRESULT WINAPI Main_DirectDraw_SetCooperativeLevel	(	LPDDRAWI_DIRECTDRAW_INT	This,
		HWND	hwnd,
		DWORD	cooplevel
	)

• Handle those levels first which set various hwnds *‍/
• DDSCL_NORMAL or DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE *‍/

Definition at line 13 of file ddraw_setcooperativelevel.c.

{
    HRESULT retVal = DD_OK;
 
 
    DX_WINDBG_trace();
 
    _SEH2_TRY
    {
 
        if (hwnd && !IsWindow(hwnd))
        {
            retVal = DDERR_INVALIDPARAMS;
             _SEH2_LEAVE;
        }
 
        // FIXME test if 0x20 exists as a flag and what thuse it do
        if ( cooplevel & (~(DDSCL_FPUPRESERVE | DDSCL_FPUSETUP | DDSCL_MULTITHREADED | DDSCL_CREATEDEVICEWINDOW |
                            DDSCL_SETDEVICEWINDOW | DDSCL_SETFOCUSWINDOW | DDSCL_ALLOWMODEX | DDSCL_EXCLUSIVE |
                            DDSCL_NORMAL | DDSCL_NOWINDOWCHANGES | DDSCL_ALLOWREBOOT | DDSCL_FULLSCREEN)))
        {
 
              retVal = DDERR_INVALIDPARAMS;
             _SEH2_LEAVE;
        }
 
        if (!( cooplevel & (DDSCL_NORMAL | DDSCL_EXCLUSIVE | DDSCL_SETFOCUSWINDOW)))
        {
              retVal = DDERR_INVALIDPARAMS;
             _SEH2_LEAVE;
        }
 
        if ((cooplevel & DDSCL_FPUSETUP) && (cooplevel & DDSCL_FPUPRESERVE))
        {
              retVal = DDERR_INVALIDPARAMS;
             _SEH2_LEAVE;
        }
 
        if ((cooplevel & DDSCL_EXCLUSIVE) && (!(cooplevel & DDSCL_FULLSCREEN)))
        {
              retVal = DDERR_INVALIDPARAMS;
             _SEH2_LEAVE;
        }
 
        if ((cooplevel & DDSCL_ALLOWMODEX) &&  (!(cooplevel & DDSCL_FULLSCREEN)))
        {
              retVal = DDERR_INVALIDPARAMS;
             _SEH2_LEAVE;
        }
 
        if ((cooplevel & (DDSCL_CREATEDEVICEWINDOW | DDSCL_SETFOCUSWINDOW)))
        {
              retVal = DDERR_INVALIDPARAMS;
             _SEH2_LEAVE;
        }
 
        if (!cooplevel)
        {
              retVal = DDERR_INVALIDPARAMS;
             _SEH2_LEAVE;
        }
 
 
        /* NORMAL MODE */
        if(!(cooplevel & (~DDSCL_NORMAL)))
        {
            /* FIXME in setup.c  set DDRAWI_UMODELOADED | DDRAWI_DISPLAYDRV | DDRAWI_EMULATIONINITIALIZED | DDRAWI_GDIDRV  | DDRAWI_ATTACHEDTODESKTOP */
            /* FIXME in setup.c This->lpLcl->lpGbl->dwFlags =  */
 
            This->lpLcl->dwLocalFlags = DDRAWILCL_SETCOOPCALLED | DDRAWILCL_DIRECTDRAW7 ;
            This->lpLcl->hWnd = (ULONG_PTR) hwnd;
            This->lpLcl->hFocusWnd = (ULONG_PTR) hwnd;
            This->lpLcl->lpGbl->lpExclusiveOwner=NULL;
 
            retVal = DD_OK;
            _SEH2_LEAVE;
        }
 
        /* FULLSCREEN */
        if ((!(cooplevel & (~(DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN)))) ||
           (!(cooplevel & (~(DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX)))))
 
        {
            /* FIXME in setup.c This->lpLcl->lpGbl->dwFlags =  */
 
            if (hwnd == NULL)
            {
                retVal = DDERR_INVALIDPARAMS;
                _SEH2_LEAVE;
            }
 
            if( (GetWindowLongPtr(hwnd, GWL_STYLE) & WS_CHILD) )
            {
                retVal = DDERR_INVALIDPARAMS;
                _SEH2_LEAVE;
            }
 
            if( (This->lpLcl->lpGbl->lpExclusiveOwner != NULL) &&
                (This->lpLcl->lpGbl->lpExclusiveOwner != This->lpLcl) )
            {
                retVal = DDERR_INVALIDPARAMS;
                _SEH2_LEAVE;
            }
 
            This->lpLcl->lpGbl->lpExclusiveOwner = This-> lpLcl;
 
            This->lpLcl->dwLocalFlags = DDRAWILCL_SETCOOPCALLED     | DDRAWILCL_DIRECTDRAW7  | DDRAWILCL_HOOKEDHWND |
                                        DDRAWILCL_HASEXCLUSIVEMODE  | DDRAWILCL_ISFULLSCREEN | DDRAWILCL_ACTIVEYES |
                                        DDRAWILCL_CURSORCLIPPED;
 
            if (cooplevel & DDSCL_ALLOWMODEX)
            {
                This->lpLcl->dwLocalFlags = This->lpLcl->dwLocalFlags | DDRAWILCL_ALLOWMODEX;
            }
 
            This->lpLcl->hWnd = (ULONG_PTR) hwnd;
            This->lpLcl->hFocusWnd = (ULONG_PTR) hwnd;
 
 
            /* FIXME fullscreen are not finuish */
 
            retVal = DD_OK;
            _SEH2_LEAVE;
        }
 
    /*
 * Code from wine, this functions have been cut and paste from wine 0.9.35
 * and have been modify allot and are still in devloping so it match with
 * msdn document struct and flags
 */
 
 
 
        //if(cooplevel & DDSCL_SETFOCUSWINDOW)
        //{
        //
 
        //    if(This->lpLcl->dwLocalFlags & DDRAWILCL_SETCOOPCALLED)
        //    {
        //        retVal = DDERR_HWNDALREADYSET;
        //         _SEH2_LEAVE;
        //    }
        //    else if( (This->lpLcl->dwLocalFlags & DDRAWILCL_ISFULLSCREEN) && window)
        //    {
        //        retVal = DDERR_HWNDALREADYSET;
        //        _SEH2_LEAVE;
        //    }
 
        //    This->lpLcl->hFocusWnd = (ULONG_PTR) hwnd;
 
 
        //    /* Won't use the hwnd param for anything else */
        //    hwnd = NULL;
 
        //    /* Use the focus window for drawing too */
        //    This->lpLcl->hWnd = This->lpLcl->hFocusWnd;
 
        //}
 
        //if(cooplevel & DDSCL_NORMAL)
        //{
        //    /* Can't coexist with fullscreen or exclusive */
        //    if(cooplevel & (DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE) )
        //    {
        //        retVal = DDERR_INVALIDPARAMS;
        //         _SEH2_LEAVE;
        //    }
 
        //    /* Switching from fullscreen? */
        //    if(This->lpLcl->dwLocalFlags & DDRAWILCL_ISFULLSCREEN)
        //    {
        //        /* Restore the display mode */
        //        Main_DirectDraw_RestoreDisplayMode(iface);
 
        //        This->lpLcl->dwLocalFlags &= ~DDRAWILCL_ISFULLSCREEN;
        //        This->lpLcl->dwLocalFlags &= ~DDRAWILCL_HASEXCLUSIVEMODE;
        //        This->lpLcl->dwLocalFlags &= ~DDRAWILCL_ALLOWMODEX;
        //    }
 
        //    /* Don't override focus windows or private device windows */
        //    if( hwnd &&
        //        !(This->lpLcl->hFocusWnd) &&
        //        !(This->lpLcl->dwObsolete1) &&
        //        (hwnd != window) )
        //    {
        //        This->lpLcl->hWnd = (ULONG_PTR)hwnd;
        //    }
 
        //    /* FIXME GL
        //        IWineD3DDevice_SetFullscreen(This->wineD3DDevice,
        //                             FALSE);
        //    */
        //    }
        //    else if(cooplevel & DDSCL_FULLSCREEN)
        //    {
        //        /* Needs DDSCL_EXCLUSIVE */
        //        if(!(cooplevel & DDSCL_EXCLUSIVE) )
        //        {
        //            retVal = DDERR_INVALIDPARAMS;
        //            _SEH2_LEAVE;
        //        }
 
        //        /* Switch from normal to full screen mode? */
        //        if (!(This->lpLcl->dwLocalFlags & DDRAWILCL_HASEXCLUSIVEMODE))
        //        {
        //            /* FIXME GL
        //            IWineD3DDevice_SetFullscreen(This->wineD3DDevice,
        //                                 TRUE);
        //            */
        //        }
 
        //        /* Don't override focus windows or private device windows */
        //        if( hwnd &&
        //            !(This->lpLcl->hFocusWnd) &&
        //            !(This->lpLcl->dwObsolete1) &&
        //            (hwnd != window) )
        //        {
        //            This->lpLcl->hWnd =  (ULONG_PTR) hwnd;
        //        }
        //    }
        //    else if(cooplevel & DDSCL_EXCLUSIVE)
        //    {
        //        retVal = DDERR_INVALIDPARAMS;
        //        _SEH2_LEAVE;
        //    }
 
        //    if(cooplevel & DDSCL_CREATEDEVICEWINDOW)
        //    {
        //        /* Don't create a device window if a focus window is set */
        //        if( !This->lpLcl->hFocusWnd)
        //        {
        //            HWND devicewindow = CreateWindowExW(0, classname, L"DDraw device window",
        //                                        WS_POPUP, 0, 0,
        //                                        GetSystemMetrics(SM_CXSCREEN),
        //                                        GetSystemMetrics(SM_CYSCREEN),
        //                                        NULL, NULL, GetModuleHandleW(0), NULL);
 
        //            ShowWindow(devicewindow, SW_SHOW);   /* Just to be sure */
 
        //            This->lpLcl->dwObsolete1 = (DWORD)devicewindow;
        //        }
        //    }
 
        //    if(cooplevel & DDSCL_MULTITHREADED && !(This->lpLcl->dwLocalFlags & DDRAWILCL_MULTITHREADED))
        //    {
        //        /* FIXME GL
        //         * IWineD3DDevice_SetMultithreaded(This->wineD3DDevice);
        //         */
        //    }
 
 
 
        //    /* Store the cooperative_level */
 
        //    /* FIXME GL
        //     * This->cooperative_level |= cooplevel;
        //     */
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
 
    return retVal;
}

Referenced by ThunkDirectDraw2_SetCooperativeLevel(), ThunkDirectDraw4_SetCooperativeLevel(), and ThunkDirectDraw_SetCooperativeLevel().

Main_DirectDraw_SetDisplayMode()

HRESULT WINAPI Main_DirectDraw_SetDisplayMode	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwWidth,
		DWORD	dwHeight,
		DWORD	dwBPP
	)

Definition at line 210 of file ddraw_displaymode.c.

{
    DX_WINDBG_trace();
 
    return Main_DirectDraw_SetDisplayMode2 (This, dwWidth, dwHeight, dwBPP, 0, 0 );
}

Referenced by ThunkDirectDraw2_SetDisplayMode(), ThunkDirectDraw4_SetDisplayMode(), and ThunkDirectDraw_SetDisplayMode().

Main_DirectDraw_SetDisplayMode2()

HRESULT WINAPI Main_DirectDraw_SetDisplayMode2	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwWidth,
		DWORD	dwHeight,
		DWORD	dwBPP,
		DWORD	dwRefreshRate,
		DWORD	dwFlags
	)

Definition at line 218 of file ddraw_displaymode.c.

{
    HRESULT ret = DD_OK;
    DX_WINDBG_trace();
 
    _SEH2_TRY
    {
        // FIXME: Check primary if surface is locked / busy etc.
 
        // Check Parameters
        if(dwFlags != 0)
        {
            ret = DDERR_INVALIDPARAMS;
        }
        else
        {
            if ((!dwHeight || This->lpLcl->lpGbl->vmiData.dwDisplayHeight == dwHeight) &&
                (!dwWidth || This->lpLcl->lpGbl->vmiData.dwDisplayWidth == dwWidth)  &&
                (!dwBPP || This->lpLcl->lpGbl->vmiData.ddpfDisplay.dwRGBBitCount == dwBPP) &&
                (!dwRefreshRate || This->lpLcl->lpGbl->dwMonitorFrequency == dwRefreshRate))
            {
                ret = DD_OK; // nothing to do here for us
            }
            else
            {
                LONG retval;
                // Here we go
                DEVMODE DevMode;
                ZeroMemory(&DevMode, sizeof(DEVMODE));
                DevMode.dmSize = sizeof(DEVMODE);
 
                if (dwHeight)
                    DevMode.dmFields |= DM_PELSHEIGHT;
                if (dwWidth)
                    DevMode.dmFields |= DM_PELSWIDTH;
                if (dwBPP)
                    DevMode.dmFields |= DM_BITSPERPEL;
                if (dwRefreshRate)
                    DevMode.dmFields |= DM_DISPLAYFREQUENCY;
 
                DevMode.dmPelsHeight = dwHeight;
                DevMode.dmPelsWidth = dwWidth;
                DevMode.dmBitsPerPel = dwBPP;
                DevMode.dmDisplayFrequency = dwRefreshRate;
 
                DX_WINDBG_trace_res(dwWidth, dwHeight,dwBPP, dwRefreshRate);
 
                retval = ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN);
                /* FIXME: Are we supposed to set CDS_SET_PRIMARY as well ? */
 
                if(retval == DISP_CHANGE_BADMODE)
                {
                    /* Note : it seam ms ddraw ignore this and try using the bad mode any case.
                     * tested with Ati HD2400 that only support 16 and 32 Bpp in windows
                     */
                    DX_STUB_str("Warning ChangeDisplaySettings return DISP_CHANGE_BADMODE, but ddraw.dll ignore it\n");
 
                    //ret = DDERR_UNSUPPORTED;
                    BOOL ModeChanged;
                    This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
                    DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
                    StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
                }
                else if(retval != DISP_CHANGE_SUCCESSFUL)
                {
                    ret = DDERR_GENERIC;
                }
                else
                {
                    // Update Interals
                    BOOL ModeChanged;
                    This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
                    DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
                    StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
                }
            }
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    return ret;
}

Referenced by Main_DirectDraw_SetDisplayMode().

Main_DirectDraw_StartModeTest()

HRESULT WINAPI Main_DirectDraw_StartModeTest	(	LPDDRAWI_DIRECTDRAW_INT	This,
		LPSIZE	pModes,
		DWORD	dwNumModes,
		DWORD	dwFlags
	)

Definition at line 124 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Main_DirectDraw_TestCooperativeLevel()

HRESULT WINAPI Main_DirectDraw_TestCooperativeLevel

(

LPDDRAWI_DIRECTDRAW_INT

This

)

Definition at line 117 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw4_TestCooperativeLevel().

Main_DirectDraw_WaitForVerticalBlank()

HRESULT WINAPI Main_DirectDraw_WaitForVerticalBlank	(	LPDDRAWI_DIRECTDRAW_INT	This,
		DWORD	dwFlags,
		HANDLE	h
	)

Definition at line 97 of file ddraw_stubs.c.

{
    DX_WINDBG_trace();
    DX_STUB;
}

Referenced by ThunkDirectDraw2_WaitForVerticalBlank(), ThunkDirectDraw4_WaitForVerticalBlank(), and ThunkDirectDraw_WaitForVerticalBlank().