pixel[nHeadCount+1]=cTmp;       }*/       draw_bmp(x,y,2,16,pixel);       x+=16;  	              if(x>=screen_width) {                              y+=16;                             x=0;                           }       i+=2;      }    else     {      //Yongkui Lu add it to fit the small head problem!      //int iTmp=i;//backup i      //printf("gui:i=%d,count=%d,buf[%d]=%c\n",i,count,i,buf[i]);      /*if(i%2==0){	      i++;      }else{	      i--;      }*/      if(buf[i]=='\n') {	      		k=(y*screen_width+x)>>3;			l=(screen_width-x)>>3;	      		for(j=0;j<16;j++,k+=m)			  memset(screen_ptr+k,0,l);	      		x=0;y+=16;	           			}      else      {	      draw_bmp(x,y,1,16,E_Font+(buf[i]<<4));		      x+=8;      }      //i=iTmp; //load from backup      i++;      /*iTmp=i;//backup i      if(i%2==0){	      i++;      }else{	      i--;      }      if(buf[i]=='\n') {	      		k=(y*screen_width+x)>>3;			l=(screen_width-x)>>3;	      		for(j=0;j<16;j++,k+=m)			  memset(screen_ptr+k,0,l);	      		x=0;y+=16;	           			}      else      {	      draw_bmp(x,y,1,16,E_Font+(buf[i]<<4));		      x+=8;      }      i=iTmp; //load from backup      i++;*/     }  }}void setmode(CopyMode mode){  Mode=mode;}CopyMode getmode(void)	{  return Mode;	}void setcolor(short color){  Color=color;}UINT getcolor(void){	return Color;}void setfillpattern(PatternIndex index){  P_Index=index;	}PatternIndex getfillpattern(void){  return P_Index;	}void moveto(short x,short y){	X=x;Y=y;}void lineto(short x,short y){	line(x,y,X,Y);	X=x;Y=y;}/* * $Id: graphic.c,v 1.2 1999/11/12 13:03:26 till Exp $ * * Graphics primitive drawing functions * derived from: graphic.c Pixy Graphic Library * derived from: lissa.c: Graphics demos * * Copyright (C) 2001  Chen Yang <support@hhcn.com> * Copyright (C) 1999  Till Krech <till@snafu.de> * Copyright (C) 1998  Kenneth Albanowski <kjahds@kjahds.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * The code in this file is partially based on Kenneth Albanowskis work * for the lissa graphics demo. *//******************Notice*********************************** * The Default Font size for ASCII Font is 8x16 * The Default Font size of Chinese Font is 16x16 ***********************************************************/#include <sys/types.h>#include <sys/stat.h>#include <linux/fb.h>#include <stdio.h>#include <unistd.h>#include <fcntl.h>#include <sys/mman.h>#include "mathf.h"#include "font_8x16.h"#include "gui.h"/*Define the correct Chinese Font File Path*/#define CHINESE_FONT_FILE "/font/hanzi"typedef struct {    unsigned short height;    unsigned char data[0];} Pattern;const Pattern _BlackPattern ={  1,    {~0}};const Pattern _WhitePattern ={  1,  { 0 }};const Pattern _DarkGreyPattern ={  2,  {    (unsigned char)0x55555555,    (unsigned char)0xCCCCCCCC  }};const Pattern _LightGreyPattern ={  4,  {    (unsigned char)0x88888888,    (unsigned char)0x00000000,    (unsigned char)0x22222222,    (unsigned char)0x00000000,  }};const Pattern _MicroPengPattern ={  16,  {    0x3c,0x7e,0x56,0xaa,0x86,0x4e,0x7b,0xc3,0x83,0x83,0xc3,0xc7,0xbd,0x99,0x99,    0xff  }};static const Pattern *patterns[] = {  /* This must correspond to the enum in pixy.h! */  &_BlackPattern,  &_WhitePattern,  &_DarkGreyPattern,  &_LightGreyPattern,  &_MicroPengPattern,};static short masktab[]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};static int screen_fd=-1;FILE *C_Font;unsigned char * screen_ptr=(unsigned char*)(0x0400),*E_Font=(unsigned char*)(0x8500);static short screen_width=160,screen_height=160;static short WinSX,WinSY,WinEX,WinEY;static unsigned short X,Y,Color,P_Index,Mode=MODE_SRC;//CopyMode pixy_copy_mode = Mode_SRC;inline void setpixel(short x, short y, short color){    if ((x<0) || (x>=screen_width) || (y<0) || (y>=screen_height))		return;    {	       	unsigned char * loc = screen_ptr + ((y * screen_width*2 + x*2 ));	if (color){		*loc =0xff;*(loc+1)=0xff;	}else{		*loc = 0x0;*(loc+1)=0x0;	}			/*	short mask = masktab[(x&7)];    	unsigned char * loc = screen_ptr + ((y * screen_width + x )>>3);		if (color)			*loc |= mask;		else			*loc &= ~mask;	*/    }}/* Abrash's take on the simplest Bresenham line-drawing algorithm.  * * This isn't especially efficient, as we aren't combining the bit-mask * logic and addresses with the line drawing code, never mind higher * level optimizations like run-length slicing, etc. * */static inline void draw_xish_line(short x, short y, short dx, short dy, short xdir){	short dyX2=dy+dy;	short dyX2mdxX2=dyX2-(dx+dx);	short error=dyX2-dx;		setpixel(x, y, Color);	while (dx--) {		if (error >= 0) {			y++;			error += dyX2mdxX2;		} else {			error += dyX2;		}		x += xdir;		setpixel(x,y,Color);	}}static inline void draw_yish_line(short x, short y, short dx, short dy,short xdir){	short dxX2=dx + dx;	short dxX2mdyX2=dxX2-(dy+dy);	short error=dxX2-dy;		setpixel(x, y, Color);	while (dy--) {		if (error >= 0) {			x+= xdir;			error += dxX2mdyX2;		} else {			error += dxX2;		}		y++;		setpixel(x,y, Color);	}}void line(short x1, short y1, short x2, short y2){	short dx,dy;		if ( y1 > y2) {		short t = y1;		y1 = y2;		y2 = t;		t = x1;		x1 = x2;		x2 = t;	}		dx = x2-x1;	dy = y2-y1;		if (dx > 0) {		if (dx > dy)			draw_xish_line(x1, y1, dx, dy, 1);		else			draw_yish_line(x1, y1, dx, dy, 1);	} else {		dx = -dx;		if (dx > dy)			draw_xish_line(x1, y1, dx, dy, -1);		else			draw_yish_line(x1, y1, dx, dy, -1);	}		}/* One of Abrash's ellipse algorithms  */void ellipse(short x, short y, short a, short b){	short wx, wy;	short thresh;	short asq = a * a;	short bsq = b * b;	short xa, ya;		setpixel(x, y+b, Color);	setpixel(x, y-b, Color);		wx = 0;	wy = b;	xa = 0;	ya = asq * 2 * b;	thresh = asq / 4 - asq * b;		for (;;) {		thresh += xa + bsq;				if (thresh >= 0) {			ya -= asq * 2;			thresh -= ya;			wy--;		}				xa += bsq * 2;		wx++;				if (xa >= ya)		  break;						setpixel(x+wx, y-wy, Color);		setpixel(x-wx, y-wy, Color);		setpixel(x+wx, y+wy, Color);		setpixel(x-wx, y+wy, Color);	}		setpixel(x+a, y, Color);	setpixel(x-a, y, Color);		wx = a;	wy = 0;	xa = (bsq * a) << 1;		ya = 0;	thresh = (bsq >> 2) - bsq * a;		for (;;) {		thresh += ya + asq;				if (thresh >= 0) {			xa -= bsq + bsq;			thresh = thresh - xa;			wx--;		}				ya += asq + asq;		wy++;				if (ya > xa)		  break;		 		setpixel(x+wx, y-wy, Color);		setpixel(x-wx, y-wy, Color);		setpixel(x+wx, y+wy, Color);		setpixel(x-wx, y+wy, Color);	}}inline void h_line(int x1,int x2,int y){ static short ftab[]={0xff,0x7f,0x3f,0x1f,0x0f,0x7,0x3,0x1}; static short btab[]={0x0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe}; short count;  count=(x2-x1)>>3; if(count>1) {  unsigned char *loc;    loc=screen_ptr+((y*screen_width+x1)>>3);    if(Color)  {    *(loc)|=ftab[x1&7];         memset(loc+1,0xff,count-1);   *(loc+count)|= ftab[7-(x2&7)];  }   else   {    *loc &=btab[x1&7];    memset(loc+1,0,count-1);      *(loc+count)&=ftab[(x2&7)+1];   } }  else    line(x1, y, x2, y);	  }/* Composites */void rectangle(short x1, short y1, short x2, short y2){	line(x1, y1, x2, y1);	line(x2, y1, x2, y2);	line(x2, y2, x1, y2);	line(x1, y2, x1, y1);}void bar(short x1,short y1,short x2,short y2){		for(;y1<y2;y1++)		h_line(x1,x2,y1);}inline void clip_screen(short in_x, short in_y, short in_w, short in_h, short *out_x, short *out_y, short *out_w, short *out_h) {  short swp;  if (in_w < 0) {    in_x += in_w;    in_w = -in_w;  }  if (in_h < 0) {    in_y += in_h;    in_h = -in_h;  }  if (in_x < 0) {    in_w -= in_x;    in_x = 0;  }  if (in_y < 0) {    in_h -= in_y;    in_y = 0;  }  if (in_w > screen_width) {    in_w = screen_width;  }  if (in_h > screen_height) {    in_h = screen_height;  }  if (in_w < 0) {    in_w = 0;  }  if (in_h < 0) {    in_h = 0;  }  *out_x = in_x;  *out_y = in_y;  *out_w = in_w;  *out_h = in_h;}		void patternfill( short dest_x,		 short dest_y, 		 short w,		 short h,		 unsigned char*dest,		 short dest_units_per_line);void  fillrect(short x1, short y1, short x2, short y2){	short x, y, w, h;	clip_screen(x1, y1, x2-x1, y2-y1, &x, &y, &w, &h); 	patternfill(x, y, w, h, screen_ptr, screen_width>>3);}void bitblt(		 short src_x,		 short src_y,		 short w,		 short h,		 short dest_x,		 short dest_y, 		 unsigned char *src,		 short src_units_per_line, 		 unsigned char *dest,		 short dest_units_per_line		 ) {  /* todo: clip */  register char dx;  unsigned short x,y;  unsigned char src_off, dest_off;  short dest_n;  unsigned char dest_beg_mask, dest_end_mask;    /* goto line y */  src += src_y * src_units_per_line;  dest += dest_y * dest_units_per_line;    /* goto UNIT-offset x */  src += src_x >>3;  dest += dest_x >>3;  /* determine number of affected units per line */    dest_n = ((dest_x + w + 8 - 1) >>3) - (dest_x >>3);  /* determine PIXEL-offsets */  src_off = src_x & 7;  dest_off = dest_x & 7;  dx = dest_off - src_off;    /* make masks to mask out untouchable destination */  dest_beg_mask = ~((unsigned char)(-1) >> dest_off);  dest_end_mask = (unsigned char)(-1) >> ((dest_off + w) & 7);  if (dest_end_mask == (unsigned char)(-1)) {    /* bit stupid */    dest_end_mask = 0;  }  //printf("dx=%d\n", dx);  //dump_unit("dest_beg_mask", dest_beg_mask);  //dump_unit("dest_end_mask", dest_end_mask);  for (y = 0; y < h; y++) {    // process one line    register unsigned char *sp;    register unsigned char *dp;    register unsigned char mask = 0;    register unsigned char left, right;    unsigned char s, d;    sp = src;    dp = dest;    for (x = 0; x < dest_n; x++, sp++, dp++) {      // process one unit      if (dx < 0) {	// first, don't care about masks	left = *sp << (-dx);	right = *(sp+1) >> (8 + dx);      } else if (dx > 0) {	// first, don't care about masks	left = *(sp-1) << (8-dx);	right = *(sp) >> (dx);      } else {	left = *sp;	right = 0;      }      s = left | right;      // combine with destination      switch (Mode) {      case MODE_SRC:      default:	d = s;	break;      case MODE_NOT_SRC:	d = ~s;	break;      case MODE_SRC_OR_DST:	d = *dp | s;	break;      case MODE_SRC_AND_DST:	d = *dp & s;	break;      case MODE_SRC_XOR_DST:	d = *dp ^ s;	break;      case MODE_NOT_SRC_OR_DST:	d = *dp | ~s;	break;      case MODE_NOT_SRC_AND_DST:	d = *dp & ~s;	break;      case MODE_NOT_SRC_XOR_DST:	d = *dp ^ ~s;	break;      case MODE_SRC_OR_NOT_DST:	d = ~*dp | s;	break;      case MODE_SRC_AND_NOT_DST:	d = ~*dp & s;	break;      case MODE_SRC_XOR_NOT_DST:	d = ~*dp ^ ~s;	break;      }      mask = 0;      if (x == 0) {	mask |= dest_beg_mask;      }      if (x == dest_n-1) {	mask |= dest_end_mask;      }      *dp = (*dp & mask) | (d & ~mask);    }    src += src_units_per_line;    dest += dest_units_per_line;  }}void patternfill( short dest_x,		 short dest_y, 		 short w,		 short h,		 unsigned char*dest,		 short dest_units_per_line)  {    /* todo: clip */  register char dx;  unsigned short x,y;  unsigned char src_off, dest_off;  short dest_n;  unsigned char dest_beg_mask, dest_end_mask;  const Pattern *pattern = patterns[P_Index];    /* goto line y */  dest += dest_y * dest_units_per_line;    /* goto UNIT-offset x */  dest += dest_x / 8;  /* determine number of affected units per line */    dest_n = (dest_x + w + 8 - 1) / 8 - dest_x / 8;  /* determine PIXEL-offsets */  dest_off = dest_x % 8;    /* make masks to mask out untouchable destination */  dest_beg_mask = ~((unsigned char)(-1) >> dest_off);  dest_end_mask = (unsigned char)(-1) >> ((dest_off + w) % 8);  if (dest_end_mask == (unsigned char)(-1)) {    /* bit stupid */    dest_end_mask = 0;  }    for (y = 0; y < h; y++) {    // process one line    register unsigned char *dp;    register unsigned char mask = 0;    unsigned char s=pattern->data[(dest_y+y)%pattern->height], d;