1 /***************************************************************************/ 2 /* */ 3 /* ftstroke.c */ 4 /* */ 5 /* FreeType path stroker (body). */ 6 /* */ 7 /* Copyright 2002, 2003, 2004, 2005, 2006, 2008, 2009, 2010 by */ 8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9 /* */ 10 /* This file is part of the FreeType project, and may only be used, */ 11 /* modified, and distributed under the terms of the FreeType project */ 12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13 /* this file you indicate that you have read the license and */ 14 /* understand and accept it fully. */ 15 /* */ 16 /***************************************************************************/ 17 18 19 #include <ft2build.h> 20 #include FT_STROKER_H 21 #include FT_TRIGONOMETRY_H 22 #include FT_OUTLINE_H 23 #include FT_INTERNAL_MEMORY_H 24 #include FT_INTERNAL_DEBUG_H 25 #include FT_INTERNAL_OBJECTS_H 26 27 28 /* documentation is in ftstroke.h */ 29 30 FT_EXPORT_DEF( FT_StrokerBorder ) 31 FT_Outline_GetInsideBorder( FT_Outline* outline ) 32 { 33 FT_Orientation o = FT_Outline_Get_Orientation( outline ); 34 35 36 return o == FT_ORIENTATION_TRUETYPE ? FT_STROKER_BORDER_RIGHT 37 : FT_STROKER_BORDER_LEFT ; 38 } 39 40 41 /* documentation is in ftstroke.h */ 42 43 FT_EXPORT_DEF( FT_StrokerBorder ) 44 FT_Outline_GetOutsideBorder( FT_Outline* outline ) 45 { 46 FT_Orientation o = FT_Outline_Get_Orientation( outline ); 47 48 49 return o == FT_ORIENTATION_TRUETYPE ? FT_STROKER_BORDER_LEFT 50 : FT_STROKER_BORDER_RIGHT ; 51 } 52 53 54 /***************************************************************************/ 55 /***************************************************************************/ 56 /***** *****/ 57 /***** BEZIER COMPUTATIONS *****/ 58 /***** *****/ 59 /***************************************************************************/ 60 /***************************************************************************/ 61 62 #define FT_SMALL_CONIC_THRESHOLD ( FT_ANGLE_PI / 6 ) 63 #define FT_SMALL_CUBIC_THRESHOLD ( FT_ANGLE_PI / 6 ) 64 #define FT_EPSILON 2 65 66 #define FT_IS_SMALL( x ) ( (x) > -FT_EPSILON && (x) < FT_EPSILON ) 67 68 69 static FT_Pos 70 ft_pos_abs( FT_Pos x ) 71 { 72 return x >= 0 ? x : -x ; 73 } 74 75 76 static void 77 ft_conic_split( FT_Vector* base ) 78 { 79 FT_Pos a, b; 80 81 82 base[4].x = base[2].x; 83 b = base[1].x; 84 a = base[3].x = ( base[2].x + b ) / 2; 85 b = base[1].x = ( base[0].x + b ) / 2; 86 base[2].x = ( a + b ) / 2; 87 88 base[4].y = base[2].y; 89 b = base[1].y; 90 a = base[3].y = ( base[2].y + b ) / 2; 91 b = base[1].y = ( base[0].y + b ) / 2; 92 base[2].y = ( a + b ) / 2; 93 } 94 95 96 static FT_Bool 97 ft_conic_is_small_enough( FT_Vector* base, 98 FT_Angle *angle_in, 99 FT_Angle *angle_out ) 100 { 101 FT_Vector d1, d2; 102 FT_Angle theta; 103 FT_Int close1, close2; 104 105 106 d1.x = base[1].x - base[2].x; 107 d1.y = base[1].y - base[2].y; 108 d2.x = base[0].x - base[1].x; 109 d2.y = base[0].y - base[1].y; 110 111 close1 = FT_IS_SMALL( d1.x ) && FT_IS_SMALL( d1.y ); 112 close2 = FT_IS_SMALL( d2.x ) && FT_IS_SMALL( d2.y ); 113 114 if ( close1 ) 115 { 116 if ( close2 ) 117 *angle_in = *angle_out = 0; 118 else 119 *angle_in = *angle_out = FT_Atan2( d2.x, d2.y ); 120 } 121 else if ( close2 ) 122 { 123 *angle_in = *angle_out = FT_Atan2( d1.x, d1.y ); 124 } 125 else 126 { 127 *angle_in = FT_Atan2( d1.x, d1.y ); 128 *angle_out = FT_Atan2( d2.x, d2.y ); 129 } 130 131 theta = ft_pos_abs( FT_Angle_Diff( *angle_in, *angle_out ) ); 132 133 return FT_BOOL( theta < FT_SMALL_CONIC_THRESHOLD ); 134 } 135 136 137 static void 138 ft_cubic_split( FT_Vector* base ) 139 { 140 FT_Pos a, b, c, d; 141 142 143 base[6].x = base[3].x; 144 c = base[1].x; 145 d = base[2].x; 146 base[1].x = a = ( base[0].x + c ) / 2; 147 base[5].x = b = ( base[3].x + d ) / 2; 148 c = ( c + d ) / 2; 149 base[2].x = a = ( a + c ) / 2; 150 base[4].x = b = ( b + c ) / 2; 151 base[3].x = ( a + b ) / 2; 152 153 base[6].y = base[3].y; 154 c = base[1].y; 155 d = base[2].y; 156 base[1].y = a = ( base[0].y + c ) / 2; 157 base[5].y = b = ( base[3].y + d ) / 2; 158 c = ( c + d ) / 2; 159 base[2].y = a = ( a + c ) / 2; 160 base[4].y = b = ( b + c ) / 2; 161 base[3].y = ( a + b ) / 2; 162 } 163 164 165 static FT_Bool 166 ft_cubic_is_small_enough( FT_Vector* base, 167 FT_Angle *angle_in, 168 FT_Angle *angle_mid, 169 FT_Angle *angle_out ) 170 { 171 FT_Vector d1, d2, d3; 172 FT_Angle theta1, theta2; 173 FT_Int close1, close2, close3; 174 175 176 d1.x = base[2].x - base[3].x; 177 d1.y = base[2].y - base[3].y; 178 d2.x = base[1].x - base[2].x; 179 d2.y = base[1].y - base[2].y; 180 d3.x = base[0].x - base[1].x; 181 d3.y = base[0].y - base[1].y; 182 183 close1 = FT_IS_SMALL( d1.x ) && FT_IS_SMALL( d1.y ); 184 close2 = FT_IS_SMALL( d2.x ) && FT_IS_SMALL( d2.y ); 185 close3 = FT_IS_SMALL( d3.x ) && FT_IS_SMALL( d3.y ); 186 187 if ( close1 || close3 ) 188 { 189 if ( close2 ) 190 { 191 /* basically a point */ 192 *angle_in = *angle_out = *angle_mid = 0; 193 } 194 else if ( close1 ) 195 { 196 *angle_in = *angle_mid = FT_Atan2( d2.x, d2.y ); 197 *angle_out = FT_Atan2( d3.x, d3.y ); 198 } 199 else /* close2 */ 200 { 201 *angle_in = FT_Atan2( d1.x, d1.y ); 202 *angle_mid = *angle_out = FT_Atan2( d2.x, d2.y ); 203 } 204 } 205 else if ( close2 ) 206 { 207 *angle_in = *angle_mid = FT_Atan2( d1.x, d1.y ); 208 *angle_out = FT_Atan2( d3.x, d3.y ); 209 } 210 else 211 { 212 *angle_in = FT_Atan2( d1.x, d1.y ); 213 *angle_mid = FT_Atan2( d2.x, d2.y ); 214 *angle_out = FT_Atan2( d3.x, d3.y ); 215 } 216 217 theta1 = ft_pos_abs( FT_Angle_Diff( *angle_in, *angle_mid ) ); 218 theta2 = ft_pos_abs( FT_Angle_Diff( *angle_mid, *angle_out ) ); 219 220 return FT_BOOL( theta1 < FT_SMALL_CUBIC_THRESHOLD && 221 theta2 < FT_SMALL_CUBIC_THRESHOLD ); 222 } 223 224 225 /***************************************************************************/ 226 /***************************************************************************/ 227 /***** *****/ 228 /***** STROKE BORDERS *****/ 229 /***** *****/ 230 /***************************************************************************/ 231 /***************************************************************************/ 232 233 typedef enum FT_StrokeTags_ 234 { 235 FT_STROKE_TAG_ON = 1, /* on-curve point */ 236 FT_STROKE_TAG_CUBIC = 2, /* cubic off-point */ 237 FT_STROKE_TAG_BEGIN = 4, /* sub-path start */ 238 FT_STROKE_TAG_END = 8 /* sub-path end */ 239 240 } FT_StrokeTags; 241 242 #define FT_STROKE_TAG_BEGIN_END (FT_STROKE_TAG_BEGIN|FT_STROKE_TAG_END) 243 244 typedef struct FT_StrokeBorderRec_ 245 { 246 FT_UInt num_points; 247 FT_UInt max_points; 248 FT_Vector* points; 249 FT_Byte* tags; 250 FT_Bool movable; 251 FT_Int start; /* index of current sub-path start point */ 252 FT_Memory memory; 253 FT_Bool valid; 254 255 } FT_StrokeBorderRec, *FT_StrokeBorder; 256 257 258 static FT_Error 259 ft_stroke_border_grow( FT_StrokeBorder border, 260 FT_UInt new_points ) 261 { 262 FT_UInt old_max = border->max_points; 263 FT_UInt new_max = border->num_points + new_points; 264 FT_Error error = FT_Err_Ok; 265 266 267 if ( new_max > old_max ) 268 { 269 FT_UInt cur_max = old_max; 270 FT_Memory memory = border->memory; 271 272 273 while ( cur_max < new_max ) 274 cur_max += ( cur_max >> 1 ) + 16; 275 276 if ( FT_RENEW_ARRAY( border->points, old_max, cur_max ) || 277 FT_RENEW_ARRAY( border->tags, old_max, cur_max ) ) 278 goto Exit; 279 280 border->max_points = cur_max; 281 } 282 283 Exit: 284 return error; 285 } 286 287 288 static void 289 ft_stroke_border_close( FT_StrokeBorder border, 290 FT_Bool reverse ) 291 { 292 FT_UInt start = border->start; 293 FT_UInt count = border->num_points; 294 295 296 FT_ASSERT( border->start >= 0 ); 297 298 /* don't record empty paths! */ 299 if ( count <= start + 1U ) 300 border->num_points = start; 301 else 302 { 303 /* copy the last point to the start of this sub-path, since */ 304 /* it contains the `adjusted' starting coordinates */ 305 border->num_points = --count; 306 border->points[start] = border->points[count]; 307 308 if ( reverse ) 309 { 310 /* reverse the points */ 311 { 312 FT_Vector* vec1 = border->points + start + 1; 313 FT_Vector* vec2 = border->points + count - 1; 314 315 316 for ( ; vec1 < vec2; vec1++, vec2-- ) 317 { 318 FT_Vector tmp; 319 320 321 tmp = *vec1; 322 *vec1 = *vec2; 323 *vec2 = tmp; 324 } 325 } 326 327 /* then the tags */ 328 { 329 FT_Byte* tag1 = border->tags + start + 1; 330 FT_Byte* tag2 = border->tags + count - 1; 331 332 333 for ( ; tag1 < tag2; tag1++, tag2-- ) 334 { 335 FT_Byte tmp; 336 337 338 tmp = *tag1; 339 *tag1 = *tag2; 340 *tag2 = tmp; 341 } 342 } 343 } 344 345 border->tags[start ] |= FT_STROKE_TAG_BEGIN; 346 border->tags[count - 1] |= FT_STROKE_TAG_END; 347 } 348 349 border->start = -1; 350 border->movable = FALSE; 351 } 352 353 354 static FT_Error 355 ft_stroke_border_lineto( FT_StrokeBorder border, 356 FT_Vector* to, 357 FT_Bool movable ) 358 { 359 FT_Error error = FT_Err_Ok; 360 361 362 FT_ASSERT( border->start >= 0 ); 363 364 if ( border->movable ) 365 { 366 /* move last point */ 367 border->points[border->num_points - 1] = *to; 368 } 369 else 370 { 371 /* add one point */ 372 error = ft_stroke_border_grow( border, 1 ); 373 if ( !error ) 374 { 375 FT_Vector* vec = border->points + border->num_points; 376 FT_Byte* tag = border->tags + border->num_points; 377 378 379 vec[0] = *to; 380 tag[0] = FT_STROKE_TAG_ON; 381 382 border->num_points += 1; 383 } 384 } 385 border->movable = movable; 386 return error; 387 } 388 389 390 static FT_Error 391 ft_stroke_border_conicto( FT_StrokeBorder border, 392 FT_Vector* control, 393 FT_Vector* to ) 394 { 395 FT_Error error; 396 397 398 FT_ASSERT( border->start >= 0 ); 399 400 error = ft_stroke_border_grow( border, 2 ); 401 if ( !error ) 402 { 403 FT_Vector* vec = border->points + border->num_points; 404 FT_Byte* tag = border->tags + border->num_points; 405 406 vec[0] = *control; 407 vec[1] = *to; 408 409 tag[0] = 0; 410 tag[1] = FT_STROKE_TAG_ON; 411 412 border->num_points += 2; 413 } 414 border->movable = FALSE; 415 return error; 416 } 417 418 419 static FT_Error 420 ft_stroke_border_cubicto( FT_StrokeBorder border, 421 FT_Vector* control1, 422 FT_Vector* control2, 423 FT_Vector* to ) 424 { 425 FT_Error error; 426 427 428 FT_ASSERT( border->start >= 0 ); 429 430 error = ft_stroke_border_grow( border, 3 ); 431 if ( !error ) 432 { 433 FT_Vector* vec = border->points + border->num_points; 434 FT_Byte* tag = border->tags + border->num_points; 435 436 437 vec[0] = *control1; 438 vec[1] = *control2; 439 vec[2] = *to; 440 441 tag[0] = FT_STROKE_TAG_CUBIC; 442 tag[1] = FT_STROKE_TAG_CUBIC; 443 tag[2] = FT_STROKE_TAG_ON; 444 445 border->num_points += 3; 446 } 447 border->movable = FALSE; 448 return error; 449 } 450 451 452 #define FT_ARC_CUBIC_ANGLE ( FT_ANGLE_PI / 2 ) 453 454 455 static FT_Error 456 ft_stroke_border_arcto( FT_StrokeBorder border, 457 FT_Vector* center, 458 FT_Fixed radius, 459 FT_Angle angle_start, 460 FT_Angle angle_diff ) 461 { 462 FT_Angle total, angle, step, rotate, next, theta; 463 FT_Vector a, b, a2, b2; 464 FT_Fixed length; 465 FT_Error error = FT_Err_Ok; 466 467 468 /* compute start point */ 469 FT_Vector_From_Polar( &a, radius, angle_start ); 470 a.x += center->x; 471 a.y += center->y; 472 473 total = angle_diff; 474 angle = angle_start; 475 rotate = ( angle_diff >= 0 ) ? FT_ANGLE_PI2 : -FT_ANGLE_PI2; 476 477 while ( total != 0 ) 478 { 479 step = total; 480 if ( step > FT_ARC_CUBIC_ANGLE ) 481 step = FT_ARC_CUBIC_ANGLE; 482 483 else if ( step < -FT_ARC_CUBIC_ANGLE ) 484 step = -FT_ARC_CUBIC_ANGLE; 485 486 next = angle + step; 487 theta = step; 488 if ( theta < 0 ) 489 theta = -theta; 490 491 theta >>= 1; 492 493 /* compute end point */ 494 FT_Vector_From_Polar( &b, radius, next ); 495 b.x += center->x; 496 b.y += center->y; 497 498 /* compute first and second control points */ 499 length = FT_MulDiv( radius, FT_Sin( theta ) * 4, 500 ( 0x10000L + FT_Cos( theta ) ) * 3 ); 501 502 FT_Vector_From_Polar( &a2, length, angle + rotate ); 503 a2.x += a.x; 504 a2.y += a.y; 505 506 FT_Vector_From_Polar( &b2, length, next - rotate ); 507 b2.x += b.x; 508 b2.y += b.y; 509 510 /* add cubic arc */ 511 error = ft_stroke_border_cubicto( border, &a2, &b2, &b ); 512 if ( error ) 513 break; 514 515 /* process the rest of the arc ?? */ 516 a = b; 517 total -= step; 518 angle = next; 519 } 520 521 return error; 522 } 523 524 525 static FT_Error 526 ft_stroke_border_moveto( FT_StrokeBorder border, 527 FT_Vector* to ) 528 { 529 /* close current open path if any ? */ 530 if ( border->start >= 0 ) 531 ft_stroke_border_close( border, FALSE ); 532 533 border->start = border->num_points; 534 border->movable = FALSE; 535 536 return ft_stroke_border_lineto( border, to, FALSE ); 537 } 538 539 540 static void 541 ft_stroke_border_init( FT_StrokeBorder border, 542 FT_Memory memory ) 543 { 544 border->memory = memory; 545 border->points = NULL; 546 border->tags = NULL; 547 548 border->num_points = 0; 549 border->max_points = 0; 550 border->start = -1; 551 border->valid = FALSE; 552 } 553 554 555 static void 556 ft_stroke_border_reset( FT_StrokeBorder border ) 557 { 558 border->num_points = 0; 559 border->start = -1; 560 border->valid = FALSE; 561 } 562 563 564 static void 565 ft_stroke_border_done( FT_StrokeBorder border ) 566 { 567 FT_Memory memory = border->memory; 568 569 570 FT_FREE( border->points ); 571 FT_FREE( border->tags ); 572 573 border->num_points = 0; 574 border->max_points = 0; 575 border->start = -1; 576 border->valid = FALSE; 577 } 578 579 580 static FT_Error 581 ft_stroke_border_get_counts( FT_StrokeBorder border, 582 FT_UInt *anum_points, 583 FT_UInt *anum_contours ) 584 { 585 FT_Error error = FT_Err_Ok; 586 FT_UInt num_points = 0; 587 FT_UInt num_contours = 0; 588 589 FT_UInt count = border->num_points; 590 FT_Vector* point = border->points; 591 FT_Byte* tags = border->tags; 592 FT_Int in_contour = 0; 593 594 595 for ( ; count > 0; count--, num_points++, point++, tags++ ) 596 { 597 if ( tags[0] & FT_STROKE_TAG_BEGIN ) 598 { 599 if ( in_contour != 0 ) 600 goto Fail; 601 602 in_contour = 1; 603 } 604 else if ( in_contour == 0 ) 605 goto Fail; 606 607 if ( tags[0] & FT_STROKE_TAG_END ) 608 { 609 in_contour = 0; 610 num_contours++; 611 } 612 } 613 614 if ( in_contour != 0 ) 615 goto Fail; 616 617 border->valid = TRUE; 618 619 Exit: 620 *anum_points = num_points; 621 *anum_contours = num_contours; 622 return error; 623 624 Fail: 625 num_points = 0; 626 num_contours = 0; 627 goto Exit; 628 } 629 630 631 static void 632 ft_stroke_border_export( FT_StrokeBorder border, 633 FT_Outline* outline ) 634 { 635 /* copy point locations */ 636 FT_ARRAY_COPY( outline->points + outline->n_points, 637 border->points, 638 border->num_points ); 639 640 /* copy tags */ 641 { 642 FT_UInt count = border->num_points; 643 FT_Byte* read = border->tags; 644 FT_Byte* write = (FT_Byte*)outline->tags + outline->n_points; 645 646 647 for ( ; count > 0; count--, read++, write++ ) 648 { 649 if ( *read & FT_STROKE_TAG_ON ) 650 *write = FT_CURVE_TAG_ON; 651 else if ( *read & FT_STROKE_TAG_CUBIC ) 652 *write = FT_CURVE_TAG_CUBIC; 653 else 654 *write = FT_CURVE_TAG_CONIC; 655 } 656 } 657 658 /* copy contours */ 659 { 660 FT_UInt count = border->num_points; 661 FT_Byte* tags = border->tags; 662 FT_Short* write = outline->contours + outline->n_contours; 663 FT_Short idx = (FT_Short)outline->n_points; 664 665 666 for ( ; count > 0; count--, tags++, idx++ ) 667 { 668 if ( *tags & FT_STROKE_TAG_END ) 669 { 670 *write++ = idx; 671 outline->n_contours++; 672 } 673 } 674 } 675 676 outline->n_points = (short)( outline->n_points + border->num_points ); 677 678 FT_ASSERT( FT_Outline_Check( outline ) == 0 ); 679 } 680 681 682 /***************************************************************************/ 683 /***************************************************************************/ 684 /***** *****/ 685 /***** STROKER *****/ 686 /***** *****/ 687 /***************************************************************************/ 688 /***************************************************************************/ 689 690 #define FT_SIDE_TO_ROTATE( s ) ( FT_ANGLE_PI2 - (s) * FT_ANGLE_PI ) 691 692 typedef struct FT_StrokerRec_ 693 { 694 FT_Angle angle_in; 695 FT_Angle angle_out; 696 FT_Vector center; 697 FT_Bool first_point; 698 FT_Bool subpath_open; 699 FT_Angle subpath_angle; 700 FT_Vector subpath_start; 701 702 FT_Stroker_LineCap line_cap; 703 FT_Stroker_LineJoin line_join; 704 FT_Fixed miter_limit; 705 FT_Fixed radius; 706 707 FT_Bool valid; 708 FT_StrokeBorderRec borders[2]; 709 FT_Library library; 710 711 } FT_StrokerRec; 712 713 714 /* documentation is in ftstroke.h */ 715 716 FT_EXPORT_DEF( FT_Error ) 717 FT_Stroker_New( FT_Library library, 718 FT_Stroker *astroker ) 719 { 720 FT_Error error; 721 FT_Memory memory; 722 FT_Stroker stroker; 723 724 725 if ( !library ) 726 return FT_Err_Invalid_Argument; 727 728 memory = library->memory; 729 730 if ( !FT_NEW( stroker ) ) 731 { 732 stroker->library = library; 733 734 ft_stroke_border_init( &stroker->borders[0], memory ); 735 ft_stroke_border_init( &stroker->borders[1], memory ); 736 } 737 *astroker = stroker; 738 return error; 739 } 740 741 742 /* documentation is in ftstroke.h */ 743 744 FT_EXPORT_DEF( void ) 745 FT_Stroker_Set( FT_Stroker stroker, 746 FT_Fixed radius, 747 FT_Stroker_LineCap line_cap, 748 FT_Stroker_LineJoin line_join, 749 FT_Fixed miter_limit ) 750 { 751 stroker->radius = radius; 752 stroker->line_cap = line_cap; 753 stroker->line_join = line_join; 754 stroker->miter_limit = miter_limit; 755 756 FT_Stroker_Rewind( stroker ); 757 } 758 759 760 /* documentation is in ftstroke.h */ 761 762 FT_EXPORT_DEF( void ) 763 FT_Stroker_Rewind( FT_Stroker stroker ) 764 { 765 if ( stroker ) 766 { 767 ft_stroke_border_reset( &stroker->borders[0] ); 768 ft_stroke_border_reset( &stroker->borders[1] ); 769 } 770 } 771 772 773 /* documentation is in ftstroke.h */ 774 775 FT_EXPORT_DEF( void ) 776 FT_Stroker_Done( FT_Stroker stroker ) 777 { 778 if ( stroker ) 779 { 780 FT_Memory memory = stroker->library->memory; 781 782 783 ft_stroke_border_done( &stroker->borders[0] ); 784 ft_stroke_border_done( &stroker->borders[1] ); 785 786 stroker->library = NULL; 787 FT_FREE( stroker ); 788 } 789 } 790 791 792 /* creates a circular arc at a corner or cap */ 793 static FT_Error 794 ft_stroker_arcto( FT_Stroker stroker, 795 FT_Int side ) 796 { 797 FT_Angle total, rotate; 798 FT_Fixed radius = stroker->radius; 799 FT_Error error = FT_Err_Ok; 800 FT_StrokeBorder border = stroker->borders + side; 801 802 803 rotate = FT_SIDE_TO_ROTATE( side ); 804 805 total = FT_Angle_Diff( stroker->angle_in, stroker->angle_out ); 806 if ( total == FT_ANGLE_PI ) 807 total = -rotate * 2; 808 809 error = ft_stroke_border_arcto( border, 810 &stroker->center, 811 radius, 812 stroker->angle_in + rotate, 813 total ); 814 border->movable = FALSE; 815 return error; 816 } 817 818 819 /* adds a cap at the end of an opened path */ 820 static FT_Error 821 ft_stroker_cap( FT_Stroker stroker, 822 FT_Angle angle, 823 FT_Int side ) 824 { 825 FT_Error error = FT_Err_Ok; 826 827 828 if ( stroker->line_cap == FT_STROKER_LINECAP_ROUND ) 829 { 830 /* add a round cap */ 831 stroker->angle_in = angle; 832 stroker->angle_out = angle + FT_ANGLE_PI; 833 error = ft_stroker_arcto( stroker, side ); 834 } 835 else if ( stroker->line_cap == FT_STROKER_LINECAP_SQUARE ) 836 { 837 /* add a square cap */ 838 FT_Vector delta, delta2; 839 FT_Angle rotate = FT_SIDE_TO_ROTATE( side ); 840 FT_Fixed radius = stroker->radius; 841 FT_StrokeBorder border = stroker->borders + side; 842 843 844 FT_Vector_From_Polar( &delta2, radius, angle + rotate ); 845 FT_Vector_From_Polar( &delta, radius, angle ); 846 847 delta.x += stroker->center.x + delta2.x; 848 delta.y += stroker->center.y + delta2.y; 849 850 error = ft_stroke_border_lineto( border, &delta, FALSE ); 851 if ( error ) 852 goto Exit; 853 854 FT_Vector_From_Polar( &delta2, radius, angle - rotate ); 855 FT_Vector_From_Polar( &delta, radius, angle ); 856 857 delta.x += delta2.x + stroker->center.x; 858 delta.y += delta2.y + stroker->center.y; 859 860 error = ft_stroke_border_lineto( border, &delta, FALSE ); 861 } 862 else if ( stroker->line_cap == FT_STROKER_LINECAP_BUTT ) 863 { 864 /* add a butt ending */ 865 FT_Vector delta; 866 FT_Angle rotate = FT_SIDE_TO_ROTATE( side ); 867 FT_Fixed radius = stroker->radius; 868 FT_StrokeBorder border = stroker->borders + side; 869 870 871 FT_Vector_From_Polar( &delta, radius, angle + rotate ); 872 873 delta.x += stroker->center.x; 874 delta.y += stroker->center.y; 875 876 error = ft_stroke_border_lineto( border, &delta, FALSE ); 877 if ( error ) 878 goto Exit; 879 880 FT_Vector_From_Polar( &delta, radius, angle - rotate ); 881 882 delta.x += stroker->center.x; 883 delta.y += stroker->center.y; 884 885 error = ft_stroke_border_lineto( border, &delta, FALSE ); 886 } 887 888 Exit: 889 return error; 890 } 891 892 893 /* process an inside corner, i.e. compute intersection */ 894 static FT_Error 895 ft_stroker_inside( FT_Stroker stroker, 896 FT_Int side) 897 { 898 FT_StrokeBorder border = stroker->borders + side; 899 FT_Angle phi, theta, rotate; 900 FT_Fixed length, thcos, sigma; 901 FT_Vector delta; 902 FT_Error error = FT_Err_Ok; 903 904 905 rotate = FT_SIDE_TO_ROTATE( side ); 906 907 /* compute median angle */ 908 theta = FT_Angle_Diff( stroker->angle_in, stroker->angle_out ); 909 if ( theta == FT_ANGLE_PI ) 910 theta = rotate; 911 else 912 theta = theta / 2; 913 914 phi = stroker->angle_in + theta; 915 916 thcos = FT_Cos( theta ); 917 sigma = FT_MulFix( stroker->miter_limit, thcos ); 918 919 /* TODO: find better criterion to switch off the optimization */ 920 if ( sigma < 0x10000L ) 921 { 922 FT_Vector_From_Polar( &delta, stroker->radius, 923 stroker->angle_out + rotate ); 924 delta.x += stroker->center.x; 925 delta.y += stroker->center.y; 926 border->movable = FALSE; 927 } 928 else 929 { 930 length = FT_DivFix( stroker->radius, thcos ); 931 932 FT_Vector_From_Polar( &delta, length, phi + rotate ); 933 delta.x += stroker->center.x; 934 delta.y += stroker->center.y; 935 } 936 937 error = ft_stroke_border_lineto( border, &delta, FALSE ); 938 939 return error; 940 } 941 942 943 /* process an outside corner, i.e. compute bevel/miter/round */ 944 static FT_Error 945 ft_stroker_outside( FT_Stroker stroker, 946 FT_Int side ) 947 { 948 FT_StrokeBorder border = stroker->borders + side; 949 FT_Error error; 950 FT_Angle rotate; 951 952 953 if ( stroker->line_join == FT_STROKER_LINEJOIN_ROUND ) 954 error = ft_stroker_arcto( stroker, side ); 955 else 956 { 957 /* this is a mitered or beveled corner */ 958 FT_Fixed sigma, radius = stroker->radius; 959 FT_Angle theta, phi; 960 FT_Fixed thcos; 961 FT_Bool miter; 962 963 964 rotate = FT_SIDE_TO_ROTATE( side ); 965 miter = FT_BOOL( stroker->line_join == FT_STROKER_LINEJOIN_MITER ); 966 967 theta = FT_Angle_Diff( stroker->angle_in, stroker->angle_out ); 968 if ( theta == FT_ANGLE_PI ) 969 { 970 theta = rotate; 971 phi = stroker->angle_in; 972 } 973 else 974 { 975 theta = theta / 2; 976 phi = stroker->angle_in + theta + rotate; 977 } 978 979 thcos = FT_Cos( theta ); 980 sigma = FT_MulFix( stroker->miter_limit, thcos ); 981 982 /* FT_Sin(x) = 0 for x <= 57 */ 983 if ( sigma >= 0x10000L || ft_pos_abs( theta ) <= 57 ) 984 miter = FALSE; 985 986 if ( miter ) /* this is a miter (broken angle) */ 987 { 988 FT_Vector middle, delta; 989 FT_Fixed length; 990 991 992 /* compute middle point */ 993 FT_Vector_From_Polar( &middle, 994 FT_MulFix( radius, stroker->miter_limit ), 995 phi ); 996 middle.x += stroker->center.x; 997 middle.y += stroker->center.y; 998 999 /* compute first angle point */ 1000 length = FT_MulFix( radius, 1001 FT_DivFix( 0x10000L - sigma, 1002 ft_pos_abs( FT_Sin( theta ) ) ) ); 1003 1004 FT_Vector_From_Polar( &delta, length, phi + rotate ); 1005 delta.x += middle.x; 1006 delta.y += middle.y; 1007 1008 error = ft_stroke_border_lineto( border, &delta, FALSE ); 1009 if ( error ) 1010 goto Exit; 1011 1012 /* compute second angle point */ 1013 FT_Vector_From_Polar( &delta, length, phi - rotate ); 1014 delta.x += middle.x; 1015 delta.y += middle.y; 1016 1017 error = ft_stroke_border_lineto( border, &delta, FALSE ); 1018 if ( error ) 1019 goto Exit; 1020 1021 /* finally, add a movable end point */ 1022 FT_Vector_From_Polar( &delta, radius, stroker->angle_out + rotate ); 1023 delta.x += stroker->center.x; 1024 delta.y += stroker->center.y; 1025 1026 error = ft_stroke_border_lineto( border, &delta, TRUE ); 1027 } 1028 1029 else /* this is a bevel (intersection) */ 1030 { 1031 FT_Fixed length; 1032 FT_Vector delta; 1033 1034 1035 length = FT_DivFix( stroker->radius, thcos ); 1036 1037 FT_Vector_From_Polar( &delta, length, phi ); 1038 delta.x += stroker->center.x; 1039 delta.y += stroker->center.y; 1040 1041 error = ft_stroke_border_lineto( border, &delta, FALSE ); 1042 if ( error ) 1043 goto Exit; 1044 1045 /* now add end point */ 1046 FT_Vector_From_Polar( &delta, stroker->radius, 1047 stroker->angle_out + rotate ); 1048 delta.x += stroker->center.x; 1049 delta.y += stroker->center.y; 1050 1051 error = ft_stroke_border_lineto( border, &delta, TRUE ); 1052 } 1053 } 1054 1055 Exit: 1056 return error; 1057 } 1058 1059 1060 static FT_Error 1061 ft_stroker_process_corner( FT_Stroker stroker ) 1062 { 1063 FT_Error error = FT_Err_Ok; 1064 FT_Angle turn; 1065 FT_Int inside_side; 1066 1067 1068 turn = FT_Angle_Diff( stroker->angle_in, stroker->angle_out ); 1069 1070 /* no specific corner processing is required if the turn is 0 */ 1071 if ( turn == 0 ) 1072 goto Exit; 1073 1074 /* when we turn to the right, the inside side is 0 */ 1075 inside_side = 0; 1076 1077 /* otherwise, the inside side is 1 */ 1078 if ( turn < 0 ) 1079 inside_side = 1; 1080 1081 /* process the inside side */ 1082 error = ft_stroker_inside( stroker, inside_side ); 1083 if ( error ) 1084 goto Exit; 1085 1086 /* process the outside side */ 1087 error = ft_stroker_outside( stroker, 1 - inside_side ); 1088 1089 Exit: 1090 return error; 1091 } 1092 1093 1094 /* add two points to the left and right borders corresponding to the */ 1095 /* start of the subpath */ 1096 static FT_Error 1097 ft_stroker_subpath_start( FT_Stroker stroker, 1098 FT_Angle start_angle ) 1099 { 1100 FT_Vector delta; 1101 FT_Vector point; 1102 FT_Error error; 1103 FT_StrokeBorder border; 1104 1105 1106 FT_Vector_From_Polar( &delta, stroker->radius, 1107 start_angle + FT_ANGLE_PI2 ); 1108 1109 point.x = stroker->center.x + delta.x; 1110 point.y = stroker->center.y + delta.y; 1111 1112 border = stroker->borders; 1113 error = ft_stroke_border_moveto( border, &point ); 1114 if ( error ) 1115 goto Exit; 1116 1117 point.x = stroker->center.x - delta.x; 1118 point.y = stroker->center.y - delta.y; 1119 1120 border++; 1121 error = ft_stroke_border_moveto( border, &point ); 1122 1123 /* save angle for last cap */ 1124 stroker->subpath_angle = start_angle; 1125 stroker->first_point = FALSE; 1126 1127 Exit: 1128 return error; 1129 } 1130 1131 1132 /* documentation is in ftstroke.h */ 1133 1134 FT_EXPORT_DEF( FT_Error ) 1135 FT_Stroker_LineTo( FT_Stroker stroker, 1136 FT_Vector* to ) 1137 { 1138 FT_Error error = FT_Err_Ok; 1139 FT_StrokeBorder border; 1140 FT_Vector delta; 1141 FT_Angle angle; 1142 FT_Int side; 1143 1144 delta.x = to->x - stroker->center.x; 1145 delta.y = to->y - stroker->center.y; 1146 1147 angle = FT_Atan2( delta.x, delta.y ); 1148 FT_Vector_From_Polar( &delta, stroker->radius, angle + FT_ANGLE_PI2 ); 1149 1150 /* process corner if necessary */ 1151 if ( stroker->first_point ) 1152 { 1153 /* This is the first segment of a subpath. We need to */ 1154 /* add a point to each border at their respective starting */ 1155 /* point locations. */ 1156 error = ft_stroker_subpath_start( stroker, angle ); 1157 if ( error ) 1158 goto Exit; 1159 } 1160 else 1161 { 1162 /* process the current corner */ 1163 stroker->angle_out = angle; 1164 error = ft_stroker_process_corner( stroker ); 1165 if ( error ) 1166 goto Exit; 1167 } 1168 1169 /* now add a line segment to both the `inside' and `outside' paths */ 1170 1171 for ( border = stroker->borders, side = 1; side >= 0; side--, border++ ) 1172 { 1173 FT_Vector point; 1174 1175 1176 point.x = to->x + delta.x; 1177 point.y = to->y + delta.y; 1178 1179 error = ft_stroke_border_lineto( border, &point, TRUE ); 1180 if ( error ) 1181 goto Exit; 1182 1183 delta.x = -delta.x; 1184 delta.y = -delta.y; 1185 } 1186 1187 stroker->angle_in = angle; 1188 stroker->center = *to; 1189 1190 Exit: 1191 return error; 1192 } 1193 1194 1195 /* documentation is in ftstroke.h */ 1196 1197 FT_EXPORT_DEF( FT_Error ) 1198 FT_Stroker_ConicTo( FT_Stroker stroker, 1199 FT_Vector* control, 1200 FT_Vector* to ) 1201 { 1202 FT_Error error = FT_Err_Ok; 1203 FT_Vector bez_stack[34]; 1204 FT_Vector* arc; 1205 FT_Vector* limit = bez_stack + 30; 1206 FT_Angle start_angle; 1207 FT_Bool first_arc = TRUE; 1208 1209 1210 arc = bez_stack; 1211 arc[0] = *to; 1212 arc[1] = *control; 1213 arc[2] = stroker->center; 1214 1215 while ( arc >= bez_stack ) 1216 { 1217 FT_Angle angle_in, angle_out; 1218 1219 1220 angle_in = angle_out = 0; /* remove compiler warnings */ 1221 1222 if ( arc < limit && 1223 !ft_conic_is_small_enough( arc, &angle_in, &angle_out ) ) 1224 { 1225 ft_conic_split( arc ); 1226 arc += 2; 1227 continue; 1228 } 1229 1230 if ( first_arc ) 1231 { 1232 first_arc = FALSE; 1233 1234 start_angle = angle_in; 1235 1236 /* process corner if necessary */ 1237 if ( stroker->first_point ) 1238 error = ft_stroker_subpath_start( stroker, start_angle ); 1239 else 1240 { 1241 stroker->angle_out = start_angle; 1242 error = ft_stroker_process_corner( stroker ); 1243 } 1244 } 1245 1246 /* the arc's angle is small enough; we can add it directly to each */ 1247 /* border */ 1248 { 1249 FT_Vector ctrl, end; 1250 FT_Angle theta, phi, rotate; 1251 FT_Fixed length; 1252 FT_Int side; 1253 1254 1255 theta = FT_Angle_Diff( angle_in, angle_out ) / 2; 1256 phi = angle_in + theta; 1257 length = FT_DivFix( stroker->radius, FT_Cos( theta ) ); 1258 1259 for ( side = 0; side <= 1; side++ ) 1260 { 1261 rotate = FT_SIDE_TO_ROTATE( side ); 1262 1263 /* compute control point */ 1264 FT_Vector_From_Polar( &ctrl, length, phi + rotate ); 1265 ctrl.x += arc[1].x; 1266 ctrl.y += arc[1].y; 1267 1268 /* compute end point */ 1269 FT_Vector_From_Polar( &end, stroker->radius, angle_out + rotate ); 1270 end.x += arc[0].x; 1271 end.y += arc[0].y; 1272 1273 error = ft_stroke_border_conicto( stroker->borders + side, 1274 &ctrl, &end ); 1275 if ( error ) 1276 goto Exit; 1277 } 1278 } 1279 1280 arc -= 2; 1281 1282 if ( arc < bez_stack ) 1283 stroker->angle_in = angle_out; 1284 } 1285 1286 stroker->center = *to; 1287 1288 Exit: 1289 return error; 1290 } 1291 1292 1293 /* documentation is in ftstroke.h */ 1294 1295 FT_EXPORT_DEF( FT_Error ) 1296 FT_Stroker_CubicTo( FT_Stroker stroker, 1297 FT_Vector* control1, 1298 FT_Vector* control2, 1299 FT_Vector* to ) 1300 { 1301 FT_Error error = FT_Err_Ok; 1302 FT_Vector bez_stack[37]; 1303 FT_Vector* arc; 1304 FT_Vector* limit = bez_stack + 32; 1305 FT_Angle start_angle; 1306 FT_Bool first_arc = TRUE; 1307 1308 1309 arc = bez_stack; 1310 arc[0] = *to; 1311 arc[1] = *control2; 1312 arc[2] = *control1; 1313 arc[3] = stroker->center; 1314 1315 while ( arc >= bez_stack ) 1316 { 1317 FT_Angle angle_in, angle_mid, angle_out; 1318 1319 1320 /* remove compiler warnings */ 1321 angle_in = angle_out = angle_mid = 0; 1322 1323 if ( arc < limit && 1324 !ft_cubic_is_small_enough( arc, &angle_in, 1325 &angle_mid, &angle_out ) ) 1326 { 1327 ft_cubic_split( arc ); 1328 arc += 3; 1329 continue; 1330 } 1331 1332 if ( first_arc ) 1333 { 1334 first_arc = FALSE; 1335 1336 /* process corner if necessary */ 1337 start_angle = angle_in; 1338 1339 if ( stroker->first_point ) 1340 error = ft_stroker_subpath_start( stroker, start_angle ); 1341 else 1342 { 1343 stroker->angle_out = start_angle; 1344 error = ft_stroker_process_corner( stroker ); 1345 } 1346 if ( error ) 1347 goto Exit; 1348 } 1349 1350 /* the arc's angle is small enough; we can add it directly to each */ 1351 /* border */ 1352 { 1353 FT_Vector ctrl1, ctrl2, end; 1354 FT_Angle theta1, phi1, theta2, phi2, rotate; 1355 FT_Fixed length1, length2; 1356 FT_Int side; 1357 1358 1359 theta1 = ft_pos_abs( angle_mid - angle_in ) / 2; 1360 theta2 = ft_pos_abs( angle_out - angle_mid ) / 2; 1361 phi1 = (angle_mid + angle_in ) / 2; 1362 phi2 = (angle_mid + angle_out ) / 2; 1363 length1 = FT_DivFix( stroker->radius, FT_Cos( theta1 ) ); 1364 length2 = FT_DivFix( stroker->radius, FT_Cos( theta2 ) ); 1365 1366 for ( side = 0; side <= 1; side++ ) 1367 { 1368 rotate = FT_SIDE_TO_ROTATE( side ); 1369 1370 /* compute control points */ 1371 FT_Vector_From_Polar( &ctrl1, length1, phi1 + rotate ); 1372 ctrl1.x += arc[2].x; 1373 ctrl1.y += arc[2].y; 1374 1375 FT_Vector_From_Polar( &ctrl2, length2, phi2 + rotate ); 1376 ctrl2.x += arc[1].x; 1377 ctrl2.y += arc[1].y; 1378 1379 /* compute end point */ 1380 FT_Vector_From_Polar( &end, stroker->radius, angle_out + rotate ); 1381 end.x += arc[0].x; 1382 end.y += arc[0].y; 1383 1384 error = ft_stroke_border_cubicto( stroker->borders + side, 1385 &ctrl1, &ctrl2, &end ); 1386 if ( error ) 1387 goto Exit; 1388 } 1389 } 1390 1391 arc -= 3; 1392 if ( arc < bez_stack ) 1393 stroker->angle_in = angle_out; 1394 } 1395 1396 stroker->center = *to; 1397 1398 Exit: 1399 return error; 1400 } 1401 1402 1403 /* documentation is in ftstroke.h */ 1404 1405 FT_EXPORT_DEF( FT_Error ) 1406 FT_Stroker_BeginSubPath( FT_Stroker stroker, 1407 FT_Vector* to, 1408 FT_Bool open ) 1409 { 1410 /* We cannot process the first point, because there is not enough */ 1411 /* information regarding its corner/cap. The latter will be processed */ 1412 /* in the `FT_Stroker_EndSubPath' routine. */ 1413 /* */ 1414 stroker->first_point = TRUE; 1415 stroker->center = *to; 1416 stroker->subpath_open = open; 1417 1418 /* record the subpath start point for each border */ 1419 stroker->subpath_start = *to; 1420 1421 return FT_Err_Ok; 1422 } 1423 1424 1425 static FT_Error 1426 ft_stroker_add_reverse_left( FT_Stroker stroker, 1427 FT_Bool open ) 1428 { 1429 FT_StrokeBorder right = stroker->borders + 0; 1430 FT_StrokeBorder left = stroker->borders + 1; 1431 FT_Int new_points; 1432 FT_Error error = FT_Err_Ok; 1433 1434 1435 FT_ASSERT( left->start >= 0 ); 1436 1437 new_points = left->num_points - left->start; 1438 if ( new_points > 0 ) 1439 { 1440 error = ft_stroke_border_grow( right, (FT_UInt)new_points ); 1441 if ( error ) 1442 goto Exit; 1443 1444 { 1445 FT_Vector* dst_point = right->points + right->num_points; 1446 FT_Byte* dst_tag = right->tags + right->num_points; 1447 FT_Vector* src_point = left->points + left->num_points - 1; 1448 FT_Byte* src_tag = left->tags + left->num_points - 1; 1449 1450 while ( src_point >= left->points + left->start ) 1451 { 1452 *dst_point = *src_point; 1453 *dst_tag = *src_tag; 1454 1455 if ( open ) 1456 dst_tag[0] &= ~FT_STROKE_TAG_BEGIN_END; 1457 else 1458 { 1459 FT_Byte ttag = (FT_Byte)( dst_tag[0] & FT_STROKE_TAG_BEGIN_END ); 1460 1461 1462 /* switch begin/end tags if necessary */ 1463 if ( ttag == FT_STROKE_TAG_BEGIN || 1464 ttag == FT_STROKE_TAG_END ) 1465 dst_tag[0] ^= FT_STROKE_TAG_BEGIN_END; 1466 1467 } 1468 1469 src_point--; 1470 src_tag--; 1471 dst_point++; 1472 dst_tag++; 1473 } 1474 } 1475 1476 left->num_points = left->start; 1477 right->num_points += new_points; 1478 1479 right->movable = FALSE; 1480 left->movable = FALSE; 1481 } 1482 1483 Exit: 1484 return error; 1485 } 1486 1487 1488 /* documentation is in ftstroke.h */ 1489 1490 /* there's a lot of magic in this function! */ 1491 FT_EXPORT_DEF( FT_Error ) 1492 FT_Stroker_EndSubPath( FT_Stroker stroker ) 1493 { 1494 FT_Error error = FT_Err_Ok; 1495 1496 1497 if ( stroker->subpath_open ) 1498 { 1499 FT_StrokeBorder right = stroker->borders; 1500 1501 /* All right, this is an opened path, we need to add a cap between */ 1502 /* right & left, add the reverse of left, then add a final cap */ 1503 /* between left & right. */ 1504 error = ft_stroker_cap( stroker, stroker->angle_in, 0 ); 1505 if ( error ) 1506 goto Exit; 1507 1508 /* add reversed points from `left' to `right' */ 1509 error = ft_stroker_add_reverse_left( stroker, TRUE ); 1510 if ( error ) 1511 goto Exit; 1512 1513 /* now add the final cap */ 1514 stroker->center = stroker->subpath_start; 1515 error = ft_stroker_cap( stroker, 1516 stroker->subpath_angle + FT_ANGLE_PI, 0 ); 1517 if ( error ) 1518 goto Exit; 1519 1520 /* Now end the right subpath accordingly. The left one is */ 1521 /* rewind and doesn't need further processing. */ 1522 ft_stroke_border_close( right, FALSE ); 1523 } 1524 else 1525 { 1526 FT_Angle turn; 1527 FT_Int inside_side; 1528 1529 /* close the path if needed */ 1530 if ( stroker->center.x != stroker->subpath_start.x || 1531 stroker->center.y != stroker->subpath_start.y ) 1532 { 1533 error = FT_Stroker_LineTo( stroker, &stroker->subpath_start ); 1534 if ( error ) 1535 goto Exit; 1536 } 1537 1538 /* process the corner */ 1539 stroker->angle_out = stroker->subpath_angle; 1540 turn = FT_Angle_Diff( stroker->angle_in, 1541 stroker->angle_out ); 1542 1543 /* no specific corner processing is required if the turn is 0 */ 1544 if ( turn != 0 ) 1545 { 1546 /* when we turn to the right, the inside side is 0 */ 1547 inside_side = 0; 1548 1549 /* otherwise, the inside side is 1 */ 1550 if ( turn < 0 ) 1551 inside_side = 1; 1552 1553 error = ft_stroker_inside( stroker, inside_side ); 1554 if ( error ) 1555 goto Exit; 1556 1557 /* process the outside side */ 1558 error = ft_stroker_outside( stroker, 1 - inside_side ); 1559 if ( error ) 1560 goto Exit; 1561 } 1562 1563 /* then end our two subpaths */ 1564 ft_stroke_border_close( stroker->borders + 0, TRUE ); 1565 ft_stroke_border_close( stroker->borders + 1, FALSE ); 1566 } 1567 1568 Exit: 1569 return error; 1570 } 1571 1572 1573 /* documentation is in ftstroke.h */ 1574 1575 FT_EXPORT_DEF( FT_Error ) 1576 FT_Stroker_GetBorderCounts( FT_Stroker stroker, 1577 FT_StrokerBorder border, 1578 FT_UInt *anum_points, 1579 FT_UInt *anum_contours ) 1580 { 1581 FT_UInt num_points = 0, num_contours = 0; 1582 FT_Error error; 1583 1584 1585 if ( !stroker || border > 1 ) 1586 { 1587 error = FT_Err_Invalid_Argument; 1588 goto Exit; 1589 } 1590 1591 error = ft_stroke_border_get_counts( stroker->borders + border, 1592 &num_points, &num_contours ); 1593 Exit: 1594 if ( anum_points ) 1595 *anum_points = num_points; 1596 1597 if ( anum_contours ) 1598 *anum_contours = num_contours; 1599 1600 return error; 1601 } 1602 1603 1604 /* documentation is in ftstroke.h */ 1605 1606 FT_EXPORT_DEF( FT_Error ) 1607 FT_Stroker_GetCounts( FT_Stroker stroker, 1608 FT_UInt *anum_points, 1609 FT_UInt *anum_contours ) 1610 { 1611 FT_UInt count1, count2, num_points = 0; 1612 FT_UInt count3, count4, num_contours = 0; 1613 FT_Error error; 1614 1615 1616 error = ft_stroke_border_get_counts( stroker->borders + 0, 1617 &count1, &count2 ); 1618 if ( error ) 1619 goto Exit; 1620 1621 error = ft_stroke_border_get_counts( stroker->borders + 1, 1622 &count3, &count4 ); 1623 if ( error ) 1624 goto Exit; 1625 1626 num_points = count1 + count3; 1627 num_contours = count2 + count4; 1628 1629 Exit: 1630 *anum_points = num_points; 1631 *anum_contours = num_contours; 1632 return error; 1633 } 1634 1635 1636 /* documentation is in ftstroke.h */ 1637 1638 FT_EXPORT_DEF( void ) 1639 FT_Stroker_ExportBorder( FT_Stroker stroker, 1640 FT_StrokerBorder border, 1641 FT_Outline* outline ) 1642 { 1643 if ( border == FT_STROKER_BORDER_LEFT || 1644 border == FT_STROKER_BORDER_RIGHT ) 1645 { 1646 FT_StrokeBorder sborder = & stroker->borders[border]; 1647 1648 1649 if ( sborder->valid ) 1650 ft_stroke_border_export( sborder, outline ); 1651 } 1652 } 1653 1654 1655 /* documentation is in ftstroke.h */ 1656 1657 FT_EXPORT_DEF( void ) 1658 FT_Stroker_Export( FT_Stroker stroker, 1659 FT_Outline* outline ) 1660 { 1661 FT_Stroker_ExportBorder( stroker, FT_STROKER_BORDER_LEFT, outline ); 1662 FT_Stroker_ExportBorder( stroker, FT_STROKER_BORDER_RIGHT, outline ); 1663 } 1664 1665 1666 /* documentation is in ftstroke.h */ 1667 1668 /* 1669 * The following is very similar to FT_Outline_Decompose, except 1670 * that we do support opened paths, and do not scale the outline. 1671 */ 1672 FT_EXPORT_DEF( FT_Error ) 1673 FT_Stroker_ParseOutline( FT_Stroker stroker, 1674 FT_Outline* outline, 1675 FT_Bool opened ) 1676 { 1677 FT_Vector v_last; 1678 FT_Vector v_control; 1679 FT_Vector v_start; 1680 1681 FT_Vector* point; 1682 FT_Vector* limit; 1683 char* tags; 1684 1685 FT_Error error; 1686 1687 FT_Int n; /* index of contour in outline */ 1688 FT_UInt first; /* index of first point in contour */ 1689 FT_Int tag; /* current point's state */ 1690 1691 1692 if ( !outline || !stroker ) 1693 return FT_Err_Invalid_Argument; 1694 1695 FT_Stroker_Rewind( stroker ); 1696 1697 first = 0; 1698 1699 for ( n = 0; n < outline->n_contours; n++ ) 1700 { 1701 FT_UInt last; /* index of last point in contour */ 1702 1703 1704 last = outline->contours[n]; 1705 limit = outline->points + last; 1706 1707 /* skip empty points; we don't stroke these */ 1708 if ( last <= first ) 1709 { 1710 first = last + 1; 1711 continue; 1712 } 1713 1714 v_start = outline->points[first]; 1715 v_last = outline->points[last]; 1716 1717 v_control = v_start; 1718 1719 point = outline->points + first; 1720 tags = outline->tags + first; 1721 tag = FT_CURVE_TAG( tags[0] ); 1722 1723 /* A contour cannot start with a cubic control point! */ 1724 if ( tag == FT_CURVE_TAG_CUBIC ) 1725 goto Invalid_Outline; 1726 1727 /* check first point to determine origin */ 1728 if ( tag == FT_CURVE_TAG_CONIC ) 1729 { 1730 /* First point is conic control. Yes, this happens. */ 1731 if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON ) 1732 { 1733 /* start at last point if it is on the curve */ 1734 v_start = v_last; 1735 limit--; 1736 } 1737 else 1738 { 1739 /* if both first and last points are conic, */ 1740 /* start at their middle */ 1741 v_start.x = ( v_start.x + v_last.x ) / 2; 1742 v_start.y = ( v_start.y + v_last.y ) / 2; 1743 } 1744 point--; 1745 tags--; 1746 } 1747 1748 error = FT_Stroker_BeginSubPath( stroker, &v_start, opened ); 1749 if ( error ) 1750 goto Exit; 1751 1752 while ( point < limit ) 1753 { 1754 point++; 1755 tags++; 1756 1757 tag = FT_CURVE_TAG( tags[0] ); 1758 switch ( tag ) 1759 { 1760 case FT_CURVE_TAG_ON: /* emit a single line_to */ 1761 { 1762 FT_Vector vec; 1763 1764 1765 vec.x = point->x; 1766 vec.y = point->y; 1767 1768 error = FT_Stroker_LineTo( stroker, &vec ); 1769 if ( error ) 1770 goto Exit; 1771 continue; 1772 } 1773 1774 case FT_CURVE_TAG_CONIC: /* consume conic arcs */ 1775 v_control.x = point->x; 1776 v_control.y = point->y; 1777 1778 Do_Conic: 1779 if ( point < limit ) 1780 { 1781 FT_Vector vec; 1782 FT_Vector v_middle; 1783 1784 1785 point++; 1786 tags++; 1787 tag = FT_CURVE_TAG( tags[0] ); 1788 1789 vec = point[0]; 1790 1791 if ( tag == FT_CURVE_TAG_ON ) 1792 { 1793 error = FT_Stroker_ConicTo( stroker, &v_control, &vec ); 1794 if ( error ) 1795 goto Exit; 1796 continue; 1797 } 1798 1799 if ( tag != FT_CURVE_TAG_CONIC ) 1800 goto Invalid_Outline; 1801 1802 v_middle.x = ( v_control.x + vec.x ) / 2; 1803 v_middle.y = ( v_control.y + vec.y ) / 2; 1804 1805 error = FT_Stroker_ConicTo( stroker, &v_control, &v_middle ); 1806 if ( error ) 1807 goto Exit; 1808 1809 v_control = vec; 1810 goto Do_Conic; 1811 } 1812 1813 error = FT_Stroker_ConicTo( stroker, &v_control, &v_start ); 1814 goto Close; 1815 1816 default: /* FT_CURVE_TAG_CUBIC */ 1817 { 1818 FT_Vector vec1, vec2; 1819 1820 1821 if ( point + 1 > limit || 1822 FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC ) 1823 goto Invalid_Outline; 1824 1825 point += 2; 1826 tags += 2; 1827 1828 vec1 = point[-2]; 1829 vec2 = point[-1]; 1830 1831 if ( point <= limit ) 1832 { 1833 FT_Vector vec; 1834 1835 1836 vec = point[0]; 1837 1838 error = FT_Stroker_CubicTo( stroker, &vec1, &vec2, &vec ); 1839 if ( error ) 1840 goto Exit; 1841 continue; 1842 } 1843 1844 error = FT_Stroker_CubicTo( stroker, &vec1, &vec2, &v_start ); 1845 goto Close; 1846 } 1847 } 1848 } 1849 1850 Close: 1851 if ( error ) 1852 goto Exit; 1853 1854 error = FT_Stroker_EndSubPath( stroker ); 1855 if ( error ) 1856 goto Exit; 1857 1858 first = last + 1; 1859 } 1860 1861 return FT_Err_Ok; 1862 1863 Exit: 1864 return error; 1865 1866 Invalid_Outline: 1867 return FT_Err_Invalid_Outline; 1868 } 1869 1870 /* declare an extern to access ft_outline_glyph_class global allocated 1871 in ftglyph.c, and use the FT_OUTLINE_GLYPH_CLASS_GET macro to access 1872 it when FT_CONFIG_OPTION_PIC is defined */ 1873 #ifndef FT_CONFIG_OPTION_PIC 1874 extern const FT_Glyph_Class ft_outline_glyph_class; 1875 #endif 1876 #include "basepic.h" 1877 1878 1879 /* documentation is in ftstroke.h */ 1880 1881 FT_EXPORT_DEF( FT_Error ) 1882 FT_Glyph_Stroke( FT_Glyph *pglyph, 1883 FT_Stroker stroker, 1884 FT_Bool destroy ) 1885 { 1886 FT_Error error = FT_Err_Invalid_Argument; 1887 FT_Glyph glyph = NULL; 1888 FT_Library library = stroker->library; 1889 FT_UNUSED(library); 1890 1891 if ( pglyph == NULL ) 1892 goto Exit; 1893 1894 glyph = *pglyph; 1895 if ( glyph == NULL || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET ) 1896 goto Exit; 1897 1898 { 1899 FT_Glyph copy; 1900 1901 1902 error = FT_Glyph_Copy( glyph, © ); 1903 if ( error ) 1904 goto Exit; 1905 1906 glyph = copy; 1907 } 1908 1909 { 1910 FT_OutlineGlyph oglyph = (FT_OutlineGlyph) glyph; 1911 FT_Outline* outline = &oglyph->outline; 1912 FT_UInt num_points, num_contours; 1913 1914 1915 error = FT_Stroker_ParseOutline( stroker, outline, FALSE ); 1916 if ( error ) 1917 goto Fail; 1918 1919 (void)FT_Stroker_GetCounts( stroker, &num_points, &num_contours ); 1920 1921 FT_Outline_Done( glyph->library, outline ); 1922 1923 error = FT_Outline_New( glyph->library, 1924 num_points, num_contours, outline ); 1925 if ( error ) 1926 goto Fail; 1927 1928 outline->n_points = 0; 1929 outline->n_contours = 0; 1930 1931 FT_Stroker_Export( stroker, outline ); 1932 } 1933 1934 if ( destroy ) 1935 FT_Done_Glyph( *pglyph ); 1936 1937 *pglyph = glyph; 1938 goto Exit; 1939 1940 Fail: 1941 FT_Done_Glyph( glyph ); 1942 glyph = NULL; 1943 1944 if ( !destroy ) 1945 *pglyph = NULL; 1946 1947 Exit: 1948 return error; 1949 } 1950 1951 1952 /* documentation is in ftstroke.h */ 1953 1954 FT_EXPORT_DEF( FT_Error ) 1955 FT_Glyph_StrokeBorder( FT_Glyph *pglyph, 1956 FT_Stroker stroker, 1957 FT_Bool inside, 1958 FT_Bool destroy ) 1959 { 1960 FT_Error error = FT_Err_Invalid_Argument; 1961 FT_Glyph glyph = NULL; 1962 FT_Library library = stroker->library; 1963 FT_UNUSED(library); 1964 1965 if ( pglyph == NULL ) 1966 goto Exit; 1967 1968 glyph = *pglyph; 1969 if ( glyph == NULL || glyph->clazz != FT_OUTLINE_GLYPH_CLASS_GET ) 1970 goto Exit; 1971 1972 { 1973 FT_Glyph copy; 1974 1975 1976 error = FT_Glyph_Copy( glyph, © ); 1977 if ( error ) 1978 goto Exit; 1979 1980 glyph = copy; 1981 } 1982 1983 { 1984 FT_OutlineGlyph oglyph = (FT_OutlineGlyph) glyph; 1985 FT_StrokerBorder border; 1986 FT_Outline* outline = &oglyph->outline; 1987 FT_UInt num_points, num_contours; 1988 1989 1990 border = FT_Outline_GetOutsideBorder( outline ); 1991 if ( inside ) 1992 { 1993 if ( border == FT_STROKER_BORDER_LEFT ) 1994 border = FT_STROKER_BORDER_RIGHT; 1995 else 1996 border = FT_STROKER_BORDER_LEFT; 1997 } 1998 1999 error = FT_Stroker_ParseOutline( stroker, outline, FALSE ); 2000 if ( error ) 2001 goto Fail; 2002 2003 (void)FT_Stroker_GetBorderCounts( stroker, border, 2004 &num_points, &num_contours ); 2005 2006 FT_Outline_Done( glyph->library, outline ); 2007 2008 error = FT_Outline_New( glyph->library, 2009 num_points, 2010 num_contours, 2011 outline ); 2012 if ( error ) 2013 goto Fail; 2014 2015 outline->n_points = 0; 2016 outline->n_contours = 0; 2017 2018 FT_Stroker_ExportBorder( stroker, border, outline ); 2019 } 2020 2021 if ( destroy ) 2022 FT_Done_Glyph( *pglyph ); 2023 2024 *pglyph = glyph; 2025 goto Exit; 2026 2027 Fail: 2028 FT_Done_Glyph( glyph ); 2029 glyph = NULL; 2030 2031 if ( !destroy ) 2032 *pglyph = NULL; 2033 2034 Exit: 2035 return error; 2036 } 2037 2038 2039 /* END */ 2040
