URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [drivers/] [scr_bogl.x] - Blame information for rev 365

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * Copyright (c) 1999 Greg Haerr 
 *
 * 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 
#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(ifirstchar || 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; nheight; ++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

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [drivers/] [scr_bogl.x] - Blame information for rev 365

Line No.	Rev	Author	Line
1	27	unneback	`/*`
2			`* Copyright (c) 1999 Greg Haerr`
3			`*`
4			`* Screen Driver using BOGL Library`
5			`*`
6			`* This driver now requires only the following BOGL entry points:`
7			`* bogl_init, bogl_done,`
8			`* bogl_pixel, bogl_readpixel,`
9			`* bogl_vline, bogl_hline`
10			`*`
11			`* All graphics drawing primitives are based on top of these functions.`
12			`*`
13			`* This file also contains the generalized low-level font/text`
14			`* drawing routines, which will be split out into another file.`
15			`* Both fixed and proportional fonts are supported, with fixed`
16			`* pitch structure allowing much smaller font files.`
17			`*/`
18			`#include`
19			`#include "../device.h"`
20			`#include "bogl/bogl.h"`
21
22			`/* specific bogl driver entry points*/`
23			`static int BOGL_open(SCREENDEVICE *psd);`
24			`static void BOGL_close(void);`
25			`static void BOGL_getscreeninfo(PSCREENINFO psi);`
26			`static void BOGL_setpalette(int first,int count,RGBENTRY *pal);`
27			`static void BOGL_drawpixel(COORD x, COORD y, PIXELVAL c);`
28			`static PIXELVAL BOGL_readpixel(COORD x, COORD y);`
29			`static void BOGL_drawhline(COORD x1, COORD x2, COORD y, PIXELVAL c);`
30			`static void BOGL_drawvline(COORD x, COORD y1, COORD y2, PIXELVAL c);`
31			`static void BOGL_fillrect(COORD x1, COORD y1, COORD x2, COORD y2, PIXELVAL c);`
32
33			`/* generalized text/font routines*/`
34			`static BOOL gen_getfontinfo(FONTID fontid,PFONTINFO pfontinfo);`
35			`static void gen_gettextsize(const UCHAR str,int cc,COORD retwd,`
36			`COORD *retht,FONTID fontid);`
37			`static void gen_gettextbits(UCHAR ch,IMAGEBITS retmap,COORD retwd,`
38			`COORD *retht,FONTID fontid);`
39			`/static void gen_drawtext(COORD x, COORD y, const UCHAR s, int n,`
40			`PIXELVAL fg, FONTID fontid);`
41			`static void gen_drawbitmap(COORD x, COORD y, COORD width, COORD height,`
42			`IMAGEBITS table, PIXELVAL fgcolor);/`
43
44			`SCREENDEVICE scrdev = {`
45			`BOGL_open,`
46			`BOGL_close,`
47			`BOGL_getscreeninfo,`
48			`BOGL_setpalette,`
49			`BOGL_drawpixel,`
50			`BOGL_readpixel,`
51			`BOGL_drawhline,`
52			`BOGL_drawvline,`
53			`BOGL_fillrect,`
54			`gen_getfontinfo,`
55			`gen_gettextsize,`
56			`gen_gettextbits,`
57			`640, 480, 256, PF_PALETTE`
58			`};`
59
60			`/* compiled in fonts*/`
61			`#define NUMBER_FONTS 3`
62			`extern FONT font_rom8x16, font_rom8x8;`
63			`extern FONT font_winFreeSansSerif11x13;`
64			`extern FONT font_winFreeSystem14x16;`
65			`extern FONT font_winSystem14x16;`
66			`extern FONT font_winMSSansSerif11x13;`
67			`extern FONT font_winTerminal8x12;`
68			`extern FONT font_helvB10, font_helvB12, font_helvR10;`
69
70			`/* first font is default font*/`
71			`PFONT fonts[NUMBER_FONTS] = {`
72			`#if HAVEMSFONTS`
73			`&font_winSystem14x16, /* FONT_SYSTEM_VAR*/`
74			`&font_winMSSansSerif11x13, /* FONT_GUI_VAR*/`
75			`&font_winTerminal8x12 /* FONT_OEM_FIXED*/`
76			`#else`
77			`&font_winFreeSystem14x16, /* FONT_SYSTEM_VAR*/`
78			`&font_winFreeSansSerif11x13, /* FONT_GUI_VAR*/`
79			`&font_rom8x16 /* FONT_OEM_FIXED*/`
80			`#endif`
81			`};`
82
83			`static int`
84			`BOGL_open(SCREENDEVICE *psd)`
85			`{`
86			`if(bogl_init() == 0)`
87			`return -1;`
88			`psd->xres = bogl_xres;`
89			`psd->yres = bogl_yres;`
90			`psd->ncolors = bogl_ncols;`
91
92			`/* set pixel format*/`
93			`if(bogl_ncols > 256)`
94			`psd->pixtype = PF_TRUECOLOR24;`
95			`else if(bogl_ncols == 256 && bogl_truecolor)`
96			`psd->pixtype = PF_TRUECOLOR332;`
97			`else`
98			`psd->pixtype = PF_PALETTE;`
99			`return 1;`
100			`}`
101
102			`static void`
103			`BOGL_close(void)`
104			`{`
105			`bogl_done();`
106			`}`
107
108			`static void`
109			`BOGL_getscreeninfo(PSCREENINFO psi)`
110			`{`
111			`psi->rows = scrdev.yres;`
112			`psi->cols = scrdev.xres;`
113			`psi->ncolors = scrdev.ncolors;`
114			`psi->pixtype = scrdev.pixtype;`
115			`psi->black = 0;`
116			`psi->white = 15;`
117			`psi->fonts = NUMBER_FONTS;`
118
119			`if(scrdev.yres > 480) {`
120			`/* SVGA 800x600*/`
121			`psi->xdpcm = 33; /* assumes screen width of 24 cm*/`
122			`psi->ydpcm = 33; /* assumes screen height of 18 cm*/`
123			`} else if(scrdev.yres > 350) {`
124			`/* VGA 640x480*/`
125			`psi->xdpcm = 27; /* assumes screen width of 24 cm*/`
126			`psi->ydpcm = 27; /* assumes screen height of 18 cm*/`
127			`} else {`
128			`/* EGA 640x350*/`
129			`psi->xdpcm = 27; /* assumes screen width of 24 cm*/`
130			`psi->ydpcm = 19; /* assumes screen height of 18 cm*/`
131			`}`
132			`}`
133
134			`/*`
135			`* Set count palette entries starting from first`
136			`*/`
137			`static void`
138			`BOGL_setpalette(int first,int count,RGBENTRY *pal)`
139			`{`
140			`bogl_set_palette(first, count, (void*)pal);`
141			`}`
142
143			`static void`
144			`BOGL_drawpixel(COORD x, COORD y, PIXELVAL c)`
145			`{`
146			`bogl_pixel(x, y, c);`
147			`}`
148
149			`static PIXELVAL`
150			`BOGL_readpixel(COORD x, COORD y)`
151			`{`
152			`return bogl_readpixel(x, y);`
153			`}`
154
155			`static void`
156			`BOGL_drawhline(COORD x1, COORD x2, COORD y, PIXELVAL c)`
157			`{`
158			`/*`
159			`* bogl uses type 2 line drawing, the last point is not drawn`
160			`*/`
161			`bogl_hline(x1, x2+1, y, c);`
162
163			`/*`
164			`* Uncomment the following if driver doesn't support hline`
165			`while(x1 <= x2)`
166			`bogl_pixel(x1++, y, c);`
167			`*/`
168			`}`
169
170			`static void`
171			`BOGL_drawvline(COORD x, COORD y1, COORD y2, PIXELVAL c)`
172			`{`
173			`/*`
174			`* bogl uses type 2 line drawing, the last point is not drawn`
175			`*/`
176			`bogl_vline(x, y1, y2+1, c);`
177
178			`/*`
179			`* Uncomment the following if driver doesn't support vline`
180			`while(y1 <= y2)`
181			`bogl_pixel(x, y1++, c);`
182			`*/`
183			`}`
184
185			`static void`
186			`BOGL_fillrect(COORD x1, COORD y1, COORD x2, COORD y2, PIXELVAL c)`
187			`{`
188			`/*`
189			`* Call bogl hline (type 2) to save size`
190			`*/`
191			`++x2; /* fix bogl last point not drawn*/`
192			`while(y1 <= y2)`
193			`bogl_hline(x1, x2, y1++, c);`
194			`/*`
195			`* Uncomment the following if driver doesn't support fillrect`
196			`while(y1 <= y2)`
197			`BOGL_drawhline(x1, x2, y1++, c);`
198			`*/`
199			`}`
200
201			`#if 0000`
202			`/*`
203			`* Generalized low level text draw routine, called only`
204			`* if no clipping is required`
205			`*/`
206			`static void`
207			`gen_drawtext(COORD x,COORD y,const UCHAR *s,int n,PIXELVAL fg,FONTID fontid)`
208			`{`
209			`COORD width; /* width of character */`
210			`COORD height; /* height of character */`
211			`PFONT pf;`
212			`IMAGEBITS bitmap[MAX_CHAR_HEIGHT];/* bitmap for character */`
213
214			`if(fontid >= NUMBER_FONTS)`
215			`return;`
216			`pf = fonts[fontid];`
217
218			`/* x, y is bottom left corner*/`
219			`y -= pf->height - 1;`
220			`while (n-- > 0) {`
221			`gen_gettextbits(*s++, bitmap, &width, &height, pf);`
222			`gen_drawbitmap(x, y, width, height, bitmap, fg);`
223			`x += width;`
224			`}`
225			`}`
226
227			`/*`
228			`* Generalized low level bitmap output routine, called`
229			`* only if no clipping is required. Only the set bits`
230			`* in the bitmap are drawn, in the foreground color.`
231			`*/`
232			`static void`
233			`gen_drawbitmap(COORD x, COORD y, COORD width, COORD height, IMAGEBITS *table,`
234			`PIXELVAL fgcolor)`
235			`{`
236			`COORD minx;`
237			`COORD maxx;`
238			`IMAGEBITS bitvalue; /* bitmap word value */`
239			`int bitcount; /* number of bits left in bitmap word */`
240
241			`minx = x;`
242			`maxx = x + width - 1;`
243			`bitcount = 0;`
244			`while (height > 0) {`
245			`if (bitcount <= 0) {`
246			`bitcount = IMAGE_BITSPERIMAGE;`
247			`bitvalue = *table++;`
248			`}`
249			`if (IMAGE_TESTBIT(bitvalue))`
250			`BOGL_drawpixel(x, y, fgcolor);`
251			`bitvalue = IMAGE_SHIFTBIT(bitvalue);`
252			`--bitcount;`
253			`if (x++ == maxx) {`
254			`x = minx;`
255			`++y;`
256			`--height;`
257			`bitcount = 0;`
258			`}`
259			`}`
260			`}`
261			`#endif`
262
263			`/*`
264			`* Generalized low level get font info routine. This`
265			`* routine works with fixed and proportional fonts.`
266			`*/`
267			`static BOOL`
268			`gen_getfontinfo(FONTID fontid,PFONTINFO pfontinfo)`
269			`{`
270			`PFONT pf;`
271			`int i;`
272
273			`if(fontid >= NUMBER_FONTS)`
274			`return FALSE;`
275			`pf = fonts[fontid];`
276
277			`pfontinfo->font = fontid;`
278			`pfontinfo->height = pf->height;`
279			`pfontinfo->maxwidth = pf->maxwidth;`
280			`pfontinfo->baseline = 0;`
281			`pfontinfo->fixed = pf->width == NULL? TRUE: FALSE;`
282			`for(i=0; i<256; ++i) {`
283			`if(pf->width == NULL)`
284			`pfontinfo->widths[i] = pf->maxwidth;`
285			`else {`
286			`if(ifirstchar \|\| i >= pf->firstchar+pf->size)`
287			`pfontinfo->widths[i] = 0;`
288			`else pfontinfo->widths[i] = pf->width[i-pf->firstchar];`
289			`}`
290			`}`
291			`return TRUE;`
292			`}`
293
294			`/*`
295			`* Generalized low level routine to calc bounding box for text output.`
296			`* Handles both fixed and proportional fonts.`
297			`*/`
298			`static void`
299			`gen_gettextsize(const UCHAR str,int cc,COORD retwd,COORD *retht,`
300			`FONTID fontid)`
301			`{`
302			`PFONT pf;`
303			`int c;`
304			`int width;`
305
306			`if(fontid >= NUMBER_FONTS) {`
307			`*retht = 0;`
308			`*retwd = 0;`
309			`return;`
310			`}`
311			`pf = fonts[fontid];`
312
313			`if(pf->width == NULL)`
314			`width = cc * pf->maxwidth;`
315			`else {`
316			`width = 0;`
317			`while(--cc >= 0) {`
318			`if( (c = *str++) >= pf->firstchar &&`
319			`c < pf->firstchar+pf->size)`
320			`width += pf->width[c - pf->firstchar];`
321			`}`
322			`}`
323
324			`*retwd = width;`
325			`*retht = pf->height;`
326
327			`}`
328
329			`/*`
330			`* Generalized low level routine to get the bitmap associated`
331			`* with a character. Handles fixed and proportional fonts.`
332			`*/`
333			`static void`
334			`gen_gettextbits(UCHAR ch,IMAGEBITS retmap,COORD retwd, COORD *retht,`
335			`FONTID fontid)`
336			`{`
337			`int n;`
338			`PFONT pf = NULL;`
339			`IMAGEBITS * bits;`
340
341			`if(fontid < NUMBER_FONTS)`
342			`pf = fonts[fontid];`
343
344			`if(!pf \|\| ch < pf->firstchar \|\| ch >= pf->firstchar+pf->size) {`
345			`*retht = 0;`
346			`*retwd = 0;`
347			`return;`
348			`}`
349			`ch -= pf->firstchar;`
350
351			`/* get font bitmap depending on fixed pitch or not*/`
352			`bits = pf->bits + (pf->offset? pf->offset[ch]: (pf->height * ch));`
353			`for(n=0; nheight; ++n)`
354			`retmap++ = bits++;`
355
356			`/* return width depending on fixed pitch or not*/`
357			`*retwd = pf->width? pf->width[ch]: pf->maxwidth;`
358			`*retht = pf->height;`
359			`}`
360
361			`#if 0`
362			`static unsigned char palette[16+16][3] = {`
363			`/* Linux 16 color palette*/`
364			`{ 0x00,0x00,0x00 },`
365			`{ 0x00,0x00,0xaa },`
366			`{ 0x00,0xaa,0x00 },`
367			`{ 0x00,0xaa,0xaa },`
368			`{ 0xaa,0x00,0x00 },`
369			`{ 0xaa,0x00,0xaa },`
370			`{ 0xaa,0x55,0x00 }, /* adjust to brown*/`
371			`//{ 0xaa,0xaa,0x00 },`
372			`{ 0xaa,0xaa,0xaa },`
373			`{ 0x55,0x55,0x55 },`
374			`{ 0x55,0x55,0xff },`
375			`{ 0x55,0xff,0x55 },`
376			`{ 0x55,0xff,0xff },`
377			`{ 0xff,0x55,0x55 },`
378			`{ 0xff,0x55,0xff },`
379			`{ 0xff,0xff,0x55 },`
380			`{ 0xff,0xff,0xff },`
381
382			`/* 16 entry std palette*/`
383			`{0x00, 0x00, 0x00},`
384			`{0x00, 0x00, 0xbf},`
385			`{0x00, 0xbf, 0x00},`
386			`{0x00, 0xbf, 0xbf},`
387			`{0xbf, 0x00, 0x00},`
388			`{0xbf, 0x00, 0xbf},`
389			`{0xbf, 0x60, 0x00}, /* adjust to brown*/`
390			`//{0xbf, 0xbf, 0x00},`
391			`{0xc0, 0xc0, 0xc0},`
392			`{0x80, 0x80, 0x80},`
393			`{0x00, 0x00, 0xff},`
394			`{0x00, 0xff, 0x00},`
395			`{0x00, 0xff, 0xff},`
396			`{0xff, 0x00, 0x00},`
397			`{0xff, 0x00, 0xff},`
398			`{0xff, 0xff, 0x00},`
399			`{0xff, 0xff, 0xff},`
400			`};`
401			`#endif`