gdidrv1b.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

	//需要的移位数
    maskShift = lpData->lprcSrc->left & 0x07;
    dstShift = lpData->lprcDest->left & 0x07;
	//需要的目标字节数
    destBytes =( (lpData->lprcDest->right-1) >> 3) - (lpData->lprcDest->left >> 3) + 1;
    maskBytes = ( (lpData->lprcSrc->left + i - 1) >> 3 ) - (lpData->lprcSrc->left >> 3) + 1;

    lMask = leftFillMask[lpData->lprcDest->left&0x07];
    rMask = rightFillMask[lpData->lprcDest->right&0x07];
    if( destBytes == 1 )
        lMask &= rMask;

    if( lpData->solidColor )
         clFore = 0xffff;
    else
         clFore = 0x0000;
    if( lpData->solidBkColor )
         clBack = 0xffff;
    else
         clBack = 0x0000;
	//需要处理的行数
    rows = lpData->lprcDest->bottom - lpData->lprcDest->top;
	//对每一行数据进行处理
    for( i = 0; i < rows; i++ )
    {
	    //处理开始的字节  handle first byte
        lpStart = lpMaskStart;
        lpDst = lpDestStart;

        maskValue = *lpStart;
        maskValue <<= (maskShift + 8);
        maskValue >>= dstShift;
        shift = maskShift + 8 - dstShift;

	    if( maskBytes == 1 )
	    {
            maskValue &= (rightMask << shift);
            shift = 0;
	    }
        lpStart++;
        j = 1;   /// count mask bytes
        n = 0;   // count dest bytes

        // fill first byte
        if( shift > 8 )
        {
            shift -= 8;
            maskValue |= *lpStart++ << shift;
            if( ++j == maskBytes )
            {
                maskValue &= (rightMask << shift);
                shift = 0;
            }
        }
        mask = maskValue >> 8;
        maskValue <<= 8;
        shift += 8;
        color = ((clFore & mask) | (clBack & ~mask));
        *lpDst++ = (*lpDst & ~lMask) | (color & lMask);
        n++;
		//处理中间的字节
        // fill middle bytes
        while( n < destBytes - 1 )
        {
            if( shift > 8 )
            {
                shift -= 8;
                maskValue |= *lpStart++ << shift;
                if( ++j == maskBytes )
                {
                    maskValue &= (rightMask << shift);
                    shift = 0;
                }
            }
            mask = maskValue >> 8;
            maskValue <<= 8;
            shift += 8;

            *lpDst++ = (clFore & mask) | (clBack & ~mask);
            n++;
        }

        // 假如可能，处理最后的字节 fill end byte
        if( n < destBytes )
        {
            if( shift > 8 )
            {
                shift -= 8;
                maskValue |= *lpStart++ << shift;
                if( ++j == maskBytes )
                {
                    maskValue &= (rightMask << shift);
                    shift = 0;
                }
            }
            mask = maskValue >> 8;
            color = ((clFore & mask) | (clBack & ~mask));
            *lpDst = (*lpDst & ~rMask) | (color & rMask);
        }
		//下一行
        lpMaskStart += lpData->lpSrcImage->bmWidthBytes;
        lpDestStart += lpData->lpDestImage->bmWidthBytes;
    }
    return TRUE;
}

// *****************************************************************
//声明：static BOOL __TextTransparentBitBlt( _LPBLKBITBLT lpData )
//参数：
//	IN lpData - _BLKBITBLT结构指针
//返回值：
//	返回TRUE
//功能描述：
//	用纯色输出透明文本（当位模bit为1时，输出；否则不输出）
//引用: 
//	
// *****************************************************************

static BOOL __TextTransparentBitBlt( _LPBLKBITBLT lpData )
{
    LPBYTE lpDestStart, lpDst;
    LPCBYTE lpMaskStart, lpStart;
    WORD clFore;
    WORD maskValue, rightMask, destBytes, maskBytes;
    int i, j, n,  rows, maskShift, dstShift, shift;
    BYTE mask;

    lpDestStart = lpData->lpDestImage->bmBits + lpData->lprcDest->top * lpData->lpDestImage->bmWidthBytes + (lpData->lprcDest->left >> 3);
    lpMaskStart = lpData->lpSrcImage->bmBits + lpData->lprcSrc->top * lpData->lpSrcImage->bmWidthBytes + (lpData->lprcSrc->left >> 3);

    i = lpData->lprcDest->right - lpData->lprcDest->left;
    mask = (lpData->lprcSrc->left + i) & 0x07;
    if ( mask )
        rightMask = (WORD)(0xffffff00l >> mask);
    else
        rightMask = (WORD)0xffffffffl;

    maskShift = lpData->lprcSrc->left & 0x07;
    dstShift = lpData->lprcDest->left & 0x07;

    destBytes =( (lpData->lprcDest->right-1) >> 3) - (lpData->lprcDest->left >> 3) + 1;
    maskBytes = ( (lpData->lprcSrc->left + i - 1) >> 3 ) - (lpData->lprcSrc->left >> 3) + 1;

    if( lpData->solidColor )
         clFore = 0xffff;
    else
         clFore = 0x0000;

    rows = lpData->lprcDest->bottom - lpData->lprcDest->top;

    for( i = 0; i < rows; i++ )
    {
	    //处理开始的字节 //  handle first byte
        lpStart = lpMaskStart;
        lpDst = lpDestStart;

        maskValue = *lpStart;
        maskValue <<= (maskShift + 8);
        maskValue >>= dstShift;
        shift = maskShift + 8 - dstShift;

	    if( maskBytes == 1 )
	    {
            maskValue &= (rightMask << shift);
            shift = 0;
	    }
        lpStart++;
        j = 1;   /// count mask bytes
        n = 0;   // count dest bytes
		//处理余下的字节
        while( n < destBytes )
        {
            if( shift > 8 )
            {
                shift -= 8;
                maskValue |= *lpStart++ << shift;
                if( ++j == maskBytes )
                {
                    maskValue &= (rightMask << shift);
                    shift = 0;
                }
            }
            mask = maskValue >> 8;
            maskValue <<= 8;
            shift += 8;

            *lpDst = (*lpDst & ~mask) | (clFore & mask);
            lpDst++;
            n++;
        }
		//下一行
        lpMaskStart += lpData->lpSrcImage->bmWidthBytes;
        lpDestStart += lpData->lpDestImage->bmWidthBytes;
    }
    return TRUE;
}

