rbf_font.c-Dateireferenz

#include "camera_info.h"
#include "conf.h"
#include "gui.h"
#include "gui_draw.h"
#include "font.h"

Include-Abhängigkeitsdiagramm für rbf_font.c:

gehe zum Quellcode dieser Datei

Datenstrukturen
struct	font_hdr
struct	_font

Makrodefinitionen
#define	RBF_MAX_NAME   64
#define	UBUFFER_SIZE   256
#define	maxSymbols   128

Typdefinitionen
typedef struct _font	font

Funktionen
font *	new_font ()
void	init_fonts ()
void	alloc_cTable (font *f)
int	code_page_char (int ch)
char *	rbf_font_char (font *f, int ch)
int	font_read (int fd, unsigned char *dest, int len)
int	rbf_font_load (char *file, font *f, int maxchar)
int	rbf_load_symbol (char *file)
void	rbf_load_from_file (char *file, int codepage)
void	rbf_set_codepage (int codepage)
int	rbf_font_height ()
int	rbf_symbol_height ()
int	rbf_char_width (int ch)
int	rbf_symbol_width (int ch)
int	rbf_str_width (const char *str)
int	rbf_str_clipped_width (const char *str, int l, int maxlen)
void	font_draw_char (int x, int y, char *cdata, int width, int height, int pixel_width, twoColors cl)
int	rbf_draw_char (int x, int y, int ch, twoColors cl)
int	rbf_draw_symbol (int x, int y, int ch, twoColors cl)
int	rbf_draw_string_c (int x, int y, const char *str, twoColors c1, int c, twoColors c2)
int	rbf_draw_string (int x, int y, const char *str, twoColors cl)
void	rbf_enable_cursor (int s, int e)
void	rbf_disable_cursor ()
int	rbf_draw_clipped_string (int x, int y, const char *str, twoColors cl, int l, int maxlen)
int	rbf_draw_string_len (int x, int y, int len, const char *str, twoColors cl)
int	rbf_draw_string_right_len (int x, int y, int len, const char *str, twoColors cl)
int	rbf_draw_menu_header (int x, int y, int len, char symbol, const char *str, twoColors cl)

Variablen
static int	RBF_HDR_MAGIC1 = 0x0DF00EE0
static int	RBF_HDR_MAGIC2 = 0x00000003
static unsigned char *	ubuffer = 0
static font *	rbf_symbol_font = 0
static font *	rbf_font = 0
static int	rbf_codepage = FONT_CP_WIN
static const char	tbl_dos2win []
static int	cursor_on = 0
static int	cursor_start = 0
static int	cursor_end = 0

Makro-Dokumentation

#define maxSymbols   128

Definiert in Zeile 232 der Datei rbf_font.c.

#define RBF_MAX_NAME   64

Definiert in Zeile 8 der Datei rbf_font.c.

#define UBUFFER_SIZE   256

Definiert in Zeile 9 der Datei rbf_font.c.

Dokumentation der benutzerdefinierten Typen

typedef struct _font font

Dokumentation der Funktionen

void alloc_cTable

(

font *

f)

Definiert in Zeile 84 der Datei rbf_font.c.

                           {

    // Calculate additional values for font
    if (f->usingFont8x16) {
        f->width = FONT_WIDTH;
    }
    else {
        f->width = 8 * f->hdr.charSize / f->hdr.height;
    }
    f->charCount = f->hdr.charLast - f->hdr.charFirst + 1;

    // set width table to default value
    memset(f->wTable, f->width, 256);
    
    // allocate cTable memory

    // If existing data has been allocated then we are re-using the font data
    // See if it the existing cTable data is large enough to hold the new font data
    // If not free it so new memory will be allocated
    if ((f->cTable != 0) && (f->cTableSizeMax < (f->charCount*f->hdr.charSize))) {
        free(f->cTable);              // free the memory
        f->cTable = 0;                // clear pointer so new memory is allocated
        f->cTableSizeMax = 0;
    }

    // Allocated memory if needed
    if (f->cTable == 0 && !f->usingFont8x16) {
        // Allocate memory from cached pool
        f->cTable = malloc(f->charCount*f->hdr.charSize);

        // save size
        f->cTableSize = f->charCount*f->hdr.charSize;
        if (f->cTableSizeMax == 0) f->cTableSizeMax = f->cTableSize;    // Save actual size allocated
    }
}

