surface.h File Reference

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

Go to the source code of this file.

Functions
ULONG WINAPI	Main_DDrawSurface_AddRef (LPDDRAWI_DDRAWSURFACE_INT)
ULONG WINAPI	Main_DDrawSurface_Release (LPDDRAWI_DDRAWSURFACE_INT)
HRESULT WINAPI	Main_DDrawSurface_QueryInterface (LPDDRAWI_DDRAWSURFACE_INT, REFIID, LPVOID *)
HRESULT WINAPI	Main_DDrawSurface_Blt (LPDDRAWI_DDRAWSURFACE_INT, LPRECT, LPDDRAWI_DDRAWSURFACE_INT, LPRECT, DWORD, LPDDBLTFX)
HRESULT WINAPI	Main_DDrawSurface_BltBatch (LPDDRAWI_DDRAWSURFACE_INT, LPDDBLTBATCH, DWORD, DWORD)
HRESULT WINAPI	Main_DDrawSurface_BltFast (LPDDRAWI_DDRAWSURFACE_INT, DWORD, DWORD, LPDDRAWI_DDRAWSURFACE_INT, LPRECT, DWORD)
HRESULT WINAPI	Main_DDrawSurface_DeleteAttachedSurface (LPDDRAWI_DDRAWSURFACE_INT, DWORD, LPDDRAWI_DDRAWSURFACE_INT)
HRESULT WINAPI	Main_DDrawSurface_EnumAttachedSurfaces (LPDDRAWI_DDRAWSURFACE_INT, LPVOID, LPDDENUMSURFACESCALLBACK7)
HRESULT WINAPI	Main_DDrawSurface_EnumOverlayZOrders (LPDDRAWI_DDRAWSURFACE_INT, DWORD, LPVOID, LPDDENUMSURFACESCALLBACK7)
HRESULT WINAPI	Main_DDrawSurface_Flip (LPDDRAWI_DDRAWSURFACE_INT, LPDDRAWI_DDRAWSURFACE_INT, DWORD)
HRESULT WINAPI	Main_DDrawSurface_FreePrivateData (LPDDRAWI_DDRAWSURFACE_INT, REFGUID)
HRESULT WINAPI	Main_DDrawSurface_GetAttachedSurface (LPDDRAWI_DDRAWSURFACE_INT, LPDDSCAPS2, LPDDRAWI_DDRAWSURFACE_INT *)
HRESULT WINAPI	Main_DDrawSurface_GetBltStatus (LPDDRAWI_DDRAWSURFACE_INT, DWORD dwFlags)
HRESULT WINAPI	Main_DDrawSurface_GetCaps (LPDDRAWI_DDRAWSURFACE_INT, LPDDSCAPS2 pCaps)
HRESULT WINAPI	Main_DDrawSurface_GetClipper (LPDDRAWI_DDRAWSURFACE_INT, LPDIRECTDRAWCLIPPER *)
HRESULT WINAPI	Main_DDrawSurface_GetColorKey (LPDDRAWI_DDRAWSURFACE_INT, DWORD, LPDDCOLORKEY)
HRESULT WINAPI	Main_DDrawSurface_GetDC (LPDDRAWI_DDRAWSURFACE_INT, HDC *)
HRESULT WINAPI	Main_DDrawSurface_GetDDInterface (LPDDRAWI_DDRAWSURFACE_INT, LPVOID *)
HRESULT WINAPI	Main_DDrawSurface_GetFlipStatus (LPDDRAWI_DDRAWSURFACE_INT, DWORD)
HRESULT WINAPI	Main_DDrawSurface_GetLOD (LPDDRAWI_DDRAWSURFACE_INT, LPDWORD)
HRESULT WINAPI	Main_DDrawSurface_GetOverlayPosition (LPDDRAWI_DDRAWSURFACE_INT, LPLONG, LPLONG)
HRESULT WINAPI	Main_DDrawSurface_GetPalette (LPDDRAWI_DDRAWSURFACE_INT, LPDIRECTDRAWPALETTE *)
HRESULT WINAPI	Main_DDrawSurface_GetPixelFormat (LPDDRAWI_DDRAWSURFACE_INT, LPDDPIXELFORMAT)
HRESULT WINAPI	Main_DDrawSurface_GetPriority (LPDDRAWI_DDRAWSURFACE_INT, LPDWORD)
HRESULT WINAPI	Main_DDrawSurface_GetPrivateData (LPDDRAWI_DDRAWSURFACE_INT, REFGUID, LPVOID, LPDWORD)
HRESULT WINAPI	Main_DDrawSurface_GetSurfaceDesc (LPDDRAWI_DDRAWSURFACE_INT, LPDDSURFACEDESC2)
HRESULT WINAPI	Main_DDrawSurface_GetUniquenessValue (LPDDRAWI_DDRAWSURFACE_INT, LPDWORD)
HRESULT WINAPI	Main_DDrawSurface_IsLost (LPDDRAWI_DDRAWSURFACE_INT)
HRESULT WINAPI	Main_DDrawSurface_PageLock (LPDDRAWI_DDRAWSURFACE_INT, DWORD)
HRESULT WINAPI	Main_DDrawSurface_PageUnlock (LPDDRAWI_DDRAWSURFACE_INT, DWORD)
HRESULT WINAPI	Main_DDrawSurface_ReleaseDC (LPDDRAWI_DDRAWSURFACE_INT, HDC)
HRESULT WINAPI	Main_DDrawSurface_SetClipper (LPDDRAWI_DDRAWSURFACE_INT, LPDIRECTDRAWCLIPPER)
HRESULT WINAPI	Main_DDrawSurface_SetColorKey (LPDDRAWI_DDRAWSURFACE_INT, DWORD, LPDDCOLORKEY)
HRESULT WINAPI	Main_DDrawSurface_SetOverlayPosition (LPDDRAWI_DDRAWSURFACE_INT, LONG, LONG)
HRESULT WINAPI	Main_DDrawSurface_SetPalette (LPDDRAWI_DDRAWSURFACE_INT, LPDIRECTDRAWPALETTE)
HRESULT WINAPI	Main_DDrawSurface_SetPriority (LPDDRAWI_DDRAWSURFACE_INT, DWORD)
HRESULT WINAPI	Main_DDrawSurface_SetPrivateData (LPDDRAWI_DDRAWSURFACE_INT, REFGUID, LPVOID, DWORD, DWORD)
HRESULT WINAPI	Main_DDrawSurface_UpdateOverlayDisplay (LPDDRAWI_DDRAWSURFACE_INT, DWORD)
HRESULT WINAPI	Main_DDrawSurface_UpdateOverlayZOrder (LPDDRAWI_DDRAWSURFACE_INT, DWORD, LPDDRAWI_DDRAWSURFACE_INT)
HRESULT WINAPI	Main_DDrawSurface_SetSurfaceDesc (LPDDRAWI_DDRAWSURFACE_INT, DDSURFACEDESC2 *, DWORD)
HRESULT WINAPI	Main_DDrawSurface_SetLOD (LPDDRAWI_DDRAWSURFACE_INT, DWORD)
HRESULT WINAPI	Main_DDrawSurface_Unlock (LPDDRAWI_DDRAWSURFACE_INT, LPRECT)
HRESULT WINAPI	Main_DDrawSurface_Initialize (LPDDRAWI_DDRAWSURFACE_INT, LPDIRECTDRAW, LPDDSURFACEDESC2)
HRESULT WINAPI	Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT, LPRECT, LPDDSURFACEDESC2, DWORD, HANDLE)
HRESULT WINAPI	Main_DDrawSurface_Restore (LPDDRAWI_DDRAWSURFACE_INT)
HRESULT WINAPI	Main_DDrawSurface_UpdateOverlay (LPDDRAWI_DDRAWSURFACE_INT, LPRECT, LPDDRAWI_DDRAWSURFACE_INT, LPRECT, DWORD, LPDDOVERLAYFX)
HRESULT WINAPI	Main_DDrawSurface_ChangeUniquenessValue (LPDDRAWI_DDRAWSURFACE_INT iface)
HRESULT WINAPI	Main_DDrawSurface_AddAttachedSurface (LPDDRAWI_DDRAWSURFACE_INT iface, LPDDRAWI_DDRAWSURFACE_INT pAttach)
HRESULT WINAPI	Main_DDrawSurface_AddOverlayDirtyRect (LPDDRAWI_DDRAWSURFACE_INT iface, LPRECT pRect)
DWORD CALLBACK	HelDdDestroyDriver (LPDDHAL_DESTROYDRIVERDATA lpDestroyDriver)
DWORD CALLBACK	HelDdCreateSurface (LPDDHAL_CREATESURFACEDATA lpCreateSurface)
DWORD CALLBACK	HelDdSetColorKey (LPDDHAL_DRVSETCOLORKEYDATA lpSetColorKey)
DWORD CALLBACK	HelDdSetMode (LPDDHAL_SETMODEDATA SetMode)
DWORD CALLBACK	HelDdWaitForVerticalBlank (LPDDHAL_WAITFORVERTICALBLANKDATA lpWaitForVerticalBlank)
DWORD CALLBACK	HelDdCanCreateSurface (LPDDHAL_CANCREATESURFACEDATA lpCanCreateSurface)
DWORD CALLBACK	HelDdCreatePalette (LPDDHAL_CREATEPALETTEDATA lpCreatePalette)
DWORD CALLBACK	HelDdGetScanLine (LPDDHAL_GETSCANLINEDATA lpGetScanLine)
DWORD CALLBACK	HelDdSetExclusiveMode (LPDDHAL_SETEXCLUSIVEMODEDATA lpSetExclusiveMode)
DWORD CALLBACK	HelDdFlipToGDISurface (LPDDHAL_FLIPTOGDISURFACEDATA lpFlipToGDISurface)

