lcdslin.c

MCB2300_ucgui_LCD320240.rar LPC2368的uc/gui的移植

	}
	LCD_SETADR(0);
	for (i = 0; i < LCD_RAMSIZE; i++)
	{
		LCD_WRITE1(0x0);
	}
}

#endif /* T6963 */


/*
		*********************************************************
		*   													*
		*   	Write 1 byte and manage cache   				*
		*   													*
		*********************************************************
*/

static void LCD_Write(int Adr, U8 Byte)
{
	if (Cache[Adr] != Byte)
	{
		Cache[Adr] = Byte;
		if (LCD_Adr != Adr)
		{
			LCD_SETADR(Adr);
		}
		LCD_WRITE1(Byte);
	}
}

#define LCD_WRITE(Adr,Byte) LCD_Write(Adr,Byte);


/*
		*********************************************************
		*   													*
		*   	Internal set pixel routines 					*
		*   													*
		*********************************************************
*/

static void _SetPixel(int x, int y, LCD_PIXELINDEX c)
{
	U8 Mask = 1 << (7 - (x&7));
	int Adr = XY2OFF(x, y);
	U8 CacheByte = Cache[Adr];
	if (c)
	{
		CacheByte |= Mask;
	}
	else
	{
		CacheByte &= ~Mask;
	}
	LCD_WRITE(Adr, CacheByte)
}

static PIXELCOLOR _GetPixel(int x, int y)
{
	int Adr = XY2OFF(x, y);
	U8 Mask = 1 << (7 - (x&7));
	return (Cache[Adr] & Mask) ? 1 : 0;
}

static void XorPixel(int x, int y)
{
	LCD_PIXELINDEX Index = _GetPixel(x, y);
	_SetPixel(x, y, LCD_NUM_COLORS - 1 - Index);
}

/*
		*********************************************************
		*   													*
		*   	LCD_L0_SetPixelIndex							*
		*   													*
		*********************************************************

Purpose:  This routine is called by emWin. It writes 1 pixel into the
		  display.

*/

void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex)
{
	SETPIXEL(x, y, ColorIndex);
}


/*
		*********************************************************
		*   													*
		*   	LCD_L0_XorPixel 								*
		*   													*
		*********************************************************

Purpose:  This routine is called by emWin. It writes 1 pixel into the
		  display.

*/

void LCD_L0_XorPixel(int x, int y)
{
	XORPIXEL(x, y);
}


/*
		*********************************************************
		*   													*
		*   	   LCD_L0_DrawHLine optimized   				*
		*   													*
		*********************************************************
*/

#if (LCD_OPTIMIZE)  			 \
	  && (!LCD_SWAP_XY) 		 \
	  && (!LCD_MIRROR_X)		 \
	  && (!LCD_MIRROR_Y)		 \
	  && (!LCD_SUPPORT_COMTRANS) \
	  && (!LCD_SUPPORT_SEGTRANS)

void LCD_L0_DrawHLine(int x0, int y, int x1)
{
	register int Off = XY2OFF(x0, y);
	int iByte = x0 >> 3;
	int Byte1 = x1 >> 3;
	U8 Mask = 0xff >> (x0&7);
	U8 EndMask = 0xff80 >> (x1&7);
	U8 Data;
	if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR)
	{
		for (; iByte < Byte1; iByte++)
		{
			Data = Cache[Off];
			Data ^= Mask; 
			LCD_WRITE(Off++, Data);
			Mask = 0xff;
		}
		Mask &= EndMask;
		Data = Cache[Off];
		Data ^= Mask; 
		LCD_WRITE(Off++, Data);
	}
	else
	{
		/* Clear pixels in line */
		int NumBytes = Byte1 - iByte;
		if (COLOR == 0)
		{
			if (NumBytes)
			{
				Data = Cache[Off] & (~Mask);
				LCD_WRITE(Off++, Data);
				NumBytes--;
				/* Fill bytes in 2 loops for speed reasons ... */
				for (; NumBytes >= 4; NumBytes -= 4)
				{
					LCD_WRITE(Off++, 0);
					LCD_WRITE(Off++, 0);
					LCD_WRITE(Off++, 0);
					LCD_WRITE(Off++, 0);
				}
				for (; NumBytes; NumBytes--)
				{
					LCD_WRITE(Off++, 0);
				}
				Mask = 0xff;
			}
			Mask &= EndMask;
			Data = Cache[Off];
			Data &= ~Mask; 
			LCD_WRITE(Off++, Data);
		}
		else
		{
			/* Set pixels in line */
			if (NumBytes)
			{
				Data = Cache[Off] | Mask; 
				LCD_WRITE(Off++, Data);
				NumBytes--;
				/* Fill bytes in 2 loops for speed reasons ... */
				for (; NumBytes >= 4; NumBytes -= 4)
				{
					LCD_WRITE(Off++, 0xff);
					LCD_WRITE(Off++, 0xff);
					LCD_WRITE(Off++, 0xff);
					LCD_WRITE(Off++, 0xff);
				}
				for (; NumBytes; NumBytes--)
				{
					LCD_WRITE(Off++, 0xff);
				}
				Mask = 0xff;
			}
			Mask &= EndMask;
			Data = Cache[Off] | Mask; 
			LCD_WRITE(Off++, Data);
		}
	}
}