int code_page_char

(

int

ch)

Definiert in Zeile 132 der Datei rbf_font.c.

{
    // convert character value based on selected code page
    if ((rbf_codepage == FONT_CP_DOS) && (ch >= 128) && (ch < 256)) {
        // Convert DOS to WIN char
        ch = tbl_dos2win[ch-128];
    }
    return ch;
}

void font_draw_char	(	int	x,
		int	y,
		char *	cdata,
		int	width,
		int	height,
		int	pixel_width,
		twoColors	cl
	)

Definiert in Zeile 311 der Datei rbf_font.c.

                                                                                                     {
    int xx, yy;

    // draw pixels for font character
    if (cdata)
        for (yy=0; yy<height; ++yy)
            for (xx=0; xx<pixel_width; ++xx)
                draw_pixel(x+xx ,y+yy, (cdata[yy*width/8+xx/8] & (1<<(xx%8))) ? FG_COLOR(cl) : BG_COLOR(cl));
}

int font_read	(	int	fd,
		unsigned char *	dest,
		int	len
	)

Definiert in Zeile 156 der Datei rbf_font.c.

{
    // Return actual bytes read
    int bytes_read = 0;

    if (ubuffer)
    {
        // Read file in UBUFFER_SIZE blocks
        while (len)
        {
            // Calc size of next block to read = min(UBUFFER_SIZE, len)
            int to_read = UBUFFER_SIZE;
            if (to_read > len) to_read = len;

            // Read block and copy to dest
            bytes_read += read(fd, ubuffer, to_read);
            memcpy(dest, ubuffer, to_read);

            // Increment dest pointer, decrement len left to read
            dest += to_read;
            len -= to_read;
        }
    }

    return bytes_read;
}

void init_fonts

(

)

Definiert in Zeile 74 der Datei rbf_font.c.

{
    // Allocate base font memory if needed
    if (rbf_font == 0) rbf_font = new_font();
    if (rbf_symbol_font == 0) rbf_symbol_font = new_font();

    // allocate uncached memory buffer for reading
    ubuffer = umalloc(UBUFFER_SIZE);
}

font* new_font

(

)

Definiert in Zeile 61 der Datei rbf_font.c.

                 {
    // allocate font from cached memory
    font *f = malloc(sizeof(font));
    if (f) {
        memset(f,0,sizeof(font));      // wipe memory
        // return address in cached memory
        return f;
    }

    // memory not allocated ! should probably do something else in this case ?
    return 0;
}

int rbf_char_width

(

int

ch)

Definiert in Zeile 282 der Datei rbf_font.c.

                           {
    return rbf_font->wTable[code_page_char(ch)];
}

void rbf_disable_cursor

(

)

Definiert in Zeile 403 der Datei rbf_font.c.

{
    cursor_on = 0;
}

int rbf_draw_char	(	int	x,
		int	y,
		int	ch,
		twoColors	cl
	)

Definiert in Zeile 322 der Datei rbf_font.c.

                                                      {
    // Convert char for code page
    ch = code_page_char(ch);

    // Get char data pointer
    char* cdata = rbf_font_char(rbf_font, ch);

    // Draw font character (either loaded font, or from default font)
    if (rbf_font->usingFont8x16 || !cdata)
        draw_char(x,y,ch,cl);
    else
        font_draw_char(x, y, cdata, rbf_font->width, rbf_font->hdr.height, rbf_font->wTable[ch], cl);

    return rbf_font->wTable[ch];
}

int rbf_draw_clipped_string	(	int	x,
		int	y,
		const char *	str,
		twoColors	cl,
		int	l,
		int	maxlen
	)

Definiert in Zeile 408 der Datei rbf_font.c.

