![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cfbgc.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 cfbgc.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / cfb |
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: #include "X.h"
25: #include "Xmd.h"
26: #include "Xproto.h"
27: #include "dixfontstr.h"
28: #include "fontstruct.h"
29: #include "gcstruct.h"
30: #include "windowstr.h"
31: #include "pixmapstr.h"
32: #include "scrnintstr.h"
33: #include "region.h"
34:
35: #include "cfb.h"
36: #include "mistruct.h"
37:
38: #include "cfbmskbits.h"
39: extern cfbXRotatePixmap();
40: extern cfbYRotatePixmap();
41: extern void mfbPushPixels();
42:
43: Bool
44: cfbCreateGC(pGC)
45: register GCPtr pGC;
46: {
47: GCInterestPtr pQ;
48:
49: switch (pGC->depth) {
50: case 1:
51: return (mfbCreateGC(pGC));
52: case PSZ:
53: break;
54: default:
55: ErrorF("cfbCreateGC: unsupported depth: %d\n", pGC->depth);
56: return FALSE;
57: }
58: pGC->clientClip = NULL;
59: pGC->clientClipType = CT_NONE;
60:
61: /*
62: * some of the output primitives aren't really necessary, since they
63: * will be filled in ValidateGC because of dix/CreateGC() setting all
64: * the change bits. Others are necessary because although they depend
65: * on being a color frame buffer, they don't change
66: */
67:
68: pGC->FillSpans = cfbSolidFS;
69: pGC->SetSpans = cfbSetSpans;
70: pGC->PutImage = miPutImage;
71: pGC->CopyArea = miCopyArea;
72: pGC->CopyPlane = miCopyPlane;
73: pGC->PolyPoint = miPolyPoint;
74:
75: #ifdef notdef
76: pGC->Polylines = miNotMiter; /* Doesn't work for 0-width lines */
77: #else
78: pGC->Polylines = miZeroLine;
79: #endif notdef
80: pGC->PolySegment = miPolySegment;
81: pGC->PolyRectangle = miPolyRectangle;
82: pGC->PolyArc = miPolyArc;
83: pGC->FillPolygon = miFillPolygon;
84: pGC->PolyFillRect = miPolyFillRect;
85: pGC->PolyFillArc = miPolyFillArc;
86: pGC->PolyText8 = miPolyText8;
87: pGC->ImageText8 = miImageText8;
88: pGC->PolyText16 = miPolyText16;
89: pGC->ImageText16 = miImageText16;
90: pGC->ImageGlyphBlt = miImageGlyphBlt;
91: pGC->PolyGlyphBlt = miPolyGlyphBlt;
92: #ifdef notdef
93: pGC->PushPixels = miPushPixels; /* miPushPixels is garbage */
94: #else
95: pGC->PushPixels = mfbPushPixels; /* but mfbPushPixels isn't depth
96: * dependent */
97: #endif
98: pGC->LineHelper = miMiter;
99: pGC->ChangeClip = cfbChangeClip;
100: pGC->DestroyClip = cfbDestroyClip;
101: pGC->CopyClip = cfbCopyClip;
102:
103: /* cfb wants to translate before scan convesion */
104: pGC->miTranslate = 1;
105:
106: {
107: cfbPrivGC *pPriv;
108:
109: pPriv = (cfbPrivGC *) Xalloc(sizeof(cfbPrivGC));
110: if (!pPriv)
111: return FALSE;
112: else {
113: pPriv->rop = pGC->alu;
114: pPriv->fExpose = TRUE;
115: pGC->devPriv = (pointer) pPriv;
116: pPriv->pRotatedTile = NullPixmap;
117: pPriv->pRotatedStipple = NullPixmap;
118: pPriv->pAbsClientRegion = (*pGC->pScreen->RegionCreate) (NULL, 1);
119: pPriv->pCompositeClip = (*pGC->pScreen->RegionCreate) (NULL, 1);
120: pPriv->freeCompClip = REPLACE_CC;
121: }
122: }
123: pQ = (GCInterestPtr) Xalloc(sizeof(GCInterestRec));
124: if (!pQ) {
125: Xfree(pGC->devPriv);
126: return FALSE;
127: }
128:
129: /* Now link this device into the GCque */
130: pGC->pNextGCInterest = pQ;
131: pGC->pLastGCInterest = pQ;
132: pQ->pNextGCInterest = (GCInterestPtr) & pGC->pNextGCInterest;
133: pQ->pLastGCInterest = (GCInterestPtr) & pGC->pNextGCInterest;
134: pQ->length = sizeof(GCInterestRec);
135: pQ->owner = 0; /* server owns this */
136: pQ->ValInterestMask = ~0; /* interested in everything at validate
137: * time */
138: pQ->ValidateGC = cfbValidateGC;
139: pQ->ChangeInterestMask = 0; /* interested in nothing at change time */
140: pQ->ChangeGC = (int (*) ()) NULL;
141: pQ->CopyGCSource = (void (*) ()) NULL;
142: pQ->CopyGCDest = cfbCopyGCDest;
143: pQ->DestroyGC = cfbDestroyGC;
144: return TRUE;
145: }
146:
147: void
148: cfbDestroyGC(pGC, pQ)
149: GC *pGC;
150: GCInterestPtr pQ;
151:
152: {
153: cfbPrivGC *pPriv;
154:
155: switch (pGC->depth) {
156: case 1:
157: mfbDestroyGC(pGC, pQ);
158: return;
159: case PSZ:
160: break;
161: default:
162: ErrorF("cfbCreateGC: unsupported depth: %d\n", pGC->depth);
163: return;
164: }
165: /* Most GCInterest pointers would free pQ->devPriv. This one is privileged
166: * and allowed to allocate its private data directly in the GC (this
167: * saves an indirection). We must also unlink and free the pQ.
168: */
169: pQ->pLastGCInterest->pNextGCInterest = pGC->pNextGCInterest;
170: pQ->pNextGCInterest->pLastGCInterest = pGC->pLastGCInterest;
171:
172: pPriv = (cfbPrivGC *)(pGC->devPriv);
173: if (pPriv->pRotatedTile)
174: cfbDestroyPixmap(pPriv->pRotatedTile);
175: if (pPriv->pRotatedStipple)
176: cfbDestroyPixmap(pPriv->pRotatedStipple);
177: if (pPriv->freeCompClip == FREE_CC && pPriv->pCompositeClip)
178: (*pGC->pScreen->RegionDestroy)(pPriv->pCompositeClip);
179: if(pPriv->pAbsClientRegion)
180: (*pGC->pScreen->RegionDestroy)(pPriv->pAbsClientRegion);
181: Xfree(pGC->devPriv);
182: Xfree(pQ);
183: }
184:
185: #define WINMOVED(pWin, pGC) \
186: ((pWin->absCorner.x != pGC->lastWinOrg.x) || \
187: (pWin->absCorner.y != pGC->lastWinOrg.y))
188:
189: /* Clipping conventions
190: if the drawable is a window
191: CT_REGION ==> pCompositeClip really is the composite
192: CT_other ==> pCompositeClip is the window clip region
193: if the drawable is a pixmap
194: CT_REGION ==> pCompositeClip is the translated client region
195: clipped to the pixmap boundary
196: CT_other ==> pCompositeClip is the pixmap bounding box
197: */
198:
199: void
200: cfbValidateGC(pGC, pQ, changes, pDrawable)
201: register GC *pGC;
202: GCInterestPtr *pQ;
203: Mask changes;
204: DrawablePtr pDrawable;
205: {
206: WindowPtr pWin;
207: int mask; /* stateChanges */
208: int index; /* used for stepping through bitfields */
209: int xrot, yrot; /* rotations for tile and stipple pattern */
210: Bool fRotate = FALSE;/* True if rotated pixmaps are needed */
211: int new_line, new_text, new_fillspans;
212: /* flags for changing the proc vector */
213: cfbPrivGCPtr devPriv;
214:
215: switch (pGC->depth) {
216: case PSZ:
217: break;
218: case 1:
219: if (pDrawable->type == DRAWABLE_PIXMAP) {
220: mfbValidateGC(pGC, pQ, changes, pDrawable);
221: return;
222: }
223: /* WARNING - FALL THROUGH */
224: default:
225: ErrorF("cfbCreateGC: unsupported depth: %d\n", pGC->depth);
226: return;
227: }
228: if (pDrawable->type == DRAWABLE_WINDOW)
229: pWin = (WindowPtr) pDrawable;
230: else
231: pWin = (WindowPtr) NULL;
232:
233: devPriv = ((cfbPrivGCPtr) (pGC->devPriv));
234:
235: /*
236: * if the client clip is different or moved OR the subwindowMode has
237: * changed OR the window's clip has changed since the last validation
238: * we need to recompute the composite clip
239: */
240:
241: if ((changes & (GCClipXOrigin | GCClipYOrigin | GCClipMask)) ||
242: (changes & GCSubwindowMode) ||
243: (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS))
244: ) {
245:
246: /*
247: * if there is a client clip (always a region, for us) AND it has
248: * moved or is different OR the window has moved we need to
249: * (re)translate it.
250: */
251: if ((pGC->clientClipType == CT_REGION) &&
252: ((changes & (GCClipXOrigin | GCClipYOrigin | GCClipMask)) ||
253: (pWin && WINMOVED(pWin, pGC))
254: )
255: ) {
256: /* retranslate client clip */
257: (*pGC->pScreen->RegionCopy) (devPriv->pAbsClientRegion,
258: pGC->clientClip);
259:
260: if (pWin) {
261: pGC->lastWinOrg.x = pWin->absCorner.x;
262: pGC->lastWinOrg.y = pWin->absCorner.y;
263: (*pGC->pScreen->TranslateRegion) (
264: devPriv->pAbsClientRegion,
265: pGC->lastWinOrg.x + pGC->clipOrg.x,
266: pGC->lastWinOrg.y + pGC->clipOrg.y);
267: }
268: else {
269: pGC->lastWinOrg.x = 0;
270: pGC->lastWinOrg.y = 0;
271: (*pGC->pScreen->TranslateRegion) (
272: devPriv->pAbsClientRegion, pGC->clipOrg.x, pGC->clipOrg.y);
273: }
274: }
275:
276: if (pWin) {
277: RegionPtr pregWin;
278: int freeTmpClip, freeCompClip;
279:
280: if (pGC->subWindowMode == IncludeInferiors) {
281: pregWin = NotClippedByChildren(pWin);
282: freeTmpClip = FREE_CC;
283: }
284: else {
285: pregWin = pWin->clipList;
286: freeTmpClip = REPLACE_CC;
287: }
288: freeCompClip = devPriv->freeCompClip;
289:
290: /*
291: * if there is no client clip, we can get by with just keeping
292: * the pointer we got, and remembering whether or not should
293: * destroy (or maybe re-use) it later. this way, we avoid
294: * unnecessary copying of regions. (this wins especially if
295: * many clients clip by children and have no client clip.)
296: */
297: if (pGC->clientClipType == CT_NONE) {
298: if (freeCompClip == FREE_CC) {
299: (*pGC->pScreen->RegionDestroy) (devPriv->pCompositeClip);
300: }
301: devPriv->pCompositeClip = pregWin;
302: devPriv->freeCompClip = freeTmpClip;
303: }
304: else {
305: /*
306: * we need one 'real' region to put into the composite
307: * clip. if pregWin the current composite clip are real,
308: * we can get rid of one. if pregWin is real and the
309: * current composite clip isn't, use pregWin for the
310: * composite clip. if the current composite clip is real
311: * and pregWin isn't, use the current composite clip. if
312: * neither is real, create a new region.
313: */
314:
315: if ((freeTmpClip == FREE_CC) && (freeCompClip == FREE_CC)) {
316: (*pGC->pScreen->Intersect) (
317: devPriv->pCompositeClip,
318: pregWin,
319: devPriv->pAbsClientRegion);
320: (*pGC->pScreen->RegionDestroy) (pregWin);
321: }
322: else if ((freeTmpClip == REPLACE_CC) &&
323: (freeCompClip == FREE_CC)) {
324: devPriv->pCompositeClip = pregWin;
325: (*pGC->pScreen->Intersect) (
326: devPriv->pCompositeClip,
327: devPriv->pCompositeClip,
328: devPriv->pAbsClientRegion);
329: }
330: else if ((freeTmpClip == FREE_CC) &&
331: (freeCompClip == REPLACE_CC)) {
332: (*pGC->pScreen->Intersect) (
333: devPriv->pCompositeClip,
334: pregWin,
335: devPriv->pAbsClientRegion);
336: }
337: else if ((freeTmpClip == REPLACE_CC) &&
338: (freeCompClip == REPLACE_CC)) {
339: devPriv->pCompositeClip =
340: (*pGC->pScreen->RegionCreate) (NULL, 1);
341: (*pGC->pScreen->Intersect) (
342: devPriv->pCompositeClip,
343: pregWin,
344: devPriv->pAbsClientRegion);
345: }
346: }
347: } /* end of composite clip for a window */
348: else {
349: BoxRec pixbounds;
350:
351: pixbounds.x1 = 0;
352: pixbounds.y1 = 0;
353: pixbounds.x2 = ((PixmapPtr) pDrawable)->width;
354: pixbounds.y2 = ((PixmapPtr) pDrawable)->height;
355:
356: if (devPriv->freeCompClip == FREE_CC)
357: (*pGC->pScreen->RegionReset) (
358: devPriv->pCompositeClip, &pixbounds);
359: else {
360: devPriv->freeCompClip = FREE_CC;
361: devPriv->pCompositeClip =
362: (*pGC->pScreen->RegionCreate) (&pixbounds, 1);
363: }
364:
365: if (pGC->clientClipType == CT_REGION)
366: (*pGC->pScreen->Intersect) (
367: devPriv->pCompositeClip,
368: devPriv->pCompositeClip,
369: devPriv->pAbsClientRegion);
370: } /* end of composute clip for pixmap */
371: }
372:
373: if (pWin) {
374:
375: /*
376: * rotate tile patterns so that pattern can be combined in word by
377: * word, but the pattern seems to begin aligned with the window
378: */
379: xrot = pWin->absCorner.x;
380: yrot = pWin->absCorner.y;
381: }
382: else {
383: yrot = 0;
384: xrot = 0;
385: }
386:
387:
388: new_line = FALSE;
389: new_text = FALSE;
390: new_fillspans = FALSE;
391:
392: mask = changes;
393: while (mask) {
394: index = ffs(mask) - 1;
395: mask &= ~(index = (1 << index));
396:
397: /*
398: * this switch acculmulates a list of which procedures might have
399: * to change due to changes in the GC. in some cases (e.g.
400: * changing one 16 bit tile for another) we might not really need
401: * a change, but the code is being paranoid. this sort of batching
402: * wins if, for example, the alu and the font have been changed,
403: * or any other pair of items that both change the same thing.
404: */
405: switch (index) {
406: case GCFunction:
407: case GCForeground:
408: new_text = TRUE;
409: break;
410: case GCPlaneMask:
411: break;
412: case GCBackground:
413: new_fillspans = TRUE;
414: break;
415: case GCLineStyle:
416: break;
417: case GCLineWidth:
418: case GCCapStyle:
419: case GCJoinStyle:
420: new_line = TRUE;
421: break;
422: case GCFillStyle:
423: new_text = TRUE;
424: new_fillspans = TRUE;
425: new_line = TRUE;
426: break;
427: case GCFillRule:
428: break;
429: case GCTile:
430: if (pGC->tile == (PixmapPtr) NULL)
431: break;
432: cfbPadPixmap(pGC->tile);
433: fRotate = TRUE;
434: new_fillspans = TRUE;
435: break;
436:
437: case GCStipple:
438: if (pGC->stipple == (PixmapPtr) NULL)
439: break;
440: cfbPadPixmap(pGC->stipple);
441: fRotate = TRUE;
442: new_fillspans = TRUE;
443: break;
444:
445: case GCTileStipXOrigin:
446: fRotate = TRUE;
447: break;
448:
449: case GCTileStipYOrigin:
450: fRotate = TRUE;
451: break;
452:
453: case GCFont:
454: new_text = TRUE;
455: break;
456: case GCSubwindowMode:
457: break;
458: case GCGraphicsExposures:
459: break;
460: case GCClipXOrigin:
461: break;
462: case GCClipYOrigin:
463: break;
464: case GCClipMask:
465: break;
466: case GCDashOffset:
467: break;
468: case GCDashList:
469: break;
470: case GCArcMode:
471: break;
472: default:
473: break;
474: }
475: }
476:
477: /*
478: * If the drawable has changed, check its depth & ensure suitable
479: * entries are in the proc vector.
480: */
481: if (pDrawable->serialNumber != (pGC->serialNumber & (DRAWABLE_SERIAL_BITS))) {
482: new_fillspans = TRUE; /* deal with FillSpans later */
483: pGC->SetSpans = cfbSetSpans;
484: }
485:
486: /* deal with the changes we've collected */
487:
488: if (new_line) {
489: if (pGC->lineWidth == 0) {
490: #ifdef notdef
491: if (pGC->fillStyle == FillSolid)
492: pGC->Polylines = miNotMiter; /* XXX - doesn't work for
493: * zero. ???miNotMiter??? */
494: else
495: #endif
496: pGC->Polylines = miZeroLine;
497: }
498: else {
499: switch (pGC->joinStyle) {
500: case JoinMiter:
501: pGC->LineHelper = miMiter;
502: break;
503: case JoinRound:
504: case JoinBevel:
505: pGC->LineHelper = miNotMiter;
506: break;
507: }
508: }
509: }
510:
511: if (new_text && pGC->font) {
512: pGC->PolyGlyphBlt = miPolyGlyphBlt;
513: pGC->ImageGlyphBlt = miImageGlyphBlt;
514: pGC->PolyGlyphBlt = miPolyGlyphBlt;
515: pGC->ImageGlyphBlt = miImageGlyphBlt;
516: }
517:
518: if (new_fillspans) {
519: switch (pGC->fillStyle) {
520: case FillSolid:
521: pGC->FillSpans = cfbSolidFS;
522: break;
523: case FillTiled:
524: pGC->FillSpans = cfbUnnaturalTileFS;
525: if (!pGC->tile)
526: FatalError("cfbValidateGC: tile mode & no tile\n");
527: if (((DrawablePtr)pGC->tile)->depth != pGC->depth)
528: FatalError("cfbValidateGC: tile wrong depth\n");
529: break;
530: case FillStippled:
531: pGC->FillSpans = cfbUnnaturalStippleFS;
532: if (!pGC->stipple)
533: FatalError("cfbValidateGC: stipple mode & no stipple\n");
534: if (((DrawablePtr)pGC->stipple)->depth != 1)
535: FatalError("cfbValidateGC: stipple wrong depth\n");
536: break;
537: case FillOpaqueStippled:
538: if (pGC->fgPixel == pGC->bgPixel)
539: pGC->FillSpans = cfbSolidFS;
540: else {
541: pGC->FillSpans = cfbUnnaturalStippleFS;
542: if (!pGC->stipple)
543: FatalError("cfbValidateGC: stipple mode & no stipple\n");
544: if (((DrawablePtr)pGC->stipple)->depth != 1)
545: FatalError("cfbValidateGC: stipple wrong depth\n");
546: }
547: break;
548: default:
549: FatalError("cfbValidateGC: illegal fillStyle\n");
550: }
551: } /* end of new_fillspans */
552:
553: if (xrot || yrot || fRotate) {
554: /*
555: * First destroy any previously-rotated tile/stipple
556: */
557: if (devPriv->pRotatedTile) {
558: cfbDestroyPixmap(devPriv->pRotatedTile);
559: devPriv->pRotatedTile = (PixmapPtr)NULL;
560: }
561: if (devPriv->pRotatedStipple) {
562: cfbDestroyPixmap(devPriv->pRotatedStipple);
563: devPriv->pRotatedStipple = (PixmapPtr)NULL;
564: }
565: if (pGC->tile &&
566: (devPriv->pRotatedTile = cfbCopyPixmap(pGC->tile))
567: == (PixmapPtr) NULL)
568: FatalError("cfbValidateGC: cannot rotate tile\n");
569: if (pGC->stipple &&
570: (devPriv->pRotatedStipple = cfbCopyPixmap(pGC->stipple))
571: == (PixmapPtr) NULL)
572: FatalError("cfbValidateGC: cannot rotate stipple\n");
573: /*
574: * If we've gotten here, we're probably going to rotate the tile
575: * and/or stipple, so we have to add the pattern origin into
576: * the rotation factor, even if it hasn't changed.
577: */
578: xrot += pGC->patOrg.x;
579: yrot += pGC->patOrg.y;
580: if (xrot) {
581: if (pGC->tile && devPriv->pRotatedTile)
582: cfbXRotatePixmap(devPriv->pRotatedTile, xrot);
583: if (pGC->stipple && devPriv->pRotatedStipple)
584: cfbXRotatePixmap(devPriv->pRotatedStipple, xrot);
585: }
586: if (yrot) {
587: if (pGC->tile && devPriv->pRotatedTile)
588: cfbYRotatePixmap(devPriv->pRotatedTile, yrot);
589: if (pGC->stipple && devPriv->pRotatedStipple)
590: cfbYRotatePixmap(devPriv->pRotatedStipple, yrot);
591: }
592: }
593: }
594:
595:
596: void
597: cfbDestroyClip(pGC)
598: GCPtr pGC;
599: {
600: switch (pGC->depth) {
601: case 1:
602: mfbDestroyClip(pGC);
603: return;
604: case PSZ:
605: break;
606: default:
607: ErrorF("cfbCreateGC: unsupported depth: %d\n", pGC->depth);
608: return;
609: }
610: if(pGC->clientClipType == CT_NONE)
611: return;
612: (*pGC->pScreen->RegionDestroy)(pGC->clientClip);
613: pGC->clientClip = NULL;
614: pGC->clientClipType = CT_NONE;
615: pGC->stateChanges |= (GCClipXOrigin | GCClipYOrigin | GCClipMask);
616: }
617:
618: void
619: cfbChangeClip(pGC, type, pvalue, nrects)
620: GCPtr pGC;
621: int type;
622: pointer pvalue;
623: int nrects;
624: {
625: switch (pGC->depth) {
626: case 1:
627: mfbChangeClip(pGC, type, pvalue, nrects);
628: return;
629: case PSZ:
630: break;
631: default:
632: ErrorF("cfbChangeClip: unsupported depth: %d\n", pGC->depth);
633: return;
634: }
635: cfbDestroyClip(pGC);
636: if(type == CT_PIXMAP)
637: {
638: pGC->clientClip = (pointer) mfbPixmapToRegion(pvalue);
639: (*pGC->pScreen->DestroyPixmap)(pvalue);
640: }
641: else if (type == CT_REGION) {
642: pGC->clientClip = (pointer) (*pGC->pScreen->RegionCreate)( NULL, 0 );
643: (*pGC->pScreen->RegionCopy)( pGC->clientClip, pvalue );
644: }
645: else if (type != CT_NONE)
646: {
647: pGC->clientClip = (pointer) miRectsToRegion(pGC, nrects, pvalue, type);
648: Xfree(pvalue);
649: }
650: pGC->clientClipType = (pGC->clientClip) ? CT_REGION : CT_NONE;
651: pGC->stateChanges |= (GCClipXOrigin | GCClipYOrigin | GCClipMask);
652: }
653:
654: void
655: cfbCopyClip (pgcDst, pgcSrc)
656: GCPtr pgcDst, pgcSrc;
657: {
658: RegionPtr prgnNew;
659:
660: switch (pgcSrc->depth) {
661: case 1:
662: mfbCopyClip(pgcDst, pgcSrc);
663: return;
664: case PSZ:
665: break;
666: default:
667: ErrorF("cfbCopyClip: unsupported depth: %d\n", pgcSrc->depth);
668: return;
669: }
670: switch(pgcSrc->clientClipType)
671: {
672: case CT_NONE:
673: case CT_PIXMAP:
674: cfbChangeClip(pgcDst, pgcSrc->clientClipType, pgcSrc->clientClip, 0);
675: break;
676: case CT_REGION:
677: prgnNew = (*pgcSrc->pScreen->RegionCreate)(NULL, 1);
678: (*pgcSrc->pScreen->RegionCopy)(prgnNew,
679: (RegionPtr)(pgcSrc->clientClip));
680: cfbChangeClip(pgcDst, CT_REGION, prgnNew, 0);
681: break;
682: }
683: }
684:
685: void
686: cfbCopyGCDest (pGC, pQ, changes, pGCSrc)
687: GCPtr pGC;
688: GCInterestPtr pQ;
689: Mask changes;
690: GCPtr pGCSrc;
691: {
692: RegionPtr pClip;
693:
694: switch (pGC->depth) {
695: case 1:
696: mfbCopyGCDest(pGC);
697: return;
698: case PSZ:
699: break;
700: default:
701: ErrorF("cfbCreateGC: unsupported depth: %d\n", pGC->depth);
702: return;
703: }
704: if(changes & GCClipMask)
705: {
706: if(pGC->clientClipType == CT_PIXMAP)
707: {
708: ((PixmapPtr)pGC->clientClip)->refcnt++;
709: }
710: else if(pGC->clientClipType == CT_REGION)
711: {
712: BoxRec pixbounds;
713:
714: pixbounds.x1 = 0;
715: pixbounds.y1 = 0;
716: pixbounds.x2 = 0;
717: pixbounds.y2 = 0;
718:
719: pClip = (RegionPtr) pGC->clientClip;
720: pGC->clientClip =
721: (pointer)(* pGC->pScreen->RegionCreate)(&pixbounds, 1);
722: (* pGC->pScreen->RegionCopy)(pGC->clientClip, pClip);
723: }
724: }
725: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.