![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to patfill.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 patfill.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / print / pscript |
1.1 ! root 1: //-------------------------------------------------------------------------- ! 2: // ! 3: // Module Name: PATFILL.C ! 4: // ! 5: // Brief Description: This module contains the PSCRIPT driver's pattern ! 6: // filling routines. ! 7: // ! 8: // Author: Kent Settle (kentse) ! 9: // Created: 12-Dec-1990 ! 10: // ! 11: // Copyright (c) 1990 - 1992 Microsoft Corporation ! 12: // ! 13: //-------------------------------------------------------------------------- ! 14: ! 15: #include "pscript.h" ! 16: #include "patfill.h" ! 17: #include "enable.h" ! 18: ! 19: VOID vPatfill_Base(PDEVDATA, FLONG, BGR_PAL_ENTRY *, MIX); ! 20: ! 21: #ifdef INDEX_PAL ! 22: extern ULONG PSMonoPalette[]; ! 23: extern ULONG PSColorPalette[]; ! 24: #endif ! 25: ! 26: //-------------------------------------------------------------------------- ! 27: // BOOL ps_patfill(pdev, pso, flFillMethod, pbo, pptlBrushOrg, mix, ! 28: // prclBound, bInvertPat, bFillPath) ! 29: // PDEVDATA pdev; ! 30: // SURFOBJ *pso; ! 31: // FLONG flFillMethod; ! 32: // BRUSHOBJ *pbo; ! 33: // PPOINTL pptlBrushOrg; ! 34: // MIX mix; ! 35: // RECTL *prclBound; ! 36: // BOOL bInvertPat; ! 37: // BOOL bFillPath; // TRUE if fill path is defined in printer. ! 38: // ! 39: // Parameters: ! 40: // ! 41: // Returns: ! 42: // This function returns no value. ! 43: // ! 44: // History: ! 45: // 17-Mar-1993 updated -by- Rob Kiesler ! 46: // For non-1BPP pattern brushes, create the target bitmap to be passed ! 47: // to the engine in the same format as the brush pattern. ! 48: // 10-Feb-1993 updated -by- Rob Kiesler ! 49: // Let the PS Interpreter perform tiling of 1BPP Pattern Brushes. ! 50: // 03-May-1991 -by- Kent Settle [kentse] ! 51: // Wrote it. ! 52: //-------------------------------------------------------------------------- ! 53: ! 54: BOOL ps_patfill(pdev, pso, flFillMethod, pbo, pptlBrushOrg, mix, ! 55: prclBound, bInvertPat, bFillPath) ! 56: PDEVDATA pdev; ! 57: SURFOBJ *pso; ! 58: FLONG flFillMethod; ! 59: BRUSHOBJ *pbo; ! 60: PPOINTL pptlBrushOrg; ! 61: MIX mix; ! 62: RECTL *prclBound; ! 63: BOOL bInvertPat; ! 64: BOOL bFillPath; // TRUE if fill path is defined in printer. ! 65: { ! 66: DEVBRUSH *pBrush; ! 67: ULONG iPatternIndex; ! 68: BGR_PAL_ENTRY bgr; ! 69: BGR_PAL_ENTRY *pbgr; ! 70: BGR_PAL_ENTRY *pbgrTmp; ! 71: ULONG ulRed, ulGreen, ulBlue; ! 72: PSZ pszFill; ! 73: SIZEL sizlMem; ! 74: HBITMAP hbmMem; ! 75: SURFOBJ *psoMem; ! 76: RECTL rclTarget; ! 77: POINTL ptl, ptlOrg; ! 78: LPSTR *plpstr; ! 79: ROP4 rop4; ! 80: RECTPSFX rectpsfx; ! 81: ULONG ulNextScan; ! 82: ULONG ulWidthBytes; ! 83: ULONG ulStartByte; ! 84: ULONG cCnt; ! 85: ULONG cCurScan; ! 86: ULONG cCurByte; ! 87: ULONG cBytes; ! 88: LONG ShiftBits; ! 89: BYTE curByte; ! 90: PBYTE pbPat; ! 91: ULONG ulbpp; ! 92: #ifdef INDEX_PAL ! 93: ULONG *pulColors; ! 94: ULONG iFormat; ! 95: #endif ! 96: ! 97: // just output the solid color if there is one. ! 98: ! 99: #ifdef INDEX_PAL ! 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: prgb = (PALETTEENTRY *)pulColors + pbo->iSolidColor; ! 109: iPatternIndex = HS_SOLID; ! 110: } ! 111: else ! 112: { ! 113: // get the device brush to draw with. ! 114: ! 115: pBrush = (DEVBRUSH *)BRUSHOBJ_pvGetRbrush(pbo); ! 116: ! 117: if (!pBrush) ! 118: { ! 119: RIP("ps_patfill: pBrush is NULL.\n"); ! 120: return(FALSE); ! 121: } ! 122: else ! 123: { ! 124: if (pBrush->iSolidColor == NOT_SOLID_COLOR) ! 125: { ! 126: // get the foreground color. ! 127: ! 128: prgb = (PALETTEENTRY *)pulColors + ! 129: *(ULONG *)((PBYTE)pBrush + pBrush->offsetXlate + ! 130: sizeof(ULONG)); ! 131: ! 132: // get the index for the pattern. ! 133: ! 134: iPatternIndex = pBrush->iPatIndex; ! 135: } ! 136: else ! 137: { ! 138: prgb = (PALETTEENTRY *)&pBrush->iSolidColor; ! 139: iPatternIndex = HS_SOLID; ! 140: } ! 141: } ! 142: } ! 143: #else ! 144: pbgr = (BGR_PAL_ENTRY *)&pbo->iSolidColor; ! 145: iPatternIndex = HS_SOLID; ! 146: ! 147: if (pbo->iSolidColor == NOT_SOLID_COLOR) ! 148: { ! 149: // get the device brush to draw with. ! 150: ! 151: pBrush = (DEVBRUSH *)BRUSHOBJ_pvGetRbrush(pbo); ! 152: ! 153: if (!pBrush) ! 154: { ! 155: RIP("ps_patfill: pBrush is NULL.\n"); ! 156: return(FALSE); ! 157: } ! 158: ! 159: // get the foreground color. ! 160: ! 161: pbgr = (BGR_PAL_ENTRY *)((PBYTE)pBrush + pBrush->offsetXlate + ! 162: sizeof(ULONG)); ! 163: ! 164: // get the index for the pattern. ! 165: ! 166: iPatternIndex = pBrush->iPatIndex; ! 167: } ! 168: #endif ! 169: ! 170: // now handle the different patterns. the PostScript driver handles ! 171: // patterns in the following manner: at DrvEnablePDEV time we created ! 172: // bitmaps for each of the patterns, in the event that someone actually ! 173: // wants to draw with the pattern in a compatible bitmap. assuming ! 174: // someone is not doing something silly like that, we have been called ! 175: // here to handle the pattern filling. at DrvRealizeBrush time, the ! 176: // driver does a lookup in our internal table to determine the pattern ! 177: // index from the bitmap handle (pBrush->iPatIndex). since bltting ! 178: // these patterns would be SLOW, we will draw them in reasonable ! 179: // ways, depeding on the pattern. ! 180: ! 181: switch(iPatternIndex) ! 182: { ! 183: case HS_DENSE1: ! 184: case HS_DENSE2: ! 185: case HS_DENSE3: ! 186: case HS_DENSE4: ! 187: case HS_DENSE5: ! 188: case HS_DENSE6: ! 189: case HS_DENSE7: ! 190: case HS_DENSE8: ! 191: // Seperate the Red, Green, and Blue color planes. ! 192: ! 193: #ifdef INDEX_PAL ! 194: ulRed = (ULONG)prgb->peRed; ! 195: ulGreen = (ULONG)prgb->peGreen; ! 196: ulBlue = (ULONG)prgb->peBlue; ! 197: #else ! 198: ulRed = (ULONG)pbgr->bgrRed; ! 199: ulGreen = (ULONG)pbgr->bgrGreen; ! 200: ulBlue = (ULONG)pbgr->bgrBlue; ! 201: #endif ! 202: ! 203: // adjust their intensities by the pattern percentage. ! 204: ! 205: ulRed += PSFXTOL((255L - ulRed) * ! 206: apsfxPatGray[iPatternIndex - HS_DENSE1]); ! 207: ulGreen += PSFXTOL((255L - ulGreen) * ! 208: apsfxPatGray[iPatternIndex - HS_DENSE1]); ! 209: ulBlue += PSFXTOL((255L - ulBlue) * ! 210: apsfxPatGray[iPatternIndex - HS_DENSE1]); ! 211: ! 212: // Recombine the Red, Green, and Blue values into an RGB color ! 213: ! 214: #ifdef INDEX_PAL ! 215: rgb.peRed = (BYTE)ulRed; ! 216: rgb.peGreen = (BYTE)ulGreen; ! 217: rgb.peBlue = (BYTE)ulBlue; ! 218: #else ! 219: bgr.bgrRed = (BYTE)ulRed; ! 220: bgr.bgrGreen = (BYTE)ulGreen; ! 221: bgr.bgrBlue = (BYTE)ulBlue; ! 222: #endif ! 223: ! 224: pbgr = &bgr; ! 225: ! 226: // fall through to the HS_SOLID code, with pe set up for ! 227: // the shading. ! 228: ! 229: case HS_SOLID: ! 230: ps_setrgbcolor(pdev, pbgr); ! 231: ps_fill(pdev, flFillMethod); ! 232: break; ! 233: ! 234: case HS_NOSHADE: ! 235: // just destroy the path. there is no filling to do. ! 236: ! 237: ps_newpath(pdev); ! 238: break; ! 239: ! 240: case HS_HALFTONE: ! 241: // Seperate the Red, Green, and Blue color planes. ! 242: ! 243: #ifdef INDEX_PAL ! 244: ulRed = (ULONG)prgb->peRed; ! 245: ulGreen = (ULONG)prgb->peGreen; ! 246: ulBlue = (ULONG)prgb->peBlue; ! 247: #else ! 248: ulRed = (ULONG)pbgr->bgrRed; ! 249: ulGreen = (ULONG)pbgr->bgrGreen; ! 250: ulBlue = (ULONG)pbgr->bgrBlue; ! 251: #endif ! 252: // adjust their intensities by one half. ! 253: ! 254: ulRed += PSFXTOL((255L - ulRed) * PSFXONEHALF); ! 255: ulGreen += PSFXTOL((255L - ulGreen) * PSFXONEHALF); ! 256: ulBlue += PSFXTOL((255L - ulBlue) * PSFXONEHALF); ! 257: ! 258: // Recombine the Red, Green, and Blue values into an RGB color ! 259: ! 260: #ifdef INDEX_PAL ! 261: rgb.peRed = (BYTE)ulRed; ! 262: rgb.peGreen = (BYTE)ulGreen; ! 263: rgb.peBlue = (BYTE)ulBlue; ! 264: #else ! 265: bgr.bgrRed = (BYTE)ulRed; ! 266: bgr.bgrGreen = (BYTE)ulGreen; ! 267: bgr.bgrBlue = (BYTE)ulBlue; ! 268: #endif ! 269: ps_setrgbcolor(pdev, &bgr); ! 270: ps_fill(pdev, flFillMethod); ! 271: break; ! 272: ! 273: // if we get this far, we either have one of the hatched brushes, ! 274: // or a user defined bitmap pattern. ! 275: ! 276: case HS_HORIZONTAL: ! 277: case HS_VERTICAL: ! 278: case HS_BDIAGONAL1: ! 279: case HS_BDIAGONAL: ! 280: case HS_FDIAGONAL1: ! 281: case HS_FDIAGONAL: ! 282: case HS_CROSS: ! 283: case HS_DIAGCROSS: ! 284: // set the foreground color. check to see if the invert pattern ! 285: // flag is set, and reverse the colors if so. ! 286: ! 287: if (bInvertPat) ! 288: { ! 289: #ifdef INDEX_PAL ! 290: prgbTmp = prgb; ! 291: prgb = (BGR_PAL_ENTRY *)pulColors + ! 292: *(ULONG *)((PBYTE)pBrush + pBrush->offsetXlate); ! 293: #else ! 294: pbgrTmp = pbgr; ! 295: pbgr = (BGR_PAL_ENTRY *)((PBYTE)pBrush + pBrush->offsetXlate); ! 296: #endif ! 297: } ! 298: ! 299: ps_setrgbcolor(pdev, pbgr); ! 300: ! 301: // if the background is not transparent, save the path, fill the path ! 302: // with the background color, then restore the path. ! 303: ! 304: if (((mix >> 8) & 0xFF) != R2_NOP) ! 305: { ! 306: // this section of code does a gsave, fills the background ! 307: // color, and then a grestore. it does this so that the ! 308: // foreground pattern can then be drawn. TRUE means to do ! 309: // a gsave, not a save command. ! 310: ! 311: if (!ps_save(pdev, TRUE)) ! 312: return(FALSE); ! 313: ! 314: #ifdef INDEX_PAL ! 315: if (bInvertPat) ! 316: prgb = prgbTmp; ! 317: else ! 318: prgb = (BGR_PAL_ENTRY *)pulColors + ! 319: *(ULONG *)((PBYTE)pBrush + pBrush->offsetXlate); ! 320: #else ! 321: if (bInvertPat) ! 322: pbgr = pbgrTmp; ! 323: else ! 324: pbgr = (BGR_PAL_ENTRY *)((PBYTE)pBrush + pBrush->offsetXlate); ! 325: #endif ! 326: ! 327: ps_setrgbcolor(pdev, pbgr); ! 328: ps_fill(pdev, flFillMethod); ! 329: ! 330: if (!ps_restore(pdev, TRUE)) ! 331: return(FALSE); ! 332: } ! 333: ! 334: // if the base pattern definitions code has not yet been downloaded ! 335: // to the printer, do it now. ! 336: ! 337: if(!(pdev->cgs.dwFlags & CGS_BASEPATSENT)) ! 338: { ! 339: plpstr = apszBase; ! 340: while (*plpstr) ! 341: { ! 342: PrintString(pdev, (PSZ)*plpstr++); ! 343: PrintString(pdev, "\n"); ! 344: } ! 345: pdev->cgs.dwFlags |= CGS_BASEPATSENT; ! 346: } ! 347: ! 348: // we will do a gsave/grestore around the pattern fill. TRUE ! 349: // means to do a gsave, not a save command. ! 350: ! 351: if (!ps_save(pdev, TRUE)) ! 352: return(FALSE); ! 353: ! 354: // let the printer know which fill method to use. ! 355: ! 356: if (flFillMethod & FP_WINDINGMODE) ! 357: pszFill = "psize"; ! 358: else ! 359: pszFill = "eopsize"; ! 360: ! 361: // make sure the linewidth for the patterns is .01 inch. ! 362: ! 363: ps_setlinewidth(pdev, PSFX_DEFAULT_LINEWIDTH); ! 364: ! 365: // output the specific command for each pattern. ! 366: ! 367: switch(iPatternIndex) ! 368: { ! 369: case HS_HORIZONTAL: ! 370: PrintString(pdev, pszFill); ! 371: PrintString(pdev, " phoriz "); ! 372: break; ! 373: ! 374: case HS_VERTICAL: ! 375: PrintString(pdev, "90 rotate "); ! 376: PrintString(pdev, pszFill); ! 377: PrintString(pdev, " phoriz "); ! 378: break; ! 379: ! 380: case HS_BDIAGONAL1: ! 381: PrintString(pdev, "30 rotate "); ! 382: PrintString(pdev, pszFill); ! 383: PrintString(pdev, " phoriz "); ! 384: break; ! 385: ! 386: case HS_BDIAGONAL: ! 387: PrintString(pdev, "45 rotate "); ! 388: PrintString(pdev, pszFill); ! 389: PrintString(pdev, " phoriz "); ! 390: break; ! 391: ! 392: case HS_FDIAGONAL1: ! 393: PrintString(pdev, "-30 rotate "); ! 394: PrintString(pdev, pszFill); ! 395: PrintString(pdev, " phoriz "); ! 396: break; ! 397: ! 398: case HS_FDIAGONAL: ! 399: PrintString(pdev, "-45 rotate "); ! 400: PrintString(pdev, pszFill); ! 401: PrintString(pdev, " phoriz "); ! 402: break; ! 403: ! 404: case HS_CROSS: ! 405: PrintString(pdev, "gs "); ! 406: PrintString(pdev, pszFill); ! 407: PrintString(pdev, " phoriz gr 90 rotate "); ! 408: PrintString(pdev, pszFill); ! 409: PrintString(pdev, " phoriz "); ! 410: break; ! 411: ! 412: case HS_DIAGCROSS: ! 413: PrintString(pdev, "gs 45 rotate "); ! 414: PrintString(pdev, pszFill); ! 415: PrintString(pdev, " phoriz gr -45 rotate "); ! 416: PrintString(pdev, pszFill); ! 417: PrintString(pdev, " phoriz "); ! 418: break; ! 419: } ! 420: ! 421: if (!ps_restore(pdev, TRUE)) ! 422: return(FALSE); ! 423: ! 424: ps_newpath(pdev); ! 425: break; ! 426: ! 427: default: ! 428: // we have a user defined bitmap pattern. the bitmap ! 429: // can be monochrome or color. the initial method for ! 430: // filling with a bitmap pattern will be as follows: ! 431: // ! 432: // ! 433: // If the bitmap is 1BPP, download the PS pattern ! 434: // tiling procest if neccessary and invoke the "prf" ! 435: // operator which will tile the bitmap pattern into the ! 436: // destination rectangle. ! 437: // ! 438: // If the bitmap is >1BPP, a memory bitmap the size of the ! 439: // bounding rectangle will be created, and filled with the ! 440: // pattern. this memory bitmap will then be blted to the ! 441: // printer which will handle clipping to the path. ! 442: // ! 443: // NOTE: current windows implementation uses only the ! 444: // upper/lower left 8x8 bits of the bitmap for the pattern, ! 445: // no matter what size the bitmap itself is. for now we ! 446: // will print the entire bitmap as the pattern. supposedly, ! 447: // future engine functionality will support this. ! 448: ! 449: // since we have a user defined pattern, and we will be ! 450: // calling BitBlt to do the work, we want to clip to the ! 451: // path which was defined in DrvCommonPath. ! 452: ! 453: if (bFillPath) ! 454: { ! 455: if (flFillMethod & FP_WINDINGMODE) ! 456: ps_clip(pdev, TRUE); ! 457: else ! 458: ps_clip(pdev, FALSE); ! 459: } ! 460: ! 461: // a path will have been defined in the printer before calling ! 462: // ps_patfill to fill to. since user defined patterns do not ! 463: // use the fill command, we do not want a path sitting around ! 464: // in the printer. ! 465: ! 466: ps_newpath(pdev); ! 467: ! 468: //!!! OPTIMIZATION !!! ! 469: //!!! perhaps if we have a monochrome bitmap, we should ! 470: //!!! define it as a character of a font, then tile that ! 471: //!!! character over the clip path. ! 472: ! 473: sizlMem.cx = prclBound->right - prclBound->left; ! 474: sizlMem.cy = prclBound->bottom - prclBound->top; ! 475: ! 476: // ! 477: // If this is a 1BPP Bitmap Brush, generate PS code ! 478: // to handle it. ! 479: // ! 480: ! 481: if (pBrush->iFormat == BMF_1BPP) ! 482: { ! 483: // ! 484: // Check to see if any of the PS bitmap pattern code ! 485: // has been downloaded. ! 486: // ! 487: if(!(pdev->dwFlags & PDEV_UTILSSENT)) ! 488: { ! 489: // ! 490: // Download the Adobe PS Utilities Procset. ! 491: // ! 492: PrintString(pdev, "/Adobe_WinNT_Driver_Gfx 175 dict dup begin\n"); ! 493: if (!bSendPSProcSet(pdev, UTILS)) ! 494: { ! 495: RIP("PSCRIPT!ps_patfill: Couldn't download Utils Procset.\n"); ! 496: return(FALSE); ! 497: } ! 498: PrintString(pdev, "end def\n[ 1.000 0 0 1.000 0 0 ] Adobe_WinNT_Driver_Gfx dup /initialize get exec\n"); ! 499: pdev->dwFlags |= PDEV_UTILSSENT; ! 500: } ! 501: ! 502: if(!(pdev->dwFlags & PDEV_BMPPATSENT)) ! 503: { ! 504: // ! 505: // Download the Adobe PS Pattern Bitmap Procset. ! 506: // ! 507: PrintString(pdev, "Adobe_WinNT_Driver_Gfx begin\n"); ! 508: if (!bSendPSProcSet(pdev, PATTERN)) ! 509: { ! 510: RIP("PSCRIPT!ps_patfill: Couldn't download Pattern Bmp Procset.\n"); ! 511: return(FALSE); ! 512: } ! 513: PrintString(pdev, "end reinitialize\n"); ! 514: pdev->dwFlags |= PDEV_BMPPATSENT; ! 515: ! 516: } ! 517: ! 518: // ! 519: // First Convert Destination Rect Coordinates to fixed ! 520: // point. ! 521: // ! 522: rectpsfx.xLeft = X72DPI(prclBound->left); ! 523: rectpsfx.yBottom = Y72DPI(prclBound->bottom); ! 524: ! 525: // ! 526: // Compute the destination rectangle extents, and convert ! 527: // to fixed point. ! 528: // ! 529: rectpsfx.xRight = ((prclBound->right - prclBound->left) ! 530: * PS_FIX_RESOLUTION) / pdev->psdm.dm.dmPrintQuality; ! 531: rectpsfx.yTop = ((prclBound->bottom - prclBound->top) ! 532: * PS_FIX_RESOLUTION) / pdev->psdm.dm.dmPrintQuality; ! 533: ! 534: PrintPSFIX(pdev, 4, rectpsfx.xLeft, rectpsfx.yBottom, ! 535: rectpsfx.xRight, rectpsfx.yTop); ! 536: ! 537: // ! 538: // Get the bg color from the pBrush and convert to ! 539: // PS format. ! 540: // ! 541: #ifdef INDEX_PAL ! 542: prgb = (BGR_PAL_ENTRY *)pulColors + ! 543: *(ULONG *)((PBYTE)pBrush + pBrush->offsetXlate); ! 544: #else ! 545: pbgr = (BGR_PAL_ENTRY *)((PBYTE)pBrush + pBrush->offsetXlate); ! 546: #endif ! 547: ! 548: PrintString(pdev, " ["); ! 549: PrintPSFIX(pdev, 3, LTOPSFX((ULONG)pbgr->bgrRed) / 255, ! 550: LTOPSFX((ULONG)pbgr->bgrGreen) / 255, ! 551: LTOPSFX((ULONG)pbgr->bgrBlue) / 255); ! 552: PrintString(pdev, " false]"); ! 553: ! 554: // ! 555: // Get the fg color from the pBrush and convert to ! 556: // PS format. ! 557: // ! 558: ! 559: #ifdef INDEX_PAL ! 560: prgb = (BGR_PAL_ENTRY *)pulColors + ! 561: *(ULONG *)((PBYTE)pBrush + pBrush->offsetXlate + ! 562: sizeof(ULONG)); ! 563: #else ! 564: pbgr = (BGR_PAL_ENTRY *)((PBYTE)pBrush + pBrush->offsetXlate + ! 565: sizeof(ULONG)); ! 566: #endif ! 567: ! 568: PrintString(pdev, " ["); ! 569: ! 570: PrintPSFIX(pdev, 3, LTOPSFX((ULONG)pbgr->bgrRed) / 255, ! 571: LTOPSFX((ULONG)pbgr->bgrGreen) / 255, ! 572: LTOPSFX((ULONG)pbgr->bgrBlue) / 255); ! 573: PrintString(pdev, " false] "); ! 574: ! 575: // ! 576: // Send down the pattern x and y extents. ! 577: // ! 578: PrintDecimal(pdev, 2, pBrush->sizlBitmap.cx, ! 579: pBrush->sizlBitmap.cy); ! 580: ! 581: // ! 582: // Compute the width in bytes of each scanline in the ! 583: // pattern bitmap, rounded to the nearest dword boundary. ! 584: // ! 585: ulWidthBytes = (pBrush->sizlBitmap.cx + 7) / 8; ! 586: ulNextScan = ((pBrush->sizlBitmap.cx + 31) / 32) << 2; ! 587: ! 588: PrintString(pdev," <"); ! 589: ! 590: // ! 591: // Send the pattern bitmap. The PS pattern fill operator ! 592: // doesn't need the padding bytes at the end of each ! 593: // scanline. ! 594: // ! 595: pbPat = pBrush->ajBits; ! 596: ! 597: if (!pptlBrushOrg->y && !pptlBrushOrg->x) ! 598: { ! 599: // ! 600: // The brush pattern doesn't require rotation, ! 601: // send it down a scanline at a time. ! 602: // ! 603: for (cCnt = 0;cCnt < (ULONG)pBrush->sizlBitmap.cy;cCnt++) ! 604: { ! 605: vHexOut(pdev, pbPat, ulWidthBytes); ! 606: pbPat += ulNextScan; ! 607: } ! 608: } ! 609: else ! 610: { ! 611: ! 612: // ! 613: // The Brush pattern requires rotation. Calculate the ! 614: // byte offset of the x origin. ! 615: // ! 616: ! 617: // let's first yank the origin to somewhere inside our ! 618: // bitmap. ! 619: ! 620: ptlOrg.x = pptlBrushOrg->x % pBrush->sizlBitmap.cx; ! 621: if (ptlOrg.x < 0) ! 622: ptlOrg.x = ptlOrg.x + pBrush->sizlBitmap.cx; ! 623: ! 624: ptlOrg.y = pptlBrushOrg->y % pBrush->sizlBitmap.cy; ! 625: if (ptlOrg.y < 0) ! 626: ptlOrg.y = ptlOrg.y + pBrush->sizlBitmap.cy; ! 627: ! 628: ulStartByte = ptlOrg.x / 8; ! 629: ! 630: if (!(ShiftBits = ptlOrg.x % 8)) ! 631: { ! 632: // ! 633: // The x origin is byte aligned. Apply the proper ! 634: // byte rotation and send a scanline (or a partial ! 635: // scanline) at a time. ! 636: // ! 637: for (cCnt = 0;cCnt < (ULONG)pBrush->sizlBitmap.cy;cCnt++) ! 638: { ! 639: cCurScan = ((cCnt + ptlOrg.y) % pBrush->sizlBitmap.cy) ! 640: * ulNextScan; ! 641: vHexOut(pdev, &(pbPat[cCurScan + ulStartByte]), ! 642: ulWidthBytes - ulStartByte); ! 643: if (ulStartByte) ! 644: vHexOut(pdev, &(pbPat[cCurScan]), ulStartByte); ! 645: } ! 646: } ! 647: else ! 648: { ! 649: // ! 650: // The x origin is not byte aligned, rotate and send ! 651: // the pattern bitmap a byte at a time. ! 652: // ! 653: for (cCnt = 0;cCnt < (ULONG)pBrush->sizlBitmap.cy;cCnt++) ! 654: { ! 655: cCurScan = ((cCnt + ptlOrg.y) % pBrush->sizlBitmap.cy) ! 656: * ulNextScan; ! 657: for (cBytes = 0;cBytes < ulWidthBytes;cBytes++) ! 658: { ! 659: cCurByte = (cBytes + ulStartByte) % ulWidthBytes; ! 660: curByte = pbPat[cCurScan + cCurByte] >> ShiftBits; ! 661: cCurByte = ++cCurByte % ulWidthBytes; ! 662: curByte |= (pbPat[cCurScan + cCurByte] << (8 - ShiftBits)); ! 663: vHexOut(pdev, &curByte, 1); ! 664: } ! 665: } ! 666: } ! 667: } ! 668: ! 669: // ! 670: // Close the pattern data array object, and invoke the ! 671: // prf (pattern rect fill) operator. ! 672: // ! 673: PrintString(pdev,"> prf\n"); ! 674: break; ! 675: } ! 676: ! 677: // create a memory bitmap which is the size of the ! 678: // bounding box of the current path, and is compatible ! 679: // with the pattern bitmap. ! 680: ! 681: ! 682: // ! 683: // Compute the scanline delta. First get then number of ! 684: // pels/scanline. ! 685: // ! 686: ulNextScan = sizlMem.cx; ! 687: ! 688: // ! 689: // times how many bits per pel. ! 690: // ! 691: switch (pBrush->iFormat) ! 692: { ! 693: case BMF_4BPP: ! 694: ulbpp = 4; ! 695: break; ! 696: ! 697: case BMF_8BPP: ! 698: ulbpp = 8; ! 699: break; ! 700: ! 701: case BMF_16BPP: ! 702: ulbpp = 16; ! 703: break; ! 704: ! 705: case BMF_24BPP: ! 706: ulbpp = 24; ! 707: break; ! 708: ! 709: case BMF_32BPP: ! 710: ulbpp = 32; ! 711: break; ! 712: } ! 713: ! 714: ulNextScan *= ulbpp; ! 715: ! 716: // ! 717: // Now convert ulNextScan to the number of bytes per scanline, ! 718: // taking into account that scanlines are padded out to 32 bit ! 719: // boundaries. ! 720: // ! 721: ulNextScan = ((ulNextScan + 31) / 32) * 4; ! 722: ! 723: #ifdef INDEX_PAL ! 724: if ((pdev->pntpd->flFlags & COLOR_DEVICE) && ! 725: (pdev->psdm.dm.dmColor == DMCOLOR_COLOR)) ! 726: iFormat = BMF_4BPP; ! 727: else ! 728: iFormat = BMF_1BPP; ! 729: ! 730: hbmMem = EngCreateBitmap(sizlMem, ulNextScan, iFormat, ! 731: pBrush->flBitmap, (PVOID)NULL); ! 732: #else ! 733: hbmMem = EngCreateBitmap(sizlMem, ulNextScan, BMF_24BPP, ! 734: pBrush->flBitmap, (PVOID)NULL); ! 735: #endif ! 736: ! 737: if (hbmMem == 0) ! 738: { ! 739: RIP("PSCRIPT!ps_patfill: EngCreateBitmap for hbmMem failed.\n"); ! 740: return(FALSE); ! 741: } ! 742: ! 743: // get the SURFOBJ for the memory bitmap. ! 744: ! 745: psoMem = (SURFOBJ *)EngLockSurface((HSURF)hbmMem); ! 746: ! 747: if (psoMem == (SURFOBJ *)NULL) ! 748: { ! 749: RIP("ps_patfill: EngLockSurface for psoMem failed.\n"); ! 750: EngDeleteSurface((HSURF)hbmMem); ! 751: return(FALSE); ! 752: } ! 753: ! 754: // do a patcopy into the memory bitmap. ! 755: ! 756: rclTarget.left = 0; ! 757: rclTarget.top = 0; ! 758: rclTarget.right = sizlMem.cx; ! 759: rclTarget.bottom = sizlMem.cy; ! 760: ! 761: if (bInvertPat) ! 762: rop4 = 0x5A5A; // invert pattern. ! 763: else ! 764: rop4 = 0xF0F0; // patcopy. ! 765: ! 766: if (!(EngBitBlt(psoMem, (SURFOBJ *)NULL, (SURFOBJ *)NULL, ! 767: (CLIPOBJ *)NULL, (XLATEOBJ *)NULL, &rclTarget, ! 768: (PPOINTL)NULL, (PPOINTL)NULL, pbo, ! 769: pptlBrushOrg, rop4))) ! 770: { ! 771: RIP("ps_patfill: EngBitBlt pat to mem failed.\n"); ! 772: EngUnlockSurface(psoMem); ! 773: EngDeleteSurface((HSURF)hbmMem); ! 774: return(FALSE); ! 775: } ! 776: ! 777: // now that the memory bitmap is filled with the pattern, ! 778: // bitblt it to the printer. the printer will handle clipping. ! 779: ! 780: // source origin. ! 781: ! 782: ptl.x = 0; ! 783: ptl.y = 0; ! 784: ! 785: if (!(DrvBitBlt(pso, psoMem, (SURFOBJ *)NULL, ! 786: (CLIPOBJ *)NULL, (XLATEOBJ *)NULL, prclBound, ! 787: &ptl, (PPOINTL)NULL, pbo, ! 788: pptlBrushOrg, 0xCCCC))) ! 789: { ! 790: RIP("ps_patfill: EngBitBlt mem to printer failed.\n"); ! 791: EngUnlockSurface(psoMem); ! 792: EngDeleteSurface((HSURF)hbmMem); ! 793: return(FALSE); ! 794: } ! 795: ! 796: // release stuff. ! 797: ! 798: if (psoMem) ! 799: { ! 800: EngUnlockSurface(psoMem); ! 801: EngDeleteSurface((HSURF)hbmMem); ! 802: } ! 803: } ! 804: ! 805: return(TRUE); ! 806: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.