ddi_if.cpp

windows ce 3.00 嵌入式操作系统源代码

	CLIPOBJ  *pco,
	XLATEOBJ *pxlo,
	RECTL    *prclDest,
	POINTL   *pptlSrc)
{
	DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Entering DrvCopyBits! - SHOULD ONLY BE USED BY PRINTER DRIVER \r\n")));
	ASSERT(0);
	return FALSE;
}


BOOL APIENTRY DrvAnyBlt(
	SURFOBJ         *psoDest,
	SURFOBJ         *psoSrc,
	SURFOBJ         *psoMask,
	CLIPOBJ         *pco,
	XLATEOBJ        *pxlo,
	POINTL          *pptlHTOrg,         // Halftone brush origin
	RECTL           *prclDest,
	RECTL           *prclSrc,
	POINTL          *pptlMask,
	BRUSHOBJ        *pbo,
	POINTL          *pptlBrush,
	ROP4             rop4,
	ULONG            iMode,             // DrvStretchBlt iMode: eg, COLORONCOLOR, HALFTONE
	ULONG	         bltFlags)
{
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvAnyBlt\r\n")));

	return AnyBlt(psoDest, psoSrc, psoMask, pco, pxlo, prclDest, prclSrc,
		pptlMask, pbo, pptlBrush, rop4, bltFlags );
}



BOOL APIENTRY DrvTransparentBlt(
	SURFOBJ         *psoDest,
	SURFOBJ         *psoSrc,
	CLIPOBJ         *pco,
	XLATEOBJ        *pxlo,
	RECTL           *prclDest,
	RECTL           *prclSrc,
	ULONG            TransColor)
{
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvTransparentBlt\r\n")));

	unsigned long bltFlags = BLT_TRANSPARENT;
    BRUSHOBJ bo;
    bo.iSolidColor = TransColor;


	// Since this may be called with an actual stretch or a 1:1, check
	// the actual dimensions.


	return AnyBlt(psoDest, psoSrc, NULL, pco, pxlo, prclDest, prclSrc,
		NULL, &bo, (POINTL *)NULL, 0xCCCC, bltFlags );
}



BOOL APIENTRY DrvBitBlt(
	SURFOBJ  *psoTrg,
	SURFOBJ  *psoSrc,
	SURFOBJ  *psoMask,
	CLIPOBJ  *pco,
	XLATEOBJ *pxlo,
	RECTL    *prclTrg,
	POINTL   *pptlSrc,
	POINTL   *pptlMask,
	BRUSHOBJ *pbo,
	POINTL   *pptlBrush,
	ROP4      rop4)
{
	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Entering DrvBitBlt\r\n")));
	RECTL rclSrc;
	if( pptlSrc )
	{
		rclSrc.top = pptlSrc->y;
		rclSrc.left = pptlSrc->x;
	}
	else
	{
		rclSrc.top = 0;
		rclSrc.left = 0;
	}
	rclSrc.bottom = rclSrc.top + prclTrg->bottom - prclTrg->top;
	rclSrc.right = rclSrc.left + prclTrg->right - prclTrg->left;

	return AnyBlt( psoTrg, psoSrc, psoMask, pco, pxlo, prclTrg, &rclSrc,
		pptlMask, pbo, pptlBrush, rop4, 0 );
}

SCODE ClipBlt( GPE *pGPE, GPEBltParms *pBltParms );

// The AnyBlt function can handle any stretching, color translation, masking, etc
// and services all of the other DrvBlt style functions

