/*********************************************************************
*
* GUI__cbDrawTextStyle
*/
static void GUI__cbDrawTextStyle(U16 Char) {
int x0, x1;
x1 = GUI_Context.DispPosX - 1;
x0 = x1 - GUI_Context.pAFont->pfGetCharDistX(Char) + 1;
/* Handle Underline */
if (GUI_Context.TextStyle & GUI_TS_UNDERLINE) {
int yOff = GUI_Context.pAFont->Baseline;
if (yOff >= GUI_Context.pAFont->YSize) {
yOff = GUI_Context.pAFont->YSize - 1;
}
LCD_DrawHLine(x0, GUI_Context.DispPosY + yOff, x1);
}
/* Handle strike thru */
if (GUI_Context.TextStyle & GUI_TS_STRIKETHRU) {
int yOff = GUI_Context.pAFont->Baseline - ((GUI_Context.pAFont->CHeight + 1) / 2);
LCD_DrawHLine(x0, GUI_Context.DispPosY + yOff, x1);
}
/* Handle over line */
if (GUI_Context.TextStyle & GUI_TS_OVERLINE) {
int yOff = GUI_Context.pAFont->Baseline - GUI_Context.pAFont->CHeight - 1;
if (yOff < 0) {
yOff = 0;
}
LCD_DrawHLine(x0, GUI_Context.DispPosY + yOff, x1);
}
}
void LCD_DrawRec(u16 x,u16 y,u16 w,u16 h,u8 color)//指定起、长度、宽度和线框的颜色画矩形，线宽默认1像素
{
LCD_DrawHLine(x,y,w,color);
LCD_DrawVLine(x,y,h,color);
LCD_DrawVLine(x+w-1,y,h,color);
LCD_DrawHLine(x,y+h-1,w,color);
}
void LCD_DrawKeyOK(u16 x,u16 y)
{
LCD_DrawKeyDel(x,y);
LCD_DrawHLine(x+36+44,y+24+5,15,WHITE);
LCD_DrawHLine(x+36+44,y+24+6,15,WHITE);
LCD_DrawVLine(x+36+48+10,y+24+5-30,32,WHITE);
LCD_DrawVLine(x+36+48+11,y+24+5-30,32,WHITE);
}
/*********************************************************************
*
* _DrawMax
*/
static void _DrawMax(void) {
GUI_RECT r;
WM_GetInsideRect(&r);
WM_ADDORG(r.x0, r.y0);
WM_ADDORG(r.x1, r.y1);
WM_ITERATE_START(&r); {
LCD_DrawHLine(r.x0 + 1, r.y0 + 1, r.x1 - 1);
LCD_DrawHLine(r.x0 + 1, r.y0 + 2, r.x1 - 1);
LCD_DrawHLine(r.x0 + 1, r.y1 - 1, r.x1 - 1);
LCD_DrawVLine(r.x0 + 1, r.y0 + 1, r.y1 - 1);
LCD_DrawVLine(r.x1 - 1, r.y0 + 1, r.y1 - 1);
} WM_ITERATE_END();
}
void Show_KeyMap(void)//»Êý×Ö¼üÅÌ
{
touch.PID=1;
LCD_Clear(2,20,236,99,BLACK);
LCD_Clear(0,160,240,300,BLUE);
LCD_DrawTitleBar(title);
LCD_DrawEdit(input);
LCD_DrawHLine(0,160,240,BLACK);
LCD_DrawHLine(0,220,240,BLACK);
LCD_DrawHLine(0,280,240,BLACK);
LCD_DrawHLine(0,340,180,BLACK);
LCD_DrawHLine(0,399,240,BLACK);
LCD_DrawVLine(60,160,180,BLACK);
LCD_DrawVLine(120,160,240,BLACK);
LCD_DrawVLine(180,160,180,BLACK);
Set_Color(BLUE,WHITE);
LCD_DrawKeyNum(1,0,160);
LCD_DrawKeyNum(2,60,160);
LCD_DrawKeyNum(3,120,160);
LCD_DrawKeyNum(0,180,160);
LCD_DrawKeyNum(4,0,220);
LCD_DrawKeyNum(5,60,220);
LCD_DrawKeyNum(6,120,220);
LCD_DrawKeyNum(10,180,220);
LCD_DrawKeyNum(7,0,280);
LCD_DrawKeyNum(8,60,280);
LCD_DrawKeyNum(9,120,280);
LCD_DrawKeyDel(0,340);
LCD_DrawKeyOK(120,340);
Set_Cursor(8,132);
}
/*********************************************************************
*
* _DrawRestore
*/
static void _DrawRestore(void) {
GUI_RECT r;
int Size;
WM_GetInsideRect(&r);
WM_ADDORG(r.x0, r.y0);
WM_ADDORG(r.x1, r.y1);
Size = ((r.x1 - r.x0 + 1) << 1) / 3;
WM_ITERATE_START(&r); {
LCD_DrawHLine(r.x1 - Size, r.y0 + 1, r.x1 - 1);
LCD_DrawHLine(r.x1 - Size, r.y0 + 2, r.x1 - 1);
LCD_DrawHLine(r.x0 + Size, r.y0 + Size, r.x1 - 1);
LCD_DrawVLine(r.x1 - Size, r.y0 + 1, r.y1 - Size);
LCD_DrawVLine(r.x1 - 1, r.y0 + 1, r.y0 + Size);
LCD_DrawHLine(r.x0 + 1, r.y1 - Size, r.x0 + Size);
LCD_DrawHLine(r.x0 + 1, r.y1 - Size + 1, r.x0 + Size);
LCD_DrawHLine(r.x0 + 1, r.y1 - 1, r.x0 + Size);
LCD_DrawVLine(r.x0 + 1, r.y1 - Size, r.y1 - 1);
LCD_DrawVLine(r.x0 + Size, r.y1 - Size, r.y1 - 1);
} WM_ITERATE_END();
}
/*********************************************************************
*
* GL_DrawBitmapEx
*/
static void GL_DrawBitmapEx(const GUI_BITMAP GUI_UNI_PTR * pBitmap, int x0, int y0,
int xCenter, int yCenter, int xMag, int yMag) {
LCD_PIXELINDEX Index, IndexPrev = 0;
LCD_COLOR Color;
int x, y, xi, yi, xSize, ySize, xAct, xStart, xMagAbs, xiMag, yMin, yMax, yEnd, yPrev, yStep;
char Cached, HasTrans = 0;
/* Use clipping rect to reduce calculation */
yMin = GUI_Context.ClipRect.y0;
yMax = GUI_Context.ClipRect.y1;
/* Init some values */
xSize = pBitmap->XSize;
ySize = pBitmap->YSize;
xMagAbs = ((xMag < 0) ? -xMag : xMag);
x0 -= (I32)((xMag < 0) ? xSize - xCenter - 1 : xCenter) * (I32)(xMagAbs) / (I32)(1000);
yEnd = y0 + GUI__DivideRound32(((I32)(-yCenter) * (I32)(yMag)), 1000);
yPrev = yEnd + 1;
yStep = (yMag < 0) ? -1 : 1;
if (pBitmap->pPal) {
if (pBitmap->pPal->HasTrans) {
HasTrans = 1;
}
}
for (yi = 0; yi < ySize; yi++) {
y = yEnd;
yEnd = y0 + GUI__DivideRound32(((I32)(yi + 1 - yCenter) * (I32)(yMag)), 1000);
if (y != yPrev) {
yPrev = y;
do {
if ((y >= yMin) && (y <= yMax)) {
xStart = -1;
x = 0;
xiMag = 0;
Cached = 0;
for (xi = 0; xi < xSize; xi++) {
xiMag += xMagAbs;
if (xiMag >= 1000) {
xAct = (xMag > 0) ? xi : xSize - xi - 1;
Index = GUI_GetBitmapPixelIndex(pBitmap, xAct, yi);
if (Index != IndexPrev || xStart == -1) {
if ((Index == 0) && HasTrans) {
/* Transparent color ... clear cache */
if (Cached) {
LCD_DrawHLine(x0 + xStart, y, x0 + x - 1);
Cached = 0;
}
} else {
/* Another color ... draw contents of cache */
if (Cached && xStart != -1) {
LCD_DrawHLine(x0 + xStart, y, x0 + x - 1);
}
xStart = x;
Cached = 1;
if (pBitmap->pMethods) {
Color = pBitmap->pMethods->pfIndex2Color(Index);
} else {
Color = pBitmap->pPal->pPalEntries[Index];
}
LCD_SetColorIndex(LCDDEV_L0_Color2Index(Color));
}
IndexPrev = Index;
}
do {
x++;
xiMag -= 1000;
} while (xiMag >= 1000);
}
}
/* Clear cache */
if (Cached) {
LCD_DrawHLine(x0 + xStart, y, x0 + x - 1);
}
}
y += yStep;
} while ((yMag < 0) ? (y > yEnd) : (y < yEnd));
}
}
}
/*********************************************************************
*
* _DrawBitmap_RLE8
*/
static void _DrawBitmap_RLE8(int x0,int y0,int xsize, int ysize, const U8 GUI_UNI_PTR * pPixel, const LCD_LOGPALETTE GUI_UNI_PTR * pLogPal, int xMag, int yMag) {
LCD_PIXELINDEX aColorIndex[2];
LCD_PIXELINDEX PixelIndex;
int xi,y;
int xL, yL;
const U8 GUI_UNI_PTR * pPixelOrg = pPixel;
char NoTrans = !(GUI_Context.DrawMode & LCD_DRAWMODE_TRANS);
const LCD_PIXELINDEX* pTrans =NULL;
char IsMagnified = ((yMag | xMag) != 1);
aColorIndex[0] = LCD_ACOLORINDEX[0];
aColorIndex[1] = LCD_ACOLORINDEX[1];
/* Handle color translation */
if ((pLogPal) && (pLogPal->pPalEntries)) {
if ((pTrans = LCD_GetpPalConvTable(pLogPal)) == NULL) {
return;
}
}
/* Check if we can limit the number of lines due to clipping) */
if (yMag == 1) {
if (ysize > GUI_Context.ClipRect.y1 - y0 + 1)
ysize = GUI_Context.ClipRect.y1 - y0 + 1;
}
/* Init variables for looping */
xi=0;
y =0;
/* Check if we can use the cache to save some unnecessary iterations */
if (!IsMagnified) {
int yDiff = GUI_Context.ClipRect.y0 - y0;
if ((Cache.pPixelStart == pPixel) && (yDiff > Cache.y)) {
/* Accept cache values */
y = Cache.y;
xi = Cache.x;
pPixel = Cache.pPixel;
}
}
/* Init values for caching */
Cache.pPixel = Cache.pPixelStart = pPixelOrg;
Cache.x = Cache.y = 0;
/* Repeat until we have reached bottom */
for (; y < ysize; ) {
U8 Cmd = *pPixel++;
U8 Data = *pPixel++;
if (Cmd) {
/* Save cache info */
Cache.pPixel = pPixel-2;
Cache.x = xi;
Cache.y = y;
LCD_ACOLORINDEX[1] = pTrans ? *(pTrans+Data) : Data;
while (Cmd) {
int xi1 = xi+Cmd;
if (xi1>=xsize)
xi1 = xsize;
Cmd -= (xi1-xi);
if (Data || NoTrans) { /* Skip transparent pixels */
if (IsMagnified) {
xL = xMag * xi + x0;
yL = yMag * y + y0;
LCD_FillRect(xL, yL, xL + xMag * (xi1 - xi) -1 , yL + yMag - 1);
} else {
LCD_DrawHLine(x0+xi, y + y0, xi1+x0-1);
}
}
xi =xi1;
if (xi1==xsize) {
y++;
xi=0;
}
}
} else {
do {
U8 Index = *pPixel++;
if (Index || NoTrans) { /* Skip transparent pixels */
int x = x0+xi;
PixelIndex = pTrans ? *(pTrans+Index) : Index;
if (IsMagnified) {
LCD_SetColorIndex(PixelIndex);
xL = xMag * xi + x0;
yL = yMag * y + y0;
LCD_FillRect(xL, yL, xL + xMag -1 , yL + yMag - 1);
} else {
#if 1 /* High speed variant */
if (y + y0>= GUI_Context.ClipRect.y0)
if (x >= GUI_Context.ClipRect.x0)
if (x <= GUI_Context.ClipRect.x1)
LCDDEV_L0_SetPixelIndex(x, y + y0, PixelIndex);
#else
LCD_SetPixelIndex(x, y + y0, PixelIndex);
#endif
}
}
if (++xi >= xsize) {
xi=0; y++;
if (y >= ysize)
break;
}
} while (--Data);
}
}
LCD_ACOLORINDEX[0] = aColorIndex[0];
LCD_ACOLORINDEX[1] = aColorIndex[1];
}
