Visualization Library 2.0.0-b5

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
bdfdrivr.c
Go to the documentation of this file.
1 /* bdfdrivr.c
2 
3  FreeType font driver for bdf files
4 
5  Copyright (C) 2001-2008, 2011, 2013 by
6  Francesco Zappa Nardelli
7 
8 Permission is hereby granted, free of charge, to any person obtaining a copy
9 of this software and associated documentation files (the "Software"), to deal
10 in the Software without restriction, including without limitation the rights
11 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 copies of the Software, and to permit persons to whom the Software is
13 furnished to do so, subject to the following conditions:
14 
15 The above copyright notice and this permission notice shall be included in
16 all copies or substantial portions of the Software.
17 
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 THE SOFTWARE.
25 */
26 
27 #include <ft2build.h>
28 
29 #include FT_INTERNAL_DEBUG_H
30 #include FT_INTERNAL_STREAM_H
31 #include FT_INTERNAL_OBJECTS_H
32 #include FT_BDF_H
33 #include FT_TRUETYPE_IDS_H
34 
35 #include FT_SERVICE_BDF_H
36 #include FT_SERVICE_XFREE86_NAME_H
37 
38 #include "bdf.h"
39 #include "bdfdrivr.h"
40 
41 #include "bdferror.h"
42 
43 
44  /*************************************************************************/
45  /* */
46  /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
47  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
48  /* messages during execution. */
49  /* */
50 #undef FT_COMPONENT
51 #define FT_COMPONENT trace_bdfdriver
52 
53 
54  typedef struct BDF_CMapRec_
55  {
56  FT_CMapRec cmap;
57  FT_ULong num_encodings; /* ftobjs.h: FT_CMap->clazz->size */
58  BDF_encoding_el* encodings;
59 
61 
62 
65  FT_Pointer init_data )
66  {
67  BDF_CMap cmap = (BDF_CMap)bdfcmap;
69  FT_UNUSED( init_data );
70 
71 
72  cmap->num_encodings = face->bdffont->glyphs_used;
73  cmap->encodings = face->en_table;
74 
75  return FT_Err_Ok;
76  }
77 
78 
79  FT_CALLBACK_DEF( void )
81  {
82  BDF_CMap cmap = (BDF_CMap)bdfcmap;
83 
84 
85  cmap->encodings = NULL;
86  cmap->num_encodings = 0;
87  }
88 
89 
92  FT_UInt32 charcode )
93  {
94  BDF_CMap cmap = (BDF_CMap)bdfcmap;
95  BDF_encoding_el* encodings = cmap->encodings;
96  FT_ULong min, max, mid; /* num_encodings */
97  FT_UShort result = 0; /* encodings->glyph */
98 
99 
100  min = 0;
101  max = cmap->num_encodings;
102 
103  while ( min < max )
104  {
105  FT_ULong code;
106 
107 
108  mid = ( min + max ) >> 1;
109  code = encodings[mid].enc;
110 
111  if ( charcode == code )
112  {
113  /* increase glyph index by 1 -- */
114  /* we reserve slot 0 for the undefined glyph */
115  result = encodings[mid].glyph + 1;
116  break;
117  }
118 
119  if ( charcode < code )
120  max = mid;
121  else
122  min = mid + 1;
123  }
124 
125  return result;
126  }
127 
128 
131  FT_UInt32 *acharcode )
132  {
133  BDF_CMap cmap = (BDF_CMap)bdfcmap;
134  BDF_encoding_el* encodings = cmap->encodings;
135  FT_ULong min, max, mid; /* num_encodings */
136  FT_UShort result = 0; /* encodings->glyph */
137  FT_ULong charcode = *acharcode + 1;
138 
139 
140  min = 0;
141  max = cmap->num_encodings;
142 
143  while ( min < max )
144  {
145  FT_ULong code; /* same as BDF_encoding_el.enc */
146 
147 
148  mid = ( min + max ) >> 1;
149  code = encodings[mid].enc;
150 
151  if ( charcode == code )
152  {
153  /* increase glyph index by 1 -- */
154  /* we reserve slot 0 for the undefined glyph */
155  result = encodings[mid].glyph + 1;
156  goto Exit;
157  }
158 
159  if ( charcode < code )
160  max = mid;
161  else
162  min = mid + 1;
163  }
164 
165  charcode = 0;
166  if ( min < cmap->num_encodings )
167  {
168  charcode = encodings[min].enc;
169  result = encodings[min].glyph + 1;
170  }
171 
172  Exit:
173  if ( charcode > 0xFFFFFFFFUL )
174  {
175  FT_TRACE1(( "bdf_cmap_char_next: charcode 0x%x > 32bit API" ));
176  *acharcode = 0;
177  /* XXX: result should be changed to indicate an overflow error */
178  }
179  else
180  *acharcode = (FT_UInt32)charcode;
181  return result;
182  }
183 
184 
187  {
188  sizeof ( BDF_CMapRec ),
193 
194  NULL, NULL, NULL, NULL, NULL
195  };
196 
197 
198  static FT_Error
199  bdf_interpret_style( BDF_Face bdf )
200  {
202  FT_Face face = FT_FACE( bdf );
203  FT_Memory memory = face->memory;
204  bdf_font_t* font = bdf->bdffont;
205  bdf_property_t* prop;
206 
207  char* strings[4] = { NULL, NULL, NULL, NULL };
208  size_t nn, len, lengths[4];
209 
210 
211  face->style_flags = 0;
212 
213  prop = bdf_get_font_property( font, (char *)"SLANT" );
214  if ( prop && prop->format == BDF_ATOM &&
215  prop->value.atom &&
216  ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' ||
217  *(prop->value.atom) == 'I' || *(prop->value.atom) == 'i' ) )
218  {
220  strings[2] = ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' )
221  ? (char *)"Oblique"
222  : (char *)"Italic";
223  }
224 
225  prop = bdf_get_font_property( font, (char *)"WEIGHT_NAME" );
226  if ( prop && prop->format == BDF_ATOM &&
227  prop->value.atom &&
228  ( *(prop->value.atom) == 'B' || *(prop->value.atom) == 'b' ) )
229  {
231  strings[1] = (char *)"Bold";
232  }
233 
234  prop = bdf_get_font_property( font, (char *)"SETWIDTH_NAME" );
235  if ( prop && prop->format == BDF_ATOM &&
236  prop->value.atom && *(prop->value.atom) &&
237  !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
238  strings[3] = (char *)(prop->value.atom);
239 
240  prop = bdf_get_font_property( font, (char *)"ADD_STYLE_NAME" );
241  if ( prop && prop->format == BDF_ATOM &&
242  prop->value.atom && *(prop->value.atom) &&
243  !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
244  strings[0] = (char *)(prop->value.atom);
245 
246  len = 0;
247 
248  for ( len = 0, nn = 0; nn < 4; nn++ )
249  {
250  lengths[nn] = 0;
251  if ( strings[nn] )
252  {
253  lengths[nn] = ft_strlen( strings[nn] );
254  len += lengths[nn] + 1;
255  }
256  }
257 
258  if ( len == 0 )
259  {
260  strings[0] = (char *)"Regular";
261  lengths[0] = ft_strlen( strings[0] );
262  len = lengths[0] + 1;
263  }
264 
265  {
266  char* s;
267 
268 
269  if ( FT_ALLOC( face->style_name, len ) )
270  return error;
271 
272  s = face->style_name;
273 
274  for ( nn = 0; nn < 4; nn++ )
275  {
276  char* src = strings[nn];
277 
278 
279  len = lengths[nn];
280 
281  if ( src == NULL )
282  continue;
283 
284  /* separate elements with a space */
285  if ( s != face->style_name )
286  *s++ = ' ';
287 
288  ft_memcpy( s, src, len );
289 
290  /* need to convert spaces to dashes for */
291  /* add_style_name and setwidth_name */
292  if ( nn == 0 || nn == 3 )
293  {
294  size_t mm;
295 
296 
297  for ( mm = 0; mm < len; mm++ )
298  if ( s[mm] == ' ' )
299  s[mm] = '-';
300  }
301 
302  s += len;
303  }
304  *s = 0;
305  }
306 
307  return error;
308  }
309 
310 
311  FT_CALLBACK_DEF( void )
312  BDF_Face_Done( FT_Face bdfface ) /* BDF_Face */
313  {
314  BDF_Face face = (BDF_Face)bdfface;
315  FT_Memory memory;
316 
317 
318  if ( !face )
319  return;
320 
321  memory = FT_FACE_MEMORY( face );
322 
323  bdf_free_font( face->bdffont );
324 
325  FT_FREE( face->en_table );
326 
327  FT_FREE( face->charset_encoding );
328  FT_FREE( face->charset_registry );
329  FT_FREE( bdfface->family_name );
330  FT_FREE( bdfface->style_name );
331 
332  FT_FREE( bdfface->available_sizes );
333 
334  FT_FREE( face->bdffont );
335  }
336 
337 
340  FT_Face bdfface, /* BDF_Face */
341  FT_Int face_index,
342  FT_Int num_params,
344  {
346  BDF_Face face = (BDF_Face)bdfface;
347  FT_Memory memory = FT_FACE_MEMORY( face );
348 
349  bdf_font_t* font = NULL;
350  bdf_options_t options;
351 
352  FT_UNUSED( num_params );
353  FT_UNUSED( params );
354  FT_UNUSED( face_index );
355 
356 
357  FT_TRACE2(( "BDF driver\n" ));
358 
359  if ( FT_STREAM_SEEK( 0 ) )
360  goto Exit;
361 
362  options.correct_metrics = 1; /* FZ XXX: options semantics */
363  options.keep_unencoded = 1;
364  options.keep_comments = 0;
365  options.font_spacing = BDF_PROPORTIONAL;
366 
367  error = bdf_load_font( stream, memory, &options, &font );
368  if ( FT_ERR_EQ( error, Missing_Startfont_Field ) )
369  {
370  FT_TRACE2(( " not a BDF file\n" ));
371  goto Fail;
372  }
373  else if ( error )
374  goto Exit;
375 
376  /* we have a bdf font: let's construct the face object */
377  face->bdffont = font;
378  {
379  bdf_property_t* prop = NULL;
380 
381 
382  FT_TRACE4(( " number of glyphs: allocated %d (used %d)\n",
383  font->glyphs_size,
384  font->glyphs_used ));
385  FT_TRACE4(( " number of unencoded glyphs: allocated %d (used %d)\n",
386  font->unencoded_size,
387  font->unencoded_used ));
388 
389  bdfface->num_faces = 1;
390  bdfface->face_index = 0;
391  bdfface->face_flags = FT_FACE_FLAG_FIXED_SIZES |
394 
395  prop = bdf_get_font_property( font, "SPACING" );
396  if ( prop && prop->format == BDF_ATOM &&
397  prop->value.atom &&
398  ( *(prop->value.atom) == 'M' || *(prop->value.atom) == 'm' ||
399  *(prop->value.atom) == 'C' || *(prop->value.atom) == 'c' ) )
400  bdfface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
401 
402  /* FZ XXX: TO DO: FT_FACE_FLAGS_VERTICAL */
403  /* FZ XXX: I need a font to implement this */
404 
405  prop = bdf_get_font_property( font, "FAMILY_NAME" );
406  if ( prop && prop->value.atom )
407  {
408  if ( FT_STRDUP( bdfface->family_name, prop->value.atom ) )
409  goto Exit;
410  }
411  else
412  bdfface->family_name = 0;
413 
414  if ( ( error = bdf_interpret_style( face ) ) != 0 )
415  goto Exit;
416 
417  /* the number of glyphs (with one slot for the undefined glyph */
418  /* at position 0 and all unencoded glyphs) */
419  bdfface->num_glyphs = font->glyphs_size + 1;
420 
421  bdfface->num_fixed_sizes = 1;
422  if ( FT_NEW_ARRAY( bdfface->available_sizes, 1 ) )
423  goto Exit;
424 
425  {
426  FT_Bitmap_Size* bsize = bdfface->available_sizes;
427  FT_Short resolution_x = 0, resolution_y = 0;
428 
429 
430  FT_MEM_ZERO( bsize, sizeof ( FT_Bitmap_Size ) );
431 
432  bsize->height = (FT_Short)( font->font_ascent + font->font_descent );
433 
434  prop = bdf_get_font_property( font, "AVERAGE_WIDTH" );
435  if ( prop )
436  bsize->width = (FT_Short)( ( prop->value.l + 5 ) / 10 );
437  else
438  bsize->width = (FT_Short)( bsize->height * 2/3 );
439 
440  prop = bdf_get_font_property( font, "POINT_SIZE" );
441  if ( prop )
442  /* convert from 722.7 decipoints to 72 points per inch */
443  bsize->size =
444  (FT_Pos)( ( prop->value.l * 64 * 7200 + 36135L ) / 72270L );
445  else
446  bsize->size = bsize->width << 6;
447 
448  prop = bdf_get_font_property( font, "PIXEL_SIZE" );
449  if ( prop )
450  bsize->y_ppem = (FT_Short)prop->value.l << 6;
451 
452  prop = bdf_get_font_property( font, "RESOLUTION_X" );
453  if ( prop )
454  resolution_x = (FT_Short)prop->value.l;
455 
456  prop = bdf_get_font_property( font, "RESOLUTION_Y" );
457  if ( prop )
458  resolution_y = (FT_Short)prop->value.l;
459 
460  if ( bsize->y_ppem == 0 )
461  {
462  bsize->y_ppem = bsize->size;
463  if ( resolution_y )
464  bsize->y_ppem = bsize->y_ppem * resolution_y / 72;
465  }
466  if ( resolution_x && resolution_y )
467  bsize->x_ppem = bsize->y_ppem * resolution_x / resolution_y;
468  else
469  bsize->x_ppem = bsize->y_ppem;
470  }
471 
472  /* encoding table */
473  {
474  bdf_glyph_t* cur = font->glyphs;
475  unsigned long n;
476 
477 
478  if ( FT_NEW_ARRAY( face->en_table, font->glyphs_size ) )
479  goto Exit;
480 
481  face->default_glyph = 0;
482  for ( n = 0; n < font->glyphs_size; n++ )
483  {
484  (face->en_table[n]).enc = cur[n].encoding;
485  FT_TRACE4(( " idx %d, val 0x%lX\n", n, cur[n].encoding ));
486  (face->en_table[n]).glyph = (FT_Short)n;
487 
488  if ( cur[n].encoding == font->default_char )
489  {
490  if ( n < FT_UINT_MAX )
491  face->default_glyph = (FT_UInt)n;
492  else
493  FT_TRACE1(( "BDF_Face_Init:"
494  " idx %d is too large for this system\n", n ));
495  }
496  }
497  }
498 
499  /* charmaps */
500  {
501  bdf_property_t *charset_registry = 0, *charset_encoding = 0;
502  FT_Bool unicode_charmap = 0;
503 
504 
505  charset_registry =
506  bdf_get_font_property( font, "CHARSET_REGISTRY" );
507  charset_encoding =
508  bdf_get_font_property( font, "CHARSET_ENCODING" );
509  if ( charset_registry && charset_encoding )
510  {
511  if ( charset_registry->format == BDF_ATOM &&
512  charset_encoding->format == BDF_ATOM &&
513  charset_registry->value.atom &&
514  charset_encoding->value.atom )
515  {
516  const char* s;
517 
518 
519  if ( FT_STRDUP( face->charset_encoding,
520  charset_encoding->value.atom ) ||
522  charset_registry->value.atom ) )
523  goto Exit;
524 
525  /* Uh, oh, compare first letters manually to avoid dependency */
526  /* on locales. */
527  s = face->charset_registry;
528  if ( ( s[0] == 'i' || s[0] == 'I' ) &&
529  ( s[1] == 's' || s[1] == 'S' ) &&
530  ( s[2] == 'o' || s[2] == 'O' ) )
531  {
532  s += 3;
533  if ( !ft_strcmp( s, "10646" ) ||
534  ( !ft_strcmp( s, "8859" ) &&
535  !ft_strcmp( face->charset_encoding, "1" ) ) )
536  unicode_charmap = 1;
537  }
538 
539  {
540  FT_CharMapRec charmap;
541 
542 
543  charmap.face = FT_FACE( face );
544  charmap.encoding = FT_ENCODING_NONE;
545  /* initial platform/encoding should indicate unset status? */
548 
549  if ( unicode_charmap )
550  {
551  charmap.encoding = FT_ENCODING_UNICODE;
554  }
555 
556  error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
557 
558 #if 0
559  /* Select default charmap */
560  if ( bdfface->num_charmaps )
561  bdfface->charmap = bdfface->charmaps[0];
562 #endif
563  }
564 
565  goto Exit;
566  }
567  }
568 
569  /* otherwise assume Adobe standard encoding */
570 
571  {
572  FT_CharMapRec charmap;
573 
574 
575  charmap.face = FT_FACE( face );
576  charmap.encoding = FT_ENCODING_ADOBE_STANDARD;
577  charmap.platform_id = TT_PLATFORM_ADOBE;
579 
580  error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
581 
582  /* Select default charmap */
583  if ( bdfface->num_charmaps )
584  bdfface->charmap = bdfface->charmaps[0];
585  }
586  }
587  }
588 
589  Exit:
590  return error;
591 
592  Fail:
593  BDF_Face_Done( bdfface );
594  return FT_THROW( Unknown_File_Format );
595  }
596 
597 
600  FT_ULong strike_index )
601  {
602  bdf_font_t* bdffont = ( (BDF_Face)size->face )->bdffont;
603 
604 
605  FT_Select_Metrics( size->face, strike_index );
606 
607  size->metrics.ascender = bdffont->font_ascent << 6;
608  size->metrics.descender = -bdffont->font_descent << 6;
609  size->metrics.max_advance = bdffont->bbx.width << 6;
610 
611  return FT_Err_Ok;
612  }
613 
614 
617  FT_Size_Request req )
618  {
619  FT_Face face = size->face;
620  FT_Bitmap_Size* bsize = face->available_sizes;
621  bdf_font_t* bdffont = ( (BDF_Face)face )->bdffont;
622  FT_Error error = FT_ERR( Invalid_Pixel_Size );
623  FT_Long height;
624 
625 
626  height = FT_REQUEST_HEIGHT( req );
627  height = ( height + 32 ) >> 6;
628 
629  switch ( req->type )
630  {
632  if ( height == ( ( bsize->y_ppem + 32 ) >> 6 ) )
633  error = FT_Err_Ok;
634  break;
635 
637  if ( height == ( bdffont->font_ascent +
638  bdffont->font_descent ) )
639  error = FT_Err_Ok;
640  break;
641 
642  default:
643  error = FT_THROW( Unimplemented_Feature );
644  break;
645  }
646 
647  if ( error )
648  return error;
649  else
650  return BDF_Size_Select( size, 0 );
651  }
652 
653 
654 
657  FT_Size size,
658  FT_UInt glyph_index,
659  FT_Int32 load_flags )
660  {
662  FT_Face face = FT_FACE( bdf );
664  FT_Bitmap* bitmap = &slot->bitmap;
665  bdf_glyph_t glyph;
666  int bpp = bdf->bdffont->bpp;
667 
668  FT_UNUSED( load_flags );
669 
670 
671  if ( !face || glyph_index >= (FT_UInt)face->num_glyphs )
672  {
673  error = FT_THROW( Invalid_Argument );
674  goto Exit;
675  }
676 
677  /* index 0 is the undefined glyph */
678  if ( glyph_index == 0 )
679  glyph_index = bdf->default_glyph;
680  else
681  glyph_index--;
682 
683  /* slot, bitmap => freetype, glyph => bdflib */
684  glyph = bdf->bdffont->glyphs[glyph_index];
685 
686  bitmap->rows = glyph.bbx.height;
687  bitmap->width = glyph.bbx.width;
688  if ( glyph.bpr > INT_MAX )
689  FT_TRACE1(( "BDF_Glyph_Load: too large pitch %d is truncated\n",
690  glyph.bpr ));
691  bitmap->pitch = (int)glyph.bpr; /* same as FT_Bitmap.pitch */
692 
693  /* note: we don't allocate a new array to hold the bitmap; */
694  /* we can simply point to it */
695  ft_glyphslot_set_bitmap( slot, glyph.bitmap );
696 
697  switch ( bpp )
698  {
699  case 1:
700  bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
701  break;
702  case 2:
704  break;
705  case 4:
707  break;
708  case 8:
709  bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
710  bitmap->num_grays = 256;
711  break;
712  }
713 
714  slot->format = FT_GLYPH_FORMAT_BITMAP;
715  slot->bitmap_left = glyph.bbx.x_offset;
716  slot->bitmap_top = glyph.bbx.ascent;
717 
718  slot->metrics.horiAdvance = glyph.dwidth << 6;
719  slot->metrics.horiBearingX = glyph.bbx.x_offset << 6;
720  slot->metrics.horiBearingY = glyph.bbx.ascent << 6;
721  slot->metrics.width = bitmap->width << 6;
722  slot->metrics.height = bitmap->rows << 6;
723 
724  /*
725  * XXX DWIDTH1 and VVECTOR should be parsed and
726  * used here, provided such fonts do exist.
727  */
728  ft_synthesize_vertical_metrics( &slot->metrics,
729  bdf->bdffont->bbx.height << 6 );
730 
731  Exit:
732  return error;
733  }
734 
735 
736  /*
737  *
738  * BDF SERVICE
739  *
740  */
741 
742  static FT_Error
743  bdf_get_bdf_property( BDF_Face face,
744  const char* prop_name,
745  BDF_PropertyRec *aproperty )
746  {
747  bdf_property_t* prop;
748 
749 
750  FT_ASSERT( face && face->bdffont );
751 
752  prop = bdf_get_font_property( face->bdffont, prop_name );
753  if ( prop )
754  {
755  switch ( prop->format )
756  {
757  case BDF_ATOM:
758  aproperty->type = BDF_PROPERTY_TYPE_ATOM;
759  aproperty->u.atom = prop->value.atom;
760  break;
761 
762  case BDF_INTEGER:
763  if ( prop->value.l > 0x7FFFFFFFL || prop->value.l < ( -1 - 0x7FFFFFFFL ) )
764  {
765  FT_TRACE1(( "bdf_get_bdf_property:"
766  " too large integer 0x%x is truncated\n" ));
767  }
768  aproperty->type = BDF_PROPERTY_TYPE_INTEGER;
769  aproperty->u.integer = (FT_Int32)prop->value.l;
770  break;
771 
772  case BDF_CARDINAL:
773  if ( prop->value.ul > 0xFFFFFFFFUL )
774  {
775  FT_TRACE1(( "bdf_get_bdf_property:"
776  " too large cardinal 0x%x is truncated\n" ));
777  }
778  aproperty->type = BDF_PROPERTY_TYPE_CARDINAL;
779  aproperty->u.cardinal = (FT_UInt32)prop->value.ul;
780  break;
781 
782  default:
783  goto Fail;
784  }
785  return 0;
786  }
787 
788  Fail:
789  return FT_THROW( Invalid_Argument );
790  }
791 
792 
793  static FT_Error
794  bdf_get_charset_id( BDF_Face face,
795  const char* *acharset_encoding,
796  const char* *acharset_registry )
797  {
798  *acharset_encoding = face->charset_encoding;
799  *acharset_registry = face->charset_registry;
800 
801  return 0;
802  }
803 
804 
805  static const FT_Service_BDFRec bdf_service_bdf =
806  {
807  (FT_BDF_GetCharsetIdFunc)bdf_get_charset_id,
808  (FT_BDF_GetPropertyFunc) bdf_get_bdf_property
809  };
810 
811 
812  /*
813  *
814  * SERVICES LIST
815  *
816  */
817 
818  static const FT_ServiceDescRec bdf_services[] =
819  {
820  { FT_SERVICE_ID_BDF, &bdf_service_bdf },
822  { NULL, NULL }
823  };
824 
825 
828  const char* name )
829  {
830  FT_UNUSED( module );
831 
832  return ft_service_list_lookup( bdf_services, name );
833  }
834 
835 
836 
839  {
840  {
843  sizeof ( FT_DriverRec ),
844 
845  "bdf",
846  0x10000L,
847  0x20000L,
848 
849  0,
850 
851  0, /* FT_Module_Constructor */
852  0, /* FT_Module_Destructor */
854  },
855 
856  sizeof ( BDF_FaceRec ),
857  sizeof ( FT_SizeRec ),
858  sizeof ( FT_GlyphSlotRec ),
859 
862  0, /* FT_Size_InitFunc */
863  0, /* FT_Size_DoneFunc */
864  0, /* FT_Slot_InitFunc */
865  0, /* FT_Slot_DoneFunc */
866 
867 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
868  ft_stub_set_char_sizes,
869  ft_stub_set_pixel_sizes,
870 #endif
872 
873  0, /* FT_Face_GetKerningFunc */
874  0, /* FT_Face_AttachFunc */
875  0, /* FT_Face_GetAdvancesFunc */
876 
879  };
880 
881 
882 /* END */
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:260
#define FT_UINT_MAX
Definition: ftstdlib.h:66
GLint GLint GLsizei GLsizei height
ft_glyphslot_set_bitmap(FT_GlyphSlot slot, FT_Byte *buffer)
Definition: ftobjs.c:294
ft_service_list_lookup(FT_ServiceDesc service_descriptors, const char *service_id)
Definition: ftobjs.c:58
int FT_Error
Definition: fttypes.h:296
unsigned long unencoded_size
Definition: bdf.h:214
GLuint GLuint stream
signed long FT_Long
Definition: fttypes.h:238
FT_Pos x_ppem
Definition: freetype.h:305
char * charset_encoding
Definition: bdfdrivr.h:56
FT_BEGIN_HEADER struct BDF_encoding_el_ BDF_encoding_el
unsigned long FT_ULong
Definition: fttypes.h:249
FT_Short width
Definition: freetype.h:301
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:59
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2542
BDF_Glyph_Load(FT_GlyphSlot slot, FT_Size size, FT_UInt glyph_index, FT_Int32 load_flags)
Definition: bdfdrivr.c:656
#define FT_CMAP_FACE(x)
Definition: ftobjs.h:145
FT_CALLBACK_TABLE_DEF const FT_Driver_ClassRec bdf_driver_class
Definition: bdfdrivr.c:838
FT_Select_Metrics(FT_Face face, FT_ULong strike_index)
Definition: ftobjs.c:2602
#define TT_ADOBE_ID_STANDARD
Definition: ttnameid.h:309
#define FT_MEM_ZERO(dest, count)
Definition: ftmemory.h:208
FT_UInt default_glyph
Definition: bdfdrivr.h:66
#define FT_FACE_FLAG_FAST_GLYPHS
Definition: freetype.h:1083
#define NULL
Definition: ftobjs.h:61
signed int FT_Int
Definition: fttypes.h:216
int rows
Definition: ftimage.h:312
#define FT_REQUEST_HEIGHT(req)
Definition: ftobjs.h:621
BDF_Size_Request(FT_Size size, FT_Size_Request req)
Definition: bdfdrivr.c:616
GLsizei const GLchar *const * strings
FT_Short height
Definition: freetype.h:300
int format
Definition: bdf.h:112
long font_ascent
Definition: bdf.h:207
return FT_THROW(Missing_Property)
#define FT_UNUSED(arg)
Definition: ftconfig.h:76
#define BDF_CARDINAL
Definition: bdf.h:104
#define BDF_INTEGER
Definition: bdf.h:103
FT_String * style_name
Definition: freetype.h:930
FT_UShort platform_id
Definition: freetype.h:744
FT_Bitmap_Size * available_sizes
Definition: freetype.h:933
unsigned int FT_UInt32
Definition: ftconfig.h:133
#define FT_FACE_FLAG_FIXED_SIZES
Definition: freetype.h:1077
FT_Error(* FT_BDF_GetCharsetIdFunc)(FT_Face face, const char **acharset_encoding, const char **acharset_registry)
Definition: svbdf.h:32
struct FT_SizeRec_ FT_SizeRec
bdf_free_font(bdf_font_t *font)
Definition: bdflib.c:2523
int pitch
Definition: ftimage.h:314
return FT_Err_Ok
Definition: ftbbox.c:645
bdf_driver_requester(FT_Module module, const char *name)
Definition: bdfdrivr.c:827
#define FT_XF86_FORMAT_BDF
Definition: svxf86nm.h:38
BDF_Face_Done(FT_Face bdfface)
Definition: bdfdrivr.c:312
#define FT_SERVICE_ID_BDF
Definition: svbdf.h:29
#define TT_PLATFORM_MICROSOFT
Definition: ttnameid.h:89
bdf_get_font_property(bdf_font_t *font, const char *name)
Definition: bdflib.c:2604
BDF_Size_Select(FT_Size size, FT_ULong strike_index)
Definition: bdfdrivr.c:599
#define BDF_ATOM
Definition: bdf.h:102
bdf_cmap_init(FT_CMap bdfcmap, FT_Pointer init_data)
Definition: bdfdrivr.c:64
bdf_bbx_t bbx
Definition: bdf.h:152
FT_UShort encoding_id
Definition: freetype.h:745
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:104
FT_Face face
Definition: freetype.h:742
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
GLenum GLuint GLint GLenum face
#define const
Definition: zconf.h:91
#define FT_ASSERT(condition)
Definition: ftdebug.h:211
#define FT_STYLE_FLAG_BOLD
Definition: freetype.h:1297
bdf_cmap_char_index(FT_CMap bdfcmap, FT_UInt32 charcode)
Definition: bdfdrivr.c:91
#define FT_TRACE4(varformat)
Definition: ftdebug.h:161
struct BDF_CMapRec_ * BDF_CMap
FT_Int32 integer
Definition: ftbdf.h:122
int correct_metrics
Definition: bdf.h:79
unsigned short dwidth
Definition: bdf.h:151
unsigned long ul
Definition: bdf.h:118
struct BDF_FaceRec_ * BDF_Face
unsigned short bpp
Definition: bdf.h:235
#define FT_FREE(ptr)
Definition: ftmemory.h:286
#define FT_FACE_FLAG_FIXED_WIDTH
Definition: freetype.h:1078
GLenum GLsizei len
long default_char
Definition: bdf.h:205
unsigned long glyphs_size
Definition: bdf.h:210
#define FT_ERR(e)
Definition: fttypes.h:582
FT_Error error
Definition: cffdrivr.c:411
#define FT_SERVICE_ID_XF86_NAME
Definition: svxf86nm.h:34
void * FT_Pointer
Definition: fttypes.h:307
short x_offset
Definition: bdf.h:137
#define FT_FACE_FLAG_HORIZONTAL
Definition: freetype.h:1080
long font_descent
Definition: bdf.h:208
long l
Definition: bdf.h:117
unsigned long bpr
Definition: bdf.h:154
int keep_unencoded
Definition: bdf.h:80
float min(float a, float b)
Definition: Vector2.hpp:307
const char * atom
Definition: ftbdf.h:121
FT_Pointer FT_Module_Interface
Definition: ftmodapi.h:106
char * atom
Definition: bdf.h:116
GLdouble n
#define FT_TRACE2(varformat)
Definition: ftdebug.h:159
short num_grays
Definition: ftimage.h:316
#define TT_PLATFORM_ADOBE
Definition: ttnameid.h:91
#define FT_ERR_EQ(x, e)
Definition: fttypes.h:587
signed int FT_Int32
Definition: ftconfig.h:132
GLenum src
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:323
bdf_cmap_done(FT_CMap bdfcmap)
Definition: bdfdrivr.c:80
FT_Encoding encoding
Definition: freetype.h:743
unsigned long unencoded_used
Definition: bdf.h:215
#define FT_MODULE_FONT_DRIVER
Definition: ftmodapi.h:82
BDF_PropertyType type
Definition: ftbdf.h:119
signed short FT_Short
Definition: fttypes.h:194
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
int width
Definition: ftimage.h:313
char * charset_registry
Definition: bdfdrivr.h:57
local int max
Definition: enough.c:170
FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec bdf_cmap_class
Definition: bdfdrivr.c:186
bdf_font_t * bdffont
Definition: bdfdrivr.h:59
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:290
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:489
FT_Error(* FT_BDF_GetPropertyFunc)(FT_Face face, const char *prop_name, BDF_PropertyRec *aproperty)
Definition: svbdf.h:37
GLuint const GLchar * name
if(!abbox) return FT_THROW(Invalid_Argument)
#define FT_CALLBACK_TABLE_DEF
Definition: ftconfig.h:333
#define FT_FACE_MEMORY(x)
Definition: ftobjs.h:563
FT_CMap_New(FT_CMap_Class clazz, FT_Pointer init_data, FT_CharMap charmap, FT_CMap *acmap)
Definition: ftobjs.c:3248
typedef int
Definition: png.h:978
bdf_load_font(FT_Stream stream, FT_Memory memory, bdf_options_t *opts, bdf_font_t **font)
Definition: bdflib.c:2365
GLenum const GLfloat * params
#define BDF_PROPORTIONAL
Definition: bdf.h:63
#define FT_FACE(x)
Definition: ftobjs.h:557
FT_Long num_glyphs
Definition: freetype.h:927
GLuint64EXT * result
unsigned int FT_UInt
Definition: fttypes.h:227
unsigned short height
Definition: bdf.h:135
#define FT_SIZE_FACE(x)
Definition: ftobjs.h:566
short ascent
Definition: bdf.h:140
GLdouble s
char pixel_mode
Definition: ftimage.h:317
FT_Long style_flags
Definition: freetype.h:925
bdf_glyph_t * glyphs
Definition: bdf.h:212
#define TT_PLATFORM_APPLE_UNICODE
Definition: ttnameid.h:86
GLsizei GLenum GLenum GLuint GLenum GLsizei * lengths
struct BDF_CMapRec_ BDF_CMapRec
unsigned short width
Definition: bdf.h:134
FT_Pos y_ppem
Definition: freetype.h:306
BDF_Face_Init(FT_Stream stream, FT_Face bdfface, FT_Int face_index, FT_Int num_params, FT_Parameter *params)
Definition: bdfdrivr.c:339
#define TT_MS_ID_UNICODE_CS
Definition: ttnameid.h:280
#define FT_MODULE_DRIVER_NO_OUTLINES
Definition: ftmodapi.h:89
#define FT_STRDUP(dst, str)
Definition: ftmemory.h:351
unsigned long glyphs_used
Definition: bdf.h:211
struct FT_DriverRec_ FT_DriverRec
int font_spacing
Definition: bdf.h:82
local int * code
Definition: enough.c:174
#define FT_STYLE_FLAG_ITALIC
Definition: freetype.h:1296
unsigned short FT_UShort
Definition: fttypes.h:205
#define ft_memcpy
Definition: ftstdlib.h:81
GLsizeiptr size
bdf_cmap_char_next(FT_CMap bdfcmap, FT_UInt32 *acharcode)
Definition: bdfdrivr.c:130
unsigned char * bitmap
Definition: bdf.h:153
#define ft_strlen
Definition: ftstdlib.h:87
#define TT_APPLE_ID_DEFAULT
Definition: ttnameid.h:124
FT_Memory memory
Definition: freetype.h:963
BDF_encoding_el * en_table
Definition: bdfdrivr.h:61
#define ft_strcmp
Definition: ftstdlib.h:85
bdf_bbx_t bbx
Definition: bdf.h:195
union BDF_PropertyRec_::@0 u
int keep_comments
Definition: bdf.h:81
union bdf_property_t_::@7 value
FT_UInt32 cardinal
Definition: ftbdf.h:123