{
    int i = 0;
    twoColors inv_cl = MAKE_COLOR(FG_COLOR(cl), BG_COLOR(cl));

    // Draw chars from string up to max pixel length
    while (*str && l+rbf_char_width(*str)<=maxlen)
    {
        if (cursor_on && (cursor_start <= i) && (i <= cursor_end))
            l+=rbf_draw_char(x+l, y, *str++, inv_cl);
        else
            l+=rbf_draw_char(x+l, y, *str++, cl);
        i++;
    }

    return l;
}

int rbf_draw_menu_header	(	int	x,
		int	y,
		int	len,
		char	symbol,
		const char *	str,
		twoColors	cl
	)

Definiert in Zeile 454 der Datei rbf_font.c.

                                                                                            { 
    int l=0, i, ll, lr;

    // If symbol to be added to string determing the width of the symbol + space
    if (symbol!=0x0 && conf.menu_symbol_enable && rbf_font_height()>=rbf_symbol_height()) {
        l += rbf_symbol_width(symbol);
        l += rbf_char_width(' ');
    }

    // Add the length of the string (possibly clipped to fit)
    l = rbf_str_clipped_width(str, l, len);

    // Calculate padding required on left and right side
    ll = 8;
    lr = len-l-ll; 

    int right = x+len-1, bottom = y+rbf_font_height()-1;

    // Fill left & right sides of string area with a rectangle that has rounded top corners
    for (i=0; i<=l && i<3; i++) {
        if (i < 2) {
            // First and second columns make rounded top corners
            draw_line(x+i,     y+2-i, x+i,     bottom, BG_COLOR(cl));        // left side
            draw_line(right-i, y+2-i, right-i, bottom, BG_COLOR(cl));        // right side
        }
        else {
            // Rest of empty space is just filled with rectangles
            draw_rectangle(x+i,      y, x+ll-1,   bottom, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);    // left side
            draw_rectangle(right-lr, y, right-i,  bottom, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);    // right side
        }
    }

    // Draw symbol and space if required
    if (symbol!=0x0 && conf.menu_symbol_enable && rbf_font_height()>=rbf_symbol_height()) {
      ll += rbf_draw_symbol(x+ll, y, symbol, cl);
      ll += rbf_draw_char(x+ll, y, ' ', cl);
    }

    // Draw chars
    ll = rbf_draw_clipped_string(x, y, str, cl, ll, len);

    return ll;
} 

int rbf_draw_string	(	int	x,
		int	y,
		const char *	str,
		twoColors	cl
	)

Definiert in Zeile 387 der Datei rbf_font.c.

                                                                 {
    return rbf_draw_string_c(x, y, str, cl, -1, MAKE_COLOR(0,0));
}

int rbf_draw_string_c	(	int	x,
		int	y,
		const char *	str,
		twoColors	c1,
		int	c,
		twoColors	c2
	)

Definiert in Zeile 376 der Datei rbf_font.c.

                                                                                        {
     int l=0, i=0;

     while (*str) {
          l+=rbf_draw_char(x+l, y, *str++, (i==c)?c2:c1);
          ++i;
     }
     return l;
}

int rbf_draw_string_len	(	int	x,
		int	y,
		int	len,
		const char *	str,
		twoColors	cl
	)

Definiert in Zeile 427 der Datei rbf_font.c.

                                                                              {
    // Draw string characters
    int l = rbf_draw_clipped_string(x, y, str, cl, 0, len);

    // Fill any remaining space on right with background color
    if (l < len)
        draw_rectangle(x+l, y, x+len-1, y+rbf_font->hdr.height-1, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);

    return len;
}

int rbf_draw_string_right_len	(	int	x,
		int	y,
		int	len,
		const char *	str,
		twoColors	cl
	)

Definiert in Zeile 439 der Datei rbf_font.c.

                                                                                    {
    // Calulate amount of padding needed on the left
    int l = len - rbf_str_clipped_width(str, 0, len);

    // Fill padding with background color
    if (l > 0)
        draw_rectangle(x, y, x+l-1, y+rbf_font->hdr.height-1, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);

    // Draw chars
    l = rbf_draw_clipped_string(x, y, str, cl, l, len);

    return l;
}

int rbf_draw_symbol	(	int	x,
		int	y,
		int	ch,
		twoColors	cl
	)

