pshints.c File Reference

#include "psft.h"
#include "psglue.h"
#include "psfont.h"
#include "pshints.h"
#include "psintrp.h"

Include dependency graph for pshints.c:

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

Go to the source code of this file.

Classes
struct	CF2_HintMoveRec_

Macros
#define	FT_COMPONENT   trace_cf2hints
#define	cf2_perp(a, b)    ( FT_MulFix( a.x, b.y ) - FT_MulFix( a.y, b.x ) )
#define	CF2_CS_SCALE(x)    ( ( (x) + 0x10 ) >> 5 )

Typedefs
typedef struct CF2_HintMoveRec_	CF2_HintMoveRec
typedef struct CF2_HintMoveRec_ *	CF2_HintMove

Functions
static CF2_Int	cf2_getWindingMomentum (CF2_Fixed x1, CF2_Fixed y1, CF2_Fixed x2, CF2_Fixed y2)
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)
static void	cf2_hint_initZero (CF2_Hint hint)
	cf2_hint_isValid (const CF2_Hint hint)
static FT_Bool	cf2_hint_isPair (const CF2_Hint hint)
static FT_Bool	cf2_hint_isPairTop (const CF2_Hint hint)
	cf2_hint_isTop (const CF2_Hint hint)
	cf2_hint_isBottom (const CF2_Hint hint)
static FT_Bool	cf2_hint_isLocked (const CF2_Hint hint)
static FT_Bool	cf2_hint_isSynthetic (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)
static FT_Bool	cf2_hintmap_isValid (const CF2_HintMap hintmap)
static void	cf2_hintmap_dump (CF2_HintMap hintmap)
static CF2_Fixed	cf2_hintmap_map (CF2_HintMap hintmap, CF2_Fixed csCoord)
static void	cf2_hintmap_adjustHints (CF2_HintMap hintmap)
static void	cf2_hintmap_insertHint (CF2_HintMap hintmap, CF2_Hint bottomHintEdge, CF2_Hint topHintEdge)
	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 hintOriginY, const CF2_Blues blues, const FT_Vector *fractionalTranslation)
	cf2_glyphpath_finalize (CF2_GlyphPath glyphpath)
static void	cf2_glyphpath_hintPoint (CF2_GlyphPath glyphpath, CF2_HintMap hintmap, FT_Vector *ppt, CF2_Fixed x, CF2_Fixed y)
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)
static void	cf2_glyphpath_pushPrevElem (CF2_GlyphPath glyphpath, CF2_HintMap hintmap, FT_Vector *nextP0, FT_Vector nextP1, FT_Bool close)
static void	cf2_glyphpath_pushMove (CF2_GlyphPath glyphpath, FT_Vector start)
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_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)

Macro Definition Documentation

CF2_CS_SCALE

#define CF2_CS_SCALE

(

x

)

( ( (x) + 0x10 ) >> 5 )

cf2_perp

#define cf2_perp	(		a,
			b
	)		( FT_MulFix( a.x, b.y ) - FT_MulFix( a.y, b.x ) )

FT_COMPONENT

#define FT_COMPONENT   trace_cf2hints

Definition at line 55 of file pshints.c.

Typedef Documentation

CF2_HintMove

typedef struct CF2_HintMoveRec_ * CF2_HintMove

CF2_HintMoveRec

typedef struct CF2_HintMoveRec_ CF2_HintMoveRec

Function Documentation

cf2_getWindingMomentum()

static CF2_Int cf2_getWindingMomentum ( CF2_Fixed  x1, CF2_Fixed  y1, CF2_Fixed  x2, CF2_Fixed  y2  )

static

