projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Sync with trunk (r48008)
[reactos.git] / lib / 3rdparty / freetype / src / base / ftobjs.c
1 /***************************************************************************/
2 /* */
3 /* ftobjs.c */
4 /* */
5 /* The FreeType private base classes (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */
8 /* 2010 by */
9 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
10 /* */
11 /* This file is part of the FreeType project, and may only be used, */
12 /* modified, and distributed under the terms of the FreeType project */
13 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
14 /* this file you indicate that you have read the license and */
15 /* understand and accept it fully. */
16 /* */
17 /***************************************************************************/
18
19
20 #include <ft2build.h>
21 #include FT_LIST_H
22 #include FT_OUTLINE_H
23 #include FT_INTERNAL_VALIDATE_H
24 #include FT_INTERNAL_OBJECTS_H
25 #include FT_INTERNAL_DEBUG_H
26 #include FT_INTERNAL_RFORK_H
27 #include FT_INTERNAL_STREAM_H
28 #include FT_INTERNAL_SFNT_H /* for SFNT_Load_Table_Func */
29 #include FT_TRUETYPE_TABLES_H
30 #include FT_TRUETYPE_TAGS_H
31 #include FT_TRUETYPE_IDS_H
32 #include FT_OUTLINE_H
33
34 #include FT_SERVICE_SFNT_H
35 #include FT_SERVICE_POSTSCRIPT_NAME_H
36 #include FT_SERVICE_GLYPH_DICT_H
37 #include FT_SERVICE_TT_CMAP_H
38 #include FT_SERVICE_KERNING_H
39 #include FT_SERVICE_TRUETYPE_ENGINE_H
40
41 #ifdef FT_CONFIG_OPTION_MAC_FONTS
42 #include "ftbase.h"
43 #endif
44
45 #define GRID_FIT_METRICS
46
47
48 FT_BASE_DEF( FT_Pointer )
49 ft_service_list_lookup( FT_ServiceDesc service_descriptors,
50 const char* service_id )
51 {
52 FT_Pointer result = NULL;
53 FT_ServiceDesc desc = service_descriptors;
54
55
56 if ( desc && service_id )
57 {
58 for ( ; desc->serv_id != NULL; desc++ )
59 {
60 if ( ft_strcmp( desc->serv_id, service_id ) == 0 )
61 {
62 result = (FT_Pointer)desc->serv_data;
63 break;
64 }
65 }
66 }
67
68 return result;
69 }
70
71
72 FT_BASE_DEF( void )
73 ft_validator_init( FT_Validator valid,
74 const FT_Byte* base,
75 const FT_Byte* limit,
76 FT_ValidationLevel level )
77 {
78 valid->base = base;
79 valid->limit = limit;
80 valid->level = level;
81 valid->error = FT_Err_Ok;
82 }
83
84
85 FT_BASE_DEF( FT_Int )
86 ft_validator_run( FT_Validator valid )
87 {
88 /* This function doesn't work! None should call it. */
89 FT_UNUSED( valid );
90
91 return -1;
92 }
93
94
95 FT_BASE_DEF( void )
96 ft_validator_error( FT_Validator valid,
97 FT_Error error )
98 {
99 /* since the cast below also disables the compiler's */
100 /* type check, we introduce a dummy variable, which */
101 /* will be optimized away */
102 volatile ft_jmp_buf* jump_buffer = &valid->jump_buffer;
103
104
105 valid->error = error;
106
107 /* throw away volatileness; use `jump_buffer' or the */
108 /* compiler may warn about an unused local variable */
109 ft_longjmp( *(ft_jmp_buf*) jump_buffer, 1 );
110 }
111
112
113 /*************************************************************************/
114 /*************************************************************************/
115 /*************************************************************************/
116 /**** ****/
117 /**** ****/
118 /**** S T R E A M ****/
119 /**** ****/
120 /**** ****/
121 /*************************************************************************/
122 /*************************************************************************/
123 /*************************************************************************/
124
125
126 /* create a new input stream from an FT_Open_Args structure */
127 /* */
128 FT_BASE_DEF( FT_Error )
129 FT_Stream_New( FT_Library library,
130 const FT_Open_Args* args,
131 FT_Stream *astream )
132 {
133 FT_Error error;
134 FT_Memory memory;
135 FT_Stream stream;
136
137
138 *astream = 0;
139
140 if ( !library )
141 return FT_Err_Invalid_Library_Handle;
142
143 if ( !args )
144 return FT_Err_Invalid_Argument;
145
146 memory = library->memory;
147
148 if ( FT_NEW( stream ) )
149 goto Exit;
150
151 stream->memory = memory;
152
153 if ( args->flags & FT_OPEN_MEMORY )
154 {
155 /* create a memory-based stream */
156 FT_Stream_OpenMemory( stream,
157 (const FT_Byte*)args->memory_base,
158 args->memory_size );
159 }
160 else if ( args->flags & FT_OPEN_PATHNAME )
161 {
162 /* create a normal system stream */
163 error = FT_Stream_Open( stream, args->pathname );
164 stream->pathname.pointer = args->pathname;
165 }
166 else if ( ( args->flags & FT_OPEN_STREAM ) && args->stream )
167 {
168 /* use an existing, user-provided stream */
169
170 /* in this case, we do not need to allocate a new stream object */
171 /* since the caller is responsible for closing it himself */
172 FT_FREE( stream );
173 stream = args->stream;
174 }
175 else
176 error = FT_Err_Invalid_Argument;
177
178 if ( error )
179 FT_FREE( stream );
180 else
181 stream->memory = memory; /* just to be certain */
182
183 *astream = stream;
184
185 Exit:
186 return error;
187 }
188
189
190 FT_BASE_DEF( void )
191 FT_Stream_Free( FT_Stream stream,
192 FT_Int external )
193 {
194 if ( stream )
195 {
196 FT_Memory memory = stream->memory;
197
198
199 FT_Stream_Close( stream );
200
201 if ( !external )
202 FT_FREE( stream );
203 }
204 }
205
206
207 /*************************************************************************/
208 /* */
209 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
210 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
211 /* messages during execution. */
212 /* */
213 #undef FT_COMPONENT
214 #define FT_COMPONENT trace_objs
215
216
217 /*************************************************************************/
218 /*************************************************************************/
219 /*************************************************************************/
220 /**** ****/
221 /**** ****/
222 /**** FACE, SIZE & GLYPH SLOT OBJECTS ****/
223 /**** ****/
224 /**** ****/
225 /*************************************************************************/
226 /*************************************************************************/
227 /*************************************************************************/
228
229
230 static FT_Error
231 ft_glyphslot_init( FT_GlyphSlot slot )
232 {
233 FT_Driver driver = slot->face->driver;
234 FT_Driver_Class clazz = driver->clazz;
235 FT_Memory memory = driver->root.memory;
236 FT_Error error = FT_Err_Ok;
237 FT_Slot_Internal internal;
238
239
240 slot->library = driver->root.library;
241
242 if ( FT_NEW( internal ) )
243 goto Exit;
244
245 slot->internal = internal;
246
247 if ( FT_DRIVER_USES_OUTLINES( driver ) )
248 error = FT_GlyphLoader_New( memory, &internal->loader );
249
250 if ( !error && clazz->init_slot )
251 error = clazz->init_slot( slot );
252
253 Exit:
254 return error;
255 }
256
257
258 FT_BASE_DEF( void )
259 ft_glyphslot_free_bitmap( FT_GlyphSlot slot )
260 {
261 if ( slot->internal && ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
262 {
263 FT_Memory memory = FT_FACE_MEMORY( slot->face );
264
265
266 FT_FREE( slot->bitmap.buffer );
267 slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
268 }
269 else
270 {
271 /* assume that the bitmap buffer was stolen or not */
272 /* allocated from the heap */
273 slot->bitmap.buffer = NULL;
274 }
275 }
276
277
278 FT_BASE_DEF( void )
279 ft_glyphslot_set_bitmap( FT_GlyphSlot slot,
280 FT_Byte* buffer )
281 {
282 ft_glyphslot_free_bitmap( slot );
283
284 slot->bitmap.buffer = buffer;
285
286 FT_ASSERT( (slot->internal->flags & FT_GLYPH_OWN_BITMAP) == 0 );
287 }
288
289
290 FT_BASE_DEF( FT_Error )
291 ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot,
292 FT_ULong size )
293 {
294 FT_Memory memory = FT_FACE_MEMORY( slot->face );
295 FT_Error error;
296
297
298 if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
299 FT_FREE( slot->bitmap.buffer );
300 else
301 slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
302
303 (void)FT_ALLOC( slot->bitmap.buffer, size );
304 return error;
305 }
306
307
308 static void
309 ft_glyphslot_clear( FT_GlyphSlot slot )
310 {
311 /* free bitmap if needed */
312 ft_glyphslot_free_bitmap( slot );
313
314 /* clear all public fields in the glyph slot */
315 FT_ZERO( &slot->metrics );
316 FT_ZERO( &slot->outline );
317
318 slot->bitmap.width = 0;
319 slot->bitmap.rows = 0;
320 slot->bitmap.pitch = 0;
321 slot->bitmap.pixel_mode = 0;
322 /* `slot->bitmap.buffer' has been handled by ft_glyphslot_free_bitmap */
323
324 slot->bitmap_left = 0;
325 slot->bitmap_top = 0;
326 slot->num_subglyphs = 0;
327 slot->subglyphs = 0;
328 slot->control_data = 0;
329 slot->control_len = 0;
330 slot->other = 0;
331 slot->format = FT_GLYPH_FORMAT_NONE;
332
333 slot->linearHoriAdvance = 0;
334 slot->linearVertAdvance = 0;
335 slot->lsb_delta = 0;
336 slot->rsb_delta = 0;
337 }
338
339
340 static void
341 ft_glyphslot_done( FT_GlyphSlot slot )
342 {
343 FT_Driver driver = slot->face->driver;
344 FT_Driver_Class clazz = driver->clazz;
345 FT_Memory memory = driver->root.memory;
346
347
348 if ( clazz->done_slot )
349 clazz->done_slot( slot );
350
351 /* free bitmap buffer if needed */
352 ft_glyphslot_free_bitmap( slot );
353
354 /* slot->internal might be NULL in out-of-memory situations */
355 if ( slot->internal )
356 {
357 /* free glyph loader */
358 if ( FT_DRIVER_USES_OUTLINES( driver ) )
359 {
360 FT_GlyphLoader_Done( slot->internal->loader );
361 slot->internal->loader = 0;
362 }
363
364 FT_FREE( slot->internal );
365 }
366 }
367
368
369 /* documentation is in ftobjs.h */
370
371 FT_BASE_DEF( FT_Error )
372 FT_New_GlyphSlot( FT_Face face,
373 FT_GlyphSlot *aslot )
374 {
375 FT_Error error;
376 FT_Driver driver;
377 FT_Driver_Class clazz;
378 FT_Memory memory;
379 FT_GlyphSlot slot;
380
381
382 if ( !face || !face->driver )
383 return FT_Err_Invalid_Argument;
384
385 driver = face->driver;
386 clazz = driver->clazz;
387 memory = driver->root.memory;
388
389 FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" ));
390 if ( !FT_ALLOC( slot, clazz->slot_object_size ) )
391 {
392 slot->face = face;
393
394 error = ft_glyphslot_init( slot );
395 if ( error )
396 {
397 ft_glyphslot_done( slot );
398 FT_FREE( slot );
399 goto Exit;
400 }
401
402 slot->next = face->glyph;
403 face->glyph = slot;
404
405 if ( aslot )
406 *aslot = slot;
407 }
408 else if ( aslot )
409 *aslot = 0;
410
411
412 Exit:
413 FT_TRACE4(( "FT_New_GlyphSlot: Return %d\n", error ));
414 return error;
415 }
416
417
418 /* documentation is in ftobjs.h */
419
420 FT_BASE_DEF( void )
421 FT_Done_GlyphSlot( FT_GlyphSlot slot )
422 {
423 if ( slot )
424 {
425 FT_Driver driver = slot->face->driver;
426 FT_Memory memory = driver->root.memory;
427 FT_GlyphSlot prev;
428 FT_GlyphSlot cur;
429
430
431 /* Remove slot from its parent face's list */
432 prev = NULL;
433 cur = slot->face->glyph;
434
435 while ( cur )
436 {
437 if ( cur == slot )
438 {
439 if ( !prev )
440 slot->face->glyph = cur->next;
441 else
442 prev->next = cur->next;
443
444 ft_glyphslot_done( slot );
445 FT_FREE( slot );
446 break;
447 }
448 prev = cur;
449 cur = cur->next;
450 }
451 }
452 }
453
454
455 /* documentation is in freetype.h */
456
457 FT_EXPORT_DEF( void )
458 FT_Set_Transform( FT_Face face,
459 FT_Matrix* matrix,
460 FT_Vector* delta )
461 {
462 FT_Face_Internal internal;
463
464
465 if ( !face )
466 return;
467
468 internal = face->internal;
469
470 internal->transform_flags = 0;
471
472 if ( !matrix )
473 {
474 internal->transform_matrix.xx = 0x10000L;
475 internal->transform_matrix.xy = 0;
476 internal->transform_matrix.yx = 0;
477 internal->transform_matrix.yy = 0x10000L;
478 matrix = &internal->transform_matrix;
479 }
480 else
481 internal->transform_matrix = *matrix;
482
483 /* set transform_flags bit flag 0 if `matrix' isn't the identity */
484 if ( ( matrix->xy | matrix->yx ) ||
485 matrix->xx != 0x10000L ||
486 matrix->yy != 0x10000L )
487 internal->transform_flags |= 1;
488
489 if ( !delta )
490 {
491 internal->transform_delta.x = 0;
492 internal->transform_delta.y = 0;
493 delta = &internal->transform_delta;
494 }
495 else
496 internal->transform_delta = *delta;
497
498 /* set transform_flags bit flag 1 if `delta' isn't the null vector */
499 if ( delta->x | delta->y )
500 internal->transform_flags |= 2;
501 }
502
503
504 static FT_Renderer
505 ft_lookup_glyph_renderer( FT_GlyphSlot slot );
506
507
508 #ifdef GRID_FIT_METRICS
509 static void
510 ft_glyphslot_grid_fit_metrics( FT_GlyphSlot slot,
511 FT_Bool vertical )
512 {
513 FT_Glyph_Metrics* metrics = &slot->metrics;
514 FT_Pos right, bottom;
515
516
517 if ( vertical )
518 {
519 metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX );
520 metrics->horiBearingY = FT_PIX_CEIL ( metrics->horiBearingY );
521
522 right = FT_PIX_CEIL( metrics->vertBearingX + metrics->width );
523 bottom = FT_PIX_CEIL( metrics->vertBearingY + metrics->height );
524
525 metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX );
526 metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY );
527
528 metrics->width = right - metrics->vertBearingX;
529 metrics->height = bottom - metrics->vertBearingY;
530 }
531 else
532 {
533 metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX );
534 metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY );
535
536 right = FT_PIX_CEIL ( metrics->horiBearingX + metrics->width );
537 bottom = FT_PIX_FLOOR( metrics->horiBearingY - metrics->height );
538
539 metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX );
540 metrics->horiBearingY = FT_PIX_CEIL ( metrics->horiBearingY );
541
542 metrics->width = right - metrics->horiBearingX;
543 metrics->height = metrics->horiBearingY - bottom;
544 }
545
546 metrics->horiAdvance = FT_PIX_ROUND( metrics->horiAdvance );
547 metrics->vertAdvance = FT_PIX_ROUND( metrics->vertAdvance );
548 }
549 #endif /* GRID_FIT_METRICS */
550
551
552 /* documentation is in freetype.h */
553
554 FT_EXPORT_DEF( FT_Error )
555 FT_Load_Glyph( FT_Face face,
556 FT_UInt glyph_index,
557 FT_Int32 load_flags )
558 {
559 FT_Error error;
560 FT_Driver driver;
561 FT_GlyphSlot slot;
562 FT_Library library;
563 FT_Bool autohint = FALSE;
564 FT_Module hinter;
565
566
567 if ( !face || !face->size || !face->glyph )
568 return FT_Err_Invalid_Face_Handle;
569
570 /* The validity test for `glyph_index' is performed by the */
571 /* font drivers. */
572
573 slot = face->glyph;
574 ft_glyphslot_clear( slot );
575
576 driver = face->driver;
577 library = driver->root.library;
578 hinter = library->auto_hinter;
579
580 /* resolve load flags dependencies */
581
582 if ( load_flags & FT_LOAD_NO_RECURSE )
583 load_flags |= FT_LOAD_NO_SCALE |
584 FT_LOAD_IGNORE_TRANSFORM;
585
586 if ( load_flags & FT_LOAD_NO_SCALE )
587 {
588 load_flags |= FT_LOAD_NO_HINTING |
589 FT_LOAD_NO_BITMAP;
590
591 load_flags &= ~FT_LOAD_RENDER;
592 }
593
594 /*
595 * Determine whether we need to auto-hint or not.
596 * The general rules are:
597 *
598 * - Do only auto-hinting if we have a hinter module, a scalable font
599 * format dealing with outlines, and no transforms except simple
600 * slants and/or rotations by integer multiples of 90 degrees.
601 *
602 * - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't
603 * have a native font hinter.
604 *
605 * - Otherwise, auto-hint for LIGHT hinting mode.
606 *
607 * - Exception: The font is `tricky' and requires the native hinter to
608 * load properly.
609 */
610
611 if ( hinter &&
612 !( load_flags & FT_LOAD_NO_HINTING ) &&
613 !( load_flags & FT_LOAD_NO_AUTOHINT ) &&
614 FT_DRIVER_IS_SCALABLE( driver ) &&
615 FT_DRIVER_USES_OUTLINES( driver ) &&
616 !FT_IS_TRICKY( face ) &&
617 ( ( face->internal->transform_matrix.yx == 0 &&
618 face->internal->transform_matrix.xx != 0 ) ||
619 ( face->internal->transform_matrix.xx == 0 &&
620 face->internal->transform_matrix.yx != 0 ) ) )
621 {
622 if ( ( load_flags & FT_LOAD_FORCE_AUTOHINT ) ||
623 !FT_DRIVER_HAS_HINTER( driver ) )
624 autohint = TRUE;
625 else
626 {
627 FT_Render_Mode mode = FT_LOAD_TARGET_MODE( load_flags );
628
629
630 if ( mode == FT_RENDER_MODE_LIGHT ||
631 face->internal->ignore_unpatented_hinter )
632 autohint = TRUE;
633 }
634 }
635
636 if ( autohint )
637 {
638 FT_AutoHinter_Service hinting;
639
640
641 /* try to load embedded bitmaps first if available */
642 /* */
643 /* XXX: This is really a temporary hack that should disappear */
644 /* promptly with FreeType 2.1! */
645 /* */
646 if ( FT_HAS_FIXED_SIZES( face ) &&
647 ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
648 {
649 error = driver->clazz->load_glyph( slot, face->size,
650 glyph_index,
651 load_flags | FT_LOAD_SBITS_ONLY );
652
653 if ( !error && slot->format == FT_GLYPH_FORMAT_BITMAP )
654 goto Load_Ok;
655 }
656
657 {
658 FT_Face_Internal internal = face->internal;
659 FT_Int transform_flags = internal->transform_flags;
660
661
662 /* since the auto-hinter calls FT_Load_Glyph by itself, */
663 /* make sure that glyphs aren't transformed */
664 internal->transform_flags = 0;
665
666 /* load auto-hinted outline */
667 hinting = (FT_AutoHinter_Service)hinter->clazz->module_interface;
668
669 error = hinting->load_glyph( (FT_AutoHinter)hinter,
670 slot, face->size,
671 glyph_index, load_flags );
672
673 internal->transform_flags = transform_flags;
674 }
675 }
676 else
677 {
678 error = driver->clazz->load_glyph( slot,
679 face->size,
680 glyph_index,
681 load_flags );
682 if ( error )
683 goto Exit;
684
685 if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
686 {
687 /* check that the loaded outline is correct */
688 error = FT_Outline_Check( &slot->outline );
689 if ( error )
690 goto Exit;
691
692 #ifdef GRID_FIT_METRICS
693 if ( !( load_flags & FT_LOAD_NO_HINTING ) )
694 ft_glyphslot_grid_fit_metrics( slot,
695 FT_BOOL( load_flags & FT_LOAD_VERTICAL_LAYOUT ) );
696 #endif
697 }
698 }
699
700 Load_Ok:
701 /* compute the advance */
702 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
703 {
704 slot->advance.x = 0;
705 slot->advance.y = slot->metrics.vertAdvance;
706 }
707 else
708 {
709 slot->advance.x = slot->metrics.horiAdvance;
710 slot->advance.y = 0;
711 }
712
713 /* compute the linear advance in 16.16 pixels */
714 if ( ( load_flags & FT_LOAD_LINEAR_DESIGN ) == 0 &&
715 ( FT_IS_SCALABLE( face ) ) )
716 {
717 FT_Size_Metrics* metrics = &face->size->metrics;
718
719
720 /* it's tricky! */
721 slot->linearHoriAdvance = FT_MulDiv( slot->linearHoriAdvance,
722 metrics->x_scale, 64 );
723
724 slot->linearVertAdvance = FT_MulDiv( slot->linearVertAdvance,
725 metrics->y_scale, 64 );
726 }
727
728 if ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) == 0 )
729 {
730 FT_Face_Internal internal = face->internal;
731
732
733 /* now, transform the glyph image if needed */
734 if ( internal->transform_flags )
735 {
736 /* get renderer */
737 FT_Renderer renderer = ft_lookup_glyph_renderer( slot );
738
739
740 if ( renderer )
741 error = renderer->clazz->transform_glyph(
742 renderer, slot,
743 &internal->transform_matrix,
744 &internal->transform_delta );
745 else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
746 {
747 /* apply `standard' transformation if no renderer is available */
748 if ( &internal->transform_matrix )
749 FT_Outline_Transform( &slot->outline,
750 &internal->transform_matrix );
751
752 if ( &internal->transform_delta )
753 FT_Outline_Translate( &slot->outline,
754 internal->transform_delta.x,
755 internal->transform_delta.y );
756 }
757
758 /* transform advance */
759 FT_Vector_Transform( &slot->advance, &internal->transform_matrix );
760 }
761 }
762
763 FT_TRACE5(( " x advance: %d\n" , slot->advance.x ));
764 FT_TRACE5(( " y advance: %d\n" , slot->advance.y ));
765
766 FT_TRACE5(( " linear x advance: %d\n" , slot->linearHoriAdvance ));
767 FT_TRACE5(( " linear y advance: %d\n" , slot->linearVertAdvance ));
768
769 /* do we need to render the image now? */
770 if ( !error &&
771 slot->format != FT_GLYPH_FORMAT_BITMAP &&
772 slot->format != FT_GLYPH_FORMAT_COMPOSITE &&
773 load_flags & FT_LOAD_RENDER )
774 {
775 FT_Render_Mode mode = FT_LOAD_TARGET_MODE( load_flags );
776
777
778 if ( mode == FT_RENDER_MODE_NORMAL &&
779 (load_flags & FT_LOAD_MONOCHROME ) )
780 mode = FT_RENDER_MODE_MONO;
781
782 error = FT_Render_Glyph( slot, mode );
783 }
784
785 Exit:
786 return error;
787 }
788
789
790 /* documentation is in freetype.h */
791
792 FT_EXPORT_DEF( FT_Error )
793 FT_Load_Char( FT_Face face,
794 FT_ULong char_code,
795 FT_Int32 load_flags )
796 {
797 FT_UInt glyph_index;
798
799
800 if ( !face )
801 return FT_Err_Invalid_Face_Handle;
802
803 glyph_index = (FT_UInt)char_code;
804 if ( face->charmap )
805 glyph_index = FT_Get_Char_Index( face, char_code );
806
807 return FT_Load_Glyph( face, glyph_index, load_flags );
808 }
809
810
811 /* destructor for sizes list */
812 static void
813 destroy_size( FT_Memory memory,
814 FT_Size size,
815 FT_Driver driver )
816 {
817 /* finalize client-specific data */
818 if ( size->generic.finalizer )
819 size->generic.finalizer( size );
820
821 /* finalize format-specific stuff */
822 if ( driver->clazz->done_size )
823 driver->clazz->done_size( size );
824
825 FT_FREE( size->internal );
826 FT_FREE( size );
827 }
828
829
830 static void
831 ft_cmap_done_internal( FT_CMap cmap );
832
833
834 static void
835 destroy_charmaps( FT_Face face,
836 FT_Memory memory )
837 {
838 FT_Int n;
839
840
841 if ( !face )
842 return;
843
844 for ( n = 0; n < face->num_charmaps; n++ )
845 {
846 FT_CMap cmap = FT_CMAP( face->charmaps[n] );
847
848
849 ft_cmap_done_internal( cmap );
850
851 face->charmaps[n] = NULL;
852 }
853
854 FT_FREE( face->charmaps );
855 face->num_charmaps = 0;
856 }
857
858
859 /* destructor for faces list */
860 static void
861 destroy_face( FT_Memory memory,
862 FT_Face face,
863 FT_Driver driver )
864 {
865 FT_Driver_Class clazz = driver->clazz;
866
867
868 /* discard auto-hinting data */
869 if ( face->autohint.finalizer )
870 face->autohint.finalizer( face->autohint.data );
871
872 /* Discard glyph slots for this face. */
873 /* Beware! FT_Done_GlyphSlot() changes the field `face->glyph' */
874 while ( face->glyph )
875 FT_Done_GlyphSlot( face->glyph );
876
877 /* discard all sizes for this face */
878 FT_List_Finalize( &face->sizes_list,
879 (FT_List_Destructor)destroy_size,
880 memory,
881 driver );
882 face->size = 0;
883
884 /* now discard client data */
885 if ( face->generic.finalizer )
886 face->generic.finalizer( face );
887
888 /* discard charmaps */
889 destroy_charmaps( face, memory );
890
891 /* finalize format-specific stuff */
892 if ( clazz->done_face )
893 clazz->done_face( face );
894
895 /* close the stream for this face if needed */
896 FT_Stream_Free(
897 face->stream,
898 ( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );
899
900 face->stream = 0;
901
902 /* get rid of it */
903 if ( face->internal )
904 {
905 FT_FREE( face->internal );
906 }
907 FT_FREE( face );
908 }
909
910
911 static void
912 Destroy_Driver( FT_Driver driver )
913 {
914 FT_List_Finalize( &driver->faces_list,
915 (FT_List_Destructor)destroy_face,
916 driver->root.memory,
917 driver );
918
919 /* check whether we need to drop the driver's glyph loader */
920 if ( FT_DRIVER_USES_OUTLINES( driver ) )
921 FT_GlyphLoader_Done( driver->glyph_loader );
922 }
923
924
925 /*************************************************************************/
926 /* */
927 /* <Function> */
928 /* find_unicode_charmap */
929 /* */
930 /* <Description> */
931 /* This function finds a Unicode charmap, if there is one. */
932 /* And if there is more than one, it tries to favour the more */
933 /* extensive one, i.e., one that supports UCS-4 against those which */
934 /* are limited to the BMP (said UCS-2 encoding.) */
935 /* */
936 /* This function is called from open_face() (just below), and also */
937 /* from FT_Select_Charmap( ..., FT_ENCODING_UNICODE ). */
938 /* */
939 static FT_Error
940 find_unicode_charmap( FT_Face face )
941 {
942 FT_CharMap* first;
943 FT_CharMap* cur;
944
945
946 /* caller should have already checked that `face' is valid */
947 FT_ASSERT( face );
948
949 first = face->charmaps;
950
951 if ( !first )
952 return FT_Err_Invalid_CharMap_Handle;
953
954 /*
955 * The original TrueType specification(s) only specified charmap
956 * formats that are capable of mapping 8 or 16 bit character codes to
957 * glyph indices.
958 *
959 * However, recent updates to the Apple and OpenType specifications
960 * introduced new formats that are capable of mapping 32-bit character
961 * codes as well. And these are already used on some fonts, mainly to
962 * map non-BMP Asian ideographs as defined in Unicode.
963 *
964 * For compatibility purposes, these fonts generally come with
965 * *several* Unicode charmaps:
966 *
967 * - One of them in the "old" 16-bit format, that cannot access
968 * all glyphs in the font.
969 *
970 * - Another one in the "new" 32-bit format, that can access all
971 * the glyphs.
972 *
973 * This function has been written to always favor a 32-bit charmap
974 * when found. Otherwise, a 16-bit one is returned when found.
975 */
976
977 /* Since the `interesting' table, with IDs (3,10), is normally the */
978 /* last one, we loop backwards. This loses with type1 fonts with */
979 /* non-BMP characters (<.0001%), this wins with .ttf with non-BMP */
980 /* chars (.01% ?), and this is the same about 99.99% of the time! */
981
982 cur = first + face->num_charmaps; /* points after the last one */
983
984 for ( ; --cur >= first; )
985 {
986 if ( cur[0]->encoding == FT_ENCODING_UNICODE )
987 {
988 /* XXX If some new encodings to represent UCS-4 are added, */
989 /* they should be added here. */
990 if ( ( cur[0]->platform_id == TT_PLATFORM_MICROSOFT &&
991 cur[0]->encoding_id == TT_MS_ID_UCS_4 ) ||
992 ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE &&
993 cur[0]->encoding_id == TT_APPLE_ID_UNICODE_32 ) )
994 {
995 face->charmap = cur[0];
996 return FT_Err_Ok;
997 }
998 }
999 }
1000
1001 /* We do not have any UCS-4 charmap. */
1002 /* Do the loop again and search for UCS-2 charmaps. */
1003 cur = first + face->num_charmaps;
1004
1005 for ( ; --cur >= first; )
1006 {
1007 if ( cur[0]->encoding == FT_ENCODING_UNICODE )
1008 {
1009 face->charmap = cur[0];
1010 return FT_Err_Ok;
1011 }
1012 }
1013
1014 return FT_Err_Invalid_CharMap_Handle;
1015 }
1016
1017
1018 /*************************************************************************/
1019 /* */
1020 /* <Function> */
1021 /* find_variant_selector_charmap */
1022 /* */
1023 /* <Description> */
1024 /* This function finds the variant selector charmap, if there is one. */
1025 /* There can only be one (platform=0, specific=5, format=14). */
1026 /* */
1027 static FT_CharMap
1028 find_variant_selector_charmap( FT_Face face )
1029 {
1030 FT_CharMap* first;
1031 FT_CharMap* end;
1032 FT_CharMap* cur;
1033
1034
1035 /* caller should have already checked that `face' is valid */
1036 FT_ASSERT( face );
1037
1038 first = face->charmaps;
1039
1040 if ( !first )
1041 return NULL;
1042
1043 end = first + face->num_charmaps; /* points after the last one */
1044
1045 for ( cur = first; cur < end; ++cur )
1046 {
1047 if ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE &&
1048 cur[0]->encoding_id == TT_APPLE_ID_VARIANT_SELECTOR &&
1049 FT_Get_CMap_Format( cur[0] ) == 14 )
1050 return cur[0];
1051 }
1052
1053 return NULL;
1054 }
1055
1056
1057 /*************************************************************************/
1058 /* */
1059 /* <Function> */
1060 /* open_face */
1061 /* */
1062 /* <Description> */
1063 /* This function does some work for FT_Open_Face(). */
1064 /* */
1065 static FT_Error
1066 open_face( FT_Driver driver,
1067 FT_Stream stream,
1068 FT_Long face_index,
1069 FT_Int num_params,
1070 FT_Parameter* params,
1071 FT_Face *aface )
1072 {
1073 FT_Memory memory;
1074 FT_Driver_Class clazz;
1075 FT_Face face = 0;
1076 FT_Error error, error2;
1077 FT_Face_Internal internal = NULL;
1078
1079
1080 clazz = driver->clazz;
1081 memory = driver->root.memory;
1082
1083 /* allocate the face object and perform basic initialization */
1084 if ( FT_ALLOC( face, clazz->face_object_size ) )
1085 goto Fail;
1086
1087 if ( FT_NEW( internal ) )
1088 goto Fail;
1089
1090 face->internal = internal;
1091
1092 face->driver = driver;
1093 face->memory = memory;
1094 face->stream = stream;
1095
1096 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1097 {
1098 int i;
1099
1100
1101 face->internal->incremental_interface = 0;
1102 for ( i = 0; i < num_params && !face->internal->incremental_interface;
1103 i++ )
1104 if ( params[i].tag == FT_PARAM_TAG_INCREMENTAL )
1105 face->internal->incremental_interface =
1106 (FT_Incremental_Interface)params[i].data;
1107 }
1108 #endif
1109
1110 if ( clazz->init_face )
1111 error = clazz->init_face( stream,
1112 face,
1113 (FT_Int)face_index,
1114 num_params,
1115 params );
1116 if ( error )
1117 goto Fail;
1118
1119 /* select Unicode charmap by default */
1120 error2 = find_unicode_charmap( face );
1121
1122 /* if no Unicode charmap can be found, FT_Err_Invalid_CharMap_Handle */
1123 /* is returned. */
1124
1125 /* no error should happen, but we want to play safe */
1126 if ( error2 && error2 != FT_Err_Invalid_CharMap_Handle )
1127 {
1128 error = error2;
1129 goto Fail;
1130 }
1131
1132 *aface = face;
1133
1134 Fail:
1135 if ( error )
1136 {
1137 destroy_charmaps( face, memory );
1138 if ( clazz->done_face )
1139 clazz->done_face( face );
1140 FT_FREE( internal );
1141 FT_FREE( face );
1142 *aface = 0;
1143 }
1144
1145 return error;
1146 }
1147
1148
1149 /* there's a Mac-specific extended implementation of FT_New_Face() */
1150 /* in src/base/ftmac.c */
1151
1152 #if !defined( FT_MACINTOSH ) || defined( DARWIN_NO_CARBON )
1153
1154 /* documentation is in freetype.h */
1155
1156 FT_EXPORT_DEF( FT_Error )
1157 FT_New_Face( FT_Library library,
1158 const char* pathname,
1159 FT_Long face_index,
1160 FT_Face *aface )
1161 {
1162 FT_Open_Args args;
1163
1164
1165 /* test for valid `library' and `aface' delayed to FT_Open_Face() */
1166 if ( !pathname )
1167 return FT_Err_Invalid_Argument;
1168
1169 args.flags = FT_OPEN_PATHNAME;
1170 args.pathname = (char*)pathname;
1171 args.stream = NULL;
1172
1173 return FT_Open_Face( library, &args, face_index, aface );
1174 }
1175
1176 #endif /* defined( FT_MACINTOSH ) && !defined( DARWIN_NO_CARBON ) */
1177
1178
1179 /* documentation is in freetype.h */
1180
1181 FT_EXPORT_DEF( FT_Error )
1182 FT_New_Memory_Face( FT_Library library,
1183 const FT_Byte* file_base,
1184 FT_Long file_size,
1185 FT_Long face_index,
1186 FT_Face *aface )
1187 {
1188 FT_Open_Args args;
1189
1190
1191 /* test for valid `library' and `face' delayed to FT_Open_Face() */
1192 if ( !file_base )
1193 return FT_Err_Invalid_Argument;
1194
1195 args.flags = FT_OPEN_MEMORY;
1196 args.memory_base = file_base;
1197 args.memory_size = file_size;
1198 args.stream = NULL;
1199
1200 return FT_Open_Face( library, &args, face_index, aface );
1201 }
1202
1203
1204 #ifdef FT_CONFIG_OPTION_MAC_FONTS
1205
1206 /* The behavior here is very similar to that in base/ftmac.c, but it */
1207 /* is designed to work on non-mac systems, so no mac specific calls. */
1208 /* */
1209 /* We look at the file and determine if it is a mac dfont file or a mac */
1210 /* resource file, or a macbinary file containing a mac resource file. */
1211 /* */
1212 /* Unlike ftmac I'm not going to look at a `FOND'. I don't really see */
1213 /* the point, especially since there may be multiple `FOND' resources. */
1214 /* Instead I'll just look for `sfnt' and `POST' resources, ordered as */
1215 /* they occur in the file. */
1216 /* */
1217 /* Note that multiple `POST' resources do not mean multiple postscript */
1218 /* fonts; they all get jammed together to make what is essentially a */
1219 /* pfb file. */
1220 /* */
1221 /* We aren't interested in `NFNT' or `FONT' bitmap resources. */
1222 /* */
1223 /* As soon as we get an `sfnt' load it into memory and pass it off to */
1224 /* FT_Open_Face. */
1225 /* */
1226 /* If we have a (set of) `POST' resources, massage them into a (memory) */
1227 /* pfb file and pass that to FT_Open_Face. (As with ftmac.c I'm not */
1228 /* going to try to save the kerning info. After all that lives in the */
1229 /* `FOND' which isn't in the file containing the `POST' resources so */
1230 /* we don't really have access to it. */
1231
1232
1233 /* Finalizer for a memory stream; gets called by FT_Done_Face(). */
1234 /* It frees the memory it uses. */
1235 /* From ftmac.c. */
1236 static void
1237 memory_stream_close( FT_Stream stream )
1238 {
1239 FT_Memory memory = stream->memory;
1240
1241
1242 FT_FREE( stream->base );
1243
1244 stream->size = 0;
1245 stream->base = 0;
1246 stream->close = 0;
1247 }
1248
1249
1250 /* Create a new memory stream from a buffer and a size. */
1251 /* From ftmac.c. */
1252 static FT_Error
1253 new_memory_stream( FT_Library library,
1254 FT_Byte* base,
1255 FT_ULong size,
1256 FT_Stream_CloseFunc close,
1257 FT_Stream *astream )
1258 {
1259 FT_Error error;
1260 FT_Memory memory;
1261 FT_Stream stream;
1262
1263
1264 if ( !library )
1265 return FT_Err_Invalid_Library_Handle;
1266
1267 if ( !base )
1268 return FT_Err_Invalid_Argument;
1269
1270 *astream = 0;
1271 memory = library->memory;
1272 if ( FT_NEW( stream ) )
1273 goto Exit;
1274
1275 FT_Stream_OpenMemory( stream, base, size );
1276
1277 stream->close = close;
1278
1279 *astream = stream;
1280
1281 Exit:
1282 return error;
1283 }
1284
1285
1286 /* Create a new FT_Face given a buffer and a driver name. */
1287 /* from ftmac.c */
1288 FT_LOCAL_DEF( FT_Error )
1289 open_face_from_buffer( FT_Library library,
1290 FT_Byte* base,
1291 FT_ULong size,
1292 FT_Long face_index,
1293 const char* driver_name,
1294 FT_Face *aface )
1295 {
1296 FT_Open_Args args;
1297 FT_Error error;
1298 FT_Stream stream = NULL;
1299 FT_Memory memory = library->memory;
1300
1301
1302 error = new_memory_stream( library,
1303 base,
1304 size,
1305 memory_stream_close,
1306 &stream );
1307 if ( error )
1308 {
1309 FT_FREE( base );
1310 return error;
1311 }
1312
1313 args.flags = FT_OPEN_STREAM;
1314 args.stream = stream;
1315 if ( driver_name )
1316 {
1317 args.flags = args.flags | FT_OPEN_DRIVER;
1318 args.driver = FT_Get_Module( library, driver_name );
1319 }
1320
1321 #ifdef FT_MACINTOSH
1322 /* At this point, face_index has served its purpose; */
1323 /* whoever calls this function has already used it to */
1324 /* locate the correct font data. We should not propagate */
1325 /* this index to FT_Open_Face() (unless it is negative). */
1326
1327 if ( face_index > 0 )
1328 face_index = 0;
1329 #endif
1330
1331 error = FT_Open_Face( library, &args, face_index, aface );
1332
1333 if ( error == FT_Err_Ok )
1334 (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
1335 else
1336 #ifdef FT_MACINTOSH
1337 FT_Stream_Free( stream, 0 );
1338 #else
1339 {
1340 FT_Stream_Close( stream );
1341 FT_FREE( stream );
1342 }
1343 #endif
1344
1345 return error;
1346 }
1347
1348
1349 /* Look up `TYP1' or `CID ' table from sfnt table directory. */
1350 /* `offset' and `length' must exclude the binary header in tables. */
1351
1352 /* Type 1 and CID-keyed font drivers should recognize sfnt-wrapped */
1353 /* format too. Here, since we can't expect that the TrueType font */
1354 /* driver is loaded unconditially, we must parse the font by */
1355 /* ourselves. We are only interested in the name of the table and */
1356 /* the offset. */
1357
1358 static FT_Error
1359 ft_lookup_PS_in_sfnt_stream( FT_Stream stream,
1360 FT_Long face_index,
1361 FT_ULong* offset,
1362 FT_ULong* length,
1363 FT_Bool* is_sfnt_cid )
1364 {
1365 FT_Error error;
1366 FT_UShort numTables;
1367 FT_Long pstable_index;
1368 FT_ULong tag;
1369 int i;
1370
1371
1372 *offset = 0;
1373 *length = 0;
1374 *is_sfnt_cid = FALSE;
1375
1376 /* TODO: support for sfnt-wrapped PS/CID in TTC format */
1377
1378 /* version check for 'typ1' (should be ignored?) */
1379 if ( FT_READ_ULONG( tag ) )
1380 return error;
1381 if ( tag != TTAG_typ1 )
1382 return FT_Err_Unknown_File_Format;
1383
1384 if ( FT_READ_USHORT( numTables ) )
1385 return error;
1386 if ( FT_STREAM_SKIP( 2 * 3 ) ) /* skip binary search header */
1387 return error;
1388
1389 pstable_index = -1;
1390 *is_sfnt_cid = FALSE;
1391
1392 for ( i = 0; i < numTables; i++ )
1393 {
1394 if ( FT_READ_ULONG( tag ) || FT_STREAM_SKIP( 4 ) ||
1395 FT_READ_ULONG( *offset ) || FT_READ_ULONG( *length ) )
1396 return error;
1397
1398 if ( tag == TTAG_CID )
1399 {
1400 pstable_index++;
1401 *offset += 22;
1402 *length -= 22;
1403 *is_sfnt_cid = TRUE;
1404 if ( face_index < 0 )
1405 return FT_Err_Ok;
1406 }
1407 else if ( tag == TTAG_TYP1 )
1408 {
1409 pstable_index++;
1410 *offset += 24;
1411 *length -= 24;
1412 *is_sfnt_cid = FALSE;
1413 if ( face_index < 0 )
1414 return FT_Err_Ok;
1415 }
1416 if ( face_index >= 0 && pstable_index == face_index )
1417 return FT_Err_Ok;
1418 }
1419 return FT_Err_Table_Missing;
1420 }
1421
1422
1423 FT_LOCAL_DEF( FT_Error )
1424 open_face_PS_from_sfnt_stream( FT_Library library,
1425 FT_Stream stream,
1426 FT_Long face_index,
1427 FT_Int num_params,
1428 FT_Parameter *params,
1429 FT_Face *aface )
1430 {
1431 FT_Error error;
1432 FT_Memory memory = library->memory;
1433 FT_ULong offset, length;
1434 FT_Long pos;
1435 FT_Bool is_sfnt_cid;
1436 FT_Byte* sfnt_ps;
1437
1438 FT_UNUSED( num_params );
1439 FT_UNUSED( params );
1440
1441
1442 pos = FT_Stream_Pos( stream );
1443
1444 error = ft_lookup_PS_in_sfnt_stream( stream,
1445 face_index,
1446 &offset,
1447 &length,
1448 &is_sfnt_cid );
1449 if ( error )
1450 goto Exit;
1451
1452 if ( FT_Stream_Seek( stream, pos + offset ) )
1453 goto Exit;
1454
1455 if ( FT_ALLOC( sfnt_ps, (FT_Long)length ) )
1456 goto Exit;
1457
1458 error = FT_Stream_Read( stream, (FT_Byte *)sfnt_ps, length );
1459 if ( error )
1460 goto Exit;
1461
1462 error = open_face_from_buffer( library,
1463 sfnt_ps,
1464 length,
1465 face_index < 0 ? face_index : 0,
1466 is_sfnt_cid ? "cid" : "type1",
1467 aface );
1468 Exit:
1469 {
1470 FT_Error error1;
1471
1472
1473 if ( error == FT_Err_Unknown_File_Format )
1474 {
1475 error1 = FT_Stream_Seek( stream, pos );
1476 if ( error1 )
1477 return error1;
1478 }
1479
1480 return error;
1481 }
1482 }
1483
1484
1485 #if !defined( FT_MACINTOSH ) || defined( DARWIN_NO_CARBON )
1486
1487 /* The resource header says we've got resource_cnt `POST' (type1) */
1488 /* resources in this file. They all need to be coalesced into */
1489 /* one lump which gets passed on to the type1 driver. */
1490 /* Here can be only one PostScript font in a file so face_index */
1491 /* must be 0 (or -1). */
1492 /* */
1493 static FT_Error
1494 Mac_Read_POST_Resource( FT_Library library,
1495 FT_Stream stream,
1496 FT_Long *offsets,
1497 FT_Long resource_cnt,
1498 FT_Long face_index,
1499 FT_Face *aface )
1500 {
1501 FT_Error error = FT_Err_Cannot_Open_Resource;
1502 FT_Memory memory = library->memory;
1503 FT_Byte* pfb_data;
1504 int i, type, flags;
1505 FT_Long len;
1506 FT_Long pfb_len, pfb_pos, pfb_lenpos;
1507 FT_Long rlen, temp;
1508
1509
1510 if ( face_index == -1 )
1511 face_index = 0;
1512 if ( face_index != 0 )
1513 return error;
1514
1515 /* Find the length of all the POST resources, concatenated. Assume */
1516 /* worst case (each resource in its own section). */
1517 pfb_len = 0;
1518 for ( i = 0; i < resource_cnt; ++i )
1519 {
1520 error = FT_Stream_Seek( stream, offsets[i] );
1521 if ( error )
1522 goto Exit;
1523 if ( FT_READ_LONG( temp ) )
1524 goto Exit;
1525 pfb_len += temp + 6;
1526 }
1527
1528 if ( FT_ALLOC( pfb_data, (FT_Long)pfb_len + 2 ) )
1529 goto Exit;
1530
1531 pfb_data[0] = 0x80;
1532 pfb_data[1] = 1; /* Ascii section */
1533 pfb_data[2] = 0; /* 4-byte length, fill in later */
1534 pfb_data[3] = 0;
1535 pfb_data[4] = 0;
1536 pfb_data[5] = 0;
1537 pfb_pos = 6;
1538 pfb_lenpos = 2;
1539
1540 len = 0;
1541 type = 1;
1542 for ( i = 0; i < resource_cnt; ++i )
1543 {
1544 error = FT_Stream_Seek( stream, offsets[i] );
1545 if ( error )
1546 goto Exit2;
1547 if ( FT_READ_LONG( rlen ) )
1548 goto Exit;
1549 if ( FT_READ_USHORT( flags ) )
1550 goto Exit;
1551 rlen -= 2; /* the flags are part of the resource */
1552 if ( ( flags >> 8 ) == type )
1553 len += rlen;
1554 else
1555 {
1556 pfb_data[pfb_lenpos ] = (FT_Byte)( len );
1557 pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 );
1558 pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 );
1559 pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 );
1560
1561 if ( ( flags >> 8 ) == 5 ) /* End of font mark */
1562 break;
1563
1564 pfb_data[pfb_pos++] = 0x80;
1565
1566 type = flags >> 8;
1567 len = rlen;
1568
1569 pfb_data[pfb_pos++] = (FT_Byte)type;
1570 pfb_lenpos = pfb_pos;
1571 pfb_data[pfb_pos++] = 0; /* 4-byte length, fill in later */
1572 pfb_data[pfb_pos++] = 0;
1573 pfb_data[pfb_pos++] = 0;
1574 pfb_data[pfb_pos++] = 0;
1575 }
1576
1577 error = FT_Stream_Read( stream, (FT_Byte *)pfb_data + pfb_pos, rlen );
1578 pfb_pos += rlen;
1579 }
1580
1581 pfb_data[pfb_pos++] = 0x80;
1582 pfb_data[pfb_pos++] = 3;
1583
1584 pfb_data[pfb_lenpos ] = (FT_Byte)( len );
1585 pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 );
1586 pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 );
1587 pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 );
1588
1589 return open_face_from_buffer( library,
1590 pfb_data,
1591 pfb_pos,
1592 face_index,
1593 "type1",
1594 aface );
1595
1596 Exit2:
1597 FT_FREE( pfb_data );
1598
1599 Exit:
1600 return error;
1601 }
1602
1603
1604 /* The resource header says we've got resource_cnt `sfnt' */
1605 /* (TrueType/OpenType) resources in this file. Look through */
1606 /* them for the one indicated by face_index, load it into mem, */
1607 /* pass it on the the truetype driver and return it. */
1608 /* */
1609 static FT_Error
1610 Mac_Read_sfnt_Resource( FT_Library library,
1611 FT_Stream stream,
1612 FT_Long *offsets,
1613 FT_Long resource_cnt,
1614 FT_Long face_index,
1615 FT_Face *aface )
1616 {
1617 FT_Memory memory = library->memory;
1618 FT_Byte* sfnt_data;
1619 FT_Error error;
1620 FT_Long flag_offset;
1621 FT_Long rlen;
1622 int is_cff;
1623 FT_Long face_index_in_resource = 0;
1624
1625
1626 if ( face_index == -1 )
1627 face_index = 0;
1628 if ( face_index >= resource_cnt )
1629 return FT_Err_Cannot_Open_Resource;
1630
1631 flag_offset = offsets[face_index];
1632 error = FT_Stream_Seek( stream, flag_offset );
1633 if ( error )
1634 goto Exit;
1635
1636 if ( FT_READ_LONG( rlen ) )
1637 goto Exit;
1638 if ( rlen == -1 )
1639 return FT_Err_Cannot_Open_Resource;
1640
1641 error = open_face_PS_from_sfnt_stream( library,
1642 stream,
1643 face_index,
1644 0, NULL,
1645 aface );
1646 if ( !error )
1647 goto Exit;
1648
1649 /* rewind sfnt stream before open_face_PS_from_sfnt_stream() */
1650 if ( FT_Stream_Seek( stream, flag_offset + 4 ) )
1651 goto Exit;
1652
1653 if ( FT_ALLOC( sfnt_data, (FT_Long)rlen ) )
1654 return error;
1655 error = FT_Stream_Read( stream, (FT_Byte *)sfnt_data, rlen );
1656 if ( error )
1657 goto Exit;
1658
1659 is_cff = rlen > 4 && !ft_memcmp( sfnt_data, "OTTO", 4 );
1660 error = open_face_from_buffer( library,
1661 sfnt_data,
1662 rlen,
1663 face_index_in_resource,
1664 is_cff ? "cff" : "truetype",
1665 aface );
1666
1667 Exit:
1668 return error;
1669 }
1670
1671
1672 /* Check for a valid resource fork header, or a valid dfont */
1673 /* header. In a resource fork the first 16 bytes are repeated */
1674 /* at the location specified by bytes 4-7. In a dfont bytes */
1675 /* 4-7 point to 16 bytes of zeroes instead. */
1676 /* */
1677 static FT_Error
1678 IsMacResource( FT_Library library,
1679 FT_Stream stream,
1680 FT_Long resource_offset,
1681 FT_Long face_index,
1682 FT_Face *aface )
1683 {
1684 FT_Memory memory = library->memory;
1685 FT_Error error;
1686 FT_Long map_offset, rdara_pos;
1687 FT_Long *data_offsets;
1688 FT_Long count;
1689
1690
1691 error = FT_Raccess_Get_HeaderInfo( library, stream, resource_offset,
1692 &map_offset, &rdara_pos );
1693 if ( error )
1694 return error;
1695
1696 error = FT_Raccess_Get_DataOffsets( library, stream,
1697 map_offset, rdara_pos,
1698 TTAG_POST,
1699 &data_offsets, &count );
1700 if ( !error )
1701 {
1702 error = Mac_Read_POST_Resource( library, stream, data_offsets, count,
1703 face_index, aface );
1704 FT_FREE( data_offsets );
1705 /* POST exists in an LWFN providing a single face */
1706 if ( !error )
1707 (*aface)->num_faces = 1;
1708 return error;
1709 }
1710
1711 error = FT_Raccess_Get_DataOffsets( library, stream,
1712 map_offset, rdara_pos,
1713 TTAG_sfnt,
1714 &data_offsets, &count );
1715 if ( !error )
1716 {
1717 FT_Long face_index_internal = face_index % count;
1718
1719
1720 error = Mac_Read_sfnt_Resource( library, stream, data_offsets, count,
1721 face_index_internal, aface );
1722 FT_FREE( data_offsets );
1723 if ( !error )
1724 (*aface)->num_faces = count;
1725 }
1726
1727 return error;
1728 }
1729
1730
1731 /* Check for a valid macbinary header, and if we find one */
1732 /* check that the (flattened) resource fork in it is valid. */
1733 /* */
1734 static FT_Error
1735 IsMacBinary( FT_Library library,
1736 FT_Stream stream,
1737 FT_Long face_index,
1738 FT_Face *aface )
1739 {
1740 unsigned char header[128];
1741 FT_Error error;
1742 FT_Long dlen, offset;
1743
1744
1745 if ( NULL == stream )
1746 return FT_Err_Invalid_Stream_Operation;
1747
1748 error = FT_Stream_Seek( stream, 0 );
1749 if ( error )
1750 goto Exit;
1751
1752 error = FT_Stream_Read( stream, (FT_Byte*)header, 128 );
1753 if ( error )
1754 goto Exit;
1755
1756 if ( header[ 0] != 0 ||
1757 header[74] != 0 ||
1758 header[82] != 0 ||
1759 header[ 1] == 0 ||
1760 header[ 1] > 33 ||
1761 header[63] != 0 ||
1762 header[2 + header[1]] != 0 )
1763 return FT_Err_Unknown_File_Format;
1764
1765 dlen = ( header[0x53] << 24 ) |
1766 ( header[0x54] << 16 ) |
1767 ( header[0x55] << 8 ) |
1768 header[0x56];
1769 #if 0
1770 rlen = ( header[0x57] << 24 ) |
1771 ( header[0x58] << 16 ) |
1772 ( header[0x59] << 8 ) |
1773 header[0x5a];
1774 #endif /* 0 */
1775 offset = 128 + ( ( dlen + 127 ) & ~127 );
1776
1777 return IsMacResource( library, stream, offset, face_index, aface );
1778
1779 Exit:
1780 return error;
1781 }
1782
1783
1784 static FT_Error
1785 load_face_in_embedded_rfork( FT_Library library,
1786 FT_Stream stream,
1787 FT_Long face_index,
1788 FT_Face *aface,
1789 const FT_Open_Args *args )
1790 {
1791
1792 #undef FT_COMPONENT
1793 #define FT_COMPONENT trace_raccess
1794
1795 FT_Memory memory = library->memory;
1796 FT_Error error = FT_Err_Unknown_File_Format;
1797 int i;
1798
1799 char * file_names[FT_RACCESS_N_RULES];
1800 FT_Long offsets[FT_RACCESS_N_RULES];
1801 FT_Error errors[FT_RACCESS_N_RULES];
1802
1803 FT_Open_Args args2;
1804 FT_Stream stream2 = 0;
1805
1806
1807 FT_Raccess_Guess( library, stream,
1808 args->pathname, file_names, offsets, errors );
1809
1810 for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
1811 {
1812 if ( errors[i] )
1813 {
1814 FT_TRACE3(( "Error[%d] has occurred in rule %d\n", errors[i], i ));
1815 continue;
1816 }
1817
1818 args2.flags = FT_OPEN_PATHNAME;
1819 args2.pathname = file_names[i] ? file_names[i] : args->pathname;
1820
1821 FT_TRACE3(( "Try rule %d: %s (offset=%d) ...",
1822 i, args2.pathname, offsets[i] ));
1823
1824 error = FT_Stream_New( library, &args2, &stream2 );
1825 if ( error )
1826 {
1827 FT_TRACE3(( "failed\n" ));
1828 continue;
1829 }
1830
1831 error = IsMacResource( library, stream2, offsets[i],
1832 face_index, aface );
1833 FT_Stream_Free( stream2, 0 );
1834
1835 FT_TRACE3(( "%s\n", error ? "failed": "successful" ));
1836
1837 if ( !error )
1838 break;
1839 }
1840
1841 for (i = 0; i < FT_RACCESS_N_RULES; i++)
1842 {
1843 if ( file_names[i] )
1844 FT_FREE( file_names[i] );
1845 }
1846
1847 /* Caller (load_mac_face) requires FT_Err_Unknown_File_Format. */
1848 if ( error )
1849 error = FT_Err_Unknown_File_Format;
1850
1851 return error;
1852
1853 #undef FT_COMPONENT
1854 #define FT_COMPONENT trace_objs
1855
1856 }
1857
1858
1859 /* Check for some macintosh formats without Carbon framework. */
1860 /* Is this a macbinary file? If so look at the resource fork. */
1861 /* Is this a mac dfont file? */
1862 /* Is this an old style resource fork? (in data) */
1863 /* Else call load_face_in_embedded_rfork to try extra rules */
1864 /* (defined in `ftrfork.c'). */
1865 /* */
1866 static FT_Error
1867 load_mac_face( FT_Library library,
1868 FT_Stream stream,
1869 FT_Long face_index,
1870 FT_Face *aface,
1871 const FT_Open_Args *args )
1872 {
1873 FT_Error error;
1874 FT_UNUSED( args );
1875
1876
1877 error = IsMacBinary( library, stream, face_index, aface );
1878 if ( FT_ERROR_BASE( error ) == FT_Err_Unknown_File_Format )
1879 {
1880
1881 #undef FT_COMPONENT
1882 #define FT_COMPONENT trace_raccess
1883
1884 FT_TRACE3(( "Try as dfont: %s ...", args->pathname ));
1885
1886 error = IsMacResource( library, stream, 0, face_index, aface );
1887
1888 FT_TRACE3(( "%s\n", error ? "failed" : "successful" ));
1889
1890 #undef FT_COMPONENT
1891 #define FT_COMPONENT trace_objs
1892
1893 }
1894
1895 if ( ( FT_ERROR_BASE( error ) == FT_Err_Unknown_File_Format ||
1896 FT_ERROR_BASE( error ) == FT_Err_Invalid_Stream_Operation ) &&
1897 ( args->flags & FT_OPEN_PATHNAME ) )
1898 error = load_face_in_embedded_rfork( library, stream,
1899 face_index, aface, args );
1900 return error;
1901 }
1902 #endif
1903
1904 #endif /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */
1905
1906
1907 /* documentation is in freetype.h */
1908
1909 FT_EXPORT_DEF( FT_Error )
1910 FT_Open_Face( FT_Library library,
1911 const FT_Open_Args* args,
1912 FT_Long face_index,
1913 FT_Face *aface )
1914 {
1915 FT_Error error;
1916 FT_Driver driver;
1917 FT_Memory memory;
1918 FT_Stream stream = 0;
1919 FT_Face face = 0;
1920 FT_ListNode node = 0;
1921 FT_Bool external_stream;
1922 FT_Module* cur;
1923 FT_Module* limit;
1924
1925
1926 /* test for valid `library' delayed to */
1927 /* FT_Stream_New() */
1928
1929 if ( ( !aface && face_index >= 0 ) || !args )
1930 return FT_Err_Invalid_Argument;
1931
1932 external_stream = FT_BOOL( ( args->flags & FT_OPEN_STREAM ) &&
1933 args->stream );
1934
1935 /* create input stream */
1936 error = FT_Stream_New( library, args, &stream );
1937 if ( error )
1938 goto Fail3;
1939
1940 memory = library->memory;
1941
1942 /* If the font driver is specified in the `args' structure, use */
1943 /* it. Otherwise, we scan the list of registered drivers. */
1944 if ( ( args->flags & FT_OPEN_DRIVER ) && args->driver )
1945 {
1946 driver = FT_DRIVER( args->driver );
1947
1948 /* not all modules are drivers, so check... */
1949 if ( FT_MODULE_IS_DRIVER( driver ) )
1950 {
1951 FT_Int num_params = 0;
1952 FT_Parameter* params = 0;
1953
1954
1955 if ( args->flags & FT_OPEN_PARAMS )
1956 {
1957 num_params = args->num_params;
1958 params = args->params;
1959 }
1960
1961 error = open_face( driver, stream, face_index,
1962 num_params, params, &face );
1963 if ( !error )
1964 goto Success;
1965 }
1966 else
1967 error = FT_Err_Invalid_Handle;
1968
1969 FT_Stream_Free( stream, external_stream );
1970 goto Fail;
1971 }
1972 else
1973 {
1974 /* check each font driver for an appropriate format */
1975 cur = library->modules;
1976 limit = cur + library->num_modules;
1977
1978
1979 for ( ; cur < limit; cur++ )
1980 {
1981 /* not all modules are font drivers, so check... */
1982 if ( FT_MODULE_IS_DRIVER( cur[0] ) )
1983 {
1984 FT_Int num_params = 0;
1985 FT_Parameter* params = 0;
1986
1987
1988 driver = FT_DRIVER( cur[0] );
1989
1990 if ( args->flags & FT_OPEN_PARAMS )
1991 {
1992 num_params = args->num_params;
1993 params = args->params;
1994 }
1995
1996 error = open_face( driver, stream, face_index,
1997 num_params, params, &face );
1998 if ( !error )
1999 goto Success;
2000
2001 #ifdef FT_CONFIG_OPTION_MAC_FONTS
2002 if ( ft_strcmp( cur[0]->clazz->module_name, "truetype" ) == 0 &&
2003 FT_ERROR_BASE( error ) == FT_Err_Table_Missing )
2004 {
2005 /* TrueType but essential tables are missing */
2006 if ( FT_Stream_Seek( stream, 0 ) )
2007 break;
2008
2009 error = open_face_PS_from_sfnt_stream( library,
2010 stream,
2011 face_index,
2012 num_params,
2013 params,
2014 aface );
2015 if ( !error )
2016 {
2017 FT_Stream_Free( stream, external_stream );
2018 return error;
2019 }
2020 }
2021 #endif
2022
2023 if ( FT_ERROR_BASE( error ) != FT_Err_Unknown_File_Format )
2024 goto Fail3;
2025 }
2026 }
2027
2028 Fail3:
2029 /* If we are on the mac, and we get an FT_Err_Invalid_Stream_Operation */
2030 /* it may be because we have an empty data fork, so we need to check */
2031 /* the resource fork. */
2032 if ( FT_ERROR_BASE( error ) != FT_Err_Cannot_Open_Stream &&
2033 FT_ERROR_BASE( error ) != FT_Err_Unknown_File_Format &&
2034 FT_ERROR_BASE( error ) != FT_Err_Invalid_Stream_Operation )
2035 goto Fail2;
2036
2037 #if !defined( FT_MACINTOSH ) && defined( FT_CONFIG_OPTION_MAC_FONTS )
2038 error = load_mac_face( library, stream, face_index, aface, args );
2039 if ( !error )
2040 {
2041 /* We don't want to go to Success here. We've already done that. */
2042 /* On the other hand, if we succeeded we still need to close this */
2043 /* stream (we opened a different stream which extracted the */
2044 /* interesting information out of this stream here. That stream */
2045 /* will still be open and the face will point to it). */
2046 FT_Stream_Free( stream, external_stream );
2047 return error;
2048 }
2049
2050 if ( FT_ERROR_BASE( error ) != FT_Err_Unknown_File_Format )
2051 goto Fail2;
2052 #endif /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */
2053
2054 /* no driver is able to handle this format */
2055 error = FT_Err_Unknown_File_Format;
2056
2057 Fail2:
2058 FT_Stream_Free( stream, external_stream );
2059 goto Fail;
2060 }
2061
2062 Success:
2063 FT_TRACE4(( "FT_Open_Face: New face object, adding to list\n" ));
2064
2065 /* set the FT_FACE_FLAG_EXTERNAL_STREAM bit for FT_Done_Face */
2066 if ( external_stream )
2067 face->face_flags |= FT_FACE_FLAG_EXTERNAL_STREAM;
2068
2069 /* add the face object to its driver's list */
2070 if ( FT_NEW( node ) )
2071 goto Fail;
2072
2073 node->data = face;
2074 /* don't assume driver is the same as face->driver, so use */
2075 /* face->driver instead. */
2076 FT_List_Add( &face->driver->faces_list, node );
2077
2078 /* now allocate a glyph slot object for the face */
2079 FT_TRACE4(( "FT_Open_Face: Creating glyph slot\n" ));
2080
2081 if ( face_index >= 0 )
2082 {
2083 error = FT_New_GlyphSlot( face, NULL );
2084 if ( error )
2085 goto Fail;
2086
2087 /* finally, allocate a size object for the face */
2088 {
2089 FT_Size size;
2090
2091
2092 FT_TRACE4(( "FT_Open_Face: Creating size object\n" ));
2093
2094 error = FT_New_Size( face, &size );
2095 if ( error )
2096 goto Fail;
2097
2098 face->size = size;
2099 }
2100 }
2101
2102 /* some checks */
2103
2104 if ( FT_IS_SCALABLE( face ) )
2105 {
2106 if ( face->height < 0 )
2107 face->height = (FT_Short)-face->height;
2108
2109 if ( !FT_HAS_VERTICAL( face ) )
2110 face->max_advance_height = (FT_Short)face->height;
2111 }
2112
2113 if ( FT_HAS_FIXED_SIZES( face ) )
2114 {
2115 FT_Int i;
2116
2117
2118 for ( i = 0; i < face->num_fixed_sizes; i++ )
2119 {
2120 FT_Bitmap_Size* bsize = face->available_sizes + i;
2121
2122
2123 if ( bsize->height < 0 )
2124 bsize->height = (FT_Short)-bsize->height;
2125 if ( bsize->x_ppem < 0 )
2126 bsize->x_ppem = (FT_Short)-bsize->x_ppem;
2127 if ( bsize->y_ppem < 0 )
2128 bsize->y_ppem = -bsize->y_ppem;
2129 }
2130 }
2131
2132 /* initialize internal face data */
2133 {
2134 FT_Face_Internal internal = face->internal;
2135
2136
2137 internal->transform_matrix.xx = 0x10000L;
2138 internal->transform_matrix.xy = 0;
2139 internal->transform_matrix.yx = 0;
2140 internal->transform_matrix.yy = 0x10000L;
2141
2142 internal->transform_delta.x = 0;
2143 internal->transform_delta.y = 0;
2144 }
2145
2146 if ( aface )
2147 *aface = face;
2148 else
2149 FT_Done_Face( face );
2150
2151 goto Exit;
2152
2153 Fail:
2154 FT_Done_Face( face );
2155
2156 Exit:
2157 FT_TRACE4(( "FT_Open_Face: Return %d\n", error ));
2158
2159 return error;
2160 }
2161
2162
2163 /* documentation is in freetype.h */
2164
2165 FT_EXPORT_DEF( FT_Error )
2166 FT_Attach_File( FT_Face face,
2167 const char* filepathname )
2168 {
2169 FT_Open_Args open;
2170
2171
2172 /* test for valid `face' delayed to FT_Attach_Stream() */
2173
2174 if ( !filepathname )
2175 return FT_Err_Invalid_Argument;
2176
2177 open.stream = NULL;
2178 open.flags = FT_OPEN_PATHNAME;
2179 open.pathname = (char*)filepathname;
2180
2181 return FT_Attach_Stream( face, &open );
2182 }
2183
2184
2185 /* documentation is in freetype.h */
2186
2187 FT_EXPORT_DEF( FT_Error )
2188 FT_Attach_Stream( FT_Face face,
2189 FT_Open_Args* parameters )
2190 {
2191 FT_Stream stream;
2192 FT_Error error;
2193 FT_Driver driver;
2194
2195 FT_Driver_Class clazz;
2196
2197
2198 /* test for valid `parameters' delayed to FT_Stream_New() */
2199
2200 if ( !face )
2201 return FT_Err_Invalid_Face_Handle;
2202
2203 driver = face->driver;
2204 if ( !driver )
2205 return FT_Err_Invalid_Driver_Handle;
2206
2207 error = FT_Stream_New( driver->root.library, parameters, &stream );
2208 if ( error )
2209 goto Exit;
2210
2211 /* we implement FT_Attach_Stream in each driver through the */
2212 /* `attach_file' interface */
2213
2214 error = FT_Err_Unimplemented_Feature;
2215 clazz = driver->clazz;
2216 if ( clazz->attach_file )
2217 error = clazz->attach_file( face, stream );
2218
2219 /* close the attached stream */
2220 FT_Stream_Free( stream,
2221 (FT_Bool)( parameters->stream &&
2222 ( parameters->flags & FT_OPEN_STREAM ) ) );
2223
2224 Exit:
2225 return error;
2226 }
2227
2228
2229 /* documentation is in freetype.h */
2230
2231 FT_EXPORT_DEF( FT_Error )
2232 FT_Done_Face( FT_Face face )
2233 {
2234 FT_Error error;
2235 FT_Driver driver;
2236 FT_Memory memory;
2237 FT_ListNode node;
2238
2239
2240 error = FT_Err_Invalid_Face_Handle;
2241 if ( face && face->driver )
2242 {
2243 driver = face->driver;
2244 memory = driver->root.memory;
2245
2246 /* find face in driver's list */
2247 node = FT_List_Find( &driver->faces_list, face );
2248 if ( node )
2249 {
2250 /* remove face object from the driver's list */
2251 FT_List_Remove( &driver->faces_list, node );
2252 FT_FREE( node );
2253
2254 /* now destroy the object proper */
2255 destroy_face( memory, face, driver );
2256 error = FT_Err_Ok;
2257 }
2258 }
2259 return error;
2260 }
2261
2262
2263 /* documentation is in ftobjs.h */
2264
2265 FT_EXPORT_DEF( FT_Error )
2266 FT_New_Size( FT_Face face,
2267 FT_Size *asize )
2268 {
2269 FT_Error error;
2270 FT_Memory memory;
2271 FT_Driver driver;
2272 FT_Driver_Class clazz;
2273
2274 FT_Size size = 0;
2275 FT_ListNode node = 0;
2276
2277
2278 if ( !face )
2279 return FT_Err_Invalid_Face_Handle;
2280
2281 if ( !asize )
2282 return FT_Err_Invalid_Size_Handle;
2283
2284 if ( !face->driver )
2285 return FT_Err_Invalid_Driver_Handle;
2286
2287 *asize = 0;
2288
2289 driver = face->driver;
2290 clazz = driver->clazz;
2291 memory = face->memory;
2292
2293 /* Allocate new size object and perform basic initialisation */
2294 if ( FT_ALLOC( size, clazz->size_object_size ) || FT_NEW( node ) )
2295 goto Exit;
2296
2297 size->face = face;
2298
2299 /* for now, do not use any internal fields in size objects */
2300 size->internal = 0;
2301
2302 if ( clazz->init_size )
2303 error = clazz->init_size( size );
2304
2305 /* in case of success, add to the face's list */
2306 if ( !error )
2307 {
2308 *asize = size;
2309 node->data = size;
2310 FT_List_Add( &face->sizes_list, node );
2311 }
2312
2313 Exit:
2314 if ( error )
2315 {
2316 FT_FREE( node );
2317 FT_FREE( size );
2318 }
2319
2320 return error;
2321 }
2322
2323
2324 /* documentation is in ftobjs.h */
2325
2326 FT_EXPORT_DEF( FT_Error )
2327 FT_Done_Size( FT_Size size )
2328 {
2329 FT_Error error;
2330 FT_Driver driver;
2331 FT_Memory memory;
2332 FT_Face face;
2333 FT_ListNode node;
2334
2335
2336 if ( !size )
2337 return FT_Err_Invalid_Size_Handle;
2338
2339 face = size->face;
2340 if ( !face )
2341 return FT_Err_Invalid_Face_Handle;
2342
2343 driver = face->driver;
2344 if ( !driver )
2345 return FT_Err_Invalid_Driver_Handle;
2346
2347 memory = driver->root.memory;
2348
2349 error = FT_Err_Ok;
2350 node = FT_List_Find( &face->sizes_list, size );
2351 if ( node )
2352 {
2353 FT_List_Remove( &face->sizes_list, node );
2354 FT_FREE( node );
2355
2356 if ( face->size == size )
2357 {
2358 face->size = 0;
2359 if ( face->sizes_list.head )
2360 face->size = (FT_Size)(face->sizes_list.head->data);
2361 }
2362
2363 destroy_size( memory, size, driver );
2364 }
2365 else
2366 error = FT_Err_Invalid_Size_Handle;
2367
2368 return error;
2369 }
2370
2371
2372 /* documentation is in ftobjs.h */
2373
2374 FT_BASE_DEF( FT_Error )
2375 FT_Match_Size( FT_Face face,
2376 FT_Size_Request req,
2377 FT_Bool ignore_width,
2378 FT_ULong* size_index )
2379 {
2380 FT_Int i;
2381 FT_Long w, h;
2382
2383
2384 if ( !FT_HAS_FIXED_SIZES( face ) )
2385 return FT_Err_Invalid_Face_Handle;
2386
2387 /* FT_Bitmap_Size doesn't provide enough info... */
2388 if ( req->type != FT_SIZE_REQUEST_TYPE_NOMINAL )
2389 return FT_Err_Unimplemented_Feature;
2390
2391 w = FT_REQUEST_WIDTH ( req );
2392 h = FT_REQUEST_HEIGHT( req );
2393
2394 if ( req->width && !req->height )
2395 h = w;
2396 else if ( !req->width && req->height )
2397 w = h;
2398
2399 w = FT_PIX_ROUND( w );
2400 h = FT_PIX_ROUND( h );
2401
2402 for ( i = 0; i < face->num_fixed_sizes; i++ )
2403 {
2404 FT_Bitmap_Size* bsize = face->available_sizes + i;
2405
2406
2407 if ( h != FT_PIX_ROUND( bsize->y_ppem ) )
2408 continue;
2409
2410 if ( w == FT_PIX_ROUND( bsize->x_ppem ) || ignore_width )
2411 {
2412 if ( size_index )
2413 *size_index = (FT_ULong)i;
2414
2415 return FT_Err_Ok;
2416 }
2417 }
2418
2419 return FT_Err_Invalid_Pixel_Size;
2420 }
2421
2422
2423 /* documentation is in ftobjs.h */
2424
2425 FT_BASE_DEF( void )
2426 ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics,
2427 FT_Pos advance )
2428 {
2429 FT_Pos height = metrics->height;
2430
2431
2432 /* compensate for glyph with bbox above/below the baseline */
2433 if ( metrics->horiBearingY < 0 )
2434 {
2435 if ( height < metrics->horiBearingY )
2436 height = metrics->horiBearingY;
2437 }
2438 else if ( metrics->horiBearingY > 0 )
2439 height -= metrics->horiBearingY;
2440
2441 /* the factor 1.2 is a heuristical value */
2442 if ( !advance )
2443 advance = height * 12 / 10;
2444
2445 metrics->vertBearingX = metrics->horiBearingX - metrics->horiAdvance / 2;
2446 metrics->vertBearingY = ( advance - height ) / 2;
2447 metrics->vertAdvance = advance;
2448 }
2449
2450
2451 static void
2452 ft_recompute_scaled_metrics( FT_Face face,
2453 FT_Size_Metrics* metrics )
2454 {
2455 /* Compute root ascender, descender, test height, and max_advance */
2456
2457 #ifdef GRID_FIT_METRICS
2458 metrics->ascender = FT_PIX_CEIL( FT_MulFix( face->ascender,
2459 metrics->y_scale ) );
2460
2461 metrics->descender = FT_PIX_FLOOR( FT_MulFix( face->descender,
2462 metrics->y_scale ) );
2463
2464 metrics->height = FT_PIX_ROUND( FT_MulFix( face->height,
2465 metrics->y_scale ) );
2466
2467 metrics->max_advance = FT_PIX_ROUND( FT_MulFix( face->max_advance_width,
2468 metrics->x_scale ) );
2469 #else /* !GRID_FIT_METRICS */
2470 metrics->ascender = FT_MulFix( face->ascender,
2471 metrics->y_scale );
2472
2473 metrics->descender = FT_MulFix( face->descender,
2474 metrics->y_scale );
2475
2476 metrics->height = FT_MulFix( face->height,
2477 metrics->y_scale );
2478
2479 metrics->max_advance = FT_MulFix( face->max_advance_width,
2480 metrics->x_scale );
2481 #endif /* !GRID_FIT_METRICS */
2482 }
2483
2484
2485 FT_BASE_DEF( void )
2486 FT_Select_Metrics( FT_Face face,
2487 FT_ULong strike_index )
2488 {
2489 FT_Size_Metrics* metrics;
2490 FT_Bitmap_Size* bsize;
2491
2492
2493 metrics = &face->size->metrics;
2494 bsize = face->available_sizes + strike_index;
2495
2496 metrics->x_ppem = (FT_UShort)( ( bsize->x_ppem + 32 ) >> 6 );
2497 metrics->y_ppem = (FT_UShort)( ( bsize->y_ppem + 32 ) >> 6 );
2498
2499 if ( FT_IS_SCALABLE( face ) )
2500 {
2501 metrics->x_scale = FT_DivFix( bsize->x_ppem,
2502 face->units_per_EM );
2503 metrics->y_scale = FT_DivFix( bsize->y_ppem,
2504 face->units_per_EM );
2505
2506 ft_recompute_scaled_metrics( face, metrics );
2507 }
2508 else
2509 {
2510 metrics->x_scale = 1L << 16;
2511 metrics->y_scale = 1L << 16;
2512 metrics->ascender = bsize->y_ppem;
2513 metrics->descender = 0;
2514 metrics->height = bsize->height << 6;
2515 metrics->max_advance = bsize->x_ppem;
2516 }
2517 }
2518
2519
2520 FT_BASE_DEF( void )
2521 FT_Request_Metrics( FT_Face face,
2522 FT_Size_Request req )
2523 {
2524 FT_Size_Metrics* metrics;
2525
2526
2527 metrics = &face->size->metrics;
2528
2529 if ( FT_IS_SCALABLE( face ) )
2530 {
2531 FT_Long w = 0, h = 0, scaled_w = 0, scaled_h = 0;
2532
2533
2534 switch ( req->type )
2535 {
2536 case FT_SIZE_REQUEST_TYPE_NOMINAL:
2537 w = h = face->units_per_EM;
2538 break;
2539
2540 case FT_SIZE_REQUEST_TYPE_REAL_DIM:
2541 w = h = face->ascender - face->descender;
2542 break;
2543
2544 case FT_SIZE_REQUEST_TYPE_BBOX:
2545 w = face->bbox.xMax - face->bbox.xMin;
2546 h = face->bbox.yMax - face->bbox.yMin;
2547 break;
2548
2549 case FT_SIZE_REQUEST_TYPE_CELL:
2550 w = face->max_advance_width;
2551 h = face->ascender - face->descender;
2552 break;
2553
2554 case FT_SIZE_REQUEST_TYPE_SCALES:
2555 metrics->x_scale = (FT_Fixed)req->width;
2556 metrics->y_scale = (FT_Fixed)req->height;
2557 if ( !metrics->x_scale )
2558 metrics->x_scale = metrics->y_scale;
2559 else if ( !metrics->y_scale )
2560 metrics->y_scale = metrics->x_scale;
2561 goto Calculate_Ppem;
2562
2563 case FT_SIZE_REQUEST_TYPE_MAX:
2564 break;
2565 }
2566
2567 /* to be on the safe side */
2568 if ( w < 0 )
2569 w = -w;
2570
2571 if ( h < 0 )
2572 h = -h;
2573
2574 scaled_w = FT_REQUEST_WIDTH ( req );
2575 scaled_h = FT_REQUEST_HEIGHT( req );
2576
2577 /* determine scales */
2578 if ( req->width )
2579 {
2580 metrics->x_scale = FT_DivFix( scaled_w, w );
2581
2582 if ( req->height )
2583 {
2584 metrics->y_scale = FT_DivFix( scaled_h, h );
2585
2586 if ( req->type == FT_SIZE_REQUEST_TYPE_CELL )
2587 {
2588 if ( metrics->y_scale > metrics->x_scale )
2589 metrics->y_scale = metrics->x_scale;
2590 else
2591 metrics->x_scale = metrics->y_scale;
2592 }
2593 }
2594 else
2595 {
2596 metrics->y_scale = metrics->x_scale;
2597 scaled_h = FT_MulDiv( scaled_w, h, w );
2598 }
2599 }
2600 else
2601 {
2602 metrics->x_scale = metrics->y_scale = FT_DivFix( scaled_h, h );
2603 scaled_w = FT_MulDiv( scaled_h, w, h );
2604 }
2605
2606 Calculate_Ppem:
2607 /* calculate the ppems */
2608 if ( req->type != FT_SIZE_REQUEST_TYPE_NOMINAL )
2609 {
2610 scaled_w = FT_MulFix( face->units_per_EM, metrics->x_scale );
2611 scaled_h = FT_MulFix( face->units_per_EM, metrics->y_scale );
2612 }
2613
2614 metrics->x_ppem = (FT_UShort)( ( scaled_w + 32 ) >> 6 );
2615 metrics->y_ppem = (FT_UShort)( ( scaled_h + 32 ) >> 6 );
2616
2617 ft_recompute_scaled_metrics( face, metrics );
2618 }
2619 else
2620 {
2621 FT_ZERO( metrics );
2622 metrics->x_scale = 1L << 16;
2623 metrics->y_scale = 1L << 16;
2624 }
2625 }
2626
2627
2628 /* documentation is in freetype.h */
2629
2630 FT_EXPORT_DEF( FT_Error )
2631 FT_Select_Size( FT_Face face,
2632 FT_Int strike_index )
2633 {
2634 FT_Driver_Class clazz;
2635
2636
2637 if ( !face || !FT_HAS_FIXED_SIZES( face ) )
2638 return FT_Err_Invalid_Face_Handle;
2639
2640 if ( strike_index < 0 || strike_index >= face->num_fixed_sizes )
2641 return FT_Err_Invalid_Argument;
2642
2643 clazz = face->driver->clazz;
2644
2645 if ( clazz->select_size )
2646 return clazz->select_size( face->size, (FT_ULong)strike_index );
2647
2648 FT_Select_Metrics( face, (FT_ULong)strike_index );
2649
2650 return FT_Err_Ok;
2651 }
2652
2653
2654 /* documentation is in freetype.h */
2655
2656 FT_EXPORT_DEF( FT_Error )
2657 FT_Request_Size( FT_Face face,
2658 FT_Size_Request req )
2659 {
2660 FT_Driver_Class clazz;
2661 FT_ULong strike_index;
2662
2663
2664 if ( !face )
2665 return FT_Err_Invalid_Face_Handle;
2666
2667 if ( !req || req->width < 0 || req->height < 0 ||
2668 req->type >= FT_SIZE_REQUEST_TYPE_MAX )
2669 return FT_Err_Invalid_Argument;
2670
2671 clazz = face->driver->clazz;
2672
2673 if ( clazz->request_size )
2674 return clazz->request_size( face->size, req );
2675
2676 /*
2677 * The reason that a driver doesn't have `request_size' defined is
2678 * either that the scaling here suffices or that the supported formats
2679 * are bitmap-only and size matching is not implemented.
2680 *
2681 * In the latter case, a simple size matching is done.
2682 */
2683 if ( !FT_IS_SCALABLE( face ) && FT_HAS_FIXED_SIZES( face ) )
2684 {
2685 FT_Error error;
2686
2687
2688 error = FT_Match_Size( face, req, 0, &strike_index );
2689 if ( error )
2690 return error;
2691
2692 FT_TRACE3(( "FT_Request_Size: bitmap strike %lu matched\n",
2693 strike_index ));
2694
2695 return FT_Select_Size( face, (FT_Int)strike_index );
2696 }
2697
2698 FT_Request_Metrics( face, req );
2699
2700 return FT_Err_Ok;
2701 }
2702
2703
2704 /* documentation is in freetype.h */
2705
2706 FT_EXPORT_DEF( FT_Error )
2707 FT_Set_Char_Size( FT_Face face,
2708 FT_F26Dot6 char_width,
2709 FT_F26Dot6 char_height,
2710 FT_UInt horz_resolution,
2711 FT_UInt vert_resolution )
2712 {
2713 FT_Size_RequestRec req;
2714
2715
2716 if ( !char_width )
2717 char_width = char_height;
2718 else if ( !char_height )
2719 char_height = char_width;
2720
2721 if ( !horz_resolution )
2722 horz_resolution = vert_resolution;
2723 else if ( !vert_resolution )
2724 vert_resolution = horz_resolution;
2725
2726 if ( char_width < 1 * 64 )
2727 char_width = 1 * 64;
2728 if ( char_height < 1 * 64 )
2729 char_height = 1 * 64;
2730
2731 if ( !horz_resolution )
2732 horz_resolution = vert_resolution = 72;
2733
2734 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL;
2735 req.width = char_width;
2736 req.height = char_height;
2737 req.horiResolution = horz_resolution;
2738 req.vertResolution = vert_resolution;
2739
2740 return FT_Request_Size( face, &req );
2741 }
2742
2743
2744 /* documentation is in freetype.h */
2745
2746 FT_EXPORT_DEF( FT_Error )
2747 FT_Set_Pixel_Sizes( FT_Face face,
2748 FT_UInt pixel_width,
2749 FT_UInt pixel_height )
2750 {
2751 FT_Size_RequestRec req;
2752
2753
2754 if ( pixel_width == 0 )
2755 pixel_width = pixel_height;
2756 else if ( pixel_height == 0 )
2757 pixel_height = pixel_width;
2758
2759 if ( pixel_width < 1 )
2760 pixel_width = 1;
2761 if ( pixel_height < 1 )
2762 pixel_height = 1;
2763
2764 /* use `>=' to avoid potential compiler warning on 16bit platforms */
2765 if ( pixel_width >= 0xFFFFU )
2766 pixel_width = 0xFFFFU;
2767 if ( pixel_height >= 0xFFFFU )
2768 pixel_height = 0xFFFFU;
2769
2770 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL;
2771 req.width = pixel_width << 6;
2772 req.height = pixel_height << 6;
2773 req.horiResolution = 0;
2774 req.vertResolution = 0;
2775
2776 return FT_Request_Size( face, &req );
2777 }
2778
2779
2780 /* documentation is in freetype.h */
2781
2782 FT_EXPORT_DEF( FT_Error )
2783 FT_Get_Kerning( FT_Face face,
2784 FT_UInt left_glyph,
2785 FT_UInt right_glyph,
2786 FT_UInt kern_mode,
2787 FT_Vector *akerning )
2788 {
2789 FT_Error error = FT_Err_Ok;
2790 FT_Driver driver;
2791
2792
2793 if ( !face )
2794 return FT_Err_Invalid_Face_Handle;
2795
2796 if ( !akerning )
2797 return FT_Err_Invalid_Argument;
2798
2799 driver = face->driver;
2800
2801 akerning->x = 0;
2802 akerning->y = 0;
2803
2804 if ( driver->clazz->get_kerning )
2805 {
2806 error = driver->clazz->get_kerning( face,
2807 left_glyph,
2808 right_glyph,
2809 akerning );
2810 if ( !error )
2811 {
2812 if ( kern_mode != FT_KERNING_UNSCALED )
2813 {
2814 akerning->x = FT_MulFix( akerning->x, face->size->metrics.x_scale );
2815 akerning->y = FT_MulFix( akerning->y, face->size->metrics.y_scale );
2816
2817 if ( kern_mode != FT_KERNING_UNFITTED )
2818 {
2819 /* we scale down kerning values for small ppem values */
2820 /* to avoid that rounding makes them too big. */
2821 /* `25' has been determined heuristically. */
2822 if ( face->size->metrics.x_ppem < 25 )
2823 akerning->x = FT_MulDiv( akerning->x,
2824 face->size->metrics.x_ppem, 25 );
2825 if ( face->size->metrics.y_ppem < 25 )
2826 akerning->y = FT_MulDiv( akerning->y,
2827 face->size->metrics.y_ppem, 25 );
2828
2829 akerning->x = FT_PIX_ROUND( akerning->x );
2830 akerning->y = FT_PIX_ROUND( akerning->y );
2831 }
2832 }
2833 }
2834 }
2835
2836 return error;
2837 }
2838
2839
2840 /* documentation is in freetype.h */
2841
2842 FT_EXPORT_DEF( FT_Error )
2843 FT_Get_Track_Kerning( FT_Face face,
2844 FT_Fixed point_size,
2845 FT_Int degree,
2846 FT_Fixed* akerning )
2847 {
2848 FT_Service_Kerning service;
2849 FT_Error error = FT_Err_Ok;
2850
2851
2852 if ( !face )
2853 return FT_Err_Invalid_Face_Handle;
2854
2855 if ( !akerning )
2856 return FT_Err_Invalid_Argument;
2857
2858 FT_FACE_FIND_SERVICE( face, service, KERNING );
2859 if ( !service )
2860 return FT_Err_Unimplemented_Feature;
2861
2862 error = service->get_track( face,
2863 point_size,
2864 degree,
2865 akerning );
2866
2867 return error;
2868 }
2869
2870
2871 /* documentation is in freetype.h */
2872
2873 FT_EXPORT_DEF( FT_Error )
2874 FT_Select_Charmap( FT_Face face,
2875 FT_Encoding encoding )
2876 {
2877 FT_CharMap* cur;
2878 FT_CharMap* limit;
2879
2880
2881 if ( !face )
2882 return FT_Err_Invalid_Face_Handle;
2883
2884 if ( encoding == FT_ENCODING_NONE )
2885 return FT_Err_Invalid_Argument;
2886
2887 /* FT_ENCODING_UNICODE is special. We try to find the `best' Unicode */
2888 /* charmap available, i.e., one with UCS-4 characters, if possible. */
2889 /* */
2890 /* This is done by find_unicode_charmap() above, to share code. */
2891 if ( encoding == FT_ENCODING_UNICODE )
2892 return find_unicode_charmap( face );
2893
2894 cur = face->charmaps;
2895 if ( !cur )
2896 return FT_Err_Invalid_CharMap_Handle;
2897
2898 limit = cur + face->num_charmaps;
2899
2900 for ( ; cur < limit; cur++ )
2901 {
2902 if ( cur[0]->encoding == encoding )
2903 {
2904 face->charmap = cur[0];
2905 return 0;
2906 }
2907 }
2908
2909 return FT_Err_Invalid_Argument;
2910 }
2911
2912
2913 /* documentation is in freetype.h */
2914
2915 FT_EXPORT_DEF( FT_Error )
2916 FT_Set_Charmap( FT_Face face,
2917 FT_CharMap charmap )
2918 {
2919 FT_CharMap* cur;
2920 FT_CharMap* limit;
2921
2922
2923 if ( !face )
2924 return FT_Err_Invalid_Face_Handle;
2925
2926 cur = face->charmaps;
2927 if ( !cur )
2928 return FT_Err_Invalid_CharMap_Handle;
2929 if ( FT_Get_CMap_Format( charmap ) == 14 )
2930 return FT_Err_Invalid_Argument;
2931
2932 limit = cur + face->num_charmaps;
2933
2934 for ( ; cur < limit; cur++ )
2935 {
2936 if ( cur[0] == charmap )
2937 {
2938 face->charmap = cur[0];
2939 return 0;
2940 }
2941 }
2942 return FT_Err_Invalid_Argument;
2943 }
2944
2945
2946 /* documentation is in freetype.h */
2947
2948 FT_EXPORT_DEF( FT_Int )
2949 FT_Get_Charmap_Index( FT_CharMap charmap )
2950 {
2951 FT_Int i;
2952
2953
2954 for ( i = 0; i < charmap->face->num_charmaps; i++ )
2955 if ( charmap->face->charmaps[i] == charmap )
2956 break;
2957
2958 FT_ASSERT( i < charmap->face->num_charmaps );
2959
2960 return i;
2961 }
2962
2963
2964 static void
2965 ft_cmap_done_internal( FT_CMap cmap )
2966 {
2967 FT_CMap_Class clazz = cmap->clazz;
2968 FT_Face face = cmap->charmap.face;
2969 FT_Memory memory = FT_FACE_MEMORY(face);
2970
2971
2972 if ( clazz->done )
2973 clazz->done( cmap );
2974
2975 FT_FREE( cmap );
2976 }
2977
2978
2979 FT_BASE_DEF( void )
2980 FT_CMap_Done( FT_CMap cmap )
2981 {
2982 if ( cmap )
2983 {
2984 FT_Face face = cmap->charmap.face;
2985 FT_Memory memory = FT_FACE_MEMORY( face );
2986 FT_Error error;
2987 FT_Int i, j;
2988
2989
2990 for ( i = 0; i < face->num_charmaps; i++ )
2991 {
2992 if ( (FT_CMap)face->charmaps[i] == cmap )
2993 {
2994 FT_CharMap last_charmap = face->charmaps[face->num_charmaps - 1];
2995
2996
2997 if ( FT_RENEW_ARRAY( face->charmaps,
2998 face->num_charmaps,
2999 face->num_charmaps - 1 ) )
3000 return;
3001
3002 /* remove it from our list of charmaps */
3003 for ( j = i + 1; j < face->num_charmaps; j++ )
3004 {
3005 if ( j == face->num_charmaps - 1 )
3006 face->charmaps[j - 1] = last_charmap;
3007 else
3008 face->charmaps[j - 1] = face->charmaps[j];
3009 }
3010
3011 face->num_charmaps--;
3012
3013 if ( (FT_CMap)face->charmap == cmap )
3014 face->charmap = NULL;
3015
3016 ft_cmap_done_internal( cmap );
3017
3018 break;
3019 }
3020 }
3021 }
3022 }
3023
3024
3025 FT_BASE_DEF( FT_Error )
3026 FT_CMap_New( FT_CMap_Class clazz,
3027 FT_Pointer init_data,
3028 FT_CharMap charmap,
3029 FT_CMap *acmap )
3030 {
3031 FT_Error error = FT_Err_Ok;
3032 FT_Face face;
3033 FT_Memory memory;
3034 FT_CMap cmap;
3035
3036
3037 if ( clazz == NULL || charmap == NULL || charmap->face == NULL )
3038 return FT_Err_Invalid_Argument;
3039
3040 face = charmap->face;
3041 memory = FT_FACE_MEMORY( face );
3042
3043 if ( !FT_ALLOC( cmap, clazz->size ) )
3044 {
3045 cmap->charmap = *charmap;
3046 cmap->clazz = clazz;
3047
3048 if ( clazz->init )
3049 {
3050 error = clazz->init( cmap, init_data );
3051 if ( error )
3052 goto Fail;
3053 }
3054
3055 /* add it to our list of charmaps */
3056 if ( FT_RENEW_ARRAY( face->charmaps,
3057 face->num_charmaps,
3058 face->num_charmaps + 1 ) )
3059 goto Fail;
3060
3061 face->charmaps[face->num_charmaps++] = (FT_CharMap)cmap;
3062 }
3063
3064 Exit:
3065 if ( acmap )
3066 *acmap = cmap;
3067
3068 return error;
3069
3070 Fail:
3071 ft_cmap_done_internal( cmap );
3072 cmap = NULL;
3073 goto Exit;
3074 }
3075
3076
3077 /* documentation is in freetype.h */
3078
3079 FT_EXPORT_DEF( FT_UInt )
3080 FT_Get_Char_Index( FT_Face face,
3081 FT_ULong charcode )
3082 {
3083 FT_UInt result = 0;
3084
3085
3086 if ( face && face->charmap )
3087 {
3088 FT_CMap cmap = FT_CMAP( face->charmap );
3089
3090
3091 if ( charcode > 0xFFFFFFFFUL )
3092 {
3093 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
3094 FT_TRACE1(( " 0x%x is truncated\n", charcode ));
3095 }
3096 result = cmap->clazz->char_index( cmap, (FT_UInt32)charcode );
3097 }
3098 return result;
3099 }
3100
3101
3102 /* documentation is in freetype.h */
3103
3104 FT_EXPORT_DEF( FT_ULong )
3105 FT_Get_First_Char( FT_Face face,
3106 FT_UInt *agindex )
3107 {
3108 FT_ULong result = 0;
3109 FT_UInt gindex = 0;
3110
3111
3112 if ( face && face->charmap )
3113 {
3114 gindex = FT_Get_Char_Index( face, 0 );
3115 if ( gindex == 0 )
3116 result = FT_Get_Next_Char( face, 0, &gindex );
3117 }
3118
3119 if ( agindex )
3120 *agindex = gindex;
3121
3122 return result;
3123 }
3124
3125
3126 /* documentation is in freetype.h */
3127
3128 FT_EXPORT_DEF( FT_ULong )
3129 FT_Get_Next_Char( FT_Face face,
3130 FT_ULong charcode,
3131 FT_UInt *agindex )
3132 {
3133 FT_ULong result = 0;
3134 FT_UInt gindex = 0;
3135
3136
3137 if ( face && face->charmap )
3138 {
3139 FT_UInt32 code = (FT_UInt32)charcode;
3140 FT_CMap cmap = FT_CMAP( face->charmap );
3141
3142
3143 gindex = cmap->clazz->char_next( cmap, &code );
3144 result = ( gindex == 0 ) ? 0 : code;
3145 }
3146
3147 if ( agindex )
3148 *agindex = gindex;
3149
3150 return result;
3151 }
3152
3153
3154 /* documentation is in freetype.h */
3155
3156 FT_EXPORT_DEF( FT_UInt )
3157 FT_Face_GetCharVariantIndex( FT_Face face,
3158 FT_ULong charcode,
3159 FT_ULong variantSelector )
3160 {
3161 FT_UInt result = 0;
3162
3163
3164 if ( face && face->charmap &&
3165 face->charmap->encoding == FT_ENCODING_UNICODE )
3166 {
3167 FT_CharMap charmap = find_variant_selector_charmap( face );
3168 FT_CMap ucmap = FT_CMAP( face->charmap );
3169
3170
3171 if ( charmap != NULL )
3172 {
3173 FT_CMap vcmap = FT_CMAP( charmap );
3174
3175
3176 if ( charcode > 0xFFFFFFFFUL )
3177 {
3178 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
3179 FT_TRACE1(( " 0x%x is truncated\n", charcode ));
3180 }
3181 if ( variantSelector > 0xFFFFFFFFUL )
3182 {
3183 FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
3184 FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
3185 }
3186
3187 result = vcmap->clazz->char_var_index( vcmap, ucmap,
3188 (FT_UInt32)charcode,
3189 (FT_UInt32)variantSelector );
3190 }
3191 }
3192
3193 return result;
3194 }
3195
3196
3197 /* documentation is in freetype.h */
3198
3199 FT_EXPORT_DEF( FT_Int )
3200 FT_Face_GetCharVariantIsDefault( FT_Face face,
3201 FT_ULong charcode,
3202 FT_ULong variantSelector )
3203 {
3204 FT_Int result = -1;
3205
3206
3207 if ( face )
3208 {
3209 FT_CharMap charmap = find_variant_selector_charmap( face );
3210
3211
3212 if ( charmap != NULL )
3213 {
3214 FT_CMap vcmap = FT_CMAP( charmap );
3215
3216
3217 if ( charcode > 0xFFFFFFFFUL )
3218 {
3219 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
3220 FT_TRACE1(( " 0x%x is truncated\n", charcode ));
3221 }
3222 if ( variantSelector > 0xFFFFFFFFUL )
3223 {
3224 FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
3225 FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
3226 }
3227
3228 result = vcmap->clazz->char_var_default( vcmap,
3229 (FT_UInt32)charcode,
3230 (FT_UInt32)variantSelector );
3231 }
3232 }
3233
3234 return result;
3235 }
3236
3237
3238 /* documentation is in freetype.h */
3239
3240 FT_EXPORT_DEF( FT_UInt32* )
3241 FT_Face_GetVariantSelectors( FT_Face face )
3242 {
3243 FT_UInt32 *result = NULL;
3244
3245
3246 if ( face )
3247 {
3248 FT_CharMap charmap = find_variant_selector_charmap( face );
3249
3250
3251 if ( charmap != NULL )
3252 {
3253 FT_CMap vcmap = FT_CMAP( charmap );
3254 FT_Memory memory = FT_FACE_MEMORY( face );
3255
3256
3257 result = vcmap->clazz->variant_list( vcmap, memory );
3258 }
3259 }
3260
3261 return result;
3262 }
3263
3264
3265 /* documentation is in freetype.h */
3266
3267 FT_EXPORT_DEF( FT_UInt32* )
3268 FT_Face_GetVariantsOfChar( FT_Face face,
3269 FT_ULong charcode )
3270 {
3271 FT_UInt32 *result = NULL;
3272
3273
3274 if ( face )
3275 {
3276 FT_CharMap charmap = find_variant_selector_charmap( face );
3277
3278
3279 if ( charmap != NULL )
3280 {
3281 FT_CMap vcmap = FT_CMAP( charmap );
3282 FT_Memory memory = FT_FACE_MEMORY( face );
3283
3284
3285 if ( charcode > 0xFFFFFFFFUL )
3286 {
3287 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
3288 FT_TRACE1(( " 0x%x is truncated\n", charcode ));
3289 }
3290
3291 result = vcmap->clazz->charvariant_list( vcmap, memory,
3292 (FT_UInt32)charcode );
3293 }
3294 }
3295 return result;
3296 }
3297
3298
3299 /* documentation is in freetype.h */
3300
3301 FT_EXPORT_DEF( FT_UInt32* )
3302 FT_Face_GetCharsOfVariant( FT_Face face,
3303 FT_ULong variantSelector )
3304 {
3305 FT_UInt32 *result = NULL;
3306
3307
3308 if ( face )
3309 {
3310 FT_CharMap charmap = find_variant_selector_charmap( face );
3311
3312
3313 if ( charmap != NULL )
3314 {
3315 FT_CMap vcmap = FT_CMAP( charmap );
3316 FT_Memory memory = FT_FACE_MEMORY( face );
3317
3318
3319 if ( variantSelector > 0xFFFFFFFFUL )
3320 {
3321 FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
3322 FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
3323 }
3324
3325 result = vcmap->clazz->variantchar_list( vcmap, memory,
3326 (FT_UInt32)variantSelector );
3327 }
3328 }
3329
3330 return result;
3331 }
3332
3333
3334 /* documentation is in freetype.h */
3335
3336 FT_EXPORT_DEF( FT_UInt )
3337 FT_Get_Name_Index( FT_Face face,
3338 FT_String* glyph_name )
3339 {
3340 FT_UInt result = 0;
3341
3342
3343 if ( face && FT_HAS_GLYPH_NAMES( face ) )
3344 {
3345 FT_Service_GlyphDict service;
3346
3347
3348 FT_FACE_LOOKUP_SERVICE( face,
3349 service,
3350 GLYPH_DICT );
3351
3352 if ( service && service->name_index )
3353 result = service->name_index( face, glyph_name );
3354 }
3355
3356 return result;
3357 }
3358
3359
3360 /* documentation is in freetype.h */
3361
3362 FT_EXPORT_DEF( FT_Error )
3363 FT_Get_Glyph_Name( FT_Face face,
3364 FT_UInt glyph_index,
3365 FT_Pointer buffer,
3366 FT_UInt buffer_max )
3367 {
3368 FT_Error error = FT_Err_Invalid_Argument;
3369
3370
3371 /* clean up buffer */
3372 if ( buffer && buffer_max > 0 )
3373 ((FT_Byte*)buffer)[0] = 0;
3374
3375 if ( face &&
3376 (FT_Long)glyph_index <= face->num_glyphs &&
3377 FT_HAS_GLYPH_NAMES( face ) )
3378 {
3379 FT_Service_GlyphDict service;
3380
3381
3382 FT_FACE_LOOKUP_SERVICE( face,
3383 service,
3384 GLYPH_DICT );
3385
3386 if ( service && service->get_name )
3387 error = service->get_name( face, glyph_index, buffer, buffer_max );
3388 }
3389
3390 return error;
3391 }
3392
3393
3394 /* documentation is in freetype.h */
3395
3396 FT_EXPORT_DEF( const char* )
3397 FT_Get_Postscript_Name( FT_Face face )
3398 {
3399 const char* result = NULL;
3400
3401
3402 if ( !face )
3403 goto Exit;
3404
3405 if ( !result )
3406 {
3407 FT_Service_PsFontName service;
3408
3409
3410 FT_FACE_LOOKUP_SERVICE( face,
3411 service,
3412 POSTSCRIPT_FONT_NAME );
3413
3414 if ( service && service->get_ps_font_name )
3415 result = service->get_ps_font_name( face );
3416 }
3417
3418 Exit:
3419 return result;
3420 }
3421
3422
3423 /* documentation is in tttables.h */
3424
3425 FT_EXPORT_DEF( void* )
3426 FT_Get_Sfnt_Table( FT_Face face,
3427 FT_Sfnt_Tag tag )
3428 {
3429 void* table = 0;
3430 FT_Service_SFNT_Table service;
3431
3432
3433 if ( face && FT_IS_SFNT( face ) )
3434 {
3435 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
3436 if ( service != NULL )
3437 table = service->get_table( face, tag );
3438 }
3439
3440 return table;
3441 }
3442
3443
3444 /* documentation is in tttables.h */
3445
3446 FT_EXPORT_DEF( FT_Error )
3447 FT_Load_Sfnt_Table( FT_Face face,
3448 FT_ULong tag,
3449 FT_Long offset,
3450 FT_Byte* buffer,
3451 FT_ULong* length )
3452 {
3453 FT_Service_SFNT_Table service;
3454
3455
3456 if ( !face || !FT_IS_SFNT( face ) )
3457 return FT_Err_Invalid_Face_Handle;
3458
3459 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
3460 if ( service == NULL )
3461 return FT_Err_Unimplemented_Feature;
3462
3463 return service->load_table( face, tag, offset, buffer, length );
3464 }
3465
3466
3467 /* documentation is in tttables.h */
3468
3469 FT_EXPORT_DEF( FT_Error )
3470 FT_Sfnt_Table_Info( FT_Face face,
3471 FT_UInt table_index,
3472 FT_ULong *tag,
3473 FT_ULong *length )
3474 {
3475 FT_Service_SFNT_Table service;
3476 FT_ULong offset;
3477
3478
3479 if ( !face || !FT_IS_SFNT( face ) )
3480 return FT_Err_Invalid_Face_Handle;
3481
3482 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
3483 if ( service == NULL )
3484 return FT_Err_Unimplemented_Feature;
3485
3486 return service->table_info( face, table_index, tag, &offset, length );
3487 }
3488
3489
3490 /* documentation is in tttables.h */
3491
3492 FT_EXPORT_DEF( FT_ULong )
3493 FT_Get_CMap_Language_ID( FT_CharMap charmap )
3494 {
3495 FT_Service_TTCMaps service;
3496 FT_Face face;
3497 TT_CMapInfo cmap_info;
3498
3499
3500 if ( !charmap || !charmap->face )
3501 return 0;
3502
3503 face = charmap->face;
3504 FT_FACE_FIND_SERVICE( face, service, TT_CMAP );
3505 if ( service == NULL )
3506 return 0;
3507 if ( service->get_cmap_info( charmap, &cmap_info ))
3508 return 0;
3509
3510 return cmap_info.language;
3511 }
3512
3513
3514 /* documentation is in tttables.h */
3515
3516 FT_EXPORT_DEF( FT_Long )
3517 FT_Get_CMap_Format( FT_CharMap charmap )
3518 {
3519 FT_Service_TTCMaps service;
3520 FT_Face face;
3521 TT_CMapInfo cmap_info;
3522
3523
3524 if ( !charmap || !charmap->face )
3525 return -1;
3526
3527 face = charmap->face;
3528 FT_FACE_FIND_SERVICE( face, service, TT_CMAP );
3529 if ( service == NULL )
3530 return -1;
3531 if ( service->get_cmap_info( charmap, &cmap_info ))
3532 return -1;
3533
3534 return cmap_info.format;
3535 }
3536
3537
3538 /* documentation is in ftsizes.h */
3539
3540 FT_EXPORT_DEF( FT_Error )
3541 FT_Activate_Size( FT_Size size )
3542 {
3543 FT_Face face;
3544
3545
3546 if ( size == NULL )
3547 return FT_Err_Invalid_Argument;
3548
3549 face = size->face;
3550 if ( face == NULL || face->driver == NULL )
3551 return FT_Err_Invalid_Argument;
3552
3553 /* we don't need anything more complex than that; all size objects */
3554 /* are already listed by the face */
3555 face->size = size;
3556
3557 return FT_Err_Ok;
3558 }
3559
3560
3561 /*************************************************************************/
3562 /*************************************************************************/
3563 /*************************************************************************/
3564 /**** ****/
3565 /**** ****/
3566 /**** R E N D E R E R S ****/
3567 /**** ****/
3568 /**** ****/
3569 /*************************************************************************/
3570 /*************************************************************************/
3571 /*************************************************************************/
3572
3573 /* lookup a renderer by glyph format in the library's list */
3574 FT_BASE_DEF( FT_Renderer )
3575 FT_Lookup_Renderer( FT_Library library,
3576 FT_Glyph_Format format,
3577 FT_ListNode* node )
3578 {
3579 FT_ListNode cur;
3580 FT_Renderer result = 0;
3581
3582
3583 if ( !library )
3584 goto Exit;
3585
3586 cur = library->renderers.head;
3587
3588 if ( node )
3589 {
3590 if ( *node )
3591 cur = (*node)->next;
3592 *node = 0;
3593 }
3594
3595 while ( cur )
3596 {
3597 FT_Renderer renderer = FT_RENDERER( cur->data );
3598
3599
3600 if ( renderer->glyph_format == format )
3601 {
3602 if ( node )
3603 *node = cur;
3604
3605 result = renderer;
3606 break;
3607 }
3608 cur = cur->next;
3609 }
3610
3611 Exit:
3612 return result;
3613 }
3614
3615
3616 static FT_Renderer
3617 ft_lookup_glyph_renderer( FT_GlyphSlot slot )
3618 {
3619 FT_Face face = slot->face;
3620 FT_Library library = FT_FACE_LIBRARY( face );
3621 FT_Renderer result = library->cur_renderer;
3622
3623
3624 if ( !result || result->glyph_format != slot->format )
3625 result = FT_Lookup_Renderer( library, slot->format, 0 );
3626
3627 return result;
3628 }
3629
3630
3631 static void
3632 ft_set_current_renderer( FT_Library library )
3633 {
3634 FT_Renderer renderer;
3635
3636
3637 renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE, 0 );
3638 library->cur_renderer = renderer;
3639 }
3640
3641
3642 static FT_Error
3643 ft_add_renderer( FT_Module module )
3644 {
3645 FT_Library library = module->library;
3646 FT_Memory memory = library->memory;
3647 FT_Error error;
3648 FT_ListNode node;
3649
3650
3651 if ( FT_NEW( node ) )
3652 goto Exit;
3653
3654 {
3655 FT_Renderer render = FT_RENDERER( module );
3656 FT_Renderer_Class* clazz = (FT_Renderer_Class*)module->clazz;
3657
3658
3659 render->clazz = clazz;
3660 render->glyph_format = clazz->glyph_format;
3661
3662 /* allocate raster object if needed */
3663 if ( clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE &&
3664 clazz->raster_class->raster_new )
3665 {
3666 error = clazz->raster_class->raster_new( memory, &render->raster );
3667 if ( error )
3668 goto Fail;
3669
3670 render->raster_render = clazz->raster_class->raster_render;
3671 render->render = clazz->render_glyph;
3672 }
3673
3674 /* add to list */
3675 node->data = module;
3676 FT_List_Add( &library->renderers, node );
3677
3678 ft_set_current_renderer( library );
3679 }
3680
3681 Fail:
3682 if ( error )
3683 FT_FREE( node );
3684
3685 Exit:
3686 return error;
3687 }
3688
3689
3690 static void
3691 ft_remove_renderer( FT_Module module )
3692 {
3693 FT_Library library = module->library;
3694 FT_Memory memory = library->memory;
3695 FT_ListNode node;
3696
3697
3698 node = FT_List_Find( &library->renderers, module );
3699 if ( node )
3700 {
3701 FT_Renderer render = FT_RENDERER( module );
3702
3703
3704 /* release raster object, if any */
3705 if ( render->raster )
3706 render->clazz->raster_class->raster_done( render->raster );
3707
3708 /* remove from list */
3709 FT_List_Remove( &library->renderers, node );
3710 FT_FREE( node );
3711
3712 ft_set_current_renderer( library );
3713 }
3714 }
3715
3716
3717 /* documentation is in ftrender.h */
3718
3719 FT_EXPORT_DEF( FT_Renderer )
3720 FT_Get_Renderer( FT_Library library,
3721 FT_Glyph_Format format )
3722 {
3723 /* test for valid `library' delayed to FT_Lookup_Renderer() */
3724
3725 return FT_Lookup_Renderer( library, format, 0 );
3726 }
3727
3728
3729 /* documentation is in ftrender.h */
3730
3731 FT_EXPORT_DEF( FT_Error )
3732 FT_Set_Renderer( FT_Library library,
3733 FT_Renderer renderer,
3734 FT_UInt num_params,
3735 FT_Parameter* parameters )
3736 {
3737 FT_ListNode node;
3738 FT_Error error = FT_Err_Ok;
3739
3740
3741 if ( !library )
3742 return FT_Err_Invalid_Library_Handle;
3743
3744 if ( !renderer )
3745 return FT_Err_Invalid_Argument;
3746
3747 node = FT_List_Find( &library->renderers, renderer );
3748 if ( !node )
3749 {
3750 error = FT_Err_Invalid_Argument;
3751 goto Exit;
3752 }
3753
3754 FT_List_Up( &library->renderers, node );
3755
3756 if ( renderer->glyph_format == FT_GLYPH_FORMAT_OUTLINE )
3757 library->cur_renderer = renderer;
3758
3759 if ( num_params > 0 )
3760 {
3761 FT_Renderer_SetModeFunc set_mode = renderer->clazz->set_mode;
3762
3763
3764 for ( ; num_params > 0; num_params-- )
3765 {
3766 error = set_mode( renderer, parameters->tag, parameters->data );
3767 if ( error )
3768 break;
3769 }
3770 }
3771
3772 Exit:
3773 return error;
3774 }
3775
3776
3777 FT_BASE_DEF( FT_Error )
3778 FT_Render_Glyph_Internal( FT_Library library,
3779 FT_GlyphSlot slot,
3780 FT_Render_Mode render_mode )
3781 {
3782 FT_Error error = FT_Err_Ok;
3783 FT_Renderer renderer;
3784
3785
3786 /* if it is already a bitmap, no need to do anything */
3787 switch ( slot->format )
3788 {
3789 case FT_GLYPH_FORMAT_BITMAP: /* already a bitmap, don't do anything */
3790 break;
3791
3792 default:
3793 {
3794 FT_ListNode node = 0;
3795 FT_Bool update = 0;
3796
3797
3798 /* small shortcut for the very common case */
3799 if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
3800 {
3801 renderer = library->cur_renderer;
3802 node = library->renderers.head;
3803 }
3804 else
3805 renderer = FT_Lookup_Renderer( library, slot->format, &node );
3806
3807 error = FT_Err_Unimplemented_Feature;
3808 while ( renderer )
3809 {
3810 error = renderer->render( renderer, slot, render_mode, NULL );
3811 if ( !error ||
3812 FT_ERROR_BASE( error ) != FT_Err_Cannot_Render_Glyph )
3813 break;
3814
3815 /* FT_Err_Cannot_Render_Glyph is returned if the render mode */
3816 /* is unsupported by the current renderer for this glyph image */
3817 /* format. */
3818
3819 /* now, look for another renderer that supports the same */
3820 /* format. */
3821 renderer = FT_Lookup_Renderer( library, slot->format, &node );
3822 update = 1;
3823 }
3824
3825 /* if we changed the current renderer for the glyph image format */
3826 /* we need to select it as the next current one */
3827 if ( !error && update && renderer )
3828 FT_Set_Renderer( library, renderer, 0, 0 );
3829 }
3830 }
3831
3832 return error;
3833 }
3834
3835
3836 /* documentation is in freetype.h */
3837
3838 FT_EXPORT_DEF( FT_Error )
3839 FT_Render_Glyph( FT_GlyphSlot slot,
3840 FT_Render_Mode render_mode )
3841 {
3842 FT_Library library;
3843
3844
3845 if ( !slot )
3846 return FT_Err_Invalid_Argument;
3847
3848 library = FT_FACE_LIBRARY( slot->face );
3849
3850 return FT_Render_Glyph_Internal( library, slot, render_mode );
3851 }
3852
3853
3854 /*************************************************************************/
3855 /*************************************************************************/
3856 /*************************************************************************/
3857 /**** ****/
3858 /**** ****/
3859 /**** M O D U L E S ****/
3860 /**** ****/
3861 /**** ****/
3862 /*************************************************************************/
3863 /*************************************************************************/
3864 /*************************************************************************/
3865
3866
3867 /*************************************************************************/
3868 /* */
3869 /* <Function> */
3870 /* Destroy_Module */
3871 /* */
3872 /* <Description> */
3873 /* Destroys a given module object. For drivers, this also destroys */
3874 /* all child faces. */
3875 /* */
3876 /* <InOut> */
3877 /* module :: A handle to the target driver object. */
3878 /* */
3879 /* <Note> */
3880 /* The driver _must_ be LOCKED! */
3881 /* */
3882 static void
3883 Destroy_Module( FT_Module module )
3884 {
3885 FT_Memory memory = module->memory;
3886 FT_Module_Class* clazz = module->clazz;
3887 FT_Library library = module->library;
3888
3889
3890 /* finalize client-data - before anything else */
3891 if ( module->generic.finalizer )
3892 module->generic.finalizer( module );
3893
3894 if ( library && library->auto_hinter == module )
3895 library->auto_hinter = 0;
3896
3897 /* if the module is a renderer */
3898 if ( FT_MODULE_IS_RENDERER( module ) )
3899 ft_remove_renderer( module );
3900
3901 /* if the module is a font driver, add some steps */
3902 if ( FT_MODULE_IS_DRIVER( module ) )
3903 Destroy_Driver( FT_DRIVER( module ) );
3904
3905 /* finalize the module object */
3906 if ( clazz->module_done )
3907 clazz->module_done( module );
3908
3909 /* discard it */
3910 FT_FREE( module );
3911 }
3912
3913
3914 /* documentation is in ftmodapi.h */
3915
3916 FT_EXPORT_DEF( FT_Error )
3917 FT_Add_Module( FT_Library library,
3918 const FT_Module_Class* clazz )
3919 {
3920 FT_Error error;
3921 FT_Memory memory;
3922 FT_Module module;
3923 FT_UInt nn;
3924
3925
3926 #define FREETYPE_VER_FIXED ( ( (FT_Long)FREETYPE_MAJOR << 16 ) | \
3927 FREETYPE_MINOR )
3928
3929 if ( !library )
3930 return FT_Err_Invalid_Library_Handle;
3931
3932 if ( !clazz )
3933 return FT_Err_Invalid_Argument;
3934
3935 /* check freetype version */
3936 if ( clazz->module_requires > FREETYPE_VER_FIXED )
3937 return FT_Err_Invalid_Version;
3938
3939 /* look for a module with the same name in the library's table */
3940 for ( nn = 0; nn < library->num_modules; nn++ )
3941 {
3942 module = library->modules[nn];
3943 if ( ft_strcmp( module->clazz->module_name, clazz->module_name ) == 0 )
3944 {
3945 /* this installed module has the same name, compare their versions */
3946 if ( clazz->module_version <= module->clazz->module_version )
3947 return FT_Err_Lower_Module_Version;
3948
3949 /* remove the module from our list, then exit the loop to replace */
3950 /* it by our new version.. */
3951 FT_Remove_Module( library, module );
3952 break;
3953 }
3954 }
3955
3956 memory = library->memory;
3957 error = FT_Err_Ok;
3958
3959 if ( library->num_modules >= FT_MAX_MODULES )
3960 {
3961 error = FT_Err_Too_Many_Drivers;
3962 goto Exit;
3963 }
3964
3965 /* allocate module object */
3966 if ( FT_ALLOC( module, clazz->module_size ) )
3967 goto Exit;
3968
3969 /* base initialization */
3970 module->library = library;
3971 module->memory = memory;
3972 module->clazz = (FT_Module_Class*)clazz;
3973
3974 /* check whether the module is a renderer - this must be performed */
3975 /* before the normal module initialization */
3976 if ( FT_MODULE_IS_RENDERER( module ) )
3977 {
3978 /* add to the renderers list */
3979 error = ft_add_renderer( module );
3980 if ( error )
3981 goto Fail;
3982 }
3983
3984 /* is the module a auto-hinter? */
3985 if ( FT_MODULE_IS_HINTER( module ) )
3986 library->auto_hinter = module;
3987
3988 /* if the module is a font driver */
3989 if ( FT_MODULE_IS_DRIVER( module ) )
3990 {
3991 /* allocate glyph loader if needed */
3992 FT_Driver driver = FT_DRIVER( module );
3993
3994
3995 driver->clazz = (FT_Driver_Class)module->clazz;
3996 if ( FT_DRIVER_USES_OUTLINES( driver ) )
3997 {
3998 error = FT_GlyphLoader_New( memory, &driver->glyph_loader );
3999 if ( error )
4000 goto Fail;
4001 }
4002 }
4003
4004 if ( clazz->module_init )
4005 {
4006 error = clazz->module_init( module );
4007 if ( error )
4008 goto Fail;
4009 }
4010
4011 /* add module to the library's table */
4012 library->modules[library->num_modules++] = module;
4013
4014 Exit:
4015 return error;
4016
4017 Fail:
4018 if ( FT_MODULE_IS_DRIVER( module ) )
4019 {
4020 FT_Driver driver = FT_DRIVER( module );
4021
4022
4023 if ( FT_DRIVER_USES_OUTLINES( driver ) )
4024 FT_GlyphLoader_Done( driver->glyph_loader );
4025 }
4026
4027 if ( FT_MODULE_IS_RENDERER( module ) )
4028 {
4029 FT_Renderer renderer = FT_RENDERER( module );
4030
4031
4032 if ( renderer->raster )
4033 renderer->clazz->raster_class->raster_done( renderer->raster );
4034 }
4035
4036 FT_FREE( module );
4037 goto Exit;
4038 }
4039
4040
4041 /* documentation is in ftmodapi.h */
4042
4043 FT_EXPORT_DEF( FT_Module )
4044 FT_Get_Module( FT_Library library,
4045 const char* module_name )
4046 {
4047 FT_Module result = 0;
4048 FT_Module* cur;
4049 FT_Module* limit;
4050
4051
4052 if ( !library || !module_name )
4053 return result;
4054
4055 cur = library->modules;
4056 limit = cur + library->num_modules;
4057
4058 for ( ; cur < limit; cur++ )
4059 if ( ft_strcmp( cur[0]->clazz->module_name, module_name ) == 0 )
4060 {
4061 result = cur[0];
4062 break;
4063 }
4064
4065 return result;
4066 }
4067
4068
4069 /* documentation is in ftobjs.h */
4070
4071 FT_BASE_DEF( const void* )
4072 FT_Get_Module_Interface( FT_Library library,
4073 const char* mod_name )
4074 {
4075 FT_Module module;
4076
4077
4078 /* test for valid `library' delayed to FT_Get_Module() */
4079
4080 module = FT_Get_Module( library, mod_name );
4081
4082 return module ? module->clazz->module_interface : 0;
4083 }
4084
4085
4086 FT_BASE_DEF( FT_Pointer )
4087 ft_module_get_service( FT_Module module,
4088 const char* service_id )
4089 {
4090 FT_Pointer result = NULL;
4091
4092 if ( module )
4093 {
4094 FT_ASSERT( module->clazz && module->clazz->get_interface );
4095
4096 /* first, look for the service in the module
4097 */
4098 if ( module->clazz->get_interface )
4099 result = module->clazz->get_interface( module, service_id );
4100
4101 if ( result == NULL )
4102 {
4103 /* we didn't find it, look in all other modules then
4104 */
4105 FT_Library library = module->library;
4106 FT_Module* cur = library->modules;
4107 FT_Module* limit = cur + library->num_modules;
4108
4109 for ( ; cur < limit; cur++ )
4110 {
4111 if ( cur[0] != module )
4112 {
4113 FT_ASSERT( cur[0]->clazz );
4114
4115 if ( cur[0]->clazz->get_interface )
4116 {
4117 result = cur[0]->clazz->get_interface( cur[0], service_id );
4118 if ( result != NULL )
4119 break;
4120 }
4121 }
4122 }
4123 }
4124 }
4125
4126 return result;
4127 }
4128
4129
4130 /* documentation is in ftmodapi.h */
4131
4132 FT_EXPORT_DEF( FT_Error )
4133 FT_Remove_Module( FT_Library library,
4134 FT_Module module )
4135 {
4136 /* try to find the module from the table, then remove it from there */
4137
4138 if ( !library )
4139 return FT_Err_Invalid_Library_Handle;
4140
4141 if ( module )
4142 {
4143 FT_Module* cur = library->modules;
4144 FT_Module* limit = cur + library->num_modules;
4145
4146
4147 for ( ; cur < limit; cur++ )
4148 {
4149 if ( cur[0] == module )
4150 {
4151 /* remove it from the table */
4152 library->num_modules--;
4153 limit--;
4154 while ( cur < limit )
4155 {
4156 cur[0] = cur[1];
4157 cur++;
4158 }
4159 limit[0] = 0;
4160
4161 /* destroy the module */
4162 Destroy_Module( module );
4163
4164 return FT_Err_Ok;
4165 }
4166 }
4167 }
4168 return FT_Err_Invalid_Driver_Handle;
4169 }
4170
4171
4172 /*************************************************************************/
4173 /*************************************************************************/
4174 /*************************************************************************/
4175 /**** ****/
4176 /**** ****/
4177 /**** L I B R A R Y ****/
4178 /**** ****/
4179 /**** ****/
4180 /*************************************************************************/
4181 /*************************************************************************/
4182 /*************************************************************************/
4183
4184
4185 /* documentation is in ftmodapi.h */
4186
4187 FT_EXPORT_DEF( FT_Error )
4188 FT_New_Library( FT_Memory memory,
4189 FT_Library *alibrary )
4190 {
4191 FT_Library library = 0;
4192 FT_Error error;
4193
4194
4195 if ( !memory )
4196 return FT_Err_Invalid_Argument;
4197
4198 #ifdef FT_DEBUG_LEVEL_ERROR
4199 /* init debugging support */
4200 ft_debug_init();
4201 #endif
4202
4203 /* first of all, allocate the library object */
4204 if ( FT_NEW( library ) )
4205 return error;
4206
4207 library->memory = memory;
4208
4209 #ifdef FT_CONFIG_OPTION_PIC
4210 /* initialize position independent code containers */
4211 error = ft_pic_container_init( library );
4212 if ( error )
4213 goto Fail;
4214 #endif
4215
4216 /* allocate the render pool */
4217 library->raster_pool_size = FT_RENDER_POOL_SIZE;
4218 #if FT_RENDER_POOL_SIZE > 0
4219 if ( FT_ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) )
4220 goto Fail;
4221 #endif
4222
4223 library->version_major = FREETYPE_MAJOR;
4224 library->version_minor = FREETYPE_MINOR;
4225 library->version_patch = FREETYPE_PATCH;
4226
4227 /* That's ok now */
4228 *alibrary = library;
4229
4230 return FT_Err_Ok;
4231
4232 Fail:
4233 #ifdef FT_CONFIG_OPTION_PIC
4234 ft_pic_container_destroy( library );
4235 #endif
4236 FT_FREE( library );
4237 return error;
4238 }
4239
4240
4241 /* documentation is in freetype.h */
4242
4243 FT_EXPORT_DEF( void )
4244 FT_Library_Version( FT_Library library,
4245 FT_Int *amajor,
4246 FT_Int *aminor,
4247 FT_Int *apatch )
4248 {
4249 FT_Int major = 0;
4250 FT_Int minor = 0;
4251 FT_Int patch = 0;
4252
4253
4254 if ( library )
4255 {
4256 major = library->version_major;
4257 minor = library->version_minor;
4258 patch = library->version_patch;
4259 }
4260
4261 if ( amajor )
4262 *amajor = major;
4263
4264 if ( aminor )
4265 *aminor = minor;
4266
4267 if ( apatch )
4268 *apatch = patch;
4269 }
4270
4271
4272 /* documentation is in ftmodapi.h */
4273
4274 FT_EXPORT_DEF( FT_Error )
4275 FT_Done_Library( FT_Library library )
4276 {
4277 FT_Memory memory;
4278
4279
4280 if ( !library )
4281 return FT_Err_Invalid_Library_Handle;
4282
4283 memory = library->memory;
4284
4285 /* Discard client-data */
4286 if ( library->generic.finalizer )
4287 library->generic.finalizer( library );
4288
4289 /* Close all faces in the library. If we don't do
4290 * this, we can have some subtle memory leaks.
4291 * Example:
4292 *
4293 * - the cff font driver uses the pshinter module in cff_size_done
4294 * - if the pshinter module is destroyed before the cff font driver,
4295 * opened FT_Face objects managed by the driver are not properly
4296 * destroyed, resulting in a memory leak
4297 */
4298 {
4299 FT_UInt n;
4300
4301
4302 for ( n = 0; n < library->num_modules; n++ )
4303 {
4304 FT_Module module = library->modules[n];
4305 FT_List faces;
4306
4307
4308 if ( ( module->clazz->module_flags & FT_MODULE_FONT_DRIVER ) == 0 )
4309 continue;
4310
4311 faces = &FT_DRIVER(module)->faces_list;
4312 while ( faces->head )
4313 {
4314 FT_Done_Face( FT_FACE( faces->head->data ) );
4315 if ( faces->head )
4316 FT_TRACE0(( "FT_Done_Library: failed to free some faces\n" ));
4317 }
4318 }
4319 }
4320
4321 /* Close all other modules in the library */
4322 #if 1
4323 /* XXX Modules are removed in the reversed order so that */
4324 /* type42 module is removed before truetype module. This */
4325 /* avoids double free in some occasions. It is a hack. */
4326 while ( library->num_modules > 0 )
4327 FT_Remove_Module( library,
4328 library->modules[library->num_modules - 1] );
4329 #else
4330 {
4331 FT_UInt n;
4332
4333
4334 for ( n = 0; n < library->num_modules; n++ )
4335 {
4336 FT_Module module = library->modules[n];
4337
4338
4339 if ( module )
4340 {
4341 Destroy_Module( module );
4342 library->modules[n] = 0;
4343 }
4344 }
4345 }
4346 #endif
4347
4348 /* Destroy raster objects */
4349 FT_FREE( library->raster_pool );
4350 library->raster_pool_size = 0;
4351
4352 #ifdef FT_CONFIG_OPTION_PIC
4353 /* Destroy pic container contents */
4354 ft_pic_container_destroy( library );
4355 #endif
4356
4357 FT_FREE( library );
4358 return FT_Err_Ok;
4359 }
4360
4361
4362 /* documentation is in ftmodapi.h */
4363
4364 FT_EXPORT_DEF( void )
4365 FT_Set_Debug_Hook( FT_Library library,
4366 FT_UInt hook_index,
4367 FT_DebugHook_Func debug_hook )
4368 {
4369 if ( library && debug_hook &&
4370 hook_index <
4371 ( sizeof ( library->debug_hooks ) / sizeof ( void* ) ) )
4372 library->debug_hooks[hook_index] = debug_hook;
4373 }
4374
4375
4376 /* documentation is in ftmodapi.h */
4377
4378 FT_EXPORT_DEF( FT_TrueTypeEngineType )
4379 FT_Get_TrueType_Engine_Type( FT_Library library )
4380 {
4381 FT_TrueTypeEngineType result = FT_TRUETYPE_ENGINE_TYPE_NONE;
4382
4383
4384 if ( library )
4385 {
4386 FT_Module module = FT_Get_Module( library, "truetype" );
4387
4388
4389 if ( module )
4390 {
4391 FT_Service_TrueTypeEngine service;
4392
4393
4394 service = (FT_Service_TrueTypeEngine)
4395 ft_module_get_service( module,
4396 FT_SERVICE_ID_TRUETYPE_ENGINE );
4397 if ( service )
4398 result = service->engine_type;
4399 }
4400 }
4401
4402 return result;
4403 }
4404
4405
4406 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
4407
4408 FT_BASE_DEF( FT_Error )
4409 ft_stub_set_char_sizes( FT_Size size,
4410 FT_F26Dot6 width,
4411 FT_F26Dot6 height,
4412 FT_UInt horz_res,
4413 FT_UInt vert_res )
4414 {
4415 FT_Size_RequestRec req;
4416 FT_Driver driver = size->face->driver;
4417
4418
4419 if ( driver->clazz->request_size )
4420 {
4421 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL;
4422 req.width = width;
4423 req.height = height;
4424
4425 if ( horz_res == 0 )
4426 horz_res = vert_res;
4427
4428 if ( vert_res == 0 )
4429 vert_res = horz_res;
4430
4431 if ( horz_res == 0 )
4432 horz_res = vert_res = 72;
4433
4434 req.horiResolution = horz_res;
4435 req.vertResolution = vert_res;
4436
4437 return driver->clazz->request_size( size, &req );
4438 }
4439
4440 return 0;
4441 }
4442
4443
4444 FT_BASE_DEF( FT_Error )
4445 ft_stub_set_pixel_sizes( FT_Size size,
4446 FT_UInt width,
4447 FT_UInt height )
4448 {
4449 FT_Size_RequestRec req;
4450 FT_Driver driver = size->face->driver;
4451
4452
4453 if ( driver->clazz->request_size )
4454 {
4455 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL;
4456 req.width = width << 6;
4457 req.height = height << 6;
4458 req.horiResolution = 0;
4459 req.vertResolution = 0;
4460
4461 return driver->clazz->request_size( size, &req );
4462 }
4463
4464 return 0;
4465 }
4466
4467 #endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
4468
4469
4470 FT_EXPORT_DEF( FT_Error )
4471 FT_Get_SubGlyph_Info( FT_GlyphSlot glyph,
4472 FT_UInt sub_index,
4473 FT_Int *p_index,
4474 FT_UInt *p_flags,
4475 FT_Int *p_arg1,
4476 FT_Int *p_arg2,
4477 FT_Matrix *p_transform )
4478 {
4479 FT_Error error = FT_Err_Invalid_Argument;
4480
4481
4482 if ( glyph != NULL &&
4483 glyph->format == FT_GLYPH_FORMAT_COMPOSITE &&
4484 sub_index < glyph->num_subglyphs )
4485 {
4486 FT_SubGlyph subg = glyph->subglyphs + sub_index;
4487
4488
4489 *p_index = subg->index;
4490 *p_flags = subg->flags;
4491 *p_arg1 = subg->arg1;
4492 *p_arg2 = subg->arg2;
4493 *p_transform = subg->transform;
4494 }
4495
4496 return error;
4497 }
4498
4499
4500 /* END */
A free Windows-compatible Operating System