#else

/*
		*********************************************************
		*   													*
		*   	   LCD_L0_DrawHLine unoptimized 				*
		*   													*
		*********************************************************
*/

void LCD_L0_DrawHLine(int x0, int y, int x1)
{
	if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR)
	{
		while (x0 <= x1)
		{
			XORPIXEL(x0, y);
			x0++;
		}
	}
	else
	{
		while (x0 <= x1)
		{
			SETPIXEL(x0, y, COLOR);
			x0++;
		}
	}
}

#endif


/*
		*********************************************************
		*   													*
		*   	   LCD_L0_DrawVLine 							*
		*   													*
		*********************************************************
*/

void LCD_L0_DrawVLine(int x, int y0, int y1)
{
	if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR)
	{
		while (y0 <= y1)
		{
			XORPIXEL(x, y0);
			y0++;
		}
	}
	else
	{
		while (y0 <= y1)
		{
			SETPIXEL(x, y0, COLOR);
			y0++;
		}
	}
}


/*
		*********************************************************
		*   													*
		*   	   LCD_FillRect, unoptimized					*
		*   													*
		*********************************************************
*/

void LCD_L0_FillRect(int x0, int y0, int x1, int y1)
{
	for (; y0 <= y1; y0++)
	{
		LCD_L0_DrawHLine(x0, y0, x1);
	}
}


/*
		*********************************************************
		*   													*
		*    Support for dynamic inversion of entire LCD		*
		*   													*
		*********************************************************

*/

#if LCD_REVERSEMODE_SUPPORT

void LCD_SetNormalDispMode(void)
{
}
void LCD_SetReverseDispMode(void)
{
}

#endif


/*
		*********************************************************
		*   													*
		*   	   Draw Bitmap 1 BPP, optimized 				*
		*   													*
		*********************************************************
*/

#if (LCD_OPTIMIZE)  			 \
	  && (!LCD_SWAP_XY) 		 \
	  && (!LCD_MIRROR_X)		 \
	  && (!LCD_MIRROR_Y)		 \
	  && (!LCD_SUPPORT_COMTRANS) \
	  && (!LCD_SUPPORT_SEGTRANS)

static void DrawBitLine1BPP(int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX *pTrans)
{
	LCD_PIXELINDEX Index0 = *(pTrans + 0);
	LCD_PIXELINDEX Index1 = *(pTrans + 1);
	x += Diff;
	if ((Index0 == Index1) & (!(GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR))))
	{
		LCD_PIXELINDEX ColorIndexOld = COLOR;
		COLOR = Index0;
		LCD_L0_DrawHLine(x, y, x + xsize - 1);
		COLOR = ColorIndexOld;
		return;
	}
	{
		int Adr = XY2OFF(x, y);
		int x1 = x + xsize - 1;
		U8 Mask = 0xff >> (x &7);
		U8 EndMask = 0xff80 >> (x1&7);
		U8 CacheByte;
		U16 PixelData;
		int NumBytes = (x1 >> 3) - (x >> 3);
		if (NumBytes)
		{
			CacheByte = Cache[Adr];
			PixelData = (*(p + 1) | ((*p) << 8));
			PixelData >>= (8 + (x & 7) - (Diff & 7));
			switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR))
			{
				case 0:
					if (!COLOR)
					{
						PixelData ^= 255;
					}
					CacheByte = (CacheByte & ~Mask) | (PixelData & Mask);
					break;
				case LCD_DRAWMODE_TRANS:
					if (COLOR)
					{
						CacheByte |= (PixelData & Mask);
					}
					else
					{
						CacheByte &= ~(PixelData & Mask);
					}
					break;
				case LCD_DRAWMODE_XOR:
					CacheByte ^= (PixelData & Mask);
					break;
			}
			LCD_WRITE(Adr++, CacheByte);
			{
				int DiffOld = Diff;
				Diff += 8 - (x & 7); 
				if ((DiffOld & ~7) != (Diff & ~7))
				{
					p++;
				}
			}
			x = 0;
			NumBytes--;
			for (; NumBytes; NumBytes--)
			{
				PixelData = (*(p + 1) | ((*p) << 8));
				PixelData >>= (8 - (Diff & 7));
				p++;
				switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR))
				{
					case 0:
						if (!COLOR)
						{
							PixelData ^= 255;
						}
						CacheByte = PixelData & 255;
						break;
					case LCD_DRAWMODE_TRANS:
						CacheByte = Cache[Adr];
						if (COLOR)
						{
							CacheByte |= PixelData;
						}
						else
						{
							CacheByte &= ~PixelData;
						}
						break;
					case LCD_DRAWMODE_XOR:
						CacheByte = Cache[Adr] ^ PixelData;
						break;
				}
				LCD_WRITE(Adr++, CacheByte);
			}
			Mask = 0xff;
		}
		PixelData = (*(p + 1) | ((*p) << 8));
		PixelData >>= (8 + (x & 7) - (Diff & 7));
		Mask &= EndMask;
		CacheByte = Cache[Adr];
		switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR))
		{
			case 0:
				if (!COLOR)
				{
					PixelData ^= 255;
				}
				CacheByte = (CacheByte & ~Mask) | (PixelData & Mask);
				break;
			case LCD_DRAWMODE_TRANS:
				if (COLOR)
				{
					CacheByte |= (PixelData & Mask);
				}
				else
				{
					CacheByte &= ~(PixelData & Mask);
				}
				break;
			case LCD_DRAWMODE_XOR:
				CacheByte ^= (PixelData & Mask);
				break;
		}
		LCD_WRITE(Adr++, CacheByte);
	}
}