Function Documentation

HelDdCanCreateSurface()

DWORD CALLBACK HelDdCanCreateSurface

(

LPDDHAL_CANCREATESURFACEDATA

lpCanCreateSurface

)

Definition at line 72 of file callbacks_dd_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdCreatePalette()

DWORD CALLBACK HelDdCreatePalette

(

LPDDHAL_CREATEPALETTEDATA

lpCreatePalette

)

Definition at line 77 of file callbacks_dd_hel.c.

{
    DDRAWI_DDRAWPALETTE_GBL* ddPalGbl = lpCreatePalette->lpDDPalette;
    LOGPALETTE* logPal ;
    WORD size=1;

    if(ddPalGbl->dwFlags & DDRAWIPAL_2)
        size = 2;
    else if(ddPalGbl->dwFlags & DDRAWIPAL_4)
        size = 4;
    else if(ddPalGbl->dwFlags & DDRAWIPAL_16)
        size = 16;
    else if(ddPalGbl->dwFlags & DDRAWIPAL_256)
        size = 256;

    DxHeapMemAlloc(logPal, sizeof(LOGPALETTE) + size*sizeof(PALETTEENTRY));
    if(logPal == NULL)
    {
        lpCreatePalette->ddRVal = DDERR_OUTOFMEMORY;
        return DDHAL_DRIVER_HANDLED;
    }

    logPal->palVersion = 0x300;
    logPal->palNumEntries = size;
    CopyMemory(&logPal->palPalEntry[0], lpCreatePalette->lpColorTable, size*sizeof(PALETTEENTRY));

    ddPalGbl->hHELGDIPalette = CreatePalette(logPal);

    if (ddPalGbl->hHELGDIPalette == NULL)
    {
        DxHeapMemFree(logPal);
        lpCreatePalette->ddRVal = DDERR_INVALIDOBJECT;
        return DDHAL_DRIVER_HANDLED;
    }

    DxHeapMemFree(logPal);
    ddPalGbl->lpColorTable = lpCreatePalette->lpColorTable;
    ddPalGbl->dwFlags |= DDRAWIPAL_INHEL | DDRAWIPAL_GDI ;
    lpCreatePalette->ddRVal = DD_OK;
    return DDHAL_DRIVER_HANDLED;
}

