CHDK_DE Vorschauversion  Trunk Rev. 5779
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
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

fontnew_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 fontrbf_symbol_font = 0
 
static fontrbf_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.

84  {
85 
86  // Calculate additional values for font
87  if (f->usingFont8x16) {
88  f->width = FONT_WIDTH;
89  }
90  else {
91  f->width = 8 * f->hdr.charSize / f->hdr.height;
92  }
93  f->charCount = f->hdr.charLast - f->hdr.charFirst + 1;
94 
95  // set width table to default value
96  memset(f->wTable, f->width, 256);
97 
98  // allocate cTable memory
99 
100  // If existing data has been allocated then we are re-using the font data
101  // See if it the existing cTable data is large enough to hold the new font data
102  // If not free it so new memory will be allocated
103  if ((f->cTable != 0) && (f->cTableSizeMax < (f->charCount*f->hdr.charSize))) {
104  free(f->cTable); // free the memory
105  f->cTable = 0; // clear pointer so new memory is allocated
106  f->cTableSizeMax = 0;
107  }
108 
109  // Allocated memory if needed
110  if (f->cTable == 0 && !f->usingFont8x16) {
111  // Allocate memory from cached pool
112  f->cTable = malloc(f->charCount*f->hdr.charSize);
113 
114  // save size
115  f->cTableSize = f->charCount*f->hdr.charSize;
116  if (f->cTableSizeMax == 0) f->cTableSizeMax = f->cTableSize; // Save actual size allocated
117  }
118 }
int code_page_char ( int  ch)

Definiert in Zeile 132 der Datei rbf_font.c.

133 {
134  // convert character value based on selected code page
135  if ((rbf_codepage == FONT_CP_DOS) && (ch >= 128) && (ch < 256)) {
136  // Convert DOS to WIN char
137  ch = tbl_dos2win[ch-128];
138  }
139  return ch;
140 }
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.

311  {
312  int xx, yy;
313 
314  // draw pixels for font character
315  if (cdata)
316  for (yy=0; yy<height; ++yy)
317  for (xx=0; xx<pixel_width; ++xx)
318  draw_pixel(x+xx ,y+yy, (cdata[yy*width/8+xx/8] & (1<<(xx%8))) ? FG_COLOR(cl) : BG_COLOR(cl));
319 }
int font_read ( int  fd,
unsigned char *  dest,
int  len 
)

Definiert in Zeile 156 der Datei rbf_font.c.

157 {
158  // Return actual bytes read
159  int bytes_read = 0;
160 
161  if (ubuffer)
162  {
163  // Read file in UBUFFER_SIZE blocks
164  while (len)
165  {
166  // Calc size of next block to read = min(UBUFFER_SIZE, len)
167  int to_read = UBUFFER_SIZE;
168  if (to_read > len) to_read = len;
169 
170  // Read block and copy to dest
171  bytes_read += read(fd, ubuffer, to_read);
172  memcpy(dest, ubuffer, to_read);
173 
174  // Increment dest pointer, decrement len left to read
175  dest += to_read;
176  len -= to_read;
177  }
178  }
179 
180  return bytes_read;
181 }
void init_fonts ( )

Definiert in Zeile 74 der Datei rbf_font.c.

75 {
76  // Allocate base font memory if needed
77  if (rbf_font == 0) rbf_font = new_font();
79 
80  // allocate uncached memory buffer for reading
82 }
font* new_font ( )

Definiert in Zeile 61 der Datei rbf_font.c.

61  {
62  // allocate font from cached memory
63  font *f = malloc(sizeof(font));
64  if (f) {
65  memset(f,0,sizeof(font)); // wipe memory
66  // return address in cached memory
67  return f;
68  }
69 
70  // memory not allocated ! should probably do something else in this case ?
71  return 0;
72 }
int rbf_char_width ( int  ch)

Definiert in Zeile 282 der Datei rbf_font.c.

282  {
283  return rbf_font->wTable[code_page_char(ch)];
284 }
void rbf_disable_cursor ( )

Definiert in Zeile 403 der Datei rbf_font.c.

404 {
405  cursor_on = 0;
406 }
int rbf_draw_char ( int  x,
int  y,
int  ch,
twoColors  cl 
)

Definiert in Zeile 322 der Datei rbf_font.c.

322  {
323  // Convert char for code page
324  ch = code_page_char(ch);
325 
326  // Get char data pointer
327  char* cdata = rbf_font_char(rbf_font, ch);
328 
329  // Draw font character (either loaded font, or from default font)
330  if (rbf_font->usingFont8x16 || !cdata)
331  draw_char(x,y,ch,cl);
332  else
334 
335  return rbf_font->wTable[ch];
336 }
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.

