![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mfbbitblt.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 mfbbitblt.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: mfbbitblt.c,v 1.42 87/08/09 13:58:52 ham Exp $ */
25: #include "X.h"
26: #include "Xprotostr.h"
27:
28: #include "miscstruct.h"
29: #include "regionstr.h"
30: #include "gcstruct.h"
31: #include "windowstr.h"
32: #include "pixmapstr.h"
33: #include "scrnintstr.h"
34:
35: #include "mfb.h"
36: #include "maskbits.h"
37:
38:
39: /* CopyArea and CopyPlane for a monchrome frame buffer
40:
41:
42: clip the source rectangle to the source's available bits. (this
43: avoids copying unnecessary pieces that will just get exposed anyway.)
44: this becomes the new shape of the destination.
45: clip the destination region to the composite clip in the
46: GC. this requires translating the destination region to (dstx, dsty).
47: build a list of source points, one for each rectangle in the
48: destination. this is a simple translation.
49: go do the multiple rectangle copies
50: do graphics exposures
51: */
52:
53: void
54: mfbCopyArea(pSrcDrawable, pDstDrawable,
55: pGC, srcx, srcy, width, height, dstx, dsty)
56: register DrawablePtr pSrcDrawable;
57: register DrawablePtr pDstDrawable;
58: GC *pGC;
59: int srcx, srcy;
60: int width, height;
61: int dstx, dsty;
62: {
63: BoxRec srcBox;
64: RegionPtr prgnSrcClip; /* may be a new region, or just a copy */
65: int realSrcClip = 0; /* non-0 if we've created a src clip */
66:
67: RegionPtr prgnDst;
68: DDXPointPtr pptSrc;
69: register DDXPointPtr ppt;
70: register BoxPtr pbox;
71: int i;
72: register int dx;
73: register int dy;
74: xRectangle origSource;
75: DDXPointRec origDest;
76:
77: if (!(pGC->planemask & 1))
78: return;
79:
80: origSource.x = srcx;
81: origSource.y = srcy;
82: origSource.width = width;
83: origSource.height = height;
84: origDest.x = dstx;
85: origDest.y = dsty;
86:
87: /*
88: clip the left and top edges of the source
89: */
90: if (srcx < 0)
91: {
92: width += srcx;
93: srcx = 0;
94: }
95: if (srcy < 0)
96: {
97: height += srcy;
98: srcy = 0;
99: }
100:
101: /* clip the source */
102:
103: if (pSrcDrawable->type == DRAWABLE_PIXMAP)
104: {
105: BoxRec box;
106:
107: box.x1 = 0;
108: box.y1 = 0;
109: box.x2 = ((PixmapPtr)pSrcDrawable)->width;
110: box.y2 = ((PixmapPtr)pSrcDrawable)->height;
111:
112: prgnSrcClip = miRegionCreate(&box, 1);
113: realSrcClip = 1;
114: }
115: else
116: {
117: srcx += ((WindowPtr)pSrcDrawable)->absCorner.x;
118: srcy += ((WindowPtr)pSrcDrawable)->absCorner.y;
119: prgnSrcClip = ((WindowPtr)pSrcDrawable)->clipList;
120: }
121:
122: srcBox.x1 = srcx;
123: srcBox.y1 = srcy;
124: srcBox.x2 = srcx + width;
125: srcBox.y2 = srcy + height;
126:
127: prgnDst = miRegionCreate(&srcBox, 1);
128: miIntersect(prgnDst, prgnDst, prgnSrcClip);
129:
130: if (pDstDrawable->type == DRAWABLE_WINDOW)
131: {
132: if (!((WindowPtr)pDstDrawable)->realized)
133: {
134: miSendNoExpose(pGC);
135: miRegionDestroy(prgnDst);
136: if (realSrcClip)
137: miRegionDestroy(prgnSrcClip);
138: return;
139: }
140: dstx += ((WindowPtr)pDstDrawable)->absCorner.x;
141: dsty += ((WindowPtr)pDstDrawable)->absCorner.y;
142: }
143:
144: dx = srcx - dstx;
145: dy = srcy - dsty;
146:
147: /* clip the shape of the dst to the destination composite clip */
148: miTranslateRegion(prgnDst, -dx, -dy);
149: miIntersect(prgnDst,
150: prgnDst,
151: ((mfbPrivGC *)(pGC->devPriv))->pCompositeClip);
152:
153: if (!prgnDst->numRects)
154: {
155: miSendNoExpose(pGC);
156: miRegionDestroy(prgnDst);
157: if (realSrcClip)
158: miRegionDestroy(prgnSrcClip);
159: return;
160: }
161: if(!(pptSrc = (DDXPointPtr)ALLOCATE_LOCAL( prgnDst->numRects *
162: sizeof(DDXPointRec))))
163: {
164: miRegionDestroy(prgnDst);
165: if (realSrcClip)
166: miRegionDestroy(prgnSrcClip);
167: return;
168: }
169: pbox = prgnDst->rects;
170: ppt = pptSrc;
171: for (i=0; i<prgnDst->numRects; i++, pbox++, ppt++)
172: {
173: ppt->x = pbox->x1 + dx;
174: ppt->y = pbox->y1 + dy;
175: }
176:
177: mfbDoBitblt(pSrcDrawable, pDstDrawable, pGC->alu, prgnDst, pptSrc);
178:
179: if (((mfbPrivGC *)(pGC->devPriv))->fExpose)
180: miHandleExposures(pSrcDrawable, pDstDrawable, pGC,
181: origSource.x, origSource.y,
182: origSource.width, origSource.height,
183: origDest.x, origDest.y);
184:
185: DEALLOCATE_LOCAL(pptSrc);
186: miRegionDestroy(prgnDst);
187: if (realSrcClip)
188: miRegionDestroy(prgnSrcClip);
189: }
190:
191: /* DoBitblt() does multiple rectangle moves into the rectangles
192: DISCLAIMER:
193: this code can be made much faster; this implementation is
194: designed to be independent of byte/bit order, processor
195: instruction set, and the like. it could probably be done
196: in a similarly device independent way using mask tables instead
197: of the getbits/putbits macros. the narrow case (w<32) can be
198: subdivided into a case that crosses word boundaries and one that
199: doesn't.
200:
201: we have to cope with the dircetion on a per band basis,
202: rather than a per rectangle basis. moving bottom to top
203: means we have to invert the order of the bands; moving right
204: to left requires reversing the order of the rectangles in
205: each band.
206:
207: if src or dst is a window, the points have already been
208: translated.
209: */
210:
211: mfbDoBitblt(pSrcDrawable, pDstDrawable, alu, prgnDst, pptSrc)
212: DrawablePtr pSrcDrawable;
213: DrawablePtr pDstDrawable;
214: int alu;
215: RegionPtr prgnDst;
216: DDXPointPtr pptSrc;
217: {
218: unsigned int *psrcBase, *pdstBase;
219: /* start of src and dst bitmaps */
220: int widthSrc, widthDst; /* add to get to same position in next line */
221:
222: register BoxPtr pbox;
223: int nbox;
224:
225: BoxPtr pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
226: /* temporaries for shuffling rectangles */
227: DDXPointPtr pptTmp, pptNew1, pptNew2;
228: /* shuffling boxes entails shuffling the
229: source points too */
230: int w, h;
231: int xdir; /* 1 = left right, -1 = right left/ */
232: int ydir; /* 1 = top down, -1 = bottom up */
233:
234: unsigned int *psrcLine, *pdstLine;
235: /* pointers to line with current src and dst */
236: register unsigned int *psrc;/* pointer to current src longword */
237: register unsigned int *pdst;/* pointer to current dst longword */
238:
239: /* following used for looping through a line */
240: int startmask, endmask; /* masks for writing ends of dst */
241: int nlMiddle; /* whole longwords in dst */
242: register int nl; /* temp copy of nlMiddle */
243: register unsigned int tmpSrc;
244: /* place to store full source word */
245: register int xoffSrc; /* offset (>= 0, < 32) from which to
246: fetch whole longwords fetched
247: in src */
248: int nstart; /* number of ragged bits at start of dst */
249: int nend; /* number of ragged bits at end of dst */
250: int srcStartOver; /* pulling nstart bits from src
251: overflows into the next word? */
252:
253:
254: if (pSrcDrawable->type == DRAWABLE_WINDOW)
255: {
256: psrcBase = (unsigned int *)
257: (((PixmapPtr)(pSrcDrawable->pScreen->devPrivate))->devPrivate);
258: widthSrc = (int)
259: ((PixmapPtr)(pSrcDrawable->pScreen->devPrivate))->devKind
260: >> 2;
261: }
262: else
263: {
264: psrcBase = (unsigned int *)(((PixmapPtr)pSrcDrawable)->devPrivate);
265: widthSrc = (int)(((PixmapPtr)pSrcDrawable)->devKind) >> 2;
266: }
267:
268: if (pDstDrawable->type == DRAWABLE_WINDOW)
269: {
270: pdstBase = (unsigned int *)
271: (((PixmapPtr)(pDstDrawable->pScreen->devPrivate))->devPrivate);
272: widthDst = (int)
273: ((PixmapPtr)(pDstDrawable->pScreen->devPrivate))->devKind
274: >> 2;
275: }
276: else
277: {
278: pdstBase = (unsigned int *)(((PixmapPtr)pDstDrawable)->devPrivate);
279: widthDst = (int)(((PixmapPtr)pDstDrawable)->devKind) >> 2;
280: }
281:
282: pbox = prgnDst->rects;
283: nbox = prgnDst->numRects;
284:
285: pboxNew1 = 0;
286: pptNew1 = 0;
287: pboxNew2 = 0;
288: pptNew2 = 0;
289: if (pptSrc->y < pbox->y1)
290: {
291: /* walk source botttom to top */
292: ydir = -1;
293: widthSrc = -widthSrc;
294: widthDst = -widthDst;
295:
296: if (nbox > 1)
297: {
298: /* keep ordering in each band, reverse order of bands */
299: pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
300: pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
301: if(!pboxNew1 || !pptNew1)
302: {
303: DEALLOCATE_LOCAL(pptNew1);
304: DEALLOCATE_LOCAL(pboxNew1);
305: return;
306: }
307: pboxBase = pboxNext = pbox+nbox-1;
308: while (pboxBase >= pbox)
309: {
310: while ((pboxNext >= pbox) &&
311: (pboxBase->y1 == pboxNext->y1))
312: pboxNext--;
313: pboxTmp = pboxNext+1;
314: pptTmp = pptSrc + (pboxTmp - pbox);
315: while (pboxTmp <= pboxBase)
316: {
317: *pboxNew1++ = *pboxTmp++;
318: *pptNew1++ = *pptTmp++;
319: }
320: pboxBase = pboxNext;
321: }
322: pboxNew1 -= nbox;
323: pbox = pboxNew1;
324: pptNew1 -= nbox;
325: pptSrc = pptNew1;
326: }
327: }
328: else
329: {
330: /* walk source top to bottom */
331: ydir = 1;
332: }
333:
334: if (pptSrc->x < pbox->x1)
335: {
336: /* walk source right to left */
337: xdir = -1;
338:
339: if (nbox > 1)
340: {
341: /* reverse order of rects in each band */
342: pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
343: pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
344: pboxBase = pboxNext = pbox;
345: if(!pboxNew2 || !pptNew2)
346: {
347: DEALLOCATE_LOCAL(pptNew2);
348: DEALLOCATE_LOCAL(pboxNew2);
349: return;
350: }
351: while (pboxBase < pbox+nbox)
352: {
353: while ((pboxNext < pbox+nbox) &&
354: (pboxNext->y1 == pboxBase->y1))
355: pboxNext++;
356: pboxTmp = pboxNext;
357: pptTmp = pptSrc + (pboxTmp - pbox);
358: while (pboxTmp != pboxBase)
359: {
360: *pboxNew2++ = *--pboxTmp;
361: *pptNew2++ = *--pptTmp;
362: }
363: pboxBase = pboxNext;
364: }
365: pboxNew2 -= nbox;
366: pbox = pboxNew2;
367: pptNew2 -= nbox;
368: pptSrc = pptNew2;
369: }
370: }
371: else
372: {
373: /* walk source left to right */
374: xdir = 1;
375: }
376:
377:
378: /* special case copy */
379: if (alu == GXcopy)
380: {
381: while (nbox--)
382: {
383: w = pbox->x2 - pbox->x1;
384: h = pbox->y2 - pbox->y1;
385:
386: if (ydir == -1) /* start at last scanline of rectangle */
387: {
388: psrcLine = psrcBase + ((pptSrc->y+h-1) * -widthSrc);
389: pdstLine = pdstBase + ((pbox->y2-1) * -widthDst);
390: }
391: else /* start at first scanline */
392: {
393: psrcLine = psrcBase + (pptSrc->y * widthSrc);
394: pdstLine = pdstBase + (pbox->y1 * widthDst);
395: }
396:
397: /* x direction doesn't matter for < 1 longword */
398: if (w <= 32)
399: {
400: int srcBit, dstBit; /* bit offset of src and dst */
401:
402: pdstLine += (pbox->x1 >> 5);
403: psrcLine += (pptSrc->x >> 5);
404: psrc = psrcLine;
405: pdst = pdstLine;
406:
407: srcBit = pptSrc->x & 0x1f;
408: dstBit = pbox->x1 & 0x1f;
409:
410: while(h--)
411: {
412: getbits(psrc, srcBit, w, tmpSrc)
413: putbits(tmpSrc, dstBit, w, pdst)
414: pdst += widthDst;
415: psrc += widthSrc;
416: }
417: }
418: else
419: {
420: maskbits(pbox->x1, w, startmask, endmask, nlMiddle)
421: if (startmask)
422: nstart = 32 - (pbox->x1 & 0x1f);
423: else
424: nstart = 0;
425: if (endmask)
426: nend = pbox->x2 & 0x1f;
427: else
428: nend = 0;
429:
430: xoffSrc = ((pptSrc->x & 0x1f) + nstart) & 0x1f;
431: srcStartOver = ((pptSrc->x & 0x1f) + nstart) > 31;
432:
433: if (xdir == 1) /* move left to right */
434: {
435: pdstLine += (pbox->x1 >> 5);
436: psrcLine += (pptSrc->x >> 5);
437:
438: while (h--)
439: {
440: psrc = psrcLine;
441: pdst = pdstLine;
442:
443: if (startmask)
444: {
445: getbits(psrc, (pptSrc->x & 0x1f), nstart, tmpSrc)
446: putbits(tmpSrc, (pbox->x1 & 0x1f), nstart, pdst)
447: pdst++;
448: if (srcStartOver)
449: psrc++;
450: }
451:
452: nl = nlMiddle;
453: while (nl--)
454: {
455: getbits(psrc, xoffSrc, 32, tmpSrc)
456: *pdst++ = tmpSrc;
457: psrc++;
458: }
459:
460: if (endmask)
461: {
462: getbits(psrc, xoffSrc, nend, tmpSrc)
463: putbits(tmpSrc, 0, nend, pdst)
464: }
465:
466: pdstLine += widthDst;
467: psrcLine += widthSrc;
468: }
469: }
470: else /* move right to left */
471: {
472: pdstLine += (pbox->x2 >> 5);
473: psrcLine += (pptSrc->x+w >> 5);
474: /* if fetch of last partial bits from source crosses
475: a longword boundary, start at the previous longword
476: */
477: if (xoffSrc + nend >= 32)
478: --psrcLine;
479:
480: while (h--)
481: {
482: psrc = psrcLine;
483: pdst = pdstLine;
484:
485: if (endmask)
486: {
487: getbits(psrc, xoffSrc, nend, tmpSrc)
488: putbits(tmpSrc, 0, nend, pdst)
489: }
490:
491: nl = nlMiddle;
492: while (nl--)
493: {
494: --psrc;
495: getbits(psrc, xoffSrc, 32, tmpSrc)
496: *--pdst = tmpSrc;
497: }
498:
499: if (startmask)
500: {
501: if (srcStartOver)
502: --psrc;
503: --pdst;
504: getbits(psrc, (pptSrc->x & 0x1f), nstart, tmpSrc)
505: putbits(tmpSrc, (pbox->x1 & 0x1f), nstart, pdst)
506: }
507:
508: pdstLine += widthDst;
509: psrcLine += widthSrc;
510: }
511: } /* move right to left */
512: }
513: pbox++;
514: pptSrc++;
515: } /* while (nbox--) */
516: }
517: else /* do some rop */
518: {
519: while (nbox--)
520: {
521: w = pbox->x2 - pbox->x1;
522: h = pbox->y2 - pbox->y1;
523:
524: if (ydir == -1) /* start at last scanline of rectangle */
525: {
526: psrcLine = psrcBase + ((pptSrc->y+h-1) * -widthSrc);
527: pdstLine = pdstBase + ((pbox->y2-1) * -widthDst);
528: }
529: else /* start at first scanline */
530: {
531: psrcLine = psrcBase + (pptSrc->y * widthSrc);
532: pdstLine = pdstBase + (pbox->y1 * widthDst);
533: }
534:
535: /* x direction doesn't matter for < 1 longword */
536: if (w <= 32)
537: {
538: int srcBit, dstBit; /* bit offset of src and dst */
539:
540: pdstLine += (pbox->x1 >> 5);
541: psrcLine += (pptSrc->x >> 5);
542: psrc = psrcLine;
543: pdst = pdstLine;
544:
545: srcBit = pptSrc->x & 0x1f;
546: dstBit = pbox->x1 & 0x1f;
547:
548: while(h--)
549: {
550: getbits(psrc, srcBit, w, tmpSrc)
551: putbitsrop(tmpSrc, dstBit, w, pdst, alu)
552: pdst += widthDst;
553: psrc += widthSrc;
554: }
555: }
556: else
557: {
558: maskbits(pbox->x1, w, startmask, endmask, nlMiddle)
559: if (startmask)
560: nstart = 32 - (pbox->x1 & 0x1f);
561: else
562: nstart = 0;
563: if (endmask)
564: nend = pbox->x2 & 0x1f;
565: else
566: nend = 0;
567:
568: xoffSrc = ((pptSrc->x & 0x1f) + nstart) & 0x1f;
569: srcStartOver = ((pptSrc->x & 0x1f) + nstart) > 31;
570:
571: if (xdir == 1) /* move left to right */
572: {
573: pdstLine += (pbox->x1 >> 5);
574: psrcLine += (pptSrc->x >> 5);
575:
576: while (h--)
577: {
578: psrc = psrcLine;
579: pdst = pdstLine;
580:
581: if (startmask)
582: {
583: getbits(psrc, (pptSrc->x & 0x1f), nstart, tmpSrc)
584: putbitsrop(tmpSrc, (pbox->x1 & 0x1f), nstart, pdst,
585: alu)
586: pdst++;
587: if (srcStartOver)
588: psrc++;
589: }
590:
591: nl = nlMiddle;
592: while (nl--)
593: {
594: getbits(psrc, xoffSrc, 32, tmpSrc)
595: *pdst = DoRop(alu, tmpSrc, *pdst);
596: pdst++;
597: psrc++;
598: }
599:
600: if (endmask)
601: {
602: getbits(psrc, xoffSrc, nend, tmpSrc)
603: putbitsrop(tmpSrc, 0, nend, pdst, alu)
604: }
605:
606: pdstLine += widthDst;
607: psrcLine += widthSrc;
608: }
609: }
610: else /* move right to left */
611: {
612: pdstLine += (pbox->x2 >> 5);
613: psrcLine += (pptSrc->x+w >> 5);
614: /* if fetch of last partial bits from source crosses
615: a longword boundary, start at the previous longword
616: */
617: if (xoffSrc + nend >= 32)
618: --psrcLine;
619:
620: while (h--)
621: {
622: psrc = psrcLine;
623: pdst = pdstLine;
624:
625: if (endmask)
626: {
627: getbits(psrc, xoffSrc, nend, tmpSrc)
628: putbitsrop(tmpSrc, 0, nend, pdst, alu)
629: }
630:
631: nl = nlMiddle;
632: while (nl--)
633: {
634: --psrc;
635: --pdst;
636: getbits(psrc, xoffSrc, 32, tmpSrc)
637: *pdst = DoRop(alu, tmpSrc, *pdst);
638: }
639:
640: if (startmask)
641: {
642: if (srcStartOver)
643: --psrc;
644: --pdst;
645: getbits(psrc, (pptSrc->x & 0x1f), nstart, tmpSrc)
646: putbitsrop(tmpSrc, (pbox->x1 & 0x1f), nstart, pdst,
647: alu)
648: }
649:
650: pdstLine += widthDst;
651: psrcLine += widthSrc;
652: }
653: } /* move right to left */
654: }
655: pbox++;
656: pptSrc++;
657: } /* while (nbox--) */
658: }
659:
660: /* free up stuff */
661: if (pptNew1)
662: {
663: DEALLOCATE_LOCAL(pptNew1);
664: }
665: if (pboxNew1)
666: {
667: DEALLOCATE_LOCAL(pboxNew1);
668: }
669: if (pptNew2)
670: {
671: DEALLOCATE_LOCAL(pptNew2);
672: }
673: if (pboxNew2)
674: {
675: DEALLOCATE_LOCAL(pboxNew2);
676: }
677: }
678:
679:
680: /*
681: if fg == 1 and bg ==0, we can do an ordinary CopyArea.
682: if fg == bg, we can do a CopyArea with alu = ReduceRop(alu, fg)
683: if fg == 0 and bg == 1, we use the same rasterop, with
684: source operand inverted.
685:
686: CopyArea deals with all of the graphics exposure events.
687: This code depends on knowing that we can change the
688: alu in the GC without having to call ValidateGC() before calling
689: CopyArea().
690:
691: */
692:
693: void
694: mfbCopyPlane(pSrcDrawable, pDstDrawable,
695: pGC, srcx, srcy, width, height, dstx, dsty, plane)
696: DrawablePtr pSrcDrawable, pDstDrawable;
697: register GC *pGC;
698: int srcx, srcy;
699: int width, height;
700: int dstx, dsty;
701: unsigned int plane;
702: {
703: int alu;
704:
705: if (!(pGC->planemask & 1))
706: return;
707:
708: if (plane != 1)
709: return;
710:
711: if ((pGC->fgPixel == 1) && (pGC->bgPixel == 0))
712: {
713: (*pGC->CopyArea)(pSrcDrawable, pDstDrawable,
714: pGC, srcx, srcy, width, height, dstx, dsty);
715: }
716: else if (pGC->fgPixel == pGC->bgPixel)
717: {
718: alu = pGC->alu;
719: pGC->alu = ReduceRop(pGC->alu, pGC->fgPixel);
720: (*pGC->CopyArea)(pSrcDrawable, pDstDrawable,
721: pGC, srcx, srcy, width, height, dstx, dsty);
722: pGC->alu = alu;
723: }
724: else /* need to invert the src */
725: {
726: alu = pGC->alu;
727: pGC->alu = InverseAlu[alu];
728: (*pGC->CopyArea)(pSrcDrawable, pDstDrawable,
729: pGC, srcx, srcy, width, height, dstx, dsty);
730: pGC->alu = alu;
731: }
732: }
733:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.