// *****************************************************************
//声明：static BOOL _TextBitBlt( _LPBLKBITBLT lpData )
//参数：
//	IN lpData - _BLKBITBLT结构指针
//返回值：
//	返回TRUE
//功能描述：
//	用输出文本或位模
//引用: 
//	
// *****************************************************************

static BOOL _TextBitBlt( _LPBLKBITBLT lpData )
{
    if( lpData->backMode == TRANSPARENT )
        return __TextTransparentBitBlt( lpData );
    else
        return __TextSolidBitBlt( lpData );
}

// *****************************************************************
//声明：static BOOL __BltFillTransparentPattern( _LPBLKBITBLT lpData )
//参数：
//	IN lpData - _BLKBITBLT结构指针
//返回值：
//	成功TRUE
//功能描述：
//	用模板透明填充
//引用: 
//	
// *****************************************************************

static BOOL __BltFillTransparentPattern( _LPBLKBITBLT lpData )
{
    int height = lpData->lprcDest->bottom - lpData->lprcDest->top;
    LPBYTE lpDstStart = lpData->lpDestImage->bmBits +
                   lpData->lpDestImage->bmWidthBytes * lpData->lprcDest->top +
                   (lpData->lprcDest->left >> 3);
    WORD scanBytes = lpData->lpDestImage->bmWidthBytes;
    WORD destBytes = ( (lpData->lprcDest->right - 1) >> 3 ) - ( lpData->lprcDest->left >> 3 ) + 1;
    BYTE leftMask = leftFillMask[lpData->lprcDest->left & 0x07];
    BYTE rightMask = rightFillMask[lpData->lprcDest->right & 0x07];
    LPCBYTE lpPattern = lpData->lpBrush->pattern;
    WORD clrFore;

    if( destBytes == 1 )
        leftMask &= rightMask;
    if( lpData->lpBrush->color )
        clrFore = 0xffff;
    else
        clrFore = 0;

    // 假如可能，填充开始字节 fill left bytes if posible
    if( leftMask != 0xff )
    {
        register LPBYTE lpDst = lpDstStart;
        register int m, n = lpData->lprcDest->top;
        register BYTE pattern;

        for( m = 0; m < height; m++, n++, lpDst += scanBytes )
        {
            pattern = *(lpPattern+(n&0x07)) & leftMask;
            *lpDst = (*lpDst & ~pattern) | ( clrFore & pattern );
        }
        destBytes--;
        lpDstStart++;
    }
    // 假如可能，填充终点 fill right bytes if posible
    if( rightMask != 0xff && destBytes > 0 )
    {
        register LPBYTE lpDst = lpDstStart + destBytes - 1;
        register int m, n = lpData->lprcDest->top;
        register BYTE pattern;
        for( m = 0; m < height; m++, n++, lpDst += scanBytes )
        {
            pattern = *(lpPattern+(n&0x07)) & rightMask;
            *lpDst = (*lpDst & ~pattern) | (clrFore & pattern);
        }
        destBytes--;
    }

    // 填充中间的字节 fill middle bytes
    if( destBytes > 0 )
    {
        register LPBYTE lpDst;
        register int n, m, k = lpData->lprcDest->top;
        register BYTE pattern;

        for( m = 0; m < height; m++, k++ )
        {
            pattern = *(lpPattern+(k&0x07));
            lpDst = lpDstStart;
            // line copy
            for( n = 0; n < destBytes; n++, lpDst++ )
                *lpDst = (*lpDst & ~pattern) | (clrFore & pattern);

            lpDstStart += scanBytes;
        }
    }
    return TRUE;
}

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltFillPattern
#define BLT_ROP( bDst, bSrc )  ( (bSrc) )
#include "bltfpat.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltPatInvertPattern
#define BLT_ROP( bDst, bSrc ) ( (bDst) ^ (bSrc) )
#include "bltfpat.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltSrcCopy
#define BLT_ROP( bDst, bSrc )  ( (bSrc) )
#include "bltcpy.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltSrcAnd
#define BLT_ROP( bDst, bSrc )  ( (bDst) & (bSrc) )
#include "bltcpy.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltNotSrcCopy
#define BLT_ROP( bDst, bSrc )  ( ~(bSrc) )
#include "bltcpy.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltSrcInvert
#define BLT_ROP( bDst, bSrc )  ( (bDst) ^ (bSrc) )
#include "bltcpy.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltSrcPaint
#define BLT_ROP( bDst, bSrc )  ( (bDst) | (bSrc) )
#include "bltcpy.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltFillSolid
#define BLT_ROP( bDst, bColor ) ( (bColor) )
#include "bltfill.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltPatInvertSolid
#define BLT_ROP( bDst, bSrc ) ( (bDst) ^ (bSrc) )
#include "bltfill.h"