Referenced by StartDirectDrawHel().

HelDdCreateSurface()

DWORD CALLBACK HelDdCreateSurface

(

LPDDHAL_CREATESURFACEDATA

lpCreateSurface

)

Definition at line 25 of file callbacks_dd_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdDestroyDriver()

DWORD CALLBACK HelDdDestroyDriver

(

LPDDHAL_DESTROYDRIVERDATA

lpDestroyDriver

)

Definition at line 20 of file callbacks_dd_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdFlipToGDISurface()

DWORD CALLBACK HelDdFlipToGDISurface

(

LPDDHAL_FLIPTOGDISURFACEDATA

lpFlipToGDISurface

)

Definition at line 133 of file callbacks_dd_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdGetScanLine()

DWORD CALLBACK HelDdGetScanLine

(

LPDDHAL_GETSCANLINEDATA

lpGetScanLine

)

Definition at line 119 of file callbacks_dd_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSetColorKey()

DWORD CALLBACK HelDdSetColorKey

(

LPDDHAL_DRVSETCOLORKEYDATA

lpSetColorKey

)

Definition at line 31 of file callbacks_dd_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

HelDdSetExclusiveMode()

DWORD CALLBACK HelDdSetExclusiveMode

(

LPDDHAL_SETEXCLUSIVEMODEDATA

lpSetExclusiveMode

)

Definition at line 124 of file callbacks_dd_hel.c.

{
    DX_WINDBG_trace();
    DX_STUB_str("Not implement yet, return DD_OK for not bsod\n");
    lpSetExclusiveMode->ddRVal = DD_OK;

    return DDHAL_DRIVER_HANDLED;
}

Referenced by StartDirectDrawHel().

HelDdSetMode()

DWORD CALLBACK HelDdSetMode

(

LPDDHAL_SETMODEDATA

SetMode

)

Definition at line 37 of file callbacks_dd_hel.c.

{
    DEVMODE DevMode;

    DX_STUB_str("in hel");

    DevMode.dmSize = (WORD)sizeof(DEVMODE);
    DevMode.dmDriverExtra = 0;

    SetMode->ddRVal = DDERR_UNSUPPORTEDMODE;

    if (EnumDisplaySettingsEx(NULL, SetMode->dwModeIndex, &DevMode, 0 ) != 0)
    {


        if (ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
        {
            DX_STUB_str("FAIL");
            SetMode->ddRVal = DDERR_UNSUPPORTEDMODE;
        }
        else
        {
            DX_STUB_str("OK");
            SetMode->ddRVal = DD_OK;
        }
    }

    return DDHAL_DRIVER_HANDLED;
}

Referenced by StartDirectDrawHel().

HelDdWaitForVerticalBlank()

DWORD CALLBACK HelDdWaitForVerticalBlank

(

LPDDHAL_WAITFORVERTICALBLANKDATA

lpWaitForVerticalBlank

)

Definition at line 67 of file callbacks_dd_hel.c.

{
    DX_STUB;
}

Referenced by StartDirectDrawHel().

Main_DDrawSurface_AddAttachedSurface()

HRESULT WINAPI Main_DDrawSurface_AddAttachedSurface	(	LPDDRAWI_DDRAWSURFACE_INT	iface,
		LPDDRAWI_DDRAWSURFACE_INT	pAttach
	)

Definition at line 571 of file surface_main.c.

{

   // LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
   // LPDDRAWI_DDRAWSURFACE_INT That = (LPDDRAWI_DDRAWSURFACE_INT)pAttach;

   DX_WINDBG_trace();

   DX_STUB;
}

Referenced by Thunk_DDrawSurface3_AddAttachedSurface().

Main_DDrawSurface_AddOverlayDirtyRect()

HRESULT WINAPI Main_DDrawSurface_AddOverlayDirtyRect	(	LPDDRAWI_DDRAWSURFACE_INT	iface,
		LPRECT	pRect
	)

Definition at line 17 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_AddOverlayDirtyRect().

Main_DDrawSurface_AddRef()

ULONG WINAPI Main_DDrawSurface_AddRef

(

LPDDRAWI_DDRAWSURFACE_INT

)

Definition at line 40 of file surface_main.c.

{

    DX_WINDBG_trace();

    if (This!=NULL)
    {
        This->dwIntRefCnt++;
        This->lpLcl->dwLocalRefCnt++;

        if (This->lpLcl->lpGbl != NULL)
        {
            This->lpLcl->lpGbl->dwRefCnt++;
        }
    }
    return This->dwIntRefCnt;

}

Referenced by Internal_CreateSurface(), Main_DDrawSurface_QueryInterface(), and Thunk_DDrawSurface3_AddRef().

Main_DDrawSurface_Blt()

HRESULT WINAPI Main_DDrawSurface_Blt	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPRECT	,
		LPDDRAWI_DDRAWSURFACE_INT	,
		LPRECT	,
		DWORD	,
		LPDDBLTFX
	)

Definition at line 289 of file surface_main.c.

