scr_bogl.x

开放源码实时操作系统源码.

/*
 * Copyright (c) 1999 Greg Haerr <[e-mail]>
 *
 * Screen Driver using BOGL Library
 *
 * This driver now requires only the following BOGL entry points:
 * 	bogl_init, bogl_done, 
 * 	bogl_pixel, bogl_readpixel,
 * 	bogl_vline, bogl_hline
 *
 * All graphics drawing primitives are based on top of these functions.
 *
 * This file also contains the generalized low-level font/text
 * drawing routines, which will be split out into another file.
 * Both fixed and proportional fonts are supported, with fixed
 * pitch structure allowing much smaller font files.
 */
#include <stdio.h>
#include "../device.h"
#include "bogl/bogl.h"

/* specific bogl driver entry points*/
static int  BOGL_open(SCREENDEVICE *psd);
static void BOGL_close(void);
static void BOGL_getscreeninfo(PSCREENINFO psi);
static void BOGL_setpalette(int first,int count,RGBENTRY *pal);
static void BOGL_drawpixel(COORD x, COORD y, PIXELVAL c);
static PIXELVAL BOGL_readpixel(COORD x, COORD y);
static void BOGL_drawhline(COORD x1, COORD x2, COORD y, PIXELVAL c);
static void BOGL_drawvline(COORD x, COORD y1, COORD y2, PIXELVAL c);
static void BOGL_fillrect(COORD x1, COORD y1, COORD x2, COORD y2, PIXELVAL c);

/* generalized text/font routines*/
static BOOL gen_getfontinfo(FONTID fontid,PFONTINFO pfontinfo);
static void gen_gettextsize(const UCHAR *str,int cc,COORD *retwd,
		COORD *retht,FONTID fontid);
static void gen_gettextbits(UCHAR ch,IMAGEBITS *retmap,COORD *retwd,
		COORD *retht,FONTID fontid);
/*static void gen_drawtext(COORD x, COORD y, const UCHAR *s, int n,
			PIXELVAL fg, FONTID fontid);
static void gen_drawbitmap(COORD x, COORD y, COORD width, COORD height,
			IMAGEBITS *table, PIXELVAL fgcolor);*/

SCREENDEVICE	scrdev = {
	BOGL_open,
	BOGL_close,
	BOGL_getscreeninfo,
	BOGL_setpalette,
	BOGL_drawpixel,
	BOGL_readpixel,
	BOGL_drawhline,
	BOGL_drawvline,
	BOGL_fillrect,
	gen_getfontinfo,
	gen_gettextsize,
	gen_gettextbits,
	640, 480, 256, PF_PALETTE
};

/* compiled in fonts*/
#define NUMBER_FONTS	3
extern FONT font_rom8x16, font_rom8x8;
extern FONT font_winFreeSansSerif11x13;
extern FONT font_winFreeSystem14x16;
extern FONT font_winSystem14x16;
extern FONT font_winMSSansSerif11x13;
extern FONT font_winTerminal8x12;
extern FONT font_helvB10, font_helvB12, font_helvR10;

/* first font is default font*/
PFONT fonts[NUMBER_FONTS] = {
#if HAVEMSFONTS
	&font_winSystem14x16,		/* FONT_SYSTEM_VAR*/
	&font_winMSSansSerif11x13,	/* FONT_GUI_VAR*/
	&font_winTerminal8x12		/* FONT_OEM_FIXED*/
#else
	&font_winFreeSystem14x16,	/* FONT_SYSTEM_VAR*/
	&font_winFreeSansSerif11x13,	/* FONT_GUI_VAR*/
	&font_rom8x16			/* FONT_OEM_FIXED*/
#endif
};

static int
BOGL_open(SCREENDEVICE *psd)
{
	if(bogl_init() == 0)
		return -1;
	psd->xres = bogl_xres;
	psd->yres = bogl_yres;
	psd->ncolors = bogl_ncols;

	/* set pixel format*/
	if(bogl_ncols > 256)
		psd->pixtype = PF_TRUECOLOR24;
	else if(bogl_ncols == 256 && bogl_truecolor)
		psd->pixtype = PF_TRUECOLOR332;
	else
		psd->pixtype = PF_PALETTE;
	return 1;
}

static void
BOGL_close(void)
{
	bogl_done();
}