#undef  FUNCTION
#undef  BLT_ROP
#define FUNCTION __BltDstInvert
#define BLT_ROP( bDst, bSrc ) (~(bDst))
#include "bltfill.h"

// *****************************************************************
//声明：static BOOL _BlkBitTransparentBlt( _LPBLKBITBLT lpData )
//参数：
//	IN lpData - _BLKBITBLT结构指针
//返回值：
//	成功TRUE
//功能描述：
//	透明填充位模
//引用: 
//	
// *****************************************************************

static BOOL _BlkBitTransparentBlt( _LPBLKBITBLT lpData )
{
    if( lpData->lpBrush )	//是否带模板
        return __BltFillTransparentPattern( lpData );
    else
        return __TextTransparentBitBlt( lpData );
}

#undef FUNCTION
#undef SRC_ROP
#undef DEST_ROP
#define SRC_ROP( bSrc, bMask ) ((bSrc)&(bMask))
#define DEST_ROP( bDest, bMask ) ((bDest)&~(bMask))
#define FUNCTION __BltMaskSrcCopy
#include "bltmask.h"

#undef FUNCTION
#undef SRC_ROP
#undef DEST_ROP
#define SRC_ROP( bSrc, bMask ) ((bSrc)&(~(bMask)))
#define DEST_ROP( bDest, bMask ) ((bDest)&(bMask))
#define FUNCTION __BltInvertMaskSrcCopy
#include "bltmask.h"

// *****************************************************************
//声明：static BOOL _BlkBitMaskBlt( _LPBLKBITBLT lpData )
//参数：
//	IN lpData - _BLKBITBLT结构指针
//返回值：
//	成功TRUE
//功能描述：
//	带屏蔽位的位块传送
//引用: 
//	
// *****************************************************************

static BOOL _BlkBitMaskBlt( _LPBLKBITBLT lpData )
{
    if( lpData->lpSrcImage->bmBitsPixel == 1 )
    {
        if( lpData->dwRop == SRCCOPY )
            return __BltMaskSrcCopy( lpData );
        else if( lpData->dwRop == 1000 )
        {
            return __BltInvertMaskSrcCopy( lpData );
        }
    }
    return FALSE;

}

// *****************************************************************
//声明：static BOOL _BlkBitBlt( _LPBLKBITBLT lpData )
//参数：
//	IN lpData - _BLKBITBLT结构指针
//返回值：
//	成功TRUE
//功能描述：
//	位块传送
//引用: 
//	
// *****************************************************************

static BOOL _BlkBitBlt( _LPBLKBITBLT lpData )
{
    switch( lpData->dwRop )
    {
    case SRCCOPY:		// dest = src
        if( lpData->lpSrcImage != lpData->lpDestImage )
            return __TextSolidBitBlt( lpData );
        else
            return __BltSrcCopy( lpData );        
    case SRCAND:		// dest = dest & src
        return __BltSrcAnd( lpData );
    case SRCINVERT:		// dest = dest ^ src
        return __BltSrcInvert( lpData );
    case SRCPAINT:		// dest = dest | src
        return __BltSrcPaint( lpData );
    case PATCOPY:
        if( lpData->lpBrush == 0 )
            return __BltFillSolid( lpData );
        else
        {
            if( lpData->lpBrush->style == BS_SOLID )
            {
                lpData->solidColor = lpData->lpBrush->color;
                return __BltFillSolid( lpData );
            }
            else
                return __BltFillPattern( lpData );
        }
    case BLACKNESS:
        lpData->solidColor = CL_BLACK;
        return __BltFillSolid( lpData );
    case WHITENESS:
        lpData->solidColor = CL_WHITE;
        return __BltFillSolid( lpData );
    case PATINVERT:
        if( lpData->lpBrush == 0 )
            return __BltPatInvertSolid( lpData );
        else
            return __BltPatInvertPattern( lpData );
    case DSTINVERT:		// dest = ~dest
        return __BltDstInvert( lpData );
    case NOTSRCCOPY:	// dest = ~src
        return __BltNotSrcCopy( lpData );
    }
    return FALSE;
}