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