| Index: core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2hints.c
|
| diff --git a/core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2hints.c b/core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2hints.c
|
| deleted file mode 100644
|
| index 70926299f3f1e5918a9becc855d58dbb34000775..0000000000000000000000000000000000000000
|
| --- a/core/src/fxge/fx_freetype/fxft2.5.01/src/cff/cf2hints.c
|
| +++ /dev/null
|
| @@ -1,1752 +0,0 @@
|
| -/***************************************************************************/
|
| -/* */
|
| -/* 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 "../../include/freetype/internal/ftdebug.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 (FT_Bool)( hint->flags != 0 );
|
| - }
|
| -
|
| -
|
| - static FT_Bool
|
| - cf2_hint_isPair( const CF2_Hint hint )
|
| - {
|
| - return (FT_Bool)( ( hint->flags &
|
| - ( CF2_PairBottom | CF2_PairTop ) ) != 0 );
|
| - }
|
| -
|
| -
|
| - static FT_Bool
|
| - cf2_hint_isPairTop( const CF2_Hint hint )
|
| - {
|
| - return (FT_Bool)( ( hint->flags & CF2_PairTop ) != 0 );
|
| - }
|
| -
|
| -
|
| - FT_LOCAL_DEF( FT_Bool )
|
| - cf2_hint_isTop( const CF2_Hint hint )
|
| - {
|
| - return (FT_Bool)( ( hint->flags &
|
| - ( CF2_PairTop | CF2_GhostTop ) ) != 0 );
|
| - }
|
| -
|
| -
|
| - FT_LOCAL_DEF( FT_Bool )
|
| - cf2_hint_isBottom( const CF2_Hint hint )
|
| - {
|
| - return (FT_Bool)( ( hint->flags &
|
| - ( CF2_PairBottom | CF2_GhostBottom ) ) != 0 );
|
| - }
|
| -
|
| -
|
| - static FT_Bool
|
| - cf2_hint_isLocked( const CF2_Hint hint )
|
| - {
|
| - return (FT_Bool)( ( hint->flags & CF2_Locked ) != 0 );
|
| - }
|
| -
|
| -
|
| - static FT_Bool
|
| - cf2_hint_isSynthetic( const CF2_Hint hint )
|
| - {
|
| - return (FT_Bool)( ( 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;
|
| - /* 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 += 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;
|
| - FT_Byte* maskEndPtr; // add by Xiaochuan_Liu
|
| -
|
| - 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 );
|
| - maskEndPtr = maskPtr + ( CF2_MAX_HINTS + 7 ) / 8;
|
| -
|
| -
|
| - /* 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++;
|
| - if (maskPtr >= maskEndPtr)
|
| - {
|
| - break;
|
| - }
|
| -
|
| - 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 );
|
| - maskEndPtr = maskPtr + ( CF2_MAX_HINTS + 7 ) / 8;
|
| -
|
| - 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++;
|
| - if (maskPtr >= maskEndPtr)
|
| - {
|
| - break;
|
| - }
|
| - 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,
|
| - ¶ms.pt1,
|
| - glyphpath->prevElemP1.x,
|
| - glyphpath->prevElemP1.y );
|
| -
|
| - glyphpath->callbacks->lineTo( glyphpath->callbacks, ¶ms );
|
| -
|
| - 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,
|
| - ¶ms.pt1,
|
| - glyphpath->prevElemP1.x,
|
| - glyphpath->prevElemP1.y );
|
| - cf2_glyphpath_hintPoint( glyphpath,
|
| - hintmap,
|
| - ¶ms.pt2,
|
| - glyphpath->prevElemP2.x,
|
| - glyphpath->prevElemP2.y );
|
| - cf2_glyphpath_hintPoint( glyphpath,
|
| - hintmap,
|
| - ¶ms.pt3,
|
| - glyphpath->prevElemP3.x,
|
| - glyphpath->prevElemP3.y );
|
| -
|
| - glyphpath->callbacks->cubeTo( glyphpath->callbacks, ¶ms );
|
| -
|
| - 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,
|
| - ¶ms.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, ¶ms );
|
| -
|
| - 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,
|
| - ¶ms.pt1,
|
| - start.x,
|
| - start.y );
|
| -
|
| - /* note: pt2 and pt3 are unused */
|
| - glyphpath->callbacks->moveTo( glyphpath->callbacks, ¶ms );
|
| -
|
| - 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 );
|
| - if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
|
| -
|
| - 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 );
|
| - if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
|
| - }
|
| -
|
| - /* 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 );
|
| - if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
|
| -
|
| - 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 );
|
| - if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
|
| - }
|
| -
|
| - /* 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 );
|
| - if (glyphpath->callbacks && glyphpath->callbacks->error && *glyphpath->callbacks->error) return;
|
| -
|
| - /* 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 */
|
|
|
Chromium Code Reviews
Issue 815103002:
Update freetype to 2.5.4. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@master