graphic.c

GUI例程

/*
 * $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 "/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)  
{