surface_main.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

/* $Id: surface_main.c 27271 2007-06-24 17:29:03Z greatlrd $
 *
 * COPYRIGHT:            See COPYING in the top level directory
 * PROJECT:              ReactOS DirectX
 * FILE:                 ddraw/surface/surface_main.c
 * PURPOSE:              IDirectDrawSurface7 Implementation 
 * PROGRAMMER:           Magnus Olsen, Maarten Bosma
 *
 */

#include "rosdraw.h"


/* FIXME adding hal and hel stub 
    DestroySurface; 
    SetClipList;
    AddAttachedSurface;  
    GetFlipStatus;
    SetOverlayPosition;  
    SetPalette;
*/


HRESULT WINAPI Main_DDrawSurface_Initialize (LPDIRECTDRAWSURFACE7 iface, LPDIRECTDRAW pDD, LPDDSURFACEDESC2 pDDSD2)
{
    return DDERR_ALREADYINITIALIZED;
}

ULONG WINAPI Main_DDrawSurface_AddRef(LPDIRECTDRAWSURFACE7 iface)
{
    LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;

    DX_WINDBG_trace();

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

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

HRESULT WINAPI
Main_DDrawSurface_QueryInterface(LPDIRECTDRAWSURFACE7 iface, REFIID riid,
				      LPVOID* ppObj)
{
    DX_WINDBG_trace();

	DX_STUB_str("Unimplement\n");

	return E_NOINTERFACE;
}



ULONG WINAPI Main_DDrawSurface_Release(LPDIRECTDRAWSURFACE7 iface)
{
    LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;

    /* FIXME 
       This is not right exiame how it should be done 
     */
    DX_STUB_str("FIXME This is not right exiame how it should be done\n");
    return This->dwIntRefCnt;
}

HRESULT WINAPI Main_DDrawSurface_Blt(LPDIRECTDRAWSURFACE7 iface, LPRECT rdst,
			  LPDIRECTDRAWSURFACE7 src, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
{     
	 LPDDRAWI_DDRAWSURFACE_INT ThisDest = (LPDDRAWI_DDRAWSURFACE_INT)iface;
	 LPDDRAWI_DDRAWSURFACE_INT ThisSrc = (LPDDRAWI_DDRAWSURFACE_INT)src;

	 DDHAL_BLTDATA mDdBlt;

	 DX_WINDBG_trace();

     if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags 
		   & DDHAL_SURFCB32_BLT) != DDHAL_SURFCB32_BLT)
	 {
		 return DDERR_GENERIC;
	 }

	 ZeroMemory(&mDdBlt, sizeof(DDHAL_BLTDATA));
     ZeroMemory(&mDdBlt.bltFX, sizeof(DDBLTFX));
	 
     if (!DdResetVisrgn( ThisDest->lpLcl->lpSurfMore->slist[0], NULL)) 
     {
		 DX_STUB_str("DdResetVisrgn failed");         
     }   

	 mDdBlt.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
     mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Blt;
     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 to far 
	  *  ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
	  *  ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
	  *  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 to far 
	  *  ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
	  *  ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
	  *  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;	 	
}


HRESULT WINAPI Main_DDrawSurface_Lock (LPDIRECTDRAWSURFACE7 iface, LPRECT prect,
				LPDDSURFACEDESC2 pDDSD, DWORD flags, HANDLE events)
{      
	LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
	DDHAL_LOCKDATA mdLock;

	DX_WINDBG_trace();

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

	if (prect!=NULL)
    {
        mdLock.bHasRect = TRUE;
        memcpy(&mdLock.rArea,prect,sizeof(RECTL));
    }
    else
    {
        mdLock.bHasRect = FALSE;		
    }
	
	//This->lpLcl->lpSurfMore->slist[0]->hDC = This->lpLcl->lpSurfMore->lpDD_lcl->hDC;

    mdLock.ddRVal = DDERR_NOTPALETTIZED;
    mdLock.Lock = This->lpLcl->lpSurfMore->lpDD_lcl->lpDDCB->HALDDSurface.Lock;
    mdLock.dwFlags = flags;
	mdLock.lpDDSurface = This->lpLcl->lpSurfMore->slist[0];
	mdLock.lpDD = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;   
    mdLock.lpSurfData = NULL;
     

	if (!DdResetVisrgn(This->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 interanl mddsdPrimary shall be DDSURFACEDESC2
        //    memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
        //    pDDSD->dwSize = sizeof(DDSURFACEDESC2);
        //}
        //if (pDDSD->dwSize == sizeof(DDSURFACEDESC))
        //{
        //    RtlZeroMemory(pDDSD,sizeof(DDSURFACEDESC));
        //    memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
        //    pDDSD->dwSize = sizeof(DDSURFACEDESC);
        //}


        pDDSD->lpSurface = (LPVOID)  mdLock.lpSurfData;	
		
		pDDSD->dwHeight =This->lpLcl->lpGbl->wHeight;
		pDDSD->dwWidth = This->lpLcl->lpGbl->wWidth;




		pDDSD->ddpfPixelFormat.dwRGBBitCount = This->lpLcl->lpGbl->lPitch/ 8;
		pDDSD->lPitch = This->lpLcl->lpGbl->lPitch;
		pDDSD->dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH;

    }

    return mdLock.ddRVal;
}


HRESULT WINAPI Main_DDrawSurface_Unlock (LPDIRECTDRAWSURFACE7 iface, LPRECT pRect)
{    
	LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
	DDHAL_UNLOCKDATA mdUnLock;   

	DX_WINDBG_trace();
          	
	if (!This->lpLcl->lpSurfMore->lpDD_lcl->lpDDCB->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_UNLOCK)
	{
	   DX_STUB_str("DDERR_UNSUPPORTED");
	   return DDERR_UNSUPPORTED;
	}

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

    if (!DdResetVisrgn( mdUnLock.lpDDSurface, NULL)) 
    {   
        DX_STUB_str("DDERR_UNSUPPORTED");
		return DDERR_UNSUPPORTED;
    }

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

    return mdUnLock.ddRVal;
}

HRESULT WINAPI
Main_DDrawSurface_AddAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
					  LPDIRECTDRAWSURFACE7 pAttach)
{
    
   // LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;           
   // LPDDRAWI_DDRAWSURFACE_INT That = (LPDDRAWI_DDRAWSURFACE_INT)pAttach;

   DX_WINDBG_trace();

   DX_STUB;
}

HRESULT WINAPI
Main_DDrawSurface_GetAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
                                     LPDDSCAPS2 pCaps,
                                     LPDIRECTDRAWSURFACE7* ppSurface)
{
    /* FIXME hacked */

    LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;

    DX_WINDBG_trace();

    *ppSurface = (LPDIRECTDRAWSURFACE7) This->lpLcl->lpGbl->lpDD->dsList;
   

    return DD_OK;
}

HRESULT WINAPI
Main_DDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
{         
    LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;

	DX_WINDBG_trace();

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

	DX_STUB;
}

HRESULT WINAPI
Main_DDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps)
{    
    LPDDRAWI_DDRAWSURFACE_INT This;

	DX_WINDBG_trace();

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

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

    This = (LPDDRAWI_DDRAWSURFACE_INT)iface;        
     
    RtlZeroMemory(pCaps,sizeof(DDSCAPS2));

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