BOOL APIENTRY AnyBlt(
	SURFOBJ  *psoTrg,
	SURFOBJ  *psoSrc,
	SURFOBJ  *psoMask,
	CLIPOBJ  *pco,
	XLATEOBJ *pxlo,
	RECTL    *prclTrg,
	RECTL    *prclSrc,
	POINTL   *pptlMask,
	BRUSHOBJ *pbo,
	POINTL   *pptlBrush,
	ROP4      rop4,
	unsigned long bltFlags)
{

//	if( pbo && (pbo->iSolidColor == 0xffffffff ) && !(GPE_ZONE_BLT_HI) )
//		{
//        DebugBreak();
//	   		ulong oldSettings = dpCurSettings.ulZoneMask;
//		dpCurSettings.ulZoneMask |= 0x0034;	// enter, exit & blt hi and lo
//			BOOL v = DrvBitBlt(psoTrg,psoSrc,psoMask,pco,pxlo,prclTrg,pptlSrc,pptlMask,pbo,pptlBrush,rop4);
//			dpCurSettings.ulZoneMask = oldSettings;
//			return v;
//		}

	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("AnyBlt (rop4 = 0x%04x) rclTrg=t:%d,l:%d,b:%d,r:%d\r\n"),
		rop4, prclTrg->top, prclTrg->left, prclTrg->bottom, prclTrg->right ));

	GPE *pGPE = SurfobjToGPE(psoTrg);
	RECTL *prclCurr;
	GPEBltParms parms;
	TmpGPESurf pDst(psoTrg);
	TmpGPESurf pSrc(psoSrc,psoTrg,&pDst);
	TmpGPESurf pMask(psoMask);
	RECTL rclMask;
	int moreClipLists;
	SCODE sc1=0;
	SCODE sc2;


	if( pptlMask )
	{
		rclMask.top = pptlMask->y;
		rclMask.left = pptlMask->x;
		rclMask.bottom = pptlMask->y + prclTrg->bottom - prclTrg->top;
		rclMask.right = pptlMask->x + prclTrg->right - prclTrg->left;
	}
	else
		rclMask = *prclSrc;

	parms.pDst = pDst;
	parms.prclDst = prclTrg;
	parms.xPositive = 1;
	parms.yPositive = 1;
	parms.rop4 = rop4;
	parms.pLookup = (unsigned long *)NULL;
	parms.pConvert = NULL;
	parms.pBrush = (GPESurf *)NULL;
	parms.solidColor = 0xffffffff;

	// See if source matters
	if( ( rop4 ^ ( rop4 >> 2 ) ) & 0x3333 )
	{
		parms.prclSrc = prclSrc;
		parms.pSrc = pSrc;
		if( !prclTrg || !prclSrc )
			return 0;
		if( (prclTrg->right - prclTrg->left != prclSrc->right - prclSrc->left )
			|| ( prclTrg->bottom - prclTrg->top != prclSrc->bottom - prclSrc->top ))
			bltFlags |= BLT_STRETCH;
	}
	else
	{
		parms.prclSrc = (RECTL *)NULL;
		parms.pSrc = (GPESurf *)NULL;
		bltFlags &= ~BLT_STRETCH;
	}
	parms.bltFlags = bltFlags;

	// See if pattern matters
	if( ( rop4 ^ ( rop4 >> 4 ) ) & 0x0F0F )
	{
		parms.pptlBrush = pptlBrush;
		if( pbo )
		{
			if( pbo->iSolidColor == 0xffffffff )
			{
				if( pbo->pvRbrush == NULL )
					parms.pBrush = (GPESurf *)( BRUSHOBJ_pvGetRbrush( pbo ) );
				else
					parms.pBrush = (GPESurf *)( pbo->pvRbrush );
			}
			else
			{
				parms.solidColor = pbo->iSolidColor;
				parms.pptlBrush = (POINTL *)NULL;
			}
		}
		else
		{
			DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Blt w/ rop4=0x%04x and pbo==NULL !\r\n"),rop4));
			return FALSE;
		}
	}
	else
	{
		parms.pptlBrush = (POINTL *)NULL;
		if( pbo )
			parms.solidColor = pbo->iSolidColor;	// This is used as the transparent color
	}

	// See if mask matters
	if( ( rop4 ^ ( rop4 >> 8 ) ) & 0x00FF )
	{
		parms.prclMask = &rclMask;
		parms.pMask = pMask;
	}
	else
	{
		parms.prclMask = (RECTL *)NULL;
		parms.pMask = (GPESurf *)NULL;
	}


	ULONG iDir = CD_ANY;	// default to clip enumeration in any order

	if( (GPESurf *)(parms.pDst) == (GPESurf *)(parms.pSrc) )	// <-- Won't happen on stretch Blts
	{
		// Check for overlap since source and dest surfaces are the same
		if( 	prclSrc->bottom > prclTrg->top
			&& 	prclSrc->top < prclTrg->bottom
			&&	prclSrc->right > prclTrg->left
			&&	prclSrc->left < prclTrg->right )
		{
			if( prclSrc->top == prclTrg->top )
			{
				// Horizontal blt, just set xPositive appropriately
				parms.xPositive = prclSrc->left >= prclTrg->left;
			}
			else
				// Non horizontal blts, just set yPositive appropriately
				parms.yPositive = prclSrc->top >= prclTrg->top;

			// In case we enumerate cliprects - determine the order to use
			if( prclSrc->top > prclTrg->top )
				iDir = ( prclSrc->left > prclTrg->left ) ? CD_RIGHTDOWN : CD_LEFTDOWN;
			else
				iDir = ( prclSrc->left > prclTrg->left ) ? CD_RIGHTUP : CD_LEFTUP;
		}
	}
	else if ( parms.pSrc )
	{
		ColorConverter::InitConverter(
			pxlo,
			&parms.pColorConverter,
			(unsigned long (ColorConverter::** )(unsigned long))&parms.pConvert,
			&parms.pLookup );
	}

	parms.prclClip = (RECTL *)NULL;
	if( pco )
		if( pco->iDComplexity == DC_RECT )
			parms.prclClip = &(pco->rclBounds);

	if( FAILED(pGPE->BltPrepare( &parms ) ) )
	{
		DEBUGMSG(GPE_ZONE_ERROR,(TEXT("failed to prepare blt\r\n")));
		DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvBitBlt\r\n")));
		return FALSE;
	}

	if( pco && pco->iDComplexity == DC_COMPLEX )
	{
		// Non-trivial clipping - set up the Blt, then iterate through the cliprects & complete the blt
		CLIPENUM ce;

		// Request cliprects in a specific order to handle overlaps
		CLIPOBJ_cEnumStart( pco, TRUE, CT_RECTANGLES, iDir, 0 );	// don't need to count

		for( ce.c = 0, moreClipLists=1; ce.c || moreClipLists; )
		{
			if( ce.c == 0 )
			{
				// Get next list of cliprects from clipobj
				moreClipLists = CLIPOBJ_bEnum( pco, sizeof(ce), (ULONG *)&ce );
				prclCurr = ce.arcl;
				if( !ce.c )
					continue;
			}

			parms.prclClip = prclCurr++;
			ce.c--;

			DEBUGMSG(GPE_ZONE_BLT_HI,(TEXT("Calling GPE::Blt with complex cliprect\r\n")));
//#define ALLOW_MODIFY_BLTPARMS_IN_CLIP_BLT
#ifdef ALLOW_MODIFY_BLTPARMS_IN_CLIP_BLT
			GPEBltParms parmsCopy = parms;
			if( FAILED( sc1 = ClipBlt( pGPE, &parmsCopy ) ) )
#else
			if( FAILED( sc1 = ClipBlt( pGPE, &parms ) ) )
#endif
			{
				DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvBitBlt\r\n")));
				break;
			}
		}
	}
	else
		sc1 = ClipBlt( pGPE, &parms );

	sc2 = pGPE->BltComplete( &parms );

	DEBUGMSG(GPE_ZONE_ENTER,(TEXT("Leaving DrvBitBlt\r\n")));

	return !FAILED(sc1) && !FAILED(sc2);
}


