haigdi.c

HGui4.1.rar

//---------------------------------------------------------------------------------
// Copyright (c) Haisoft 2006-9-1
// Copyright jinhailiao 2008-2010
// E-mail:   [e-mail]
// Project:			HGui
// File:			haiGDI.c
// Description:		
//-------------------------------------------------------------
// Reversion Histroy:
//-------------------------------------------------------------
// Version		date		operations				by who
// 1.0.0		2006-09-01	Create					Kingsea
// 2.0.0		2006-09-06  update                  Kingsea
// 3.0.0		2008-03-01	update					Kingsea
//---------------------------------------------------------------------------------

#include "haitype.h"
#include "_haigdi.h"
#include "haigdi.h"
#include "haihandle.h"
#include "haimem.h"
#include "hailib.h"
#include "hzall.h"
#include "_haiscene.h"
#include "haiscene.h"
#include "_haictrl.h"
#include "haictrl.h"
#include "haigui.h"
#include "haicaret.h"
#include "haipic.h"
#include "haifile.h"


#define COPYPIXEL_24(pBmp, Color) *pBmp=(S_BYTE)Color,*(pBmp+1)=(S_BYTE)(Color>>8),*(pBmp+2)=(S_BYTE)(Color>>16)

extern S_BYTE resource[];


S_BYTE *pLcdDisRam = S_NULL;
S_DWORD LogDisRAM[(BITMAP_WIDTHBYTES(LCD_WIDTH, LCD_BITSPERPIX)*LCD_HEIGHT)/4];
//for BITSPERPIX == 4
S_BYTE	gFontMat[2][4]  = {0xFF, 0xF0, 0x0F, 0x00, 0xFF, 0xF0, 0x0F, 0x00};
S_BYTE  gFontMask[2][4] = {0x00, 0x00, 0x00, 0x00, 0xFF, 0xF0, 0x0F, 0x00};

static _S_PEN		_gPen;
static _S_BRUSH	_gBrush;
static _S_FONT	_gFont;
static _S_BITMAP	_gBitmap;

static S_BYTE gfScrnFlush = SCREEN_FLUSH_ON;

S_BYTE hai_SetScreenFlush(S_BYTE flush)
{
	S_BYTE old = gfScrnFlush;

	if (flush != SCREEN_FLUSH_GET)
		gfScrnFlush = flush;

	return old;
}

#ifdef PCSIM
S_VOID Ext_memcpy(S_BYTE *pDst, S_BYTE *pSrc, S_WORD nPixel)
{
#if (LCD_BITSPERPIX == 4)
	S_WORD i;
	S_COLOR c;
	S_WORD odd = nPixel&0x1;
	
	nPixel &= 0xFFFE;
	for (i = 0; i < nPixel; i += 2)
	{
		c = gPalette4Bits[*pSrc>>4];
		*pDst++ = (S_BYTE)c;
		*pDst++ = (S_BYTE)(c>>8);
		*pDst++ = (S_BYTE)(c>>16);

		c = gPalette4Bits[*pSrc&0xF];
		*pDst++ = (S_BYTE)c;
		*pDst++ = (S_BYTE)(c>>8);
		*pDst++ = (S_BYTE)(c>>16);

		pSrc++;
	}
	if (odd)
	{
		c = gPalette4Bits[*pSrc>>4];
		*pDst++ = (S_BYTE)c;
		*pDst++ = (S_BYTE)(c>>8);
		*pDst++ = (S_BYTE)(c>>16);
	}
#elif (LCD_BITSPERPIX == 8)
	S_WORD i;
	S_COLOR c;
	
	for (i = 0; i < nPixel; i++)
	{
		c = gPalette8Bits[*pSrc];
		*pDst++ = (S_BYTE)c;
		*pDst++ = (S_BYTE)(c>>8);
		*pDst++ = (S_BYTE)(c>>16);
		pSrc++;
	}
#elif (LCD_BITSPERPIX == 16)
	S_WORD i;
	S_WORD pixel;

	for (i = 0; i < nPixel; i++)
	{
		pixel = *(unsigned short *)pSrc;
		pSrc += 2;
		*pDst++ = pixel<<3;
		*pDst++ = (pixel>>5)<<2;
		*pDst++ = (pixel>>11)<<3;
	}
#elif (LCD_BITSPERPIX == 24)
	memcpy(pDst, pSrc, nPixel*3);
#else
	#error Unsupport color depth!
#endif
}