static void
BOGL_getscreeninfo(PSCREENINFO psi)
{
	psi->rows = scrdev.yres;
	psi->cols = scrdev.xres;
	psi->ncolors = scrdev.ncolors;
	psi->pixtype = scrdev.pixtype;
	psi->black = 0;
	psi->white = 15;
	psi->fonts = NUMBER_FONTS;

	if(scrdev.yres > 480) {
		/* SVGA 800x600*/
		psi->xdpcm = 33;	/* assumes screen width of 24 cm*/
		psi->ydpcm = 33;	/* assumes screen height of 18 cm*/
	} else if(scrdev.yres > 350) {
		/* VGA 640x480*/
		psi->xdpcm = 27;	/* assumes screen width of 24 cm*/
		psi->ydpcm = 27;	/* assumes screen height of 18 cm*/
	} else {
		/* EGA 640x350*/
		psi->xdpcm = 27;	/* assumes screen width of 24 cm*/
		psi->ydpcm = 19;	/* assumes screen height of 18 cm*/
	}
}

/*
 * Set count palette entries starting from first
 */
static void
BOGL_setpalette(int first,int count,RGBENTRY *pal)
{
	bogl_set_palette(first, count, (void*)pal);
}

static void
BOGL_drawpixel(COORD x, COORD y, PIXELVAL c)
{
	bogl_pixel(x, y, c);
}

static PIXELVAL
BOGL_readpixel(COORD x, COORD y)
{
	return bogl_readpixel(x, y);
}

static void
BOGL_drawhline(COORD x1, COORD x2, COORD y, PIXELVAL c)
{
	/*
	 * bogl uses type 2 line drawing, the last point is not drawn
	 */
	bogl_hline(x1, x2+1, y, c);

	/*
	 * Uncomment the following if driver doesn't support hline
	while(x1 <= x2)
		bogl_pixel(x1++, y, c);
	 */
}

static void
BOGL_drawvline(COORD x, COORD y1, COORD y2, PIXELVAL c)
{
	/*
	 * bogl uses type 2 line drawing, the last point is not drawn
	 */
	bogl_vline(x, y1, y2+1, c);

	/*
	 * Uncomment the following if driver doesn't support vline
	while(y1 <= y2)
		bogl_pixel(x, y1++, c);
	 */
}

static void
BOGL_fillrect(COORD x1, COORD y1, COORD x2, COORD y2, PIXELVAL c)
{
	/*
	 * Call bogl hline (type 2) to save size
	 */
	++x2;		/* fix bogl last point not drawn*/
	while(y1 <= y2)
		bogl_hline(x1, x2, y1++, c);
	/*
	 * Uncomment the following if driver doesn't support fillrect
	while(y1 <= y2)
		BOGL_drawhline(x1, x2, y1++, c);
	 */
}

#if 0000
/* 
 * Generalized low level text draw routine, called only
 * if no clipping is required
 */
static void
gen_drawtext(COORD x,COORD y,const UCHAR *s,int n,PIXELVAL fg,FONTID fontid)
{
	COORD 		width;			/* width of character */
	COORD 		height;			/* height of character */
	PFONT		pf;
	IMAGEBITS 	bitmap[MAX_CHAR_HEIGHT];/* bitmap for character */

	if(fontid >= NUMBER_FONTS)
		return;
	pf = fonts[fontid];

	/* x, y is bottom left corner*/
	y -= pf->height - 1;
	while (n-- > 0) {
		gen_gettextbits(*s++, bitmap, &width, &height, pf);
		gen_drawbitmap(x, y, width, height, bitmap, fg);
		x += width;
	}
}

/*
 * Generalized low level bitmap output routine, called
 * only if no clipping is required.  Only the set bits
 * in the bitmap are drawn, in the foreground color.
 */
static void
gen_drawbitmap(COORD x, COORD y, COORD width, COORD height, IMAGEBITS *table,
	PIXELVAL fgcolor)
{
  COORD minx;
  COORD maxx;
  IMAGEBITS bitvalue;	/* bitmap word value */
  int bitcount;			/* number of bits left in bitmap word */

  minx = x;
  maxx = x + width - 1;
  bitcount = 0;
  while (height > 0) {
	if (bitcount <= 0) {
		bitcount = IMAGE_BITSPERIMAGE;
		bitvalue = *table++;
	}
	if (IMAGE_TESTBIT(bitvalue))
		BOGL_drawpixel(x, y, fgcolor);
	bitvalue = IMAGE_SHIFTBIT(bitvalue);
	--bitcount;
	if (x++ == maxx) {
		x = minx;
		++y;
		--height;
		bitcount = 0;
	}
  }
}
#endif

