pshints.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	CF2_HintMaskRec_
struct	CF2_StemHintRec_
struct	CF2_HintMapRec_
struct	CF2_GlyphPathRec_

Typedefs
typedef struct CF2_HintMaskRec_	CF2_HintMaskRec
typedef struct CF2_HintMaskRec_ *	CF2_HintMask
typedef struct CF2_StemHintRec_	CF2_StemHintRec
typedef struct CF2_StemHintRec_ *	CF2_StemHint
typedef struct CF2_HintMapRec_	CF2_HintMapRec
typedef struct CF2_HintMapRec_ *	CF2_HintMap
typedef struct CF2_GlyphPathRec_	CF2_GlyphPathRec
typedef struct CF2_GlyphPathRec_ *	CF2_GlyphPath

Enumerations
enum	{ CF2_MAX_HINTS = 96 }
enum	{ CF2_MAX_HINT_EDGES = CF2_MAX_HINTS * 2 }

Functions
	cf2_hint_isValid (const CF2_Hint hint)
	cf2_hint_isTop (const CF2_Hint hint)
	cf2_hint_isBottom (const CF2_Hint hint)
	cf2_hint_lock (CF2_Hint hint)
	cf2_hintmap_init (CF2_HintMap hintmap, CF2_Font font, CF2_HintMap initialMap, CF2_ArrStack hintMoves, CF2_Fixed scale)
	cf2_hintmap_build (CF2_HintMap hintmap, CF2_ArrStack hStemHintArray, CF2_ArrStack vStemHintArray, CF2_HintMask hintMask, CF2_Fixed hintOrigin, FT_Bool initialMap)
	cf2_glyphpath_init (CF2_GlyphPath glyphpath, CF2_Font font, CF2_OutlineCallbacks callbacks, CF2_Fixed scaleY, CF2_ArrStack hStemHintArray, CF2_ArrStack vStemHintArray, CF2_HintMask hintMask, CF2_Fixed hintOrigin, const CF2_Blues blues, const FT_Vector *fractionalTranslation)
	cf2_glyphpath_finalize (CF2_GlyphPath glyphpath)
	cf2_glyphpath_moveTo (CF2_GlyphPath glyphpath, CF2_Fixed x, CF2_Fixed y)
	cf2_glyphpath_lineTo (CF2_GlyphPath glyphpath, CF2_Fixed x, CF2_Fixed y)
	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_glyphpath_closeOpenPath (CF2_GlyphPath glyphpath)

Typedef Documentation

CF2_GlyphPath

typedef struct CF2_GlyphPathRec_ * CF2_GlyphPath

CF2_GlyphPathRec

typedef struct CF2_GlyphPathRec_ CF2_GlyphPathRec

CF2_HintMap

typedef struct CF2_HintMapRec_ * CF2_HintMap

CF2_HintMapRec

typedef struct CF2_HintMapRec_ CF2_HintMapRec

CF2_HintMask

typedef struct CF2_HintMaskRec_ * CF2_HintMask

CF2_HintMaskRec

typedef struct CF2_HintMaskRec_ CF2_HintMaskRec

CF2_StemHint

typedef struct CF2_StemHintRec_ * CF2_StemHint

CF2_StemHintRec

typedef struct CF2_StemHintRec_ CF2_StemHintRec

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
CF2_MAX_HINTS

Definition at line 45 of file pshints.h.

  {
    CF2_MAX_HINTS = 96    /* maximum # of hints */
  };

anonymous enum

anonymous enum

Enumerator
CF2_MAX_HINT_EDGES

Definition at line 120 of file pshints.h.

  {
    CF2_MAX_HINT_EDGES = CF2_MAX_HINTS * 2
  };

Function Documentation

cf2_glyphpath_closeOpenPath()

cf2_glyphpath_closeOpenPath

(

CF2_GlyphPath

glyphpath

)

Definition at line 1904 of file pshints.c.

  {
    if ( glyphpath->pathIsOpen )
    {
      /*
       * A closing line in Character Space line is always generated below
       * with `cf2_glyphPath_lineTo'.  It may be ignored later if it turns
       * out to be zero length in Device Space.
       */
      glyphpath->pathIsClosing = TRUE;
 
      cf2_glyphpath_lineTo( glyphpath,
                            glyphpath->start.x,
                            glyphpath->start.y );
 
      /* empty the final element from the queue and close the path */
      if ( glyphpath->elemIsQueued )
        cf2_glyphpath_pushPrevElem( glyphpath,
                                    &glyphpath->hintMap,
                                    &glyphpath->offsetStart0,
                                    glyphpath->offsetStart1,
                                    TRUE );
 
      /* reset state machine */
      glyphpath->moveIsPending = TRUE;
      glyphpath->pathIsOpen    = FALSE;
      glyphpath->pathIsClosing = FALSE;
      glyphpath->elemIsQueued  = FALSE;
    }
  }