409 {
410  int i = 0;
411  twoColors inv_cl = MAKE_COLOR(FG_COLOR(cl), BG_COLOR(cl));
412 
413  // Draw chars from string up to max pixel length
414  while (*str && l+rbf_char_width(*str)<=maxlen)
415  {
416  if (cursor_on && (cursor_start <= i) && (i <= cursor_end))
417  l+=rbf_draw_char(x+l, y, *str++, inv_cl);
418  else
419  l+=rbf_draw_char(x+l, y, *str++, cl);
420  i++;
421  }
422 
423  return l;
424 }
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.

454  {
455  int l=0, i, ll, lr;
456 
457  // If symbol to be added to string determing the width of the symbol + space
458  if (symbol!=0x0 && conf.menu_symbol_enable && rbf_font_height()>=rbf_symbol_height()) {
459  l += rbf_symbol_width(symbol);
460  l += rbf_char_width(' ');
461  }
462 
463  // Add the length of the string (possibly clipped to fit)
464  l = rbf_str_clipped_width(str, l, len);
465 
466  // Calculate padding required on left and right side
467  ll = 8;
468  lr = len-l-ll;
469 
470  int right = x+len-1, bottom = y+rbf_font_height()-1;
471 
472  // Fill left & right sides of string area with a rectangle that has rounded top corners
473  for (i=0; i<=l && i<3; i++) {
474  if (i < 2) {
475  // First and second columns make rounded top corners
476  draw_line(x+i, y+2-i, x+i, bottom, BG_COLOR(cl)); // left side
477  draw_line(right-i, y+2-i, right-i, bottom, BG_COLOR(cl)); // right side
478  }
479  else {
480  // Rest of empty space is just filled with rectangles
481  draw_rectangle(x+i, y, x+ll-1, bottom, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED); // left side
482  draw_rectangle(right-lr, y, right-i, bottom, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED); // right side
483  }
484  }
485 
486  // Draw symbol and space if required
487  if (symbol!=0x0 && conf.menu_symbol_enable && rbf_font_height()>=rbf_symbol_height()) {
488  ll += rbf_draw_symbol(x+ll, y, symbol, cl);
489  ll += rbf_draw_char(x+ll, y, ' ', cl);
490  }
491 
492  // Draw chars
493  ll = rbf_draw_clipped_string(x, y, str, cl, ll, len);
494 
495  return ll;
496 }
int rbf_draw_string ( int  x,
int  y,
const char *  str,
twoColors  cl 
)

Definiert in Zeile 387 der Datei rbf_font.c.

387  {
388  return rbf_draw_string_c(x, y, str, cl, -1, MAKE_COLOR(0,0));
389 }
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.

376  {
377  int l=0, i=0;
378 
379  while (*str) {
380  l+=rbf_draw_char(x+l, y, *str++, (i==c)?c2:c1);
381  ++i;
382  }
383  return l;
384 }
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.

427  {
428  // Draw string characters
429  int l = rbf_draw_clipped_string(x, y, str, cl, 0, len);
430 
431  // Fill any remaining space on right with background color
432  if (l < len)
434 
435  return len;
436 }
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.

439  {
440  // Calulate amount of padding needed on the left
441  int l = len - rbf_str_clipped_width(str, 0, len);
442 
443  // Fill padding with background color
444  if (l > 0)
446 
447  // Draw chars
448  l = rbf_draw_clipped_string(x, y, str, cl, l, len);
449 
450  return l;
451 }
int rbf_draw_symbol ( int  x,
int  y,
int  ch,
twoColors  cl 
)

Definiert in Zeile 339 der Datei rbf_font.c.

339  {
340  int space=0, pixel_width, sym_height, txt_height;
341 
342  // Skip if symbol font height taller than text font height (or invalid char value)
343  if (rbf_font->hdr.height<rbf_symbol_font->hdr.height || ch==0x0) return 0;
344 
345  // get width of symbol in pixels
346  pixel_width = rbf_symbol_width(ch);
347  // get height of symbol font
348  sym_height = rbf_symbol_font->hdr.height;
349  // get height of text font
350  txt_height = rbf_font->hdr.height;
351 
352  // Get char data pointer
353  char* cdata = rbf_font_char(rbf_symbol_font, ch);
354 
355  if (cdata) {
356  // if symbol font shorter than text font center symbol vertically and fill empty space above
357  if (txt_height > sym_height) {
358  space = (txt_height - sym_height)/2;
360  y+=space;
361  }
362 
363  // Draw font character
364  font_draw_char(x, y, cdata, rbf_symbol_font->width, sym_height, pixel_width, cl);
365 
366  // Fill space below symbol if shorter than text font
367  if (txt_height > sym_height)
368  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);
369  }
370 
371  return pixel_width;
372 }
void rbf_enable_cursor ( int  s,
int  e 
)

