Update freetype to latest version of ASOP.

src/autofit/afcjk.c

 /***************************************************************************/
 /*                                                                         */
 /*  afcjk.c                                                                */
 /*                                                                         */
 /*    Auto-fitter hinting routines for CJK script (body).                  */
 /*                                                                         */
-/*  Copyright 2006-2012 by                                                 */
+/*  Copyright 2006-2013 by                                                 */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
 /*  modified, and distributed under the terms of the FreeType project      */
 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 /*  this file you indicate that you have read the license and              */
 /*  understand and accept it fully.                                        */
 /*                                                                         */
 /***************************************************************************/
 
@@ skipping 42 matching lines @@
   /*****                                                               *****/
   /*************************************************************************/
   /*************************************************************************/
 
 
   /* Basically the Latin version with AF_CJKMetrics */
   /* to replace AF_LatinMetrics.                    */
 
   FT_LOCAL_DEF( void )
   af_cjk_metrics_init_widths( AF_CJKMetrics  metrics,
-                              FT_Face        face,
-                              FT_ULong       charcode )
+                              FT_Face        face )
   {
     /* scan the array of segments in each direction */
     AF_GlyphHintsRec  hints[1];
 
 
     af_glyph_hints_init( hints, face->memory );
 
     metrics->axis[AF_DIMENSION_HORZ].width_count = 0;
     metrics->axis[AF_DIMENSION_VERT].width_count = 0;
 
     {
       FT_Error          error;
       FT_UInt           glyph_index;
       int               dim;
       AF_CJKMetricsRec  dummy[1];
       AF_Scaler         scaler = &dummy->root.scaler;
 
 
-      glyph_index = FT_Get_Char_Index( face, charcode );
+      glyph_index = FT_Get_Char_Index( face,
+                                       metrics->root.clazz->standard_char );
       if ( glyph_index == 0 )
         goto Exit;
 
       error = FT_Load_Glyph( face, glyph_index, FT_LOAD_NO_SCALE );
       if ( error || face->glyph->outline.n_points <= 0 )
         goto Exit;
 
       FT_ZERO( dummy );
 
       dummy->units_per_em = metrics->units_per_em;
@@ skipping 42 matching lines @@
 
             dist = seg->pos - link->pos;
             if ( dist < 0 )
               dist = -dist;
 
             if ( num_widths < AF_CJK_MAX_WIDTHS )
               axis->widths[num_widths++].org = dist;
           }
         }
 
