![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mfbfillsp.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 / mfb|
Return to mfbfillsp.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mfb |
1.1 ! root 1: /*********************************************************** ! 2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts, ! 3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts. ! 4: ! 5: All Rights Reserved ! 6: ! 7: Permission to use, copy, modify, and distribute this software and its ! 8: documentation for any purpose and without fee is hereby granted, ! 9: provided that the above copyright notice appear in all copies and that ! 10: both that copyright notice and this permission notice appear in ! 11: supporting documentation, and that the names of Digital or MIT not be ! 12: used in advertising or publicity pertaining to distribution of the ! 13: software without specific, written prior permission. ! 14: ! 15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 21: SOFTWARE. ! 22: ! 23: ******************************************************************/ ! 24: /* $Header: mfbfillsp.c,v 1.29 87/09/07 19:08:34 toddb Exp $ */ ! 25: #include "X.h" ! 26: #include "Xmd.h" ! 27: #include "gcstruct.h" ! 28: #include "window.h" ! 29: #include "pixmapstr.h" ! 30: #include "scrnintstr.h" ! 31: #include "windowstr.h" ! 32: #include "mfb.h" ! 33: #include "maskbits.h" ! 34: ! 35: #include "servermd.h" ! 36: ! 37: /* scanline filling for monochrome frame buffer ! 38: written by drewry, oct 1986 ! 39: ! 40: these routines all clip. they assume that anything that has called ! 41: them has already translated the points (i.e. pGC->miTranslate is ! 42: non-zero, which is howit gets set in mfbCreateGC().) ! 43: ! 44: the number of new scnalines created by clipping == ! 45: MaxRectsPerBand * nSpans. ! 46: ! 47: FillSolid is overloaded to be used for OpaqueStipple as well, ! 48: if fgPixel == bgPixel. ! 49: ! 50: ! 51: FillTiled is overloaded to be used for OpaqueStipple, if ! 52: fgPixel != bgPixel. based on the fill style, it uses ! 53: {RotatedTile, gc.alu} or {RotatedStipple, PrivGC.ropOpStip} ! 54: */ ! 55: ! 56: ! 57: void mfbBlackSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 58: DrawablePtr pDrawable; ! 59: GCPtr pGC; ! 60: int nInit; /* number of spans to fill */ ! 61: DDXPointPtr pptInit; /* pointer to list of start points */ ! 62: int *pwidthInit; /* pointer to list of n widths */ ! 63: int fSorted; ! 64: { ! 65: /* next three parameters are post-clip */ ! 66: int n; /* number of spans to fill */ ! 67: register DDXPointPtr ppt; /* pointer to list of start points */ ! 68: register int *pwidth; /* pointer to list of n widths */ ! 69: int *addrlBase; /* pointer to start of bitmap */ ! 70: int nlwidth; /* width in longwords of bitmap */ ! 71: register int *addrl; /* pointer to current longword in bitmap */ ! 72: register int startmask; ! 73: register int endmask; ! 74: register int nlmiddle; ! 75: int *pwidthFree; /* copies of the pointers to free */ ! 76: DDXPointPtr pptFree; ! 77: ! 78: if (!(pGC->planemask & 1)) ! 79: return; ! 80: ! 81: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 82: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 83: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 84: if(!pptFree || !pwidthFree) ! 85: { ! 86: DEALLOCATE_LOCAL(pptFree); ! 87: DEALLOCATE_LOCAL(pwidthFree); ! 88: return; ! 89: } ! 90: pwidth = pwidthFree; ! 91: ppt = pptFree; ! 92: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 93: pptInit, pwidthInit, nInit, ! 94: ppt, pwidth, fSorted); ! 95: ! 96: if (pDrawable->type == DRAWABLE_WINDOW) ! 97: { ! 98: addrlBase = (int *) ! 99: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 100: nlwidth = (int) ! 101: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 102: } ! 103: else ! 104: { ! 105: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 106: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 107: } ! 108: ! 109: while (n--) ! 110: { ! 111: addrl = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); ! 112: ! 113: if (*pwidth) ! 114: { ! 115: if ( ((ppt->x & 0x1f) + *pwidth) < 32) ! 116: { ! 117: /* all bits inside same longword */ ! 118: maskpartialbits(ppt->x, *pwidth, startmask); ! 119: *addrl &= ~startmask; ! 120: } ! 121: else ! 122: { ! 123: maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); ! 124: if (startmask) ! 125: *addrl++ &= ~startmask; ! 126: while (nlmiddle--) ! 127: *addrl++ = 0x0; ! 128: if (endmask) ! 129: *addrl &= ~endmask; ! 130: } ! 131: } ! 132: pwidth++; ! 133: ppt++; ! 134: } ! 135: DEALLOCATE_LOCAL(pptFree); ! 136: DEALLOCATE_LOCAL(pwidthFree); ! 137: } ! 138: ! 139: ! 140: ! 141: void mfbWhiteSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 142: DrawablePtr pDrawable; ! 143: GCPtr pGC; ! 144: int nInit; /* number of spans to fill */ ! 145: DDXPointPtr pptInit; /* pointer to list of start points */ ! 146: int *pwidthInit; /* pointer to list of n widths */ ! 147: int fSorted; ! 148: { ! 149: /* next three parameters are post-clip */ ! 150: int n; /* number of spans to fill */ ! 151: register DDXPointPtr ppt; /* pointer to list of start points */ ! 152: register int *pwidth; /* pointer to list of n widths */ ! 153: int *addrlBase; /* pointer to start of bitmap */ ! 154: int nlwidth; /* width in longwords of bitmap */ ! 155: register int *addrl; /* pointer to current longword in bitmap */ ! 156: register int startmask; ! 157: register int endmask; ! 158: register int nlmiddle; ! 159: int *pwidthFree; /* copies of the pointers to free */ ! 160: DDXPointPtr pptFree; ! 161: ! 162: if (!(pGC->planemask & 1)) ! 163: return; ! 164: ! 165: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 166: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 167: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 168: if(!pptFree || !pwidthFree) ! 169: { ! 170: DEALLOCATE_LOCAL(pptFree); ! 171: DEALLOCATE_LOCAL(pwidthFree); ! 172: return; ! 173: } ! 174: pwidth = pwidthFree; ! 175: ppt = pptFree; ! 176: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 177: pptInit, pwidthInit, nInit, ! 178: ppt, pwidth, fSorted); ! 179: ! 180: if (pDrawable->type == DRAWABLE_WINDOW) ! 181: { ! 182: addrlBase = (int *) ! 183: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 184: nlwidth = (int) ! 185: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 186: } ! 187: else ! 188: { ! 189: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 190: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 191: } ! 192: ! 193: while (n--) ! 194: { ! 195: addrl = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); ! 196: ! 197: if (*pwidth) ! 198: { ! 199: if ( ((ppt->x & 0x1f) + *pwidth) < 32) ! 200: { ! 201: /* all bits inside same longword */ ! 202: maskpartialbits(ppt->x, *pwidth, startmask); ! 203: *addrl |= startmask; ! 204: } ! 205: else ! 206: { ! 207: maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); ! 208: if (startmask) ! 209: *addrl++ |= startmask; ! 210: while (nlmiddle--) ! 211: *addrl++ = 0xffffffff; ! 212: if (endmask) ! 213: *addrl |= endmask; ! 214: } ! 215: } ! 216: pwidth++; ! 217: ppt++; ! 218: } ! 219: DEALLOCATE_LOCAL(pptFree); ! 220: DEALLOCATE_LOCAL(pwidthFree); ! 221: } ! 222: ! 223: ! 224: ! 225: void mfbInvertSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 226: DrawablePtr pDrawable; ! 227: GCPtr pGC; ! 228: int nInit; /* number of spans to fill */ ! 229: DDXPointPtr pptInit; /* pointer to list of start points */ ! 230: int *pwidthInit; /* pointer to list of n widths */ ! 231: int fSorted; ! 232: { ! 233: /* next three parameters are post-clip */ ! 234: int n; /* number of spans to fill */ ! 235: register DDXPointPtr ppt; /* pointer to list of start points */ ! 236: register int *pwidth; /* pointer to list of n widths */ ! 237: int *addrlBase; /* pointer to start of bitmap */ ! 238: int nlwidth; /* width in longwords of bitmap */ ! 239: register int *addrl; /* pointer to current longword in bitmap */ ! 240: register int startmask; ! 241: register int endmask; ! 242: register int nlmiddle; ! 243: int *pwidthFree; /* copies of the pointers to free */ ! 244: DDXPointPtr pptFree; ! 245: ! 246: if (!(pGC->planemask & 1)) ! 247: return; ! 248: ! 249: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 250: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 251: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 252: if(!pptFree || !pwidthFree) ! 253: { ! 254: DEALLOCATE_LOCAL(pptFree); ! 255: DEALLOCATE_LOCAL(pwidthFree); ! 256: return; ! 257: } ! 258: pwidth = pwidthFree; ! 259: ppt = pptFree; ! 260: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 261: pptInit, pwidthInit, nInit, ! 262: ppt, pwidth, fSorted); ! 263: ! 264: if (pDrawable->type == DRAWABLE_WINDOW) ! 265: { ! 266: addrlBase = (int *) ! 267: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 268: nlwidth = (int) ! 269: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 270: } ! 271: else ! 272: { ! 273: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 274: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 275: } ! 276: ! 277: while (n--) ! 278: { ! 279: addrl = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); ! 280: ! 281: if (*pwidth) ! 282: { ! 283: if ( ((ppt->x & 0x1f) + *pwidth) < 32) ! 284: { ! 285: /* all bits inside same longword */ ! 286: maskpartialbits(ppt->x, *pwidth, startmask); ! 287: *addrl ^= startmask; ! 288: } ! 289: else ! 290: { ! 291: maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); ! 292: if (startmask) ! 293: *addrl++ ^= startmask; ! 294: while (nlmiddle--) ! 295: *addrl++ ^= 0xffffffff; ! 296: if (endmask) ! 297: *addrl ^= endmask; ! 298: } ! 299: } ! 300: pwidth++; ! 301: ppt++; ! 302: } ! 303: DEALLOCATE_LOCAL(pptFree); ! 304: DEALLOCATE_LOCAL(pwidthFree); ! 305: } ! 306: ! 307: ! 308: void ! 309: mfbWhiteStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 310: DrawablePtr pDrawable; ! 311: GC *pGC; ! 312: int nInit; /* number of spans to fill */ ! 313: DDXPointPtr pptInit; /* pointer to list of start points */ ! 314: int *pwidthInit; /* pointer to list of n widths */ ! 315: int fSorted; ! 316: { ! 317: /* next three parameters are post-clip */ ! 318: int n; /* number of spans to fill */ ! 319: register DDXPointPtr ppt; /* pointer to list of start points */ ! 320: register int *pwidth; /* pointer to list of n widths */ ! 321: int *addrlBase; /* pointer to start of bitmap */ ! 322: int nlwidth; /* width in longwords of bitmap */ ! 323: register int *addrl; /* pointer to current longword in bitmap */ ! 324: register int startmask; ! 325: register int endmask; ! 326: register int nlmiddle; ! 327: PixmapPtr pStipple; ! 328: int *psrc; ! 329: int src; ! 330: int tileHeight; ! 331: int *pwidthFree; /* copies of the pointers to free */ ! 332: DDXPointPtr pptFree; ! 333: ! 334: if (!(pGC->planemask & 1)) ! 335: return; ! 336: ! 337: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 338: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 339: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 340: if(!pptFree || !pwidthFree) ! 341: { ! 342: DEALLOCATE_LOCAL(pptFree); ! 343: DEALLOCATE_LOCAL(pwidthFree); ! 344: return; ! 345: } ! 346: pwidth = pwidthFree; ! 347: ppt = pptFree; ! 348: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 349: pptInit, pwidthInit, nInit, ! 350: ppt, pwidth, fSorted); ! 351: ! 352: if (pDrawable->type == DRAWABLE_WINDOW) ! 353: { ! 354: addrlBase = (int *) ! 355: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 356: nlwidth = (int) ! 357: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 358: } ! 359: else ! 360: { ! 361: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 362: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 363: } ! 364: ! 365: pStipple = ((mfbPrivGC *)(pGC->devPriv))->pRotatedStipple; ! 366: tileHeight = pStipple->height; ! 367: psrc = (int *)(pStipple->devPrivate); ! 368: ! 369: while (n--) ! 370: { ! 371: addrl = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); ! 372: src = psrc[ppt->y % tileHeight]; ! 373: ! 374: /* all bits inside same longword */ ! 375: if ( ((ppt->x & 0x1f) + *pwidth) < 32) ! 376: { ! 377: maskpartialbits(ppt->x, *pwidth, startmask); ! 378: *addrl |= (src & startmask); ! 379: } ! 380: else ! 381: { ! 382: maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); ! 383: if (startmask) ! 384: *addrl++ |= (src & startmask); ! 385: while (nlmiddle--) ! 386: *addrl++ |= src; ! 387: if (endmask) ! 388: *addrl |= (src & endmask); ! 389: } ! 390: pwidth++; ! 391: ppt++; ! 392: } ! 393: DEALLOCATE_LOCAL(pptFree); ! 394: DEALLOCATE_LOCAL(pwidthFree); ! 395: } ! 396: ! 397: ! 398: void ! 399: mfbBlackStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 400: DrawablePtr pDrawable; ! 401: GC *pGC; ! 402: int nInit; /* number of spans to fill */ ! 403: DDXPointPtr pptInit; /* pointer to list of start points */ ! 404: int *pwidthInit; /* pointer to list of n widths */ ! 405: int fSorted; ! 406: { ! 407: /* next three parameters are post-clip */ ! 408: int n; /* number of spans to fill */ ! 409: register DDXPointPtr ppt; /* pointer to list of start points */ ! 410: register int *pwidth; /* pointer to list of n widths */ ! 411: int *addrlBase; /* pointer to start of bitmap */ ! 412: int nlwidth; /* width in longwords of bitmap */ ! 413: register int *addrl; /* pointer to current longword in bitmap */ ! 414: register int startmask; ! 415: register int endmask; ! 416: register int nlmiddle; ! 417: PixmapPtr pStipple; ! 418: int *psrc; ! 419: int src; ! 420: int tileHeight; ! 421: int *pwidthFree; /* copies of the pointers to free */ ! 422: DDXPointPtr pptFree; ! 423: ! 424: if (!(pGC->planemask & 1)) ! 425: return; ! 426: ! 427: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 428: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 429: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 430: if(!pptFree || !pwidthFree) ! 431: { ! 432: DEALLOCATE_LOCAL(pptFree); ! 433: DEALLOCATE_LOCAL(pwidthFree); ! 434: return; ! 435: } ! 436: pwidth = pwidthFree; ! 437: ppt = pptFree; ! 438: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 439: pptInit, pwidthInit, nInit, ! 440: ppt, pwidth, fSorted); ! 441: ! 442: if (pDrawable->type == DRAWABLE_WINDOW) ! 443: { ! 444: addrlBase = (int *) ! 445: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 446: nlwidth = (int) ! 447: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 448: } ! 449: else ! 450: { ! 451: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 452: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 453: } ! 454: ! 455: pStipple = ((mfbPrivGC *)(pGC->devPriv))->pRotatedStipple; ! 456: tileHeight = pStipple->height; ! 457: psrc = (int *)(pStipple->devPrivate); ! 458: ! 459: while (n--) ! 460: { ! 461: addrl = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); ! 462: src = psrc[ppt->y % tileHeight]; ! 463: ! 464: /* all bits inside same longword */ ! 465: if ( ((ppt->x & 0x1f) + *pwidth) < 32) ! 466: { ! 467: maskpartialbits(ppt->x, *pwidth, startmask); ! 468: *addrl &= ~(src & startmask); ! 469: } ! 470: else ! 471: { ! 472: maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); ! 473: if (startmask) ! 474: *addrl++ &= ~(src & startmask); ! 475: while (nlmiddle--) ! 476: *addrl++ &= ~src; ! 477: if (endmask) ! 478: *addrl &= ~(src & endmask); ! 479: } ! 480: pwidth++; ! 481: ppt++; ! 482: } ! 483: DEALLOCATE_LOCAL(pptFree); ! 484: DEALLOCATE_LOCAL(pwidthFree); ! 485: } ! 486: ! 487: ! 488: void ! 489: mfbInvertStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 490: DrawablePtr pDrawable; ! 491: GC *pGC; ! 492: int nInit; /* number of spans to fill */ ! 493: DDXPointPtr pptInit; /* pointer to list of start points */ ! 494: int *pwidthInit; /* pointer to list of n widths */ ! 495: int fSorted; ! 496: { ! 497: /* next three parameters are post-clip */ ! 498: int n; /* number of spans to fill */ ! 499: register DDXPointPtr ppt; /* pointer to list of start points */ ! 500: register int *pwidth; /* pointer to list of n widths */ ! 501: int *addrlBase; /* pointer to start of bitmap */ ! 502: int nlwidth; /* width in longwords of bitmap */ ! 503: register int *addrl; /* pointer to current longword in bitmap */ ! 504: register int startmask; ! 505: register int endmask; ! 506: register int nlmiddle; ! 507: PixmapPtr pStipple; ! 508: int *psrc; ! 509: int src; ! 510: int tileHeight; ! 511: int *pwidthFree; /* copies of the pointers to free */ ! 512: DDXPointPtr pptFree; ! 513: ! 514: if (!(pGC->planemask & 1)) ! 515: return; ! 516: ! 517: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 518: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 519: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 520: if(!pptFree || !pwidthFree) ! 521: { ! 522: DEALLOCATE_LOCAL(pptFree); ! 523: DEALLOCATE_LOCAL(pwidthFree); ! 524: return; ! 525: } ! 526: pwidth = pwidthFree; ! 527: ppt = pptFree; ! 528: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 529: pptInit, pwidthInit, nInit, ! 530: ppt, pwidth, fSorted); ! 531: ! 532: if (pDrawable->type == DRAWABLE_WINDOW) ! 533: { ! 534: addrlBase = (int *) ! 535: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 536: nlwidth = (int) ! 537: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 538: } ! 539: else ! 540: { ! 541: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 542: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 543: } ! 544: ! 545: pStipple = ((mfbPrivGC *)(pGC->devPriv))->pRotatedStipple; ! 546: tileHeight = pStipple->height; ! 547: psrc = (int *)(pStipple->devPrivate); ! 548: ! 549: while (n--) ! 550: { ! 551: addrl = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); ! 552: src = psrc[ppt->y % tileHeight]; ! 553: ! 554: /* all bits inside same longword */ ! 555: if ( ((ppt->x & 0x1f) + *pwidth) < 32) ! 556: { ! 557: maskpartialbits(ppt->x, *pwidth, startmask); ! 558: *addrl ^= (src & startmask); ! 559: } ! 560: else ! 561: { ! 562: maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); ! 563: if (startmask) ! 564: *addrl++ ^= (src & startmask); ! 565: while (nlmiddle--) ! 566: *addrl++ ^= src; ! 567: if (endmask) ! 568: *addrl ^= (src & endmask); ! 569: } ! 570: pwidth++; ! 571: ppt++; ! 572: } ! 573: DEALLOCATE_LOCAL(pptFree); ! 574: DEALLOCATE_LOCAL(pwidthFree); ! 575: } ! 576: ! 577: ! 578: /* this works with tiles of width == 32 */ ! 579: #define FILLSPAN32(ROP) \ ! 580: while (n--) \ ! 581: { \ ! 582: if (*pwidth) \ ! 583: { \ ! 584: addrl = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); \ ! 585: src = psrc[ppt->y % tileHeight]; \ ! 586: if ( ((ppt->x & 0x1f) + *pwidth) < 32) \ ! 587: { \ ! 588: maskpartialbits(ppt->x, *pwidth, startmask); \ ! 589: *addrl = (*addrl & ~startmask) | \ ! 590: (ROP(src, *addrl) & startmask); \ ! 591: } \ ! 592: else \ ! 593: { \ ! 594: maskbits(ppt->x, *pwidth, startmask, endmask, nlmiddle); \ ! 595: if (startmask) \ ! 596: { \ ! 597: *addrl = (*addrl & ~startmask) | \ ! 598: (ROP(src, *addrl) & startmask); \ ! 599: addrl++; \ ! 600: } \ ! 601: while (nlmiddle--) \ ! 602: { \ ! 603: *addrl = ROP(src, *addrl); \ ! 604: addrl++; \ ! 605: } \ ! 606: if (endmask) \ ! 607: *addrl = (*addrl & ~endmask) | \ ! 608: (ROP(src, *addrl) & endmask); \ ! 609: } \ ! 610: } \ ! 611: pwidth++; \ ! 612: ppt++; \ ! 613: } ! 614: ! 615: ! 616: ! 617: void mfbTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 618: DrawablePtr pDrawable; ! 619: GC *pGC; ! 620: int nInit; /* number of spans to fill */ ! 621: DDXPointPtr pptInit; /* pointer to list of start points */ ! 622: int *pwidthInit; /* pointer to list of n widths */ ! 623: int fSorted; ! 624: { ! 625: /* next three parameters are post-clip */ ! 626: int n; /* number of spans to fill */ ! 627: register DDXPointPtr ppt; /* pointer to list of start points */ ! 628: register int *pwidth; /* pointer to list of n widths */ ! 629: int *addrlBase; /* pointer to start of bitmap */ ! 630: int nlwidth; /* width in longwords of bitmap */ ! 631: register int *addrl; /* pointer to current longword in bitmap */ ! 632: register int startmask; ! 633: register int endmask; ! 634: register int nlmiddle; ! 635: PixmapPtr pTile; ! 636: int *psrc; ! 637: register int src; ! 638: int tileHeight; ! 639: int rop; ! 640: int *pwidthFree; /* copies of the pointers to free */ ! 641: DDXPointPtr pptFree; ! 642: ! 643: if (!(pGC->planemask & 1)) ! 644: return; ! 645: ! 646: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 647: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 648: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 649: if(!pptFree || !pwidthFree) ! 650: { ! 651: DEALLOCATE_LOCAL(pptFree); ! 652: DEALLOCATE_LOCAL(pwidthFree); ! 653: return; ! 654: } ! 655: pwidth = pwidthFree; ! 656: ppt = pptFree; ! 657: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 658: pptInit, pwidthInit, nInit, ! 659: ppt, pwidth, fSorted); ! 660: ! 661: if (pDrawable->type == DRAWABLE_WINDOW) ! 662: { ! 663: addrlBase = (int *) ! 664: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 665: nlwidth = (int) ! 666: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 667: } ! 668: else ! 669: { ! 670: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 671: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 672: } ! 673: ! 674: if (pGC->fillStyle == FillTiled) ! 675: { ! 676: pTile = ((mfbPrivGC *)(pGC->devPriv))->pRotatedTile; ! 677: tileHeight = pTile->height; ! 678: psrc = (int *)(pTile->devPrivate); ! 679: rop = pGC->alu; ! 680: } ! 681: else ! 682: { ! 683: pTile = ((mfbPrivGC *)(pGC->devPriv))->pRotatedStipple; ! 684: tileHeight = pTile->height; ! 685: psrc = (int *)(pTile->devPrivate); ! 686: rop = ((mfbPrivGC *)(pGC->devPriv))->ropOpStip; ! 687: } ! 688: ! 689: ! 690: switch(rop) ! 691: { ! 692: case GXclear: ! 693: FILLSPAN32(fnCLEAR) ! 694: break; ! 695: case GXand: ! 696: FILLSPAN32(fnAND) ! 697: break; ! 698: case GXandReverse: ! 699: FILLSPAN32(fnANDREVERSE) ! 700: break; ! 701: case GXcopy: ! 702: FILLSPAN32(fnCOPY) ! 703: break; ! 704: case GXandInverted: ! 705: FILLSPAN32(fnANDINVERTED) ! 706: break; ! 707: case GXnoop: ! 708: break; ! 709: case GXxor: ! 710: FILLSPAN32(fnXOR) ! 711: break; ! 712: case GXor: ! 713: FILLSPAN32(fnOR) ! 714: break; ! 715: case GXnor: ! 716: FILLSPAN32(fnNOR) ! 717: break; ! 718: case GXequiv: ! 719: FILLSPAN32(fnEQUIV) ! 720: break; ! 721: case GXinvert: ! 722: FILLSPAN32(fnINVERT) ! 723: break; ! 724: case GXorReverse: ! 725: FILLSPAN32(fnORREVERSE) ! 726: break; ! 727: case GXcopyInverted: ! 728: FILLSPAN32(fnCOPYINVERTED) ! 729: break; ! 730: case GXorInverted: ! 731: FILLSPAN32(fnORINVERTED) ! 732: break; ! 733: case GXnand: ! 734: FILLSPAN32(fnNAND) ! 735: break; ! 736: case GXset: ! 737: FILLSPAN32(fnSET) ! 738: break; ! 739: } ! 740: DEALLOCATE_LOCAL(pptFree); ! 741: DEALLOCATE_LOCAL(pwidthFree); ! 742: } ! 743: ! 744: ! 745: /* Fill spans with tiles that aren't 32 bits wide */ ! 746: void ! 747: mfbUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 748: DrawablePtr pDrawable; ! 749: GC *pGC; ! 750: int nInit; /* number of spans to fill */ ! 751: DDXPointPtr pptInit; /* pointer to list of start points */ ! 752: int *pwidthInit; /* pointer to list of n widths */ ! 753: int fSorted; ! 754: { ! 755: int iline; /* first line of tile to use */ ! 756: /* next three parameters are post-clip */ ! 757: int n; /* number of spans to fill */ ! 758: register DDXPointPtr ppt; /* pointer to list of start points */ ! 759: register int *pwidth; /* pointer to list of n widths */ ! 760: int *addrlBase; /* pointer to start of bitmap */ ! 761: int nlwidth; /* width in longwords of bitmap */ ! 762: register int *pdst; /* pointer to current word in bitmap */ ! 763: register int *psrc; /* pointer to current word in tile */ ! 764: register int startmask; ! 765: register int nlMiddle; ! 766: PixmapPtr pTile; /* pointer to tile we want to fill with */ ! 767: int w, width, x, xSrc, ySrc, tmpSrc, srcStartOver, nstart, nend; ! 768: int endmask, tlwidth, rem, tileWidth, *psrcT, endinc, rop; ! 769: int *pwidthFree; /* copies of the pointers to free */ ! 770: DDXPointPtr pptFree; ! 771: ! 772: if (!(pGC->planemask & 1)) ! 773: return; ! 774: ! 775: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 776: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 777: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 778: if(!pptFree || !pwidthFree) ! 779: { ! 780: DEALLOCATE_LOCAL(pptFree); ! 781: DEALLOCATE_LOCAL(pwidthFree); ! 782: return; ! 783: } ! 784: pwidth = pwidthFree; ! 785: ppt = pptFree; ! 786: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 787: pptInit, pwidthInit, nInit, ! 788: ppt, pwidth, fSorted); ! 789: ! 790: if (pGC->fillStyle == FillTiled) ! 791: { ! 792: pTile = pGC->tile; ! 793: tlwidth = pTile->devKind >> 2; ! 794: rop = pGC->alu; ! 795: } ! 796: else ! 797: { ! 798: pTile = pGC->stipple; ! 799: tlwidth = pTile->devKind >> 2; ! 800: rop = ((mfbPrivGC *)(pGC->devPriv))->ropOpStip; ! 801: } ! 802: ! 803: if (pDrawable->type == DRAWABLE_WINDOW) ! 804: { ! 805: addrlBase = (int *) ! 806: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 807: nlwidth = (int) ! 808: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 809: xSrc = ((WindowPtr) pDrawable)->absCorner.x; ! 810: ySrc = ((WindowPtr) pDrawable)->absCorner.y; ! 811: } ! 812: else ! 813: { ! 814: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 815: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 816: xSrc = 0; ! 817: ySrc = 0; ! 818: } ! 819: ! 820: tileWidth = pTile->width; ! 821: ! 822: /* this replaces rotating the tile. Instead we just adjust the offset ! 823: * at which we start grabbing bits from the tile */ ! 824: xSrc += pGC->patOrg.x; ! 825: ySrc += pGC->patOrg.y; ! 826: ! 827: while (n--) ! 828: { ! 829: iline = (ppt->y - ySrc) % pTile->height; ! 830: pdst = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); ! 831: psrcT = (int *) pTile->devPrivate + (iline * tlwidth); ! 832: x = ppt->x; ! 833: ! 834: if (*pwidth) ! 835: { ! 836: width = *pwidth; ! 837: while(width > 0) ! 838: { ! 839: psrc = psrcT; ! 840: w = min(tileWidth, width); ! 841: if((rem = (x - xSrc) % tileWidth) != 0) ! 842: { ! 843: /* if we're in the middle of the tile, get ! 844: as many bits as will finish the span, or ! 845: as many as will get to the left edge of the tile, ! 846: or a longword worth, starting at the appropriate ! 847: offset in the tile. ! 848: */ ! 849: w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_UNIT); ! 850: endinc = rem / BITMAP_SCANLINE_UNIT; ! 851: getbits(psrc + endinc, rem & 0x1f, w, tmpSrc); ! 852: putbitsrop(tmpSrc, (x & 0x1f), w, pdst, rop); ! 853: if((x & 0x1f) + w >= 0x20) ! 854: pdst++; ! 855: } ! 856: else if(((x & 0x1f) + w) < 32) ! 857: { ! 858: /* doing < 32 bits is easy, and worth special-casing */ ! 859: getbits(psrc, 0, w, tmpSrc); ! 860: putbitsrop(tmpSrc, x & 0x1f, w, pdst, rop); ! 861: } ! 862: else ! 863: { ! 864: /* start at the left edge of the tile, ! 865: and put down as much as we can ! 866: */ ! 867: maskbits(x, w, startmask, endmask, nlMiddle); ! 868: ! 869: if (startmask) ! 870: nstart = 32 - (x & 0x1f); ! 871: else ! 872: nstart = 0; ! 873: if (endmask) ! 874: nend = (x + w) & 0x1f; ! 875: else ! 876: nend = 0; ! 877: ! 878: srcStartOver = nstart > 31; ! 879: ! 880: if(startmask) ! 881: { ! 882: getbits(psrc, 0, nstart, tmpSrc); ! 883: putbitsrop(tmpSrc, (x & 0x1f), nstart, pdst, rop); ! 884: pdst++; ! 885: if(srcStartOver) ! 886: psrc++; ! 887: } ! 888: ! 889: while(nlMiddle--) ! 890: { ! 891: getbits(psrc, nstart, 32, tmpSrc); ! 892: *pdst = DoRop(rop, tmpSrc, *pdst); ! 893: pdst++; ! 894: psrc++; ! 895: } ! 896: if(endmask) ! 897: { ! 898: getbits(psrc, nstart, nend, tmpSrc); ! 899: putbitsrop(tmpSrc, 0, nend, pdst, rop); ! 900: } ! 901: } ! 902: x += w; ! 903: width -= w; ! 904: } ! 905: } ! 906: ppt++; ! 907: pwidth++; ! 908: } ! 909: DEALLOCATE_LOCAL(pptFree); ! 910: DEALLOCATE_LOCAL(pwidthFree); ! 911: } ! 912: ! 913: ! 914: /* Fill spans with stipples that aren't 32 bits wide */ ! 915: void ! 916: mfbUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted) ! 917: DrawablePtr pDrawable; ! 918: GC *pGC; ! 919: int nInit; /* number of spans to fill */ ! 920: DDXPointPtr pptInit; /* pointer to list of start points */ ! 921: int *pwidthInit; /* pointer to list of n widths */ ! 922: int fSorted; ! 923: { ! 924: /* next three parameters are post-clip */ ! 925: int n; /* number of spans to fill */ ! 926: register DDXPointPtr ppt; /* pointer to list of start points */ ! 927: register int *pwidth; /* pointer to list of n widths */ ! 928: int iline; /* first line of tile to use */ ! 929: int *addrlBase; /* pointer to start of bitmap */ ! 930: int nlwidth; /* width in longwords of bitmap */ ! 931: register int *pdst; /* pointer to current word in bitmap */ ! 932: register int *psrc; /* pointer to current word in tile */ ! 933: register int startmask; ! 934: register int nlMiddle; ! 935: PixmapPtr pTile; /* pointer to tile we want to fill with */ ! 936: int w, width, x, xSrc, ySrc, tmpSrc, srcStartOver, nstart, nend; ! 937: int endmask, tlwidth, rem, tileWidth, *psrcT, endinc, rop; ! 938: int *pwidthFree; /* copies of the pointers to free */ ! 939: DDXPointPtr pptFree; ! 940: ! 941: if (!(pGC->planemask & 1)) ! 942: return; ! 943: ! 944: n = nInit * miFindMaxBand(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip); ! 945: pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int)); ! 946: pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec)); ! 947: if(!pptFree || !pwidthFree) ! 948: { ! 949: DEALLOCATE_LOCAL(pptFree); ! 950: DEALLOCATE_LOCAL(pwidthFree); ! 951: return; ! 952: } ! 953: pwidth = pwidthFree; ! 954: ppt = pptFree; ! 955: n = miClipSpans(((mfbPrivGC *)(pGC->devPriv))->pCompositeClip, ! 956: pptInit, pwidthInit, nInit, ! 957: ppt, pwidth, fSorted); ! 958: ! 959: pTile = pGC->stipple; ! 960: rop = ((mfbPrivGC *)(pGC->devPriv))->rop; ! 961: tlwidth = pTile->devKind >> 2; ! 962: if (pDrawable->type == DRAWABLE_WINDOW) ! 963: { ! 964: addrlBase = (int *) ! 965: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate); ! 966: nlwidth = (int) ! 967: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devKind) >> 2; ! 968: xSrc = ((WindowPtr)pDrawable)->absCorner.x; ! 969: ySrc = ((WindowPtr)pDrawable)->absCorner.y; ! 970: } ! 971: else ! 972: { ! 973: addrlBase = (int *)(((PixmapPtr)pDrawable)->devPrivate); ! 974: nlwidth = (int)(((PixmapPtr)pDrawable)->devKind) >> 2; ! 975: xSrc = 0; ! 976: ySrc = 0; ! 977: } ! 978: ! 979: tileWidth = pTile->width; ! 980: ! 981: /* this replaces rotating the stipple. Instead, we just adjust the offset ! 982: * at which we start grabbing bits from the stipple */ ! 983: xSrc += pGC->patOrg.x; ! 984: ySrc += pGC->patOrg.y; ! 985: while (n--) ! 986: { ! 987: iline = (ppt->y - ySrc) % pTile->height; ! 988: pdst = addrlBase + (ppt->y * nlwidth) + (ppt->x >> 5); ! 989: psrcT = (int *) pTile->devPrivate + (iline * tlwidth); ! 990: x = ppt->x; ! 991: ! 992: if (*pwidth) ! 993: { ! 994: width = *pwidth; ! 995: while(width > 0) ! 996: { ! 997: psrc = psrcT; ! 998: w = min(tileWidth, width); ! 999: if((rem = (x - xSrc) % tileWidth) != 0) ! 1000: { ! 1001: /* if we're in the middle of the tile, get ! 1002: as many bits as will finish the span, or ! 1003: as many as will get to the left edge of the tile, ! 1004: or a longword worth, starting at the appropriate ! 1005: offset in the tile. ! 1006: */ ! 1007: w = min(min(tileWidth - rem, width), BITMAP_SCANLINE_UNIT); ! 1008: endinc = rem / BITMAP_SCANLINE_UNIT; ! 1009: getbits(psrc + endinc, rem & 0x1f, w, tmpSrc); ! 1010: putbitsrrop(tmpSrc, (x & 0x1f), w, pdst, rop); ! 1011: if((x & 0x1f) + w >= 0x20) ! 1012: pdst++; ! 1013: } ! 1014: ! 1015: else if(((x & 0x1f) + w) < 32) ! 1016: { ! 1017: /* doing < 32 bits is easy, and worth special-casing */ ! 1018: getbits(psrc, 0, w, tmpSrc); ! 1019: putbitsrrop(tmpSrc, x & 0x1f, w, pdst, rop); ! 1020: } ! 1021: else ! 1022: { ! 1023: /* start at the left edge of the tile, ! 1024: and put down as much as we can ! 1025: */ ! 1026: maskbits(x, w, startmask, endmask, nlMiddle); ! 1027: ! 1028: if (startmask) ! 1029: nstart = 32 - (x & 0x1f); ! 1030: else ! 1031: nstart = 0; ! 1032: if (endmask) ! 1033: nend = (x + w) & 0x1f; ! 1034: else ! 1035: nend = 0; ! 1036: ! 1037: srcStartOver = nstart > 31; ! 1038: ! 1039: if(startmask) ! 1040: { ! 1041: getbits(psrc, 0, nstart, tmpSrc); ! 1042: putbitsrrop(tmpSrc, (x & 0x1f), nstart, pdst, rop); ! 1043: pdst++; ! 1044: if(srcStartOver) ! 1045: psrc++; ! 1046: } ! 1047: ! 1048: while(nlMiddle--) ! 1049: { ! 1050: getbits(psrc, nstart, 32, tmpSrc); ! 1051: *pdst = DoRRop(rop, tmpSrc, *pdst); ! 1052: pdst++; ! 1053: psrc++; ! 1054: } ! 1055: if(endmask) ! 1056: { ! 1057: getbits(psrc, nstart, nend, tmpSrc); ! 1058: putbitsrrop(tmpSrc, 0, nend, pdst, rop); ! 1059: } ! 1060: } ! 1061: x += w; ! 1062: width -= w; ! 1063: } ! 1064: } ! 1065: ppt++; ! 1066: pwidth++; ! 1067: } ! 1068: DEALLOCATE_LOCAL(pptFree); ! 1069: DEALLOCATE_LOCAL(pwidthFree); ! 1070: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.