{
    DDHAL_BLTDATA mDdBlt;

    DX_WINDBG_trace();

    if (ThisDest == NULL)
    {
        return DDERR_INVALIDPARAMS;
    }

    /* Zero out members in DDHAL_BLTDATA */
    ZeroMemory(&mDdBlt, sizeof(DDHAL_BLTDATA));
    ZeroMemory(&mDdBlt.bltFX, sizeof(DDBLTFX));

    /* Check if we got HAL support for this api */
    if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
          DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
    {
        mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Blt;
    }
    /* Check if we got HEL support for this api */
    else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
          DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
    {
        mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Blt;
    }

    if (mDdBlt.Blt == NULL)
    {
        /* This API is unsupported */
        return DDERR_UNSUPPORTED;
    }

    /* Prepare for draw, if we do not reset the DdResetVisrgn some graphics card will not draw on the screen */
    if (!DdResetVisrgn( ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
    {
        DX_STUB_str("DdResetVisrgn failed");
    }

    mDdBlt.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
    mDdBlt.lpDDDestSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
    ThisDest->lpLcl->lpSurfMore->slist[0]->hDC = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hDC;

    /* Setup Src */
    if (( ThisSrc != NULL ) )
    {

        mDdBlt.lpDDSrcSurface = ThisSrc->lpLcl->lpSurfMore->slist[0];
        ThisSrc->lpLcl->lpSurfMore->slist[0]->hDC = ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hDC;

        if (rsrc != NULL)
        {
            memmove(&mDdBlt.rSrc, rsrc, sizeof (RECTL));
        }
        else
        {
            if(!GetWindowRect((HWND)ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
                (RECT *)&mDdBlt.rSrc))
            {
                DX_STUB_str("GetWindowRect failed");
            }
        }

    /* FIXME
    *  compare so we do not write too far
    *  ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
    *  ThisDest->lpLcl->lpGbl->wHeight <- surface max height
    *  ThisDest->lpLcl->lpGbl->lPitch  <- surface bpp
    */

    }

    /* Setup dest */
    if (rdst != NULL)
    {
        memmove(&mDdBlt.rDest, rdst, sizeof (RECTL));
    }
    else
    {
        if (!GetWindowRect((HWND)ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
            (RECT *)&mDdBlt.rDest))
        {
            DX_STUB_str("GetWindowRect failed");
        }
    }

    /* FIXME
    *  compare so we do not write too far
    *  ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
    *  ThisDest->lpLcl->lpGbl->wHeight <- surface max height
    *  ThisDest->lpLcl->lpGbl->lPitch  <- surface bpp
    */


    /* setup bltFX */
    if (lpbltfx != NULL)
    {
        memmove(&mDdBlt.bltFX, lpbltfx, sizeof (DDBLTFX));
    }

    /* setup value that are not config yet */
    mDdBlt.dwFlags = dwFlags;
    mDdBlt.IsClipped = FALSE;
    mDdBlt.bltFX.dwSize = sizeof(DDBLTFX);


     /* FIXME
        BltData.dwRectCnt
        BltData.dwROPFlags
        BltData.IsClipped
        BltData.prDestRects
        BltData.rOrigDest
        BltData.rOrigSrc
        BltData.ddRVal
    */

    if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
    {
        DX_STUB_str("mDdBlt DDHAL_DRIVER_HANDLED");
        return DDERR_NOBLTHW;
     }

    return mDdBlt.ddRVal;
}

Referenced by Thunk_DDrawSurface3_Blt().

Main_DDrawSurface_BltBatch()

HRESULT WINAPI Main_DDrawSurface_BltBatch	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDDBLTBATCH	,
		DWORD	,
		DWORD
	)

Definition at line 45 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_BltBatch().

Main_DDrawSurface_BltFast()

HRESULT WINAPI Main_DDrawSurface_BltFast	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD	,
		DWORD	,
		LPDDRAWI_DDRAWSURFACE_INT	,
		LPRECT	,
		DWORD
	)

Definition at line 26 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_BltFast().

Main_DDrawSurface_ChangeUniquenessValue()

HRESULT WINAPI Main_DDrawSurface_ChangeUniquenessValue

(

LPDDRAWI_DDRAWSURFACE_INT

iface

)

Definition at line 55 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_DeleteAttachedSurface()

HRESULT WINAPI Main_DDrawSurface_DeleteAttachedSurface	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD	,
		LPDDRAWI_DDRAWSURFACE_INT
	)

Definition at line 63 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_DeleteAttachedSurface().

Main_DDrawSurface_EnumAttachedSurfaces()

HRESULT WINAPI Main_DDrawSurface_EnumAttachedSurfaces	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPVOID	,
		LPDDENUMSURFACESCALLBACK7
	)

Definition at line 73 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_EnumAttachedSurfaces().

Main_DDrawSurface_EnumOverlayZOrders()

HRESULT WINAPI Main_DDrawSurface_EnumOverlayZOrders	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD	,
		LPVOID	,
		LPDDENUMSURFACESCALLBACK7
	)

Definition at line 83 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_EnumOverlayZOrders().

Main_DDrawSurface_Flip()

HRESULT WINAPI Main_DDrawSurface_Flip	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD
	)

Definition at line 93 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_Flip().

Main_DDrawSurface_FreePrivateData()

HRESULT WINAPI Main_DDrawSurface_FreePrivateData	(	LPDDRAWI_DDRAWSURFACE_INT	,
		REFGUID
	)

Definition at line 102 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_GetAttachedSurface()

HRESULT WINAPI Main_DDrawSurface_GetAttachedSurface	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDDSCAPS2	,
		LPDDRAWI_DDRAWSURFACE_INT *
	)

Definition at line 584 of file surface_main.c.

{
    /* FIXME hacked */


    DX_WINDBG_trace();

    *ppSurface = This->lpLcl->lpGbl->lpDD->dsList;


    return DD_OK;
}

Referenced by Thunk_DDrawSurface3_GetAttachedSurface().

Main_DDrawSurface_GetBltStatus()

HRESULT WINAPI Main_DDrawSurface_GetBltStatus	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD	dwFlags
	)

Definition at line 600 of file surface_main.c.

{

    DX_WINDBG_trace();

    if (!(This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_FLIP))
    {
        return DDERR_GENERIC;
    }

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_GetBltStatus().

Main_DDrawSurface_GetCaps()

HRESULT WINAPI Main_DDrawSurface_GetCaps	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDDSCAPS2	pCaps
	)

Definition at line 614 of file surface_main.c.

{

    DX_WINDBG_trace();

    if (This == NULL)
    {
       return DDERR_INVALIDOBJECT;
    }

    if (pCaps == NULL)
    {
       return DDERR_INVALIDPARAMS;
    }

    RtlZeroMemory(pCaps,sizeof(DDSCAPS2));

    pCaps->dwCaps = This->lpLcl->ddsCaps.dwCaps;

    return DD_OK;
}

Referenced by Thunk_DDrawSurface3_GetCaps().