S_BOOL _hai_UpdateRect(S_VOID)
{
	S_WORD i, x, y, w, h;
	S_BYTE *pSrc, *pDst;
	SP_RECT pRect;
	
	if (hai_IsNeedRedraw() && hai_SetScreenFlush(SCREEN_FLUSH_GET))
	{
		pRect = hai_GetInvalidRect();
		x = pRect->x, y = pRect->y;
		w = pRect->w, h = pRect->h;
		pSrc = (S_BYTE *)LogDisRAM+y*BITMAP_WIDTHBYTES(LCD_WIDTH,LCD_BITSPERPIX)+x*LCD_BITSPERPIX/8;
		pDst = (S_BYTE *)pLcdDisRam+y*BITMAP_WIDTHBYTES(LCD_WIDTH,24)+x*24/8;
		for (i = 0; i < h; i++)
		{
			Ext_memcpy(pDst, pSrc, w);
			pSrc += BITMAP_WIDTHBYTES(LCD_WIDTH,LCD_BITSPERPIX);
			pDst += BITMAP_WIDTHBYTES(LCD_WIDTH,24);
		}
		memset(pRect, 0x00, sizeof(*pRect));
		return S_TRUE;
	}
	return S_FALSE;
}
#else
S_BOOL _hai_UpdateRect(S_VOID)
{
	S_WORD i, x, y, w, h;
	S_BYTE *pSrc, *pDst;
	SP_RECT pRect;
	
	if (hai_IsNeedRedraw() && hai_SetScreenFlush(SCREEN_FLUSH_GET) == SCREEN_FLUSH_ON)
	{
		pRect = hai_GetInvalidRect();
		x = pRect->x, y = pRect->y;
		w = pRect->w, h = pRect->h;
		pSrc = (S_BYTE *)LogDisRAM+y*BITMAP_WIDTHBYTES(LCD_WIDTH,LCD_BITSPERPIX)+x*LCD_BITSPERPIX/8;
		pDst = (S_BYTE *)pLcdDisRam+y*BITMAP_WIDTHBYTES(LCD_WIDTH,LCD_BITSPERPIX)+x*LCD_BITSPERPIX/8;
		for (i = 0; i < h; i++)
		{
			memcpy(pDst, pSrc, w*LCD_BITSPERPIX/8);
			pSrc += BITMAP_WIDTHBYTES(LCD_WIDTH,LCD_BITSPERPIX);
			pDst += BITMAP_WIDTHBYTES(LCD_WIDTH,LCD_BITSPERPIX);
		}
		memset(pRect, 0x00, sizeof(*pRect));
		return S_TRUE;
	}
	return S_FALSE;
}
#endif

