![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to paths.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / print / pscript|
Return to paths.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 ! root 1: //-------------------------------------------------------------------------- ! 2: // ! 3: // Module Name: PATHS.C ! 4: // ! 5: // Brief Description: This module contains the PSCRIPT driver's path ! 6: // rendering functions and related routines. ! 7: // ! 8: // Author: Kent Settle (kentse) ! 9: // Created: 02-May-1991 ! 10: // ! 11: // 26-Mar-1992 Thu 23:53:12 updated -by- Daniel Chou (danielc) ! 12: // add the prclBound parameter to the bDoClipObj() ! 13: // ! 14: // Copyright (c) 1991 - 1992 Microsoft Corporation ! 15: // ! 16: // This Module contains the following functions: ! 17: // DrvStrokePath ! 18: // DrvFillPath ! 19: // DrvStrokeAndFillPath ! 20: //-------------------------------------------------------------------------- ! 21: ! 22: #include "pscript.h" ! 23: #include "enable.h" ! 24: ! 25: extern ULONG PSMonoPalette[]; ! 26: extern ULONG PSColorPalette[]; ! 27: ! 28: extern BOOL bDoClipObj(PDEVDATA, CLIPOBJ *, RECTL *, RECTL *, BOOL *, BOOL *, DWORD); ! 29: ! 30: BOOL DrvCommonPath(PDEVDATA, PATHOBJ *); ! 31: ! 32: //-------------------------------------------------------------------------- ! 33: // BOOL DrvStrokePath(pso, ppo, pco, pxo, pbo, pptlBrushOrg, plineattrs, mix) ! 34: // SURFOBJ *pso; ! 35: // PATHOBJ *ppo; ! 36: // CLIPOBJ *pco; ! 37: // XFORMOBJ *pxo; ! 38: // BRUSHOBJ *pbo; ! 39: // PPOINTL pptlBrushOrg; ! 40: // PLINEATTRS plineattrs; ! 41: // MIX mix; ! 42: // ! 43: // ! 44: // Parameters: ! 45: // ! 46: // Returns: ! 47: // This function returns TRUE. ! 48: // ! 49: // History: ! 50: // 02-May-1991 -by- Kent Settle [kentse] ! 51: // Wrote it. ! 52: //-------------------------------------------------------------------------- ! 53: ! 54: BOOL DrvStrokePath(pso, ppo, pco, pxo, pbo, pptlBrushOrg, plineattrs, mix) ! 55: SURFOBJ *pso; ! 56: PATHOBJ *ppo; ! 57: CLIPOBJ *pco; ! 58: XFORMOBJ *pxo; ! 59: BRUSHOBJ *pbo; ! 60: PPOINTL pptlBrushOrg; ! 61: PLINEATTRS plineattrs; ! 62: MIX mix; ! 63: { ! 64: PDEVDATA pdev; ! 65: BOOL bClipping; // TRUE if there is a clip region. ! 66: ULONG ulColor; ! 67: BOOL bMoreClipping; // TRUE if there is more clipping to handle. ! 68: BOOL bFirstClipPass; ! 69: #ifdef INDEX_PAL ! 70: DEVBRUSH *pBrush; ! 71: ULONG *pulColors; ! 72: #endif ! 73: RECTFX rcfxBound; ! 74: RECTL rclBound; ! 75: ! 76: UNREFERENCED_PARAMETER(mix); ! 77: ! 78: // get the pointer to our DEVDATA structure and make sure it is ours. ! 79: ! 80: pdev = (PDEVDATA) pso->dhpdev; ! 81: ! 82: if (bValidatePDEV(pdev) == FALSE) ! 83: { ! 84: RIP("PSCRIPT!DrvStrokePath: invalid pdev.\n"); ! 85: SetLastError(ERROR_INVALID_PARAMETER); ! 86: return(FALSE); ! 87: } ! 88: ! 89: // deal with LINEATTRS. ! 90: ! 91: if (!(ps_setlineattrs(pdev, plineattrs, pxo))) ! 92: return(FALSE); ! 93: ! 94: // output the line color to stroke with. do this before we handle ! 95: // clipping, so the line color will remain beyond the gsave/grestore. ! 96: ! 97: #ifdef INDEX_PAL ! 98: // just output the solid color if there is one. ! 99: ! 100: if ((pdev->pntpd->flFlags & COLOR_DEVICE) && ! 101: (pdev->psdm.dm.dmColor == DMCOLOR_COLOR)) ! 102: pulColors = PSColorPalette; ! 103: else ! 104: pulColors = PSMonoPalette; ! 105: ! 106: if (pbo->iSolidColor != NOT_SOLID_COLOR) ! 107: { ! 108: ps_setrgbcolor(pdev, (PALETTEENTRY *)pulColors + pbo->iSolidColor); ! 109: } ! 110: else ! 111: { ! 112: // get the device brush to draw with. ! 113: ! 114: pBrush = (DEVBRUSH *)BRUSHOBJ_pvGetRbrush(pbo); ! 115: ! 116: if (!pBrush) ! 117: { ! 118: #if DBG ! 119: DbgPrint("DrvStrokePath: NULL pBrush.\n"); ! 120: #endif ! 121: // something is wrong! just output black path. ! 122: ! 123: ulColor = RGB_BLACK; ! 124: ps_setrgbcolor(pdev, (PALETTEENTRY *)&ulColor); ! 125: } ! 126: else ! 127: { ! 128: if (pBrush->iSolidColor == NOT_SOLID_COLOR) ! 129: { ! 130: // get the foreground color. ! 131: ! 132: ps_setrgbcolor(pdev, ((PALETTEENTRY *)pulColors + ! 133: *(ULONG *)((PBYTE)pBrush + pBrush->offsetXlate + ! 134: sizeof(ULONG)))); ! 135: } ! 136: else ! 137: { ! 138: ps_setrgbcolor(pdev, (PALETTEENTRY *)&pBrush->iSolidColor); ! 139: } ! 140: } ! 141: } ! 142: #else ! 143: if (pbo->iSolidColor == NOT_SOLID_COLOR) ! 144: { ! 145: //!!! this needs to be fixed!!! -kentse. ! 146: ulColor = RGB_GRAY; ! 147: ! 148: ps_setrgbcolor(pdev, (BGR_PAL_ENTRY *)&ulColor); ! 149: } ! 150: else ! 151: { ! 152: // we have a solid brush, so simply output the line color. ! 153: ! 154: ps_setrgbcolor(pdev, (BGR_PAL_ENTRY *)&pbo->iSolidColor); ! 155: } ! 156: #endif ! 157: ! 158: // get the bounding rectangle for the path. this is used to checked ! 159: // against the clipping for optimization. ! 160: ! 161: PATHOBJ_vGetBounds(ppo, &rcfxBound); ! 162: ! 163: // get a RECTL which is guaranteed to bound the path. ! 164: ! 165: rclBound.left = FXTOL(rcfxBound.xLeft); ! 166: rclBound.top = FXTOL(rcfxBound.yTop); ! 167: rclBound.right = FXTOL(rcfxBound.xRight + FIX_ONE); ! 168: rclBound.bottom = FXTOL(rcfxBound.yBottom + FIX_ONE); ! 169: ! 170: bMoreClipping = TRUE; ! 171: bFirstClipPass = TRUE; ! 172: ! 173: while (bMoreClipping) ! 174: { ! 175: // handle the clipping. ! 176: ! 177: if (bClipping = bDoClipObj(pdev, pco, NULL, &rclBound, &bMoreClipping, ! 178: &bFirstClipPass, MAX_CLIP_RECTS)) ! 179: ps_clip(pdev, TRUE); ! 180: ! 181: if (!(DrvCommonPath(pdev, ppo))) ! 182: return(FALSE); ! 183: ! 184: // now transform for geometric lines if necessary. ! 185: ! 186: if (plineattrs->fl & LA_GEOMETRIC) ! 187: ps_geolinexform(pdev, plineattrs, pxo); ! 188: ! 189: // now stroke the path. ! 190: ! 191: ps_stroke(pdev, pbo, pptlBrushOrg); ! 192: ! 193: // restore the CTM if a transform for a geometric line was in effect. ! 194: ! 195: if (pdev->cgs.dwFlags & CGS_GEOLINEXFORM) ! 196: { ! 197: PrintString(pdev, "SM\n"); ! 198: pdev->cgs.dwFlags &= ~CGS_GEOLINEXFORM; ! 199: } ! 200: ! 201: // restore the clip path to what it was before this call. ! 202: ! 203: if (bClipping) ! 204: ps_restore(pdev, TRUE); ! 205: } ! 206: ! 207: return(TRUE); ! 208: } ! 209: ! 210: ! 211: //-------------------------------------------------------------------------- ! 212: // BOOL DrvFillPath(pso, ppo, pco, pbo, pptlBrushOrg, mix, flOptions) ! 213: // SURFOBJ *pso; ! 214: // PATHOBJ *ppo; ! 215: // CLIPOBJ *pco; ! 216: // BRUSHOBJ *pbo; ! 217: // PPOINTL pptlBrushOrg; ! 218: // MIX mix; ! 219: // FLONG flOptions; ! 220: // ! 221: // Parameters: ! 222: // ! 223: // Returns: ! 224: // This function returns TRUE. ! 225: // ! 226: // History: ! 227: // 03-May-1991 -by- Kent Settle [kentse] ! 228: // Wrote it. ! 229: //-------------------------------------------------------------------------- ! 230: ! 231: BOOL DrvFillPath(pso, ppo, pco, pbo, pptlBrushOrg, mix, flOptions) ! 232: SURFOBJ *pso; ! 233: PATHOBJ *ppo; ! 234: CLIPOBJ *pco; ! 235: BRUSHOBJ *pbo; ! 236: PPOINTL pptlBrushOrg; ! 237: MIX mix; ! 238: FLONG flOptions; ! 239: { ! 240: PDEVDATA pdev; ! 241: RECTL rclBounds; ! 242: RECTFX rcfxBounds; ! 243: BOOL bClipping; ! 244: BOOL bMoreClipping; ! 245: BOOL bFirstClipPass; ! 246: ! 247: // get the pointer to our DEVDATA structure and make sure it is ours. ! 248: ! 249: pdev = (PDEVDATA) pso->dhpdev; ! 250: ! 251: if (bValidatePDEV(pdev) == FALSE) ! 252: return(FALSE); ! 253: ! 254: bMoreClipping = TRUE; ! 255: bFirstClipPass = TRUE; ! 256: ! 257: while (bMoreClipping) ! 258: { ! 259: // get the bounding rectangle of the path to pass to ps_patfill. ! 260: ! 261: PATHOBJ_vGetBounds(ppo, &rcfxBounds); ! 262: ! 263: rclBounds.left = FXTOL(rcfxBounds.xLeft); ! 264: rclBounds.right = FXTOL(rcfxBounds.xRight) + 1; ! 265: rclBounds.top = FXTOL(rcfxBounds.yTop); ! 266: rclBounds.bottom = FXTOL(rcfxBounds.yBottom) + 1; ! 267: ! 268: // if there is a clip region, clip to it. we want to keep this ! 269: // separate from the clip path. ! 270: ! 271: if (bClipping = bDoClipObj(pdev, pco, NULL, &rclBounds, &bMoreClipping, ! 272: &bFirstClipPass, MAX_CLIP_RECTS)) ! 273: { ! 274: if (flOptions & FP_WINDINGMODE) ! 275: ps_clip(pdev, TRUE); ! 276: else ! 277: ps_clip(pdev, FALSE); ! 278: } ! 279: ! 280: // if there was no clip region, we need to output a gsave before we ! 281: // send the clip path, so we can blow it away when we are done. ! 282: ! 283: if (!bClipping) ! 284: ps_save(pdev, TRUE); ! 285: ! 286: if (!(DrvCommonPath(pdev, ppo))) ! 287: { ! 288: RIP("PSCRIPT!DrvFillPath: invalid pdev.\n"); ! 289: SetLastError(ERROR_INVALID_PARAMETER); ! 290: return(FALSE); ! 291: } ! 292: ! 293: // now fill the path. ! 294: ! 295: if (!ps_patfill(pdev, pso, flOptions, pbo, pptlBrushOrg, mix, &rclBounds, ! 296: FALSE, TRUE)) ! 297: return(FALSE); ! 298: ! 299: ps_restore(pdev, TRUE); ! 300: } ! 301: ! 302: return(TRUE); ! 303: } ! 304: ! 305: ! 306: //-------------------------------------------------------------------------- ! 307: // BOOL DrvStrokeAndFillPath(pso, ppo, pco, pxo, pboStroke, plineattrs, ! 308: // pboFill, pptlBrushOrg, mixFill, flOptions) ! 309: // SURFOBJ *pso; ! 310: // PATHOBJ *ppo; ! 311: // CLIPOBJ *pco; ! 312: // XFORMOBJ *pxo; ! 313: // BRUSHOBJ *pboStroke; ! 314: // PLINEATTRS plineattrs; ! 315: // BRUSHOBJ *pboFill; ! 316: // PPOINTL pptlBrushOrg; ! 317: // MIX mixFill; ! 318: // FLONG flOptions; ! 319: // ! 320: // Parameters: ! 321: // ! 322: // Returns: ! 323: // This function returns TRUE. ! 324: // ! 325: // History: ! 326: // 03-May-1991 -by- Kent Settle [kentse] ! 327: // Wrote it. ! 328: //-------------------------------------------------------------------------- ! 329: ! 330: BOOL DrvStrokeAndFillPath(pso, ppo, pco, pxo, pboStroke, plineattrs, ! 331: pboFill, pptlBrushOrg, mixFill, flOptions) ! 332: SURFOBJ *pso; ! 333: PATHOBJ *ppo; ! 334: CLIPOBJ *pco; ! 335: XFORMOBJ *pxo; ! 336: BRUSHOBJ *pboStroke; ! 337: PLINEATTRS plineattrs; ! 338: BRUSHOBJ *pboFill; ! 339: PPOINTL pptlBrushOrg; ! 340: MIX mixFill; ! 341: FLONG flOptions; ! 342: { ! 343: PDEVDATA pdev; ! 344: RECTL rclBounds; ! 345: RECTFX rcfxBounds; ! 346: BOOL bClipping; ! 347: ULONG ulColor; ! 348: BOOL bMoreClipping; ! 349: BOOL bFirstClipPass; ! 350: #ifdef INDEX_PAL ! 351: DEVBRUSH *pBrush; ! 352: ULONG *pulColors; ! 353: #endif ! 354: ! 355: // get the pointer to our DEVDATA structure and make sure it is ours. ! 356: ! 357: pdev = (PDEVDATA) pso->dhpdev; ! 358: ! 359: if (bValidatePDEV(pdev) == FALSE) ! 360: return(FALSE); ! 361: ! 362: // deal with LINEATTRS. ! 363: ! 364: if (!(ps_setlineattrs(pdev, plineattrs, pxo))) ! 365: return(FALSE); ! 366: ! 367: // output the line color to stroke with. do this before we handle ! 368: // clipping, so the line color will remain beyond the gsave/grestore. ! 369: ! 370: #ifdef INDEX_PAL ! 371: // just output solid color if there is one. ! 372: ! 373: if ((pdev->pntpd->flFlags & COLOR_DEVICE) && ! 374: (pdev->psdm.dm.dmColor == DMCOLOR_COLOR)) ! 375: pulColors = PSColorPalette; ! 376: else ! 377: pulColors = PSMonoPalette; ! 378: ! 379: if (pboStroke->iSolidColor != NOT_SOLID_COLOR) ! 380: { ! 381: ps_setrgbcolor(pdev, (PALETTEENTRY *)pulColors + pboStroke->iSolidColor); ! 382: } ! 383: else ! 384: { ! 385: // get the device brush to draw with. ! 386: ! 387: pBrush = (DEVBRUSH *)BRUSHOBJ_pvGetRbrush(pboStroke); ! 388: ! 389: if (!pBrush) ! 390: { ! 391: #if DBG ! 392: DbgPrint("DrvStrokeAndFillPath: NULL pBrush.\n"); ! 393: #endif ! 394: // something is wrong! stroke with black. ! 395: ! 396: ulColor = RGB_BLACK; ! 397: ps_setrgbcolor(pdev, (PALETTEENTRY *)&ulColor); ! 398: } ! 399: else ! 400: { ! 401: if (pBrush->iSolidColor == NOT_SOLID_COLOR) ! 402: { ! 403: // get the foreground color. ! 404: ! 405: ps_setrgbcolor(pdev, ((PALETTEENTRY *)pulColors + ! 406: *(ULONG *)((PBYTE)pBrush + pBrush->offsetXlate + ! 407: sizeof(ULONG)))); ! 408: } ! 409: else ! 410: { ! 411: ps_setrgbcolor(pdev, (PALETTEENTRY *)&pBrush->iSolidColor); ! 412: } ! 413: } ! 414: } ! 415: #else ! 416: if (pboStroke->iSolidColor == NOT_SOLID_COLOR) ! 417: { ! 418: //!!! this needs to be fixed!!! -kentse. ! 419: ulColor = RGB_GRAY; ! 420: ! 421: ps_setrgbcolor(pdev, (BGR_PAL_ENTRY *)&ulColor); ! 422: } ! 423: else ! 424: { ! 425: // we have a solid brush, so simply output the line color. ! 426: ! 427: ps_setrgbcolor(pdev, (BGR_PAL_ENTRY *)&pboStroke->iSolidColor); ! 428: } ! 429: #endif ! 430: ! 431: bMoreClipping = TRUE; ! 432: bFirstClipPass = TRUE; ! 433: ! 434: while (bMoreClipping) ! 435: { ! 436: // get the bounding rectangle of the path to pass to ps_patfill. ! 437: ! 438: PATHOBJ_vGetBounds(ppo, &rcfxBounds); ! 439: ! 440: rclBounds.left = FXTOL(rcfxBounds.xLeft); ! 441: rclBounds.right = FXTOL(rcfxBounds.xRight) + 1; ! 442: rclBounds.top = FXTOL(rcfxBounds.yTop); ! 443: rclBounds.bottom = FXTOL(rcfxBounds.yBottom) + 1; ! 444: ! 445: // if there is a clip region, clip to it. we want to keep this ! 446: // separate from the clip path. ! 447: ! 448: if (bClipping = bDoClipObj(pdev, pco, NULL, &rclBounds, &bMoreClipping, ! 449: &bFirstClipPass, MAX_CLIP_RECTS)) ! 450: { ! 451: if (flOptions & FP_WINDINGMODE) ! 452: ps_clip(pdev, TRUE); ! 453: else ! 454: ps_clip(pdev, FALSE); ! 455: } ! 456: ! 457: // if there was no clip region, we need to output a gsave before we ! 458: // send the clip path, so we can blow it away when we are done. ! 459: ! 460: if (!bClipping) ! 461: ps_save(pdev, TRUE); ! 462: ! 463: if (!(DrvCommonPath(pdev, ppo))) ! 464: { ! 465: RIP("PSCRIPT!DrvStrokeAndFillPath: invalid pdev.\n"); ! 466: SetLastError(ERROR_INVALID_PARAMETER); ! 467: return(FALSE); ! 468: } ! 469: ! 470: // save the path. then fill it. then restore the path which ! 471: // was wiped out when it was filled so we can stroke it. TRUE ! 472: // means to do a gsave, not a save command. ! 473: ! 474: if (!ps_save(pdev, TRUE)) ! 475: return(FALSE); ! 476: ! 477: if (!ps_patfill(pdev, pso, flOptions, pboFill, pptlBrushOrg, mixFill, ! 478: &rclBounds, FALSE, TRUE)) ! 479: return(FALSE); ! 480: ! 481: if (!ps_restore(pdev, TRUE)) ! 482: return(FALSE); ! 483: ! 484: // now transform for geometric lines if necessary. ! 485: ! 486: if (plineattrs->fl & LA_GEOMETRIC) ! 487: ps_geolinexform(pdev, plineattrs, pxo); ! 488: ! 489: // now stroke the path. remember that ps_patfill will have marked that ! 490: // the path no longer exists. since we surrounded it with gsave - ! 491: // grestore, we know otherwise. ! 492: ! 493: pdev->cgs.dwFlags |= CGS_PATHEXISTS; ! 494: ps_stroke(pdev, pboStroke, pptlBrushOrg); ! 495: ! 496: // restore the CTM if a transform for a geometric line was in effect. ! 497: ! 498: if (pdev->cgs.dwFlags & CGS_GEOLINEXFORM) ! 499: { ! 500: PrintString(pdev, "SM\n"); ! 501: pdev->cgs.dwFlags &= ~CGS_GEOLINEXFORM; ! 502: } ! 503: ! 504: ps_restore(pdev, TRUE); ! 505: } ! 506: ! 507: return(TRUE); ! 508: } ! 509: ! 510: ! 511: //-------------------------------------------------------------------------- ! 512: // BOOL DrvCommonPath(pdev, ppo) ! 513: // PDEVDATA pdev; ! 514: // PATHOBJ *ppo; ! 515: // ! 516: // ! 517: // Parameters: ! 518: // ! 519: // Returns: ! 520: // This function returns TRUE. ! 521: // ! 522: // History: ! 523: // 02-May-1991 -by- Kent Settle [kentse] ! 524: // Wrote it. ! 525: //-------------------------------------------------------------------------- ! 526: ! 527: BOOL DrvCommonPath(pdev, ppo) ! 528: PDEVDATA pdev; ! 529: PATHOBJ *ppo; ! 530: { ! 531: PATHDATA pathdata; ! 532: POINTL ptl, ptl1, ptl2; ! 533: POINTFIX *pptfx; ! 534: LONG cPoints; ! 535: BOOL bMore; ! 536: ! 537: // before we enumerate the path, let's make sure we have a clean start. ! 538: ! 539: ps_newpath(pdev); ! 540: ! 541: // enumerate the path, doing what needs to be done along the way. ! 542: ! 543: PATHOBJ_vEnumStart(ppo); ! 544: ! 545: do ! 546: { ! 547: bMore = PATHOBJ_bEnum(ppo, &pathdata); ! 548: ! 549: // get a local pointer to the array of POINTFIX's. ! 550: ! 551: pptfx = pathdata.pptfx; ! 552: cPoints = (LONG)pathdata.count; ! 553: ! 554: if (pathdata.flags & PD_BEGINSUBPATH) ! 555: { ! 556: // the first path begins a new subpath. it is not connected ! 557: // to the previous subpath. note that if this flag is not ! 558: // set, then the starting point for the first curve to be ! 559: // drawn from this data is the last point returned in the ! 560: // previous call. ! 561: ! 562: #if 0 ! 563: if (pathdata.flags & PD_RESETSTYLE) ! 564: { ! 565: // this bit is defined only if this record begins a new ! 566: // subpath. if set, it indicates that the style state ! 567: // should be reset to zero at the beginning of the subpath. ! 568: // if not set, the style state is defined by the ! 569: // LINEATTRS, or continues from the previous path. ! 570: ! 571: #if DBG ! 572: DbgPrint("DrvCommonPath: PD_RESETSTYLE flag set.\n"); ! 573: #endif ! 574: //!!! fill in here - kentse ! 575: } ! 576: #endif ! 577: ! 578: // begin the subpath within the printer by issuing a moveto ! 579: // command. ! 580: ! 581: ptl.x = FXTOL(pptfx->x); ! 582: ptl.y = FXTOL(pptfx->y); ! 583: pptfx++; ! 584: cPoints--; ! 585: ! 586: ps_moveto(pdev, &ptl); ! 587: } ! 588: ! 589: if (pathdata.flags & PD_BEZIERS) ! 590: { ! 591: // if set, then each set of three control points returned for ! 592: // this call describe a Bezier curve. if clear then each ! 593: // control point describes a line segment. a starting point ! 594: // for either type is either explicit at the beginning of the ! 595: // subpath, or implicit as the endpoint of the previous curve. ! 596: ! 597: // there had better be the correct number of points if we are ! 598: // going to draw curves. ! 599: ! 600: if ((cPoints % 3) != 0) ! 601: { ! 602: RIP("PSCRIPT!DrvCommonPath: incompatible number of points.\n"); ! 603: SetLastError(ERROR_INVALID_PARAMETER); ! 604: return(FALSE); ! 605: } ! 606: ! 607: // now draw the bezier for each set of points. ! 608: ! 609: while (cPoints > 0) ! 610: { ! 611: ptl.x = FXTOL(pptfx->x); ! 612: ptl.y = FXTOL(pptfx->y); ! 613: pptfx++; ! 614: ptl1.x = FXTOL(pptfx->x); ! 615: ptl1.y = FXTOL(pptfx->y); ! 616: pptfx++; ! 617: ptl2.x = FXTOL(pptfx->x); ! 618: ptl2.y = FXTOL(pptfx->y); ! 619: pptfx++; ! 620: ! 621: ps_curveto(pdev, &ptl, &ptl1, &ptl2); ! 622: cPoints -= 3; ! 623: } ! 624: } ! 625: else ! 626: { ! 627: // draw the line segment for each point. ! 628: ! 629: while (cPoints-- > 0) ! 630: { ! 631: ptl.x = FXTOL(pptfx->x); ! 632: ptl.y = FXTOL(pptfx->y); ! 633: pptfx++; ! 634: ! 635: ps_lineto(pdev, &ptl); ! 636: } ! 637: } ! 638: } while(bMore); ! 639: ! 640: if (pathdata.flags & PD_ENDSUBPATH) ! 641: { ! 642: // the last point in the array ends the subpath. this subpath ! 643: // may be open or closed depending on the PD_CLOSEFIGURE flag. ! 644: // if there is more data to be returned in the path, then the ! 645: // next record will begin a new subpath. note that a single ! 646: // record might begin and end a subpath. ! 647: ! 648: if (pathdata.flags & PD_CLOSEFIGURE) ! 649: { ! 650: // this bit is only defined if the record ends a subpath. if ! 651: // set, then there is an implicit line segment connecting ! 652: // the last point of the subpath with the first point. if ! 653: // such a closed subpath is being stroked, then joins are used ! 654: // all around the path, and there are no end caps. if this ! 655: // flag is not set then the subpath is considered open, even ! 656: // if the first and last points happen to be coincident. in ! 657: // that case, end caps should be drawn. this flag is not ! 658: // relevant for filling, since all subpaths are assumed closed ! 659: // when a path is filled. ! 660: ! 661: ps_closepath(pdev); ! 662: } ! 663: } ! 664: ! 665: return(TRUE); ! 666: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.