1 /**************************************************************************** 2 * 3 * pshints.c 4 * 5 * Adobe's code for handling CFF hints (body). 6 * 7 * Copyright 2007-2014 Adobe Systems Incorporated. 8 * 9 * This software, and all works of authorship, whether in source or 10 * object code form as indicated by the copyright notice(s) included 11 * herein (collectively, the "Work") is made available, and may only be 12 * used, modified, and distributed under the FreeType Project License, 13 * LICENSE.TXT. Additionally, subject to the terms and conditions of the 14 * FreeType Project License, each contributor to the Work hereby grants 15 * to any individual or legal entity exercising permissions granted by 16 * the FreeType Project License and this section (hereafter, "You" or 17 * "Your") a perpetual, worldwide, non-exclusive, no-charge, 18 * royalty-free, irrevocable (except as stated in this section) patent 19 * license to make, have made, use, offer to sell, sell, import, and 20 * otherwise transfer the Work, where such license applies only to those 21 * patent claims licensable by such contributor that are necessarily 22 * infringed by their contribution(s) alone or by combination of their 23 * contribution(s) with the Work to which such contribution(s) was 24 * submitted. If You institute patent litigation against any entity 25 * (including a cross-claim or counterclaim in a lawsuit) alleging that 26 * the Work or a contribution incorporated within the Work constitutes 27 * direct or contributory patent infringement, then any patent licenses 28 * granted to You under this License for that Work shall terminate as of 29 * the date such litigation is filed. 30 * 31 * By using, modifying, or distributing the Work you indicate that you 32 * have read and understood the terms and conditions of the 33 * FreeType Project License as well as those provided in this section, 34 * and you accept them fully. 35 * 36 */ 37 38 39 #include "psft.h" 40 #include <freetype/internal/ftdebug.h> 41 42 #include "psglue.h" 43 #include "psfont.h" 44 #include "pshints.h" 45 #include "psintrp.h" 46 47 48 /************************************************************************** 49 * 50 * The macro FT_COMPONENT is used in trace mode. It is an implicit 51 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log 52 * messages during execution. 53 */ 54 #undef FT_COMPONENT 55 #define FT_COMPONENT cf2hints 56 57 58 typedef struct CF2_HintMoveRec_ 59 { 60 size_t j; /* index of upper hint map edge */ 61 CF2_Fixed moveUp; /* adjustment to optimum position */ 62 63 } CF2_HintMoveRec, *CF2_HintMove; 64 65 66 /* Compute angular momentum for winding order detection. It is called */ 67 /* for all lines and curves, but not necessarily in element order. */ 68 static CF2_Int cf2_getWindingMomentum(CF2_Fixed x1,CF2_Fixed y1,CF2_Fixed x2,CF2_Fixed y2)69 cf2_getWindingMomentum( CF2_Fixed x1, 70 CF2_Fixed y1, 71 CF2_Fixed x2, 72 CF2_Fixed y2 ) 73 { 74 /* cross product of pt1 position from origin with pt2 position from */ 75 /* pt1; we reduce the precision so that the result fits into 32 bits */ 76 77 return ( x1 >> 16 ) * ( SUB_INT32( y2, y1 ) >> 16 ) - 78 ( y1 >> 16 ) * ( SUB_INT32( x2, x1 ) >> 16 ); 79 } 80 81 82 /* 83 * Construct from a StemHint; this is used as a parameter to 84 * `cf2_blues_capture'. 85 * `hintOrigin' is the character space displacement of a seac accent. 86 * Adjust stem hint for darkening here. 87 * 88 */ 89 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)90 cf2_hint_init( CF2_Hint hint, 91 const CF2_ArrStack stemHintArray, 92 size_t indexStemHint, 93 const CF2_Font font, 94 CF2_Fixed hintOrigin, 95 CF2_Fixed scale, 96 FT_Bool bottom ) 97 { 98 CF2_Fixed width; 99 const CF2_StemHintRec* stemHint; 100 101 102 FT_ZERO( hint ); 103 104 stemHint = (const CF2_StemHintRec*)cf2_arrstack_getPointer( 105 stemHintArray, 106 indexStemHint ); 107 108 width = SUB_INT32( stemHint->max, stemHint->min ); 109 110 if ( width == cf2_intToFixed( -21 ) ) 111 { 112 /* ghost bottom */ 113 114 if ( bottom ) 115 { 116 hint->csCoord = stemHint->max; 117 hint->flags = CF2_GhostBottom; 118 } 119 else 120 hint->flags = 0; 121 } 122 123 else if ( width == cf2_intToFixed( -20 ) ) 124 { 125 /* ghost top */ 126 127 if ( bottom ) 128 hint->flags = 0; 129 else 130 { 131 hint->csCoord = stemHint->min; 132 hint->flags = CF2_GhostTop; 133 } 134 } 135 136 else if ( width < 0 ) 137 { 138 /* inverted pair */ 139 140 /* 141 * Hints with negative widths were produced by an early version of a 142 * non-Adobe font tool. The Type 2 spec allows edge (ghost) hints 143 * with negative widths, but says 144 * 145 * All other negative widths have undefined meaning. 146 * 147 * CoolType has a silent workaround that negates the hint width; for 148 * permissive mode, we do the same here. 149 * 150 * Note: Such fonts cannot use ghost hints, but should otherwise work. 151 * Note: Some poor hints in our faux fonts can produce negative 152 * widths at some blends. For example, see a light weight of 153 * `u' in ASerifMM. 154 * 155 */ 156 if ( bottom ) 157 { 158 hint->csCoord = stemHint->max; 159 hint->flags = CF2_PairBottom; 160 } 161 else 162 { 163 hint->csCoord = stemHint->min; 164 hint->flags = CF2_PairTop; 165 } 166 } 167 168 else 169 { 170 /* normal pair */ 171 172 if ( bottom ) 173 { 174 hint->csCoord = stemHint->min; 175 hint->flags = CF2_PairBottom; 176 } 177 else 178 { 179 hint->csCoord = stemHint->max; 180 hint->flags = CF2_PairTop; 181 } 182 } 183 184 /* Now that ghost hints have been detected, adjust this edge for */ 185 /* darkening. Bottoms are not changed; tops are incremented by twice */ 186 /* `darkenY'. */ 187 if ( cf2_hint_isTop( hint ) ) 188 hint->csCoord = ADD_INT32( hint->csCoord, 2 * font->darkenY ); 189 190 hint->csCoord = ADD_INT32( hint->csCoord, hintOrigin ); 191 hint->scale = scale; 192 hint->index = indexStemHint; /* index in original stem hint array */ 193 194 /* if original stem hint has been used, use the same position */ 195 if ( hint->flags != 0 && stemHint->used ) 196 { 197 if ( cf2_hint_isTop( hint ) ) 198 hint->dsCoord = stemHint->maxDS; 199 else 200 hint->dsCoord = stemHint->minDS; 201 202 cf2_hint_lock( hint ); 203 } 204 else 205 hint->dsCoord = FT_MulFix( hint->csCoord, scale ); 206 } 207 208 209 /* initialize an invalid hint map element */ 210 static void cf2_hint_initZero(CF2_Hint hint)211 cf2_hint_initZero( CF2_Hint hint ) 212 { 213 FT_ZERO( hint ); 214 } 215 216 217 FT_LOCAL_DEF( FT_Bool ) cf2_hint_isValid(const CF2_Hint hint)218 cf2_hint_isValid( const CF2_Hint hint ) 219 { 220 return FT_BOOL( hint->flags ); 221 } 222 223 224 static FT_Bool cf2_hint_isPair(const CF2_Hint hint)225 cf2_hint_isPair( const CF2_Hint hint ) 226 { 227 return FT_BOOL( hint->flags & ( CF2_PairBottom | CF2_PairTop ) ); 228 } 229 230 231 static FT_Bool cf2_hint_isPairTop(const CF2_Hint hint)232 cf2_hint_isPairTop( const CF2_Hint hint ) 233 { 234 return FT_BOOL( hint->flags & CF2_PairTop ); 235 } 236 237 238 FT_LOCAL_DEF( FT_Bool ) cf2_hint_isTop(const CF2_Hint hint)239 cf2_hint_isTop( const CF2_Hint hint ) 240 { 241 return FT_BOOL( hint->flags & ( CF2_PairTop | CF2_GhostTop ) ); 242 } 243 244 245 FT_LOCAL_DEF( FT_Bool ) cf2_hint_isBottom(const CF2_Hint hint)246 cf2_hint_isBottom( const CF2_Hint hint ) 247 { 248 return FT_BOOL( hint->flags & ( CF2_PairBottom | CF2_GhostBottom ) ); 249 } 250 251 252 static FT_Bool cf2_hint_isLocked(const CF2_Hint hint)253 cf2_hint_isLocked( const CF2_Hint hint ) 254 { 255 return FT_BOOL( hint->flags & CF2_Locked ); 256 } 257 258 259 static FT_Bool cf2_hint_isSynthetic(const CF2_Hint hint)260 cf2_hint_isSynthetic( const CF2_Hint hint ) 261 { 262 return FT_BOOL( hint->flags & CF2_Synthetic ); 263 } 264 265 266 FT_LOCAL_DEF( void ) cf2_hint_lock(CF2_Hint hint)267 cf2_hint_lock( CF2_Hint hint ) 268 { 269 hint->flags |= CF2_Locked; 270 } 271 272 273 FT_LOCAL_DEF( void ) cf2_hintmap_init(CF2_HintMap hintmap,CF2_Font font,CF2_HintMap initialMap,CF2_ArrStack hintMoves,CF2_Fixed scale)274 cf2_hintmap_init( CF2_HintMap hintmap, 275 CF2_Font font, 276 CF2_HintMap initialMap, 277 CF2_ArrStack hintMoves, 278 CF2_Fixed scale ) 279 { 280 FT_ZERO( hintmap ); 281 282 /* copy parameters from font instance */ 283 hintmap->hinted = font->hinted; 284 hintmap->scale = scale; 285 hintmap->font = font; 286 hintmap->initialHintMap = initialMap; 287 /* will clear in `cf2_hintmap_adjustHints' */ 288 hintmap->hintMoves = hintMoves; 289 } 290 291 292 static FT_Bool cf2_hintmap_isValid(const CF2_HintMap hintmap)293 cf2_hintmap_isValid( const CF2_HintMap hintmap ) 294 { 295 return hintmap->isValid; 296 } 297 298 299 static void cf2_hintmap_dump(CF2_HintMap hintmap)300 cf2_hintmap_dump( CF2_HintMap hintmap ) 301 { 302 #ifdef FT_DEBUG_LEVEL_TRACE 303 CF2_UInt i; 304 305 306 FT_TRACE6(( " index csCoord dsCoord scale flags\n" )); 307 308 for ( i = 0; i < hintmap->count; i++ ) 309 { 310 CF2_Hint hint = &hintmap->edge[i]; 311 312 313 FT_TRACE6(( " %3zu %7.2f %7.2f %5d %s%s%s%s\n", 314 hint->index, 315 hint->csCoord / 65536.0, 316 hint->dsCoord / ( hint->scale * 1.0 ), 317 hint->scale, 318 ( cf2_hint_isPair( hint ) ? "p" : "g" ), 319 ( cf2_hint_isTop( hint ) ? "t" : "b" ), 320 ( cf2_hint_isLocked( hint ) ? "L" : ""), 321 ( cf2_hint_isSynthetic( hint ) ? "S" : "" ) )); 322 } 323 #else 324 FT_UNUSED( hintmap ); 325 #endif 326 } 327 328 329 /* transform character space coordinate to device space using hint map */ 330 static CF2_Fixed cf2_hintmap_map(CF2_HintMap hintmap,CF2_Fixed csCoord)331 cf2_hintmap_map( CF2_HintMap hintmap, 332 CF2_Fixed csCoord ) 333 { 334 if ( hintmap->count == 0 || !hintmap->hinted ) 335 { 336 /* there are no hints; use uniform scale and zero offset */ 337 return FT_MulFix( csCoord, hintmap->scale ); 338 } 339 else 340 { 341 /* start linear search from last hit */ 342 CF2_UInt i = hintmap->lastIndex; 343 344 345 FT_ASSERT( hintmap->lastIndex < CF2_MAX_HINT_EDGES ); 346 347 /* search up */ 348 while ( i < hintmap->count - 1 && 349 csCoord >= hintmap->edge[i + 1].csCoord ) 350 i += 1; 351 352 /* search down */ 353 while ( i > 0 && csCoord < hintmap->edge[i].csCoord ) 354 i -= 1; 355 356 hintmap->lastIndex = i; 357 358 if ( i == 0 && csCoord < hintmap->edge[0].csCoord ) 359 { 360 /* special case for points below first edge: use uniform scale */ 361 return ADD_INT32( FT_MulFix( SUB_INT32( csCoord, 362 hintmap->edge[0].csCoord ), 363 hintmap->scale ), 364 hintmap->edge[0].dsCoord ); 365 } 366 else 367 { 368 /* 369 * Note: entries with duplicate csCoord are allowed. 370 * Use edge[i], the highest entry where csCoord >= entry[i].csCoord 371 */ 372 return ADD_INT32( FT_MulFix( SUB_INT32( csCoord, 373 hintmap->edge[i].csCoord ), 374 hintmap->edge[i].scale ), 375 hintmap->edge[i].dsCoord ); 376 } 377 } 378 } 379 380 381 /* 382 * This hinting policy moves a hint pair in device space so that one of 383 * its two edges is on a device pixel boundary (its fractional part is 384 * zero). `cf2_hintmap_insertHint' guarantees no overlap in CS 385 * space. Ensure here that there is no overlap in DS. 386 * 387 * In the first pass, edges are adjusted relative to adjacent hints. 388 * Those that are below have already been adjusted. Those that are 389 * above have not yet been adjusted. If a hint above blocks an 390 * adjustment to an optimal position, we will try again in a second 391 * pass. The second pass is top-down. 392 * 393 */ 394 395 static void cf2_hintmap_adjustHints(CF2_HintMap hintmap)396 cf2_hintmap_adjustHints( CF2_HintMap hintmap ) 397 { 398 size_t i, j; 399 400 401 cf2_arrstack_clear( hintmap->hintMoves ); /* working storage */ 402 403 /* 404 * First pass is bottom-up (font hint order) without look-ahead. 405 * Locked edges are already adjusted. 406 * Unlocked edges begin with dsCoord from `initialHintMap'. 407 * Save edges that are not optimally adjusted in `hintMoves' array, 408 * and process them in second pass. 409 */ 410 411 for ( i = 0; i < hintmap->count; i++ ) 412 { 413 FT_Bool isPair = cf2_hint_isPair( &hintmap->edge[i] ); 414 415 /* final amount to move edge or edge pair */ 416 CF2_Fixed move = 0; 417 418 CF2_Fixed dsCoord_i; 419 CF2_Fixed dsCoord_j; 420 421 422 /* index of upper edge (same value for ghost hint) */ 423 j = isPair ? i + 1 : i; 424 425 FT_ASSERT( j < hintmap->count ); 426 FT_ASSERT( cf2_hint_isValid( &hintmap->edge[i] ) ); 427 FT_ASSERT( cf2_hint_isValid( &hintmap->edge[j] ) ); 428 FT_ASSERT( cf2_hint_isLocked( &hintmap->edge[i] ) == 429 cf2_hint_isLocked( &hintmap->edge[j] ) ); 430 431 dsCoord_i = hintmap->edge[i].dsCoord; 432 dsCoord_j = hintmap->edge[j].dsCoord; 433 434 if ( !cf2_hint_isLocked( &hintmap->edge[i] ) ) 435 { 436 /* hint edge is not locked, we can adjust it */ 437 CF2_Fixed fracDown = cf2_fixedFraction( dsCoord_i ); 438 CF2_Fixed fracUp = cf2_fixedFraction( dsCoord_j ); 439 440 /* calculate all four possibilities; moves down are negative */ 441 CF2_Fixed downMoveDown = 0 - fracDown; 442 CF2_Fixed upMoveDown = 0 - fracUp; 443 CF2_Fixed downMoveUp = ( fracDown == 0 ) 444 ? 0 445 : cf2_intToFixed( 1 ) - fracDown; 446 CF2_Fixed upMoveUp = ( fracUp == 0 ) 447 ? 0 448 : cf2_intToFixed( 1 ) - fracUp; 449 450 /* smallest move up */ 451 CF2_Fixed moveUp = FT_MIN( downMoveUp, upMoveUp ); 452 /* smallest move down */ 453 CF2_Fixed moveDown = FT_MAX( downMoveDown, upMoveDown ); 454 455 CF2_Fixed downMinCounter = CF2_MIN_COUNTER; 456 CF2_Fixed upMinCounter = CF2_MIN_COUNTER; 457 FT_Bool saveEdge = FALSE; 458 459 460 /* minimum counter constraint doesn't apply when adjacent edges */ 461 /* are synthetic */ 462 /* TODO: doesn't seem a big effect; for now, reduce the code */ 463 #if 0 464 if ( i == 0 || 465 cf2_hint_isSynthetic( &hintmap->edge[i - 1] ) ) 466 downMinCounter = 0; 467 468 if ( j >= hintmap->count - 1 || 469 cf2_hint_isSynthetic( &hintmap->edge[j + 1] ) ) 470 upMinCounter = 0; 471 #endif 472 473 /* is there room to move up? */ 474 /* there is if we are at top of array or the next edge is at or */ 475 /* beyond proposed move up? */ 476 if ( j >= hintmap->count - 1 || 477 hintmap->edge[j + 1].dsCoord >= 478 ADD_INT32( dsCoord_j, moveUp + upMinCounter ) ) 479 { 480 /* there is room to move up; is there also room to move down? */ 481 if ( i == 0 || 482 hintmap->edge[i - 1].dsCoord <= 483 ADD_INT32( dsCoord_i, moveDown - downMinCounter ) ) 484 { 485 /* move smaller absolute amount */ 486 move = ( -moveDown < moveUp ) ? moveDown : moveUp; /* optimum */ 487 } 488 else 489 move = moveUp; 490 } 491 else 492 { 493 /* is there room to move down? */ 494 if ( i == 0 || 495 hintmap->edge[i - 1].dsCoord <= 496 ADD_INT32( dsCoord_i, moveDown - downMinCounter ) ) 497 { 498 move = moveDown; 499 /* true if non-optimum move */ 500 saveEdge = FT_BOOL( moveUp < -moveDown ); 501 } 502 else 503 { 504 /* no room to move either way without overlapping or reducing */ 505 /* the counter too much */ 506 move = 0; 507 saveEdge = TRUE; 508 } 509 } 510 511 /* Identify non-moves and moves down that aren't optimal, and save */ 512 /* them for second pass. */ 513 /* Do this only if there is an unlocked edge above (which could */ 514 /* possibly move). */ 515 if ( saveEdge && 516 j < hintmap->count - 1 && 517 !cf2_hint_isLocked( &hintmap->edge[j + 1] ) ) 518 { 519 CF2_HintMoveRec savedMove; 520 521 522 savedMove.j = j; 523 /* desired adjustment in second pass */ 524 savedMove.moveUp = moveUp - move; 525 526 cf2_arrstack_push( hintmap->hintMoves, &savedMove ); 527 } 528 529 /* move the edge(s) */ 530 hintmap->edge[i].dsCoord = ADD_INT32( dsCoord_i, move ); 531 if ( isPair ) 532 hintmap->edge[j].dsCoord = ADD_INT32( dsCoord_j, move ); 533 } 534 535 /* assert there are no overlaps in device space; */ 536 /* ignore tests if there was overflow (that is, if */ 537 /* operands have the same sign but the sum does not) */ 538 FT_ASSERT( i == 0 || 539 ( ( dsCoord_i ^ move ) >= 0 && 540 ( dsCoord_i ^ hintmap->edge[i].dsCoord ) < 0 ) || 541 hintmap->edge[i - 1].dsCoord <= hintmap->edge[i].dsCoord ); 542 FT_ASSERT( i < j || 543 ( ( dsCoord_j ^ move ) >= 0 && 544 ( dsCoord_j ^ hintmap->edge[j].dsCoord ) < 0 ) || 545 hintmap->edge[i].dsCoord <= hintmap->edge[j].dsCoord ); 546 547 /* adjust the scales, avoiding divide by zero */ 548 if ( i > 0 ) 549 { 550 if ( hintmap->edge[i].csCoord != hintmap->edge[i - 1].csCoord ) 551 hintmap->edge[i - 1].scale = 552 FT_DivFix( SUB_INT32( hintmap->edge[i].dsCoord, 553 hintmap->edge[i - 1].dsCoord ), 554 SUB_INT32( hintmap->edge[i].csCoord, 555 hintmap->edge[i - 1].csCoord ) ); 556 } 557 558 if ( isPair ) 559 { 560 if ( hintmap->edge[j].csCoord != hintmap->edge[j - 1].csCoord ) 561 hintmap->edge[j - 1].scale = 562 FT_DivFix( SUB_INT32( hintmap->edge[j].dsCoord, 563 hintmap->edge[j - 1].dsCoord ), 564 SUB_INT32( hintmap->edge[j].csCoord, 565 hintmap->edge[j - 1].csCoord ) ); 566 567 i += 1; /* skip upper edge on next loop */ 568 } 569 } 570 571 /* second pass tries to move non-optimal hints up, in case there is */ 572 /* room now */ 573 for ( i = cf2_arrstack_size( hintmap->hintMoves ); i > 0; i-- ) 574 { 575 CF2_HintMove hintMove = (CF2_HintMove) 576 cf2_arrstack_getPointer( hintmap->hintMoves, i - 1 ); 577 578 579 j = hintMove->j; 580 581 /* this was tested before the push, above */ 582 FT_ASSERT( j < hintmap->count - 1 ); 583 584 /* is there room to move up? */ 585 if ( hintmap->edge[j + 1].dsCoord >= 586 ADD_INT32( hintmap->edge[j].dsCoord, 587 hintMove->moveUp + CF2_MIN_COUNTER ) ) 588 { 589 /* there is more room now, move edge up */ 590 hintmap->edge[j].dsCoord = ADD_INT32( hintmap->edge[j].dsCoord, 591 hintMove->moveUp ); 592 593 if ( cf2_hint_isPair( &hintmap->edge[j] ) ) 594 { 595 FT_ASSERT( j > 0 ); 596 hintmap->edge[j - 1].dsCoord = 597 ADD_INT32( hintmap->edge[j - 1].dsCoord, hintMove->moveUp ); 598 } 599 } 600 } 601 } 602 603 604 /* insert hint edges into map, sorted by csCoord */ 605 static void cf2_hintmap_insertHint(CF2_HintMap hintmap,CF2_Hint bottomHintEdge,CF2_Hint topHintEdge)606 cf2_hintmap_insertHint( CF2_HintMap hintmap, 607 CF2_Hint bottomHintEdge, 608 CF2_Hint topHintEdge ) 609 { 610 CF2_UInt indexInsert; 611 612 /* set default values, then check for edge hints */ 613 FT_Bool isPair = TRUE; 614 CF2_Hint firstHintEdge = bottomHintEdge; 615 CF2_Hint secondHintEdge = topHintEdge; 616 617 618 /* one or none of the input params may be invalid when dealing with */ 619 /* edge hints; at least one edge must be valid */ 620 FT_ASSERT( cf2_hint_isValid( bottomHintEdge ) || 621 cf2_hint_isValid( topHintEdge ) ); 622 623 /* determine how many and which edges to insert */ 624 if ( !cf2_hint_isValid( bottomHintEdge ) ) 625 { 626 /* insert only the top edge */ 627 firstHintEdge = topHintEdge; 628 isPair = FALSE; 629 } 630 else if ( !cf2_hint_isValid( topHintEdge ) ) 631 { 632 /* insert only the bottom edge */ 633 isPair = FALSE; 634 } 635 636 /* paired edges must be in proper order */ 637 if ( isPair && 638 topHintEdge->csCoord < bottomHintEdge->csCoord ) 639 return; 640 641 /* linear search to find index value of insertion point */ 642 indexInsert = 0; 643 for ( ; indexInsert < hintmap->count; indexInsert++ ) 644 { 645 if ( hintmap->edge[indexInsert].csCoord >= firstHintEdge->csCoord ) 646 break; 647 } 648 649 FT_TRACE7(( " Got hint at %.2f (%.2f)\n", 650 firstHintEdge->csCoord / 65536.0, 651 firstHintEdge->dsCoord / 65536.0 )); 652 if ( isPair ) 653 FT_TRACE7(( " Got hint at %.2f (%.2f)\n", 654 secondHintEdge->csCoord / 65536.0, 655 secondHintEdge->dsCoord / 65536.0 )); 656 657 /* 658 * Discard any hints that overlap in character space. Most often, this 659 * is while building the initial map, where captured hints from all 660 * zones are combined. Define overlap to include hints that `touch' 661 * (overlap zero). Hiragino Sans/Gothic fonts have numerous hints that 662 * touch. Some fonts have non-ideographic glyphs that overlap our 663 * synthetic hints. 664 * 665 * Overlap also occurs when darkening stem hints that are close. 666 * 667 */ 668 if ( indexInsert < hintmap->count ) 669 { 670 /* we are inserting before an existing edge: */ 671 /* verify that an existing edge is not the same */ 672 if ( hintmap->edge[indexInsert].csCoord == firstHintEdge->csCoord ) 673 return; /* ignore overlapping stem hint */ 674 675 /* verify that a new pair does not straddle the next edge */ 676 if ( isPair && 677 hintmap->edge[indexInsert].csCoord <= secondHintEdge->csCoord ) 678 return; /* ignore overlapping stem hint */ 679 680 /* verify that we are not inserting between paired edges */ 681 if ( cf2_hint_isPairTop( &hintmap->edge[indexInsert] ) ) 682 return; /* ignore overlapping stem hint */ 683 } 684 685 /* recompute device space locations using initial hint map */ 686 if ( cf2_hintmap_isValid( hintmap->initialHintMap ) && 687 !cf2_hint_isLocked( firstHintEdge ) ) 688 { 689 if ( isPair ) 690 { 691 /* Use hint map to position the center of stem, and nominal scale */ 692 /* to position the two edges. This preserves the stem width. */ 693 CF2_Fixed midpoint = 694 cf2_hintmap_map( 695 hintmap->initialHintMap, 696 ADD_INT32( 697 firstHintEdge->csCoord, 698 SUB_INT32 ( secondHintEdge->csCoord, 699 firstHintEdge->csCoord ) / 2 ) ); 700 CF2_Fixed halfWidth = 701 FT_MulFix( SUB_INT32( secondHintEdge->csCoord, 702 firstHintEdge->csCoord ) / 2, 703 hintmap->scale ); 704 705 706 firstHintEdge->dsCoord = SUB_INT32( midpoint, halfWidth ); 707 secondHintEdge->dsCoord = ADD_INT32( midpoint, halfWidth ); 708 } 709 else 710 firstHintEdge->dsCoord = cf2_hintmap_map( hintmap->initialHintMap, 711 firstHintEdge->csCoord ); 712 } 713 714 /* 715 * Discard any hints that overlap in device space; this can occur 716 * because locked hints have been moved to align with blue zones. 717 * 718 * TODO: Although we might correct this later during adjustment, we 719 * don't currently have a way to delete a conflicting hint once it has 720 * been inserted. See v2.030 MinionPro-Regular, 12 ppem darkened, 721 * initial hint map for second path, glyph 945 (the perispomeni (tilde) 722 * in U+1F6E, Greek omega with psili and perispomeni). Darkening is 723 * 25. Pair 667,747 initially conflicts in design space with top edge 724 * 660. This is because 667 maps to 7.87, and the top edge was 725 * captured by a zone at 8.0. The pair is later successfully inserted 726 * in a zone without the top edge. In this zone it is adjusted to 8.0, 727 * and no longer conflicts with the top edge in design space. This 728 * means it can be included in yet a later zone which does have the top 729 * edge hint. This produces a small mismatch between the first and 730 * last points of this path, even though the hint masks are the same. 731 * The density map difference is tiny (1/256). 732 * 733 */ 734 735 if ( indexInsert > 0 ) 736 { 737 /* we are inserting after an existing edge */ 738 if ( firstHintEdge->dsCoord < hintmap->edge[indexInsert - 1].dsCoord ) 739 return; 740 } 741 742 if ( indexInsert < hintmap->count ) 743 { 744 /* we are inserting before an existing edge */ 745 if ( isPair ) 746 { 747 if ( secondHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord ) 748 return; 749 } 750 else 751 { 752 if ( firstHintEdge->dsCoord > hintmap->edge[indexInsert].dsCoord ) 753 return; 754 } 755 } 756 757 /* make room to insert */ 758 { 759 CF2_UInt iSrc = hintmap->count - 1; 760 CF2_UInt iDst = isPair ? hintmap->count + 1 : hintmap->count; 761 762 CF2_UInt count = hintmap->count - indexInsert; 763 764 765 if ( iDst >= CF2_MAX_HINT_EDGES ) 766 { 767 FT_TRACE4(( "cf2_hintmap_insertHint: too many hintmaps\n" )); 768 return; 769 } 770 771 while ( count-- ) 772 hintmap->edge[iDst--] = hintmap->edge[iSrc--]; 773 774 /* insert first edge */ 775 hintmap->edge[indexInsert] = *firstHintEdge; /* copy struct */ 776 hintmap->count += 1; 777 778 FT_TRACE7(( " Inserting hint %.2f (%.2f)\n", 779 firstHintEdge->csCoord / 65536.0, 780 firstHintEdge->dsCoord / 65536.0 )); 781 782 if ( isPair ) 783 { 784 /* insert second edge */ 785 hintmap->edge[indexInsert + 1] = *secondHintEdge; /* copy struct */ 786 hintmap->count += 1; 787 788 FT_TRACE7(( " Inserting hint %.2f (%.2f)\n", 789 secondHintEdge->csCoord / 65536.0, 790 secondHintEdge->dsCoord / 65536.0 )); 791 792 } 793 } 794 795 return; 796 } 797 798 799 /* 800 * Build a map from hints and mask. 801 * 802 * This function may recur one level if `hintmap->initialHintMap' is not yet 803 * valid. 804 * If `initialMap' is true, simply build initial map. 805 * 806 * Synthetic hints are used in two ways. A hint at zero is inserted, if 807 * needed, in the initial hint map, to prevent translations from 808 * propagating across the origin. If synthetic em box hints are enabled 809 * for ideographic dictionaries, then they are inserted in all hint 810 * maps, including the initial one. 811 * 812 */ 813 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)814 cf2_hintmap_build( CF2_HintMap hintmap, 815 CF2_ArrStack hStemHintArray, 816 CF2_ArrStack vStemHintArray, 817 CF2_HintMask hintMask, 818 CF2_Fixed hintOrigin, 819 FT_Bool initialMap ) 820 { 821 FT_Byte* maskPtr; 822 823 CF2_Font font = hintmap->font; 824 CF2_HintMaskRec tempHintMask; 825 826 size_t bitCount, i; 827 FT_Byte maskByte; 828 829 830 /* check whether initial map is constructed */ 831 if ( !initialMap && !cf2_hintmap_isValid( hintmap->initialHintMap ) ) 832 { 833 /* make recursive call with initialHintMap and temporary mask; */ 834 /* temporary mask will get all bits set, below */ 835 cf2_hintmask_init( &tempHintMask, hintMask->error ); 836 cf2_hintmap_build( hintmap->initialHintMap, 837 hStemHintArray, 838 vStemHintArray, 839 &tempHintMask, 840 hintOrigin, 841 TRUE ); 842 } 843 844 if ( !cf2_hintmask_isValid( hintMask ) ) 845 { 846 /* without a hint mask, assume all hints are active */ 847 cf2_hintmask_setAll( hintMask, 848 cf2_arrstack_size( hStemHintArray ) + 849 cf2_arrstack_size( vStemHintArray ) ); 850 if ( !cf2_hintmask_isValid( hintMask ) ) 851 { 852 if ( font->isT1 ) 853 { 854 /* no error, just continue unhinted */ 855 *hintMask->error = FT_Err_Ok; 856 hintmap->hinted = FALSE; 857 } 858 return; /* too many stem hints */ 859 } 860 } 861 862 /* begin by clearing the map */ 863 hintmap->count = 0; 864 hintmap->lastIndex = 0; 865 866 /* make a copy of the hint mask so we can modify it */ 867 tempHintMask = *hintMask; 868 maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask ); 869 870 /* use the hStem hints only, which are first in the mask */ 871 bitCount = cf2_arrstack_size( hStemHintArray ); 872 873 /* Defense-in-depth. Should never return here. */ 874 if ( bitCount > hintMask->bitCount ) 875 return; 876 877 /* synthetic embox hints get highest priority */ 878 if ( font->blues.doEmBoxHints ) 879 { 880 CF2_HintRec dummy; 881 882 883 cf2_hint_initZero( &dummy ); /* invalid hint map element */ 884 885 /* ghost bottom */ 886 cf2_hintmap_insertHint( hintmap, 887 &font->blues.emBoxBottomEdge, 888 &dummy ); 889 /* ghost top */ 890 cf2_hintmap_insertHint( hintmap, 891 &dummy, 892 &font->blues.emBoxTopEdge ); 893 } 894 895 /* insert hints captured by a blue zone or already locked (higher */ 896 /* priority) */ 897 for ( i = 0, maskByte = 0x80; i < bitCount; i++ ) 898 { 899 if ( maskByte & *maskPtr ) 900 { 901 /* expand StemHint into two `CF2_Hint' elements */ 902 CF2_HintRec bottomHintEdge, topHintEdge; 903 904 905 cf2_hint_init( &bottomHintEdge, 906 hStemHintArray, 907 i, 908 font, 909 hintOrigin, 910 hintmap->scale, 911 TRUE /* bottom */ ); 912 cf2_hint_init( &topHintEdge, 913 hStemHintArray, 914 i, 915 font, 916 hintOrigin, 917 hintmap->scale, 918 FALSE /* top */ ); 919 920 if ( cf2_hint_isLocked( &bottomHintEdge ) || 921 cf2_hint_isLocked( &topHintEdge ) || 922 cf2_blues_capture( &font->blues, 923 &bottomHintEdge, 924 &topHintEdge ) ) 925 { 926 /* insert captured hint into map */ 927 cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge ); 928 929 *maskPtr &= ~maskByte; /* turn off the bit for this hint */ 930 } 931 } 932 933 if ( ( i & 7 ) == 7 ) 934 { 935 /* move to next mask byte */ 936 maskPtr++; 937 maskByte = 0x80; 938 } 939 else 940 maskByte >>= 1; 941 } 942 943 /* initial hint map includes only captured hints plus maybe one at 0 */ 944 945 /* 946 * TODO: There is a problem here because we are trying to build a 947 * single hint map containing all captured hints. It is 948 * possible for there to be conflicts between captured hints, 949 * either because of darkening or because the hints are in 950 * separate hint zones (we are ignoring hint zones for the 951 * initial map). An example of the latter is MinionPro-Regular 952 * v2.030 glyph 883 (Greek Capital Alpha with Psili) at 15ppem. 953 * A stem hint for the psili conflicts with the top edge hint 954 * for the base character. The stem hint gets priority because 955 * of its sort order. In glyph 884 (Greek Capital Alpha with 956 * Psili and Oxia), the top of the base character gets a stem 957 * hint, and the psili does not. This creates different initial 958 * maps for the two glyphs resulting in different renderings of 959 * the base character. Will probably defer this either as not 960 * worth the cost or as a font bug. I don't think there is any 961 * good reason for an accent to be captured by an alignment 962 * zone. -darnold 2/12/10 963 */ 964 965 if ( initialMap ) 966 { 967 /* Apply a heuristic that inserts a point for (0,0), unless it's */ 968 /* already covered by a mapping. This locks the baseline for glyphs */ 969 /* that have no baseline hints. */ 970 971 if ( hintmap->count == 0 || 972 hintmap->edge[0].csCoord > 0 || 973 hintmap->edge[hintmap->count - 1].csCoord < 0 ) 974 { 975 /* all edges are above 0 or all edges are below 0; */ 976 /* construct a locked edge hint at 0 */ 977 978 CF2_HintRec edge, invalid; 979 980 981 cf2_hint_initZero( &edge ); 982 983 edge.flags = CF2_GhostBottom | 984 CF2_Locked | 985 CF2_Synthetic; 986 edge.scale = hintmap->scale; 987 988 cf2_hint_initZero( &invalid ); 989 cf2_hintmap_insertHint( hintmap, &edge, &invalid ); 990 } 991 } 992 else 993 { 994 /* insert remaining hints */ 995 996 maskPtr = cf2_hintmask_getMaskPtr( &tempHintMask ); 997 998 for ( i = 0, maskByte = 0x80; i < bitCount; i++ ) 999 { 1000 if ( maskByte & *maskPtr ) 1001 { 1002 CF2_HintRec bottomHintEdge, topHintEdge; 1003 1004 1005 cf2_hint_init( &bottomHintEdge, 1006 hStemHintArray, 1007 i, 1008 font, 1009 hintOrigin, 1010 hintmap->scale, 1011 TRUE /* bottom */ ); 1012 cf2_hint_init( &topHintEdge, 1013 hStemHintArray, 1014 i, 1015 font, 1016 hintOrigin, 1017 hintmap->scale, 1018 FALSE /* top */ ); 1019 1020 cf2_hintmap_insertHint( hintmap, &bottomHintEdge, &topHintEdge ); 1021 } 1022 1023 if ( ( i & 7 ) == 7 ) 1024 { 1025 /* move to next mask byte */ 1026 maskPtr++; 1027 maskByte = 0x80; 1028 } 1029 else 1030 maskByte >>= 1; 1031 } 1032 } 1033 1034 #ifdef FT_DEBUG_LEVEL_TRACE 1035 if ( initialMap ) 1036 { 1037 FT_TRACE6(( "flags: [p]air [g]host [t]op" 1038 " [b]ottom [L]ocked [S]ynthetic\n" )); 1039 FT_TRACE6(( "Initial hintmap:\n" )); 1040 } 1041 else 1042 FT_TRACE6(( "Hints:\n" )); 1043 #endif 1044 1045 cf2_hintmap_dump( hintmap ); 1046 1047 /* 1048 * Note: The following line is a convenient place to break when 1049 * debugging hinting. Examine `hintmap->edge' for the list of 1050 * enabled hints, then step over the call to see the effect of 1051 * adjustment. We stop here first on the recursive call that 1052 * creates the initial map, and then on each counter group and 1053 * hint zone. 1054 */ 1055 1056 /* adjust positions of hint edges that are not locked to blue zones */ 1057 cf2_hintmap_adjustHints( hintmap ); 1058 1059 FT_TRACE6(( "Hints adjusted:\n" )); 1060 cf2_hintmap_dump( hintmap ); 1061 1062 /* save the position of all hints that were used in this hint map; */ 1063 /* if we use them again, we'll locate them in the same position */ 1064 if ( !initialMap ) 1065 { 1066 for ( i = 0; i < hintmap->count; i++ ) 1067 { 1068 if ( !cf2_hint_isSynthetic( &hintmap->edge[i] ) ) 1069 { 1070 /* Note: include both valid and invalid edges */ 1071 /* Note: top and bottom edges are copied back separately */ 1072 CF2_StemHint stemhint = (CF2_StemHint) 1073 cf2_arrstack_getPointer( hStemHintArray, 1074 hintmap->edge[i].index ); 1075 1076 1077 if ( cf2_hint_isTop( &hintmap->edge[i] ) ) 1078 stemhint->maxDS = hintmap->edge[i].dsCoord; 1079 else 1080 stemhint->minDS = hintmap->edge[i].dsCoord; 1081 1082 stemhint->used = TRUE; 1083 } 1084 } 1085 } 1086 1087 /* hint map is ready to use */ 1088 hintmap->isValid = TRUE; 1089 1090 /* remember this mask has been used */ 1091 cf2_hintmask_setNew( hintMask, FALSE ); 1092 } 1093 1094 1095 FT_LOCAL_DEF( void ) 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)1096 cf2_glyphpath_init( CF2_GlyphPath glyphpath, 1097 CF2_Font font, 1098 CF2_OutlineCallbacks callbacks, 1099 CF2_Fixed scaleY, 1100 /* CF2_Fixed hShift, */ 1101 CF2_ArrStack hStemHintArray, 1102 CF2_ArrStack vStemHintArray, 1103 CF2_HintMask hintMask, 1104 CF2_Fixed hintOriginY, 1105 const CF2_Blues blues, 1106 const FT_Vector* fractionalTranslation ) 1107 { 1108 FT_ZERO( glyphpath ); 1109 1110 glyphpath->font = font; 1111 glyphpath->callbacks = callbacks; 1112 1113 cf2_arrstack_init( &glyphpath->hintMoves, 1114 font->memory, 1115 &font->error, 1116 sizeof ( CF2_HintMoveRec ) ); 1117 1118 cf2_hintmap_init( &glyphpath->initialHintMap, 1119 font, 1120 &glyphpath->initialHintMap, 1121 &glyphpath->hintMoves, 1122 scaleY ); 1123 cf2_hintmap_init( &glyphpath->firstHintMap, 1124 font, 1125 &glyphpath->initialHintMap, 1126 &glyphpath->hintMoves, 1127 scaleY ); 1128 cf2_hintmap_init( &glyphpath->hintMap, 1129 font, 1130 &glyphpath->initialHintMap, 1131 &glyphpath->hintMoves, 1132 scaleY ); 1133 1134 glyphpath->scaleX = font->innerTransform.a; 1135 glyphpath->scaleC = font->innerTransform.c; 1136 glyphpath->scaleY = font->innerTransform.d; 1137 1138 glyphpath->fractionalTranslation = *fractionalTranslation; 1139 1140 #if 0 1141 glyphpath->hShift = hShift; /* for fauxing */ 1142 #endif 1143 1144 glyphpath->hStemHintArray = hStemHintArray; 1145 glyphpath->vStemHintArray = vStemHintArray; 1146 glyphpath->hintMask = hintMask; /* ptr to current mask */ 1147 glyphpath->hintOriginY = hintOriginY; 1148 glyphpath->blues = blues; 1149 glyphpath->darken = font->darkened; /* TODO: should we make copies? */ 1150 glyphpath->xOffset = font->darkenX; 1151 glyphpath->yOffset = font->darkenY; 1152 glyphpath->miterLimit = 2 * FT_MAX( 1153 cf2_fixedAbs( glyphpath->xOffset ), 1154 cf2_fixedAbs( glyphpath->yOffset ) ); 1155 1156 /* .1 character space unit */ 1157 glyphpath->snapThreshold = cf2_doubleToFixed( 0.1 ); 1158 1159 glyphpath->moveIsPending = TRUE; 1160 glyphpath->pathIsOpen = FALSE; 1161 glyphpath->pathIsClosing = FALSE; 1162 glyphpath->elemIsQueued = FALSE; 1163 } 1164 1165 1166 FT_LOCAL_DEF( void ) cf2_glyphpath_finalize(CF2_GlyphPath glyphpath)1167 cf2_glyphpath_finalize( CF2_GlyphPath glyphpath ) 1168 { 1169 cf2_arrstack_finalize( &glyphpath->hintMoves ); 1170 } 1171 1172 1173 /* 1174 * Hint point in y-direction and apply outerTransform. 1175 * Input `current' hint map (which is actually delayed by one element). 1176 * Input x,y point in Character Space. 1177 * Output x,y point in Device Space, including translation. 1178 */ 1179 static void cf2_glyphpath_hintPoint(CF2_GlyphPath glyphpath,CF2_HintMap hintmap,FT_Vector * ppt,CF2_Fixed x,CF2_Fixed y)1180 cf2_glyphpath_hintPoint( CF2_GlyphPath glyphpath, 1181 CF2_HintMap hintmap, 1182 FT_Vector* ppt, 1183 CF2_Fixed x, 1184 CF2_Fixed y ) 1185 { 1186 FT_Vector pt; /* hinted point in upright DS */ 1187 1188 1189 pt.x = ADD_INT32( FT_MulFix( glyphpath->scaleX, x ), 1190 FT_MulFix( glyphpath->scaleC, y ) ); 1191 pt.y = cf2_hintmap_map( hintmap, y ); 1192 1193 ppt->x = ADD_INT32( 1194 FT_MulFix( glyphpath->font->outerTransform.a, pt.x ), 1195 ADD_INT32( 1196 FT_MulFix( glyphpath->font->outerTransform.c, pt.y ), 1197 glyphpath->fractionalTranslation.x ) ); 1198 ppt->y = ADD_INT32( 1199 FT_MulFix( glyphpath->font->outerTransform.b, pt.x ), 1200 ADD_INT32( 1201 FT_MulFix( glyphpath->font->outerTransform.d, pt.y ), 1202 glyphpath->fractionalTranslation.y ) ); 1203 } 1204 1205 1206 /* 1207 * From two line segments, (u1,u2) and (v1,v2), compute a point of 1208 * intersection on the corresponding lines. 1209 * Return false if no intersection is found, or if the intersection is 1210 * too far away from the ends of the line segments, u2 and v1. 1211 * 1212 */ 1213 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)1214 cf2_glyphpath_computeIntersection( CF2_GlyphPath glyphpath, 1215 const FT_Vector* u1, 1216 const FT_Vector* u2, 1217 const FT_Vector* v1, 1218 const FT_Vector* v2, 1219 FT_Vector* intersection ) 1220 { 1221 /* 1222 * Let `u' be a zero-based vector from the first segment, `v' from the 1223 * second segment. 1224 * Let `w 'be the zero-based vector from `u1' to `v1'. 1225 * `perp' is the `perpendicular dot product'; see 1226 * https://mathworld.wolfram.com/PerpDotProduct.html. 1227 * `s' is the parameter for the parametric line for the first segment 1228 * (`u'). 1229 * 1230 * See notation in 1231 * http://geomalgorithms.com/a05-_intersect-1.html. 1232 * Calculations are done in 16.16, but must handle the squaring of 1233 * line lengths in character space. We scale all vectors by 1/32 to 1234 * avoid overflow. This allows values up to 4095 to be squared. The 1235 * scale factor cancels in the divide. 1236 * 1237 * TODO: the scale factor could be computed from UnitsPerEm. 1238 * 1239 */ 1240 1241 #define cf2_perp( a, b ) \ 1242 ( FT_MulFix( a.x, b.y ) - FT_MulFix( a.y, b.x ) ) 1243 1244 /* round and divide by 32 */ 1245 #define CF2_CS_SCALE( x ) \ 1246 ( ( (x) + 0x10 ) >> 5 ) 1247 1248 FT_Vector u, v, w; /* scaled vectors */ 1249 CF2_Fixed denominator, s; 1250 1251 1252 u.x = CF2_CS_SCALE( SUB_INT32( u2->x, u1->x ) ); 1253 u.y = CF2_CS_SCALE( SUB_INT32( u2->y, u1->y ) ); 1254 v.x = CF2_CS_SCALE( SUB_INT32( v2->x, v1->x ) ); 1255 v.y = CF2_CS_SCALE( SUB_INT32( v2->y, v1->y ) ); 1256 w.x = CF2_CS_SCALE( SUB_INT32( v1->x, u1->x ) ); 1257 w.y = CF2_CS_SCALE( SUB_INT32( v1->y, u1->y ) ); 1258 1259 denominator = cf2_perp( u, v ); 1260 1261 if ( denominator == 0 ) 1262 return FALSE; /* parallel or coincident lines */ 1263 1264 s = FT_DivFix( cf2_perp( w, v ), denominator ); 1265 1266 intersection->x = ADD_INT32( u1->x, 1267 FT_MulFix( s, SUB_INT32( u2->x, u1->x ) ) ); 1268 intersection->y = ADD_INT32( u1->y, 1269 FT_MulFix( s, SUB_INT32( u2->y, u1->y ) ) ); 1270 1271 1272 /* 1273 * Special case snapping for horizontal and vertical lines. 1274 * This cleans up intersections and reduces problems with winding 1275 * order detection. 1276 * Sample case is sbc cd KozGoPr6N-Medium.otf 20 16685. 1277 * Note: these calculations are in character space. 1278 * 1279 */ 1280 1281 if ( u1->x == u2->x && 1282 cf2_fixedAbs( SUB_INT32( intersection->x, 1283 u1->x ) ) < glyphpath->snapThreshold ) 1284 intersection->x = u1->x; 1285 if ( u1->y == u2->y && 1286 cf2_fixedAbs( SUB_INT32( intersection->y, 1287 u1->y ) ) < glyphpath->snapThreshold ) 1288 intersection->y = u1->y; 1289 1290 if ( v1->x == v2->x && 1291 cf2_fixedAbs( SUB_INT32( intersection->x, 1292 v1->x ) ) < glyphpath->snapThreshold ) 1293 intersection->x = v1->x; 1294 if ( v1->y == v2->y && 1295 cf2_fixedAbs( SUB_INT32( intersection->y, 1296 v1->y ) ) < glyphpath->snapThreshold ) 1297 intersection->y = v1->y; 1298 1299 /* limit the intersection distance from midpoint of u2 and v1 */ 1300 if ( cf2_fixedAbs( intersection->x - ADD_INT32( u2->x, v1->x ) / 2 ) > 1301 glyphpath->miterLimit || 1302 cf2_fixedAbs( intersection->y - ADD_INT32( u2->y, v1->y ) / 2 ) > 1303 glyphpath->miterLimit ) 1304 return FALSE; 1305 1306 return TRUE; 1307 } 1308 1309 1310 /* 1311 * Push the cached element (glyphpath->prevElem*) to the outline 1312 * consumer. When a darkening offset is used, the end point of the 1313 * cached element may be adjusted to an intersection point or we may 1314 * synthesize a connecting line to the current element. If we are 1315 * closing a subpath, we may also generate a connecting line to the start 1316 * point. 1317 * 1318 * This is where Character Space (CS) is converted to Device Space (DS) 1319 * using a hint map. This calculation must use a HintMap that was valid 1320 * at the time the element was saved. For the first point in a subpath, 1321 * that is a saved HintMap. For most elements, it just means the caller 1322 * has delayed building a HintMap from the current HintMask. 1323 * 1324 * Transform each point with outerTransform and call the outline 1325 * callbacks. This is a general 3x3 transform: 1326 * 1327 * x' = a*x + c*y + tx, y' = b*x + d*y + ty 1328 * 1329 * but it uses 4 elements from CF2_Font and the translation part 1330 * from CF2_GlyphPath. 1331 * 1332 */ 1333 static void cf2_glyphpath_pushPrevElem(CF2_GlyphPath glyphpath,CF2_HintMap hintmap,FT_Vector * nextP0,FT_Vector nextP1,FT_Bool close)1334 cf2_glyphpath_pushPrevElem( CF2_GlyphPath glyphpath, 1335 CF2_HintMap hintmap, 1336 FT_Vector* nextP0, 1337 FT_Vector nextP1, 1338 FT_Bool close ) 1339 { 1340 CF2_CallbackParamsRec params; 1341 1342 FT_Vector* prevP0; 1343 FT_Vector* prevP1; 1344 1345 FT_Vector intersection = { 0, 0 }; 1346 FT_Bool useIntersection = FALSE; 1347 1348 1349 FT_ASSERT( glyphpath->prevElemOp == CF2_PathOpLineTo || 1350 glyphpath->prevElemOp == CF2_PathOpCubeTo ); 1351 1352 if ( glyphpath->prevElemOp == CF2_PathOpLineTo ) 1353 { 1354 prevP0 = &glyphpath->prevElemP0; 1355 prevP1 = &glyphpath->prevElemP1; 1356 } 1357 else 1358 { 1359 prevP0 = &glyphpath->prevElemP2; 1360 prevP1 = &glyphpath->prevElemP3; 1361 } 1362 1363 /* optimization: if previous and next elements are offset by the same */ 1364 /* amount, then there will be no gap, and no need to compute an */ 1365 /* intersection. */ 1366 if ( prevP1->x != nextP0->x || prevP1->y != nextP0->y ) 1367 { 1368 /* previous element does not join next element: */ 1369 /* adjust end point of previous element to the intersection */ 1370 useIntersection = cf2_glyphpath_computeIntersection( glyphpath, 1371 prevP0, 1372 prevP1, 1373 nextP0, 1374 &nextP1, 1375 &intersection ); 1376 if ( useIntersection ) 1377 { 1378 /* modify the last point of the cached element (either line or */ 1379 /* curve) */ 1380 *prevP1 = intersection; 1381 } 1382 } 1383 1384 params.pt0 = glyphpath->currentDS; 1385 1386 switch( glyphpath->prevElemOp ) 1387 { 1388 case CF2_PathOpLineTo: 1389 params.op = CF2_PathOpLineTo; 1390 1391 /* note: pt2 and pt3 are unused */ 1392 1393 if ( close ) 1394 { 1395 /* use first hint map if closing */ 1396 cf2_glyphpath_hintPoint( glyphpath, 1397 &glyphpath->firstHintMap, 1398 ¶ms.pt1, 1399 glyphpath->prevElemP1.x, 1400 glyphpath->prevElemP1.y ); 1401 } 1402 else 1403 { 1404 cf2_glyphpath_hintPoint( glyphpath, 1405 hintmap, 1406 ¶ms.pt1, 1407 glyphpath->prevElemP1.x, 1408 glyphpath->prevElemP1.y ); 1409 } 1410 1411 /* output only non-zero length lines */ 1412 if ( params.pt0.x != params.pt1.x || params.pt0.y != params.pt1.y ) 1413 { 1414 glyphpath->callbacks->lineTo( glyphpath->callbacks, ¶ms ); 1415 1416 glyphpath->currentDS = params.pt1; 1417 } 1418 break; 1419 1420 case CF2_PathOpCubeTo: 1421 params.op = CF2_PathOpCubeTo; 1422 1423 /* TODO: should we intersect the interior joins (p1-p2 and p2-p3)? */ 1424 cf2_glyphpath_hintPoint( glyphpath, 1425 hintmap, 1426 ¶ms.pt1, 1427 glyphpath->prevElemP1.x, 1428 glyphpath->prevElemP1.y ); 1429 cf2_glyphpath_hintPoint( glyphpath, 1430 hintmap, 1431 ¶ms.pt2, 1432 glyphpath->prevElemP2.x, 1433 glyphpath->prevElemP2.y ); 1434 cf2_glyphpath_hintPoint( glyphpath, 1435 hintmap, 1436 ¶ms.pt3, 1437 glyphpath->prevElemP3.x, 1438 glyphpath->prevElemP3.y ); 1439 1440 glyphpath->callbacks->cubeTo( glyphpath->callbacks, ¶ms ); 1441 1442 glyphpath->currentDS = params.pt3; 1443 1444 break; 1445 } 1446 1447 if ( !useIntersection || close ) 1448 { 1449 /* insert connecting line between end of previous element and start */ 1450 /* of current one */ 1451 /* note: at the end of a subpath, we might do both, so use `nextP0' */ 1452 /* before we change it, below */ 1453 1454 if ( close ) 1455 { 1456 /* if we are closing the subpath, then nextP0 is in the first */ 1457 /* hint zone */ 1458 cf2_glyphpath_hintPoint( glyphpath, 1459 &glyphpath->firstHintMap, 1460 ¶ms.pt1, 1461 nextP0->x, 1462 nextP0->y ); 1463 } 1464 else 1465 { 1466 cf2_glyphpath_hintPoint( glyphpath, 1467 hintmap, 1468 ¶ms.pt1, 1469 nextP0->x, 1470 nextP0->y ); 1471 } 1472 1473 if ( params.pt1.x != glyphpath->currentDS.x || 1474 params.pt1.y != glyphpath->currentDS.y ) 1475 { 1476 /* length is nonzero */ 1477 params.op = CF2_PathOpLineTo; 1478 params.pt0 = glyphpath->currentDS; 1479 1480 /* note: pt2 and pt3 are unused */ 1481 glyphpath->callbacks->lineTo( glyphpath->callbacks, ¶ms ); 1482 1483 glyphpath->currentDS = params.pt1; 1484 } 1485 } 1486 1487 if ( useIntersection ) 1488 { 1489 /* return intersection point to caller */ 1490 *nextP0 = intersection; 1491 } 1492 } 1493 1494 1495 /* push a MoveTo element based on current point and offset of current */ 1496 /* element */ 1497 static void cf2_glyphpath_pushMove(CF2_GlyphPath glyphpath,FT_Vector start)1498 cf2_glyphpath_pushMove( CF2_GlyphPath glyphpath, 1499 FT_Vector start ) 1500 { 1501 CF2_CallbackParamsRec params; 1502 1503 1504 params.op = CF2_PathOpMoveTo; 1505 params.pt0 = glyphpath->currentDS; 1506 1507 /* Test if move has really happened yet; it would have called */ 1508 /* `cf2_hintmap_build' to set `isValid'. */ 1509 if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) ) 1510 { 1511 /* we are here iff first subpath is missing a moveto operator: */ 1512 /* synthesize first moveTo to finish initialization of hintMap */ 1513 cf2_glyphpath_moveTo( glyphpath, 1514 glyphpath->start.x, 1515 glyphpath->start.y ); 1516 } 1517 1518 cf2_glyphpath_hintPoint( glyphpath, 1519 &glyphpath->hintMap, 1520 ¶ms.pt1, 1521 start.x, 1522 start.y ); 1523 1524 /* note: pt2 and pt3 are unused */ 1525 glyphpath->callbacks->moveTo( glyphpath->callbacks, ¶ms ); 1526 1527 glyphpath->currentDS = params.pt1; 1528 glyphpath->offsetStart0 = start; 1529 } 1530 1531 1532 /* 1533 * All coordinates are in character space. 1534 * On input, (x1, y1) and (x2, y2) give line segment. 1535 * On output, (x, y) give offset vector. 1536 * We use a piecewise approximation to trig functions. 1537 * 1538 * TODO: Offset true perpendicular and proper length 1539 * supply the y-translation for hinting here, too, 1540 * that adds yOffset unconditionally to *y. 1541 */ 1542 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)1543 cf2_glyphpath_computeOffset( CF2_GlyphPath glyphpath, 1544 CF2_Fixed x1, 1545 CF2_Fixed y1, 1546 CF2_Fixed x2, 1547 CF2_Fixed y2, 1548 CF2_Fixed* x, 1549 CF2_Fixed* y ) 1550 { 1551 CF2_Fixed dx = SUB_INT32( x2, x1 ); 1552 CF2_Fixed dy = SUB_INT32( y2, y1 ); 1553 1554 1555 /* note: negative offsets don't work here; negate deltas to change */ 1556 /* quadrants, below */ 1557 if ( glyphpath->font->reverseWinding ) 1558 { 1559 dx = NEG_INT32( dx ); 1560 dy = NEG_INT32( dy ); 1561 } 1562 1563 *x = *y = 0; 1564 1565 if ( !glyphpath->darken ) 1566 return; 1567 1568 /* add momentum for this path element */ 1569 glyphpath->callbacks->windingMomentum = 1570 ADD_INT32( glyphpath->callbacks->windingMomentum, 1571 cf2_getWindingMomentum( x1, y1, x2, y2 ) ); 1572 1573 /* note: allow mixed integer and fixed multiplication here */ 1574 if ( dx >= 0 ) 1575 { 1576 if ( dy >= 0 ) 1577 { 1578 /* first quadrant, +x +y */ 1579 1580 if ( dx > MUL_INT32( 2, dy ) ) 1581 { 1582 /* +x */ 1583 *x = 0; 1584 *y = 0; 1585 } 1586 else if ( dy > MUL_INT32( 2, dx ) ) 1587 { 1588 /* +y */ 1589 *x = glyphpath->xOffset; 1590 *y = glyphpath->yOffset; 1591 } 1592 else 1593 { 1594 /* +x +y */ 1595 *x = FT_MulFix( cf2_doubleToFixed( 0.7 ), 1596 glyphpath->xOffset ); 1597 *y = FT_MulFix( cf2_doubleToFixed( 1.0 - 0.7 ), 1598 glyphpath->yOffset ); 1599 } 1600 } 1601 else 1602 { 1603 /* fourth quadrant, +x -y */ 1604 1605 if ( dx > MUL_INT32( -2, dy ) ) 1606 { 1607 /* +x */ 1608 *x = 0; 1609 *y = 0; 1610 } 1611 else if ( NEG_INT32( dy ) > MUL_INT32( 2, dx ) ) 1612 { 1613 /* -y */ 1614 *x = NEG_INT32( glyphpath->xOffset ); 1615 *y = glyphpath->yOffset; 1616 } 1617 else 1618 { 1619 /* +x -y */ 1620 *x = FT_MulFix( cf2_doubleToFixed( -0.7 ), 1621 glyphpath->xOffset ); 1622 *y = FT_MulFix( cf2_doubleToFixed( 1.0 - 0.7 ), 1623 glyphpath->yOffset ); 1624 } 1625 } 1626 } 1627 else 1628 { 1629 if ( dy >= 0 ) 1630 { 1631 /* second quadrant, -x +y */ 1632 1633 if ( NEG_INT32( dx ) > MUL_INT32( 2, dy ) ) 1634 { 1635 /* -x */ 1636 *x = 0; 1637 *y = MUL_INT32( 2, glyphpath->yOffset ); 1638 } 1639 else if ( dy > MUL_INT32( -2, dx ) ) 1640 { 1641 /* +y */ 1642 *x = glyphpath->xOffset; 1643 *y = glyphpath->yOffset; 1644 } 1645 else 1646 { 1647 /* -x +y */ 1648 *x = FT_MulFix( cf2_doubleToFixed( 0.7 ), 1649 glyphpath->xOffset ); 1650 *y = FT_MulFix( cf2_doubleToFixed( 1.0 + 0.7 ), 1651 glyphpath->yOffset ); 1652 } 1653 } 1654 else 1655 { 1656 /* third quadrant, -x -y */ 1657 1658 if ( NEG_INT32( dx ) > MUL_INT32( -2, dy ) ) 1659 { 1660 /* -x */ 1661 *x = 0; 1662 *y = MUL_INT32( 2, glyphpath->yOffset ); 1663 } 1664 else if ( NEG_INT32( dy ) > MUL_INT32( -2, dx ) ) 1665 { 1666 /* -y */ 1667 *x = NEG_INT32( glyphpath->xOffset ); 1668 *y = glyphpath->yOffset; 1669 } 1670 else 1671 { 1672 /* -x -y */ 1673 *x = FT_MulFix( cf2_doubleToFixed( -0.7 ), 1674 glyphpath->xOffset ); 1675 *y = FT_MulFix( cf2_doubleToFixed( 1.0 + 0.7 ), 1676 glyphpath->yOffset ); 1677 } 1678 } 1679 } 1680 } 1681 1682 1683 /* 1684 * The functions cf2_glyphpath_{moveTo,lineTo,curveTo,closeOpenPath} are 1685 * called by the interpreter with Character Space (CS) coordinates. Each 1686 * path element is placed into a queue of length one to await the 1687 * calculation of the following element. At that time, the darkening 1688 * offset of the following element is known and joins can be computed, 1689 * including possible modification of this element, before mapping to 1690 * Device Space (DS) and passing it on to the outline consumer. 1691 * 1692 */ 1693 FT_LOCAL_DEF( void ) cf2_glyphpath_moveTo(CF2_GlyphPath glyphpath,CF2_Fixed x,CF2_Fixed y)1694 cf2_glyphpath_moveTo( CF2_GlyphPath glyphpath, 1695 CF2_Fixed x, 1696 CF2_Fixed y ) 1697 { 1698 cf2_glyphpath_closeOpenPath( glyphpath ); 1699 1700 /* save the parameters of the move for later, when we'll know how to */ 1701 /* offset it; */ 1702 /* also save last move point */ 1703 glyphpath->currentCS.x = glyphpath->start.x = x; 1704 glyphpath->currentCS.y = glyphpath->start.y = y; 1705 1706 glyphpath->moveIsPending = TRUE; 1707 1708 /* ensure we have a valid map with current mask */ 1709 if ( !cf2_hintmap_isValid( &glyphpath->hintMap ) || 1710 cf2_hintmask_isNew( glyphpath->hintMask ) ) 1711 cf2_hintmap_build( &glyphpath->hintMap, 1712 glyphpath->hStemHintArray, 1713 glyphpath->vStemHintArray, 1714 glyphpath->hintMask, 1715 glyphpath->hintOriginY, 1716 FALSE ); 1717 1718 /* save a copy of current HintMap to use when drawing initial point */ 1719 glyphpath->firstHintMap = glyphpath->hintMap; /* structure copy */ 1720 } 1721 1722 1723 FT_LOCAL_DEF( void ) cf2_glyphpath_lineTo(CF2_GlyphPath glyphpath,CF2_Fixed x,CF2_Fixed y)1724 cf2_glyphpath_lineTo( CF2_GlyphPath glyphpath, 1725 CF2_Fixed x, 1726 CF2_Fixed y ) 1727 { 1728 CF2_Fixed xOffset, yOffset; 1729 FT_Vector P0, P1; 1730 FT_Bool newHintMap; 1731 1732 /* 1733 * New hints will be applied after cf2_glyphpath_pushPrevElem has run. 1734 * In case this is a synthesized closing line, any new hints should be 1735 * delayed until this path is closed (`cf2_hintmask_isNew' will be 1736 * called again before the next line or curve). 1737 */ 1738 1739 /* true if new hint map not on close */ 1740 newHintMap = cf2_hintmask_isNew( glyphpath->hintMask ) && 1741 !glyphpath->pathIsClosing; 1742 1743 /* 1744 * Zero-length lines may occur in the charstring. Because we cannot 1745 * compute darkening offsets or intersections from zero-length lines, 1746 * it is best to remove them and avoid artifacts. However, zero-length 1747 * lines in CS at the start of a new hint map can generate non-zero 1748 * lines in DS due to hint substitution. We detect a change in hint 1749 * map here and pass those zero-length lines along. 1750 */ 1751 1752 /* 1753 * Note: Find explicitly closed paths here with a conditional 1754 * breakpoint using 1755 * 1756 * !gp->pathIsClosing && gp->start.x == x && gp->start.y == y 1757 * 1758 */ 1759 1760 if ( glyphpath->currentCS.x == x && 1761 glyphpath->currentCS.y == y && 1762 !newHintMap ) 1763 /* 1764 * Ignore zero-length lines in CS where the hint map is the same 1765 * because the line in DS will also be zero length. 1766 * 1767 * Ignore zero-length lines when we synthesize a closing line because 1768 * the close will be handled in cf2_glyphPath_pushPrevElem. 1769 */ 1770 return; 1771 1772 cf2_glyphpath_computeOffset( glyphpath, 1773 glyphpath->currentCS.x, 1774 glyphpath->currentCS.y, 1775 x, 1776 y, 1777 &xOffset, 1778 &yOffset ); 1779 1780 /* construct offset points */ 1781 P0.x = ADD_INT32( glyphpath->currentCS.x, xOffset ); 1782 P0.y = ADD_INT32( glyphpath->currentCS.y, yOffset ); 1783 P1.x = ADD_INT32( x, xOffset ); 1784 P1.y = ADD_INT32( y, yOffset ); 1785 1786 if ( glyphpath->moveIsPending ) 1787 { 1788 /* emit offset 1st point as MoveTo */ 1789 cf2_glyphpath_pushMove( glyphpath, P0 ); 1790 1791 glyphpath->moveIsPending = FALSE; /* adjust state machine */ 1792 glyphpath->pathIsOpen = TRUE; 1793 1794 glyphpath->offsetStart1 = P1; /* record second point */ 1795 } 1796 1797 if ( glyphpath->elemIsQueued ) 1798 { 1799 FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) || 1800 glyphpath->hintMap.count == 0 ); 1801 1802 cf2_glyphpath_pushPrevElem( glyphpath, 1803 &glyphpath->hintMap, 1804 &P0, 1805 P1, 1806 FALSE ); 1807 } 1808 1809 /* queue the current element with offset points */ 1810 glyphpath->elemIsQueued = TRUE; 1811 glyphpath->prevElemOp = CF2_PathOpLineTo; 1812 glyphpath->prevElemP0 = P0; 1813 glyphpath->prevElemP1 = P1; 1814 1815 /* update current map */ 1816 if ( newHintMap ) 1817 cf2_hintmap_build( &glyphpath->hintMap, 1818 glyphpath->hStemHintArray, 1819 glyphpath->vStemHintArray, 1820 glyphpath->hintMask, 1821 glyphpath->hintOriginY, 1822 FALSE ); 1823 1824 glyphpath->currentCS.x = x; /* pre-offset current point */ 1825 glyphpath->currentCS.y = y; 1826 } 1827 1828 1829 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)1830 cf2_glyphpath_curveTo( CF2_GlyphPath glyphpath, 1831 CF2_Fixed x1, 1832 CF2_Fixed y1, 1833 CF2_Fixed x2, 1834 CF2_Fixed y2, 1835 CF2_Fixed x3, 1836 CF2_Fixed y3 ) 1837 { 1838 CF2_Fixed xOffset1, yOffset1, xOffset3, yOffset3; 1839 FT_Vector P0, P1, P2, P3; 1840 1841 1842 /* TODO: ignore zero length portions of curve?? */ 1843 cf2_glyphpath_computeOffset( glyphpath, 1844 glyphpath->currentCS.x, 1845 glyphpath->currentCS.y, 1846 x1, 1847 y1, 1848 &xOffset1, 1849 &yOffset1 ); 1850 cf2_glyphpath_computeOffset( glyphpath, 1851 x2, 1852 y2, 1853 x3, 1854 y3, 1855 &xOffset3, 1856 &yOffset3 ); 1857 1858 /* add momentum from the middle segment */ 1859 glyphpath->callbacks->windingMomentum = 1860 ADD_INT32( glyphpath->callbacks->windingMomentum, 1861 cf2_getWindingMomentum( x1, y1, x2, y2 ) ); 1862 1863 /* construct offset points */ 1864 P0.x = ADD_INT32( glyphpath->currentCS.x, xOffset1 ); 1865 P0.y = ADD_INT32( glyphpath->currentCS.y, yOffset1 ); 1866 P1.x = ADD_INT32( x1, xOffset1 ); 1867 P1.y = ADD_INT32( y1, yOffset1 ); 1868 /* note: preserve angle of final segment by using offset3 at both ends */ 1869 P2.x = ADD_INT32( x2, xOffset3 ); 1870 P2.y = ADD_INT32( y2, yOffset3 ); 1871 P3.x = ADD_INT32( x3, xOffset3 ); 1872 P3.y = ADD_INT32( y3, yOffset3 ); 1873 1874 if ( glyphpath->moveIsPending ) 1875 { 1876 /* emit offset 1st point as MoveTo */ 1877 cf2_glyphpath_pushMove( glyphpath, P0 ); 1878 1879 glyphpath->moveIsPending = FALSE; 1880 glyphpath->pathIsOpen = TRUE; 1881 1882 glyphpath->offsetStart1 = P1; /* record second point */ 1883 } 1884 1885 if ( glyphpath->elemIsQueued ) 1886 { 1887 FT_ASSERT( cf2_hintmap_isValid( &glyphpath->hintMap ) || 1888 glyphpath->hintMap.count == 0 ); 1889 1890 cf2_glyphpath_pushPrevElem( glyphpath, 1891 &glyphpath->hintMap, 1892 &P0, 1893 P1, 1894 FALSE ); 1895 } 1896 1897 /* queue the current element with offset points */ 1898 glyphpath->elemIsQueued = TRUE; 1899 glyphpath->prevElemOp = CF2_PathOpCubeTo; 1900 glyphpath->prevElemP0 = P0; 1901 glyphpath->prevElemP1 = P1; 1902 glyphpath->prevElemP2 = P2; 1903 glyphpath->prevElemP3 = P3; 1904 1905 /* update current map */ 1906 if ( cf2_hintmask_isNew( glyphpath->hintMask ) ) 1907 cf2_hintmap_build( &glyphpath->hintMap, 1908 glyphpath->hStemHintArray, 1909 glyphpath->vStemHintArray, 1910 glyphpath->hintMask, 1911 glyphpath->hintOriginY, 1912 FALSE ); 1913 1914 glyphpath->currentCS.x = x3; /* pre-offset current point */ 1915 glyphpath->currentCS.y = y3; 1916 } 1917 1918 1919 FT_LOCAL_DEF( void ) cf2_glyphpath_closeOpenPath(CF2_GlyphPath glyphpath)1920 cf2_glyphpath_closeOpenPath( CF2_GlyphPath glyphpath ) 1921 { 1922 if ( glyphpath->pathIsOpen ) 1923 { 1924 /* 1925 * A closing line in Character Space line is always generated below 1926 * with `cf2_glyphPath_lineTo'. It may be ignored later if it turns 1927 * out to be zero length in Device Space. 1928 */ 1929 glyphpath->pathIsClosing = TRUE; 1930 1931 cf2_glyphpath_lineTo( glyphpath, 1932 glyphpath->start.x, 1933 glyphpath->start.y ); 1934 1935 /* empty the final element from the queue and close the path */ 1936 if ( glyphpath->elemIsQueued ) 1937 cf2_glyphpath_pushPrevElem( glyphpath, 1938 &glyphpath->hintMap, 1939 &glyphpath->offsetStart0, 1940 glyphpath->offsetStart1, 1941 TRUE ); 1942 1943 /* reset state machine */ 1944 glyphpath->moveIsPending = TRUE; 1945 glyphpath->pathIsOpen = FALSE; 1946 glyphpath->pathIsClosing = FALSE; 1947 glyphpath->elemIsQueued = FALSE; 1948 } 1949 } 1950 1951 1952 /* END */ 1953