![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cfbfillsp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / cfb|
Return to cfbfillsp.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / cfb |
1.1 ! root 1: /************************************************************ ! 2: Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA. ! 3: ! 4: All Rights Reserved ! 5: ! 6: Permission to use, copy, modify, and distribute this ! 7: software and its documentation for any purpose and without ! 8: fee is hereby granted, provided that the above copyright no- ! 9: tice appear in all copies and that both that copyright no- ! 10: tice and this permission notice appear in supporting docu- ! 11: mentation, and that the names of Sun or MIT not be used in ! 12: advertising or publicity pertaining to distribution of the ! 13: software without specific prior written permission. Sun and ! 14: M.I.T. make no representations about the suitability of this ! 15: software for any purpose. It is provided "as is" without any ! 16: express or implied warranty. ! 17: ! 18: SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, ! 19: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT- ! 20: NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI- ! 21: ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 22: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR ! 23: PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR ! 24: OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH ! 25: THE USE OR PERFORMANCE OF THIS SOFTWARE. ! 26: ! 27: ********************************************************/ ! 28: ! 29: /*********************************************************** ! 30: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts, ! 31: and the Massachusetts Institute of Technology, Cambridge, Massachusetts. ! 32: ! 33: All Rights Reserved ! 34: ! 35: Permission to use, copy, modify, and distribute this software and its ! 36: documentation for any purpose and without fee is hereby granted, ! 37: provided that the above copyright notice appear in all copies and that ! 38: both that copyright notice and this permission notice appear in ! 39: supporting documentation, and that the names of Digital or MIT not be ! 40: used in advertising or publicity pertaining to distribution of the ! 41: software without specific, written prior permission. ! 42: ! 43: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 44: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 45: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 46: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 47: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 48: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 49: SOFTWARE. ! 50: ! 51: ******************************************************************/ ! 52: #include "X.h" ! 53: #include "Xmd.h" ! 54: #include "servermd.h" ! 55: #include "gcstruct.h" ! 56: #include "window.h" ! 57: #include "pixmapstr.h" ! 58: #include "scrnintstr.h" ! 59: ! 60: #include "cfb.h" ! 61: #include "cfbmskbits.h" ! 62: ! 63: /* scanline filling for color frame buffer ! 64: written by drewry, oct 1986 modified by smarks ! 65: changes for compatibility with Little-endian systems Jul 1987; MIT:yba. ! 66: ! 67: these routines all clip. they assume that anything that has called ! 68: them has already translated the points (i.e. pGC->miTranslate is ! 69: non-zero, which is howit gets set in cfbCreateGC().) ! 70: ! 71: the number of new scnalines created by clipping == ! 72: MaxRectsPerBand * nSpans. ! 73: ! 74: FillSolid is overloaded to be used for OpaqueStipple as well, ! 75: if fgPixel == bgPixel. ! 76: Note that for solids, PrivGC.rop == PrivGC.ropOpStip ! 77: ! 78: ! 79: FillTiled is overloaded to be used for OpaqueStipple, if ! 80: fgPixel != bgPixel. based on the fill style, it uses ! 81: {RotatedTile, gc.alu} or {RotatedStipple, PrivGC.ropOpStip} ! 82: */ ! 83: ! 84: #ifdef notdef ! 85: #include <stdio.h> ! 86: static ! 87: dumpspans(n, ppt, pwidth) ! 88: int n; ! 89: DDXPointPtr ppt; ! 90: int *pwidth; ! 91: { ! 92: fprintf(stderr,"%d spans\n", n); ! 93: while (n--) { ! 94: fprintf(stderr, "[%d,%d] %d\n", ppt->x, ppt->y, *pwidth); ! 95: ppt++; ! 96: pwidth++; ! 97: } ! 98: fprintf(stderr, "\n"); ! 99: } ! 100: #endif ! 101: ! 102: void ! 103: cfbSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 104: DrawablePtr pDrawable; ! 105: GCPtr pGC; ! 106: int nInit; /* number of spans to fill */ ! 107: DDXPointPtr pptInit; /* pointer to list of start points */ ! 108: int *pwidthInit; /* pointer to list of n widths */ ! 109: int fSorted; ! 110: { ! 111: /* next three parameters are post-clip */ ! 112: int n; /* number of spans to fill */ ! 113: register DDXPointPtr ppt; /* pointer to list of start points */ ! 114: register int *pwidth; /* pointer to list of n widths */ ! 115: int *addrlBase; /* pointer to start of bitmap */ ! 116: int nlwidth; /* width in longwords of bitmap */ ! 117: register int *addrl; /* pointer to current longword in bitmap */ ! 118: register int startmask; ! 119: register int endmask; ! 120: register int nlmiddle; ! 121: int rop; /* reduced rasterop */ ! 122: int *pwidthFree; /* copies of the pointers to free */ ! 123: DDXPointPtr pptFree; ! 124: int fill, rrop; ! 125: ! 126: switch (pDrawable->depth) { ! 127: case 1: ! 128: rrop = ReduceRop( pGC->alu, pGC->fgPixel ); ! 129: switch ( rrop ) { ! 130: case RROP_BLACK: ! 131: mfbBlackSolidFS(pDrawable, pGC, nInit, pptInit, ! 132: pwidthInit, fSorted); ! 133: break; ! 134: case RROP_WHITE: ! 135: mfbWhiteSolidFS(pDrawable, pGC, nInit, pptInit, ! 136: pwidthInit, fSorted); ! 137: break; ! 138: case RROP_NOP: ! 139: return; ! 140: case RROP_INVERT: ! 141: mfbInvertSolidFS(pDrawable, pGC, nInit, pptInit, ! 142: pwidthInit, fSorted); ! 143: break; ! 144: } ! 145: return; ! 146: case 8: ! 147: break; ! 148: default: ! 149: FatalError("cfbSolidFS: invalid depth\n"); ! 150: } ! 151: ! 152: if (!(pGC->planemask)) ! 153: return; ! 154: ! 155: n = nInit * miFindMaxBand(((cfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 156: pwidth = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 157: ppt = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 158: if(!ppt || !pwidth) ! 159: { ! 160: DEALLOCATE_LOCAL(ppt); ! 161: DEALLOCATE_LOCAL(pwidth); ! 162: return; ! 163: } ! 164: #ifdef notdef ! 165: dumpspans(n, pptInit, pwidthInit); ! 166: #endif ! 167: pwidthFree = pwidth; ! 168: pptFree = ppt; ! 169: n = miClipSpans(((cfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 170: pptInit, pwidthInit, nInit, ! 171: ppt, pwidth, fSorted); ! 172: ! 173: #ifdef notdef ! 174: dumpspans(n, ppt, pwidth); ! 175: #endif ! 176: if (pDrawable->type == DRAWABLE_WINDOW) ! 177: { ! 178: addrlBase = (int *) ! 179: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 180: nlwidth = (int) ! 181: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 182: } ! 183: else ! 184: { ! 185: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 186: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 187: } ! 188: ! 189: rop = pGC->alu; ! 190: fill = PFILL(pGC->fgPixel); ! 191: ! 192: while (n--) ! 193: { ! 194: addrl = addrlBase + (ppt->y * nlwidth) + (ppt->x >> PWSH); ! 195: ! 196: if (*pwidth) ! 197: { ! 198: if ( ((ppt->x & PIM) + *pwidth) <= PPW) ! 199: { ! 200: /* all bits inside same longword */ ! 201: putbitsrop( fill, ppt->x & PIM, *pwidth, ! 202: addrl, pGC->planemask, rop ); ! 203: } ! 204: else ! 205: { ! 206: maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); ! 207: if ( startmask ) { ! 208: putbitsrop( fill, ppt->x & PIM, ! 209: PPW-(ppt->x&PIM), addrl, pGC->planemask, rop); ! 210: ++addrl; ! 211: } ! 212: while ( nlmiddle-- ) { ! 213: putbitsrop( fill, 0, PPW, ! 214: addrl, pGC->planemask, rop ); ! 215: ++addrl; ! 216: } ! 217: if ( endmask ) { ! 218: putbitsrop( fill, 0, ! 219: ((ppt->x + *pwidth)&PIM), addrl, pGC->planemask, rop ); ! 220: } ! 221: } ! 222: } ! 223: pwidth++; ! 224: ppt++; ! 225: } ! 226: DEALLOCATE_LOCAL(pptFree); ! 227: DEALLOCATE_LOCAL(pwidthFree); ! 228: } ! 229: ! 230: ! 231: /* Fill spans with tiles that aren't 32 bits wide */ ! 232: void ! 233: cfbUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 234: DrawablePtr pDrawable; ! 235: GC *pGC; ! 236: int nInit; /* number of spans to fill */ ! 237: DDXPointPtr pptInit; /* pointer to list of start points */ ! 238: int *pwidthInit; /* pointer to list of n widths */ ! 239: int fSorted; ! 240: { ! 241: int iline; /* first line of tile to use */ ! 242: /* next three parameters are post-clip */ ! 243: int n; /* number of spans to fill */ ! 244: register DDXPointPtr ppt; /* pointer to list of start points */ ! 245: register int *pwidth; /* pointer to list of n widths */ ! 246: int *addrlBase; /* pointer to start of bitmap */ ! 247: int nlwidth; /* width in longwords of bitmap */ ! 248: register int *pdst; /* pointer to current word in bitmap */ ! 249: register int *psrc; /* pointer to current word in tile */ ! 250: register int startmask; ! 251: register int nlMiddle; ! 252: PixmapPtr pTile; /* pointer to tile we want to fill with */ ! 253: int w, width, x, tmpSrc, srcStartOver, nstart, nend; ! 254: int endmask, tlwidth, rem, tileWidth, *psrcT, rop; ! 255: int *pwidthFree; /* copies of the pointers to free */ ! 256: DDXPointPtr pptFree; ! 257: ! 258: switch (pDrawable->depth) { ! 259: case 1: ! 260: mfbUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted); ! 261: return; ! 262: case 8: ! 263: break; ! 264: default: ! 265: FatalError("cfbUnnaturalTileFS: invalid depth\n"); ! 266: } ! 267: ! 268: if (!(pGC->planemask)) ! 269: return; ! 270: ! 271: n = nInit * miFindMaxBand(((cfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 272: pwidth = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 273: ppt = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 274: if(!ppt || !pwidth) ! 275: { ! 276: DEALLOCATE_LOCAL(ppt); ! 277: DEALLOCATE_LOCAL(pwidth); ! 278: return; ! 279: } ! 280: pwidthFree = pwidth; ! 281: pptFree = ppt; ! 282: n = miClipSpans(((cfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 283: pptInit, pwidthInit, nInit, ! 284: ppt, pwidth, fSorted); ! 285: ! 286: if (pGC->fillStyle == FillTiled) ! 287: { ! 288: pTile = ((cfbPrivGC *)(pGC->devPriv))->pRotatedTile; ! 289: tlwidth = pTile->devKind >> 2; ! 290: rop = pGC->alu; ! 291: } ! 292: else ! 293: { ! 294: pTile = ((cfbPrivGC *)(pGC->devPriv))->pRotatedStipple; ! 295: tlwidth = pTile->devKind >> 2; ! 296: rop = pGC->alu; ! 297: } ! 298: ! 299: if (pDrawable->type == DRAWABLE_WINDOW) ! 300: { ! 301: addrlBase = (int *) ! 302: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 303: nlwidth = (int) ! 304: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 305: } ! 306: else ! 307: { ! 308: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 309: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 310: } ! 311: ! 312: tileWidth = pTile->width; ! 313: while (n--) ! 314: { ! 315: iline = ppt->y % pTile->height; ! 316: pdst = addrlBase + (ppt->y * nlwidth) + (ppt->x >> PWSH); ! 317: psrcT = (int *) pTile->devPrivate + (iline * tlwidth); ! 318: x = ppt->x; ! 319: ! 320: if (*pwidth) ! 321: { ! 322: width = *pwidth; ! 323: while(width > 0) ! 324: { ! 325: rem = x % tileWidth; ! 326: psrc = psrcT + rem / PPW; ! 327: w = min(tileWidth, width); ! 328: w = min(w,tileWidth-rem); ! 329: #ifdef notdef ! 330: if((rem = x % tileWidth) != 0) ! 331: { ! 332: w = min(min(tileWidth - rem, width), PPW); ! 333: /* we want to grab from the end of the tile. Figure ! 334: * out where that is. In general, the start of the last ! 335: * word of data on this scanline is tlwidth -1 words ! 336: * away. But if we want to grab more bits than we'll ! 337: * find on that line, we have to back up 1 word further. ! 338: * On the other hand, if the whole tile fits in 1 word, ! 339: * let's skip the work */ ! 340: endinc = tlwidth - 1 - (tileWidth-rem) / PPW; ! 341: ! 342: if(endinc) ! 343: { ! 344: if((rem & PIM) + w > tileWidth % PPW) ! 345: endinc--; ! 346: } ! 347: ! 348: getbits(psrc + endinc, rem & PIM, w, tmpSrc); ! 349: putbitsrop(tmpSrc, (x & PIM), w, pdst, ! 350: pGC->planemask, rop); ! 351: if((x & PIM) + w >= PPW) ! 352: pdst++; ! 353: } ! 354: else ! 355: #endif notdef ! 356: if(((rem & PIM) + w) <= PPW) ! 357: { ! 358: getbits(psrc, (rem & PIM), w, tmpSrc); ! 359: putbitsrop(tmpSrc, x & PIM, w, pdst, ! 360: pGC->planemask, rop); ! 361: ++pdst; ! 362: } ! 363: else ! 364: { ! 365: maskbits(x, w, startmask, endmask, nlMiddle); ! 366: ! 367: if (startmask) ! 368: nstart = PPW - (x & PIM); ! 369: else ! 370: nstart = 0; ! 371: if (endmask) ! 372: nend = (x + w) & PIM; ! 373: else ! 374: nend = 0; ! 375: ! 376: srcStartOver = nstart > PLST; ! 377: ! 378: if(startmask) ! 379: { ! 380: getbits(psrc, rem & PIM, nstart, tmpSrc); ! 381: putbitsrop(tmpSrc, x & PIM, nstart, pdst, ! 382: pGC->planemask, rop); ! 383: pdst++; ! 384: psrc++; ! 385: } ! 386: ! 387: while(nlMiddle--) ! 388: { ! 389: getbits(psrc, 0, PPW, tmpSrc); ! 390: putbitsrop( tmpSrc, 0, PPW, ! 391: pdst, pGC->planemask, rop ); ! 392: pdst++; ! 393: psrc++; ! 394: } ! 395: if(endmask) ! 396: { ! 397: getbits(psrc, 0, nend, tmpSrc); ! 398: putbitsrop(tmpSrc, 0, nend, pdst, ! 399: pGC->planemask, rop); ! 400: } ! 401: } ! 402: x += w; ! 403: width -= w; ! 404: } ! 405: } ! 406: ppt++; ! 407: pwidth++; ! 408: } ! 409: DEALLOCATE_LOCAL(pptFree); ! 410: DEALLOCATE_LOCAL(pwidthFree); ! 411: } ! 412: ! 413: ! 414: /* ! 415: * QuartetBitsTable contains four masks whose binary values are masks in the ! 416: * low order quartet that contain the number of bits specified in the ! 417: * index. This table is used by getstipplepixels. ! 418: */ ! 419: static unsigned int QuartetBitsTable[5] = { ! 420: #if (BITMAP_BIT_ORDER == MSBFirst) ! 421: 0x00000000, /* 0 - 0000 */ ! 422: 0x00000008, /* 1 - 1000 */ ! 423: 0x0000000C, /* 2 - 1100 */ ! 424: 0x0000000E, /* 3 - 1110 */ ! 425: 0x0000000F /* 4 - 1111 */ ! 426: #else /* (BITMAP_BIT_ORDER == LSBFirst */ ! 427: 0x00000000, /* 0 - 0000 */ ! 428: 0x00000001, /* 1 - 0001 */ ! 429: 0x00000003, /* 2 - 0011 */ ! 430: 0x00000007, /* 3 - 0111 */ ! 431: 0x0000000F /* 4 - 1111 */ ! 432: #endif (BITMAP_BIT_ORDER == MSBFirst) ! 433: }; ! 434: ! 435: /* ! 436: * QuartetPixelMaskTable is used by getstipplepixels to get a pixel mask ! 437: * corresponding to a quartet of bits. ! 438: */ ! 439: static unsigned int QuartetPixelMaskTable[16] = { ! 440: 0x00000000, ! 441: 0x000000FF, ! 442: 0x0000FF00, ! 443: 0x0000FFFF, ! 444: 0x00FF0000, ! 445: 0x00FF00FF, ! 446: 0x00FFFF00, ! 447: 0x00FFFFFF, ! 448: 0xFF000000, ! 449: 0xFF0000FF, ! 450: 0xFF00FF00, ! 451: 0xFF00FFFF, ! 452: 0xFFFF0000, ! 453: 0xFFFF00FF, ! 454: 0xFFFFFF00, ! 455: 0xFFFFFFFF ! 456: }; ! 457: ! 458: ! 459: /* ! 460: * getstipplepixels( psrcstip, x, w, ones, psrcpix, destpix ) ! 461: * ! 462: * Converts bits to pixels in a reasonable way. Takes w (1 <= w <= 4) ! 463: * bits from *psrcstip, starting at bit x; call this a quartet of bits. ! 464: * Then, takes the pixels from *psrcpix corresponding to the one-bits (if ! 465: * ones is TRUE) or the zero-bits (if ones is FALSE) of the quartet ! 466: * and puts these pixels into destpix. ! 467: * ! 468: * Example: ! 469: * ! 470: * getstipplepixels( &(0x08192A3B), 17, 4, 1, &(0x4C5D6E7F), dest ) ! 471: * ! 472: * 0x08192A3B = 0000 1000 0001 1001 0010 1010 0011 1011 ! 473: * ! 474: * This will take 4 bits starting at bit 17, so the quartet is 0x5 = 0101. ! 475: * It will take pixels from 0x4C5D6E7F corresponding to the one-bits in this ! 476: * quartet, so dest = 0x005D007F. ! 477: * ! 478: * XXX This should be turned into a macro after it is debugged. ! 479: * XXX Has byte order dependencies. ! 480: * XXX This works for all values of x and w within a doubleword, depending ! 481: * on the compiler to generate proper code for negative shifts. ! 482: */ ! 483: ! 484: void getstipplepixels( psrcstip, x, w, ones, psrcpix, destpix ) ! 485: unsigned int *psrcstip, *psrcpix, *destpix; ! 486: int x, w, ones; ! 487: { ! 488: unsigned int q; ! 489: ! 490: #if (BITMAP_BIT_ORDER == MSBFirst) ! 491: q = ((*psrcstip) >> (28-x)) & 0x0F; ! 492: if ( x+w > 32 ) ! 493: q |= *(psrcstip+1) >> (64-x-w); /* & 0xF ? ****XXX*/ ! 494: #else ! 495: q = (*psrcstip) >> x; ! 496: if ( x+w > 32 ) ! 497: q |= *(psrcstip+1) << (32-x); ! 498: q &= 0xf; ! 499: #endif ! 500: q = QuartetBitsTable[w] & (ones ? q : ~q); ! 501: *destpix = (*(psrcpix)) & QuartetPixelMaskTable[q]; ! 502: } ! 503: ! 504: ! 505: /* Fill spans with stipples that aren't 32 bits wide */ ! 506: void ! 507: cfbUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 508: DrawablePtr pDrawable; ! 509: GC *pGC; ! 510: int nInit; /* number of spans to fill */ ! 511: DDXPointPtr pptInit; /* pointer to list of start points */ ! 512: int *pwidthInit; /* pointer to list of n widths */ ! 513: int fSorted; ! 514: { ! 515: /* next three parameters are post-clip */ ! 516: int n; /* number of spans to fill */ ! 517: int xrem; ! 518: register DDXPointPtr ppt; /* pointer to list of start points */ ! 519: register int *pwidth; /* pointer to list of n widths */ ! 520: int iline; /* first line of tile to use */ ! 521: int *addrlBase; /* pointer to start of bitmap */ ! 522: int nlwidth; /* width in longwords of bitmap */ ! 523: register int *pdst; /* pointer to current word in bitmap */ ! 524: PixmapPtr pStipple; /* pointer to stipple we want to fill with */ ! 525: int w, width, x; ! 526: unsigned int tmpSrc, tmpDst1, tmpDst2; ! 527: int stwidth, stippleWidth, *psrcS, rop; ! 528: int *pwidthFree; /* copies of the pointers to free */ ! 529: DDXPointPtr pptFree; ! 530: unsigned int fgfill, bgfill; ! 531: ! 532: switch (pDrawable->depth) { ! 533: case 1: ! 534: mfbUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, ! 535: pwidthInit, fSorted); ! 536: return; ! 537: case 8: ! 538: break; ! 539: default: ! 540: FatalError("cfbUnnaturalStippleFS: invalid depth\n"); ! 541: } ! 542: ! 543: if (!(pGC->planemask)) ! 544: return; ! 545: ! 546: n = nInit * miFindMaxBand(((cfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 547: pwidth = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 548: ppt = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 549: if(!ppt || !pwidth) ! 550: { ! 551: DEALLOCATE_LOCAL(ppt); ! 552: DEALLOCATE_LOCAL(pwidth); ! 553: return; ! 554: } ! 555: pwidthFree = pwidth; ! 556: pptFree = ppt; ! 557: n = miClipSpans(((cfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 558: pptInit, pwidthInit, nInit, ! 559: ppt, pwidth, fSorted); ! 560: rop = ((cfbPrivGC *)(pGC->devPriv))->rop; ! 561: fgfill = PFILL(pGC->fgPixel); ! 562: bgfill = PFILL(pGC->bgPixel); ! 563: ! 564: /* ! 565: * OK, so what's going on here? We have two Drawables: ! 566: * ! 567: * The Stipple: ! 568: * Depth = 1 ! 569: * Width = stippleWidth ! 570: * Words per scanline = stwidth ! 571: * Pointer to pixels = pStipple->devPrivate ! 572: */ ! 573: pStipple = ((cfbPrivGC *)(pGC->devPriv))->pRotatedStipple; ! 574: ! 575: if (pStipple->drawable.depth != 1) { ! 576: FatalError( "Stipple depth not equal to 1!\n" ); ! 577: } ! 578: ! 579: stwidth = pStipple->devKind >> 2; ! 580: stippleWidth = pStipple->width; ! 581: ! 582: /* ! 583: * The Target: ! 584: * Depth = PSZ ! 585: * Width = determined from *pwidth ! 586: * Words per scanline = nlwidth ! 587: * Pointer to pixels = addrlBase ! 588: */ ! 589: if (pDrawable->type == DRAWABLE_WINDOW) ! 590: { ! 591: addrlBase = (int *) ! 592: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 593: nlwidth = (int) ! 594: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 595: } ! 596: else ! 597: { ! 598: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 599: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 600: } ! 601: ! 602: while (n--) ! 603: { ! 604: iline = ppt->y % pStipple->height; ! 605: x = ppt->x; ! 606: pdst = addrlBase + (ppt->y * nlwidth); ! 607: psrcS = (int *) pStipple->devPrivate + (iline * stwidth); ! 608: ! 609: if (*pwidth) ! 610: { ! 611: width = *pwidth; ! 612: while(width > 0) ! 613: { ! 614: /* ! 615: * Do a stripe through the stipple & destination w pixels ! 616: * wide. w is not more than: ! 617: * - the width of the destination ! 618: * - the width of the stipple ! 619: * - the distance between x and the next word ! 620: * boundary in the destination ! 621: * - the distance between x and the next word ! 622: * boundary in the stipple ! 623: */ ! 624: ! 625: /* width of dest/stipple */ ! 626: xrem = x % stippleWidth; ! 627: w = min((stippleWidth - (x % stippleWidth)), width); ! 628: /* dist to word bound in dest */ ! 629: w = min(w, PPW - (x & PIM)); ! 630: /* dist to word bound in stip */ ! 631: w = min(w, 32 - (x & 0x1f)); ! 632: ! 633: /* Fill tmpSrc with the source pixels */ ! 634: tmpSrc = *(pdst + (x >> PWSH)); ! 635: switch ( pGC->fillStyle ) { ! 636: case FillOpaqueStippled: ! 637: getstipplepixels(psrcS + (xrem>>5), (x&0x1f), w, 0, ! 638: &bgfill, &tmpDst1); ! 639: getstipplepixels(psrcS + (xrem>>5), (x&0x1f), w, 1, ! 640: &fgfill, &tmpDst2); ! 641: break; ! 642: case FillStippled: ! 643: getstipplepixels(psrcS + (xrem>>5), (x&0x1f), w, 0, ! 644: &tmpSrc, &tmpDst1); ! 645: getstipplepixels(psrcS + (xrem>>5), (x&0x1f), w, 1, ! 646: &fgfill, &tmpDst2); ! 647: break; ! 648: } ! 649: #ifdef notdef ! 650: putbitsrop(tmpDst1 | tmpDst2, x & PIM, w, pdst + (x>>PWSH), ! 651: pGC->planemask, rop); ! 652: #else ! 653: { ! 654: /* ! 655: * Ultrix cc hasn't enough expression stack to compile ! 656: * these values in the putbitsrop call. (MIT:yba) ! 657: */ ! 658: int tmpDst = tmpDst1 | tmpDst2, tmpx = x & PIM; ! 659: int * pdsttmp = pdst + (x>>PWSH); ! 660: putbitsrop(tmpDst, tmpx, w, pdsttmp, pGC->planemask, rop); ! 661: } ! 662: #endif notdef ! 663: x += w; ! 664: width -= w; ! 665: } ! 666: } ! 667: #ifdef notdef ! 668: if (*pwidth) ! 669: { ! 670: width = *pwidth; ! 671: while(width > 0) ! 672: { ! 673: psrc = psrcS; ! 674: w = min(min(stippleWidth, width), PPW); ! 675: if((rem = x % stippleWidth) != 0) ! 676: { ! 677: w = min(min(stippleWidth - rem, width), PPW); ! 678: /* we want to grab from the end of the tile. Figure ! 679: * out where that is. In general, the start of the last ! 680: * word of data on this scanline is stwidth -1 words ! 681: * away. But if we want to grab more bits than we'll ! 682: * find on that line, we have to back up 1 word further. ! 683: * On the other hand, if the whole tile fits in 1 word, ! 684: * let's skip the work */ ! 685: endinc = stwidth - 1 - w / PPW; ! 686: ! 687: if(endinc) ! 688: { ! 689: if((rem & 0x1f) + w > stippleWidth % PPW) ! 690: endinc--; ! 691: } ! 692: ! 693: getbits(psrc + endinc, rem & PIM, w, tmpSrc); ! 694: putbitsrop(tmpSrc, (x & PIM), w, pdst, ! 695: pGC->planemask, rop); ! 696: if((x & PIM) + w >= PPW) ! 697: pdst++; ! 698: } ! 699: ! 700: else if(((x & PIM) + w) < PPW) ! 701: { ! 702: getbits(psrc, 0, w, tmpSrc); ! 703: putbitsrop(tmpSrc, x & PIM, w, pdst, ! 704: pGC->planemask, rop); ! 705: } ! 706: else ! 707: { ! 708: maskbits(x, w, startmask, endmask, nlMiddle); ! 709: ! 710: if (startmask) ! 711: nstart = PPW - (x & PIM); ! 712: else ! 713: nstart = 0; ! 714: if (endmask) ! 715: nend = (x + w) & PIM; ! 716: else ! 717: nend = 0; ! 718: ! 719: srcStartOver = nstart > PLST; ! 720: ! 721: if(startmask) ! 722: { ! 723: getbits(psrc, 0, nstart, tmpSrc); ! 724: putbitsrop(tmpSrc, (x & PIM), nstart, pdst, ! 725: pGC->planemask, rop); ! 726: pdst++; ! 727: if(srcStartOver) ! 728: psrc++; ! 729: } ! 730: ! 731: while(nlMiddle--) ! 732: { ! 733: /* ! 734: getbits(psrc, nstart, PPW, tmpSrc); ! 735: putbitsrop( tmpSrc, 0, PPW, ! 736: pdst, pGC->planemask, rop ); ! 737: */ ! 738: switch ( pGC->fillStyle ) { ! 739: case FillStippled: ! 740: getstipplepixels( psrc, j, 4, 1, pdst, tmp1 ); ! 741: break; ! 742: case FillOpaqueStippled: ! 743: getstipplepixels( psrc, j, 4, 1, pdst, tmp1 ); ! 744: break; ! 745: } ! 746: pdst++; ! 747: psrc++; ! 748: } ! 749: if(endmask) ! 750: { ! 751: getbits(psrc, nstart, nend, tmpSrc); ! 752: putbitsrop(tmpSrc, 0, nend, pdst, ! 753: pGC->planemask, rop); ! 754: } ! 755: } ! 756: x += w; ! 757: width -= w; ! 758: } ! 759: } ! 760: #endif ! 761: ppt++; ! 762: pwidth++; ! 763: } ! 764: DEALLOCATE_LOCAL(pptFree); ! 765: DEALLOCATE_LOCAL(pwidthFree); ! 766: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.