ReactOS  0.4.14-dev-358-gbef841c
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, 2014 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_FONT_FORMAT_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  {
57  FT_ULong num_encodings; /* ftobjs.h: FT_CMap->clazz->size */
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 = (FT_ULong)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 = (FT_ULong)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 = (FT_ULong)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 
185  static
187  {
188  sizeof ( BDF_CMapRec ),
193 
194  NULL, NULL, NULL, NULL, NULL
195  };
196 
197 
198  static FT_Error
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  {
219  face->style_flags |= FT_STYLE_FLAG_ITALIC;
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  {
230  face->style_flags |= FT_STYLE_FLAG_BOLD;
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  for ( len = 0, nn = 0; nn < 4; nn++ )
247  {
248  lengths[nn] = 0;
249  if ( strings[nn] )
250  {
251  lengths[nn] = ft_strlen( strings[nn] );
252  len += lengths[nn] + 1;
253  }
254  }
255 
256  if ( len == 0 )
257  {
258  strings[0] = (char *)"Regular";
259  lengths[0] = ft_strlen( strings[0] );
260  len = lengths[0] + 1;
261  }
262 
263  {
264  char* s;
265 
266 
267  if ( FT_ALLOC( face->style_name, len ) )
268  return error;
269 
270  s = face->style_name;
271 
272  for ( nn = 0; nn < 4; nn++ )
273  {
274  char* src = strings[nn];
275 
276 
277  len = lengths[nn];
278 
279  if ( !src )
280  continue;
281 
282  /* separate elements with a space */
283  if ( s != face->style_name )
284  *s++ = ' ';
285 
286  ft_memcpy( s, src, len );
287 
288  /* need to convert spaces to dashes for */
289  /* add_style_name and setwidth_name */
290  if ( nn == 0 || nn == 3 )
291  {
292  size_t mm;
293 
294 
295  for ( mm = 0; mm < len; mm++ )
296  if ( s[mm] == ' ' )
297  s[mm] = '-';
298  }
299 
300  s += len;
301  }
302  *s = 0;
303  }
304 
305  return error;
306  }
307 
308 
309  FT_CALLBACK_DEF( void )
310  BDF_Face_Done( FT_Face bdfface ) /* BDF_Face */
311  {
312  BDF_Face face = (BDF_Face)bdfface;
314 
315 
316  if ( !face )
317  return;
318 
320 
321  bdf_free_font( face->bdffont );
322 
323  FT_FREE( face->en_table );
324 
325  FT_FREE( face->charset_encoding );
326  FT_FREE( face->charset_registry );
327  FT_FREE( bdfface->family_name );
328  FT_FREE( bdfface->style_name );
329 
330  FT_FREE( bdfface->available_sizes );
331 
332  FT_FREE( face->bdffont );
333  }
334 
335 
338  FT_Face bdfface, /* BDF_Face */
339  FT_Int face_index,
340  FT_Int num_params,
342  {
344  BDF_Face face = (BDF_Face)bdfface;
346 
347  bdf_font_t* font = NULL;
349 
350  FT_UNUSED( num_params );
351  FT_UNUSED( params );
352 
353 
354  FT_TRACE2(( "BDF driver\n" ));
355 
356  if ( FT_STREAM_SEEK( 0 ) )
357  goto Exit;
358 
359  options.correct_metrics = 1; /* FZ XXX: options semantics */
360  options.keep_unencoded = 1;
361  options.keep_comments = 0;
362  options.font_spacing = BDF_PROPORTIONAL;
363 
365  if ( FT_ERR_EQ( error, Missing_Startfont_Field ) )
366  {
367  FT_TRACE2(( " not a BDF file\n" ));
368  goto Fail;
369  }
370  else if ( error )
371  goto Exit;
372 
373  /* we have a bdf font: let's construct the face object */
374  face->bdffont = font;
375 
376  /* BDF cannot have multiple faces in a single font file.
377  * XXX: non-zero face_index is already invalid argument, but
378  * Type1, Type42 driver has a convention to return
379  * an invalid argument error when the font could be
380  * opened by the specified driver.
381  */
382  if ( face_index > 0 && ( face_index & 0xFFFF ) > 0 )
383  {
384  FT_ERROR(( "BDF_Face_Init: invalid face index\n" ));
385  BDF_Face_Done( bdfface );
386  return FT_THROW( Invalid_Argument );
387  }
388 
389  {
390  bdf_property_t* prop = NULL;
391 
392 
393  FT_TRACE4(( " number of glyphs: allocated %d (used %d)\n",
394  font->glyphs_size,
395  font->glyphs_used ));
396  FT_TRACE4(( " number of unencoded glyphs: allocated %d (used %d)\n",
397  font->unencoded_size,
398  font->unencoded_used ));
399 
400  bdfface->num_faces = 1;
401  bdfface->face_index = 0;
402 
403  bdfface->face_flags |= FT_FACE_FLAG_FIXED_SIZES |
406 
407  prop = bdf_get_font_property( font, "SPACING" );
408  if ( prop && prop->format == BDF_ATOM &&
409  prop->value.atom &&
410  ( *(prop->value.atom) == 'M' || *(prop->value.atom) == 'm' ||
411  *(prop->value.atom) == 'C' || *(prop->value.atom) == 'c' ) )
412  bdfface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
413 
414  /* FZ XXX: TO DO: FT_FACE_FLAGS_VERTICAL */
415  /* FZ XXX: I need a font to implement this */
416 
417  prop = bdf_get_font_property( font, "FAMILY_NAME" );
418  if ( prop && prop->value.atom )
419  {
420  if ( FT_STRDUP( bdfface->family_name, prop->value.atom ) )
421  goto Exit;
422  }
423  else
424  bdfface->family_name = NULL;
425 
427  goto Exit;
428 
429  /* the number of glyphs (with one slot for the undefined glyph */
430  /* at position 0 and all unencoded glyphs) */
431  bdfface->num_glyphs = (FT_Long)( font->glyphs_size + 1 );
432 
433  bdfface->num_fixed_sizes = 1;
434  if ( FT_NEW_ARRAY( bdfface->available_sizes, 1 ) )
435  goto Exit;
436 
437  {
438  FT_Bitmap_Size* bsize = bdfface->available_sizes;
439  FT_Short resolution_x = 0, resolution_y = 0;
440  long value;
441 
442 
443  FT_ZERO( bsize );
444 
445  /* sanity checks */
446  if ( font->font_ascent > 0x7FFF || font->font_ascent < -0x7FFF )
447  {
448  font->font_ascent = font->font_ascent < 0 ? -0x7FFF : 0x7FFF;
449  FT_TRACE0(( "BDF_Face_Init: clamping font ascent to value %d\n",
450  font->font_ascent ));
451  }
452  if ( font->font_descent > 0x7FFF || font->font_descent < -0x7FFF )
453  {
454  font->font_descent = font->font_descent < 0 ? -0x7FFF : 0x7FFF;
455  FT_TRACE0(( "BDF_Face_Init: clamping font descent to value %d\n",
456  font->font_descent ));
457  }
458 
459  bsize->height = (FT_Short)( font->font_ascent + font->font_descent );
460 
461  prop = bdf_get_font_property( font, "AVERAGE_WIDTH" );
462  if ( prop )
463  {
464 #ifdef FT_DEBUG_LEVEL_TRACE
465  if ( prop->value.l < 0 )
466  FT_TRACE0(( "BDF_Face_Init: negative average width\n" ));
467 #endif
468  if ( prop->value.l > 0x7FFFL * 10 - 5 ||
469  prop->value.l < -( 0x7FFFL * 10 - 5 ) )
470  {
471  bsize->width = 0x7FFF;
472  FT_TRACE0(( "BDF_Face_Init: clamping average width to value %d\n",
473  bsize->width ));
474  }
475  else
476  bsize->width = FT_ABS( (FT_Short)( ( prop->value.l + 5 ) / 10 ) );
477  }
478  else
479  {
480  /* this is a heuristical value */
481  bsize->width = (FT_Short)FT_MulDiv( bsize->height, 2, 3 );
482  }
483 
484  prop = bdf_get_font_property( font, "POINT_SIZE" );
485  if ( prop )
486  {
487 #ifdef FT_DEBUG_LEVEL_TRACE
488  if ( prop->value.l < 0 )
489  FT_TRACE0(( "BDF_Face_Init: negative point size\n" ));
490 #endif
491  /* convert from 722.7 decipoints to 72 points per inch */
492  if ( prop->value.l > 0x504C2L || /* 0x7FFF * 72270/7200 */
493  prop->value.l < -0x504C2L )
494  {
495  bsize->size = 0x7FFF;
496  FT_TRACE0(( "BDF_Face_Init: clamping point size to value %d\n",
497  bsize->size ));
498  }
499  else
500  bsize->size = FT_MulDiv( FT_ABS( prop->value.l ),
501  64 * 7200,
502  72270L );
503  }
504  else if ( font->point_size )
505  {
506  if ( font->point_size > 0x7FFF )
507  {
508  bsize->size = 0x7FFF;
509  FT_TRACE0(( "BDF_Face_Init: clamping point size to value %d\n",
510  bsize->size ));
511  }
512  else
513  bsize->size = (FT_Pos)font->point_size << 6;
514  }
515  else
516  {
517  /* this is a heuristical value */
518  bsize->size = bsize->width * 64;
519  }
520 
521  prop = bdf_get_font_property( font, "PIXEL_SIZE" );
522  if ( prop )
523  {
524 #ifdef FT_DEBUG_LEVEL_TRACE
525  if ( prop->value.l < 0 )
526  FT_TRACE0(( "BDF_Face_Init: negative pixel size\n" ));
527 #endif
528  if ( prop->value.l > 0x7FFF || prop->value.l < -0x7FFF )
529  {
530  bsize->y_ppem = 0x7FFF << 6;
531  FT_TRACE0(( "BDF_Face_Init: clamping pixel size to value %d\n",
532  bsize->y_ppem ));
533  }
534  else
535  bsize->y_ppem = FT_ABS( (FT_Short)prop->value.l ) << 6;
536  }
537 
538  prop = bdf_get_font_property( font, "RESOLUTION_X" );
539  if ( prop )
540  value = prop->value.l;
541  else
542  value = (long)font->resolution_x;
543  if ( value )
544  {
545 #ifdef FT_DEBUG_LEVEL_TRACE
546  if ( value < 0 )
547  FT_TRACE0(( "BDF_Face_Init: negative X resolution\n" ));
548 #endif
549  if ( value > 0x7FFF || value < -0x7FFF )
550  {
551  resolution_x = 0x7FFF;
552  FT_TRACE0(( "BDF_Face_Init: clamping X resolution to value %d\n",
553  resolution_x ));
554  }
555  else
556  resolution_x = FT_ABS( (FT_Short)value );
557  }
558 
559  prop = bdf_get_font_property( font, "RESOLUTION_Y" );
560  if ( prop )
561  value = prop->value.l;
562  else
563  value = (long)font->resolution_y;
564  if ( value )
565  {
566 #ifdef FT_DEBUG_LEVEL_TRACE
567  if ( value < 0 )
568  FT_TRACE0(( "BDF_Face_Init: negative Y resolution\n" ));
569 #endif
570  if ( value > 0x7FFF || value < -0x7FFF )
571  {
572  resolution_y = 0x7FFF;
573  FT_TRACE0(( "BDF_Face_Init: clamping Y resolution to value %d\n",
574  resolution_y ));
575  }
576  else
577  resolution_y = FT_ABS( (FT_Short)value );
578  }
579 
580  if ( bsize->y_ppem == 0 )
581  {
582  bsize->y_ppem = bsize->size;
583  if ( resolution_y )
584  bsize->y_ppem = FT_MulDiv( bsize->y_ppem, resolution_y, 72 );
585  }
586  if ( resolution_x && resolution_y )
587  bsize->x_ppem = FT_MulDiv( bsize->y_ppem,
588  resolution_x,
589  resolution_y );
590  else
591  bsize->x_ppem = bsize->y_ppem;
592  }
593 
594  /* encoding table */
595  {
596  bdf_glyph_t* cur = font->glyphs;
597  unsigned long n;
598 
599 
600  if ( FT_NEW_ARRAY( face->en_table, font->glyphs_size ) )
601  goto Exit;
602 
603  face->default_glyph = 0;
604  for ( n = 0; n < font->glyphs_size; n++ )
605  {
606  (face->en_table[n]).enc = cur[n].encoding;
607  FT_TRACE4(( " idx %d, val 0x%lX\n", n, cur[n].encoding ));
608  (face->en_table[n]).glyph = (FT_UShort)n;
609 
610  if ( cur[n].encoding == font->default_char )
611  {
612  if ( n < FT_UINT_MAX )
613  face->default_glyph = (FT_UInt)n;
614  else
615  FT_TRACE1(( "BDF_Face_Init:"
616  " idx %d is too large for this system\n", n ));
617  }
618  }
619  }
620 
621  /* charmaps */
622  {
623  bdf_property_t *charset_registry, *charset_encoding;
624  FT_Bool unicode_charmap = 0;
625 
626 
627  charset_registry =
628  bdf_get_font_property( font, "CHARSET_REGISTRY" );
629  charset_encoding =
630  bdf_get_font_property( font, "CHARSET_ENCODING" );
631  if ( charset_registry && charset_encoding )
632  {
633  if ( charset_registry->format == BDF_ATOM &&
634  charset_encoding->format == BDF_ATOM &&
635  charset_registry->value.atom &&
636  charset_encoding->value.atom )
637  {
638  const char* s;
639 
640 
641  if ( FT_STRDUP( face->charset_encoding,
642  charset_encoding->value.atom ) ||
643  FT_STRDUP( face->charset_registry,
644  charset_registry->value.atom ) )
645  goto Exit;
646 
647  /* Uh, oh, compare first letters manually to avoid dependency */
648  /* on locales. */
649  s = face->charset_registry;
650  if ( ( s[0] == 'i' || s[0] == 'I' ) &&
651  ( s[1] == 's' || s[1] == 'S' ) &&
652  ( s[2] == 'o' || s[2] == 'O' ) )
653  {
654  s += 3;
655  if ( !ft_strcmp( s, "10646" ) ||
656  ( !ft_strcmp( s, "8859" ) &&
657  !ft_strcmp( face->charset_encoding, "1" ) ) )
658  unicode_charmap = 1;
659  /* another name for ASCII */
660  else if ( !ft_strcmp( s, "646.1991" ) &&
661  !ft_strcmp( face->charset_encoding, "IRV" ) )
662  unicode_charmap = 1;
663  }
664 
665  {
666  FT_CharMapRec charmap;
667 
668 
669  charmap.face = FT_FACE( face );
670  charmap.encoding = FT_ENCODING_NONE;
671  /* initial platform/encoding should indicate unset status? */
674 
675  if ( unicode_charmap )
676  {
677  charmap.encoding = FT_ENCODING_UNICODE;
680  }
681 
682  error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
683  }
684 
685  goto Exit;
686  }
687  }
688 
689  /* otherwise assume Adobe standard encoding */
690 
691  {
692  FT_CharMapRec charmap;
693 
694 
695  charmap.face = FT_FACE( face );
696  charmap.encoding = FT_ENCODING_ADOBE_STANDARD;
697  charmap.platform_id = TT_PLATFORM_ADOBE;
699 
700  error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
701 
702  /* Select default charmap */
703  if ( bdfface->num_charmaps )
704  bdfface->charmap = bdfface->charmaps[0];
705  }
706  }
707  }
708 
709  Exit:
710  return error;
711 
712  Fail:
713  BDF_Face_Done( bdfface );
714  return FT_THROW( Unknown_File_Format );
715  }
716 
717 
720  FT_ULong strike_index )
721  {
722  bdf_font_t* bdffont = ( (BDF_Face)size->face )->bdffont;
723 
724 
725  FT_Select_Metrics( size->face, strike_index );
726 
727  size->metrics.ascender = bdffont->font_ascent * 64;
728  size->metrics.descender = -bdffont->font_descent * 64;
729  size->metrics.max_advance = bdffont->bbx.width * 64;
730 
731  return FT_Err_Ok;
732  }
733 
734 
737  FT_Size_Request req )
738  {
739  FT_Face face = size->face;
740  FT_Bitmap_Size* bsize = face->available_sizes;
741  bdf_font_t* bdffont = ( (BDF_Face)face )->bdffont;
742  FT_Error error = FT_ERR( Invalid_Pixel_Size );
743  FT_Long height;
744 
745 
746  height = FT_REQUEST_HEIGHT( req );
747  height = ( height + 32 ) >> 6;
748 
749  switch ( req->type )
750  {
752  if ( height == ( ( bsize->y_ppem + 32 ) >> 6 ) )
753  error = FT_Err_Ok;
754  break;
755 
757  if ( height == ( bdffont->font_ascent +
758  bdffont->font_descent ) )
759  error = FT_Err_Ok;
760  break;
761 
762  default:
763  error = FT_THROW( Unimplemented_Feature );
764  break;
765  }
766 
767  if ( error )
768  return error;
769  else
770  return BDF_Size_Select( size, 0 );
771  }
772 
773 
774 
777  FT_Size size,
778  FT_UInt glyph_index,
779  FT_Int32 load_flags )
780  {
782  FT_Face face = FT_FACE( bdf );
784  FT_Bitmap* bitmap = &slot->bitmap;
785  bdf_glyph_t glyph;
786  int bpp = bdf->bdffont->bpp;
787 
788  FT_UNUSED( load_flags );
789 
790 
791  if ( !face )
792  {
793  error = FT_THROW( Invalid_Face_Handle );
794  goto Exit;
795  }
796 
797  if ( glyph_index >= (FT_UInt)face->num_glyphs )
798  {
799  error = FT_THROW( Invalid_Argument );
800  goto Exit;
801  }
802 
803  FT_TRACE1(( "BDF_Glyph_Load: glyph index %d\n", glyph_index ));
804 
805  /* index 0 is the undefined glyph */
806  if ( glyph_index == 0 )
807  glyph_index = bdf->default_glyph;
808  else
809  glyph_index--;
810 
811  /* slot, bitmap => freetype, glyph => bdflib */
812  glyph = bdf->bdffont->glyphs[glyph_index];
813 
814  bitmap->rows = glyph.bbx.height;
815  bitmap->width = glyph.bbx.width;
816  if ( glyph.bpr > FT_INT_MAX )
817  FT_TRACE1(( "BDF_Glyph_Load: too large pitch %d is truncated\n",
818  glyph.bpr ));
819  bitmap->pitch = (int)glyph.bpr; /* same as FT_Bitmap.pitch */
820 
821  /* note: we don't allocate a new array to hold the bitmap; */
822  /* we can simply point to it */
824 
825  switch ( bpp )
826  {
827  case 1:
828  bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
829  break;
830  case 2:
831  bitmap->pixel_mode = FT_PIXEL_MODE_GRAY2;
832  break;
833  case 4:
834  bitmap->pixel_mode = FT_PIXEL_MODE_GRAY4;
835  break;
836  case 8:
837  bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
838  bitmap->num_grays = 256;
839  break;
840  }
841 
842  slot->format = FT_GLYPH_FORMAT_BITMAP;
843  slot->bitmap_left = glyph.bbx.x_offset;
844  slot->bitmap_top = glyph.bbx.ascent;
845 
846  slot->metrics.horiAdvance = (FT_Pos)( glyph.dwidth * 64 );
847  slot->metrics.horiBearingX = (FT_Pos)( glyph.bbx.x_offset * 64 );
848  slot->metrics.horiBearingY = (FT_Pos)( glyph.bbx.ascent * 64 );
849  slot->metrics.width = (FT_Pos)( bitmap->width * 64 );
850  slot->metrics.height = (FT_Pos)( bitmap->rows * 64 );
851 
852  /*
853  * XXX DWIDTH1 and VVECTOR should be parsed and
854  * used here, provided such fonts do exist.
855  */
857  bdf->bdffont->bbx.height * 64 );
858 
859  Exit:
860  return error;
861  }
862 
863 
864  /*
865  *
866  * BDF SERVICE
867  *
868  */
869 
870  static FT_Error
872  const char* prop_name,
873  BDF_PropertyRec *aproperty )
874  {
875  bdf_property_t* prop;
876 
877 
878  FT_ASSERT( face && face->bdffont );
879 
880  prop = bdf_get_font_property( face->bdffont, prop_name );
881  if ( prop )
882  {
883  switch ( prop->format )
884  {
885  case BDF_ATOM:
886  aproperty->type = BDF_PROPERTY_TYPE_ATOM;
887  aproperty->u.atom = prop->value.atom;
888  break;
889 
890  case BDF_INTEGER:
891  if ( prop->value.l > 0x7FFFFFFFL || prop->value.l < ( -1 - 0x7FFFFFFFL ) )
892  {
893  FT_TRACE1(( "bdf_get_bdf_property:"
894  " too large integer 0x%x is truncated\n" ));
895  }
896  aproperty->type = BDF_PROPERTY_TYPE_INTEGER;
897  aproperty->u.integer = (FT_Int32)prop->value.l;
898  break;
899 
900  case BDF_CARDINAL:
901  if ( prop->value.ul > 0xFFFFFFFFUL )
902  {
903  FT_TRACE1(( "bdf_get_bdf_property:"
904  " too large cardinal 0x%x is truncated\n" ));
905  }
906  aproperty->type = BDF_PROPERTY_TYPE_CARDINAL;
907  aproperty->u.cardinal = (FT_UInt32)prop->value.ul;
908  break;
909 
910  default:
911  goto Fail;
912  }
913  return 0;
914  }
915 
916  Fail:
917  return FT_THROW( Invalid_Argument );
918  }
919 
920 
921  static FT_Error
923  const char* *acharset_encoding,
924  const char* *acharset_registry )
925  {
926  *acharset_encoding = face->charset_encoding;
927  *acharset_registry = face->charset_registry;
928 
929  return 0;
930  }
931 
932 
933  static const FT_Service_BDFRec bdf_service_bdf =
934  {
935  (FT_BDF_GetCharsetIdFunc)bdf_get_charset_id, /* get_charset_id */
936  (FT_BDF_GetPropertyFunc) bdf_get_bdf_property /* get_property */
937  };
938 
939 
940  /*
941  *
942  * SERVICES LIST
943  *
944  */
945 
947  {
950  { NULL, NULL }
951  };
952 
953 
956  const char* name )
957  {
958  FT_UNUSED( module );
959 
961  }
962 
963 
964 
967  {
968  {
971  sizeof ( FT_DriverRec ),
972 
973  "bdf",
974  0x10000L,
975  0x20000L,
976 
977  NULL, /* module-specific interface */
978 
979  NULL, /* FT_Module_Constructor module_init */
980  NULL, /* FT_Module_Destructor module_done */
981  bdf_driver_requester /* FT_Module_Requester get_interface */
982  },
983 
984  sizeof ( BDF_FaceRec ),
985  sizeof ( FT_SizeRec ),
986  sizeof ( FT_GlyphSlotRec ),
987 
988  BDF_Face_Init, /* FT_Face_InitFunc init_face */
989  BDF_Face_Done, /* FT_Face_DoneFunc done_face */
990  NULL, /* FT_Size_InitFunc init_size */
991  NULL, /* FT_Size_DoneFunc done_size */
992  NULL, /* FT_Slot_InitFunc init_slot */
993  NULL, /* FT_Slot_DoneFunc done_slot */
994 
995  BDF_Glyph_Load, /* FT_Slot_LoadFunc load_glyph */
996 
997  NULL, /* FT_Face_GetKerningFunc get_kerning */
998  NULL, /* FT_Face_AttachFunc attach_file */
999  NULL, /* FT_Face_GetAdvancesFunc get_advances */
1000 
1001  BDF_Size_Request, /* FT_Size_RequestFunc request_size */
1002  BDF_Size_Select /* FT_Size_SelectFunc select_size */
1003  };
1004 
1005 
1006 /* END */
#define TT_APPLE_ID_DEFAULT
Definition: font.c:1176
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:303
#define FT_UINT_MAX
Definition: ftstdlib.h:65
ft_glyphslot_set_bitmap(FT_GlyphSlot slot, FT_Byte *buffer)
Definition: ftobjs.c:466
struct BDF_FaceRec_ BDF_FaceRec
ft_service_list_lookup(FT_ServiceDesc service_descriptors, const char *service_id)
Definition: ftobjs.c:98
int FT_Error
Definition: fttypes.h:300
#define max(a, b)
Definition: svc.c:63
FT_Face face
Definition: freetype.h:842
signed long FT_Long
Definition: fttypes.h:242
FT_BEGIN_HEADER struct BDF_encoding_el_ BDF_encoding_el
unsigned long FT_ULong
Definition: fttypes.h:253
FT_UShort encoding_id
Definition: freetype.h:845
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:58
FT_Pos x_ppem
Definition: freetype.h:378
static FT_Error bdf_get_charset_id(BDF_Face face, const char **acharset_encoding, const char **acharset_registry)
Definition: bdfdrivr.c:922
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2933
uint32 width
Definition: uimain.c:91
BDF_PropertyType type
Definition: ftbdf.h:120
#define error(str)
Definition: mkdosfs.c:1605
BDF_Glyph_Load(FT_GlyphSlot slot, FT_Size size, FT_UInt glyph_index, FT_Int32 load_flags)
Definition: bdfdrivr.c:776
#define FT_CMAP_FACE(x)
Definition: ftobjs.h:165
FT_CALLBACK_TABLE_DEF const FT_Driver_ClassRec bdf_driver_class
Definition: bdfdrivr.c:966
FT_Select_Metrics(FT_Face face, FT_ULong strike_index)
Definition: ftobjs.c:2993
#define TT_ADOBE_ID_STANDARD
Definition: ttnameid.h:281
union BDF_PropertyRec_::@3860 u
Definition: mk_font.cpp:20
#define FT_FACE_FLAG_FAST_GLYPHS
Definition: freetype.h:1245
signed int FT_Int
Definition: fttypes.h:220
#define FT_REQUEST_HEIGHT(req)
Definition: ftobjs.h:694
BDF_Size_Request(FT_Size size, FT_Size_Request req)
Definition: bdfdrivr.c:736
#define FT_ABS(a)
Definition: ftobjs.h:74
int format
Definition: bdf.h:113
static const FT_Service_BDFRec bdf_service_bdf
Definition: bdfdrivr.c:933
long font_ascent
Definition: bdf.h:190
GLdouble n
Definition: glext.h:7729
#define FT_SERVICE_ID_FONT_FORMAT
Definition: svfntfmt.h:34
#define BDF_CARDINAL
Definition: bdf.h:105
#define BDF_INTEGER
Definition: bdf.h:104
#define FT_FACE_FLAG_FIXED_SIZES
Definition: freetype.h:1239
FT_Error(* FT_BDF_GetCharsetIdFunc)(FT_Face face, const char **acharset_encoding, const char **acharset_registry)
Definition: svbdf.h:32
bdf_free_font(bdf_font_t *font)
Definition: bdflib.c:2366
#define TT_MS_ID_UNICODE_CS
Definition: font.c:1181
return FT_Err_Ok
Definition: ftbbox.c:511
FT_ULong num_encodings
Definition: bdfdrivr.c:57
static char memory[1024 *256]
Definition: process.c:116
bdf_driver_requester(FT_Module module, const char *name)
Definition: bdfdrivr.c:955
BDF_Face_Done(FT_Face bdfface)
Definition: bdfdrivr.c:310
#define FT_SERVICE_ID_BDF
Definition: svbdf.h:29
bdf_get_font_property(bdf_font_t *font, const char *name)
Definition: bdflib.c:2447
struct FT_GlyphSlotRec_ FT_GlyphSlotRec
BDF_Size_Select(FT_Size size, FT_ULong strike_index)
Definition: bdfdrivr.c:719
#define BDF_ATOM
Definition: bdf.h:103
bdf_cmap_init(FT_CMap bdfcmap, FT_Pointer init_data)
Definition: bdfdrivr.c:64
bdf_bbx_t bbx
Definition: bdf.h:153
#define TT_PLATFORM_MICROSOFT
Definition: font.c:1174
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
GLenum const GLfloat * params
Definition: glext.h:5645
#define FT_ASSERT(condition)
Definition: ftdebug.h:211
#define FT_THROW(e)
Definition: ftdebug.h:213
#define FT_STYLE_FLAG_BOLD
Definition: freetype.h:1518
static const FT_ServiceDescRec bdf_services[]
Definition: bdfdrivr.c:946
bdf_cmap_char_index(FT_CMap bdfcmap, FT_UInt32 charcode)
Definition: bdfdrivr.c:91
#define FT_TRACE4(varformat)
Definition: ftdebug.h:161
#define TT_PLATFORM_APPLE_UNICODE
Definition: font.c:1172
struct BDF_CMapRec_ * BDF_CMap
smooth NULL
Definition: ftsmooth.c:416
const char * atom
Definition: ftbdf.h:122
static FT_Error bdf_get_bdf_property(BDF_Face face, const char *prop_name, BDF_PropertyRec *aproperty)
Definition: bdfdrivr.c:871
unsigned short dwidth
Definition: bdf.h:152
unsigned long ul
Definition: bdf.h:119
struct BDF_FaceRec_ * BDF_Face
unsigned short bpp
Definition: bdf.h:218
#define FT_FREE(ptr)
Definition: ftmemory.h:329
FT_CMapRec cmap
Definition: bdfdrivr.c:56
#define FT_FACE_FLAG_FIXED_WIDTH
Definition: freetype.h:1240
bdf_font_t * bdffont
Definition: bdfdrivr.h:59
int options
Definition: main.c:106
FT_UInt32 cardinal
Definition: ftbdf.h:124
FT_MulDiv(FT_Long a, FT_Long b, FT_Long c)
Definition: ftcalc.c:416
#define FT_ERR(e)
Definition: fttypes.h:586
Definition: uimain.c:88
#define FT_TRACE0(varformat)
Definition: ftdebug.h:157
FT_Int32 integer
Definition: ftbdf.h:123
GLsizeiptr size
Definition: glext.h:5919
#define FT_ZERO(p)
Definition: ftmemory.h:237
short x_offset
Definition: bdf.h:138
#define FT_FACE_FLAG_HORIZONTAL
Definition: freetype.h:1242
if(!(yy_init))
Definition: macro.lex.yy.c:714
long font_descent
Definition: bdf.h:191
long l
Definition: bdf.h:118
unsigned long bpr
Definition: bdf.h:155
static void Exit(void)
Definition: sock.c:1331
FT_UInt default_glyph
Definition: bdfdrivr.h:66
char * atom
Definition: bdf.h:117
#define FT_TRACE2(varformat)
Definition: ftdebug.h:159
BDF_encoding_el * encodings
Definition: bdfdrivr.c:58
#define TT_PLATFORM_ADOBE
Definition: ttnameid.h:91
#define FT_ERR_EQ(x, e)
Definition: fttypes.h:591
FT_Pos y_ppem
Definition: freetype.h:379
FT_Short width
Definition: freetype.h:374
bdf_cmap_done(FT_CMap bdfcmap)
Definition: bdfdrivr.c:80
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:533
static FT_Error bdf_interpret_style(BDF_Face bdf)
Definition: bdfdrivr.c:199
FT_Encoding encoding
Definition: freetype.h:843
#define FT_MODULE_FONT_DRIVER
Definition: ftmodapi.h:110
GLsizei const GLchar *const * strings
Definition: glext.h:7622
static const WCHAR L[]
Definition: oid.c:1250
Definition: parse.h:22
signed short FT_Short
Definition: fttypes.h:198
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
GLenum GLsizei len
Definition: glext.h:6722
GLdouble s
Definition: gl.h:2039
GLenum src
Definition: glext.h:6340
int code
Definition: i386-dis.c:3591
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:333
GLsizei const GLfloat * value
Definition: glext.h:6069
#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
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
ed encoding
Definition: write.c:2839
Definition: vfat.h:184
#define FT_FACE_MEMORY(x)
Definition: ftobjs.h:636
Definition: hiveinit.c:368
FT_CMap_New(FT_CMap_Class clazz, FT_Pointer init_data, FT_CharMap charmap, FT_CMap *acmap)
Definition: ftobjs.c:3614
bdf_load_font(FT_Stream stream, FT_Memory memory, bdf_options_t *opts, bdf_font_t **font)
Definition: bdflib.c:2207
#define BDF_PROPORTIONAL
Definition: bdf.h:64
FT_UShort platform_id
Definition: freetype.h:844
#define FT_FACE(x)
Definition: ftobjs.h:630
#define FT_SET_ERROR(expression)
Definition: ftmemory.h:42
unsigned int FT_UInt
Definition: fttypes.h:231
unsigned short height
Definition: bdf.h:136
#define long
Definition: qsort.c:33
#define FT_SIZE_FACE(x)
Definition: ftobjs.h:639
short ascent
Definition: bdf.h:141
#define min(a, b)
Definition: monoChain.cc:55
bdf_glyph_t * glyphs
Definition: bdf.h:195
Definition: name.c:36
struct BDF_CMapRec_ BDF_CMapRec
unsigned short width
Definition: bdf.h:135
BDF_Face_Init(FT_Stream stream, FT_Face bdfface, FT_Int face_index, FT_Int num_params, FT_Parameter *params)
Definition: bdfdrivr.c:337
#define FT_MODULE_DRIVER_NO_OUTLINES
Definition: ftmodapi.h:117
static const FT_CMap_ClassRec bdf_cmap_class
Definition: bdfdrivr.c:186
#define FT_INT_MAX
Definition: ftstdlib.h:63
#define const
Definition: zconf.h:230
#define FT_STRDUP(dst, str)
Definition: ftmemory.h:364
struct FT_DriverRec_ FT_DriverRec
DWORD bpp
Definition: surface.c:181
#define FT_STYLE_FLAG_ITALIC
Definition: freetype.h:1517
unsigned short FT_UShort
Definition: fttypes.h:209
GLsizei GLenum GLenum GLuint GLenum GLsizei * lengths
Definition: glext.h:7753
GLuint64EXT * result
Definition: glext.h:11304
#define ft_memcpy
Definition: ftstdlib.h:82
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
bdf_cmap_char_next(FT_CMap bdfcmap, FT_UInt32 *acharcode)
Definition: bdfdrivr.c:130
unsigned char * bitmap
Definition: bdf.h:154
#define ft_strlen
Definition: ftstdlib.h:88
#define FT_FONT_FORMAT_BDF
Definition: svfntfmt.h:38
FT_Short height
Definition: freetype.h:373
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
union bdf_property_t_::@3864 value
#define FT_CALLBACK_TABLE_DEF
Definition: ftconfig.h:553
#define ft_strcmp
Definition: ftstdlib.h:86
bdf_bbx_t bbx
Definition: bdf.h:178
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31