source: trunk/poppler/freetype-2.1.10/src/bdf/bdfdrivr.c @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 16 years ago

First import

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