Main_DDrawSurface_GetClipper()

HRESULT WINAPI Main_DDrawSurface_GetClipper	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDIRECTDRAWCLIPPER *
	)

Definition at line 637 of file surface_main.c.

{

    DX_WINDBG_trace();

    if (This == NULL)
    {
       return DDERR_INVALIDOBJECT;
    }

    if (ppClipper == NULL)
    {
       return DDERR_INVALIDPARAMS;
    }

    if (This->lpLcl->lp16DDClipper == NULL)
    {
        return DDERR_NOCLIPPERATTACHED;
    }

    *ppClipper = (LPDIRECTDRAWCLIPPER)This->lpLcl->lp16DDClipper;

    return DD_OK;
}

Referenced by Thunk_DDrawSurface3_GetClipper().

Main_DDrawSurface_GetColorKey()

HRESULT WINAPI Main_DDrawSurface_GetColorKey	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD	,
		LPDDCOLORKEY
	)

Definition at line 109 of file surface_stubs.c.

{
    //LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;

    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_GetColorKey().

Main_DDrawSurface_GetDC()

HRESULT WINAPI Main_DDrawSurface_GetDC	(	LPDDRAWI_DDRAWSURFACE_INT	,
		HDC *
	)

Definition at line 694 of file surface_main.c.

{

    DX_WINDBG_trace();

    if (This == NULL)
    {
       return DDERR_INVALIDOBJECT;
    }

    if (phDC == NULL)
    {
       return DDERR_INVALIDPARAMS;
    }


    *phDC = (HDC)This->lpLcl->lpSurfMore->lpDD_lcl->hDC;

    return DD_OK;
}

Referenced by Thunk_DDrawSurface3_GetDC().

Main_DDrawSurface_GetDDInterface()

HRESULT WINAPI Main_DDrawSurface_GetDDInterface	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPVOID *
	)

Definition at line 120 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_GetDDInterface().

Main_DDrawSurface_GetFlipStatus()

HRESULT WINAPI Main_DDrawSurface_GetFlipStatus	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD
	)

Definition at line 127 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_GetFlipStatus().

Main_DDrawSurface_GetLOD()

HRESULT WINAPI Main_DDrawSurface_GetLOD	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDWORD
	)

Definition at line 135 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_GetOverlayPosition()

HRESULT WINAPI Main_DDrawSurface_GetOverlayPosition	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPLONG	,
		LPLONG
	)

Definition at line 143 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_GetOverlayPosition().

Main_DDrawSurface_GetPalette()

HRESULT WINAPI Main_DDrawSurface_GetPalette	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDIRECTDRAWPALETTE *
	)

Definition at line 151 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_GetPalette().

Main_DDrawSurface_GetPixelFormat()

HRESULT WINAPI Main_DDrawSurface_GetPixelFormat	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDDPIXELFORMAT
	)

Definition at line 716 of file surface_main.c.

{
    HRESULT retVale = DDERR_INVALIDPARAMS;

    DX_WINDBG_trace();

    if (pDDPixelFormat != NULL)
    {
        if (This->lpLcl->dwFlags & DDRAWISURF_HASPIXELFORMAT)
        {
            memcpy(pDDPixelFormat,&This->lpLcl->lpGbl->ddpfSurface,sizeof(DDPIXELFORMAT));
        }
        else
        {
            memcpy(pDDPixelFormat,&This->lpLcl->lpSurfMore->
                              lpDD_lcl->lpGbl->vmiData.ddpfDisplay,sizeof(DDPIXELFORMAT));
        }
        retVale = DD_OK;
    }

  return retVale;
}

Referenced by Thunk_DDrawSurface3_GetPixelFormat().

Main_DDrawSurface_GetPriority()

HRESULT WINAPI Main_DDrawSurface_GetPriority	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDWORD
	)

Definition at line 160 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_GetPrivateData()

HRESULT WINAPI Main_DDrawSurface_GetPrivateData	(	LPDDRAWI_DDRAWSURFACE_INT	,
		REFGUID	,
		LPVOID	,
		LPDWORD
	)

Definition at line 169 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_GetSurfaceDesc()

HRESULT WINAPI Main_DDrawSurface_GetSurfaceDesc	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDDSURFACEDESC2
	)

Definition at line 741 of file surface_main.c.