Definiert in Zeile 339 der Datei rbf_font.c.

                                                        {
    int space=0, pixel_width, sym_height, txt_height;

    // Skip if symbol font height taller than text font height (or invalid char value)
    if (rbf_font->hdr.height<rbf_symbol_font->hdr.height || ch==0x0) return 0;

    // get width of symbol in pixels
    pixel_width = rbf_symbol_width(ch);
    // get height of symbol font
    sym_height = rbf_symbol_font->hdr.height;
    // get height of text font
    txt_height = rbf_font->hdr.height;

    // Get char data pointer
    char* cdata = rbf_font_char(rbf_symbol_font, ch);

    if (cdata) {
      // if symbol font shorter than text font center symbol vertically and fill empty space above
      if (txt_height > sym_height) {
        space = (txt_height - sym_height)/2;
        draw_rectangle(x, y, x+pixel_width, y+space, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);
        y+=space;
      }

      // Draw font character
      font_draw_char(x, y, cdata, rbf_symbol_font->width, sym_height, pixel_width, cl);

      // Fill space below symbol if shorter than text font
      if (txt_height > sym_height)
          draw_rectangle(x, y+sym_height, x+pixel_width, y-space+txt_height-1, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);
    }

    return pixel_width;
}

void rbf_enable_cursor	(	int	s,
		int	e
	)

Definiert in Zeile 396 der Datei rbf_font.c.

{
    cursor_on = 1;
    cursor_start = s;
    cursor_end = e;
}

char* rbf_font_char	(	font *	f,
		int	ch
	)

Definiert in Zeile 144 der Datei rbf_font.c.

{
    if (f && (ch >= f->hdr.charFirst) && (ch <= f->hdr.charLast))
    {
        return &f->cTable[(ch-f->hdr.charFirst)*f->hdr.charSize];
    }

    return 0;
}

int rbf_font_height

(

)

Definiert in Zeile 273 der Datei rbf_font.c.

                      {
    return rbf_font->hdr.height;
}

int rbf_font_load	(	char *	file,
		font *	f,
		int	maxchar
	)

Definiert in Zeile 184 der Datei rbf_font.c.

{
    int i;
    int rv = 0; // return value

    // make sure the font has been allocated, and a valid filename is given
    if ((f == 0) || (*file == 0)) return 0;

    // turn of default font if it was being used
    f->usingFont8x16 = 0;

    // open file (can't use fopen here due to potential conflict FsIoNotify crash)
    int fd = open(file, O_RDONLY, 0777);
    if (fd >= 0) {
        // read header
        i = font_read(fd, (unsigned char*)&f->hdr, sizeof(font_hdr));

        // check size read is correct and magic numbers are valid
        if ((i == sizeof(font_hdr)) && (f->hdr.magic1 == RBF_HDR_MAGIC1) && (f->hdr.magic2 == RBF_HDR_MAGIC2)) {

            if (maxchar != 0) {
                f->hdr.charLast = maxchar;
            }

            alloc_cTable(f);

            // read width table (using uncached buffer)
            lseek(fd, f->hdr._wmapAddr, SEEK_SET);
            font_read(fd, (unsigned char*)&f->wTable[f->hdr.charFirst], f->charCount);

            // read cTable data (using uncached buffer)
            lseek(fd, f->hdr._cmapAddr, SEEK_SET);
            font_read(fd, (unsigned char*)f->cTable, f->charCount*f->hdr.charSize);

            // Reset symbol display if symbol font too tall
            if (conf.menu_symbol_enable && rbf_font && rbf_symbol_font)
                conf.menu_symbol_enable=(rbf_font->hdr.height>=rbf_symbol_font->hdr.height);

            rv = 1;
        }

        close(fd);
    }

    return rv;
}

void rbf_load_from_file	(	char *	file,
		int	codepage
	)

Definiert in Zeile 242 der Datei rbf_font.c.