-        af_sort_widths( num_widths, axis->widths );
+        /* this also replaces multiple almost identical stem widths */
+        /* with a single one (the value 100 is heuristic) */
+        af_sort_and_quantize_widths( &num_widths, axis->widths,
+                                     dummy->units_per_em / 100 );
         axis->width_count = num_widths;
       }
 
     Exit:
       for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
       {
         AF_CJKAxis  axis = &metrics->axis[dim];
         FT_Pos      stdw;
 
 
@@ skipping 307 matching lines @@
 
       /* make sure blue_ref >= blue_shoot for top/right or */
       /* vice versa for bottom/left                        */
       if ( *blue_shoot != *blue_ref )
       {
         FT_Pos   ref       = *blue_ref;
         FT_Pos   shoot     = *blue_shoot;
         FT_Bool  under_ref = FT_BOOL( shoot < ref );
 
 
-        if ( (AF_CJK_BLUE_TOP == bb || AF_CJK_BLUE_RIGHT == bb) ^ under_ref )
+        if ( ( AF_CJK_BLUE_TOP == bb   ||
+               AF_CJK_BLUE_RIGHT == bb ) ^ under_ref )
           *blue_shoot = *blue_ref = ( shoot + ref ) / 2;
       }
 
       blue->flags = 0;
       if ( AF_CJK_BLUE_TOP == bb )
         blue->flags |= AF_CJK_BLUE_IS_TOP;
       else if ( AF_CJK_BLUE_RIGHT == bb )
         blue->flags |= AF_CJK_BLUE_IS_RIGHT;
 
       FT_TRACE5(( "-- cjk %s bluezone ref = %ld shoot = %ld\n",
@@ skipping 57 matching lines @@
   {
     FT_CharMap  oldmap = face->charmap;
 
 
     metrics->units_per_em = face->units_per_EM;
 
     if ( FT_Select_Charmap( face, FT_ENCODING_UNICODE ) )
       face->charmap = NULL;
     else
     {
-      af_cjk_metrics_init_widths( metrics, face, 0x7530 );
+      af_cjk_metrics_init_widths( metrics, face );
       af_cjk_metrics_init_blues( metrics, face, af_cjk_hani_blue_chars );
       af_cjk_metrics_check_digits( metrics, face );
     }
 
     FT_Set_Charmap( face, oldmap );
 
-    return AF_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
   static void
   af_cjk_metrics_scale_dim( AF_CJKMetrics  metrics,
                             AF_Scaler      scaler,
                             AF_Dimension   dim )
   {
     FT_Fixed    scale;
     FT_Pos      delta;
@@ skipping 115 matching lines @@
     error = af_latin_hints_compute_segments( hints, dim );
     if ( error )
       return error;
 
     /* a segment is round if it doesn't have successive */
     /* on-curve points.                                 */
     for ( seg = segments; seg < segment_limit; seg++ )
     {
       AF_Point  pt   = seg->first;
       AF_Point  last = seg->last;
-      AF_Flags  f0   = (AF_Flags)(pt->flags & AF_FLAG_CONTROL);
+      AF_Flags  f0   = (AF_Flags)( pt->flags & AF_FLAG_CONTROL );
       AF_Flags  f1;
 
 
       seg->flags &= ~AF_EDGE_ROUND;
 
       for ( ; pt != last; f0 = f1 )
       {
         pt = pt->next;
-        f1 = (AF_Flags)(pt->flags & AF_FLAG_CONTROL);
+        f1 = (AF_Flags)( pt->flags & AF_FLAG_CONTROL );
 
         if ( !f0 && !f1 )
           break;
 
         if ( pt == last )
           seg->flags |= AF_EDGE_ROUND;
       }
     }
 
-    return AF_Err_Ok;
+    return FT_Err_Ok;
   }
 
 
   static void
   af_cjk_hints_link_segments( AF_GlyphHints  hints,
                               AF_Dimension   dim )
   {
     AF_AxisHints  axis          = &hints->axis[dim];
     AF_Segment    segments      = axis->segments;
     AF_Segment    segment_limit = segments + axis->num_segments;
@@ skipping 153 matching lines @@
       }
     }
   }
 
 
   static FT_Error
   af_cjk_hints_compute_edges( AF_GlyphHints  hints,
                               AF_Dimension   dim )
   {
     AF_AxisHints  axis   = &hints->axis[dim];
-    FT_Error      error  = AF_Err_Ok;
+    FT_Error      error  = FT_Err_Ok;
     FT_Memory     memory = hints->memory;
     AF_CJKAxis    laxis  = &((AF_CJKMetrics)hints->metrics)->axis[dim];
 
     AF_Segment    segments      = axis->segments;
     AF_Segment    segment_limit = segments + axis->num_segments;
     AF_Segment    seg;
 
     FT_Fixed      scale;
     FT_Pos        edge_distance_threshold;
 
@@ skipping 49 matching lines @@
 
         if ( dist < edge_distance_threshold && dist < best )
         {
           AF_Segment  link = seg->link;
 
 
           /* check whether all linked segments of the candidate edge */
           /* can make a single edge.                                 */
           if ( link )
           {
-            AF_Segment  seg1 = edge->first;
-            AF_Segment  link1;
+            AF_Segment  seg1  = edge->first;
             FT_Pos      dist2 = 0;
 
 
             do
             {
-              link1 = seg1->link;
+              AF_Segment  link1 = seg1->link;
+
+
               if ( link1 )
               {
                 dist2 = AF_SEGMENT_DIST( link, link1 );
                 if ( dist2 >= edge_distance_threshold )
                   break;
               }
 
             } while ( ( seg1 = seg1->edge_next ) != edge->first );
 
             if ( dist2 >= edge_distance_threshold )
@@ skipping 1200 matching lines @@
   /*****                C J K   S C R I P T   C L A S S                *****/
   /*****                                                               *****/
   /*************************************************************************/
   /*************************************************************************/
 
 
   /* this corresponds to Unicode 6.0 */
 
   static const AF_Script_UniRangeRec  af_cjk_uniranges[] =
   {
+    AF_UNIRANGE_REC(  0x1100UL,  0x11FFUL ),  /* Hangul Jamo                             */
     AF_UNIRANGE_REC(  0x2E80UL,  0x2EFFUL ),  /* CJK Radicals Supplement                 */
     AF_UNIRANGE_REC(  0x2F00UL,  0x2FDFUL ),  /* Kangxi Radicals                         */
     AF_UNIRANGE_REC(  0x2FF0UL,  0x2FFFUL ),  /* Ideographic Description Characters      */
     AF_UNIRANGE_REC(  0x3000UL,  0x303FUL ),  /* CJK Symbols and Punctuation             */
     AF_UNIRANGE_REC(  0x3040UL,  0x309FUL ),  /* Hiragana                                */
     AF_UNIRANGE_REC(  0x30A0UL,  0x30FFUL ),  /* Katakana                                */
     AF_UNIRANGE_REC(  0x3100UL,  0x312FUL ),  /* Bopomofo                                */
     AF_UNIRANGE_REC(  0x3130UL,  0x318FUL ),  /* Hangul Compatibility Jamo               */
     AF_UNIRANGE_REC(  0x3190UL,  0x319FUL ),  /* Kanbun                                  */
     AF_UNIRANGE_REC(  0x31A0UL,  0x31BFUL ),  /* Bopomofo Extended                       */
@@ skipping 18 matching lines @@
     AF_UNIRANGE_REC( 0x2A700UL, 0x2B73FUL ),  /* CJK Unified Ideographs Extension C      */
     AF_UNIRANGE_REC( 0x2B740UL, 0x2B81FUL ),  /* CJK Unified Ideographs Extension D      */
     AF_UNIRANGE_REC( 0x2F800UL, 0x2FA1FUL ),  /* CJK Compatibility Ideographs Supplement */
     AF_UNIRANGE_REC(       0UL,       0UL )
   };
 
 
   AF_DEFINE_SCRIPT_CLASS( af_cjk_script_class,
     AF_SCRIPT_CJK,
     af_cjk_uniranges,
+    0x7530, /* 田 */
 
     sizeof ( AF_CJKMetricsRec ),
 
     (AF_Script_InitMetricsFunc) af_cjk_metrics_init,
     (AF_Script_ScaleMetricsFunc)af_cjk_metrics_scale,
     (AF_Script_DoneMetricsFunc) NULL,
 
     (AF_Script_InitHintsFunc)   af_cjk_hints_init,
     (AF_Script_ApplyHintsFunc)  af_cjk_hints_apply
   )
 
 #else /* !AF_CONFIG_OPTION_CJK */
 
   static const AF_Script_UniRangeRec  af_cjk_uniranges[] =
   {
     AF_UNIRANGE_REC( 0UL, 0UL )
   };
 
 
   AF_DEFINE_SCRIPT_CLASS( af_cjk_script_class,
     AF_SCRIPT_CJK,
     af_cjk_uniranges,
+    0,
 
     sizeof ( AF_CJKMetricsRec ),
 
     (AF_Script_InitMetricsFunc) NULL,
     (AF_Script_ScaleMetricsFunc)NULL,
     (AF_Script_DoneMetricsFunc) NULL,
 
     (AF_Script_InitHintsFunc)   NULL,
     (AF_Script_ApplyHintsFunc)  NULL
   )
 
 #endif /* !AF_CONFIG_OPTION_CJK */
 
 
 /* END */