{
    DWORD dwSize;

    DX_WINDBG_trace();

    dwSize =  pDDSD->dwSize;

    if ((dwSize != sizeof(DDSURFACEDESC)) &&
        (dwSize != sizeof(DDSURFACEDESC2)))
    {
       return DDERR_GENERIC;
    }

    ZeroMemory(pDDSD,dwSize);

    if (dwSize == sizeof(DDSURFACEDESC))
    {
        LPDDSURFACEDESC lpDS = (LPDDSURFACEDESC) pDDSD;
        memcpy(&lpDS->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
        memcpy(&lpDS->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
        memcpy(&lpDS->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
        memcpy(&lpDS->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
        memcpy(&lpDS->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
        memcpy(&lpDS->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));

        lpDS->dwAlphaBitDepth = This->lpLcl->dwAlpha;
        lpDS->dwBackBufferCount = This->lpLcl->dwBackBufferCount;

        /* FIXME setting the flags right */
        // lpDS->dwFlags = This->lpLcl->dwFlags;

        lpDS->dwHeight = This->lpLcl->lpGbl->wHeight;
        lpDS->dwWidth =  This->lpLcl->lpGbl->wWidth;

        /* This two are a union in lpDS  and in This->lpLcl->lpGbl
          so I comment out lPitch
          lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
        */
        lpDS->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;


        /* This tree are a union */
        //lpDS->dwMipMapCount
        //lpDS->dwRefreshRate
        //lpDS->dwZBufferBitDepth

        /* Unknown */
        // lpDS->dwReserved
        // lpDS->lpSurface
    }
    else
    {
        memcpy(&pDDSD->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));

        /*
           pDDSD->dwEmptyFaceColor is a union to ddckCKDestOverlay
        */
        memcpy(&pDDSD->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
        memcpy(&pDDSD->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
        memcpy(&pDDSD->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));

        /*
           pDDSD->dwFVF is a union to ddpfPixelFormat
        */
        memcpy(&pDDSD->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
        memcpy(&pDDSD->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));


        pDDSD->dwAlphaBitDepth = This->lpLcl->dwAlpha;
        pDDSD->dwBackBufferCount = This->lpLcl->dwBackBufferCount;

        /* FIXME setting the flags right */
        // lpDS->dwFlags = This->lpLcl->dwFlags;

        pDDSD->dwHeight = This->lpLcl->lpGbl->wHeight;
        pDDSD->dwWidth =  This->lpLcl->lpGbl->wWidth;

        /* This two are a union in lpDS  and in This->lpLcl->lpGbl
          so I comment out lPitch
          lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
        */
        pDDSD->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;

        /* This tree are a union */
        // pDDSD->dwMipMapCount
        // pDDSD->dwRefreshRate
        // pDDSD->dwSrcVBHandle

        /* Unknown */
        // lpDS->dwReserved
        // lpDS->lpSurface
        // pDDSD->dwTextureStage
    }

    return DD_OK;
}

Referenced by Thunk_DDrawSurface3_GetSurfaceDesc().

Main_DDrawSurface_GetUniquenessValue()

HRESULT WINAPI Main_DDrawSurface_GetUniquenessValue	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDWORD
	)

Definition at line 179 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_Initialize()

HRESULT WINAPI Main_DDrawSurface_Initialize	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDIRECTDRAW	,
		LPDDSURFACEDESC2
	)

Definition at line 35 of file surface_main.c.

{
    return DDERR_ALREADYINITIALIZED;
}

Referenced by Thunk_DDrawSurface3_Initialize().

Main_DDrawSurface_IsLost()

HRESULT WINAPI Main_DDrawSurface_IsLost

(

LPDDRAWI_DDRAWSURFACE_INT

)

Definition at line 188 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    //DX_STUB;
    DX_STUB_str("not implement return not lost\n");
    return DD_OK;
}

Referenced by Thunk_DDrawSurface3_IsLost().

Main_DDrawSurface_Lock()

HRESULT WINAPI Main_DDrawSurface_Lock	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPRECT	,
		LPDDSURFACEDESC2	,
		DWORD	,
		HANDLE
	)

Definition at line 418 of file surface_main.c.

{
    DDHAL_LOCKDATA mdLock;

    DX_WINDBG_trace();

    DX_WINDBG_trace_res( (DWORD)ThisDest->lpLcl->lpGbl->wWidth, (DWORD)ThisDest->lpLcl->lpGbl->wHeight, (DWORD)ThisDest->lpLcl->lpGbl->lPitch, (DWORD) 0);

     /* Zero out members in DDHAL_LOCKDATA */
    ZeroMemory(&mdLock, sizeof(DDHAL_LOCKDATA));

     /* Check if we got HAL support for this api */
    if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
        DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
    {
        mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Lock;
    }
    /* Check if we got HEL support for this api */
    else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
          DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
    {
        mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Lock;
    }

    if (mdLock.Lock == NULL)
    {
        /* This api are unsupported */
        return DDERR_UNSUPPORTED;
    }

    if (events != NULL)
    {
        return DDERR_INVALIDPARAMS;
    }

    /* FIXME add a check see if lock support or not */

    if (prect!=NULL)
    {
        mdLock.bHasRect = TRUE;
        memcpy(&mdLock.rArea,prect,sizeof(RECTL));
    }
    else
    {
        mdLock.bHasRect = FALSE;
    }

    //FIXME check if it primary or not and use primary or pixelformat data, at moment it is hardcode to primary

    mdLock.ddRVal = DDERR_CANTLOCKSURFACE;
    mdLock.dwFlags = flags;
    mdLock.lpDDSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
    mdLock.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
    mdLock.lpSurfData = NULL;


    if (!DdResetVisrgn(ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
    {
      DX_STUB_str("Here DdResetVisrgn lock");
      // return DDERR_UNSUPPORTED;
    }

    if (mdLock.Lock(&mdLock)!= DDHAL_DRIVER_HANDLED)
    {
      DX_STUB_str("Here DDHAL_DRIVER_HANDLED lock");
      return DDERR_UNSUPPORTED;
    }

    // FIXME ??? is this right ??

    if (pDDSD != NULL)
    {
        ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
        pDDSD->dwSize = sizeof(DDSURFACEDESC2);

        //if (pDDSD->dwSize == sizeof(DDSURFACEDESC2))
        //{
        //    ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
        //    // FIXME the internal mddsdPrimary shall be DDSURFACEDESC2
        //    memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
        //    pDDSD->dwSize = sizeof(DDSURFACEDESC2);
        //}
        //if (pDDSD->dwSize == sizeof(DDSURFACEDESC))
        //{
        //    RtlZeroMemory(pDDSD,sizeof(DDSURFACEDESC));
        //    memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
        //    pDDSD->dwSize = sizeof(DDSURFACEDESC);
        //}


        pDDSD->lpSurface = (LPVOID)  mdLock.lpSurfData;

        pDDSD->dwHeight = ThisDest->lpLcl->lpGbl->wHeight;
        pDDSD->dwWidth = ThisDest->lpLcl->lpGbl->wWidth;

        pDDSD->ddpfPixelFormat.dwRGBBitCount = ThisDest->lpLcl->lpGbl->lpDD->lpModeInfo->dwBPP;// .lpModeInfo->dwBPP; //This->lpLcl->lpGbl->lPitch/ 8;
        pDDSD->lPitch = ThisDest->lpLcl->lpGbl->lPitch;
        pDDSD->dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH;
    }

    return mdLock.ddRVal;
}

Referenced by Thunk_DDrawSurface3_Lock().

Main_DDrawSurface_PageLock()

HRESULT WINAPI Main_DDrawSurface_PageLock	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD
	)

Definition at line 198 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_PageLock().

Main_DDrawSurface_PageUnlock()

HRESULT WINAPI Main_DDrawSurface_PageUnlock	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD
	)