SH_GDIOBJ hai_GetStockObject(S_BYTE ObjType)
{
	switch (ObjType)
	{
	case BLACK_BRUSH:
		_gBrush.HdlType = HT_BRUSH;
		_gBrush.style   = BS_SOLID;
		_gBrush.color   = COLOR_BLACK;
		_gBrush.hatch   = 0;
		return (SH_GDIOBJ)&_gBrush;

	case DKGRAY_BRUSH:
		_gBrush.HdlType = HT_BRUSH;
		_gBrush.style   = BS_SOLID;
		_gBrush.color   = COLOR_DARK;
		_gBrush.hatch   = 0;
		return (SH_GDIOBJ)&_gBrush;

	case GRAY_BRUSH:
		_gBrush.HdlType = HT_BRUSH;
		_gBrush.style   = BS_SOLID;
		_gBrush.color   = COLOR_GRAY;
		_gBrush.hatch   = 0;
		return (SH_GDIOBJ)&_gBrush;

	case LTGRAY_BRUSH:
		_gBrush.HdlType = HT_BRUSH;
		_gBrush.style   = BS_SOLID;
		_gBrush.color   = COLOR_LIGHT;
		_gBrush.hatch   = 0;
		return (SH_GDIOBJ)&_gBrush;

	case WHITE_BRUSH:
		_gBrush.HdlType = HT_BRUSH;
		_gBrush.style   = BS_SOLID;
		_gBrush.color   = COLOR_WHITE;
		_gBrush.hatch   = 0;
		return (SH_GDIOBJ)&_gBrush;

	case NULL_BRUSH:
		_gBrush.HdlType = HT_BRUSH;
		_gBrush.style   = BS_NULL;
		_gBrush.color   = COLOR_BLACK;
		_gBrush.hatch   = 0;
		return (SH_GDIOBJ)&_gBrush;

	case BLACK_PEN:
		_gPen.HdlType	= HT_PEN;
		_gPen.color		= COLOR_BLACK;
		_gPen.width		= 1;
		_gPen.style		= PS_SOLID;
		return (SH_GDIOBJ)&_gPen;

	case WHITE_PEN:
		_gPen.HdlType	= HT_PEN;
		_gPen.color		= COLOR_WHITE;
		_gPen.width		= 1;
		_gPen.style		= PS_SOLID;
		return (SH_GDIOBJ)&_gPen;

	case NULL_PEN:
		_gPen.HdlType	= HT_PEN;
		_gPen.color		= COLOR_BLACK;
		_gPen.width		= 1;
		_gPen.style		= PS_NONE;
		return (SH_GDIOBJ)&_gPen;

	case SYSTEM_FONT:
		_gFont.HdlType = HT_FONT;
		_gFont.FontID  = 1;
		_gFont.height   = 12;
		_gFont.width   = 6;
		_gFont.style   = 0;
		return (SH_GDIOBJ)&_gFont;

	case SYSTEM_FIXED_FONT:
		_gFont.HdlType = HT_FONT;
		_gFont.FontID  = 2;
		_gFont.height   = 12;
		_gFont.width   = 6;
		_gFont.style   = 0;
		return (SH_GDIOBJ)&_gFont;

	case DEFAULT_PALETTE:

	default:
		return S_NULL;
	}
}

S_VOID _hai_InitGDISystem(S_VOID)
{
//for BITSPERPIX == 4
	gFontMat[0][0] = 0xFF;
	gFontMat[0][1] = 0xF0;
	gFontMat[0][2] = 0x0F;
	gFontMat[0][3] = 0x00;
	gFontMat[1][0] = 0x00;
	gFontMat[1][1] = 0x00;
	gFontMat[1][2] = 0x00;
	gFontMat[1][3] = 0x00;

	gFontMask[0][0] = 0x00;
	gFontMask[0][1] = 0x00;
	gFontMask[0][2] = 0x00;
	gFontMask[0][3] = 0x00;
	gFontMask[1][0] = 0xFF;
	gFontMask[1][1] = 0xF0;
	gFontMask[1][2] = 0x0F;
	gFontMask[1][3] = 0x00;
}