Definition at line 69 of file pshints.c.

  {
    /* 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 ) * ( SUB_INT32( y2, y1 ) >> 16 ) -
           ( y1 >> 16 ) * ( SUB_INT32( x2, x1 ) >> 16 );
  }

Referenced by cf2_glyphpath_computeOffset(), and cf2_glyphpath_curveTo().

cf2_glyphpath_closeOpenPath()

cf2_glyphpath_closeOpenPath

(

CF2_GlyphPath

glyphpath

)

Definition at line 1907 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_computeIntersection()

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  )

static

Definition at line 1201 of file pshints.c.

  {
    /*
     * 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
     * https://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( SUB_INT32( u2->x, u1->x ) );
    u.y = CF2_CS_SCALE( SUB_INT32( u2->y, u1->y ) );
    v.x = CF2_CS_SCALE( SUB_INT32( v2->x, v1->x ) );
    v.y = CF2_CS_SCALE( SUB_INT32( v2->y, v1->y ) );
    w.x = CF2_CS_SCALE( SUB_INT32( v1->x, u1->x ) );
    w.y = CF2_CS_SCALE( SUB_INT32( 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 = ADD_INT32( u1->x,
                                 FT_MulFix( s, SUB_INT32( u2->x, u1->x ) ) );
    intersection->y = ADD_INT32( u1->y,
                                 FT_MulFix( s, SUB_INT32( 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( SUB_INT32( intersection->x,
                                  u1->x ) ) < glyphpath->snapThreshold )
      intersection->x = u1->x;
    if ( u1->y == u2->y                                                &&
         cf2_fixedAbs( SUB_INT32( intersection->y,
                                  u1->y ) ) < glyphpath->snapThreshold )
      intersection->y = u1->y;
 
    if ( v1->x == v2->x                                                &&
         cf2_fixedAbs( SUB_INT32( intersection->x,
                                  v1->x ) ) < glyphpath->snapThreshold )
      intersection->x = v1->x;
    if ( v1->y == v2->y                                                &&
         cf2_fixedAbs( SUB_INT32( 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 - ADD_INT32( u2->x, v1->x ) / 2 ) >
           glyphpath->miterLimit                                           ||
         cf2_fixedAbs( intersection->y - ADD_INT32( u2->y, v1->y ) / 2 ) >
           glyphpath->miterLimit                                           )
      return FALSE;
 
    return TRUE;
  }

Referenced by cf2_glyphpath_pushPrevElem().

cf2_glyphpath_computeOffset()

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  )

static

Definition at line 1530 of file pshints.c.

  {
    CF2_Fixed  dx = SUB_INT32( x2, x1 );
    CF2_Fixed  dy = SUB_INT32( y2, y1 );
 
 
    /* note: negative offsets don't work here; negate deltas to change */
    /* quadrants, below                                                */
    if ( glyphpath->font->reverseWinding )
    {
      dx = NEG_INT32( dx );
      dy = NEG_INT32( dy );
    }
 
    *x = *y = 0;
 
    if ( !glyphpath->darken )
        return;
 
    /* add momentum for this path element */
    glyphpath->callbacks->windingMomentum =
      ADD_INT32( 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 > MUL_INT32( 2, dy ) )
        {
          /* +x */
          *x = 0;
          *y = 0;
        }
        else if ( dy > MUL_INT32( 2, dx ) )
        {
          /* +y */
          *x = glyphpath->xOffset;
          *y = glyphpath->yOffset;
        }
        else
        {
          /* +x +y */
          *x = FT_MulFix( cf2_doubleToFixed( 0.7 ),
                          glyphpath->xOffset );
          *y = FT_MulFix( cf2_doubleToFixed( 1.0 - 0.7 ),
                          glyphpath->yOffset );
        }
      }
      else
      {
        /* fourth quadrant, +x -y */
 
        if ( dx > MUL_INT32( -2, dy ) )
        {
          /* +x */
          *x = 0;
          *y = 0;
        }
        else if ( NEG_INT32( dy ) > MUL_INT32( 2, dx ) )
        {
          /* -y */
          *x = NEG_INT32( glyphpath->xOffset );
          *y = glyphpath->yOffset;
        }
        else
        {
          /* +x -y */
          *x = FT_MulFix( cf2_doubleToFixed( -0.7 ),
                          glyphpath->xOffset );
          *y = FT_MulFix( cf2_doubleToFixed( 1.0 - 0.7 ),
                          glyphpath->yOffset );
        }
      }
    }
    else
    {
      if ( dy >= 0 )
      {
        /* second quadrant, -x +y */
 
        if ( NEG_INT32( dx ) > MUL_INT32( 2, dy ) )
        {
          /* -x */
          *x = 0;
          *y = MUL_INT32( 2, glyphpath->yOffset );
        }
        else if ( dy > MUL_INT32( -2, dx ) )
        {
          /* +y */
          *x = glyphpath->xOffset;
          *y = glyphpath->yOffset;
        }
        else
        {
          /* -x +y */
          *x = FT_MulFix( cf2_doubleToFixed( 0.7 ),
                          glyphpath->xOffset );
          *y = FT_MulFix( cf2_doubleToFixed( 1.0 + 0.7 ),
                          glyphpath->yOffset );
        }
      }
      else
      {
        /* third quadrant, -x -y */
 
        if ( NEG_INT32( dx ) > MUL_INT32( -2, dy ) )
        {
          /* -x */
          *x = 0;
          *y = MUL_INT32( 2, glyphpath->yOffset );
        }
        else if ( NEG_INT32( dy ) > MUL_INT32( -2, dx ) )
        {
          /* -y */
          *x = NEG_INT32( glyphpath->xOffset );
          *y = glyphpath->yOffset;
        }
        else
        {
          /* -x -y */
          *x = FT_MulFix( cf2_doubleToFixed( -0.7 ),
                          glyphpath->xOffset );
          *y = FT_MulFix( cf2_doubleToFixed( 1.0 + 0.7 ),
                          glyphpath->yOffset );
        }
      }
    }
  }