Definition at line 206 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_PageUnlock().

Main_DDrawSurface_QueryInterface()

HRESULT WINAPI Main_DDrawSurface_QueryInterface	(	LPDDRAWI_DDRAWSURFACE_INT	,
		REFIID	,
		LPVOID *
	)

Definition at line 60 of file surface_main.c.

{
    HRESULT retVal = DD_OK;
    *ppObj = NULL;

    DX_WINDBG_trace();

    _SEH2_TRY
    {
        if (IsEqualGUID(&IID_IDirectDrawSurface7, riid))
        {
            if (This->lpVtbl != &DirectDrawSurface7_Vtable)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &DirectDrawSurface7_Vtable;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDrawSurface4, riid))
        {
            if (This->lpVtbl != &DirectDrawSurface4_Vtable)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &DirectDrawSurface4_Vtable;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDrawSurface3, riid))
        {
            if (This->lpVtbl != &DirectDrawSurface3_Vtable)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &DirectDrawSurface3_Vtable;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDrawSurface2, riid))
        {
            if (This->lpVtbl != &DirectDrawSurface2_Vtable)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &DirectDrawSurface2_Vtable;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDrawSurface, riid))
        {
            if (This->lpVtbl != &DirectDrawSurface_Vtable)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &DirectDrawSurface_Vtable;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDrawColorControl, riid))
        {
            if (This->lpVtbl != &DirectDrawColorControl_Vtable)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &DirectDrawColorControl_Vtable;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDrawGammaControl, riid))
        {
            if (This->lpVtbl != &DirectDrawGammaControl_Vtable)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &DirectDrawGammaControl_Vtable;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirectDrawSurfaceKernel, riid))
        {
            if (This->lpVtbl != &DirectDrawSurfaceKernel_Vtable)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &DirectDrawSurfaceKernel_Vtable;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirect3D, riid))
        {
            if (This->lpVtbl != &IDirect3D_Vtbl)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &IDirect3D_Vtbl;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirect3D2, riid))
        {
            if (This->lpVtbl != &IDirect3D2_Vtbl)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &IDirect3D2_Vtbl;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirect3D3, riid))
        {
            if (This->lpVtbl != &IDirect3D3_Vtbl)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &IDirect3D3_Vtbl;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else if (IsEqualGUID(&IID_IDirect3D7, riid))
        {
            if (This->lpVtbl != &IDirect3D7_Vtbl)
            {
                This = internal_directdrawsurface_int_alloc(This);
                if (!This)
                {
                    retVal = DDERR_OUTOFVIDEOMEMORY;
                    _SEH2_LEAVE;
                }
            }
            This->lpVtbl = &IDirect3D7_Vtbl;
            *ppObj = This;
            Main_DDrawSurface_AddRef(This);
        }
        else
        {
            DX_STUB_str("E_NOINTERFACE");
            retVal = E_NOINTERFACE;
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
    return retVal;
}

Referenced by Thunk_DDrawSurface3_QueryInterface().

Main_DDrawSurface_Release()

ULONG WINAPI Main_DDrawSurface_Release

(

LPDDRAWI_DDRAWSURFACE_INT

)

Definition at line 264 of file surface_main.c.

{
    /* FIXME
       This is not right exiame how it should be done
     */
    ULONG ret = --This->dwIntRefCnt;
    if(!ret)
    {
        DX_STUB_str("Release is a bit simplistic right now\n");
        AcquireDDThreadLock();
        DxHeapMemFree(This);
        ReleaseDDThreadLock();
    }
    return ret;
}

Referenced by Main_DDrawSurface_Release4(), and Thunk_DDrawSurface3_Release().

Main_DDrawSurface_ReleaseDC()

HRESULT WINAPI Main_DDrawSurface_ReleaseDC	(	LPDDRAWI_DDRAWSURFACE_INT	,
		HDC
	)

Definition at line 841 of file surface_main.c.

{
    DX_WINDBG_trace();

    if (This == NULL)
    {
       return DDERR_INVALIDOBJECT;
    }

    if (hDC == NULL)
    {
       return DDERR_INVALIDPARAMS;
    }

    /* FIXME check if surface exits or not */


    if ((HDC)This->lpLcl->hDC == NULL)
    {
        return DDERR_GENERIC;
    }

    return DD_OK;
}

Referenced by Thunk_DDrawSurface3_ReleaseDC().

Main_DDrawSurface_Restore()

HRESULT WINAPI Main_DDrawSurface_Restore

(

LPDDRAWI_DDRAWSURFACE_INT

)

Definition at line 36 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_Restore().

Main_DDrawSurface_SetClipper()

HRESULT WINAPI Main_DDrawSurface_SetClipper	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDIRECTDRAWCLIPPER
	)

Definition at line 664 of file surface_main.c.

{

    DX_WINDBG_trace();

    if (This == NULL)
    {
       return DDERR_INVALIDOBJECT;
    }

    if(pDDClipper == NULL)
    {
        if(!This->lpLcl->lp16DDClipper)
            return DDERR_NOCLIPPERATTACHED;

        DirectDrawClipper_Release((LPDIRECTDRAWCLIPPER)This->lpLcl->lp16DDClipper);
        This->lpLcl->lp16DDClipper = NULL;
        return DD_OK;
    }

    // FIXME: Check Surface type and return DDERR_INVALIDSURFACETYPE

    DirectDrawClipper_AddRef((LPDIRECTDRAWCLIPPER)pDDClipper);
    This->lpLcl->lp16DDClipper = (LPDDRAWI_DDRAWCLIPPER_INT)pDDClipper;

    return DD_OK;
}

Referenced by Thunk_DDrawSurface3_SetClipper().

Main_DDrawSurface_SetColorKey()

HRESULT WINAPI Main_DDrawSurface_SetColorKey	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD	,
		LPDDCOLORKEY
	)

Definition at line 867 of file surface_main.c.