{
    // Allocate font if needed
    init_fonts();
    // Load font, load default on failure
    if (!rbf_font_load(file, rbf_font, 0))
    {
        // Reset back to built in font, file load failed
        rbf_font->hdr.charSize  = FONT_HEIGHT;
        rbf_font->hdr.height    = FONT_HEIGHT;
        rbf_font->hdr.maxWidth  = FONT_WIDTH;
        rbf_font->hdr.charFirst = 0;
        rbf_font->hdr.charLast  = 255;

        // This is only ever called to copy the 'current_font' data into the rbf_font
        // Instead of doing this set the rbf_font flag so we call 'draw_char' directly (which uses current_font)
        // This avoids allocating memory for a copy of something we already have
        rbf_font->usingFont8x16 = 1;

        alloc_cTable(rbf_font);
    }
    // Set codepage
    rbf_set_codepage(codepage);
}

int rbf_load_symbol

(

char *

file)

Definiert in Zeile 233 der Datei rbf_font.c.

                                {
    // Allocate font if needed
    init_fonts();
    // Load font
    return rbf_font_load(file, rbf_symbol_font, maxSymbols+32);
}

void rbf_set_codepage

(

int

codepage)

Definiert in Zeile 268 der Datei rbf_font.c.

                                    {
    rbf_codepage = codepage;
}

int rbf_str_clipped_width	(	const char *	str,
		int	l,
		int	maxlen
	)

Definiert in Zeile 302 der Datei rbf_font.c.

                                                              {
    // Calculate how long the string is in pixels (possibly clipped to 'maxlen')
    while (*str && l+rbf_char_width(*str)<=maxlen)
        l+=rbf_char_width(*str++);

    return l;
}

int rbf_str_width

(

const char *

str)

Definiert in Zeile 292 der Datei rbf_font.c.

                                   {
    int l=0;

    // Calculate how long the string is in pixels
    while (*str)
        l+=rbf_char_width(*str++);

    return l;
}

int rbf_symbol_height

(

)

Definiert in Zeile 277 der Datei rbf_font.c.

                        {
    return rbf_symbol_font->hdr.height;
}

int rbf_symbol_width

(

int

ch)

Definiert in Zeile 287 der Datei rbf_font.c.

                             {
    return rbf_symbol_font->wTable[ch];
}

Variablen-Dokumentation

int cursor_end = 0

static

Definiert in Zeile 394 der Datei rbf_font.c.

int cursor_on = 0

static

Definiert in Zeile 392 der Datei rbf_font.c.

int cursor_start = 0

static

Definiert in Zeile 393 der Datei rbf_font.c.

int rbf_codepage = FONT_CP_WIN

static

Definiert in Zeile 57 der Datei rbf_font.c.

font * rbf_font = 0

static

Definiert in Zeile 56 der Datei rbf_font.c.

int RBF_HDR_MAGIC1 = 0x0DF00EE0

static

Definiert in Zeile 11 der Datei rbf_font.c.

int RBF_HDR_MAGIC2 = 0x00000003

static

Definiert in Zeile 12 der Datei rbf_font.c.

font* rbf_symbol_font = 0

static

Definiert in Zeile 56 der Datei rbf_font.c.

const char tbl_dos2win[]

static

Initialisierung:

= {
    0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
    0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
    0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
    0x2D, 0x2D, 0x2D, 0xA6, 0x2B, 0xA6, 0xA6, 0xAC, 0xAC, 0xA6, 0xA6, 0xAC, 0x2D, 0x2D, 0x2D, 0xAC,
    0x4C, 0x2B, 0x54, 0x2B, 0x2D, 0x2B, 0xA6, 0xA6, 0x4C, 0xE3, 0xA6, 0x54, 0xA6, 0x3D, 0x2B, 0xA6,
    0xA6, 0x54, 0x54, 0x4C, 0x4C, 0x2D, 0xE3, 0x2B, 0x2B, 0x2D, 0x2D, 0x2D, 0x2D, 0xA6, 0xA6, 0x2D,
    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
    0xA8, 0xB8, 0xAA, 0xBA, 0xAF, 0xBF, 0xA1, 0xA2, 0xB0, 0x95, 0xB7, 0x76, 0xB9, 0xA4, 0xA6, 0xA0
}

Definiert in Zeile 121 der Datei rbf_font.c.

unsigned char* ubuffer = 0

static

Definiert in Zeile 55 der Datei rbf_font.c.