Referenced by cf2_glyphpath_curveTo(), and cf2_glyphpath_lineTo().

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 1817 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 1154 of file pshints.c.

  {
    cf2_arrstack_finalize( &glyphpath->hintMoves );
  }

Referenced by cf2_interpT2CharString().

cf2_glyphpath_hintPoint()

static void cf2_glyphpath_hintPoint ( CF2_GlyphPath  glyphpath, CF2_HintMap  hintmap, FT_Vector *  ppt, CF2_Fixed  x, CF2_Fixed  y  )

static

Definition at line 1167 of file pshints.c.

  {
    FT_Vector  pt;   /* hinted point in upright DS */
 
 
    pt.x = ADD_INT32( FT_MulFix( glyphpath->scaleX, x ),
                      FT_MulFix( glyphpath->scaleC, y ) );
    pt.y = cf2_hintmap_map( hintmap, y );
 
    ppt->x = ADD_INT32(
               FT_MulFix( glyphpath->font->outerTransform.a, pt.x ),
               ADD_INT32(
                 FT_MulFix( glyphpath->font->outerTransform.c, pt.y ),
                 glyphpath->fractionalTranslation.x ) );
    ppt->y = ADD_INT32(
               FT_MulFix( glyphpath->font->outerTransform.b, pt.x ),
               ADD_INT32(
                 FT_MulFix( glyphpath->font->outerTransform.d, pt.y ),
                 glyphpath->fractionalTranslation.y ) );
  }

Referenced by cf2_glyphpath_pushMove(), and cf2_glyphpath_pushPrevElem().

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	hintOriginY,
		const CF2_Blues	blues,
		const FT_Vector *	fractionalTranslation
	)

Definition at line 1083 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 1711 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 1681 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_glyphpath_pushMove()

static void cf2_glyphpath_pushMove ( CF2_GlyphPath  glyphpath, FT_Vector  start  )

static

Definition at line 1485 of file pshints.c.

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

Referenced by cf2_glyphpath_curveTo(), and cf2_glyphpath_lineTo().

cf2_glyphpath_pushPrevElem()

static void cf2_glyphpath_pushPrevElem ( CF2_GlyphPath  glyphpath, CF2_HintMap  hintmap, FT_Vector *  nextP0, FT_Vector  nextP1, FT_Bool  close  )

static