{

    DDHAL_SETCOLORKEYDATA ColorKeyData;

    DX_WINDBG_trace();

    ColorKeyData.ddRVal = DDERR_COLORKEYNOTSET;

    if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)
    {

        ColorKeyData.lpDD = This->lpLcl->lpGbl->lpDD;
        ColorKeyData.SetColorKey =  This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetColorKey;

        //ColorKeyData.lpDDSurface = &This->lpLcl->hDDSurface;
        ColorKeyData.dwFlags = dwFlags;
        /* FIXME
           ColorKeyData.ckNew = ?
           add / move dwFlags to This->lpLcl->dwFlags ??
         */

        if (ColorKeyData.SetColorKey(&ColorKeyData) == DDHAL_DRIVER_HANDLED )
        {
            return  ColorKeyData.ddRVal;
        }
    }
    return DDERR_COLORKEYNOTSET;
}

Referenced by Thunk_DDrawSurface3_SetColorKey().

Main_DDrawSurface_SetLOD()

HRESULT WINAPI Main_DDrawSurface_SetLOD	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD
	)

Definition at line 288 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_SetOverlayPosition()

HRESULT WINAPI Main_DDrawSurface_SetOverlayPosition	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LONG	,
		LONG
	)

Definition at line 901 of file surface_main.c.

{

    DDHAL_SETOVERLAYPOSITIONDATA OverLayPositionData;

    DX_WINDBG_trace();

    OverLayPositionData.ddRVal = DDERR_COLORKEYNOTSET;

    if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
    {

        OverLayPositionData.lpDD = This->lpLcl->lpGbl->lpDD;
        OverLayPositionData.SetOverlayPosition = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetOverlayPosition;

        //OverLayPositionData.lpDDSrcSurface = This->lpLcl->lpSurfaceOverlaying->lpLcl->hDDSurface;
        //OverLayPositionData.lpDDDestSurface = This->lpLcl->hDDSurface;

        OverLayPositionData.lXPos = X;
        OverLayPositionData.lYPos = Y;


        /* FIXME
           Should X and Y be save ??
         */

        if (OverLayPositionData.SetOverlayPosition(&OverLayPositionData) == DDHAL_DRIVER_HANDLED )
        {
            return  OverLayPositionData.ddRVal;
        }
    }

    return DDERR_GENERIC;
}

Referenced by Thunk_DDrawSurface3_SetOverlayPosition().

Main_DDrawSurface_SetPalette()

HRESULT WINAPI Main_DDrawSurface_SetPalette	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPDIRECTDRAWPALETTE
	)

Definition at line 214 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_SetPalette().

Main_DDrawSurface_SetPriority()

HRESULT WINAPI Main_DDrawSurface_SetPriority	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD
	)

Definition at line 223 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_SetPrivateData()

HRESULT WINAPI Main_DDrawSurface_SetPrivateData	(	LPDDRAWI_DDRAWSURFACE_INT	,
		REFGUID	,
		LPVOID	,
		DWORD	,
		DWORD
	)

Definition at line 232 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Main_DDrawSurface_SetSurfaceDesc()

HRESULT WINAPI Main_DDrawSurface_SetSurfaceDesc	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DDSURFACEDESC2 *	,
		DWORD
	)

Definition at line 280 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_SetSurfaceDesc().

Main_DDrawSurface_Unlock()

HRESULT WINAPI Main_DDrawSurface_Unlock	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPRECT
	)

Definition at line 523 of file surface_main.c.

{
    DDHAL_UNLOCKDATA mdUnLock;

    DX_WINDBG_trace();

    /* Zero out members in DDHAL_UNLOCKDATA */
    ZeroMemory(&mdUnLock, sizeof(DDHAL_UNLOCKDATA));

     /* Check if we got HAL support for this api */
    if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
        DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
    {
        mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Unlock;
    }
    /* Check if we got HEL support for this api */
    else if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
          DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
    {
        mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Unlock;
    }

    if (mdUnLock.Unlock == NULL)
    {
        /* This api are unsupported */
        return DDERR_UNSUPPORTED;
    }

    mdUnLock.ddRVal = DDERR_NOTPALETTIZED;
    mdUnLock.lpDD = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
    mdUnLock.lpDDSurface = This->lpLcl->lpSurfMore->slist[0];

    if (!DdResetVisrgn( mdUnLock.lpDDSurface, NULL))
    {
        DX_STUB_str("DdResetVisrgn fail");
        //return DDERR_UNSUPPORTED; /* this can fail */
    }

    if (mdUnLock.Unlock(&mdUnLock)!= DDHAL_DRIVER_HANDLED)
    {
        DX_STUB_str("unLock fail");
        return DDERR_UNSUPPORTED;
    }

    return mdUnLock.ddRVal;
}

Main_DDrawSurface_UpdateOverlay()

HRESULT WINAPI Main_DDrawSurface_UpdateOverlay	(	LPDDRAWI_DDRAWSURFACE_INT	,
		LPRECT	,
		LPDDRAWI_DDRAWSURFACE_INT	,
		LPRECT	,
		DWORD	,
		LPDDOVERLAYFX
	)

Definition at line 242 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_UpdateOverlay().

Main_DDrawSurface_UpdateOverlayDisplay()

HRESULT WINAPI Main_DDrawSurface_UpdateOverlayDisplay	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD
	)

Definition at line 256 of file surface_stubs.c.

{

    DX_WINDBG_trace();

    if (!(This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY))
    {
        return DDERR_GENERIC;
    }

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_UpdateOverlayDisplay().

Main_DDrawSurface_UpdateOverlayZOrder()

HRESULT WINAPI Main_DDrawSurface_UpdateOverlayZOrder	(	LPDDRAWI_DDRAWSURFACE_INT	,
		DWORD	,
		LPDDRAWI_DDRAWSURFACE_INT
	)

Definition at line 271 of file surface_stubs.c.

{
    DX_WINDBG_trace();

    DX_STUB;
}

Referenced by Thunk_DDrawSurface3_UpdateOverlayZOrder().