kc3-lang/freetype/src/cff/cf2hints.c

• Show log

  Commit

• Hash : 283c8ed8
  Author :
  Date : 2013-04-13T15:02:31
  

  [cff] New files for Adobe's Type 2 interpreter and hinting engine.

Download

• src/cff/cf2hints.c

• /***************************************************************************/
  /*                                                                         */
  /*  cf2hints.c                                                             */
  /*                                                                         */
  /*    Adobe's code for handling CFF hints (body).                          */
  /*                                                                         */
  /*  Copyright 2007-2013 Adobe Systems Incorporated.                        */
  /*                                                                         */
  /*  This software, and all works of authorship, whether in source or       */
  /*  object code form as indicated by the copyright notice(s) included      */
  /*  herein (collectively, the "Work") is made available, and may only be   */
  /*  used, modified, and distributed under the FreeType Project License,    */
  /*  LICENSE.TXT.  Additionally, subject to the terms and conditions of the */
  /*  FreeType Project License, each contributor to the Work hereby grants   */
  /*  to any individual or legal entity exercising permissions granted by    */
  /*  the FreeType Project License and this section (hereafter, "You" or     */
  /*  "Your") a perpetual, worldwide, non-exclusive, no-charge,              */
  /*  royalty-free, irrevocable (except as stated in this section) patent    */
  /*  license to make, have made, use, offer to sell, sell, import, and      */
  /*  otherwise transfer the Work, where such license applies only to those  */
  /*  patent claims licensable by such contributor that are necessarily      */
  /*  infringed by their contribution(s) alone or by combination of their    */
  /*  contribution(s) with the Work to which such contribution(s) was        */
  /*  submitted.  If You institute patent litigation against any entity      */
  /*  (including a cross-claim or counterclaim in a lawsuit) alleging that   */
  /*  the Work or a contribution incorporated within the Work constitutes    */
  /*  direct or contributory patent infringement, then any patent licenses   */
  /*  granted to You under this License for that Work shall terminate as of  */
  /*  the date such litigation is filed.                                     */
  /*                                                                         */
  /*  By using, modifying, or distributing the Work you indicate that you    */
  /*  have read and understood the terms and conditions of the               */
  /*  FreeType Project License as well as those provided in this section,    */
  /*  and you accept them fully.                                             */
  /*                                                                         */
  /***************************************************************************/
  
  
  #include "cf2ft.h"
  #include FT_INTERNAL_DEBUG_H
  
  #include "cf2glue.h"
  #include "cf2font.h"
  #include "cf2hints.h"
  #include "cf2intrp.h"
  
  
    /*************************************************************************/
    /*                                                                       */
    /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
    /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
    /* messages during execution.                                            */
    /*                                                                       */
  #undef  FT_COMPONENT
  #define FT_COMPONENT  trace_cf2hints
  
  
    typedef struct  CF2_HintMoveRec_
    {
      size_t     j;          /* index of upper hint map edge   */
      CF2_Fixed  moveUp;     /* adjustment to optimum position */
  
    } CF2_HintMoveRec, *CF2_HintMove;
  
  
    /* Compute angular momentum for winding order detection.  It is called */
    /* for all lines and curves, but not necessarily in element order.     */
    static CF2_Int
    cf2_getWindingMomentum( CF2_Fixed  x1,
                            CF2_Fixed  y1,
                            CF2_Fixed  x2,
                            CF2_Fixed  y2 )
    {
      /* cross product of pt1 position from origin with pt2 position from  */
      /* pt1; we reduce the precision so that the result fits into 32 bits */
  
      return ( x1 >> 16 ) * ( ( y2 - y1 ) >> 16 ) -
             ( y1 >> 16 ) * ( ( x2 - x1 ) >> 16 );
    }
  
  
    /*
     * Construct from a StemHint; this is used as a parameter to
     * `cf2_blues_capture'.
     * `hintOrigin' is the character space displacement of a seac accent.
     * Adjust stem hint for darkening here.
     *
     */
    static void
    cf2_hint_init( CF2_Hint            hint,
                   const CF2_ArrStack  stemHintArray,
                   size_t              indexStemHint,
                   const CF2_Font      font,
                   CF2_Fixed           hintOrigin,
                   CF2_Fixed           scale,
                   FT_Bool             bottom )
    {
      CF2_Fixed               width;
      const CF2_StemHintRec*  stemHint;
  
  
      FT_ZERO( hint );
  
      stemHint = (const CF2_StemHintRec*)cf2_arrstack_getPointer(
                                           stemHintArray,
                                           indexStemHint );
  
      width = stemHint->max - stemHint->min;
  
      if ( width == cf2_intToFixed( -21 ) )
      {
        /* ghost bottom */
  
        if ( bottom )
        {
          hint->csCoord = stemHint->max;
          hint->flags   = CF2_GhostBottom;
        }
        else
          hint->flags = 0;
      }
  
      else if ( width == cf2_intToFixed( -20 ) )
      {
        /* ghost top */
  
        if ( bottom )
          hint->flags = 0;
        else
        {
          hint->csCoord = stemHint->min;
          hint->flags   = CF2_GhostTop;
        }
      }
  
      else if ( width < 0 )
      {
        /* inverted pair */
  
        /*
         * Hints with negative widths were produced by an early version of a
         * non-Adobe font tool.  The Type 2 spec allows edge (ghost) hints
         * with negative widths, but says
         *
         *   All other negative widths have undefined meaning.
         *
         * CoolType has a silent workaround that negates the hint width; for
         * permissive mode, we do the same here.
         *
         * Note: Such fonts cannot use ghost hints, but should otherwise work.
         * Note: Some poor hints in our faux fonts can produce negative
         *       widths at some blends.  For example, see a light weight of
         *       `u' in ASerifMM.
         *
         */
        if ( bottom )
        {
          hint->csCoord = stemHint->max;
          hint->flags   = CF2_PairBottom;
        }
        else
        {
          hint->csCoord = stemHint->min;
          hint->flags   = CF2_PairTop;
        }
      }
  
      else
      {
        /* normal pair */
  
        if ( bottom )
        {
          hint->csCoord = stemHint->min;
          hint->flags   = CF2_PairBottom;
        }
        else
        {
          hint->csCoord = stemHint->max;
          hint->flags   = CF2_PairTop;
        }
      }
  
      /* Now that ghost hints have been detected, adjust this edge for      */
      /* darkening.  Bottoms are not changed; tops are incremented by twice */
      /* `darkenY'.                                                         */
      if ( cf2_hint_isTop( hint ) )
        hint->csCoord += 2 * font->darkenY;
  
      hint->csCoord += hintOrigin;
      hint->scale    = scale;
      hint->index    = indexStemHint;   /* index in original stem hint array */
  
      /* if original stem hint has been used, use the same position */
      if ( hint->flags != 0 && stemHint->used )
      {
        if ( cf2_hint_isTop( hint ) )
          hint->dsCoord = stemHint->maxDS;
        else
          hint->dsCoord = stemHint->minDS;
  
        cf2_hint_lock( hint );
      }
      else
        hint->dsCoord = FT_MulFix( hint->csCoord, scale );
    }
  
  
    /* initialize an invalid hint map element */
    static void
    cf2_hint_initZero( CF2_Hint  hint )
    {
      FT_ZERO( hint );
    }
  
  
    FT_LOCAL_DEF( FT_Bool )
    cf2_hint_isValid( const CF2_Hint  hint )
    {
      return hint->flags != 0;
    }
  
  
    static FT_Bool
    cf2_hint_isPair( const CF2_Hint  hint )
    {
      return ( hint->flags                      &
               ( CF2_PairBottom | CF2_PairTop ) ) != 0;
    }
  
  
    static FT_Bool
    cf2_hint_isPairTop( const CF2_Hint  hint )
    {
      return ( hint->flags & CF2_PairTop ) != 0;
    }
  
  
    FT_LOCAL_DEF( FT_Bool )
    cf2_hint_isTop( const CF2_Hint  hint )
    {
      return ( hint->flags                    &
               ( CF2_PairTop | CF2_GhostTop ) ) != 0;
    }
  
  
    FT_LOCAL_DEF( FT_Bool )
    cf2_hint_isBottom( const CF2_Hint  hint )
    {
      return ( hint->flags                          &
               ( CF2_PairBottom | CF2_GhostBottom ) ) != 0;
    }
  
  
    static FT_Bool
    cf2_hint_isLocked( const CF2_Hint  hint )
    {
      return ( hint->flags & CF2_Locked ) != 0;
    }
  
  
    static FT_Bool
    cf2_hint_isSynthetic( const CF2_Hint  hint )
    {
      return ( hint->flags & CF2_Synthetic ) != 0;
    }
  
  
    FT_LOCAL_DEF( void )
    cf2_hint_lock( CF2_Hint  hint )
    {
      hint->flags |= CF2_Locked;
    }
  
  
    FT_LOCAL_DEF( void )
    cf2_hintmap_init( CF2_HintMap   hintmap,
                      CF2_Font      font,
                      CF2_HintMap   initialMap,
                      CF2_ArrStack  hintMoves,
                      CF2_Fixed     scale )
    {
      FT_ZERO( hintmap );
  
      /* copy parameters from font instance */
      hintmap->hinted         = font->hinted;
      hintmap->scale          = scale;
      hintmap->font           = font;
      hintmap->initialHintMap = initialMap;
      /* will clear in `cf2_hintmap_adjustHints' */
      hintmap->hintMoves      = hintMoves;
    }
  
  
    static FT_Bool
    cf2_hintmap_isValid( const CF2_HintMap  hintmap )
    {
      return hintmap->isValid;
    }
  
  
    /* transform character space coordinate to device space using hint map */
    static CF2_Fixed
    cf2_hintmap_map( CF2_HintMap  hintmap,
                     CF2_Fixed    csCoord )
    {
      FT_ASSERT( hintmap->isValid );  /* must call Build before Map */
      FT_ASSERT( hintmap->lastIndex < CF2_MAX_HINT_EDGES );
  
      if ( hintmap->count == 0 || ! hintmap->hinted )
      {
        /* there are no hints; use uniform scale and zero offset */
        return FT_MulFix( csCoord, hintmap->scale );
      }
      else
      {
        /* start linear search from last hit */
        CF2_UInt  i = hintmap->lastIndex;
  
  
        /* search up */
        while ( i < hintmap->count - 1                  &&
                csCoord >= hintmap->edge[i + 1].csCoord )
          i += 1;
  
        /* search down */
        while ( i > 0 && csCoord < hintmap->edge[i].csCoord )
          i -= 1;
  
        hintmap->lastIndex = i;
  
        if ( i == 0 && csCoord < hintmap->edge[0].csCoord )
        {
          /* special case for points below first edge: use uniform scale */
          return FT_MulFix( csCoord - hintmap->edge[0].csCoord,
                            hintmap->scale ) +
                   hintmap->edge[0].dsCoord;
        }
        else
        {
          /*
           * Note: entries with duplicate csCoord are allowed.
           * Use edge[i], the highest entry where csCoord >= entry[i].csCoord
           */
          return FT_MulFix( csCoord - hintmap->edge[i].csCoord,
                            hintmap->edge[i].scale ) +
                   hintmap->edge[i].dsCoord;
        }
      }
    }
  
  
    /*
     * This hinting policy moves a hint pair in device space so that one of
     * its two edges is on a device pixel boundary (its fractional part is
     * zero).  `cf2_hintmap_insertHint' guarantees no overlap in CS
     * space.  Ensure here that there is no overlap in DS.
     *
     * In the first pass, edges are adjusted relative to adjacent hints.
     * Those that are below have already been adjusted.  Those that are
     * above have not yet been adjusted.  If a hint above blocks an
     * adjustment to an optimal position, we will try again in a second
     * pass.  The second pass is top-down.
     *
     */
  
    static void
    cf2_hintmap_adjustHints( CF2_HintMap  hintmap )
    {
      size_t  i, j;
  
  
      cf2_arrstack_clear( hintmap->hintMoves );      /* working storage */
  
      /*
       * First pass is bottom-up (font hint order) without look-ahead.
       * Locked edges are already adjusted.
       * Unlocked edges begin with dsCoord from `initialHintMap'.
       * Save edges that are not optimally adjusted in `hintMoves' array,
       * and process them in second pass.
       */
  
      for ( i = 0; i < hintmap->count; i++ )
      {
        FT_Bool  isPair = cf2_hint_isPair( &hintmap->edge[i] );
  
  
        /* index of upper edge (same value for ghost hint) */
        j = isPair ? i + 1 : i;
  
        FT_ASSERT( j < hintmap->count );
        FT_ASSERT( cf2_hint_isValid( &hintmap->edge[i] ) );
        FT_ASSERT( cf2_hint_isValid( &hintmap->edge[j] ) );
        FT_ASSERT( cf2_hint_isLocked( &hintmap->edge[i] ) ==
                     cf2_hint_isLocked( &hintmap->edge[j] ) );
  
        if ( !cf2_hint_isLocked( &hintmap->edge[i] ) )
        {
          /* hint edge is not locked, we can adjust it */
          CF2_Fixed  fracDown = cf2_fixedFraction( hintmap->edge[i].dsCoord );
          CF2_Fixed  fracUp   = cf2_fixedFraction( hintmap->edge[j].dsCoord );
  
          /* calculate all four possibilities; moves down are negative */
          CF2_Fixed  downMoveDown = 0 - fracDown;
          CF2_Fixed  upMoveDown   = 0 - fracUp;
          CF2_Fixed  downMoveUp   = fracDown == 0
                                      ? 0
                                      : cf2_intToFixed( 1 ) - fracDown;
          CF2_Fixed  upMoveUp     = fracUp == 0
                                      ? 0
                                      : cf2_intToFixed( 1 ) - fracUp;
  
          /* smallest move up */
          CF2_Fixed  moveUp   = FT_MIN( downMoveUp, upMoveUp );
          /* smallest move down */
          CF2_Fixed  moveDown = FT_MAX( downMoveDown, upMoveDown );
  
          /* final amount to move edge or edge pair */
          CF2_Fixed  move;
  
          CF2_Fixed  downMinCounter = CF2_MIN_COUNTER;
          CF2_Fixed  upMinCounter   = CF2_MIN_COUNTER;
          FT_Bool    saveEdge       = FALSE;
  
  
          /* minimum counter constraint doesn't apply when adjacent edges */
          /* are synthetic                                                */
          /* TODO: doesn't seem a big effect; for now, reduce the code    */
  #if 0
          if ( i == 0                                        ||
               cf2_hint_isSynthetic( &hintmap->edge[i - 1] ) )
            downMinCounter = 0;
  
          if ( j >= hintmap->count - 1                       ||
               cf2_hint_isSynthetic( &hintmap->edge[j + 1] ) )
            upMinCounter = 0;
  #endif
  
          /* is there room to move up?                                    */
          /* there is if we are at top of array or the next edge is at or */
          /* beyond proposed move up?                                     */
          if ( j >= hintmap->count - 1                            ||
               hintmap->edge[j + 1].dsCoord >=
                 hintmap->edge[j].dsCoord + moveUp + upMinCounter )
          {
            /* there is room to move up; is there also room to move down? */
            if ( i == 0                                                 ||
                 hintmap->edge[i - 1].dsCoord <=
                   hintmap->edge[i].dsCoord + moveDown - downMinCounter )
            {
              /* move smaller absolute amount */
              move = ( -moveDown < moveUp ) ? moveDown : moveUp;  /* optimum */
            }
            else
              move = moveUp;
          }
          else
          {
            /* is there room to move down? */
            if ( i == 0                                                 ||
                 hintmap->edge[i - 1].dsCoord <=
                   hintmap->edge[i].dsCoord + moveDown - downMinCounter )
            {
              move     = moveDown;
              saveEdge = moveUp < -moveDown;  /* true if non-optimum move */
            }
            else
            {
              /* no room to move either way without overlapping or reducing */
              /* the counter too much                                       */
              move     = 0;
              saveEdge = TRUE;
            }
          }
  
          /* Identify non-moves and moves down that aren't optimal, and save */
          /* them for second pass.                                           */
          /* Do this only if there is an unlocked edge above (which could    */
          /* possibly move).                                                 */
          if ( saveEdge                                    &&
               j < hintmap->count - 1                      &&
               !cf2_hint_isLocked( &hintmap->edge[j + 1] ) )
          {
            CF2_HintMoveRec  savedMove;
  
  
            savedMove.j      = j;
            /* desired adjustment in second pass */
            savedMove.moveUp = moveUp - move;
  
            cf2_arrstack_push( hintmap->hintMoves, &savedMove );
          }
  
          /* move the edge(s) */
          hintmap->edge[i].dsCoord += move;
          if ( isPair )
            hintmap->edge[j].dsCoord += move;
        }
  
        /* assert there are no overlaps in device space */
        FT_ASSERT( i == 0                                                   ||
                   hintmap->edge[i - 1].dsCoord <= hintmap->edge[i].dsCoord );
        FT_ASSERT( i < j                                                ||
                   hintmap->edge[i].dsCoord <= hintmap->edge[j].dsCoord );
  
        /* adjust the scales, avoiding divide by zero */
        if ( i > 0 )
        {
          if ( hintmap->edge[i].csCoord != hintmap->edge[i - 1].csCoord )
            hintmap->edge[i - 1].scale =
              FT_DivFix(
                hintmap->edge[i].dsCoord - hintmap->edge[i - 1].dsCoord,
                hintmap->edge[i].csCoord - hintmap->edge[i - 1].csCoord );
        }
  
        if ( isPair )
        {
          if ( hintmap->edge[j].csCoord != hintmap->edge[j - 1].csCoord )
            hintmap->edge[j - 1].scale =
              FT_DivFix(
                hintmap->edge[j].dsCoord - hintmap->edge[j - 1].dsCoord,
                hintmap->edge[j].csCoord - hintmap->edge[j - 1].csCoord );
  
          i += 1;     /* skip upper edge on next loop */
        }
      }
  
      /* second pass tries to move non-optimal hints up, in case there is */
      /* room now                                                         */
      for ( i = cf2_arrstack_size( hintmap->hintMoves ); i > 0; i-- )
      {
        CF2_HintMove  hintMove = (CF2_HintMove)
                        cf2_arrstack_getPointer( hintmap->hintMoves, i - 1 );
  
  
        j = hintMove->j;
  
        /* this was tested before the push, above */
        FT_ASSERT( j < hintmap->count - 1 );
  
        /* is there room to move up? */
        if ( hintmap->edge[j + 1].dsCoord >=
               hintmap->edge[j].dsCoord + hintMove->moveUp + CF2_MIN_COUNTER )
        {
          /* there is more room now, move edge up */
          hintmap->edge[j].dsCoord += hintMove->moveUp;
  
          if ( cf2_hint_isPair( &hintmap->edge[j] ) )
          {
            FT_ASSERT( j > 0 );
            hintmap->edge[j - 1].dsCoord += hintMove->moveUp;
          }
        }
      }
    }
  
  
    /* insert hint edges into map, sorted by csCoord */
    static void
    cf2_hintmap_insertHint( CF2_HintMap  hintmap,
                            CF2_Hint     bottomHintEdge,
                            CF2_Hint     topHintEdge )
    {
      CF2_UInt  indexInsert;
  
      /* set default values, then check for edge hints */
      FT_Bool   isPair         = TRUE;
      CF2_Hint  firstHintEdge  = bottomHintEdge;
      CF2_Hint  secondHintEdge = topHintEdge;
  
  
      /* one or none of the input params may be invalid when dealing with */
      /* edge hints; at least one edge must be valid                      */
      FT_ASSERT( cf2_hint_isValid( bottomHintEdge ) ||
                 cf2_hint_isValid( topHintEdge )    );
  
      /* determine how many and which edges to insert */
      if ( !cf2_hint_isValid( bottomHintEdge ) )
      {
        /* insert only the top edge */
        firstHintEdge = topHintEdge;
        isPair        = FALSE;
      }
      else if ( !cf2_hint_isValid( topHintEdge ) )
      {
        /* insert only the bottom edge */
        isPair = FALSE;
      }
  
      /* paired edges must be in proper order */
      FT_ASSERT( !isPair                                         ||
                 topHintEdge->csCoord >= bottomHintEdge->csCoord );
  
      /* linear search to find index value of insertion point */
      indexInsert = 0;
      for ( ; indexInsert < hintmap->count; indexInsert++ )
      {
        if ( hintmap->edge[indexInsert].csCoord > firstHintEdge->csCoord )
          break;
      }
  
      /*
       * Discard any hints that overlap in character space.  Most often,
       * this is while building the initial map, but in theory, it can also
       * occur because of darkening.
       *
       */
      if ( indexInsert < hintmap->count )
      {
        /* we are inserting before an existing edge:              */
        /* verify that a new pair does not straddle the next edge */
        if ( isPair                                                       &&
             hintmap->edge[indexInsert].csCoord < secondHintEdge->csCoord )
          return; /* ignore overlapping stem hint */
  
        /* verify that we are not inserting between paired edges */
        if ( cf2_hint_isPairTop( &hintmap->edge[indexInsert] ) )
          return; /* ignore overlapping stem hint */
      }
  
      /* recompute device space locations using initial hint map */
      if ( cf2_hintmap_isValid( hintmap->initialHintMap ) &&
           !cf2_hint_isLocked( firstHintEdge )            )
      {
        if ( isPair )
        {
          /* Use hint map to position the center of stem, and nominal scale */
          /* to position the two edges.  This preserves the stem width.     */
          CF2_Fixed  midpoint  = cf2_hintmap_map(
                                   hintmap->initialHintMap,
                                   ( secondHintEdge->csCoord +
                                     firstHintEdge->csCoord ) / 2 );
          CF2_Fixed  halfWidth = FT_MulFix(
                                   ( secondHintEdge->csCoord -
                                     firstHintEdge->csCoord ) / 2,
                                   hintmap->scale );
  
  
          firstHintEdge->dsCoord  = midpoint - halfWidth;
          secondHintEdge->dsCoord = midpoint + halfWidth;
        }
        else
          firstHintEdge->dsCoord = cf2_hintmap_map( hintmap->initialHintMap,
                                                    firstHintEdge->csCoord );
      }
  
      /* discard any hints that overlap in device space; this can occur */
      /* because locked hints have been moved to align with blue zones  */
      if ( indexInsert > 0 )
      {
        /* we are inserting after an existing edge */
        if ( firstHintEdge->dsCoord < hintmap->edge[indexInsert - 1].dsCoord )
          return;
      }
  
      if ( indexInsert < hintmap->count )
      {
        /* we are inserting before an existing edge */
        if ( isPair )
        {
          if ( secondHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord )
            return;
        }
        else
        {
          if ( firstHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord )
            return;
        }
      }
  
      /* make room to insert */
      {
        CF2_Int  iSrc = hintmap->count - 1;
        CF2_Int  iDst = isPair ? hintmap->count + 1 : hintmap->count;
  
        CF2_Int  count = hintmap->count - indexInsert;
  
  
        if ( iDst >= CF2_MAX_HINT_EDGES )
        {
          FT_TRACE4(( "cf2_hintmap_insertHint: too many hintmaps\n" ));
          return;
        }
  
        while ( count-- )
          hintmap->edge[iDst--] = hintmap->edge[iSrc--];
  
        /* insert first edge */
        hintmap->edge[indexInsert] = *firstHintEdge;         /* copy struct */
        hintmap->count += 1;
  
        if ( isPair )
        {
          /* insert second edge */
          hintmap->edge[indexInsert + 1] = *secondHintEdge;  /* copy struct */
          hintmap->count                += 1;
        }
      }
  
      return;
    }
  
  
    /*
     * Build a map from hints and mask.
     *
     * This function may recur one level if `hintmap->initialHintMap' is not yet
     * valid.
     * If `initialMap' is true, simply build initial map.
     *
     * Synthetic hints are used in two ways.  A hint at zero is inserted, if
     * needed, in the initial hint map, to prevent translations from
     * propagating across the origin.  If synthetic em box hints are enabled
     * for ideographic dictionaries, then they are inserted in all hint
     * maps, including the initial one.
     *
     */
    FT_LOCAL_DEF( void )
    cf2_hintmap_build( CF2_HintMap   hintmap,
                       CF2_ArrStack  hStemHintArray,
                       CF2_ArrStack  vStemHintArray,
                       CF2_HintMask  hintMask,
                       CF2_Fixed     hintOrigin,
                       FT_Bool       initialMap )
    {
      FT_Byte*  maskPtr;
  
      CF2_Font         font = hintmap->font;
      CF2_HintMaskRec  tempHintMask;
  
      size_t   bitCount, i;
      FT_Byte  maskByte;
  
  
      /* check whether initial map is constructed */
      if ( !initialMap && !cf2_hintmap_isValid( hintmap->initialHintMap ) )
      {
        /* make recursive call with initialHintMap and temporary mask; */
        /* temporary mask will get all bits set, below */
        cf2_hintmask_init( &tempHintMask, hintMask->error );
        cf2_hintmap_build( hintmap->initialHintMap,
                           hStemHintArray,
                           vStemHintArray,
                           &tempHintMask,
                           hintOrigin,
                           TRUE );
      }
  
      if ( !cf2_hintmask_isValid( hintMask ) )
      {
        /* without a hint mask, assume all hints are active */
        cf2_hintmask_setAll( hintMask,
                             cf2_arrstack_size( hStemHintArray ) +
                               cf2_arrstack_size( vStemHintArray ) );
      }
  
      /* begin by clearing the map */
      hintmap->count     = 0;
      hintmap->lastIndex = 0;
  
      /* make a copy of the hint mask so we can modify it */
      tempHintMask = *hintMask;
      maskPtr      = cf2_hintmask_getMaskPtr( &tempHintMask );
  
      /* use the hStem hints only, which are first in the mask */
      /* TODO: compare this to cffhintmaskGetBitCount */
      bitCount = cf2_arrstack_size( hStemHintArray );
  
      /* synthetic embox hints get highest priority */
      if ( font->blues.doEmBoxHints )
      {
        CF2_HintRec  dummy;
  
  
        cf2_hint_initZero( &dummy );   /* invalid hint map element */
  
        /* ghost bottom */
        cf2_hintmap_insertHint( hintmap,
                                &font->blues.emBoxBottomEdge,
                                &dummy );
        /* ghost top */
        cf2_hintmap_insertHint( hintmap,
                                &dummy,
                                &font->blues.emBoxTopEdge );
      }
  
      /* insert hints captured by a blue zone or already locked (higher */
      /* priority)                                                      */
      for ( i = 0, maskByte = 0x80; i < bitCount; i++ )
      {
        if ( maskByte & *maskPtr )
        {
          /* expand StemHint into two `CF2_Hint' elements */
          CF2_HintRec  bottomHintEdge, topHintEdge;
  
  
          cf2_hint_init( &bottomHintEdge,
                         hStemHintArray,
                         i,
                         font,
                         hintOrigin,
                         hintmap->scale,
                         TRUE /* bottom */ );
          cf2_hint_init( &topHintEdge,
                         hStemHintArray,
                         i,
                         font,
                         hintOrigin,
                         hintmap->scale,
                         FALSE /* top */ );
  
          if ( cf2_hint_isLocked( &bottomHintEdge ) ||
               cf2_hint_isLocked( &topHintEdge )    ||
               cf2_blues_capture( &font->blues,
                                  &bottomHintEdge,
                                  &topHintEdge )   )
          {
            /* insert captured hint into map */
            cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge );
  
            *maskPtr &= ~maskByte;      /* turn off the bit for this hint */
          }
        }
  
        if ( ( i & 7 ) == 7 )
        {
          /* move to next mask byte */
          maskPtr++;
          maskByte = 0x80;
        }
        else
          maskByte >>= 1;
      }
  
      /* initial hint map includes only captured hints plus maybe one at 0 */
  
      /*
       * TODO: There is a problem here because we are trying to build a
       *       single hint map containing all captured hints.  It is
       *       possible for there to be conflicts between captured hints,
       *       either because of darkening or because the hints are in
       *       separate hint zones (we are ignoring hint zones for the
       *       initial map).  An example of the latter is MinionPro-Regular
       *       v2.030 glyph 883 (Greek Capital Alpha with Psili) at 15ppem.
       *       A stem hint for the psili conflicts with the top edge hint
       *       for the base character.  The stem hint gets priority because
       *       of its sort order.  In glyph 884 (Greek Capital Alpha with
       *       Psili and Oxia), the top of the base character gets a stem
       *       hint, and the psili does not.  This creates different initial
       *       maps for the two glyphs resulting in different renderings of
       *       the base character.  Will probably defer this either as not
       *       worth the cost or as a font bug.  I don't think there is any
       *       good reason for an accent to be captured by an alignment
       *       zone.  -darnold 2/12/10
       */
  
      if ( initialMap )
      {
        /* Apply a heuristic that inserts a point for (0,0), unless it's     */
        /* already covered by a mapping.  This locks the baseline for glyphs */
        /* that have no baseline hints.                                      */
  
        if ( hintmap->count == 0                           ||
             hintmap->edge[0].csCoord > 0                  ||
             hintmap->edge[hintmap->count - 1].csCoord < 0 )
        {
          /* all edges are above 0 or all edges are below 0; */
          /* construct a locked edge hint at 0               */
  
          CF2_HintRec  edge, invalid;
  
  
          cf2_hint_initZero( &edge );
  
          edge.flags = CF2_GhostBottom |
                       CF2_Locked      |
                       CF2_Synthetic;
          edge.scale = hintmap->scale;
  
          cf2_hint_initZero( &invalid );
          cf2_hintmap_insertHint( hintmap, &edge, &invalid );
        }
      }
      else
      {
        /* insert remaining hints */
  
        maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask );
  
        for ( i = 0, maskByte = 0x80; i < bitCount; i++ )
        {
          if ( maskByte & *maskPtr )
          {
            CF2_HintRec  bottomHintEdge, topHintEdge;
  
  
            cf2_hint_init( &bottomHintEdge,
                           hStemHintArray,
                           i,
                           font,
                           hintOrigin,
                           hintmap->scale,
                           TRUE /* bottom */ );
            cf2_hint_init( &topHintEdge,
                           hStemHintArray,
                           i,
                           font,
                           hintOrigin,
                           hintmap->scale,
                           FALSE /* top */ );
  
            cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge );
          }
  
          if ( ( i & 7 ) == 7 )
          {
            /* move to next mask byte */
            maskPtr++;
            maskByte = 0x80;
          }
          else
            maskByte >>= 1;
        }
      }
  
      /*
       * Note: The following line is a convenient place to break when
       *       debugging hinting.  Examine `hintmap->edge' for the list of
       *       enabled hints, then step over the call to see the effect of
       *       adjustment.  We stop here first on the recursive call that
       *       creates the initial map, and then on each counter group and
       *       hint zone.
       */
  
      /* adjust positions of hint edges that are not locked to blue zones */
      cf2_hintmap_adjustHints( hintmap );
  
      /* save the position of all hints that were used in this hint map; */
      /* if we use them again, we'll locate them in the same position    */
      if ( !initialMap )
      {
        for ( i = 0; i < hintmap->count; i++ )
        {
          if ( !cf2_hint_isSynthetic( &hintmap->edge[i] ) )
          {
            /* Note: include both valid and invalid edges            */
            /* Note: top and bottom edges are copied back separately */
            CF2_StemHint  stemhint = (CF2_StemHint)
                            cf2_arrstack_getPointer( hStemHintArray,
                                                     hintmap->edge[i].index );
  
  
            if ( cf2_hint_isTop( &hintmap->edge[i] ) )
              stemhint->maxDS = hintmap->edge[i].dsCoord;
            else
              stemhint->minDS = hintmap->edge[i].dsCoord;
  
            stemhint->used = TRUE;
          }
        }
      }
  
      /* hint map is ready to use */
      hintmap->isValid = TRUE;
  
      /* remember this mask has been used */
      cf2_hintmask_setNew( hintMask, FALSE );
    }
  
  
    FT_LOCAL_DEF( void )
    cf2_glyphpath_init( CF2_GlyphPath         glyphpath,
                        CF2_Font              font,
                        CF2_OutlineCallbacks  callbacks,
                        CF2_Fixed             scaleY,
                        /* CF2_Fixed  hShift, */
                        CF2_ArrStack          hStemHintArray,
                        CF2_ArrStack          vStemHintArray,
                        CF2_HintMask          hintMask,
                        CF2_Fixed             hintOriginY,
                        const CF2_Blues       blues,
                        const FT_Vector*      fractionalTranslation )
    {
      FT_ZERO( glyphpath );
  
      glyphpath->font      = font;
      glyphpath->callbacks = callbacks;
  
      cf2_arrstack_init( &glyphpath->hintMoves,
                         font->memory,
                         &font->error,
                         sizeof ( CF2_HintMoveRec ) );
  
      cf2_hintmap_init( &glyphpath->initialHintMap,
                        font,
                        &glyphpath->initialHintMap,
                        &glyphpath->hintMoves,
                        scaleY );
      cf2_hintmap_init( &glyphpath->firstHintMap,
                        font,
                        &glyphpath->initialHintMap,
                        &glyphpath->hintMoves,
                        scaleY );
      cf2_hintmap_init( &glyphpath->hintMap,
                        font,
                        &glyphpath->initialHintMap,
                        &glyphpath->hintMoves,
                        scaleY );
  
      glyphpath->scaleX = font->innerTransform.a;
      glyphpath->scaleC = font->innerTransform.c;
      glyphpath->scaleY = font->innerTransform.d;
  
      glyphpath->fractionalTranslation = *fractionalTranslation;
  
  #if 0
      glyphpath->hShift = hShift;       /* for fauxing */
  #endif
  
      glyphpath->hStemHintArray = hStemHintArray;
      glyphpath->vStemHintArray = vStemHintArray;
      glyphpath->hintMask       = hintMask;      /* ptr to current mask */
      glyphpath->hintOriginY    = hintOriginY;
      glyphpath->blues          = blues;
      glyphpath->darken         = font->darkened; /* TODO: should we make copies? */
      glyphpath->xOffset        = font->darkenX;
      glyphpath->yOffset        = font->darkenY;
      glyphpath->miterLimit     = 2 * FT_MAX(
                                       cf2_fixedAbs( glyphpath->xOffset ),
                                       cf2_fixedAbs( glyphpath->yOffset ) );
  
      /* .1 character space unit */
      glyphpath->snapThreshold = cf2_floatToFixed( 0.1f );
  
      glyphpath->moveIsPending = TRUE;
      glyphpath->pathIsOpen    = FALSE;
      glyphpath->elemIsQueued  = FALSE;
    }
  
  
    FT_LOCAL_DEF( void )
    cf2_glyphpath_finalize( CF2_GlyphPath  glyphpath )
    {
      cf2_arrstack_finalize( &glyphpath->hintMoves );
    }
  
  
    /*
     * Hint point in y-direction and apply outerTransform.
     * Input `current' hint map (which is actually delayed by one element).
     * Input x,y point in Character Space.
     * Output x,y point in Device Space, including translation.
     */
    static void
    cf2_glyphpath_hintPoint( CF2_GlyphPath  glyphpath,
                             CF2_HintMap    hintmap,
                             FT_Vector*     ppt,
                             CF2_Fixed      x,
                             CF2_Fixed      y )
    {
      FT_Vector  pt;   /* hinted point in upright DS */
  
  
      pt.x = FT_MulFix( glyphpath->scaleX, x ) +
               FT_MulFix( glyphpath->scaleC, y );
      pt.y = cf2_hintmap_map( hintmap, y );
  
      ppt->x = FT_MulFix( glyphpath->font->outerTransform.a, pt.x )   +
                 FT_MulFix( glyphpath->font->outerTransform.c, pt.y ) +
                 glyphpath->fractionalTranslation.x;
      ppt->y = FT_MulFix( glyphpath->font->outerTransform.b, pt.x )   +
                 FT_MulFix( glyphpath->font->outerTransform.d, pt.y ) +
                 glyphpath->fractionalTranslation.y;
    }
  
  
    /*
     * From two line segments, (u1,u2) and (v1,v2), compute a point of
     * intersection on the corresponding lines.
     * Return false if no intersection is found, or if the intersection is
     * too far away from the ends of the line segments, u2 and v1.
     *
     */
    static FT_Bool
    cf2_glyphpath_computeIntersection( CF2_GlyphPath     glyphpath,
                                       const FT_Vector*  u1,
                                       const FT_Vector*  u2,
                                       const FT_Vector*  v1,
                                       const FT_Vector*  v2,
                                       FT_Vector*        intersection )
    {
      /*
       * Let `u' be a zero-based vector from the first segment, `v' from the
       * second segment.
       * Let `w 'be the zero-based vector from `u1' to `v1'.
       * `perp' is the `perpendicular dot product'; see
       * http://mathworld.wolfram.com/PerpDotProduct.html.
       * `s' is the parameter for the parametric line for the first segment
       * (`u').
       *
       * See notation in
       * http://softsurfer.com/Archive/algorithm_0104/algorithm_0104B.htm.
       * Calculations are done in 16.16, but must handle the squaring of
       * line lengths in character space.  We scale all vectors by 1/32 to
       * avoid overflow.  This allows values up to 4095 to be squared.  The
       * scale factor cancels in the divide.
       *
       * TODO: the scale factor could be computed from UnitsPerEm.
       *
       */
  
  #define cf2_perp( a, b )                                    \
            ( FT_MulFix( a.x, b.y ) - FT_MulFix( a.y, b.x ) )
  
    /* round and divide by 32 */
  #define CF2_CS_SCALE( x )         \
            ( ( (x) + 0x10 ) >> 5 )
  
      FT_Vector  u, v, w;      /* scaled vectors */
      CF2_Fixed  denominator, s;
  
  
      u.x = CF2_CS_SCALE( u2->x - u1->x );
      u.y = CF2_CS_SCALE( u2->y - u1->y );
      v.x = CF2_CS_SCALE( v2->x - v1->x );
      v.y = CF2_CS_SCALE( v2->y - v1->y );
      w.x = CF2_CS_SCALE( v1->x - u1->x );
      w.y = CF2_CS_SCALE( v1->y - u1->y );
  
      denominator = cf2_perp( u, v );
  
      if ( denominator == 0 )
        return FALSE;           /* parallel or coincident lines */
  
      s = FT_DivFix( cf2_perp( w, v ), denominator );
  
      intersection->x = u1->x + FT_MulFix( s, u2->x - u1->x );
      intersection->y = u1->y + FT_MulFix( s, u2->y - u1->y );
  
      /*
       * Special case snapping for horizontal and vertical lines.
       * This cleans up intersections and reduces problems with winding
       * order detection.
       * Sample case is sbc cd KozGoPr6N-Medium.otf 20 16685.
       * Note: these calculations are in character space.
       *
       */
  
      if ( u1->x == u2->x                                                     &&
           cf2_fixedAbs( intersection->x - u1->x ) < glyphpath->snapThreshold )
        intersection->x = u1->x;
      if ( u1->y == u2->y                                                     &&
           cf2_fixedAbs( intersection->y - u1->y ) < glyphpath->snapThreshold )
        intersection->y = u1->y;
  
      if ( v1->x == v2->x                                                     &&
           cf2_fixedAbs( intersection->x - v1->x ) < glyphpath->snapThreshold )
        intersection->x = v1->x;
      if ( v1->y == v2->y                                                     &&
           cf2_fixedAbs( intersection->y - v1->y ) < glyphpath->snapThreshold )
        intersection->y = v1->y;
  
      /* limit the intersection distance from midpoint of u2 and v1 */
      if ( cf2_fixedAbs( intersection->x - ( u2->x + v1->x ) / 2 ) >
             glyphpath->miterLimit                                   ||
           cf2_fixedAbs( intersection->y - ( u2->y + v1->y ) / 2 ) >
             glyphpath->miterLimit                                   )
        return FALSE;
  
      return TRUE;
    }
  
  
    /*
     * Push the cached element (glyphpath->prevElem*) to the outline
     * consumer.  When a darkening offset is used, the end point of the
     * cached element may be adjusted to an intersection point or it may be
     * connected by a line to the current element.  This calculation must
     * use a HintMap that was valid at the time the element was saved.  For
     * the first point in a subpath, that is a saved HintMap.  For most
     * elements, it just means the caller has delayed building a HintMap
     * from the current HintMask.
     *
     * Transform each point with outerTransform and call the outline
     * callbacks.  This is a general 3x3 transform:
     *
     *   x' = a*x + c*y + tx, y' = b*x + d*y + ty
     *
     * but it uses 4 elements from CF2_Font and the translation part
     * from CF2_GlyphPath.
     *
     */
    static void
    cf2_glyphpath_pushPrevElem( CF2_GlyphPath  glyphpath,
                                CF2_HintMap    hintmap,
                                FT_Vector*     nextP0,
                                FT_Vector      nextP1,
                                FT_Bool        close )
    {
      CF2_CallbackParamsRec  params;
  
      FT_Vector*  prevP0;
      FT_Vector*  prevP1;
  
      FT_Vector  intersection    = { 0, 0 };
      FT_Bool    useIntersection = FALSE;
  
  
      FT_ASSERT( glyphpath->prevElemOp == CF2_PathOpLineTo ||
                 glyphpath->prevElemOp == CF2_PathOpCubeTo );
  
      if ( glyphpath->prevElemOp == CF2_PathOpLineTo )
      {
        prevP0 = &glyphpath->prevElemP0;
        prevP1 = &glyphpath->prevElemP1;
      }
      else
      {
        prevP0 = &glyphpath->prevElemP2;
        prevP1 = &glyphpath->prevElemP3;
      }
  
      /* optimization: if previous and next elements are offset by the same */
      /* amount, then there will be no gap, and no need to compute an       */
      /* intersection.                                                      */
      if ( prevP1->x != nextP0->x || prevP1->y != nextP0->y )
      {
        /* previous element does not join next element:             */
        /* adjust end point of previous element to the intersection */
        useIntersection = cf2_glyphpath_computeIntersection( glyphpath,
                                                             prevP0,
                                                             prevP1,
                                                             nextP0,
                                                             &nextP1,
                                                             &intersection );
        if ( useIntersection )
        {
          /* modify the last point of the cached element (either line or */
          /* curve)                                                      */
          *prevP1 = intersection;
        }
      }
  
      params.pt0 = glyphpath->currentDS;
  
      switch( glyphpath->prevElemOp )
      {
      case CF2_PathOpLineTo:
        params.op = CF2_PathOpLineTo;
  
        /* note: pt2 and pt3 are unused */
        cf2_glyphpath_hintPoint( glyphpath,
                                 hintmap,
                                 &params.pt1,
                                 glyphpath->prevElemP1.x,
                                 glyphpath->prevElemP1.y );
  
        glyphpath->callbacks->lineTo( glyphpath->callbacks, &params );
  
        glyphpath->currentDS = params.pt1;
  
        break;
  
      case CF2_PathOpCubeTo:
        params.op = CF2_PathOpCubeTo;
  
        /* TODO: should we intersect the interior joins (p1-p2 and p2-p3)? */
        cf2_glyphpath_hintPoint( glyphpath,
                                 hintmap,
                                 &params.pt1,
                                 glyphpath->prevElemP1.x,
                                 glyphpath->prevElemP1.y );
        cf2_glyphpath_hintPoint( glyphpath,
                                 hintmap,
                                 &params.pt2,
                                 glyphpath->prevElemP2.x,
                                 glyphpath->prevElemP2.y );
        cf2_glyphpath_hintPoint( glyphpath,
                                 hintmap,
                                 &params.pt3,
                                 glyphpath->prevElemP3.x,
                                 glyphpath->prevElemP3.y );
  
        glyphpath->callbacks->cubeTo( glyphpath->callbacks, &params );
  
        glyphpath->currentDS = params.pt3;
  
        break;
      }
  
      if ( !useIntersection || close )
      {
        /* insert connecting line between end of previous element and start */
        /* of current one                                                   */
        /* note: at the end of a subpath, we might do both, so use `nextP0' */
        /* before we change it, below                                       */
  
        cf2_glyphpath_hintPoint( glyphpath,
                                 hintmap,
                                 &params.pt1,
                                 nextP0->x,
                                 nextP0->y );
  
        if ( params.pt1.x != glyphpath->currentDS.x ||
             params.pt1.y != glyphpath->currentDS.y )
        {
          /* length is nonzero */
          params.op  = CF2_PathOpLineTo;
          params.pt0 = glyphpath->currentDS;
  
          /* note: pt2 and pt3 are unused */
          glyphpath->callbacks->lineTo( glyphpath->callbacks, &params );
  
          glyphpath->currentDS = params.pt1;
        }
      }
  
      if ( useIntersection )
      {
        /* return intersection point to caller */
        *nextP0 = intersection;
      }
    }
  
  
    /* push a MoveTo element based on current point and offset of current */
    /* element                                                            */
    static void
    cf2_glyphpath_pushMove( CF2_GlyphPath  glyphpath,
                            FT_Vector      start )
    {
      CF2_CallbackParamsRec  params;
  
  
      params.op  = CF2_PathOpMoveTo;
      params.pt0 = glyphpath->currentDS;
  
      /* Test if move has really happened yet; it would have called */
      /* `cf2_hintmap_build' to set `isValid'.                   */
      if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) )
      {
        /* we are here iff first subpath is missing a moveto operator: */
        /* synthesize first moveTo to finish initialization of hintMap */
        cf2_glyphpath_moveTo( glyphpath,
                              glyphpath->start.x,
                              glyphpath->start.y );
      }
  
      cf2_glyphpath_hintPoint( glyphpath,
                               &glyphpath->hintMap,
                               &params.pt1,
                               start.x,
                               start.y );
  
      /* note: pt2 and pt3 are unused */
      glyphpath->callbacks->moveTo( glyphpath->callbacks, &params );
  
      glyphpath->currentDS    = params.pt1;
      glyphpath->offsetStart0 = start;
    }
  
  
    /*
     * All coordinates are in character space.
     * On input, (x1, y1) and (x2, y2) give line segment.
     * On output, (x, y) give offset vector.
     * We use a piecewise approximation to trig functions.
     *
     * TODO: Offset true perpendicular and proper length
     *       supply the y-translation for hinting here, too,
     *       that adds yOffset unconditionally to *y.
     */
    static void
    cf2_glyphpath_computeOffset( CF2_GlyphPath  glyphpath,
                                 CF2_Fixed      x1,
                                 CF2_Fixed      y1,
                                 CF2_Fixed      x2,
                                 CF2_Fixed      y2,
                                 CF2_Fixed*     x,
                                 CF2_Fixed*     y )
    {
      CF2_Fixed  dx = x2 - x1;
      CF2_Fixed  dy = y2 - y1;
  
  
      /* note: negative offsets don't work here; negate deltas to change */
      /* quadrants, below                                                */
      if ( glyphpath->font->reverseWinding )
      {
        dx = -dx;
        dy = -dy;
      }
  
      *x = *y = 0;
  
      if ( !glyphpath->darken )
          return;
  
      /* add momentum for this path element */
      glyphpath->callbacks->windingMomentum +=
        cf2_getWindingMomentum( x1, y1, x2, y2 );
  
      /* note: allow mixed integer and fixed multiplication here */
      if ( dx >= 0 )
      {
        if ( dy >= 0 )
        {
          /* first quadrant, +x +y */
  
          if ( dx > 2 * dy )
          {
            /* +x */
            *x = 0;
            *y = 0;
          }
          else if ( dy > 2 * dx )
          {
            /* +y */
            *x = glyphpath->xOffset;
            *y = glyphpath->yOffset;
          }
          else
          {
            /* +x +y */
            *x = FT_MulFix( cf2_floatToFixed( 0.7 ),
                            glyphpath->xOffset );
            *y = FT_MulFix( cf2_floatToFixed( 1.0 - 0.7 ),
                            glyphpath->yOffset );
          }
        }
        else
        {
          /* fourth quadrant, +x -y */
  
          if ( dx > -2 * dy )
          {
            /* +x */
            *x = 0;
            *y = 0;
          }
          else if ( -dy > 2 * dx )
          {
            /* -y */
            *x = -glyphpath->xOffset;
            *y = glyphpath->yOffset;
          }
          else
          {
            /* +x -y */
            *x = FT_MulFix( cf2_floatToFixed( -0.7 ),
                            glyphpath->xOffset );
            *y = FT_MulFix( cf2_floatToFixed( 1.0 - 0.7 ),
                            glyphpath->yOffset );
          }
        }
      }
      else
      {
        if ( dy >= 0 )
        {
          /* second quadrant, -x +y */
  
          if ( -dx > 2 * dy )
          {
            /* -x */
            *x = 0;
            *y = 2 * glyphpath->yOffset;
          }
          else if ( dy > -2 * dx )
          {
            /* +y */
            *x = glyphpath->xOffset;
            *y = glyphpath->yOffset;
          }
          else
          {
            /* -x +y */
            *x = FT_MulFix( cf2_floatToFixed( 0.7 ),
                            glyphpath->xOffset );
            *y = FT_MulFix( cf2_floatToFixed( 1.0 + 0.7 ),
                            glyphpath->yOffset );
          }
        }
        else
        {
          /* third quadrant, -x -y */
  
          if ( -dx > -2 * dy )
          {
            /* -x */
            *x = 0;
            *y = 2 * glyphpath->yOffset;
          }
          else if ( -dy > -2 * dx )
          {
            /* -y */
            *x = -glyphpath->xOffset;
            *y = glyphpath->xOffset;
          }
          else
          {
            /* -x -y */
            *x = FT_MulFix( cf2_floatToFixed( -0.7 ),
                            glyphpath->xOffset );
            *y = FT_MulFix( cf2_floatToFixed( 1.0 + 0.7 ),
                            glyphpath->yOffset );
          }
        }
      }
    }
  
  
    FT_LOCAL_DEF( void )
    cf2_glyphpath_moveTo( CF2_GlyphPath  glyphpath,
                          CF2_Fixed      x,
                          CF2_Fixed      y )
    {
      cf2_glyphpath_closeOpenPath( glyphpath );
  
      /* save the parameters of the move for later, when we'll know how to */
      /* offset it;                                                        */
      /* also save last move point */
      glyphpath->currentCS.x = glyphpath->start.x = x;
      glyphpath->currentCS.y = glyphpath->start.y = y;
  
      glyphpath->moveIsPending = TRUE;
  
      /* ensure we have a valid map with current mask */
      if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) ||
           cf2_hintmask_isNew( glyphpath->hintMask )   )
        cf2_hintmap_build( &glyphpath->hintMap,
                           glyphpath->hStemHintArray,
                           glyphpath->vStemHintArray,
                           glyphpath->hintMask,
                           glyphpath->hintOriginY,
                           FALSE );
  
      /* save a copy of current HintMap to use when drawing initial point */
      glyphpath->firstHintMap = glyphpath->hintMap;     /* structure copy */
    }
  
  
    FT_LOCAL_DEF( void )
    cf2_glyphpath_lineTo( CF2_GlyphPath  glyphpath,
                          CF2_Fixed      x,
                          CF2_Fixed      y )
    {
      CF2_Fixed  xOffset, yOffset;
      FT_Vector  P0, P1;
  
  
      /* can't compute offset of zero length line, so ignore them */
      if ( glyphpath->currentCS.x == x && glyphpath->currentCS.y == y )
        return;
  
      cf2_glyphpath_computeOffset( glyphpath,
                                   glyphpath->currentCS.x,
                                   glyphpath->currentCS.y,
                                   x,
                                   y,
                                   &xOffset,
                                   &yOffset );
  
      /* construct offset points */
      P0.x = glyphpath->currentCS.x + xOffset;
      P0.y = glyphpath->currentCS.y + yOffset;
      P1.x = x + xOffset;
      P1.y = y + yOffset;
  
      if ( glyphpath->moveIsPending )
      {
        /* emit offset 1st point as MoveTo */
        cf2_glyphpath_pushMove( glyphpath, P0 );
  
        glyphpath->moveIsPending = FALSE;  /* adjust state machine */
        glyphpath->pathIsOpen    = TRUE;
  
        glyphpath->offsetStart1 = P1;              /* record second point */
      }
  
      if ( glyphpath->elemIsQueued )
      {
        FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) );
  
        cf2_glyphpath_pushPrevElem( glyphpath,
                                    &glyphpath->hintMap,
                                    &P0,
                                    P1,
                                    FALSE );
      }
  
      /* queue the current element with offset points */
      glyphpath->elemIsQueued = TRUE;
      glyphpath->prevElemOp   = CF2_PathOpLineTo;
      glyphpath->prevElemP0   = P0;
      glyphpath->prevElemP1   = P1;
  
      /* update current map */
      if ( cf2_hintmask_isNew( glyphpath->hintMask ) )
        cf2_hintmap_build( &glyphpath->hintMap,
                           glyphpath->hStemHintArray,
                           glyphpath->vStemHintArray,
                           glyphpath->hintMask,
                           glyphpath->hintOriginY,
                           FALSE );
  
      glyphpath->currentCS.x = x;     /* pre-offset current point */
      glyphpath->currentCS.y = y;
    }
  
  
    FT_LOCAL_DEF( void )
    cf2_glyphpath_curveTo( CF2_GlyphPath  glyphpath,
                           CF2_Fixed      x1,
                           CF2_Fixed      y1,
                           CF2_Fixed      x2,
                           CF2_Fixed      y2,
                           CF2_Fixed      x3,
                           CF2_Fixed      y3 )
    {
      CF2_Fixed  xOffset1, yOffset1, xOffset3, yOffset3;
      FT_Vector  P0, P1, P2, P3;
  
  
      /* TODO: ignore zero length portions of curve?? */
      cf2_glyphpath_computeOffset( glyphpath,
                                   glyphpath->currentCS.x,
                                   glyphpath->currentCS.y,
                                   x1,
                                   y1,
                                   &xOffset1,
                                   &yOffset1 );
      cf2_glyphpath_computeOffset( glyphpath,
                                   x2,
                                   y2,
                                   x3,
                                   y3,
                                   &xOffset3,
                                   &yOffset3 );
  
      /* add momentum from the middle segment */
      glyphpath->callbacks->windingMomentum +=
        cf2_getWindingMomentum( x1, y1, x2, y2 );
  
      /* construct offset points */
      P0.x = glyphpath->currentCS.x + xOffset1;
      P0.y = glyphpath->currentCS.y + yOffset1;
      P1.x = x1 + xOffset1;
      P1.y = y1 + yOffset1;
      /* note: preserve angle of final segment by using offset3 at both ends */
      P2.x = x2 + xOffset3;
      P2.y = y2 + yOffset3;
      P3.x = x3 + xOffset3;
      P3.y = y3 + yOffset3;
  
      if ( glyphpath->moveIsPending )
      {
        /* emit offset 1st point as MoveTo */
        cf2_glyphpath_pushMove( glyphpath, P0 );
  
        glyphpath->moveIsPending = FALSE;
        glyphpath->pathIsOpen    = TRUE;
  
        glyphpath->offsetStart1 = P1;              /* record second point */
      }
  
      if ( glyphpath->elemIsQueued )
      {
        FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) );
  
        cf2_glyphpath_pushPrevElem( glyphpath,
                                    &glyphpath->hintMap,
                                    &P0,
                                    P1,
                                    FALSE );
      }
  
      /* queue the current element with offset points */
      glyphpath->elemIsQueued = TRUE;
      glyphpath->prevElemOp   = CF2_PathOpCubeTo;
      glyphpath->prevElemP0   = P0;
      glyphpath->prevElemP1   = P1;
      glyphpath->prevElemP2   = P2;
      glyphpath->prevElemP3   = P3;
  
      /* update current map */
      if ( cf2_hintmask_isNew( glyphpath->hintMask ) )
        cf2_hintmap_build( &glyphpath->hintMap,
                           glyphpath->hStemHintArray,
                           glyphpath->vStemHintArray,
                           glyphpath->hintMask,
                           glyphpath->hintOriginY,
                           FALSE );
  
      glyphpath->currentCS.x = x3;       /* pre-offset current point */
      glyphpath->currentCS.y = y3;
    }
  
  
    FT_LOCAL_DEF( void )
    cf2_glyphpath_closeOpenPath( CF2_GlyphPath  glyphpath )
    {
      if ( glyphpath->pathIsOpen )
      {
        FT_ASSERT( cf2_hintmap_isValid( &glyphpath->firstHintMap ) );
  
        /* since we need to apply an offset to the implicit lineto, we make */
        /* it explicit here                                                 */
        cf2_glyphpath_lineTo( glyphpath,
                              glyphpath->start.x,
                              glyphpath->start.y );
  
        /* Draw previous element (the explicit LineTo we just created,      */
        /* above) and connect it to the start point, but with the offset we */
        /* saved from the first element.                                    */
        /* Use the saved HintMap, too. */
        FT_ASSERT( glyphpath->elemIsQueued );
  
        cf2_glyphpath_pushPrevElem( glyphpath,
                                    &glyphpath->firstHintMap,
                                    &glyphpath->offsetStart0,
                                    glyphpath->offsetStart1,
                                    TRUE );
  
        /* reset state machine */
        glyphpath->moveIsPending = TRUE;
        glyphpath->pathIsOpen    = FALSE;
        glyphpath->elemIsQueued  = FALSE;
      }
    }
  
  
  /* END */
  

Download