S_COLOR hai_SetTextColor(SH_DC hDC, S_COLOR TextColor)
{
	S_COLOR CurColor;
	_SP_BITMAP pbmp;

	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x00;
	pbmp = (_SP_BITMAP)((SP_DC)hDC)->hBitmap;
	if (!pbmp)
		return 0x00;

	CurColor  = ((SP_DC)hDC)->TextColor;
	switch (pbmp->BitsPixel)
	{
	case 4:
		((SP_DC)hDC)->TextColor = TextColor&0xF;
		break;
	case 8:
		((SP_DC)hDC)->TextColor = TextColor&0xFF;
		break;
	case 16:
		((SP_DC)hDC)->TextColor = TextColor&0xFFFF;
		break;
	case 24:
		((SP_DC)hDC)->TextColor = TextColor&0xFFFFFF;
		break;
	default:
		break;
	}
	if (pbmp->BitsPixel == 4)
	{
		gFontMat[0][0] = (S_BYTE)( ((((SP_DC)hDC)->BkColor)<<4) | ((SP_DC)hDC)->BkColor );
		gFontMat[0][1] = (S_BYTE)( ((((SP_DC)hDC)->BkColor)<<4) | ((SP_DC)hDC)->TextColor );
		gFontMat[0][2] = (S_BYTE)( ((((SP_DC)hDC)->TextColor)<<4) | ((SP_DC)hDC)->BkColor );
		gFontMat[0][3] = (S_BYTE)( ((((SP_DC)hDC)->TextColor)<<4) | ((SP_DC)hDC)->TextColor );
		gFontMat[1][0] = (S_BYTE)( 0x00 );
		gFontMat[1][1] = (S_BYTE)( ((SP_DC)hDC)->TextColor );
		gFontMat[1][2] = (S_BYTE)( ((((SP_DC)hDC)->TextColor)<<4) );
		gFontMat[1][3] = (S_BYTE)( ((((SP_DC)hDC)->TextColor)<<4) | ((SP_DC)hDC)->TextColor );
	}
	return CurColor;
}

S_COLOR hai_GetTextColor(SH_DC hDC)
{
	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x0;
	return (((SP_DC)hDC)->TextColor);
}

S_COLOR hai_SetColorKey(SH_DC hDC, S_COLOR ColorKey)
{
	S_COLOR CurColor;
	_SP_BITMAP pbmp;

	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x00;
	pbmp = (_SP_BITMAP)((SP_DC)hDC)->hBitmap;
	if (!pbmp)
		return 0x00;

	CurColor  = ((SP_DC)hDC)->ColorKey;
	switch (pbmp->BitsPixel)
	{
	case 4:
		((SP_DC)hDC)->ColorKey = ColorKey&0xF;
		break;
	case 8:
		((SP_DC)hDC)->ColorKey = ColorKey&0xFF;
		break;
	case 16:
		((SP_DC)hDC)->ColorKey = ColorKey&0xFFFF;
		break;
	case 24:
		((SP_DC)hDC)->ColorKey = ColorKey&0xFFFFFF;
		break;
	default:
		break;
	}
	return CurColor;
}

S_COLOR hai_GetColorKey(SH_DC hDC)
{
	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x0;
	return (((SP_DC)hDC)->ColorKey);
}

S_BYTE hai_SetAlphaVal(SH_DC hDC, S_BYTE alpha)
{
	S_BYTE CurAlpha;

	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x00;

	CurAlpha  = ((SP_DC)hDC)->Alpha;
	((SP_DC)hDC)->Alpha = alpha;
		
	return CurAlpha;
}

S_BYTE hai_GetAlphaVal(SH_DC hDC)
{
	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x0;
	return (((SP_DC)hDC)->Alpha);
}

S_SHORT hai_SetBrightVal(SH_DC hDC, S_SHORT bright)
{
	S_SHORT CurBright;

	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x00;

	CurBright  = (S_SHORT)((SP_DC)hDC)->ColorKey;
	((SP_DC)hDC)->ColorKey = (S_COLOR)bright;
		
	return CurBright;
}

S_SHORT hai_GetBrightVal(SH_DC hDC)
{
	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x0;
	return (S_SHORT)(((SP_DC)hDC)->ColorKey);
}