Referenced by cf2_glyphpath_moveTo(), and cf2_interpT2CharString().

cf2_glyphpath_curveTo()

cf2_glyphpath_curveTo	(	CF2_GlyphPath	glyphpath,
		CF2_Fixed	x1,
		CF2_Fixed	y1,
		CF2_Fixed	x2,
		CF2_Fixed	y2,
		CF2_Fixed	x3,
		CF2_Fixed	y3
	)

Definition at line 1814 of file pshints.c.

  {
    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 =
      ADD_INT32( glyphpath->callbacks->windingMomentum,
                 cf2_getWindingMomentum( x1, y1, x2, y2 ) );
 
    /* construct offset points */
    P0.x = ADD_INT32( glyphpath->currentCS.x, xOffset1 );
    P0.y = ADD_INT32( glyphpath->currentCS.y, yOffset1 );
    P1.x = ADD_INT32( x1, xOffset1 );
    P1.y = ADD_INT32( y1, yOffset1 );
    /* note: preserve angle of final segment by using offset3 at both ends */
    P2.x = ADD_INT32( x2, xOffset3 );
    P2.y = ADD_INT32( y2, yOffset3 );
    P3.x = ADD_INT32( x3, xOffset3 );
    P3.y = ADD_INT32( 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 ) ||
                 glyphpath->hintMap.count == 0              );
 
      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;
  }

Referenced by cf2_doFlex(), and cf2_interpT2CharString().

cf2_glyphpath_finalize()

cf2_glyphpath_finalize

(

CF2_GlyphPath

glyphpath

)

Definition at line 1151 of file pshints.c.

  {
    cf2_arrstack_finalize( &glyphpath->hintMoves );
  }

Referenced by cf2_interpT2CharString().

cf2_glyphpath_init()

cf2_glyphpath_init	(	CF2_GlyphPath	glyphpath,
		CF2_Font	font,
		CF2_OutlineCallbacks	callbacks,
		CF2_Fixed	scaleY,
		CF2_ArrStack	hStemHintArray,
		CF2_ArrStack	vStemHintArray,
		CF2_HintMask	hintMask,
		CF2_Fixed	hintOrigin,
		const CF2_Blues	blues,
		const FT_Vector *	fractionalTranslation
	)

Definition at line 1080 of file pshints.c.

  {
    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_doubleToFixed( 0.1 );
 
    glyphpath->moveIsPending = TRUE;
    glyphpath->pathIsOpen    = FALSE;
    glyphpath->pathIsClosing = FALSE;
    glyphpath->elemIsQueued  = FALSE;
  }

Referenced by cf2_interpT2CharString().

cf2_glyphpath_lineTo()

cf2_glyphpath_lineTo	(	CF2_GlyphPath	glyphpath,
		CF2_Fixed	x,
		CF2_Fixed	y
	)

Definition at line 1708 of file pshints.c.

  {
    CF2_Fixed  xOffset, yOffset;
    FT_Vector  P0, P1;
    FT_Bool    newHintMap;
 
    /*
     * New hints will be applied after cf2_glyphpath_pushPrevElem has run.
     * In case this is a synthesized closing line, any new hints should be
     * delayed until this path is closed (`cf2_hintmask_isNew' will be
     * called again before the next line or curve).
     */
 
    /* true if new hint map not on close */
    newHintMap = cf2_hintmask_isNew( glyphpath->hintMask ) &&
                 !glyphpath->pathIsClosing;
 
    /*
     * Zero-length lines may occur in the charstring.  Because we cannot
     * compute darkening offsets or intersections from zero-length lines,
     * it is best to remove them and avoid artifacts.  However, zero-length
     * lines in CS at the start of a new hint map can generate non-zero
     * lines in DS due to hint substitution.  We detect a change in hint
     * map here and pass those zero-length lines along.
     */
 
    /*
     * Note: Find explicitly closed paths here with a conditional
     *       breakpoint using
     *
     *         !gp->pathIsClosing && gp->start.x == x && gp->start.y == y
     *
     */
 
    if ( glyphpath->currentCS.x == x &&
         glyphpath->currentCS.y == y &&
         !newHintMap                 )
      /*
       * Ignore zero-length lines in CS where the hint map is the same
       * because the line in DS will also be zero length.
       *
       * Ignore zero-length lines when we synthesize a closing line because
       * the close will be handled in cf2_glyphPath_pushPrevElem.
       */
      return;
 
    cf2_glyphpath_computeOffset( glyphpath,
                                 glyphpath->currentCS.x,
                                 glyphpath->currentCS.y,
                                 x,
                                 y,
                                 &xOffset,
                                 &yOffset );
 
    /* construct offset points */
    P0.x = ADD_INT32( glyphpath->currentCS.x, xOffset );
    P0.y = ADD_INT32( glyphpath->currentCS.y, yOffset );
    P1.x = ADD_INT32( x, xOffset );
    P1.y = ADD_INT32( 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 ) ||
                 glyphpath->hintMap.count == 0              );
 
      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 ( newHintMap )
      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;
  }

