graphic.c

这是linux下在LCD上显示英文和数字的程序 已经验证是好使的

/*
 * $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 <[e-mail]>
 * Copyright (C) 1999  Till Krech <[e-mail]>
 * Copyright (C) 1998  Kenneth Albanowski <[e-mail]>
 *
 * 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 "hanzi"

#define ScreenHeight 480
#define ScreenWidth 640

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,
};
//unsigned char getbit[8]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01}
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,screen_height;
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);
	//	printf("Color1inline=%d\n",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  fillrectangle(short x1, short y1, short x2, short y2)
{
	short x, y, w, h,i,j;
	//clip_screen(x1, y1, x2-x1, y2-y1, &x, &y, &w, &h); 
	//patternfill(x, y, w, h, screen_ptr, screen_width>>3);
        for(i=x1;i<x2;i++)
	for(j=y1;j<y2;j++)
		{setpixel(i, j, 1);
  			}
}
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);
}


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;