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