Definition at line 1321 of file pshints.c.

  {
    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 */
 
      if ( close )
      {
        /* use first hint map if closing */
        cf2_glyphpath_hintPoint( glyphpath,
                                 &glyphpath->firstHintMap,
                                 &params.pt1,
                                 glyphpath->prevElemP1.x,
                                 glyphpath->prevElemP1.y );
      }
      else
      {
        cf2_glyphpath_hintPoint( glyphpath,
                                 hintmap,
                                 &params.pt1,
                                 glyphpath->prevElemP1.x,
                                 glyphpath->prevElemP1.y );
      }
 
      /* output only non-zero length lines */
      if ( params.pt0.x != params.pt1.x || params.pt0.y != params.pt1.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                                       */
 
      if ( close )
      {
        /* if we are closing the subpath, then nextP0 is in the first     */
        /* hint zone                                                      */
        cf2_glyphpath_hintPoint( glyphpath,
                                 &glyphpath->firstHintMap,
                                 &params.pt1,
                                 nextP0->x,
                                 nextP0->y );
      }
      else
      {
        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;
    }
  }

Referenced by cf2_glyphpath_closeOpenPath(), cf2_glyphpath_curveTo(), and cf2_glyphpath_lineTo().

cf2_hint_init()

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  )

static

Definition at line 90 of file pshints.c.

  {
    CF2_Fixed               width;
    const CF2_StemHintRec*  stemHint;
 
 
    FT_ZERO( hint );
 
    stemHint = (const CF2_StemHintRec*)cf2_arrstack_getPointer(
                                         stemHintArray,
                                         indexStemHint );
 
    width = SUB_INT32( 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 = ADD_INT32( hint->csCoord, 2 * font->darkenY );
 
    hint->csCoord = ADD_INT32( 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 );
  }

Referenced by cf2_hintmap_build().

cf2_hint_initZero()

static void cf2_hint_initZero ( CF2_Hint  hint )

static

Definition at line 211 of file pshints.c.

  {
    FT_ZERO( hint );
  }

Referenced by cf2_hintmap_build().

cf2_hint_isBottom()

cf2_hint_isBottom

(

const CF2_Hint

hint

)

Definition at line 248 of file pshints.c.

  {
    return (FT_Bool)( ( hint->flags                          &
                        ( CF2_PairBottom | CF2_GhostBottom ) ) != 0 );
  }

Referenced by cf2_blues_capture().

cf2_hint_isLocked()

static FT_Bool cf2_hint_isLocked ( const CF2_Hint  hint )

static

Definition at line 256 of file pshints.c.

  {
    return (FT_Bool)( ( hint->flags & CF2_Locked ) != 0 );
  }

Referenced by cf2_hintmap_adjustHints(), cf2_hintmap_build(), cf2_hintmap_dump(), and cf2_hintmap_insertHint().

cf2_hint_isPair()

static FT_Bool cf2_hint_isPair ( const CF2_Hint  hint )

static

Definition at line 225 of file pshints.c.

  {
    return (FT_Bool)( ( hint->flags                      &
                        ( CF2_PairBottom | CF2_PairTop ) ) != 0 );
  }

Referenced by cf2_hintmap_adjustHints(), and cf2_hintmap_dump().

cf2_hint_isPairTop()

static FT_Bool cf2_hint_isPairTop ( const CF2_Hint  hint )

static

Definition at line 233 of file pshints.c.

  {
    return (FT_Bool)( ( hint->flags & CF2_PairTop ) != 0 );
  }

Referenced by cf2_hintmap_insertHint().

cf2_hint_isSynthetic()

static FT_Bool cf2_hint_isSynthetic ( const CF2_Hint  hint )

static

Definition at line 263 of file pshints.c.

  {
    return (FT_Bool)( ( hint->flags & CF2_Synthetic ) != 0 );
  }

Referenced by cf2_hintmap_adjustHints(), cf2_hintmap_build(), and cf2_hintmap_dump().

cf2_hint_isTop()

cf2_hint_isTop

(

const CF2_Hint

hint

)

Definition at line 240 of file pshints.c.

  {
    return (FT_Bool)( ( hint->flags                    &
                        ( CF2_PairTop | CF2_GhostTop ) ) != 0 );
  }

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 != 0 );
  }

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

cf2_hint_lock()

cf2_hint_lock

(

CF2_Hint

hint

)

Definition at line 270 of file pshints.c.

  {
    hint->flags |= CF2_Locked;
  }

Referenced by cf2_blues_capture(), and cf2_hint_init().

cf2_hintmap_adjustHints()

static void cf2_hintmap_adjustHints ( CF2_HintMap  hintmap )

static

