CHDK_DE Vorschauversion  Trunk Rev. 5232
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
rbf_font.c-Dateireferenz
#include "camera_info.h"
#include "stdlib.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 unsigned int RBF_HDR_MAGIC1 = 0x0DF00EE0
 
static unsigned 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 233 der Datei rbf_font.c.

#define RBF_MAX_NAME   64

Definiert in Zeile 9 der Datei rbf_font.c.

#define UBUFFER_SIZE   256

Definiert in Zeile 10 der Datei rbf_font.c.

Dokumentation der benutzerdefinierten Typen

typedef struct _font font

Dokumentation der Funktionen

void alloc_cTable ( font f)

Definiert in Zeile 85 der Datei rbf_font.c.

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

Definiert in Zeile 133 der Datei rbf_font.c.

134 {
135  // convert character value based on selected code page
136  if ((rbf_codepage == FONT_CP_DOS) && (ch >= 128) && (ch < 256)) {
137  // Convert DOS to WIN char
138  ch = tbl_dos2win[ch-128];
139  }
140  return ch;
141 }
void font_draw_char ( int  x,
int  y,
char *  cdata,
int  width,
int  height,
int  pixel_width,
twoColors  cl 
)

Definiert in Zeile 312 der Datei rbf_font.c.

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

Definiert in Zeile 157 der Datei rbf_font.c.

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

Definiert in Zeile 75 der Datei rbf_font.c.

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

Definiert in Zeile 62 der Datei rbf_font.c.

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

Definiert in Zeile 283 der Datei rbf_font.c.

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

Definiert in Zeile 404 der Datei rbf_font.c.

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

Definiert in Zeile 323 der Datei rbf_font.c.

323  {
324  // Convert char for code page
325  ch = code_page_char(ch);
326 
327  // Get char data pointer
328  char* cdata = rbf_font_char(rbf_font, ch);
329 
330  // Draw font character (either loaded font, or from default font)
331  if (rbf_font->usingFont8x16 || !cdata)
332  draw_char(x,y,ch,cl);
333  else
335 
336  return rbf_font->wTable[ch];
337 }
int rbf_draw_clipped_string ( int  x,
int  y,
const char *  str,
twoColors  cl,
int  l,
int  maxlen 
)

Definiert in Zeile 409 der Datei rbf_font.c.

410 {
411  int i = 0;
412  twoColors inv_cl = MAKE_COLOR(FG_COLOR(cl), BG_COLOR(cl));
413 
414  // Draw chars from string up to max pixel length
415  while (*str && l+rbf_char_width(*str)<=maxlen)
416  {
417  if (cursor_on && (cursor_start <= i) && (i <= cursor_end))
418  l+=rbf_draw_char(x+l, y, *str++, inv_cl);
419  else
420  l+=rbf_draw_char(x+l, y, *str++, cl);
421  i++;
422  }
423 
424  return l;
425 }
int rbf_draw_menu_header ( int  x,
int  y,
int  len,
char  symbol,
const char *  str,
twoColors  cl 
)

Definiert in Zeile 455 der Datei rbf_font.c.

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

Definiert in Zeile 388 der Datei rbf_font.c.

388  {
389  return rbf_draw_string_c(x, y, str, cl, -1, MAKE_COLOR(0,0));
390 }
int rbf_draw_string_c ( int  x,
int  y,
const char *  str,
twoColors  c1,
int  c,
twoColors  c2 
)

Definiert in Zeile 377 der Datei rbf_font.c.

377  {
378  int l=0, i=0;
379 
380  while (*str) {
381  l+=rbf_draw_char(x+l, y, *str++, (i==c)?c2:c1);
382  ++i;
383  }
384  return l;
385 }
int rbf_draw_string_len ( int  x,
int  y,
int  len,
const char *  str,
twoColors  cl 
)

Definiert in Zeile 428 der Datei rbf_font.c.

428  {
429  // Draw string characters
430  int l = rbf_draw_clipped_string(x, y, str, cl, 0, len);
431 
432  // Fill any remaining space on right with background color
433  if (l < len)
435 
436  return len;
437 }
int rbf_draw_string_right_len ( int  x,
int  y,
int  len,
const char *  str,
twoColors  cl 
)

Definiert in Zeile 440 der Datei rbf_font.c.

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

Definiert in Zeile 340 der Datei rbf_font.c.

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

Definiert in Zeile 397 der Datei rbf_font.c.

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

Definiert in Zeile 145 der Datei rbf_font.c.

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

Definiert in Zeile 274 der Datei rbf_font.c.

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

Definiert in Zeile 185 der Datei rbf_font.c.

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

Definiert in Zeile 243 der Datei rbf_font.c.

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

Definiert in Zeile 234 der Datei rbf_font.c.

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

Definiert in Zeile 269 der Datei rbf_font.c.

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

Definiert in Zeile 303 der Datei rbf_font.c.

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

Definiert in Zeile 293 der Datei rbf_font.c.

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

Definiert in Zeile 278 der Datei rbf_font.c.

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

Definiert in Zeile 288 der Datei rbf_font.c.

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

Variablen-Dokumentation

int cursor_end = 0
static

Definiert in Zeile 395 der Datei rbf_font.c.

int cursor_on = 0
static

Definiert in Zeile 393 der Datei rbf_font.c.

int cursor_start = 0
static

Definiert in Zeile 394 der Datei rbf_font.c.

int rbf_codepage = FONT_CP_WIN
static

Definiert in Zeile 58 der Datei rbf_font.c.

font * rbf_font = 0
static

Definiert in Zeile 57 der Datei rbf_font.c.

unsigned int RBF_HDR_MAGIC1 = 0x0DF00EE0
static

Definiert in Zeile 12 der Datei rbf_font.c.

unsigned int RBF_HDR_MAGIC2 = 0x00000003
static

Definiert in Zeile 13 der Datei rbf_font.c.

font* rbf_symbol_font = 0
static

Definiert in Zeile 57 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 122 der Datei rbf_font.c.

unsigned char* ubuffer = 0
static

Definiert in Zeile 56 der Datei rbf_font.c.