source: trunk/poppler/freetype2/src/bdf/bdfdrivr.c @ 251

Last change on this file since 251 was 251, checked in by Eugene Romanenko, 13 years ago

PDF plugin: freetype library updated to version 2.3.5

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