Definiert in Zeile 396 der Datei rbf_font.c.

397 {
398  cursor_on = 1;
399  cursor_start = s;
400  cursor_end = e;
401 }
char* rbf_font_char ( font f,
int  ch 
)

Definiert in Zeile 144 der Datei rbf_font.c.

145 {
146  if (f && (ch >= f->hdr.charFirst) && (ch <= f->hdr.charLast))
147  {
148  return &f->cTable[(ch-f->hdr.charFirst)*f->hdr.charSize];
149  }
150 
151  return 0;
152 }
int rbf_font_height ( )

Definiert in Zeile 273 der Datei rbf_font.c.

273  {
274  return rbf_font->hdr.height;
275 }
int rbf_font_load ( char *  file,
font f,
int  maxchar 
)

Definiert in Zeile 184 der Datei rbf_font.c.

185 {
186  int i;
187  int rv = 0; // return value
188 
189  // make sure the font has been allocated, and a valid filename is given
190  if ((f == 0) || (*file == 0)) return 0;
191 
192  // turn of default font if it was being used
193  f->usingFont8x16 = 0;
194 
195  // open file (can't use fopen here due to potential conflict FsIoNotify crash)
196  int fd = open(file, O_RDONLY, 0777);
197  if (fd >= 0) {
198  // read header
199  i = font_read(fd, (unsigned char*)&f->hdr, sizeof(font_hdr));
200 
201  // check size read is correct and magic numbers are valid
202  if ((i == sizeof(font_hdr)) && (f->hdr.magic1 == RBF_HDR_MAGIC1) && (f->hdr.magic2 == RBF_HDR_MAGIC2)) {
203 
204  if (maxchar != 0) {
205  f->hdr.charLast = maxchar;
206  }
207 
208  alloc_cTable(f);
209 
210  // read width table (using uncached buffer)
211  lseek(fd, f->hdr._wmapAddr, SEEK_SET);
212  font_read(fd, (unsigned char*)&f->wTable[f->hdr.charFirst], f->charCount);
213 
214  // read cTable data (using uncached buffer)
215  lseek(fd, f->hdr._cmapAddr, SEEK_SET);
216  font_read(fd, (unsigned char*)f->cTable, f->charCount*f->hdr.charSize);
217 
218  // Reset symbol display if symbol font too tall
221 
222  rv = 1;
223  }
224 
225  close(fd);
226  }
227 
228  return rv;
229 }
void rbf_load_from_file ( char *  file,
int  codepage 
)

Definiert in Zeile 242 der Datei rbf_font.c.

243 {
244  // Allocate font if needed
245  init_fonts();
246  // Load font, load default on failure
247  if (!rbf_font_load(file, rbf_font, 0))
248  {
249  // Reset back to built in font, file load failed
253  rbf_font->hdr.charFirst = 0;
254  rbf_font->hdr.charLast = 255;
255 
256  // This is only ever called to copy the 'current_font' data into the rbf_font
257  // Instead of doing this set the rbf_font flag so we call 'draw_char' directly (which uses current_font)
258  // This avoids allocating memory for a copy of something we already have
259  rbf_font->usingFont8x16 = 1;
260 
262  }
263  // Set codepage
264  rbf_set_codepage(codepage);
265 }
int rbf_load_symbol ( char *  file)

Definiert in Zeile 233 der Datei rbf_font.c.

233  {
234  // Allocate font if needed
235  init_fonts();
236  // Load font
237  return rbf_font_load(file, rbf_symbol_font, maxSymbols+32);
238 }
void rbf_set_codepage ( int  codepage)

Definiert in Zeile 268 der Datei rbf_font.c.

268  {
269  rbf_codepage = codepage;
270 }
int rbf_str_clipped_width ( const char *  str,
int  l,
int  maxlen 
)

Definiert in Zeile 302 der Datei rbf_font.c.

302  {
303  // Calculate how long the string is in pixels (possibly clipped to 'maxlen')
304  while (*str && l+rbf_char_width(*str)<=maxlen)
305  l+=rbf_char_width(*str++);
306 
307  return l;
308 }
int rbf_str_width ( const char *  str)

Definiert in Zeile 292 der Datei rbf_font.c.

292  {
293  int l=0;
294 
295  // Calculate how long the string is in pixels
296  while (*str)
297  l+=rbf_char_width(*str++);
298 
299  return l;
300 }
int rbf_symbol_height ( )

Definiert in Zeile 277 der Datei rbf_font.c.

277  {
278  return rbf_symbol_font->hdr.height;
279 }
int rbf_symbol_width ( int  ch)

Definiert in Zeile 287 der Datei rbf_font.c.

287  {
288  return rbf_symbol_font->wTable[ch];
289 }

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.