SCODE ClipBlt(
	GPE *pGPE,
	GPEBltParms *pBltParms )
{
	DEBUGMSG(GPE_ZONE_BLT_LO,(TEXT("ClipBlt continue phase\r\n")));

#ifdef ALLOW_MODIFY_BLTPARMS_IN_CLIP_BLT

	if( pBltParms->prclClip && !( pBltParms->bltFlags & BLT_STRETCH ) )
	{
		RECTL rclDst = *(pBltParms->prclDst);
		RECTL &rclClip = *(pBltParms->prclClip);

		if( rclDst.left < rclClip.left )
			rclDst.left = rclClip.left;
		if( rclDst.top < rclClip.top )
			rclDst.top = rclClip.top;
		if( rclDst.bottom > rclClip.bottom )
			rclDst.bottom = rclClip.bottom;
		if( rclDst.right > rclClip.right )
			rclDst.right = rclClip.right;
		if( rclDst.right <= rclDst.left || rclDst.bottom <= rclDst.top )
			return S_OK;	// the clipping left nothing to do

		int OffLeft   = rclDst.left   - pBltParms->prclDst->left;
		int OffTop    = rclDst.top    - pBltParms->prclDst->top;
		int OffRight  = rclDst.right  - pBltParms->prclDst->right;
		int OffBottom = rclDst.bottom - pBltParms->prclDst->bottom;

		pBltParms->prclDst = &rclDst;

		if (OffLeft || OffTop || OffRight || OffBottom)
		{
			if( pBltParms->prclSrc )
			{
				register RECTL * const prclSrc = pBltParms->prclSrc;
				prclSrc->left += OffLeft;
				prclSrc->right += OffRight;
				prclSrc->top += OffTop;
				prclSrc->bottom += OffBottom;
			}

			if( pBltParms->prclMask )
			{
				register RECTL * const prclMask = pBltParms->prclMask;
				prclMask->left += OffLeft;
				prclMask->right += OffRight;
				prclMask->top += OffTop;
				prclMask->bottom += OffBottom;
			}
		}

		pBltParms->prclClip = (RECTL *)NULL;

		// Perform actual Blt
		return (pGPE->*(pBltParms->pBlt))( pBltParms );
	}
	else
		// Perform actual Blt
		return (pGPE->*(pBltParms->pBlt))( pBltParms );

#else // !ALLOW_MODIFY_BLTPARMS_IN_CLIP_BLT

	if( pBltParms->prclClip && !( pBltParms->bltFlags & BLT_STRETCH ) )
	{
		RECTL rclDst;
		RECTL rclSrc;
		RECTL rclMask;
		RECTL rclClip = *(pBltParms->prclClip);
		GPEBltParms parms = *pBltParms;
		parms.prclDst = &rclDst;
		rclDst = *(pBltParms->prclDst);
		if( rclDst.left < rclClip.left )
			rclDst.left = rclClip.left;
		if( rclDst.top < rclClip.top )
			rclDst.top = rclClip.top;
		if( rclDst.bottom > rclClip.bottom )
			rclDst.bottom = rclClip.bottom;
		if( rclDst.right > rclClip.right )
			rclDst.right = rclClip.right;
		if( rclDst.right <= rclDst.left || rclDst.bottom <= rclDst.top )
			return S_OK;	// the clipping left nothing to do

		int OffLeft   = rclDst.left   - pBltParms->prclDst->left;
		int OffTop    = rclDst.top    - pBltParms->prclDst->top;
		int OffRight  = rclDst.right  - pBltParms->prclDst->right;
		int OffBottom = rclDst.bottom - pBltParms->prclDst->bottom;

		if (OffLeft || OffTop || OffRight || OffBottom)
		{
			if( parms.prclSrc )
			{
				rclSrc = *(parms.prclSrc);
				parms.prclSrc = &rclSrc;
				rclSrc.left += OffLeft;
				rclSrc.right += OffRight;
				rclSrc.top += OffTop;
				rclSrc.bottom += OffBottom;
			}

			if( parms.prclMask )
			{
				rclMask = *(parms.prclMask);
				parms.prclMask = &rclMask;
				rclMask.left += OffLeft;
				rclMask.right += OffRight;
				rclMask.top += OffTop;
				rclMask.bottom += OffBottom;
			}
		}

		parms.prclClip = (RECTL *)NULL;

		// Perform actual Blt
		return (pGPE->*(pBltParms->pBlt))( &parms );
	}
	else
		// Perform actual Blt
		return (pGPE->*(pBltParms->pBlt))( pBltParms );

#endif // !ALLOW_MODIFY_BLTPARMS_IN_CLIP_BLT

}