haigdi.c

HGui4.1.rar

	case 16:
		for (i = 0; i < pBmpDst->height; i++)
		{
			_memcpy16to8(pDst, pSrc, pBmpSrc->width);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	case 24:
		for (i = 0; i < pBmpDst->height; i++)
		{
			_memcpy24to8(pDst, pSrc, pBmpSrc->width);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	default:
		return S_FALSE;
		break;
	}
	return S_TRUE;

}
static S_VOID _memcpy4to16(S_BYTE *pDst, S_BYTE *pSrc, S_WORD nPixel)
{
	S_WORD i;
	S_WORD odd = nPixel&0x1;
	S_COLOR c;

	nPixel &= 0xFFFE;
	for (i = 0; i < nPixel; i += 2)
	{
		c = gPalette4Bits[*pSrc>>4];
		*(S_WORD *)pDst = (S_WORD)(((c&0xF8)>>3)|((c&0xFC00)>>5)|((c&0xF80000)>>8));
		pDst += 2;

		c = gPalette4Bits[*pSrc&0xF];
		*(S_WORD *)pDst = (S_WORD)(((c&0xF8)>>3)|((c&0xFC00)>>5)|((c&0xF80000)>>8));
		pDst += 2;

		pSrc++;
	}
	if (odd)
	{
		c = gPalette4Bits[*pSrc>>4];
		*(S_WORD *)pDst = (S_WORD)(((c&0xF8)>>3)|((c&0xFC00)>>5)|((c&0xF80000)>>8));
		pDst += 2;
	}
}
static S_VOID _memcpy8to16(S_BYTE *pDst, S_BYTE *pSrc, S_WORD nPixel)
{
	S_WORD i;
	S_COLOR c;

	for (i = 0; i < nPixel; i++)
	{
		c = gPalette8Bits[*pSrc++];
		*(S_WORD *)pDst = (S_WORD)(((c&0xF8)>>3)|((c&0xFC00)>>5)|((c&0xF80000)>>8));
		pDst += 2;
	}
}
static S_VOID _memcpy24to16(S_BYTE *pDst, S_BYTE *pSrc, S_WORD nPixel)
{
	S_WORD i;
	S_WORD c;

	for (i = 0; i < nPixel; i++)
	{
		c = (*pSrc>>3)|((S_WORD)(*(pSrc+1)>>3)<<5)|((S_WORD)(*(pSrc+2)>>3)<<11);
		pSrc += 3;
		*(S_WORD *)pDst = c;
		pDst += 2;
	}
}
static S_BOOL _hai_ConverBitmapTo16Bits(_SP_BITMAP pBmpDst, _SP_BITMAP pBmpSrc)
{
	S_WORD i;
	S_BYTE * pSrc = (S_BYTE *)(pBmpSrc->lpImage);
	S_BYTE * pDst = (S_BYTE *)(pBmpDst->lpImage);
	S_WORD  WidthBytes = pBmpSrc->WidthBytes;

	if (pBmpDst->BitsPixel != 16)
		return S_FALSE;

	switch (pBmpSrc->BitsPixel)
	{
	case 4:
		for (i = 0; i < pBmpDst->height; i++)
		{
			_memcpy4to16(pDst, pSrc, pBmpSrc->width);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	case 8:
		for (i = 0; i < pBmpDst->height; i++)
		{
			_memcpy8to16(pDst, pSrc, pBmpSrc->width);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	case 16:
		for (i = 0; i < pBmpDst->height; i++)
		{
			memcpy(pDst, pSrc, WidthBytes);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	case 24:
		for (i = 0; i < pBmpDst->height; i++)
		{
			_memcpy24to16(pDst, pSrc, pBmpSrc->width);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	default:
		return S_FALSE;
		break;
	}
	return S_TRUE;

}

static S_VOID _memcpy4to24(S_BYTE *pDst, S_BYTE *pSrc, S_WORD nPixel)
{
	S_WORD i;
	S_WORD odd = nPixel&0x1;
	S_COLOR c;

	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);
	}
}
static S_VOID _memcpy8to24(S_BYTE *pDst, S_BYTE *pSrc, S_WORD nPixel)
{
	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);
	}
}
static S_VOID _memcpy16to24(S_BYTE *pDst, S_BYTE *pSrc, S_WORD nPixel)
{
	S_WORD i;
	S_COLOR c;

	for (i = 0; i < nPixel; i++)
	{
		c = *(S_WORD *)pSrc;
		pSrc += 2;
		*pDst++ = (S_BYTE)(c<<3);
		*pDst++ = (S_BYTE)((c>>5)<<2);
		*pDst++ = (S_BYTE)((c>>11)<<3);
	}
}
static S_BOOL _hai_ConverBitmapTo24Bits(_SP_BITMAP pBmpDst, _SP_BITMAP pBmpSrc)
{
	S_WORD i;
	S_BYTE * pSrc = (S_BYTE *)(pBmpSrc->lpImage);
	S_BYTE * pDst = (S_BYTE *)(pBmpDst->lpImage);
	S_WORD  WidthBytes = pBmpSrc->WidthBytes;

	if (pBmpDst->BitsPixel != 24)
		return S_FALSE;

	switch (pBmpSrc->BitsPixel)
	{
	case 4:
		for (i = 0; i < pBmpDst->height; i++)
		{
			_memcpy4to24(pDst, pSrc, pBmpSrc->width);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	case 8:
		for (i = 0; i < pBmpDst->height; i++)
		{
			_memcpy8to24(pDst, pSrc, pBmpSrc->width);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	case 16:
		for (i = 0; i < pBmpDst->height; i++)
		{
			_memcpy16to24(pDst, pSrc, pBmpSrc->width);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	case 24:
		for (i = 0; i < pBmpDst->height; i++)
		{
			memcpy(pDst, pSrc, WidthBytes);
			pSrc += WidthBytes;
			pDst += pBmpDst->WidthBytes;
		}
		break;
	default:
		return S_FALSE;
		break;
	}
	return S_TRUE;

}

SH_BITMAP  hai_CreateFormatBitmap(SH_DC hDC, SH_BITMAP hBmp)
{
	S_WORD WidthBytes;
	_SP_BITMAP pBmp;
	_SP_BITMAP pBmpDst;
	_SP_BITMAP pBmpSrc = (_SP_BITMAP)hBmp;
	
	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return (SH_BITMAP )S_NULL;
	if (!hBmp || HAI_GETHDLTYPE(hBmp) != HT_BITMAP || pBmpSrc->lpImage == S_NULL)
		return (SH_BITMAP )S_NULL;
	pBmp = (_SP_BITMAP)(((SP_DC)hDC)->hBitmap);
	if (pBmp == S_NULL)
		return (SH_BITMAP)S_NULL;

	WidthBytes = BITMAP_WIDTHBYTES(pBmpSrc->width, pBmp->BitsPixel);
	pBmpDst = (_SP_BITMAP)hai_MemAlloc(sizeof(_S_BITMAP)+WidthBytes*pBmpSrc->height);
	if (!pBmpDst)
		return (SH_BITMAP)S_NULL;

	HAI_SETHDLTYPE(pBmpDst , HT_BITMAP);
	pBmpDst ->width = pBmpSrc->width;
	pBmpDst ->height = pBmpSrc->height;
	pBmpDst ->BitsPixel = pBmp->BitsPixel;
	pBmpDst ->WidthBytes = WidthBytes;
	pBmpDst ->lpImage = ((S_BYTE *)pBmpDst)+sizeof(_S_BITMAP);

	switch (pBmpDst->BitsPixel)
	{
	case 4:
		_hai_ConverBitmapTo4Bits(pBmpDst, pBmpSrc);
		break;
	case 8:
		_hai_ConverBitmapTo8Bits(pBmpDst, pBmpSrc);
		break;
	case 16:
		_hai_ConverBitmapTo16Bits(pBmpDst, pBmpSrc);
		break;
	case 24:
		_hai_ConverBitmapTo24Bits(pBmpDst, pBmpSrc);
		break;
	default:
		break;
	}
	
	return (SH_BITMAP)pBmpDst ;
}

SH_ICON hai_LoadIcon(S_BYTE *filename)
{
	S_DWORD size;
	S_BYTE  *pRes;
	_SP_ICON pIco = S_NULL;

	if ((S_DWORD)filename & BUILTIN_RESOURCE_FLAG)
	{
	}
	else
	{
		SH_FILE hFile = hai_fopen(filename, "rb");
		if (hFile) {
			hai_fseek(hFile, 0, SEEK_END);
			size = hai_ftell(hFile);
			pRes = hai_MemAlloc(size);
			if (pRes)
			{
				hai_fseek(hFile, 0, SEEK_SET);
				size = hai_fread(pRes, size, 1, hFile);
				if (HAI_MAKEWORD(pRes)==0&&(HAI_MAKEWORD(pRes+2)==1||HAI_MAKEWORD(pRes+2)==2))
					pIco = (_SP_ICON)hai_IcoDecode(pRes, 2);
				hai_MemFree(pRes);
			}
			hai_fclose(hFile);
		}
	}

	return (SH_ICON)pIco; 
}

SH_ICON hai_CreateFormatIcon(SH_DC hDC, SH_ICON hIcon)
{
	S_WORD WidthBytes;
	_SP_BITMAP pBmp;
	_SP_ICON picoDst;
	_SP_ICON picoSrc = (_SP_ICON)hIcon;
	
	if (!hDC || HAI_GETHDLTYPE(hDC) != HT_DC)
		return (SH_ICON )S_NULL;
	if (!hIcon || HAI_GETHDLTYPE(hIcon) != HT_ICON || picoSrc->lpImage == S_NULL)
		return (SH_ICON )S_NULL;
	pBmp = (_SP_BITMAP)(((SP_DC)hDC)->hBitmap);
	if (pBmp == S_NULL)
		return (SH_ICON)S_NULL;

	WidthBytes = BITMAP_WIDTHBYTES(picoSrc->width, pBmp->BitsPixel);
	picoDst = (_SP_ICON)hai_MemAlloc(sizeof(*picoDst)+WidthBytes*picoSrc->height+MASKWIDTH(picoSrc->width)*picoSrc->height+4);
	if (!picoDst)
		return (SH_ICON)S_NULL;

	HAI_SETHDLTYPE(picoDst , HT_ICON);
	picoDst ->width = picoSrc->width;
	picoDst ->height = picoSrc->height;
	picoDst ->BitsPixel = pBmp->BitsPixel;
	picoDst ->WidthBytes = WidthBytes;
	picoDst ->lpImage = ((S_BYTE *)picoDst)+sizeof(*picoDst);
	picoDst->lpMask = ((S_BYTE *)picoDst)+sizeof(*picoDst)+WidthBytes*picoDst->height;

	switch (picoDst->BitsPixel)
	{
	case 4:
		_hai_ConverBitmapTo4Bits((_SP_BITMAP)picoDst, (_SP_BITMAP)picoSrc);
		break;
	case 8:
		_hai_ConverBitmapTo8Bits((_SP_BITMAP)picoDst, (_SP_BITMAP)picoSrc);
		break;
	case 16:
		_hai_ConverBitmapTo16Bits((_SP_BITMAP)picoDst, (_SP_BITMAP)picoSrc);
		break;
	case 24:
		_hai_ConverBitmapTo24Bits((_SP_BITMAP)picoDst, (_SP_BITMAP)picoSrc);
		break;
	default:
		memset(picoDst->lpImage, 0x00, WidthBytes*picoDst->height);
		break;
	}
	if (picoSrc->lpMask)
		memcpy(picoDst->lpMask, picoSrc->lpMask, MASKWIDTH(picoSrc->width)*picoSrc->height);
	else
		memset(picoDst->lpMask, 0x00, MASKWIDTH(picoSrc->width)*picoSrc->height);
	
	return (SH_ICON)picoDst ;
}

S_BOOL hai_DrawIcon(SH_DC hDC, S_SHORT x, S_SHORT y, SH_ICON hIcon)
{
	S_BOOL ret;

	if (!hDC || !hIcon || HAI_GETHDLTYPE(hDC) != HT_DC)
		return S_FALSE;
	if (x >= ((SP_DC)hDC)->cx || y >= ((SP_DC)hDC)->cy)
		return S_FALSE;
	if (!((SP_DC)hDC)->lpImage || !((SP_DC)hDC)->hBitmap)
		return S_FALSE;

	if (HAI_GETHDLTYPE(hIcon) == HT_BITMAP)
	{
		SH_DC hdcMem;
		_SP_BITMAP pBitmap = (_SP_BITMAP)hIcon;
		
		hdcMem = hai_CreateCompatibleDC(hDC);
		hai_SelectObject(hdcMem, (SH_GDIOBJ)pBitmap);
		ret = hai_BitBlt(hDC, x, y, pBitmap->width, pBitmap->height, hdcMem, 0, 0, SRCCOPY);		
		hai_DeleteDC(hdcMem);
	}
	else if (HAI_GETHDLTYPE(hIcon) == HT_ICON)
	{
		S_BYTE mask[] = {0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1};
		S_WORD i, j, w, h, ix=0, iy=0;
		S_BYTE *pdst, *psrc, *pmsk;
		_SP_ICON picon = (_SP_ICON)hIcon;
		_SP_BITMAP pbmp = (_SP_BITMAP)((SP_DC)hDC)->hBitmap;
		if (picon->BitsPixel != pbmp->BitsPixel)
			return S_FALSE;
		if (!picon->lpImage || !picon->lpMask)
			return S_FALSE;
		if (x < 0) {ix = -x; x = 0;}
		if (y < 0) {iy = -y; y = 0;}
		if (ix >= picon->width || iy >= picon->height)
			return S_FALSE;
		w = picon->width - ix;
		h = picon->height - iy;
		if (w > ((SP_DC)hDC)->cx-x) w = ((SP_DC)hDC)->cx-x;
		if (h > ((SP_DC)hDC)->cy-y) h = ((SP_DC)hDC)->cy-y;
		x += ((SP_DC)hDC)->x;//convert absolute address
		y += ((SP_DC)hDC)->y;

		pdst = (S_BYTE *)((SP_DC)hDC)->lpImage;
		psrc = (S_BYTE *)picon->lpImage;
		switch (pbmp->BitsPixel)
		{
		case 4:
			x &= ~0x1, ix &= ~0x1, w &= ~0x1;
			pdst += y * pbmp->WidthBytes + (x>>1);
			psrc += iy * picon->WidthBytes + (ix>>1);
			for (j = 0; j < h; j++) {
				pmsk = (S_BYTE *)picon->lpMask + (iy+j) * MASKWIDTH(picon->width);
				for (i = 0; i < w; i += 2) {
					if (!(pmsk[(ix+i)>>3] & mask[(ix+i)&0x7]))
						*pdst = (*pdst&0x0F)|(*psrc&0xF0);
					if (!(pmsk[(ix+i+1)>>3] & mask[(ix+i+1)&0x7]))
						*pdst = (*pdst&0xF0)|(*psrc&0x0F);
					pdst++, psrc++;
				}
				pdst += pbmp->WidthBytes - (w>>1);
				psrc += picon->WidthBytes - (w>>1);
			}
			break;
		case 8:
			pdst += y * pbmp->WidthBytes + x;
			psrc += iy * picon->WidthBytes + ix;
			for (j = 0; j < h; j++) {
				pmsk = (S_BYTE *)picon->lpMask + (iy+j) * MASKWIDTH(picon->width);
				for (i = 0; i < w; i++) {
					if (pmsk[(ix+i)>>3] & mask[(ix+i)&0x7])
						pdst++, psrc++;
					else
						*pdst++ = *psrc++;
				}
				pdst += pbmp->WidthBytes - w;
				psrc += picon->WidthBytes - w;
			}
			break;
		case 16:
			pdst += y * pbmp->WidthBytes + (x<<1);
			psrc += iy * picon->WidthBytes + (ix<<1);
			for (j = 0; j < h; j++) {
				pmsk = (S_BYTE *)picon->lpMask + (iy+j) * MASKWIDTH(picon->width);
				for (i = 0; i < w; i++) {
					if (!(pmsk[(ix+i)>>3] & mask[(ix+i)&0x7]))
						*(S_WORD*)pdst = *(S_WORD*)psrc;
					pdst += 2, psrc += 2;
				}
				pdst += pbmp->WidthBytes - (w<<1);
				psrc += picon->WidthBytes - (w<<1);
			}
			break;
		case 24:
			pdst += y * pbmp->WidthBytes + (x*3);
			psrc += iy * picon->WidthBytes + (ix*3);
			for (j = 0; j < h; j++) {
				pmsk = (S_BYTE *)picon->lpMask + (iy+j) * MASKWIDTH(picon->width);
				for (i = 0; i < w; i++) {
					if (pmsk[(ix+i)>>3] & mask[(ix+i)&0x7])
						pdst += 3, psrc += 3;
					else
						*pdst++ = *psrc++, *pdst++ = *psrc++, *pdst++ = *psrc++;
				}
				pdst += pbmp->WidthBytes - (w*3);
				psrc += picon->WidthBytes - (w*3);
			}
			break;
		}
		ret = S_TRUE;
	}
	else
		return S_FALSE;
	
	return ret;
}

static S_BOOL __BitBlt2_Blackness(S_BYTE *pImage, S_WORD BitsPixel, S_WORD WidthBytes, S_SHORT x, S_SHORT y, S_SHORT w, S_SHORT h)
{
	S_BYTE c8;
	S_SHORT wbak = w;
	
	switch (BitsPixel)
	{
	case 4:
		c8 = (S_BYTE)COLOR_GRAY00<<4 | (S_BYTE)COLOR_GRAY00;
		pImage += y * WidthBytes + (x>>1);
		while (h--)
		{
			w = wbak;
			if (w && x&0x1)
			{
				*pImage = (*pImage&0xF0) | COLOR_GRAY00;
				pImage++;
				w--;
			}
			for (;w > 1; w -= 2)
			{
				*pImage++ = c8;		
			}
			if (w == 1)
			{
				*pImage = (S_BYTE)((*pImage&0x0F) | COLOR_GRAY00<<4);
				pImage++;
			}
			pImage += WidthBytes - ((wbak+1)>>1);
			if (x&0x1 && !(wbak&0x1))
				pImage -= 1;
		}
		return S_TRUE;
	case 8:
		pImage += y * WidthBytes + x;
		while (h--)
		{
			w = (wbak+7)>>3;
			switch (wbak%8)
			{
			case 0:do{*pImage++ = COLOR_BLACK_8;
			case 7:   *pImage++ = COLOR_BLACK_8;
			case 6:   *pImage++ = COLOR_BLACK_8;
			case 5:   *pImage++ = COLOR_BLACK_8;
			case 4:   *pImage++ = COLOR_BLACK_8;
			case 3:   *pImage++ = COLOR_BLACK_8;
			case 2:   *pImage++ = COLOR_BLACK_8;