#else


/*
		*********************************************************
		*   													*
		*   	   Draw Bitmap 1 BPP, no optimization   		*
		*   													*
		*********************************************************
*/

static void DrawBitLine1BPP(int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX *pTrans)
{
	PIXELCOLOR pixels;
	PIXELCOLOR Index0 = *(pTrans + 0);
	PIXELCOLOR Index1 = *(pTrans + 1);
	/*
			Jump to right entry point
	*/
	pixels = *p;
	switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR))
	{
		case 0:
			switch (Diff & 7)
			{
				case 0:
					goto WriteBit0;
				case 1:
					goto WriteBit1;
				case 2:
					goto WriteBit2;
				case 3:
					goto WriteBit3;
				case 4:
					goto WriteBit4;
				case 5:
					goto WriteBit5;
				case 6:
					goto WriteBit6;
				case 7:
					goto WriteBit7;
			}
			break;
		case LCD_DRAWMODE_TRANS:
			switch (Diff & 7)
			{
				case 0:
					goto WriteTBit0;
				case 1:
					goto WriteTBit1;
				case 2:
					goto WriteTBit2;
				case 3:
					goto WriteTBit3;
				case 4:
					goto WriteTBit4;
				case 5:
					goto WriteTBit5;
				case 6:
					goto WriteTBit6;
				case 7:
					goto WriteTBit7;
			}
			break;
		case LCD_DRAWMODE_XOR:
			switch (Diff & 7)
			{
				case 0:
					goto WriteXBit0;
				case 1:
					goto WriteXBit1;
				case 2:
					goto WriteXBit2;
				case 3:
					goto WriteXBit3;
				case 4:
					goto WriteXBit4;
				case 5:
					goto WriteXBit5;
				case 6:
					goto WriteXBit6;
				case 7:
					goto WriteXBit7;
			}
	}
	/*
			Write with transparency
	*/
	WriteTBit0:
	if (pixels & (1 << 7))
	{
		SETPIXEL(x + 0, y, Index1);
	}
	if (!--xsize)
	{
		return;
	}
	WriteTBit1:
	if (pixels & (1 << 6))
	{
		SETPIXEL(x + 1, y, Index1);
	}
	if (!--xsize)
	{
		return;
	}
	WriteTBit2:
	if (pixels & (1 << 5))
	{
		SETPIXEL(x + 2, y, Index1);
	}
	if (!--xsize)
	{
		return;
	}
	WriteTBit3:
	if (pixels & (1 << 4))
	{
		SETPIXEL(x + 3, y, Index1);
	}
	if (!--xsize)
	{
		return;
	}
	WriteTBit4:
	if (pixels & (1 << 3))
	{
		SETPIXEL(x + 4, y, Index1);
	}
	if (!--xsize)
	{
		return;
	}
	WriteTBit5:
	if (pixels & (1 << 2))
	{
		SETPIXEL(x + 5, y, Index1);
	}
	if (!--xsize)
	{
		return;
	}
	WriteTBit6:
	if (pixels & (1 << 1))
	{
		SETPIXEL(x + 6, y, Index1);
	}
	if (!--xsize)
	{
		return;
	}
	WriteTBit7:
	if (pixels & (1 << 0))
	{
		SETPIXEL(x + 7, y, Index1);
	}
	if (!--xsize)
	{
		return;
	}
	x += 8;