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

Last change on this file since 262 was 262, checked in by Eugene Romanenko, 12 years ago

PDF plugin: freetype library updated to version 2.3.8

File size: 23.1 KB
Line 
1/*  bdfdrivr.c
2
3    FreeType font driver for bdf files
4
5    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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;
309
310
311    if ( !face )
312      return;
313
314    memory = FT_FACE_MEMORY( face );
315
316    bdf_free_font( face->bdffont );
317
318    FT_FREE( face->en_table );
319
320    FT_FREE( face->charset_encoding );
321    FT_FREE( face->charset_registry );
322    FT_FREE( bdfface->family_name );
323    FT_FREE( bdfface->style_name );
324
325    FT_FREE( bdfface->available_sizes );
326
327    FT_FREE( face->bdffont );
328
329    FT_TRACE4(( "BDF_Face_Done: done face\n" ));
330  }
331
332
333  FT_CALLBACK_DEF( FT_Error )
334  BDF_Face_Init( FT_Stream      stream,
335                 FT_Face        bdfface,        /* BDF_Face */
336                 FT_Int         face_index,
337                 FT_Int         num_params,
338                 FT_Parameter*  params )
339  {
340    FT_Error       error  = BDF_Err_Ok;
341    BDF_Face       face   = (BDF_Face)bdfface;
342    FT_Memory      memory = FT_FACE_MEMORY( face );
343
344    bdf_font_t*    font = NULL;
345    bdf_options_t  options;
346
347    FT_UNUSED( num_params );
348    FT_UNUSED( params );
349    FT_UNUSED( face_index );
350
351
352    if ( FT_STREAM_SEEK( 0 ) )
353      goto Exit;
354
355    options.correct_metrics = 1;   /* FZ XXX: options semantics */
356    options.keep_unencoded  = 1;
357    options.keep_comments   = 0;
358    options.font_spacing    = BDF_PROPORTIONAL;
359
360    error = bdf_load_font( stream, memory, &options, &font );
361    if ( error == BDF_Err_Missing_Startfont_Field )
362    {
363      FT_TRACE2(( "[not a valid BDF file]\n" ));
364      goto Fail;
365    }
366    else if ( error )
367      goto Exit;
368
369    /* we have a bdf font: let's construct the face object */
370    face->bdffont = font;
371    {
372      bdf_property_t*  prop = NULL;
373
374
375      FT_TRACE4(( "number of glyphs: %d (%d)\n",
376                  font->glyphs_size,
377                  font->glyphs_used ));
378      FT_TRACE4(( "number of unencoded glyphs: %d (%d)\n",
379                  font->unencoded_size,
380                  font->unencoded_used ));
381
382      bdfface->num_faces  = 1;
383      bdfface->face_index = 0;
384      bdfface->face_flags = FT_FACE_FLAG_FIXED_SIZES |
385                            FT_FACE_FLAG_HORIZONTAL  |
386                            FT_FACE_FLAG_FAST_GLYPHS;
387
388      prop = bdf_get_font_property( font, "SPACING" );
389      if ( prop && prop->format == BDF_ATOM                             &&
390           prop->value.atom                                             &&
391           ( *(prop->value.atom) == 'M' || *(prop->value.atom) == 'm' ||
392             *(prop->value.atom) == 'C' || *(prop->value.atom) == 'c' ) )
393        bdfface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
394
395      /* FZ XXX: TO DO: FT_FACE_FLAGS_VERTICAL   */
396      /* FZ XXX: I need a font to implement this */
397
398      prop = bdf_get_font_property( font, "FAMILY_NAME" );
399      if ( prop && prop->value.atom )
400      {
401        if ( FT_STRDUP( bdfface->family_name, prop->value.atom ) )
402          goto Exit;
403      }
404      else
405        bdfface->family_name = 0;
406
407      if ( ( error = bdf_interpret_style( face ) ) != 0 )
408        goto Exit;
409
410      /* the number of glyphs (with one slot for the undefined glyph */
411      /* at position 0 and all unencoded glyphs)                     */
412      bdfface->num_glyphs = font->glyphs_size + 1;
413
414      bdfface->num_fixed_sizes = 1;
415      if ( FT_NEW_ARRAY( bdfface->available_sizes, 1 ) )
416        goto Exit;
417
418      {
419        FT_Bitmap_Size*  bsize = bdfface->available_sizes;
420        FT_Short         resolution_x = 0, resolution_y = 0;
421
422
423        FT_MEM_ZERO( bsize, sizeof ( FT_Bitmap_Size ) );
424
425        bsize->height = (FT_Short)( font->font_ascent + font->font_descent );
426
427        prop = bdf_get_font_property( font, "AVERAGE_WIDTH" );
428        if ( prop )
429          bsize->width = (FT_Short)( ( prop->value.int32 + 5 ) / 10 );
430        else
431          bsize->width = (FT_Short)( bsize->height * 2/3 );
432
433        prop = bdf_get_font_property( font, "POINT_SIZE" );
434        if ( prop )
435          /* convert from 722.7 decipoints to 72 points per inch */
436          bsize->size =
437            (FT_Pos)( ( prop->value.int32 * 64 * 7200 + 36135L ) / 72270L );
438        else
439          bsize->size = bsize->width << 6;
440
441        prop = bdf_get_font_property( font, "PIXEL_SIZE" );
442        if ( prop )
443          bsize->y_ppem = (FT_Short)prop->value.int32 << 6;
444
445        prop = bdf_get_font_property( font, "RESOLUTION_X" );
446        if ( prop )
447          resolution_x = (FT_Short)prop->value.int32;
448
449        prop = bdf_get_font_property( font, "RESOLUTION_Y" );
450        if ( prop )
451          resolution_y = (FT_Short)prop->value.int32;
452
453        if ( bsize->y_ppem == 0 )
454        {
455          bsize->y_ppem = bsize->size;
456          if ( resolution_y )
457            bsize->y_ppem = bsize->y_ppem * resolution_y / 72;
458        }
459        if ( resolution_x && resolution_y )
460          bsize->x_ppem = bsize->y_ppem * resolution_x / resolution_y;
461        else
462          bsize->x_ppem = bsize->y_ppem;
463      }
464
465      /* encoding table */
466      {
467        bdf_glyph_t*   cur = font->glyphs;
468        unsigned long  n;
469
470
471        if ( FT_NEW_ARRAY( face->en_table, font->glyphs_size ) )
472          goto Exit;
473
474        face->default_glyph = 0;
475        for ( n = 0; n < font->glyphs_size; n++ )
476        {
477          (face->en_table[n]).enc = cur[n].encoding;
478          FT_TRACE4(( "idx %d, val 0x%lX\n", n, cur[n].encoding ));
479          (face->en_table[n]).glyph = (FT_Short)n;
480
481          if ( cur[n].encoding == font->default_char )
482            face->default_glyph = n;
483        }
484      }
485
486      /* charmaps */
487      {
488        bdf_property_t  *charset_registry = 0, *charset_encoding = 0;
489        FT_Bool          unicode_charmap  = 0;
490
491
492        charset_registry =
493          bdf_get_font_property( font, "CHARSET_REGISTRY" );
494        charset_encoding =
495          bdf_get_font_property( font, "CHARSET_ENCODING" );
496        if ( charset_registry && charset_encoding )
497        {
498          if ( charset_registry->format == BDF_ATOM &&
499               charset_encoding->format == BDF_ATOM &&
500               charset_registry->value.atom         &&
501               charset_encoding->value.atom         )
502          {
503            const char*  s;
504
505
506            if ( FT_STRDUP( face->charset_encoding,
507                            charset_encoding->value.atom ) ||
508                 FT_STRDUP( face->charset_registry,
509                            charset_registry->value.atom ) )
510              goto Exit;
511
512            /* Uh, oh, compare first letters manually to avoid dependency */
513            /* on locales.                                                */
514            s = face->charset_registry;
515            if ( ( s[0] == 'i' || s[0] == 'I' ) &&
516                 ( s[1] == 's' || s[1] == 'S' ) &&
517                 ( s[2] == 'o' || s[2] == 'O' ) )
518            {
519              s += 3;
520              if ( !ft_strcmp( s, "10646" )                      ||
521                   ( !ft_strcmp( s, "8859" ) &&
522                     !ft_strcmp( face->charset_encoding, "1" ) ) )
523              unicode_charmap = 1;
524            }
525
526            {
527              FT_CharMapRec  charmap;
528
529
530              charmap.face        = FT_FACE( face );
531              charmap.encoding    = FT_ENCODING_NONE;
532              charmap.platform_id = 0;
533              charmap.encoding_id = 0;
534
535              if ( unicode_charmap )
536              {
537                charmap.encoding    = FT_ENCODING_UNICODE;
538                charmap.platform_id = 3;
539                charmap.encoding_id = 1;
540              }
541
542              error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
543
544#if 0
545              /* Select default charmap */
546              if ( bdfface->num_charmaps )
547                bdfface->charmap = bdfface->charmaps[0];
548#endif
549            }
550
551            goto Exit;
552          }
553        }
554
555        /* otherwise assume Adobe standard encoding */
556
557        {
558          FT_CharMapRec  charmap;
559
560
561          charmap.face        = FT_FACE( face );
562          charmap.encoding    = FT_ENCODING_ADOBE_STANDARD;
563          charmap.platform_id = 7;
564          charmap.encoding_id = 0;
565
566          error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
567
568          /* Select default charmap */
569          if ( bdfface->num_charmaps )
570            bdfface->charmap = bdfface->charmaps[0];
571        }
572      }
573    }
574
575  Exit:
576    return error;
577
578  Fail:
579    BDF_Face_Done( bdfface );
580    return BDF_Err_Unknown_File_Format;
581  }
582
583
584  FT_CALLBACK_DEF( FT_Error )
585  BDF_Size_Select( FT_Size   size,
586                   FT_ULong  strike_index )
587  {
588    bdf_font_t*  bdffont = ( (BDF_Face)size->face )->bdffont;
589
590
591    FT_Select_Metrics( size->face, strike_index );
592
593    size->metrics.ascender    = bdffont->font_ascent << 6;
594    size->metrics.descender   = -bdffont->font_descent << 6;
595    size->metrics.max_advance = bdffont->bbx.width << 6;
596
597    return BDF_Err_Ok;
598  }
599
600
601  FT_CALLBACK_DEF( FT_Error )
602  BDF_Size_Request( FT_Size          size,
603                    FT_Size_Request  req )
604  {
605    FT_Face          face    = size->face;
606    FT_Bitmap_Size*  bsize   = face->available_sizes;
607    bdf_font_t*      bdffont = ( (BDF_Face)face )->bdffont;
608    FT_Error         error   = BDF_Err_Invalid_Pixel_Size;
609    FT_Long          height;
610
611
612    height = FT_REQUEST_HEIGHT( req );
613    height = ( height + 32 ) >> 6;
614
615    switch ( req->type )
616    {
617    case FT_SIZE_REQUEST_TYPE_NOMINAL:
618      if ( height == ( ( bsize->y_ppem + 32 ) >> 6 ) )
619        error = BDF_Err_Ok;
620      break;
621
622    case FT_SIZE_REQUEST_TYPE_REAL_DIM:
623      if ( height == ( bdffont->font_ascent +
624                       bdffont->font_descent ) )
625        error = BDF_Err_Ok;
626      break;
627
628    default:
629      error = BDF_Err_Unimplemented_Feature;
630      break;
631    }
632
633    if ( error )
634      return error;
635    else
636      return BDF_Size_Select( size, 0 );
637  }
638
639
640
641  FT_CALLBACK_DEF( FT_Error )
642  BDF_Glyph_Load( FT_GlyphSlot  slot,
643                  FT_Size       size,
644                  FT_UInt       glyph_index,
645                  FT_Int32      load_flags )
646  {
647    BDF_Face     bdf    = (BDF_Face)FT_SIZE_FACE( size );
648    FT_Face      face   = FT_FACE( bdf );
649    FT_Error     error  = BDF_Err_Ok;
650    FT_Bitmap*   bitmap = &slot->bitmap;
651    bdf_glyph_t  glyph;
652    int          bpp    = bdf->bdffont->bpp;
653
654    FT_UNUSED( load_flags );
655
656
657    if ( !face || glyph_index >= (FT_UInt)face->num_glyphs )
658    {
659      error = BDF_Err_Invalid_Argument;
660      goto Exit;
661    }
662
663    /* index 0 is the undefined glyph */
664    if ( glyph_index == 0 )
665      glyph_index = bdf->default_glyph;
666    else
667      glyph_index--;
668
669    /* slot, bitmap => freetype, glyph => bdflib */
670    glyph = bdf->bdffont->glyphs[glyph_index];
671
672    bitmap->rows  = glyph.bbx.height;
673    bitmap->width = glyph.bbx.width;
674    bitmap->pitch = glyph.bpr;
675
676    /* note: we don't allocate a new array to hold the bitmap; */
677    /*       we can simply point to it                         */
678    ft_glyphslot_set_bitmap( slot, glyph.bitmap );
679
680    switch ( bpp )
681    {
682    case 1:
683      bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
684      break;
685    case 2:
686      bitmap->pixel_mode = FT_PIXEL_MODE_GRAY2;
687      break;
688    case 4:
689      bitmap->pixel_mode = FT_PIXEL_MODE_GRAY4;
690      break;
691    case 8:
692      bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
693      bitmap->num_grays  = 256;
694      break;
695    }
696
697    slot->format      = FT_GLYPH_FORMAT_BITMAP;
698    slot->bitmap_left = glyph.bbx.x_offset;
699    slot->bitmap_top  = glyph.bbx.ascent;
700
701    slot->metrics.horiAdvance  = glyph.dwidth << 6;
702    slot->metrics.horiBearingX = glyph.bbx.x_offset << 6;
703    slot->metrics.horiBearingY = glyph.bbx.ascent << 6;
704    slot->metrics.width        = bitmap->width << 6;
705    slot->metrics.height       = bitmap->rows << 6;
706
707    /*
708     * XXX DWIDTH1 and VVECTOR should be parsed and
709     * used here, provided such fonts do exist.
710     */
711    ft_synthesize_vertical_metrics( &slot->metrics,
712                                    bdf->bdffont->bbx.height << 6 );
713
714  Exit:
715    return error;
716  }
717
718
719 /*
720  *
721  *  BDF SERVICE
722  *
723  */
724
725  static FT_Error
726  bdf_get_bdf_property( BDF_Face          face,
727                        const char*       prop_name,
728                        BDF_PropertyRec  *aproperty )
729  {
730    bdf_property_t*  prop;
731
732
733    FT_ASSERT( face && face->bdffont );
734
735    prop = bdf_get_font_property( face->bdffont, prop_name );
736    if ( prop )
737    {
738      switch ( prop->format )
739      {
740      case BDF_ATOM:
741        aproperty->type   = BDF_PROPERTY_TYPE_ATOM;
742        aproperty->u.atom = prop->value.atom;
743        break;
744
745      case BDF_INTEGER:
746        aproperty->type      = BDF_PROPERTY_TYPE_INTEGER;
747        aproperty->u.integer = prop->value.int32;
748        break;
749
750      case BDF_CARDINAL:
751        aproperty->type       = BDF_PROPERTY_TYPE_CARDINAL;
752        aproperty->u.cardinal = prop->value.card32;
753        break;
754
755      default:
756        goto Fail;
757      }
758      return 0;
759    }
760
761  Fail:
762    return BDF_Err_Invalid_Argument;
763  }
764
765
766  static FT_Error
767  bdf_get_charset_id( BDF_Face      face,
768                      const char*  *acharset_encoding,
769                      const char*  *acharset_registry )
770  {
771    *acharset_encoding = face->charset_encoding;
772    *acharset_registry = face->charset_registry;
773
774    return 0;
775  }
776
777
778  static const FT_Service_BDFRec  bdf_service_bdf =
779  {
780    (FT_BDF_GetCharsetIdFunc)bdf_get_charset_id,
781    (FT_BDF_GetPropertyFunc) bdf_get_bdf_property
782  };
783
784
785 /*
786  *
787  *  SERVICES LIST
788  *
789  */
790
791  static const FT_ServiceDescRec  bdf_services[] =
792  {
793    { FT_SERVICE_ID_BDF,       &bdf_service_bdf },
794    { FT_SERVICE_ID_XF86_NAME, FT_XF86_FORMAT_BDF },
795    { NULL, NULL }
796  };
797
798
799  FT_CALLBACK_DEF( FT_Module_Interface )
800  bdf_driver_requester( FT_Module    module,
801                        const char*  name )
802  {
803    FT_UNUSED( module );
804
805    return ft_service_list_lookup( bdf_services, name );
806  }
807
808
809
810  FT_CALLBACK_TABLE_DEF
811  const FT_Driver_ClassRec  bdf_driver_class =
812  {
813    {
814      FT_MODULE_FONT_DRIVER         |
815      FT_MODULE_DRIVER_NO_OUTLINES,
816      sizeof ( FT_DriverRec ),
817
818      "bdf",
819      0x10000L,
820      0x20000L,
821
822      0,
823
824      (FT_Module_Constructor)0,
825      (FT_Module_Destructor) 0,
826      (FT_Module_Requester)  bdf_driver_requester
827    },
828
829    sizeof ( BDF_FaceRec ),
830    sizeof ( FT_SizeRec ),
831    sizeof ( FT_GlyphSlotRec ),
832
833    BDF_Face_Init,
834    BDF_Face_Done,
835    0,                          /* FT_Size_InitFunc */
836    0,                          /* FT_Size_DoneFunc */
837    0,                          /* FT_Slot_InitFunc */
838    0,                          /* FT_Slot_DoneFunc */
839
840#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
841    ft_stub_set_char_sizes,
842    ft_stub_set_pixel_sizes,
843#endif
844    BDF_Glyph_Load,
845
846    0,                          /* FT_Face_GetKerningFunc   */
847    0,                          /* FT_Face_AttachFunc       */
848    0,                          /* FT_Face_GetAdvancesFunc  */
849
850    BDF_Size_Request,
851    BDF_Size_Select
852  };
853
854
855/* END */
Note: See TracBrowser for help on using the repository browser.