S_COLOR hai_SetBkColor(SH_DC hDC, S_COLOR BkColor)
{
	S_COLOR CurColor;
	_SP_BITMAP pbmp;

	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x00;
	pbmp = (_SP_BITMAP)((SP_DC)hDC)->hBitmap;
	if (!pbmp)
		return 0x00;
	
	CurColor = ((SP_DC)hDC)->BkColor;
	switch (pbmp->BitsPixel)
	{
	case 4:
		((SP_DC)hDC)->BkColor = BkColor&0xF;
		break;
	case 8:
		((SP_DC)hDC)->BkColor = BkColor&0xFF;
		break;
	case 16:
		((SP_DC)hDC)->BkColor = BkColor&0xFFFF;
		break;
	case 24:
		((SP_DC)hDC)->BkColor = BkColor&0xFFFFFF;
		break;
	default:
		break;
	}

	if (pbmp->BitsPixel == 4)
	{
		gFontMat[0][0] = (S_BYTE)( ((((SP_DC)hDC)->BkColor)<<4) | ((SP_DC)hDC)->BkColor );
		gFontMat[0][1] = (S_BYTE)( ((((SP_DC)hDC)->BkColor)<<4) | ((SP_DC)hDC)->TextColor );
		gFontMat[0][2] = (S_BYTE)( ((((SP_DC)hDC)->TextColor)<<4) | ((SP_DC)hDC)->BkColor );
		gFontMat[0][3] = (S_BYTE)( ((((SP_DC)hDC)->TextColor)<<4) | ((SP_DC)hDC)->TextColor );
	}
	return CurColor;
}

S_COLOR hai_GetBkColor(SH_DC hDC)
{
	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0x0;
	return (((SP_DC)hDC)->BkColor);
}

S_BYTE hai_SetBkMode(SH_DC hDC, S_BYTE BkMode)
{
	S_BYTE mode;

	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0xFF;
	mode = ((SP_DC)hDC)->BkMode;
	((SP_DC)hDC)->BkMode = !(!BkMode);

	return mode;
}

S_BYTE hai_GetBkMode(SH_DC hDC)
{
	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return 0xFF;
	return ((SP_DC)hDC)->BkMode;
}

S_VOID _ResetDC(SP_DC pDC)
{
	HAI_SETHDLTYPE(&_gBitmap, HT_BITMAP);
	_gBitmap.width      = LCD_WIDTH;
	_gBitmap.height      = LCD_HEIGHT;
	_gBitmap.BitsPixel  = LCD_BITSPERPIX;
	_gBitmap.WidthBytes = BITMAP_WIDTHBYTES(LCD_WIDTH, LCD_BITSPERPIX);
	_gBitmap.lpImage    = LogDisRAM;
	
	pDC->OrgX		= 0;
	pDC->OrgY		= 0;
	pDC->x			= 0;
	pDC->y			= 0;
	pDC->cx			= LCD_WIDTH;
	pDC->cy			= LCD_HEIGHT;
	pDC->ColorKey	= 0;
	pDC->TextColor	= COLOR_BLACK;
	pDC->BkColor	= COLOR_WHITE;
	pDC->BkMode	= BKM_OPAQUE;
	pDC->Alpha		= 255;
	pDC->hPen		= (SH_PEN)hai_GetStockObject(BLACK_PEN);
	pDC->hFont		= (SH_FONT)hai_GetStockObject(SYSTEM_FONT);
	pDC->hBrush	= (SH_BRUSH)hai_GetStockObject(WHITE_BRUSH);
	pDC->hBitmap	= (SH_BITMAP)&_gBitmap;
	pDC->lpImage	= LogDisRAM;
}

SH_DC hai_GetScreenDC(S_VOID)
{
	SP_DC pDC;

	pDC = (SP_DC)hai_MemAlloc(sizeof(S_DC));
	if (pDC)
	{
		HAI_SETHDLTYPE(pDC, HT_DC);
		_ResetDC(pDC);
	}

	return (SH_DC)pDC;
}

SH_DC hai_GetSceneDC(S_VOID)
{
	SP_DC pDC = (SP_DC)hai_GetScreenDC();

	if (pDC)
		hai_GetSceneRect(&pDC->x, &pDC->y, &pDC->cx, &pDC->cy);

	return (SH_DC)pDC;
}