Referenced by cf2_glyphpath_closeOpenPath(), and cf2_interpT2CharString().

cf2_glyphpath_moveTo()

cf2_glyphpath_moveTo	(	CF2_GlyphPath	glyphpath,
		CF2_Fixed	x,
		CF2_Fixed	y
	)

Definition at line 1678 of file pshints.c.

  {
    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 */
  }

Referenced by cf2_glyphpath_pushMove(), and cf2_interpT2CharString().

cf2_hint_isBottom()

cf2_hint_isBottom

(

const CF2_Hint

hint

)

Definition at line 246 of file pshints.c.

  {
    return FT_BOOL( hint->flags & ( CF2_PairBottom | CF2_GhostBottom ) );
  }

Referenced by cf2_blues_capture().

cf2_hint_isTop()

cf2_hint_isTop

(

const CF2_Hint

hint

)

Definition at line 239 of file pshints.c.

  {
    return FT_BOOL( hint->flags & ( CF2_PairTop | CF2_GhostTop ) );
  }

Referenced by cf2_blues_capture(), cf2_hint_init(), cf2_hintmap_build(), and cf2_hintmap_dump().

cf2_hint_isValid()

cf2_hint_isValid

(

const CF2_Hint

hint

)

Definition at line 218 of file pshints.c.

  {
    return FT_BOOL( hint->flags );
  }

Referenced by cf2_blues_capture(), cf2_hintmap_adjustHints(), and cf2_hintmap_insertHint().

cf2_hint_lock()

cf2_hint_lock

(

CF2_Hint

hint

)

Definition at line 267 of file pshints.c.

  {
    hint->flags |= CF2_Locked;
  }

Referenced by cf2_blues_capture(), and cf2_hint_init().

cf2_hintmap_build()

cf2_hintmap_build	(	CF2_HintMap	hintmap,
		CF2_ArrStack	hStemHintArray,
		CF2_ArrStack	vStemHintArray,
		CF2_HintMask	hintMask,
		CF2_Fixed	hintOrigin,
		FT_Bool	initialMap
	)

Definition at line 805 of file pshints.c.

  {
    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 ) );
      if ( !cf2_hintmask_isValid( hintMask ) )
      {
        if ( font->isT1 )
        {
          /* no error, just continue unhinted */
          *hintMask->error = FT_Err_Ok;
          hintmap->hinted  = FALSE;
        }
        return;                   /* too many stem hints */
      }
    }
 
    /* 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 */
    bitCount = cf2_arrstack_size( hStemHintArray );
 
    /* Defense-in-depth.  Should never return here. */
    if ( bitCount > hintMask->bitCount )
      return;
 
    /* 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;
      }
    }
 
    FT_TRACE6(( "%s\n", initialMap ? "flags: [p]air [g]host [t]op"
                                     " [b]ottom [L]ocked [S]ynthetic\n"
                                     "Initial hintmap"
                                   : "Hints:" ));
    cf2_hintmap_dump( hintmap );
 
    /*
     * 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 );
 
    FT_TRACE6(( "(adjusted)\n" ));
    cf2_hintmap_dump( 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 );
  }

Referenced by cf2_glyphpath_curveTo(), cf2_glyphpath_lineTo(), cf2_glyphpath_moveTo(), cf2_hintmap_build(), and cf2_interpT2CharString().

cf2_hintmap_init()

cf2_hintmap_init	(	CF2_HintMap	hintmap,
		CF2_Font	font,
		CF2_HintMap	initialMap,
		CF2_ArrStack	hintMoves,
		CF2_Fixed	scale
	)

Definition at line 274 of file pshints.c.

  {
    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;
  }

Referenced by cf2_glyphpath_init(), and cf2_interpT2CharString().