Definition at line 399 of file pshints.c.

  {
    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 >=
               ADD_INT32( 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 <=
                 ADD_INT32( 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 <=
                 ADD_INT32( hintmap->edge[i].dsCoord,
                            moveDown - downMinCounter ) )
          {
            move     = moveDown;
            /* true if non-optimum move */
            saveEdge = (FT_Bool)( moveUp < -moveDown );
          }
          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 = ADD_INT32( hintmap->edge[i].dsCoord,
                                              move );
        if ( isPair )
          hintmap->edge[j].dsCoord = ADD_INT32( 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( SUB_INT32( hintmap->edge[i].dsCoord,
                                  hintmap->edge[i - 1].dsCoord ),
                       SUB_INT32( 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( SUB_INT32( hintmap->edge[j].dsCoord,
                                  hintmap->edge[j - 1].dsCoord ),
                       SUB_INT32( 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 >=
             ADD_INT32( hintmap->edge[j].dsCoord,
                        hintMove->moveUp + CF2_MIN_COUNTER ) )
      {
        /* there is more room now, move edge up */
        hintmap->edge[j].dsCoord = ADD_INT32( hintmap->edge[j].dsCoord,
                                              hintMove->moveUp );
 
        if ( cf2_hint_isPair( &hintmap->edge[j] ) )
        {
          FT_ASSERT( j > 0 );
          hintmap->edge[j - 1].dsCoord =
            ADD_INT32( hintmap->edge[j - 1].dsCoord, hintMove->moveUp );
        }
      }
    }
  }

Referenced by cf2_hintmap_build().

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 808 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(( initialMap ? "flags: [p]air [g]host [t]op "
                             "[b]ottom [L]ocked [S]ynthetic\n"
                             "Initial hintmap\n"
                           : "Hints:\n" ));
    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_dump()

static void cf2_hintmap_dump ( CF2_HintMap  hintmap )

static

Definition at line 303 of file pshints.c.

  {
#ifdef FT_DEBUG_LEVEL_TRACE
    CF2_UInt  i;
 
 
    FT_TRACE6(( "  index  csCoord  dsCoord  scale  flags\n" ));
 
    for ( i = 0; i < hintmap->count; i++ )
    {
      CF2_Hint  hint = &hintmap->edge[i];
 
 
      FT_TRACE6(( "  %3d    %7.2f  %7.2f  %5d  %s%s%s%s\n",
                  hint->index,
                  hint->csCoord / 65536.0,
                  hint->dsCoord / ( hint->scale * 1.0 ),
                  hint->scale,
                  ( cf2_hint_isPair( hint ) ? "p" : "g" ),
                  ( cf2_hint_isTop( hint ) ? "t" : "b" ),
                  ( cf2_hint_isLocked( hint ) ? "L" : ""),
                  ( cf2_hint_isSynthetic( hint ) ? "S" : "" ) ));
    }
#else
    FT_UNUSED( hintmap );
#endif
  }

Referenced by cf2_hintmap_build().

cf2_hintmap_init()

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

Definition at line 277 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().

cf2_hintmap_insertHint()

static void cf2_hintmap_insertHint ( CF2_HintMap  hintmap, CF2_Hint  bottomHintEdge, CF2_Hint  topHintEdge  )

static

Definition at line 602 of file pshints.c.

  {
    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 */
    if ( isPair                                         &&
         topHintEdge->csCoord < bottomHintEdge->csCoord )
      return;
 
    /* linear search to find index value of insertion point */
    indexInsert = 0;
    for ( ; indexInsert < hintmap->count; indexInsert++ )
    {
      if ( hintmap->edge[indexInsert].csCoord >= firstHintEdge->csCoord )
        break;
    }
 
    FT_TRACE7(( "  Got hint at %.2f (%.2f)\n",
                firstHintEdge->csCoord / 65536.0,
                firstHintEdge->dsCoord / 65536.0 ));
    if ( isPair )
      FT_TRACE7(( "  Got hint at %.2f (%.2f)\n",
                  secondHintEdge->csCoord / 65536.0,
                  secondHintEdge->dsCoord / 65536.0 ));
 
    /*
     * Discard any hints that overlap in character space.  Most often, this
     * is while building the initial map, where captured hints from all
     * zones are combined.  Define overlap to include hints that `touch'
     * (overlap zero).  Hiragino Sans/Gothic fonts have numerous hints that
     * touch.  Some fonts have non-ideographic glyphs that overlap our
     * synthetic hints.
     *
     * Overlap also occurs when darkening stem hints that are close.
     *
     */
    if ( indexInsert < hintmap->count )
    {
      /* we are inserting before an existing edge:    */
      /* verify that an existing edge is not the same */
      if ( hintmap->edge[indexInsert].csCoord == firstHintEdge->csCoord )
        return; /* ignore overlapping stem hint */
 
      /* 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,
                       ADD_INT32( secondHintEdge->csCoord,
                                  firstHintEdge->csCoord ) / 2 );
        CF2_Fixed  halfWidth =
                     FT_MulFix( SUB_INT32( secondHintEdge->csCoord,
                                           firstHintEdge->csCoord ) / 2,
                                hintmap->scale );
 
 
        firstHintEdge->dsCoord  = SUB_INT32( midpoint, halfWidth );
        secondHintEdge->dsCoord = ADD_INT32( 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.
     *
     * TODO: Although we might correct this later during adjustment, we
     * don't currently have a way to delete a conflicting hint once it has
     * been inserted.  See v2.030 MinionPro-Regular, 12 ppem darkened,
     * initial hint map for second path, glyph 945 (the perispomeni (tilde)
     * in U+1F6E, Greek omega with psili and perispomeni).  Darkening is
     * 25.  Pair 667,747 initially conflicts in design space with top edge
     * 660.  This is because 667 maps to 7.87, and the top edge was
     * captured by a zone at 8.0.  The pair is later successfully inserted
     * in a zone without the top edge.  In this zone it is adjusted to 8.0,
     * and no longer conflicts with the top edge in design space.  This
     * means it can be included in yet a later zone which does have the top
     * edge hint.  This produces a small mismatch between the first and
     * last points of this path, even though the hint masks are the same.
     * The density map difference is tiny (1/256).
     *
     */
 
    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_UInt  iSrc = hintmap->count - 1;
      CF2_UInt  iDst = isPair ? hintmap->count + 1 : hintmap->count;
 
      CF2_UInt  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;
 
      FT_TRACE7(( "  Inserting hint %.2f (%.2f)\n",
                  firstHintEdge->csCoord / 65536.0,
                  firstHintEdge->dsCoord / 65536.0 ));
 
      if ( isPair )
      {
        /* insert second edge */
        hintmap->edge[indexInsert + 1] = *secondHintEdge;  /* copy struct */
        hintmap->count                += 1;
 
        FT_TRACE7(( "  Inserting hint %.2f (%.2f)\n",
                    secondHintEdge->csCoord / 65536.0,
                    secondHintEdge->dsCoord / 65536.0 ));
 
      }
    }
 
    return;
  }

Referenced by cf2_hintmap_build().

cf2_hintmap_isValid()

static FT_Bool cf2_hintmap_isValid ( const CF2_HintMap  hintmap )

static

Definition at line 296 of file pshints.c.

  {
    return hintmap->isValid;
  }

Referenced by cf2_glyphpath_curveTo(), cf2_glyphpath_lineTo(), cf2_glyphpath_moveTo(), cf2_glyphpath_pushMove(), cf2_hintmap_build(), and cf2_hintmap_insertHint().

cf2_hintmap_map()

static CF2_Fixed cf2_hintmap_map ( CF2_HintMap  hintmap, CF2_Fixed  csCoord  )

static

Definition at line 334 of file pshints.c.

  {
    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;
 
 
      FT_ASSERT( hintmap->lastIndex < CF2_MAX_HINT_EDGES );
 
      /* 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 ADD_INT32( FT_MulFix( SUB_INT32( 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 ADD_INT32( FT_MulFix( SUB_INT32( csCoord,
                                                hintmap->edge[i].csCoord ),
                                     hintmap->edge[i].scale ),
                          hintmap->edge[i].dsCoord );
      }
    }
  }

Referenced by cf2_glyphpath_hintPoint(), and cf2_hintmap_insertHint().