![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mibitblt.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 / mi|
Return to mibitblt.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mi |
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: mibitblt.c,v 1.52 87/09/13 20:56:01 toddb Exp $ */
25: /* Author: Todd Newman (aided and abetted by Mr. Drewry) */
26:
27: #include "X.h"
28: #include "Xprotostr.h"
29:
30: #include "misc.h"
31: #include "gcstruct.h"
32: #include "pixmapstr.h"
33: #include "windowstr.h"
34: #include "scrnintstr.h"
35: #include "mi.h"
36: #include "regionstr.h"
37: #include "Xmd.h"
38: #include "../mfb/maskbits.h"
39: #include "servermd.h"
40:
41:
42: /* MICOPYAREA -- public entry for the CopyArea request
43: * For each rectangle in the source region
44: * get the pixels with GetSpans
45: * set them in the destination with SetSpans
46: * We let SetSpans worry about clipping to the destination.
47: */
48: void
49: miCopyArea(pSrcDrawable, pDstDrawable,
50: pGC, xIn, yIn, widthSrc, heightSrc, xOut, yOut)
51: register DrawablePtr pSrcDrawable;
52: register DrawablePtr pDstDrawable;
53: GCPtr pGC;
54: int xIn, yIn;
55: int widthSrc, heightSrc;
56: int xOut, yOut;
57: {
58: DDXPointPtr ppt, pptFirst;
59: unsigned int *pwidthFirst, *pwidth, *pbits;
60: BoxRec srcBox, *prect;
61: /* may be a new region, or just a copy */
62: RegionPtr prgnSrcClip;
63: /* non-0 if we've created a src clip */
64: int realSrcClip = 0;
65: int srcx, srcy, dstx, dsty, i, j, y, width, height,
66: xMin, xMax, yMin, yMax;
67: unsigned int *ordering;
68:
69: /* clip the left and top edges of the source */
70: if (xIn < 0)
71: {
72: widthSrc += xIn;
73: srcx = 0;
74: }
75: else
76: srcx = xIn;
77: if (yIn < 0)
78: {
79: heightSrc += yIn;
80: srcy = 0;
81: }
82: else
83: srcy = yIn;
84:
85:
86: /* If the destination isn't realized, this is easy */
87: if (pDstDrawable->type == DRAWABLE_WINDOW &&
88: !((WindowPtr)pDstDrawable)->realized)
89: {
90: miSendNoExpose(pGC);
91: return;
92: }
93:
94: /* clip the source */
95: if (pSrcDrawable->type == DRAWABLE_PIXMAP)
96: {
97: BoxRec box;
98:
99: box.x1 = 0;
100: box.y1 = 0;
101: box.x2 = ((PixmapPtr)pSrcDrawable)->width;
102: box.y2 = ((PixmapPtr)pSrcDrawable)->height;
103:
104: prgnSrcClip = (*pGC->pScreen->RegionCreate)(&box, 1);
105: realSrcClip = 1;
106: }
107: else
108: {
109: srcx += ((WindowPtr)pSrcDrawable)->absCorner.x;
110: srcy += ((WindowPtr)pSrcDrawable)->absCorner.y;
111: prgnSrcClip = ((WindowPtr)pSrcDrawable)->clipList;
112: }
113:
114: /* If the src drawable is a window, we need to translate the srcBox so
115: * that we can compare it with the window's clip region later on. */
116: srcBox.x1 = srcx;
117: srcBox.y1 = srcy;
118: srcBox.x2 = srcx + widthSrc;
119: srcBox.y2 = srcy + heightSrc;
120:
121: if (pGC->miTranslate && (pDstDrawable->type == DRAWABLE_WINDOW) )
122: {
123: dstx = xOut + ((WindowPtr)pDstDrawable)->absCorner.x;
124: dsty = yOut + ((WindowPtr)pDstDrawable)->absCorner.y;
125: }
126: else
127: {
128: dstx = xOut;
129: dsty = yOut;
130: }
131:
132:
133:
134: pptFirst = ppt = (DDXPointPtr)
135: ALLOCATE_LOCAL(heightSrc * sizeof(DDXPointRec));
136: pwidthFirst = pwidth = (unsigned int *)
137: ALLOCATE_LOCAL(heightSrc * sizeof(unsigned int));
138: ordering = (unsigned int *)
139: ALLOCATE_LOCAL(prgnSrcClip->numRects * sizeof(unsigned int));
140: if(!pptFirst || !pwidthFirst || !ordering)
141: {
142: if (pptFirst)
143: DEALLOCATE_LOCAL(pptFirst);
144: if (pwidthFirst)
145: DEALLOCATE_LOCAL(pwidthFirst);
146: if (ordering)
147: DEALLOCATE_LOCAL(ordering);
148: return;
149: }
150:
151: /* If not the same drawable then order of move doesn't matter.
152: Following assumes that prgnSrcClip->rects are sorted from top
153: to bottom and left to right.
154: */
155: if (pSrcDrawable != pDstDrawable)
156: for (i=0; i < prgnSrcClip->numRects; i++)
157: ordering[i] = i;
158: else { /* within same drawable, must sequence moves carefully! */
159: if (dsty <= srcBox.y1) { /* Scroll up or stationary vertical.
160: Vertical order OK */
161: if (dstx <= srcBox.x1) /* Scroll left or stationary horizontal.
162: Horizontal order OK as well */
163: for (i=0; i < prgnSrcClip->numRects; i++)
164: ordering[i] = i;
165: else { /* scroll right. must reverse horizontal banding of rects. */
166: for (i=0, j=1, xMax=0;
167: i < prgnSrcClip->numRects;
168: j=i+1, xMax=i) {
169: /* find extent of current horizontal band */
170: y=prgnSrcClip->rects[i].y1; /* band has this y coordinate */
171: while ((j < prgnSrcClip->numRects) &&
172: (prgnSrcClip->rects[j].y1 == y))
173: j++;
174: /* reverse the horizontal band in the output ordering */
175: for (j-- ; j >= xMax; j--, i++)
176: ordering[i] = j;
177: }
178: }
179: }
180: else { /* Scroll down. Must reverse vertical banding. */
181: if (dstx < srcBox.x1) { /* Scroll left. Horizontal order OK. */
182: for (i=prgnSrcClip->numRects-1, j=i-1, yMin=i, yMax=0;
183: i >= 0;
184: j=i-1, yMin=i) {
185: /* find extent of current horizontal band */
186: y=prgnSrcClip->rects[i].y1; /* band has this y coordinate */
187: while ((j >= 0) &&
188: (prgnSrcClip->rects[j].y1 == y))
189: j--;
190: /* reverse the horizontal band in the output ordering */
191: for (j++ ; j <= yMin; j++, i--, yMax++)
192: ordering[yMax] = j;
193: }
194: }
195: else /* Scroll right or horizontal stationary.
196: Reverse horizontal order as well (if stationary, horizontal
197: order can be swapped without penalty and this is faster
198: to compute). */
199: for (i=0, j=prgnSrcClip->numRects-1;
200: i < prgnSrcClip->numRects;
201: i++, j--)
202: ordering[i] = j;
203: }
204: }
205:
206: for(i = 0;
207: i < prgnSrcClip->numRects;
208: i++)
209: {
210: prect = &prgnSrcClip->rects[ordering[i]];
211: xMin = max(prect->x1, srcBox.x1);
212: xMax = min(prect->x2, srcBox.x2);
213: yMin = max(prect->y1, srcBox.y1);
214: yMax = min(prect->y2, srcBox.y2);
215: /* is there anything visible here? */
216: if(xMax <= xMin || yMax <= yMin)
217: continue;
218:
219: ppt = pptFirst;
220: pwidth = pwidthFirst;
221: y = yMin;
222: height = yMax - yMin;
223: width = xMax - xMin;
224:
225: for(j = 0; j < height; j++)
226: {
227: /* We must untranslate before calling GetSpans */
228: ppt->x = xMin;
229: ppt++->y = y++;
230: *pwidth++ = width;
231: }
232: pbits = (*pSrcDrawable->pScreen->GetSpans)(pSrcDrawable, width,
233: pptFirst, pwidthFirst, height);
234: ppt = pptFirst;
235: pwidth = pwidthFirst;
236: xMin -= (srcx - dstx);
237: y = yMin - (srcy - dsty);
238: for(j = 0; j < height; j++)
239: {
240: ppt->x = xMin;
241: ppt++->y = y++;
242: *pwidth++ = width;
243: }
244:
245: (*pGC->SetSpans)(pDstDrawable, pGC, pbits, pptFirst, pwidthFirst,
246: height, TRUE);
247: Xfree(pbits);
248: }
249: miHandleExposures(pSrcDrawable, pDstDrawable, pGC, xIn, yIn,
250: widthSrc, heightSrc, xOut, yOut);
251: if(realSrcClip)
252: (*pGC->pScreen->RegionDestroy)(prgnSrcClip);
253:
254: DEALLOCATE_LOCAL(pptFirst);
255: DEALLOCATE_LOCAL(pwidthFirst);
256: DEALLOCATE_LOCAL(ordering);
257: }
258:
259: /* MIGETPLANE -- gets a bitmap representing one plane of pDraw
260: * A helper used for CopyPlane and XY format GetImage
261: * No clever strategy here, we grab a scanline at a time, pull out the
262: * bits and then stuff them in a 1 bit deep map.
263: */
264: static
265: unsigned long *
266: miGetPlane(pDraw, planeNum, sx, sy, w, h, result)
267: DrawablePtr pDraw;
268: int planeNum; /* number of the bitPlane */
269: int sx, sy, w, h;
270: unsigned long *result;
271: {
272: int i, j, k, depth, width, bitsPerPixel, widthInBytes;
273: DDXPointRec pt;
274: unsigned int *pline;
275: unsigned int bit;
276: unsigned char *pCharsOut;
277: CARD16 *pShortsOut;
278: CARD32 *pLongsOut;
279:
280: depth = pDraw->depth;
281: if(pDraw->type != DRAWABLE_PIXMAP)
282: {
283: sx += ((WindowPtr) pDraw)->absCorner.x;
284: sy += ((WindowPtr) pDraw)->absCorner.y;
285: }
286: widthInBytes = PixmapBytePad(w, 1);
287: if(!result)
288: result = (unsigned long *)Xalloc(h * widthInBytes);
289: bitsPerPixel = GetBitsPerPixel(depth);
290: bzero(result, h * widthInBytes);
291: if(BITMAP_SCANLINE_UNIT == 8)
292: pCharsOut = (unsigned char *) result;
293: else if(BITMAP_SCANLINE_UNIT == 16)
294: pShortsOut = (CARD16 *) result;
295: else if(BITMAP_SCANLINE_UNIT == 32)
296: pLongsOut = (CARD32 *) result;
297: if(bitsPerPixel == 1)
298: pCharsOut = (unsigned char *) result;
299: for(i = sy; i < sy + h; i++)
300: {
301: if(bitsPerPixel == 1)
302: {
303: pt.x = sx;
304: pt.y = i;
305: width = w;
306: pline = (*pDraw->pScreen->GetSpans)(pDraw, width, &pt, &width, 1);
307: bcopy(pline, pCharsOut, (w + 7)/8);
308: pCharsOut += widthInBytes;
309: Xfree(pline);
310: }
311: else
312: {
313: k = 0;
314: for(j = 0; j < w; j++)
315: {
316: pt.x = sx + j;
317: pt.y = i;
318: width = 1;
319: /* Fetch the next pixel */
320: pline = (*pDraw->pScreen->GetSpans)(pDraw, width, &pt,
321: &width, 1);
322: bit = (unsigned int) ((*pline >> planeNum) & 1);
323: /* Now insert that bit into a bitmap in XY format */
324: if(BITMAP_BIT_ORDER == LSBFirst)
325: bit <<= k;
326: else
327: bit <<= ((BITMAP_SCANLINE_UNIT - 1) - k);
328: if(BITMAP_SCANLINE_UNIT == 8)
329: {
330: *pCharsOut |= (unsigned char) bit;
331: k++;
332: if (k == 8)
333: {
334: pCharsOut++;
335: k = 0;
336: }
337: }
338: else if(BITMAP_SCANLINE_UNIT == 16)
339: {
340: *pShortsOut |= (CARD16) bit;
341: k++;
342: if (k == 16)
343: {
344: pShortsOut++;
345: k = 0;
346: }
347: }
348: if(BITMAP_SCANLINE_UNIT == 32)
349: {
350: *pLongsOut |= (CARD32) bit;
351: k++;
352: if (k == 32)
353: {
354: pLongsOut++;
355: k = 0;
356: }
357: }
358: Xfree(pline);
359: }
360:
361: }
362: }
363: return(result);
364:
365: }
366:
367: /* GETBITSPERPIXEL -- Find out how many bits per pixel are supported at
368: * this depth -- another helper function
369: */
370: static
371: int
372: GetBitsPerPixel(depth)
373: int depth;
374: {
375: int i;
376:
377: for(i = 0; i < screenInfo.numPixmapFormats; i++)
378: {
379: if(screenInfo.formats[i].depth == depth)
380: {
381: return (screenInfo.formats[i].bitsPerPixel);
382: }
383: }
384: return(1);
385: }
386:
387:
388: /* MIOPQSTIPDRAWABLE -- use pbits as an opaque stipple for pDraw.
389: * Drawing through the clip mask we SetSpans() the bits into a
390: * bitmap and stipple those bits onto the destination drawable by doing a
391: * PolyFillRect over the whole drawable,
392: * then we invert the bitmap by copying it onto itself with an alu of
393: * GXinvert, invert the foreground/background colors of the gc, and draw
394: * the background bits.
395: * Note how the clipped out bits of the bitmap are always the background
396: * color so that the stipple never causes FillRect to draw them.
397: */
398: void
399: miOpqStipDrawable(pDraw, pGC, prgnSrc, pbits, srcx, w, h, dstx, dsty)
400: DrawablePtr pDraw;
401: GCPtr pGC;
402: RegionPtr prgnSrc;
403: unsigned long *pbits;
404: int srcx, w, h, dstx, dsty;
405: {
406: int oldfill, i;
407: unsigned long oldfg;
408: int *pwidth, *pwidthFirst;
409: long gcv[6];
410: PixmapPtr pStipple, pPixmap;
411: DDXPointRec oldOrg;
412: GCPtr pGCT;
413: DDXPointPtr ppt, pptFirst;
414: xRectangle rect;
415: RegionPtr prgnSrcClip;
416:
417: pPixmap = (PixmapPtr)(*pDraw->pScreen->CreatePixmap)
418: (pDraw->pScreen, w, h, 1);
419:
420: if (!pPixmap)
421: {
422: ErrorF( "miOpqStipDrawable can't make temp pixmap\n");
423: return;
424: }
425:
426: /* Put the image into a 1 bit deep pixmap */
427: pGCT = GetScratchGC(1, pDraw->pScreen);
428: /* First set the whole pixmap to 0 */
429: gcv[0] = 0;
430: DoChangeGC(pGCT, GCBackground, gcv, 0);
431: ValidateGC(pPixmap, pGCT);
432: miClearDrawable(pPixmap, pGCT);
433: ppt = pptFirst = (DDXPointPtr)ALLOCATE_LOCAL(h * sizeof(DDXPointRec));
434: pwidth = pwidthFirst = (int *)ALLOCATE_LOCAL(h * sizeof(int));
435: if(!ppt || !pwidth)
436: {
437: DEALLOCATE_LOCAL(pwidthFirst);
438: DEALLOCATE_LOCAL(pptFirst);
439: FreeScratchGC(pGCT);
440: return;
441: }
442:
443: /* we need a temporary region because ChangeClip must be assumed
444: to destroy what it's sent. note that this means we don't
445: have to free prgnSrcClip ourselves.
446: */
447: prgnSrcClip = (*pGCT->pScreen->RegionCreate)(NULL, 0);
448: (*pGCT->pScreen->RegionCopy)(prgnSrcClip, prgnSrc);
449: (*pGCT->ChangeClip)(pGCT, CT_REGION, prgnSrcClip, 0);
450: ValidateGC(pPixmap, pGCT);
451:
452: /* Since we know pDraw is always a pixmap, we never need to think
453: * about translation here */
454: for(i = 0; i < h; i++)
455: {
456: ppt->x = srcx;
457: ppt++->y = i;
458: *pwidth++ = w;
459: }
460:
461: (*pGCT->SetSpans)(pPixmap, pGCT, pbits, pptFirst, pwidthFirst, h, TRUE);
462: DEALLOCATE_LOCAL(pwidthFirst);
463: DEALLOCATE_LOCAL(pptFirst);
464:
465:
466: /* Save current values from the client GC */
467: oldfill = pGC->fillStyle;
468: pStipple = pGC->stipple;
469: if(pStipple)
470: pStipple->refcnt++;
471: oldOrg = pGC->patOrg;
472:
473: /* Set a new stipple in the drawable */
474: gcv[0] = FillStippled;
475: gcv[1] = (long) pPixmap;
476: gcv[2] = dstx;
477: gcv[3] = dsty;
478:
479: DoChangeGC(pGC,
480: GCFillStyle | GCStipple | GCTileStipXOrigin | GCTileStipYOrigin,
481: gcv, 1);
482: ValidateGC(pDraw, pGC);
483:
484: /* Fill the drawable with the stipple. This will draw the
485: * foreground color whereever 1 bits are set, leaving everything
486: * with 0 bits untouched. Note that the part outside the clip
487: * region is all 0s. */
488: rect.x = dstx;
489: rect.y = dsty;
490: rect.width = w;
491: rect.height = h;
492: (*pGC->PolyFillRect)(pDraw, pGC, 1, &rect);
493:
494: /* Invert the tiling pixmap. This sets 0s for 1s and 1s for 0s, only
495: * within the clipping region, the part outside is still all 0s */
496: gcv[0] = GXinvert;
497: DoChangeGC(pGCT, GCFunction, gcv, 0);
498: ValidateGC(pPixmap, pGCT);
499: (*pGCT->CopyArea)(pPixmap, pPixmap, pGCT, 0, 0, w, h, 0, 0);
500:
501: /* Swap foreground and background colors on the GC for the drawable.
502: * Now when we fill the drawable, we will fill in the "Background"
503: * values */
504: oldfg = pGC->fgPixel;
505: gcv[0] = (long) pGC->bgPixel;
506: gcv[1] = (long) oldfg;
507: gcv[2] = (long) pPixmap;
508: DoChangeGC(pGC, GCForeground | GCBackground | GCStipple, gcv, 1);
509: ValidateGC(pDraw, pGC);
510: /* PolyFillRect might have bashed the rectangle */
511: rect.x = dstx;
512: rect.y = dsty;
513: rect.width = w;
514: rect.height = h;
515: (*pGC->PolyFillRect)(pDraw, pGC, 1, &rect);
516:
517: /* Now put things back */
518: if(pStipple)
519: pStipple->refcnt--;
520: gcv[0] = (long) oldfg;
521: gcv[1] = pGC->fgPixel;
522: gcv[2] = oldfill;
523: gcv[3] = (long) pStipple;
524: gcv[4] = oldOrg.x;
525: gcv[5] = oldOrg.y;
526: DoChangeGC(pGC,
527: GCForeground | GCBackground | GCFillStyle | GCStipple |
528: GCTileStipXOrigin | GCTileStipYOrigin, gcv, 1);
529:
530: ValidateGC(pDraw, pGC);
531: /* put what we hope is a smaller clip region back in the scratch gc */
532: (*pGCT->ChangeClip)(pGCT, CT_NONE, 0, 0);
533: FreeScratchGC(pGCT);
534: (*pDraw->pScreen->DestroyPixmap)(pPixmap);
535:
536: }
537:
538: /* MICOPYPLANE -- public entry for the CopyPlane request.
539: * strategy:
540: * First build up a bitmap out of the bits requested
541: * build a source clip
542: * Use the bitmap we've built up as a Stipple for the destination
543: */
544: void
545: miCopyPlane(pSrcDrawable, pDstDrawable,
546: pGC, srcx, srcy, width, height, dstx, dsty, bitPlane)
547: DrawablePtr pSrcDrawable;
548: DrawablePtr pDstDrawable;
549: GCPtr pGC;
550: int srcx, srcy;
551: int width, height;
552: int dstx, dsty;
553: unsigned long bitPlane;
554: {
555: unsigned long *ptile;
556: BoxRec box;
557: RegionPtr prgnSrc;
558:
559:
560:
561: /* clip the left and top edges of the source */
562: if (srcx < 0)
563: {
564: width += srcx;
565: srcx = 0;
566: }
567: if (srcy < 0)
568: {
569: height += srcy;
570: srcy = 0;
571: }
572:
573: /* incorporate the source clip */
574:
575: if (pSrcDrawable->type != DRAWABLE_PIXMAP)
576: {
577: box.x1 = ((WindowPtr)pSrcDrawable)->absCorner.x;
578: box.y1 = ((WindowPtr)pSrcDrawable)->absCorner.y;
579: box.x2 = box.x1 + width;
580: box.y2 = box.y1 + height;
581: prgnSrc = (*pGC->pScreen->RegionCreate)(&box, 1);
582: (*pGC->pScreen->Intersect)
583: (prgnSrc, prgnSrc, ((WindowPtr)pSrcDrawable)->clipList);
584: (*pGC->pScreen->TranslateRegion)(prgnSrc,
585: -((WindowPtr)pSrcDrawable)->absCorner.x,
586: -((WindowPtr)pSrcDrawable)->absCorner.y);
587: }
588: else
589: {
590: box.x1 = 0;
591: box.y1 = 0;
592: box.x2 = ((PixmapPtr)pSrcDrawable)->width;
593: box.y2 = ((PixmapPtr)pSrcDrawable)->height;
594: prgnSrc = (*pGC->pScreen->RegionCreate)(&box, 1);
595: }
596:
597: /* note that we convert the plane mask bitPlane into a plane number */
598: ptile = miGetPlane(pSrcDrawable, ffs(bitPlane) - 1, srcx, srcy,
599: width, height, (unsigned char *) NULL);
600: miOpqStipDrawable(pDstDrawable, pGC, prgnSrc, ptile, 0,
601: width, height, dstx, dsty);
602: miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
603: width, height, dstx, dsty);
604: Xfree(ptile);
605: (*pGC->pScreen->RegionDestroy)(prgnSrc);
606: }
607:
608: /* MIGETIMAGE -- public entry for the GetImage Request
609: * We're getting the image into a memory buffer. While we have to use GetSpans
610: * to read a line from the device (since we don't know what that looks like),
611: * we can just write into the destination buffer
612: *
613: * two different strategies are used, depending on whether we're getting the
614: * image in Z format or XY format
615: * Z format:
616: * Line at a time, GetSpans a line and bcopy it to the destination
617: * buffer, except that if the planemask is not all ones, we create a
618: * temporary pixmap and do a SetSpans into it (to get bits turned off)
619: * and then another GetSpans to get stuff back (because pixmaps are
620: * opaque, and we are passed in the memory to write into). This is
621: * completely ugly and slow but works, but the interfaces just aren't
622: * designed for this case. Life is hard.
623: * XY format:
624: * get the single plane specified in planemask
625: */
626: void
627: miGetImage(pDraw, sx, sy, w, h, format, planeMask, pdstLine)
628: DrawablePtr pDraw;
629: int sx, sy, w, h;
630: unsigned int format;
631: unsigned long planeMask;
632: pointer pdstLine;
633: {
634: int depth, i, linelength, width, srcx, srcy;
635: DDXPointRec pt;
636: unsigned long *pbits;
637: long gcv[2];
638: PixmapPtr pPixmap = (PixmapPtr)NULL;
639: GCPtr pGC;
640: unsigned long * pDst = (unsigned long *)pdstLine;
641:
642: depth = pDraw->depth;
643: if(format == ZPixmap)
644: {
645: if ( (((1<<pDraw->depth)-1)&planeMask) !=
646: (1<<pDraw->depth)-1
647: )
648: {
649: pGC = GetScratchGC(depth, pDraw->pScreen);
650: pPixmap = (PixmapPtr)(*pDraw->pScreen->CreatePixmap)
651: (pDraw->pScreen, w, h, depth);
652: gcv[0] = GXcopy;
653: gcv[1] = planeMask;
654: DoChangeGC(pGC, GCPlaneMask | GCFunction, gcv, 0);
655: ValidateGC(pPixmap, pGC);
656: }
657:
658: linelength = PixmapBytePad(w, depth);
659: srcx = sx;
660: srcy = sy;
661: if(pDraw->type == DRAWABLE_WINDOW)
662: {
663: srcx += ((WindowPtr)pDraw)->absCorner.x;
664: srcy += ((WindowPtr)pDraw)->absCorner.y;
665: }
666: for(i = 0; i < h; i++)
667: {
668: pt.x = srcx;
669: pt.y = srcy + i;
670: width = w;
671: pbits = (unsigned long *)
672: (*pDraw->pScreen->GetSpans)(pDraw, w, &pt, &width, 1);
673: if (pPixmap)
674: {
675: pt.x = 0;
676: pt.y = 0;
677: width = w;
678: (*pGC->SetSpans)(pPixmap, pGC, pbits, &pt, &width, 1, TRUE);
679: Xfree(pbits);
680: pbits = (unsigned long *)
681: (*pDraw->pScreen->GetSpans)(pPixmap, w, &pt, &width, 1);
682: }
683: bcopy(pbits, (char *)pDst, linelength);
684: pDst += linelength / sizeof(long);
685: Xfree(pbits);
686: }
687: if (pPixmap)
688: {
689: (*pGC->pScreen->DestroyPixmap)(pPixmap);
690: FreeScratchGC(pGC);
691: }
692: }
693: else
694: {
695: miGetPlane(pDraw, ffs(planeMask) - 1, sx, sy, w, h, pDst);
696: }
697: }
698:
699:
700: /* MIPUTIMAGE -- public entry for the PutImage request
701: * Here we benefit from knowing the format of the bits pointed to by pImage,
702: * even if we don't know how pDraw represents them.
703: * Three different strategies are used depending on the format
704: * XYBitmap Format:
705: * we just use the Opaque Stipple helper function to cover the destination
706: * Note that this covers all the planes of the drawable with the
707: * foreground color (masked with the GC planemask) where there are 1 bits
708: * and the background color (masked with the GC planemask) where there are
709: * 0 bits
710: * XYPixmap format:
711: * what we're called with is a series of XYBitmaps, but we only want
712: * each XYPixmap to update 1 plane, instead of updating all of them.
713: * we set the foreground color to be all 1s and the background to all 0s
714: * then for each plane, we set the plane mask to only effect that one
715: * plane and recursive call ourself with the format set to XYBitmap
716: * (This clever idea courtesy of RGD.)
717: * ZPixmap format:
718: * This part is simple, just call SetSpans
719: */
720: void
721: miPutImage(pDraw, pGC, depth, x, y, w, h, leftPad, format, pImage)
722: DrawablePtr pDraw;
723: GCPtr pGC;
724: int depth, x, y, w, h, leftPad;
725: unsigned int format;
726: unsigned char *pImage;
727: {
728: DDXPointPtr pptFirst, ppt;
729: int *pwidthFirst, *pwidth, i;
730: RegionPtr prgnSrc;
731: BoxRec box;
732: unsigned long oldFg, oldBg, gcv[3];
733: unsigned long oldPlanemask;
734:
735: switch(format)
736: {
737: case XYBitmap:
738:
739: box.x1 = 0;
740: box.y1 = 0;
741: box.x2 = w;
742: box.y2 = h;
743: prgnSrc = (*pGC->pScreen->RegionCreate)(&box, 1);
744:
745: miOpqStipDrawable(pDraw, pGC, prgnSrc, pImage, leftPad,
746: (w - leftPad), h, x, y);
747: (*pGC->pScreen->RegionDestroy)(prgnSrc);
748: break;
749:
750: case XYPixmap:
751: depth = pGC->depth;
752: oldPlanemask = pGC->planemask;
753: oldFg = pGC->fgPixel;
754: oldBg = pGC->bgPixel;
755: gcv[0] = ~0;
756: gcv[1] = 0;
757: DoChangeGC(pGC, GCForeground | GCBackground, gcv, 0);
758:
759: for (i = 1 << (depth-1); i > 0; i >>= 1)
760: {
761: if (i & oldPlanemask)
762: {
763: gcv[0] = i;
764: DoChangeGC(pGC, GCPlaneMask, gcv, 0);
765: ValidateGC(pDraw, pGC);
766: (*pGC->PutImage)(pDraw, pGC, 1, x, y, w, h, leftPad,
767: XYBitmap, pImage);
768: pImage += h * PixmapBytePad(w, 1);
769: }
770: }
771: gcv[0] = oldPlanemask;
772: gcv[1] = oldFg;
773: gcv[2] = oldBg;
774: DoChangeGC(pGC, GCPlaneMask | GCForeground | GCBackground, gcv, 0);
775: break;
776:
777: case ZPixmap:
778: ppt = pptFirst = (DDXPointPtr)ALLOCATE_LOCAL(h * sizeof(DDXPointRec));
779: pwidth = pwidthFirst = (int *)ALLOCATE_LOCAL(h * sizeof(int));
780: if(!ppt || !pwidth)
781: {
782: if (ppt)
783: DEALLOCATE_LOCAL(ppt);
784: else if (pwidth)
785: DEALLOCATE_LOCAL(pwidthFirst);
786: return;
787: }
788: if ((pDraw->type == DRAWABLE_WINDOW) &&
789: (pGC->miTranslate))
790: {
791: x += ((WindowPtr)(pDraw))->absCorner.x;
792: y += ((WindowPtr)(pDraw))->absCorner.y;
793: }
794:
795: for(i = 0; i < h; i++)
796: {
797: ppt->x = x;
798: ppt->y = y + i;
799: ppt++;
800: *pwidth++ = w;
801: }
802:
803: (*pGC->SetSpans)(pDraw, pGC, pImage, pptFirst, pwidthFirst, h, TRUE);
804: DEALLOCATE_LOCAL(pptFirst);
805: DEALLOCATE_LOCAL(pwidthFirst);
806: break;
807: }
808: }
809:
810: /* MICLEARDRAWABLE -- sets the entire drawable to the background color of
811: * the GC. Useful when we have a scratch drawable and need to initialize
812: * it. */
813: miClearDrawable(pDraw, pGC)
814: DrawablePtr pDraw;
815: GCPtr pGC;
816: {
817: int fg = pGC->fgPixel;
818: int bg = pGC->bgPixel;
819: xRectangle rect;
820:
821: rect.x = 0;
822: rect.y = 0;
823: if(pDraw->type == DRAWABLE_PIXMAP)
824: {
825: rect.width = ((PixmapPtr) pDraw)->width;
826: rect.height = ((PixmapPtr) pDraw)->height;
827: }
828: else
829: {
830: rect.width = ((WindowPtr) pDraw)->clientWinSize.width;
831: rect.height = ((WindowPtr) pDraw)->clientWinSize.height;
832: }
833: DoChangeGC(pGC, GCForeground, &bg, 0);
834: ValidateGC(pDraw, pGC);
835: (*pGC->PolyFillRect)(pDraw, pGC, 1, &rect);
836: DoChangeGC(pGC, GCForeground, &fg, 0);
837: ValidateGC(pDraw, pGC);
838: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.