1 /***************************************************************************/

     2 /*                                                                         */

     3 /*  ftobjs.c                                                               */

     4 /*                                                                         */

     5 /*    The FreeType private base classes (body).                            */

     6 /*                                                                         */

     7 /*  Copyright 1996-2011 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;

   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     else if ( args->flags & FT_OPEN_PATHNAME )

   159     {

   160       /* create a normal system stream */

   161       error = FT_Stream_Open( stream, args->pathname );

   162       stream->pathname.pointer = args->pathname;

   163     }

   164     else if ( ( args->flags & FT_OPEN_STREAM ) && args->stream )

   165     {

   166       /* use an existing, user-provided stream */

   167 

   168       /* in this case, we do not need to allocate a new stream object */

   169       /* since the caller is responsible for closing it himself       */

   170       FT_FREE( stream );

   171       stream = args->stream;

   172     }

   173     else

   174       error = FT_Err_Invalid_Argument;

   175 

   176     if ( error )

   177       FT_FREE( stream );

   178     else

   179       stream->memory = memory;  /* just to be certain */

   180 

   181     *astream = stream;

   182 

   183   Exit:

   184     return error;

   185   }

   186 

   187 

   188   FT_BASE_DEF( void )

   189   FT_Stream_Free( FT_Stream  stream,

   190                   FT_Int     external )

   191   {

   192     if ( stream )

   193     {

   194       FT_Memory  memory = stream->memory;

   195 

   196 

   197       FT_Stream_Close( stream );

   198 

   199       if ( !external )

   200         FT_FREE( stream );

   201     }

   202   }

   203 

   204 

   205   /*************************************************************************/

   206   /*                                                                       */

   207   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */

   208   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */

   209   /* messages during execution.                                            */

   210   /*                                                                       */

   211 #undef  FT_COMPONENT

   212 #define FT_COMPONENT  trace_objs

   213 

   214 

   215   /*************************************************************************/

   216   /*************************************************************************/

   217   /*************************************************************************/

   218   /****                                                                 ****/

   219   /****                                                                 ****/

   220   /****               FACE, SIZE & GLYPH SLOT OBJECTS                   ****/

   221   /****                                                                 ****/

   222   /****                                                                 ****/

   223   /*************************************************************************/

   224   /*************************************************************************/

   225   /*************************************************************************/

   226 

   227 

   228   static FT_Error

   229   ft_glyphslot_init( FT_GlyphSlot  slot )

   230   {

   231     FT_Driver         driver   = slot->face->driver;

   232     FT_Driver_Class   clazz    = driver->clazz;

   233     FT_Memory         memory   = driver->root.memory;

   234     FT_Error          error    = FT_Err_Ok;

   235     FT_Slot_Internal  internal = NULL;

   236 

   237 

   238     slot->library = driver->root.library;

   239 

   240     if ( FT_NEW( internal ) )

   241       goto Exit;

   242 

   243     slot->internal = internal;

   244 

   245     if ( FT_DRIVER_USES_OUTLINES( driver ) )

   246       error = FT_GlyphLoader_New( memory, &internal->loader );

   247 

   248     if ( !error && clazz->init_slot )

   249       error = clazz->init_slot( slot );

   250 

   251   Exit:

   252     return error;

   253   }

   254 

   255 

   256   FT_BASE_DEF( void )

   257   ft_glyphslot_free_bitmap( FT_GlyphSlot  slot )

   258   {

   259     if ( slot->internal && ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )

   260     {

   261       FT_Memory  memory = FT_FACE_MEMORY( slot->face );

   262 

   263 

   264       FT_FREE( slot->bitmap.buffer );

   265       slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;

   266     }

   267     else

   268     {

   269       /* assume that the bitmap buffer was stolen or not */

   270       /* allocated from the heap                         */

   271       slot->bitmap.buffer = NULL;

   272     }

   273   }

   274 

   275 

   276   FT_BASE_DEF( void )

   277   ft_glyphslot_set_bitmap( FT_GlyphSlot  slot,

   278                            FT_Byte*      buffer )

   279   {

   280     ft_glyphslot_free_bitmap( slot );

   281 

   282     slot->bitmap.buffer = buffer;

   283 

   284     FT_ASSERT( (slot->internal->flags & FT_GLYPH_OWN_BITMAP) == 0 );

   285   }

   286 

   287 

   288   FT_BASE_DEF( FT_Error )

   289   ft_glyphslot_alloc_bitmap( FT_GlyphSlot  slot,

   290                              FT_ULong      size )

   291   {

   292     FT_Memory  memory = FT_FACE_MEMORY( slot->face );

   293     FT_Error   error;

   294 

   295 

   296     if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )

   297       FT_FREE( slot->bitmap.buffer );

   298     else

   299       slot->internal->flags |= FT_GLYPH_OWN_BITMAP;

   300 

   301     (void)FT_ALLOC( slot->bitmap.buffer, size );

   302     return error;

   303   }

   304 

   305 

   306   static void

   307   ft_glyphslot_clear( FT_GlyphSlot  slot )

   308   {

   309     /* free bitmap if needed */

   310     ft_glyphslot_free_bitmap( slot );

   311 

   312     /* clear all public fields in the glyph slot */

   313     FT_ZERO( &slot->metrics );

   314     FT_ZERO( &slot->outline );

   315 

   316     slot->bitmap.width      = 0;

   317     slot->bitmap.rows       = 0;

   318     slot->bitmap.pitch      = 0;

   319     slot->bitmap.pixel_mode = 0;

   320     /* `slot->bitmap.buffer' has been handled by ft_glyphslot_free_bitmap */

   321 

   322     slot->bitmap_left   = 0;

   323     slot->bitmap_top    = 0;

   324     slot->num_subglyphs = 0;

   325     slot->subglyphs     = 0;

   326     slot->control_data  = 0;

   327     slot->control_len   = 0;

   328     slot->other         = 0;

   329     slot->format        = FT_GLYPH_FORMAT_NONE;

   330 

   331     slot->linearHoriAdvance = 0;

   332     slot->linearVertAdvance = 0;

   333     slot->lsb_delta         = 0;

   334     slot->rsb_delta         = 0;

   335   }

   336 

   337 

   338   static void

   339   ft_glyphslot_done( FT_GlyphSlot  slot )

   340   {

   341     FT_Driver        driver = slot->face->driver;

   342     FT_Driver_Class  clazz  = driver->clazz;

   343     FT_Memory        memory = driver->root.memory;

   344 

   345 

   346     if ( clazz->done_slot )

   347       clazz->done_slot( slot );

   348 

   349     /* free bitmap buffer if needed */

   350     ft_glyphslot_free_bitmap( slot );

   351 

   352     /* slot->internal might be NULL in out-of-memory situations */

   353     if ( slot->internal )

   354     {

   355       /* free glyph loader */

   356       if ( FT_DRIVER_USES_OUTLINES( driver ) )

   357       {

   358         FT_GlyphLoader_Done( slot->internal->loader );

   359         slot->internal->loader = 0;

   360       }

   361 

   362       FT_FREE( slot->internal );

   363     }

   364   }

   365 

   366 

   367   /* documentation is in ftobjs.h */

   368 

   369   FT_BASE_DEF( FT_Error )

   370   FT_New_GlyphSlot( FT_Face        face,

   371                     FT_GlyphSlot  *aslot )

   372   {

   373     FT_Error         error;

   374     FT_Driver        driver;

   375     FT_Driver_Class  clazz;

   376     FT_Memory        memory;

   377     FT_GlyphSlot     slot;

   378 

   379 

   380     if ( !face || !face->driver )

   381       return FT_Err_Invalid_Argument;

   382 

   383     driver = face->driver;

   384     clazz  = driver->clazz;

   385     memory = driver->root.memory;

   386 

   387     FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" ));

   388     if ( !FT_ALLOC( slot, clazz->slot_object_size ) )

   389     {

   390       slot->face = face;

   391 

   392       error = ft_glyphslot_init( slot );

   393       if ( error )

   394       {

   395         ft_glyphslot_done( slot );

   396         FT_FREE( slot );

   397         goto Exit;

   398       }

   399 

   400       slot->next  = face->glyph;

   401       face->glyph = slot;

   402 

   403       if ( aslot )

   404         *aslot = slot;

   405     }

   406     else if ( aslot )

   407       *aslot = 0;

   408 

   409 

   410   Exit:

   411     FT_TRACE4(( "FT_New_GlyphSlot: Return %d\n", error ));

   412     return error;

   413   }

   414 

   415 

   416   /* documentation is in ftobjs.h */

   417 

   418   FT_BASE_DEF( void )

   419   FT_Done_GlyphSlot( FT_GlyphSlot  slot )

   420   {

   421     if ( slot )

   422     {

   423       FT_Driver     driver = slot->face->driver;

   424       FT_Memory     memory = driver->root.memory;

   425       FT_GlyphSlot  prev;

   426       FT_GlyphSlot  cur;

   427 

   428 

   429       /* Remove slot from its parent face's list */

   430       prev = NULL;

   431       cur  = slot->face->glyph;

   432 

   433       while ( cur )

   434       {

   435         if ( cur == slot )

   436         {

   437           if ( !prev )

   438             slot->face->glyph = cur->next;

   439           else

   440             prev->next = cur->next;

   441 

   442           ft_glyphslot_done( slot );

   443           FT_FREE( slot );

   444           break;

   445         }

   446         prev = cur;

   447         cur  = cur->next;

   448       }

   449     }

   450   }

   451 

   452 

   453   /* documentation is in freetype.h */

   454 

   455   FT_EXPORT_DEF( void )

   456   FT_Set_Transform( FT_Face     face,

   457                     FT_Matrix*  matrix,

   458                     FT_Vector*  delta )

   459   {

   460     FT_Face_Internal  internal;

   461 

   462 

   463     if ( !face )

   464       return;

   465 

   466     internal = face->internal;

   467 

   468     internal->transform_flags = 0;

   469 

   470     if ( !matrix )

   471     {

   472       internal->transform_matrix.xx = 0x10000L;

   473       internal->transform_matrix.xy = 0;

   474       internal->transform_matrix.yx = 0;

   475       internal->transform_matrix.yy = 0x10000L;

   476       matrix = &internal->transform_matrix;

   477     }

   478     else

   479       internal->transform_matrix = *matrix;

   480 

   481     /* set transform_flags bit flag 0 if `matrix' isn't the identity */

   482     if ( ( matrix->xy | matrix->yx ) ||

   483          matrix->xx != 0x10000L      ||

   484          matrix->yy != 0x10000L      )

   485       internal->transform_flags |= 1;

   486 

   487     if ( !delta )

   488     {

   489       internal->transform_delta.x = 0;

   490       internal->transform_delta.y = 0;

   491       delta = &internal->transform_delta;

   492     }

   493     else

   494       internal->transform_delta = *delta;

   495 

   496     /* set transform_flags bit flag 1 if `delta' isn't the null vector */

   497     if ( delta->x | delta->y )

   498       internal->transform_flags |= 2;

   499   }

   500 

   501 

   502   static FT_Renderer

   503   ft_lookup_glyph_renderer( FT_GlyphSlot  slot );

   504 

   505 

   506 #ifdef GRID_FIT_METRICS

   507   static void

   508   ft_glyphslot_grid_fit_metrics( FT_GlyphSlot  slot,

   509                                  FT_Bool       vertical )

   510   {

   511     FT_Glyph_Metrics*  metrics = &slot->metrics;

   512     FT_Pos             right, bottom;

   513 

   514 

   515     if ( vertical )

   516     {

   517       metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX );

   518       metrics->horiBearingY = FT_PIX_CEIL ( metrics->horiBearingY );

   519 

   520       right  = FT_PIX_CEIL( metrics->vertBearingX + metrics->width );

   521       bottom = FT_PIX_CEIL( metrics->vertBearingY + metrics->height );

   522 

   523       metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX );

   524       metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY );

   525 

   526       metrics->width  = right - metrics->vertBearingX;

   527       metrics->height = bottom - metrics->vertBearingY;

   528     }

   529     else

   530     {

   531       metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX );

   532       metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY );

   533 

   534       right  = FT_PIX_CEIL ( metrics->horiBearingX + metrics->width );

   535       bottom = FT_PIX_FLOOR( metrics->horiBearingY - metrics->height );

   536 

   537       metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX );

   538       metrics->horiBearingY = FT_PIX_CEIL ( metrics->horiBearingY );

   539 

   540       metrics->width  = right - metrics->horiBearingX;

   541       metrics->height = metrics->horiBearingY - bottom;

   542     }

   543 

   544     metrics->horiAdvance = FT_PIX_ROUND( metrics->horiAdvance );

   545     metrics->vertAdvance = FT_PIX_ROUND( metrics->vertAdvance );

   546   }

   547 #endif /* GRID_FIT_METRICS */

   548 

   549 

   550   /* documentation is in freetype.h */

   551 

   552   FT_EXPORT_DEF( FT_Error )

   553   FT_Load_Glyph( FT_Face   face,

   554                  FT_UInt   glyph_index,

   555                  FT_Int32  load_flags )

   556   {

   557     FT_Error      error;

   558     FT_Driver     driver;

   559     FT_GlyphSlot  slot;

   560     FT_Library    library;

   561     FT_Bool       autohint = FALSE;

   562     FT_Module     hinter;

   563     TT_Face       ttface = (TT_Face)face;

   564 

   565 

   566     if ( !face || !face->size || !face->glyph )

   567       return FT_Err_Invalid_Face_Handle;

   568 

   569     /* The validity test for `glyph_index' is performed by the */

   570     /* font drivers.                                           */

   571 

   572     slot = face->glyph;

   573     ft_glyphslot_clear( slot );

   574 

   575     driver  = face->driver;

   576     library = driver->root.library;

   577     hinter  = library->auto_hinter;

   578 

   579     /* resolve load flags dependencies */

   580 

   581     if ( load_flags & FT_LOAD_NO_RECURSE )

   582       load_flags |= FT_LOAD_NO_SCALE         |

   583                     FT_LOAD_IGNORE_TRANSFORM;

   584 

   585     if ( load_flags & FT_LOAD_NO_SCALE )

   586     {

   587       load_flags |= FT_LOAD_NO_HINTING |

   588                     FT_LOAD_NO_BITMAP;

   589 

   590       load_flags &= ~FT_LOAD_RENDER;

   591     }

   592 

   593     /*

   594      * Determine whether we need to auto-hint or not.

   595      * The general rules are:

   596      *

   597      * - Do only auto-hinting if we have a hinter module, a scalable font

   598      *   format dealing with outlines, and no transforms except simple

   599      *   slants and/or rotations by integer multiples of 90 degrees.

   600      *

   601      * - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't

   602      *   have a native font hinter.

   603      *

   604      * - Otherwise, auto-hint for LIGHT hinting mode or if there isn't

   605      *   any hinting bytecode in the TrueType/OpenType font.

   606      *

   607      * - Exception: The font is `tricky' and requires the native hinter to

   608      *   load properly.

   609      */

   610 

   611     if ( hinter                                           &&

   612          !( load_flags & FT_LOAD_NO_HINTING )             &&

   613          !( load_flags & FT_LOAD_NO_AUTOHINT )            &&

   614          FT_DRIVER_IS_SCALABLE( driver )                  &&

   615          FT_DRIVER_USES_OUTLINES( driver )                &&

   616          !FT_IS_TRICKY( face )                            &&

   617          ( ( face->internal->transform_matrix.yx == 0 &&

   618              face->internal->transform_matrix.xx != 0 ) ||

   619            ( face->internal->transform_matrix.xx == 0 &&

   620              face->internal->transform_matrix.yx != 0 ) ) )

   621     {

   622       if ( ( load_flags & FT_LOAD_FORCE_AUTOHINT ) ||

   623            !FT_DRIVER_HAS_HINTER( driver )         )

   624         autohint = TRUE;

   625       else

   626       {

   627         FT_Render_Mode  mode = FT_LOAD_TARGET_MODE( load_flags );

   628 

   629 

   630         /* the check for `num_locations' assures that we actually    */

   631         /* test for instructions in a TTF and not in a CFF-based OTF */

   632         if ( mode == FT_RENDER_MODE_LIGHT                       ||

   633              face->internal->ignore_unpatented_hinter           ||

   634              ( FT_IS_SFNT( face )                             &&

   635                ttface->num_locations                          &&

   636                ttface->max_profile.maxSizeOfInstructions == 0 ) )

   637           autohint = TRUE;

   638       }

   639     }

   640 

   641     if ( autohint )

   642     {

   643       FT_AutoHinter_Service  hinting;

   644 

   645 

   646       /* try to load embedded bitmaps first if available            */

   647       /*                                                            */

   648       /* XXX: This is really a temporary hack that should disappear */

   649       /*      promptly with FreeType 2.1!                           */

   650       /*                                                            */

   651       if ( FT_HAS_FIXED_SIZES( face )             &&

   652           ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )

   653       {

   654         error = driver->clazz->load_glyph( slot, face->size,

   655                                            glyph_index,

   656                                            load_flags | FT_LOAD_SBITS_ONLY );

   657 

   658         if ( !error && slot->format == FT_GLYPH_FORMAT_BITMAP )

   659           goto Load_Ok;

   660       }

   661 

   662       {

   663         FT_Face_Internal  internal        = face->internal;

   664         FT_Int            transform_flags = internal->transform_flags;

   665 

   666 

   667         /* since the auto-hinter calls FT_Load_Glyph by itself, */

   668         /* make sure that glyphs aren't transformed             */

   669         internal->transform_flags = 0;

   670 

   671         /* load auto-hinted outline */

   672         hinting = (FT_AutoHinter_Service)hinter->clazz->module_interface;

   673 

   674         error   = hinting->load_glyph( (FT_AutoHinter)hinter,

   675                                        slot, face->size,

   676                                        glyph_index, load_flags );

   677 

   678         internal->transform_flags = transform_flags;

   679       }

   680     }

   681     else

   682     {

   683       error = driver->clazz->load_glyph( slot,

   684                                          face->size,

   685                                          glyph_index,

   686                                          load_flags );

   687       if ( error )

   688         goto Exit;

   689 

   690       if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )

   691       {

   692         /* check that the loaded outline is correct */

   693         error = FT_Outline_Check( &slot->outline );

   694         if ( error )

   695           goto Exit;

   696 

   697 #ifdef GRID_FIT_METRICS

   698         if ( !( load_flags & FT_LOAD_NO_HINTING ) )

   699           ft_glyphslot_grid_fit_metrics( slot,

   700               FT_BOOL( load_flags & FT_LOAD_VERTICAL_LAYOUT ) );

   701 #endif

   702       }

   703     }

   704 

   705   Load_Ok:

   706     /* compute the advance */

   707     if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )

   708     {

   709       slot->advance.x = 0;

   710       slot->advance.y = slot->metrics.vertAdvance;

   711     }

   712     else

   713     {

   714       slot->advance.x = slot->metrics.horiAdvance;

   715       slot->advance.y = 0;

   716     }

   717 

   718     /* compute the linear advance in 16.16 pixels */

   719     if ( ( load_flags & FT_LOAD_LINEAR_DESIGN ) == 0 &&

   720          ( FT_IS_SCALABLE( face ) )                  )

   721     {

   722       FT_Size_Metrics*  metrics = &face->size->metrics;

   723 

   724 

   725       /* it's tricky! */

   726       slot->linearHoriAdvance = FT_MulDiv( slot->linearHoriAdvance,

   727                                            metrics->x_scale, 64 );

   728 

   729       slot->linearVertAdvance = FT_MulDiv( slot->linearVertAdvance,

   730                                            metrics->y_scale, 64 );

   731     }

   732 

   733     if ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) == 0 )

   734     {

   735       FT_Face_Internal  internal = face->internal;

   736 

   737 

   738       /* now, transform the glyph image if needed */

   739       if ( internal->transform_flags )

   740       {

   741         /* get renderer */

   742         FT_Renderer  renderer = ft_lookup_glyph_renderer( slot );

   743 

   744 

   745         if ( renderer )

   746           error = renderer->clazz->transform_glyph(

   747                                      renderer, slot,

   748                                      &internal->transform_matrix,

   749                                      &internal->transform_delta );

   750         else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )

   751         {

   752           /* apply `standard' transformation if no renderer is available */

   753           if ( &internal->transform_matrix )

   754             FT_Outline_Transform( &slot->outline,

   755                                   &internal->transform_matrix );

   756 

   757           if ( &internal->transform_delta )

   758             FT_Outline_Translate( &slot->outline,

   759                                   internal->transform_delta.x,

   760                                   internal->transform_delta.y );

   761         }

   762 

   763         /* transform advance */

   764         FT_Vector_Transform( &slot->advance, &internal->transform_matrix );

   765       }

   766     }

   767 

   768     FT_TRACE5(( "  x advance: %d\n" , slot->advance.x ));

   769     FT_TRACE5(( "  y advance: %d\n" , slot->advance.y ));

   770 

   771     FT_TRACE5(( "  linear x advance: %d\n" , slot->linearHoriAdvance ));

   772     FT_TRACE5(( "  linear y advance: %d\n" , slot->linearVertAdvance ));

   773 

   774     /* do we need to render the image now? */

   775     if ( !error                                    &&

   776          slot->format != FT_GLYPH_FORMAT_BITMAP    &&

   777          slot->format != FT_GLYPH_FORMAT_COMPOSITE &&

   778          load_flags & FT_LOAD_RENDER )

   779     {

   780       FT_Render_Mode  mode = FT_LOAD_TARGET_MODE( load_flags );

   781 

   782 

   783       if ( mode == FT_RENDER_MODE_NORMAL      &&

   784            (load_flags & FT_LOAD_MONOCHROME ) )

   785         mode = FT_RENDER_MODE_MONO;

   786 

   787       error = FT_Render_Glyph( slot, mode );

   788     }

   789 

   790   Exit:

   791     return error;

   792   }

   793 

   794 

   795   /* documentation is in freetype.h */

   796 

   797   FT_EXPORT_DEF( FT_Error )

   798   FT_Load_Char( FT_Face   face,

   799                 FT_ULong  char_code,

   800                 FT_Int32  load_flags )

   801   {

   802     FT_UInt  glyph_index;

   803 

   804 

   805     if ( !face )

   806       return FT_Err_Invalid_Face_Handle;

   807 

   808     glyph_index = (FT_UInt)char_code;

   809     if ( face->charmap )

   810       glyph_index = FT_Get_Char_Index( face, char_code );

   811 

   812     return FT_Load_Glyph( face, glyph_index, load_flags );

   813   }

   814 

   815 

   816   /* destructor for sizes list */

   817   static void

   818   destroy_size( FT_Memory  memory,

   819                 FT_Size    size,

   820                 FT_Driver  driver )

   821   {

   822     /* finalize client-specific data */

   823     if ( size->generic.finalizer )

   824       size->generic.finalizer( size );

   825 

   826     /* finalize format-specific stuff */

   827     if ( driver->clazz->done_size )

   828       driver->clazz->done_size( size );

   829 

   830     FT_FREE( size->internal );

   831     FT_FREE( size );

   832   }

   833 

   834 

   835   static void

   836   ft_cmap_done_internal( FT_CMap  cmap );

   837 

   838 

   839   static void

   840   destroy_charmaps( FT_Face    face,

   841                     FT_Memory  memory )

   842   {

   843     FT_Int  n;

   844 

   845 

   846     if ( !face )

   847       return;

   848 

   849     for ( n = 0; n < face->num_charmaps; n++ )

   850     {

   851       FT_CMap  cmap = FT_CMAP( face->charmaps[n] );

   852 

   853 

   854       ft_cmap_done_internal( cmap );

   855 

   856       face->charmaps[n] = NULL;

   857     }

   858 

   859     FT_FREE( face->charmaps );

   860     face->num_charmaps = 0;

   861   }

   862 

   863 

   864   /* destructor for faces list */

   865   static void

   866   destroy_face( FT_Memory  memory,

   867                 FT_Face    face,

   868                 FT_Driver  driver )

   869   {

   870     FT_Driver_Class  clazz = driver->clazz;

   871 

   872 

   873     /* discard auto-hinting data */

   874     if ( face->autohint.finalizer )

   875       face->autohint.finalizer( face->autohint.data );

   876 

   877     /* Discard glyph slots for this face.                           */

   878     /* Beware!  FT_Done_GlyphSlot() changes the field `face->glyph' */

   879     while ( face->glyph )

   880       FT_Done_GlyphSlot( face->glyph );

   881 

   882     /* discard all sizes for this face */

   883     FT_List_Finalize( &face->sizes_list,

   884                       (FT_List_Destructor)destroy_size,

   885                       memory,

   886                       driver );

   887     face->size = 0;

   888 

   889     /* now discard client data */

   890     if ( face->generic.finalizer )

   891       face->generic.finalizer( face );

   892 

   893     /* discard charmaps */

   894     destroy_charmaps( face, memory );

   895 

   896     /* finalize format-specific stuff */

   897     if ( clazz->done_face )

   898       clazz->done_face( face );

   899 

   900     /* close the stream for this face if needed */

   901     FT_Stream_Free(

   902       face->stream,

   903       ( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );

   904 

   905     face->stream = 0;

   906 

   907     /* get rid of it */

   908     if ( face->internal )

   909     {

   910       FT_FREE( face->internal );

   911     }

   912     FT_FREE( face );

   913   }

   914 

   915 

   916   static void

   917   Destroy_Driver( FT_Driver  driver )

   918   {

   919     FT_List_Finalize( &driver->faces_list,

   920                       (FT_List_Destructor)destroy_face,

   921                       driver->root.memory,

   922                       driver );

   923 

   924     /* check whether we need to drop the driver's glyph loader */

   925     if ( FT_DRIVER_USES_OUTLINES( driver ) )

   926       FT_GlyphLoader_Done( driver->glyph_loader );

   927   }

   928 

   929 

   930   /*************************************************************************/

   931   /*                                                                       */

   932   /* <Function>                                                            */

   933   /*    find_unicode_charmap                                               */

   934   /*                                                                       */

   935   /* <Description>                                                         */

   936   /*    This function finds a Unicode charmap, if there is one.            */

   937   /*    And if there is more than one, it tries to favour the more         */

   938   /*    extensive one, i.e., one that supports UCS-4 against those which   */

   939   /*    are limited to the BMP (said UCS-2 encoding.)                      */

   940   /*                                                                       */

   941   /*    This function is called from open_face() (just below), and also    */

   942   /*    from FT_Select_Charmap( ..., FT_ENCODING_UNICODE ).                */

   943   /*                                                                       */

   944   static FT_Error

   945   find_unicode_charmap( FT_Face  face )

   946   {

   947     FT_CharMap*  first;

   948     FT_CharMap*  cur;

   949 

   950 

   951     /* caller should have already checked that `face' is valid */

   952     FT_ASSERT( face );

   953 

   954     first = face->charmaps;

   955 

   956     if ( !first )

   957       return FT_Err_Invalid_CharMap_Handle;

   958 

   959     /*

   960      *  The original TrueType specification(s) only specified charmap

   961      *  formats that are capable of mapping 8 or 16 bit character codes to

   962      *  glyph indices.

   963      *

   964      *  However, recent updates to the Apple and OpenType specifications

   965      *  introduced new formats that are capable of mapping 32-bit character

   966      *  codes as well.  And these are already used on some fonts, mainly to

   967      *  map non-BMP Asian ideographs as defined in Unicode.

   968      *

   969      *  For compatibility purposes, these fonts generally come with

   970      *  *several* Unicode charmaps:

   971      *

   972      *   - One of them in the "old" 16-bit format, that cannot access

   973      *     all glyphs in the font.

   974      *

   975      *   - Another one in the "new" 32-bit format, that can access all

   976      *     the glyphs.

   977      *

   978      *  This function has been written to always favor a 32-bit charmap

   979      *  when found.  Otherwise, a 16-bit one is returned when found.

   980      */

   981 

   982     /* Since the `interesting' table, with IDs (3,10), is normally the */

   983     /* last one, we loop backwards.  This loses with type1 fonts with  */

   984     /* non-BMP characters (<.0001%), this wins with .ttf with non-BMP  */

   985     /* chars (.01% ?), and this is the same about 99.99% of the time!  */

   986 

   987     cur = first + face->num_charmaps;  /* points after the last one */

   988 

   989     for ( ; --cur >= first; )

   990     {

   991       if ( cur[0]->encoding == FT_ENCODING_UNICODE )

   992       {

   993         /* XXX If some new encodings to represent UCS-4 are added, */

   994         /*     they should be added here.                          */

   995         if ( ( cur[0]->platform_id == TT_PLATFORM_MICROSOFT &&

   996                cur[0]->encoding_id == TT_MS_ID_UCS_4        )     ||

   997              ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE &&

   998                cur[0]->encoding_id == TT_APPLE_ID_UNICODE_32    ) )

   999         {

  1000 #ifdef FT_MAX_CHARMAP_CACHEABLE

  1001           if ( cur - first > FT_MAX_CHARMAP_CACHEABLE )

  1002           {

  1003             FT_ERROR(( "find_unicode_charmap: UCS-4 cmap is found "

  1004                        "at too late position (%d)\n", cur - first ));

  1005             continue;

  1006           }

  1007 #endif

  1008           face->charmap = cur[0];

  1009           return FT_Err_Ok;

  1010         }

  1011       }

  1012     }

  1013 

  1014     /* We do not have any UCS-4 charmap.                */

  1015     /* Do the loop again and search for UCS-2 charmaps. */

  1016     cur = first + face->num_charmaps;

  1017 

  1018     for ( ; --cur >= first; )

  1019     {

  1020       if ( cur[0]->encoding == FT_ENCODING_UNICODE )

  1021       {

  1022 #ifdef FT_MAX_CHARMAP_CACHEABLE

  1023         if ( cur - first > FT_MAX_CHARMAP_CACHEABLE )

  1024         {

  1025           FT_ERROR(( "find_unicode_charmap: UCS-2 cmap is found "

  1026                      "at too late position (%d)\n", cur - first ));

  1027           continue;

  1028         }

  1029 #endif

  1030         face->charmap = cur[0];

  1031         return FT_Err_Ok;

  1032       }

  1033     }

  1034 

  1035     return FT_Err_Invalid_CharMap_Handle;

  1036   }

  1037 

  1038 

  1039   /*************************************************************************/

  1040   /*                                                                       */

  1041   /* <Function>                                                            */

  1042   /*    find_variant_selector_charmap                                      */

  1043   /*                                                                       */

  1044   /* <Description>                                                         */

  1045   /*    This function finds the variant selector charmap, if there is one. */

  1046   /*    There can only be one (platform=0, specific=5, format=14).         */

  1047   /*                                                                       */

  1048   static FT_CharMap

  1049   find_variant_selector_charmap( FT_Face  face )

  1050   {

  1051     FT_CharMap*  first;

  1052     FT_CharMap*  end;

  1053     FT_CharMap*  cur;

  1054 

  1055 

  1056     /* caller should have already checked that `face' is valid */

  1057     FT_ASSERT( face );

  1058 

  1059     first = face->charmaps;

  1060 

  1061     if ( !first )

  1062       return NULL;

  1063 

  1064     end = first + face->num_charmaps;  /* points after the last one */

  1065 

  1066     for ( cur = first; cur < end; ++cur )

  1067     {

  1068       if ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE    &&

  1069            cur[0]->encoding_id == TT_APPLE_ID_VARIANT_SELECTOR &&

  1070            FT_Get_CMap_Format( cur[0] ) == 14                  )

  1071       {

  1072 #ifdef FT_MAX_CHARMAP_CACHEABLE

  1073         if ( cur - first > FT_MAX_CHARMAP_CACHEABLE )

  1074         {

  1075           FT_ERROR(( "find_unicode_charmap: UVS cmap is found "

  1076                      "at too late position (%d)\n", cur - first ));

  1077           continue;

  1078         }

  1079 #endif

  1080         return cur[0];

  1081       }

  1082     }

  1083 

  1084     return NULL;

  1085   }

  1086 

  1087 

  1088   /*************************************************************************/

  1089   /*                                                                       */

  1090   /* <Function>                                                            */

  1091   /*    open_face                                                          */

  1092   /*                                                                       */

  1093   /* <Description>                                                         */

  1094   /*    This function does some work for FT_Open_Face().                   */

  1095   /*                                                                       */

  1096   static FT_Error

  1097   open_face( FT_Driver      driver,

  1098              FT_Stream      stream,

  1099              FT_Long        face_index,

  1100              FT_Int         num_params,

  1101              FT_Parameter*  params,

  1102              FT_Face       *aface )

  1103   {

  1104     FT_Memory         memory;

  1105     FT_Driver_Class   clazz;

  1106     FT_Face           face = 0;

  1107     FT_Error          error, error2;

  1108     FT_Face_Internal  internal = NULL;

  1109 

  1110 

  1111     clazz  = driver->clazz;

  1112     memory = driver->root.memory;

  1113 

  1114     /* allocate the face object and perform basic initialization */

  1115     if ( FT_ALLOC( face, clazz->face_object_size ) )

  1116       goto Fail;

  1117 

  1118     if ( FT_NEW( internal ) )

  1119       goto Fail;

  1120 

  1121     face->internal = internal;

  1122 

  1123     face->driver   = driver;

  1124     face->memory   = memory;

  1125     face->stream   = stream;

  1126 

  1127 #ifdef FT_CONFIG_OPTION_INCREMENTAL

  1128     {

  1129       int  i;

  1130 

  1131 

  1132       face->internal->incremental_interface = 0;

  1133       for ( i = 0; i < num_params && !face->internal->incremental_interface;

  1134             i++ )

  1135         if ( params[i].tag == FT_PARAM_TAG_INCREMENTAL )