/*
 * Generalized low level get font info routine.  This
 * routine works with fixed and proportional fonts.
 */
static BOOL
gen_getfontinfo(FONTID fontid,PFONTINFO pfontinfo)
{
	PFONT	pf;
	int	i;

	if(fontid >= NUMBER_FONTS)
		return FALSE;
	pf = fonts[fontid];

	pfontinfo->font = fontid;
	pfontinfo->height = pf->height;
	pfontinfo->maxwidth = pf->maxwidth;
	pfontinfo->baseline = 0;
	pfontinfo->fixed = pf->width == NULL? TRUE: FALSE;
	for(i=0; i<256; ++i) {
		if(pf->width == NULL)
			pfontinfo->widths[i] = pf->maxwidth;
		else {
			if(i<pf->firstchar || i >= pf->firstchar+pf->size)
				pfontinfo->widths[i] = 0;
			else pfontinfo->widths[i] = pf->width[i-pf->firstchar];
		}
	}
	return TRUE;
}

/*
 * Generalized low level routine to calc bounding box for text output.
 * Handles both fixed and proportional fonts.
 */
static void
gen_gettextsize(const UCHAR *str,int cc,COORD *retwd,COORD *retht,
	FONTID fontid)
{
	PFONT	pf;
	int	c;
	int	width;

	if(fontid >= NUMBER_FONTS) {
		*retht = 0;
		*retwd = 0;
		return;
	}
	pf = fonts[fontid];

	if(pf->width == NULL)
		width = cc * pf->maxwidth;
	else {
		width = 0;
		while(--cc >= 0) {
			if( (c = *str++) >= pf->firstchar &&
			     c < pf->firstchar+pf->size)
				width += pf->width[c - pf->firstchar];
		}
	}

	*retwd = width;
	*retht = pf->height;

}

/*
 * Generalized low level routine to get the bitmap associated
 * with a character.  Handles fixed and proportional fonts.
 */
static void
gen_gettextbits(UCHAR ch,IMAGEBITS *retmap,COORD *retwd, COORD *retht,
	FONTID fontid)
{
	int		n;
	PFONT		pf = NULL;
	IMAGEBITS *	bits;

	if(fontid < NUMBER_FONTS)
		pf = fonts[fontid];

	if(!pf || ch < pf->firstchar || ch >= pf->firstchar+pf->size) {
		*retht = 0;
		*retwd = 0;
		return;
	}
	ch -= pf->firstchar;

	/* get font bitmap depending on fixed pitch or not*/
	bits = pf->bits + (pf->offset? pf->offset[ch]: (pf->height * ch));
	for(n=0; n<pf->height; ++n)
		*retmap++ = *bits++;

	/* return width depending on fixed pitch or not*/
	*retwd = pf->width? pf->width[ch]: pf->maxwidth;
	*retht = pf->height;
}

#if 0
static unsigned char palette[16+16][3] = {
  /* Linux 16 color palette*/
  { 0x00,0x00,0x00 },
  { 0x00,0x00,0xaa },
  { 0x00,0xaa,0x00 },
  { 0x00,0xaa,0xaa },
  { 0xaa,0x00,0x00 },
  { 0xaa,0x00,0xaa },
  { 0xaa,0x55,0x00 },	/* adjust to brown*/
  //{ 0xaa,0xaa,0x00 },
  { 0xaa,0xaa,0xaa },
  { 0x55,0x55,0x55 },
  { 0x55,0x55,0xff },
  { 0x55,0xff,0x55 },
  { 0x55,0xff,0xff },
  { 0xff,0x55,0x55 },
  { 0xff,0x55,0xff },
  { 0xff,0xff,0x55 },
  { 0xff,0xff,0xff },

  /* 16 entry std palette*/
  {0x00, 0x00, 0x00},
  {0x00, 0x00, 0xbf},
  {0x00, 0xbf, 0x00},
  {0x00, 0xbf, 0xbf},
  {0xbf, 0x00, 0x00},
  {0xbf, 0x00, 0xbf},
  {0xbf, 0x60, 0x00},	/* adjust to brown*/
  //{0xbf, 0xbf, 0x00},
  {0xc0, 0xc0, 0xc0},
  {0x80, 0x80, 0x80},
  {0x00, 0x00, 0xff},
  {0x00, 0xff, 0x00},
  {0x00, 0xff, 0xff},
  {0xff, 0x00, 0x00},
  {0xff, 0x00, 0xff},
  {0xff, 0xff, 0x00},
  {0xff, 0xff, 0xff},
};
#endif