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