![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sunGC.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 / sun|
Return to sunGC.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / sun |
1.1 root 1: /*-
2: * sunGC.c --
3: * Functions to support the meddling with GC's we do to preserve
4: * the software cursor...
5: *
6: * Copyright (c) 1987 by the Regents of the University of California
7: *
8: * Permission to use, copy, modify, and distribute this
9: * software and its documentation for any purpose and without
10: * fee is hereby granted, provided that the above copyright
11: * notice appear in all copies. The University of California
12: * makes no representations about the suitability of this
13: * software for any purpose. It is provided "as is" without
14: * express or implied warranty.
15: *
16: *
17: */
18: #ifndef lint
19: static char rcsid[] =
20: "$Header: sunGC.c,v 4.2 87/09/12 21:43:53 sun Exp $ SPRITE (Berkeley)";
21: #endif lint
22:
23: #include "sun.h"
24:
25: #include "X.h"
26: #include "Xmd.h"
27: #include "extnsionst.h"
28: #include "regionstr.h"
29: #include "windowstr.h"
30: #include "fontstruct.h"
31: #include "dixfontstr.h"
32: #include "../mi/mifpoly.h" /* for SppPointPtr */
33:
34: /*
35: * Overlap BoxPtr and Box elements
36: */
37: #define BOX_OVERLAP(pCbox,X1,Y1,X2,Y2) \
38: (((pCbox)->x1 <= (X2)) && ((X1) <= (pCbox)->x2) && \
39: ((pCbox)->y1 <= (Y2)) && ((Y1) <= (pCbox)->y2))
40:
41: /*
42: * Overlap BoxPtr, origins, and rectangle
43: */
44: #define ORG_OVERLAP(pCbox,xorg,yorg,x,y,w,h) \
45: BOX_OVERLAP((pCbox),(x)+(xorg),(y)+(yorg),(x)+(xorg)+(w),(y)+(yorg)+(h))
46:
47: /*
48: * Overlap BoxPtr, origins and RectPtr
49: */
50: #define ORGRECT_OVERLAP(pCbox,xorg,yorg,pRect) \
51: ORG_OVERLAP((pCbox),(xorg),(yorg),(pRect)->x,(pRect)->y,(pRect)->width, \
52: (pRect)->height)
53: /*
54: * Overlap BoxPtr and horizontal span
55: */
56: #define SPN_OVERLAP(pCbox,y,x,w) BOX_OVERLAP((pCbox),(x),(y),(x)+(w),(y))
57:
58:
59: #ifdef notdef
60: #define COMPARE_GCS(g1, g2) compare_gcs(g1, g2)
61:
62: static
63: compare_gcs(g1, g2)
64: GCPtr g1, g2;
65: {
66: if (g1->pScreen != g2->pScreen) FatalError("GC and Shadow mis-match - pScreen\n");
67: if (g1->depth != g2->depth) FatalError("GC and Shadow mis-match - depth\n");
68: #ifdef notdef
69: if (g1->serialNumber != g2->serialNumber) FatalError("GC and Shadow mis-match - serialNumber\n");
70: #endif
71: if (g1->alu != g2->alu) FatalError("GC and Shadow mis-match - alu\n");
72: if (g1->planemask != g2->planemask) FatalError("GC and Shadow mis-match - planemask\n");
73: if (g1->fgPixel != g2->fgPixel) FatalError("GC and Shadow mis-match - fgPixel\n");
74: if (g1->bgPixel != g2->bgPixel) FatalError("GC and Shadow mis-match - bgPixel\n");
75: if (g1->lineWidth != g2->lineWidth) FatalError("GC and Shadow mis-match - lineWidth\n");
76: if (g1->lineStyle != g2->lineStyle) FatalError("GC and Shadow mis-match - lineStyle\n");
77: if (g1->capStyle != g2->capStyle) FatalError("GC and Shadow mis-match - capStyle\n");
78: if (g1->joinStyle != g2->joinStyle) FatalError("GC and Shadow mis-match - joinStyle\n");
79: if (g1->fillStyle != g2->fillStyle) FatalError("GC and Shadow mis-match - fillStyle\n");
80: if (g1->fillRule != g2->fillRule) FatalError("GC and Shadow mis-match - fillRule\n");
81: if (g1->arcMode != g2->arcMode) FatalError("GC and Shadow mis-match - arcMode\n");
82: if (g1->tile != g2->tile) FatalError("GC and Shadow mis-match - tile\n");
83: if (g1->stipple != g2->stipple) FatalError("GC and Shadow mis-match - stipple\n");
84: if (g1->patOrg.x != g2->patOrg.x) FatalError("GC and Shadow mis-match - patOrg.x\n");
85: if (g1->patOrg.y != g2->patOrg.y) FatalError("GC and Shadow mis-match - patOrg.y\n");
86: if (g1->font != g2->font) FatalError("GC and Shadow mis-match - font\n");
87: if (g1->subWindowMode != g2->subWindowMode) FatalError("GC and Shadow mis-match - subWindowMode\n");
88: if (g1->graphicsExposures != g2->graphicsExposures) FatalError("GC and Shadow mis-match - graphicsExposures\n");
89: if (g1->clipOrg.x != g2->clipOrg.x) FatalError("GC and Shadow mis-match - clipOrg.x\n");
90: if (g1->clipOrg.y != g2->clipOrg.y) FatalError("GC and Shadow mis-match - clipOrg.y\n");
91: #ifdef notdef
92: if (g1->clientClip != g2->clientClip) FatalError("GC and Shadow mis-match - clientClip\n");
93: #endif
94: if (g1->clientClipType != g2->clientClipType) FatalError("GC and Shadow mis-match - clientClipType\n");
95: if (g1->dashOffset != g2->dashOffset) FatalError("GC and Shadow mis-match - dashOffset\n");
96: if (g1->numInDashList != g2->numInDashList) FatalError("GC and Shadow mis-match - numInDashList\n");
97: #ifdef notdef
98: if (g1->dash != g2->dash) FatalError("GC and Shadow mis-match - dash\n");
99: if (g1->stateChanges != g2->stateChanges) FatalError("GC and Shadow mis-match - stateChanges\n");
100: #endif
101: if (g1->lastWinOrg.x != g2->lastWinOrg.x) FatalError("GC and Shadow mis-match - lastWinOrg.x\n");
102: if (g1->lastWinOrg.y != g2->lastWinOrg.y) FatalError("GC and Shadow mis-match - lastWinOrg.y\n");
103: if (g1->miTranslate != g2->miTranslate) FatalError("GC and Shadow mis-match - miTranslate\n");
104:
105: }
106: #else
107: #define COMPARE_GCS(g1, g2)
108: #endif
109:
110:
111: /*-
112: *-----------------------------------------------------------------------
113: * sunSaveCursorBox --
114: * Given an array of points, figure out the bounding box for the
115: * series and remove the cursor if it overlaps that box.
116: *
117: * Results:
118: *
119: * Side Effects:
120: *
121: *-----------------------------------------------------------------------
122: */
123: void
124: sunSaveCursorBox (xorg, yorg, mode, pPts, nPts, pCursorBox)
125: register int xorg; /* X-Origin for points */
126: register int yorg; /* Y-Origin for points */
127: int mode; /* CoordModeOrigin or
128: * CoordModePrevious */
129: register DDXPointPtr pPts; /* Array of points */
130: int nPts; /* Number of points */
131: register BoxPtr pCursorBox; /* Bounding box for cursor */
132: {
133: register int minx,
134: miny,
135: maxx,
136: maxy;
137:
138: minx = maxx = pPts->x + xorg;
139: miny = maxy = pPts->y + yorg;
140:
141: pPts++;
142: nPts--;
143:
144: if (mode == CoordModeOrigin) {
145: while (nPts--) {
146: minx = min(minx, pPts->x + xorg);
147: maxx = max(maxx, pPts->x + xorg);
148: miny = min(miny, pPts->y + yorg);
149: maxy = max(maxy, pPts->y + yorg);
150: pPts++;
151: }
152: } else {
153: xorg = minx;
154: yorg = miny;
155: while (nPts--) {
156: minx = min(minx, pPts->x + xorg);
157: maxx = max(maxx, pPts->x + xorg);
158: miny = min(miny, pPts->y + yorg);
159: maxy = max(maxy, pPts->y + yorg);
160: xorg += pPts->x;
161: yorg += pPts->y;
162: pPts++;
163: }
164: }
165: if (BOX_OVERLAP(pCursorBox,minx,miny,maxx,maxy)) {
166: sunRemoveCursor();
167: }
168: }
169:
170: /*-
171: *-----------------------------------------------------------------------
172: * sunFillSpans --
173: * Remove the cursor if any of the spans overlaps the area covered
174: * by the cursor. This assumes the points have been translated
175: * already, though perhaps it shouldn't...
176: *
177: * Results:
178: * None.
179: *
180: * Side Effects:
181: *
182: *-----------------------------------------------------------------------
183: */
184: void
185: sunFillSpans(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
186: DrawablePtr pDrawable;
187: GCPtr pGC;
188: int nInit; /* number of spans to fill */
189: DDXPointPtr pptInit; /* pointer to list of start points */
190: int *pwidthInit; /* pointer to list of n widths */
191: int fSorted;
192: {
193: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
194:
195: if (pDrawable->type == DRAWABLE_WINDOW) {
196: BoxRec cursorBox;
197:
198: if (sunCursorLoc (pDrawable->pScreen, &cursorBox)) {
199: register DDXPointPtr pts;
200: register int *widths;
201: register int nPts;
202:
203: for (pts = pptInit, widths = pwidthInit, nPts = nInit;
204: nPts--;
205: pts++, widths++) {
206: if (SPN_OVERLAP(&cursorBox,pts->y,pts->x,*widths)) {
207: sunRemoveCursor();
208: break;
209: }
210: }
211: }
212: }
213:
214: COMPARE_GCS(pGC,pShadowGC);
215: (* pShadowGC->FillSpans)(pDrawable, pShadowGC, nInit, pptInit,
216: pwidthInit, fSorted);
217: }
218:
219: /*-
220: *-----------------------------------------------------------------------
221: * sunSetSpans --
222: * Remove the cursor if any of the horizontal segments overlaps
223: * the area covered by the cursor. This also assumes the spans
224: * have been translated from the window's coordinates to the
225: * screen's.
226: * Results:
227: * None.
228: *
229: * Side Effects:
230: *
231: *-----------------------------------------------------------------------
232: */
233: void
234: sunSetSpans(pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted)
235: DrawablePtr pDrawable;
236: GCPtr pGC;
237: int *psrc;
238: register DDXPointPtr ppt;
239: int *pwidth;
240: int nspans;
241: int fSorted;
242: {
243: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
244:
245: if (pDrawable->type == DRAWABLE_WINDOW) {
246: BoxRec cursorBox;
247:
248: if (sunCursorLoc (pDrawable->pScreen, &cursorBox)) {
249: register DDXPointPtr pts;
250: register int *widths;
251: register int nPts;
252:
253: for (pts = ppt, widths = pwidth, nPts = nspans;
254: nPts--;
255: pts++, widths++) {
256: if (SPN_OVERLAP(&cursorBox,pts->y,pts->x,*widths)) {
257: sunRemoveCursor();
258: break;
259: }
260: }
261: }
262: }
263:
264: COMPARE_GCS(pGC,pShadowGC);
265: (* pShadowGC->SetSpans) (pDrawable, pShadowGC, psrc, ppt, pwidth,
266: nspans, fSorted);
267: }
268:
269: /*-
270: *-----------------------------------------------------------------------
271: * sunGetSpans --
272: * Remove the cursor if any of the desired spans overlaps the cursor.
273: *
274: * Results:
275: *
276: * Side Effects:
277: *
278: *-----------------------------------------------------------------------
279: */
280: unsigned int *
281: sunGetSpans(pDrawable, wMax, ppt, pwidth, nspans)
282: DrawablePtr pDrawable; /* drawable from which to get bits */
283: int wMax; /* largest value of all *pwidths */
284: register DDXPointPtr ppt; /* points to start copying from */
285: int *pwidth; /* list of number of bits to copy */
286: int nspans; /* number of scanlines to copy */
287: {
288: if (pDrawable->type == DRAWABLE_WINDOW) {
289: BoxRec cursorBox;
290:
291: if (sunCursorLoc (pDrawable->pScreen, &cursorBox)) {
292: register DDXPointPtr pts;
293: register int *widths;
294: register int nPts;
295: register int xorg,
296: yorg;
297:
298: xorg = ((WindowPtr)pDrawable)->absCorner.x;
299: yorg = ((WindowPtr)pDrawable)->absCorner.y;
300:
301: for (pts = ppt, widths = pwidth, nPts = nspans;
302: nPts--;
303: pts++, widths++) {
304: if (SPN_OVERLAP(&cursorBox,pts->y+yorg,
305: pts->x+xorg,*widths)) {
306: sunRemoveCursor();
307: break;
308: }
309: }
310: }
311: }
312:
313: /*
314: * XXX: Because we have no way to get at the GC used to call us,
315: * we must rely on the GetSpans vector never changing and stick it
316: * in the fbFd structure. Gross.
317: */
318: return (* sunFbs[pDrawable->pScreen->myNum].GetSpans)(pDrawable, wMax,
319: ppt, pwidth, nspans);
320: }
321:
322: /*-
323: *-----------------------------------------------------------------------
324: * sunPutImage --
325: * Remove the cursor if it is in the way of the image to be
326: * put down...
327: *
328: * Results:
329: * None.
330: *
331: * Side Effects:
332: *
333: *-----------------------------------------------------------------------
334: */
335: void
336: sunPutImage(pDst, pGC, depth, x, y, w, h, leftPad, format, pBits)
337: DrawablePtr pDst;
338: GCPtr pGC;
339: int depth;
340: int x;
341: int y;
342: int w;
343: int h;
344: int format;
345: char *pBits;
346: {
347: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
348:
349: if (pDst->type == DRAWABLE_WINDOW) {
350: BoxRec cursorBox;
351: if (sunCursorLoc (pDst->pScreen, &cursorBox)) {
352: register WindowPtr pWin = (WindowPtr)pDst;
353:
354: if (ORG_OVERLAP(&cursorBox,pWin->absCorner.x,pWin->absCorner.y,
355: x,y,w,h)) {
356: sunRemoveCursor();
357: }
358: }
359: }
360:
361: COMPARE_GCS(pGC,pShadowGC);
362: (* pShadowGC->PutImage) (pDst, pShadowGC, depth, x, y, w, h,
363: leftPad, format, pBits);
364: }
365:
366: /*-
367: *-----------------------------------------------------------------------
368: * sunGetImage --
369: * Remove the cursor if it overlaps the image to be gotten.
370: *
371: * Results:
372: * None.
373: *
374: * Side Effects:
375: *
376: *-----------------------------------------------------------------------
377: */
378: void
379: sunGetImage (pSrc, x, y, w, h, format, planeMask, pBits)
380: DrawablePtr pSrc;
381: int x;
382: int y;
383: int w;
384: int h;
385: unsigned int format;
386: unsigned int planeMask;
387: int *pBits;
388: {
389: if (pSrc->type == DRAWABLE_WINDOW) {
390: BoxRec cursorBox;
391:
392: if (sunCursorLoc(pSrc->pScreen, &cursorBox)) {
393: register WindowPtr pWin = (WindowPtr)pSrc;
394:
395: if (ORG_OVERLAP(&cursorBox,pWin->absCorner.x,pWin->absCorner.y,
396: x,y,w,h)) {
397: sunRemoveCursor();
398: }
399: }
400: }
401:
402: (* sunFbs[pSrc->pScreen->myNum].GetImage) (pSrc, x, y, w, h, format,
403: planeMask, pBits);
404: }
405:
406: /*-
407: *-----------------------------------------------------------------------
408: * sunCopyArea --
409: * Remove the cursor if it overlaps either the source or destination
410: * drawables, then call the screen-specific CopyArea routine.
411: *
412: * Results:
413: * None.
414: *
415: * Side Effects:
416: *
417: *-----------------------------------------------------------------------
418: */
419: void
420: sunCopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty)
421: DrawablePtr pSrc;
422: DrawablePtr pDst;
423: GCPtr pGC;
424: int srcx;
425: int srcy;
426: int w;
427: int h;
428: int dstx;
429: int dsty;
430: {
431: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
432: BoxRec cursorBox;
433: register WindowPtr pWin;
434: int out = FALSE;
435:
436: if (pSrc->type == DRAWABLE_WINDOW &&
437: sunCursorLoc(pSrc->pScreen, &cursorBox)) {
438: pWin = (WindowPtr)pSrc;
439:
440: if (ORG_OVERLAP(&cursorBox,pWin->absCorner.x,pWin->absCorner.y,
441: srcx, srcy, w, h)) {
442: sunRemoveCursor();
443: out = TRUE;
444: }
445: }
446:
447: if (!out && pDst->type == DRAWABLE_WINDOW &&
448: sunCursorLoc(pDst->pScreen, &cursorBox)) {
449: pWin = (WindowPtr)pDst;
450:
451: if (ORG_OVERLAP(&cursorBox,pWin->absCorner.x,pWin->absCorner.y,
452: dstx, dsty, w, h)) {
453: sunRemoveCursor();
454: }
455: }
456:
457: COMPARE_GCS(pGC,pShadowGC);
458: (* pShadowGC->CopyArea) (pSrc, pDst, pShadowGC, srcx, srcy,
459: w, h, dstx, dsty);
460: }
461:
462: /*-
463: *-----------------------------------------------------------------------
464: * sunCopyPlane --
465: * Remove the cursor as necessary and call the screen-specific
466: * CopyPlane function.
467: *
468: * Results:
469: * None.
470: *
471: * Side Effects:
472: *
473: *-----------------------------------------------------------------------
474: */
475: void
476: sunCopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane)
477: DrawablePtr pSrc;
478: DrawablePtr pDst;
479: register GC *pGC;
480: int srcx,
481: srcy;
482: int w,
483: h;
484: int dstx,
485: dsty;
486: unsigned int plane;
487: {
488: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
489: BoxRec cursorBox;
490: register WindowPtr pWin;
491: int out = FALSE;
492:
493: if (pSrc->type == DRAWABLE_WINDOW &&
494: sunCursorLoc(pSrc->pScreen, &cursorBox)) {
495: pWin = (WindowPtr)pSrc;
496:
497: if (ORG_OVERLAP(&cursorBox,pWin->absCorner.x,pWin->absCorner.y,
498: srcx, srcy, w, h)) {
499: sunRemoveCursor();
500: out = TRUE;
501: }
502: }
503:
504: if (!out && pDst->type == DRAWABLE_WINDOW &&
505: sunCursorLoc(pDst->pScreen, &cursorBox)) {
506: pWin = (WindowPtr)pDst;
507:
508: if (ORG_OVERLAP(&cursorBox,pWin->absCorner.x,pWin->absCorner.y,
509: dstx, dsty, w, h)) {
510: sunRemoveCursor();
511: }
512: }
513:
514:
515: COMPARE_GCS(pGC,pShadowGC);
516: (* pShadowGC->CopyPlane) (pSrc, pDst, pShadowGC, srcx, srcy, w, h,
517: dstx, dsty, plane);
518: }
519:
520: /*-
521: *-----------------------------------------------------------------------
522: * sunPolyPoint --
523: * See if any of the points lies within the area covered by the
524: * cursor and remove the cursor if one does. Then put the points
525: * down.
526: *
527: * Results:
528: * None.
529: *
530: * Side Effects:
531: *
532: *-----------------------------------------------------------------------
533: */
534: void
535: sunPolyPoint (pDrawable, pGC, mode, npt, pptInit)
536: DrawablePtr pDrawable;
537: GCPtr pGC;
538: int mode; /* Origin or Previous */
539: int npt;
540: xPoint *pptInit;
541: {
542: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
543: register xPoint *pts;
544: register int nPts;
545: register int xorg;
546: register int yorg;
547: BoxRec cursorBox;
548:
549: if (pDrawable->type == DRAWABLE_WINDOW &&
550: sunCursorLoc (pDrawable->pScreen, &cursorBox)) {
551: xorg = ((WindowPtr)pDrawable)->absCorner.x;
552: yorg = ((WindowPtr)pDrawable)->absCorner.y;
553:
554: if (mode == CoordModeOrigin) {
555: for (pts = pptInit, nPts = npt; nPts--; pts++) {
556: if (ORG_OVERLAP(&cursorBox,xorg,yorg,pts->x,pts->y,0,0)){
557: sunRemoveCursor();
558: break;
559: }
560: }
561: } else {
562: for (pts = pptInit, nPts = npt; nPts--; pts++) {
563: if (ORG_OVERLAP(&cursorBox,xorg,yorg,pts->x,pts->y,0,0)){
564: sunRemoveCursor();
565: break;
566: } else {
567: xorg += pts->x;
568: yorg += pts->y;
569: }
570: }
571: }
572: }
573:
574: COMPARE_GCS(pGC,pShadowGC);
575: (* pShadowGC->PolyPoint) (pDrawable, pShadowGC, mode, npt, pptInit);
576: }
577:
578: /*-
579: *-----------------------------------------------------------------------
580: * sunPolylines --
581: * Find the bounding box of the lines and remove the cursor if
582: * the box overlaps the area covered by the cursor. Then call
583: * the screen's Polylines function to draw the lines themselves.
584: *
585: * Results:
586: *
587: * Side Effects:
588: *
589: *-----------------------------------------------------------------------
590: */
591: void
592: sunPolylines (pDrawable, pGC, mode, npt, pptInit)
593: DrawablePtr pDrawable;
594: GCPtr pGC;
595: int mode;
596: int npt;
597: DDXPointPtr pptInit;
598: {
599: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
600: BoxRec cursorBox;
601:
602: if (pDrawable->type == DRAWABLE_WINDOW &&
603: sunCursorLoc (pDrawable->pScreen, &cursorBox)) {
604: sunSaveCursorBox(((WindowPtr)pDrawable)->absCorner.x,
605: ((WindowPtr)pDrawable)->absCorner.y,
606: mode,
607: pptInit,
608: npt,
609: &cursorBox);
610: }
611: COMPARE_GCS(pGC,pShadowGC);
612: (*pShadowGC->Polylines) (pDrawable, pShadowGC, mode, npt, pptInit);
613: }
614:
615: /*-
616: *-----------------------------------------------------------------------
617: * sunPolySegment --
618: * Treat each segment as a box and remove the cursor if any box
619: * overlaps the cursor's area. Then draw the segments. Note that
620: * the endpoints of the segments are in no way guaranteed to be
621: * in the right order, so we find the bounding box of the segment
622: * in two comparisons and use that to figure things out.
623: *
624: * Results:
625: * None.
626: *
627: * Side Effects:
628: *
629: *-----------------------------------------------------------------------
630: */
631: void
632: sunPolySegment(pDraw, pGC, nseg, pSegs)
633: DrawablePtr pDraw;
634: GCPtr pGC;
635: int nseg;
636: xSegment *pSegs;
637: {
638: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
639: register xSegment *pSeg;
640: register int nSeg;
641: register int xorg,
642: yorg;
643: BoxRec cursorBox;
644: Bool nuke = FALSE;
645:
646: if (pDraw->type == DRAWABLE_WINDOW &&
647: sunCursorLoc (pDraw->pScreen, &cursorBox)) {
648: xorg = ((WindowPtr)pDraw)->absCorner.x;
649: yorg = ((WindowPtr)pDraw)->absCorner.y;
650:
651: for (nSeg = nseg, pSeg = pSegs; nSeg--; pSeg++) {
652: if (pSeg->x1 < pSeg->x2) {
653: if (pSeg->y1 < pSeg->y2) {
654: nuke = BOX_OVERLAP(&cursorBox,
655: pSeg->x1+xorg,pSeg->y1+yorg,
656: pSeg->x2+xorg,pSeg->y2+yorg);
657: } else {
658: nuke = BOX_OVERLAP(&cursorBox,
659: pSeg->x1+xorg,pSeg->y2+yorg,
660: pSeg->x2+xorg,pSeg->y1+yorg);
661: }
662: } else if (pSeg->y1 < pSeg->y2) {
663: nuke = BOX_OVERLAP(&cursorBox,
664: pSeg->x2+xorg,pSeg->y1+yorg,
665: pSeg->x1+xorg,pSeg->y2+yorg);
666: } else {
667: nuke = BOX_OVERLAP(&cursorBox,
668: pSeg->x2+xorg,pSeg->y2+yorg,
669: pSeg->x1+xorg,pSeg->y1+yorg);
670: }
671: if (nuke) {
672: sunRemoveCursor();
673: break;
674: }
675: }
676: }
677:
678: COMPARE_GCS(pGC,pShadowGC);
679: (* pShadowGC->PolySegment) (pDraw, pShadowGC, nseg, pSegs);
680: }
681:
682: /*-
683: *-----------------------------------------------------------------------
684: * sunPolyRectangle --
685: * Remove the cursor if it overlaps any of the rectangles to be
686: * drawn, then draw them.
687: *
688: * Results:
689: * None
690: *
691: * Side Effects:
692: *
693: *-----------------------------------------------------------------------
694: */
695: void
696: sunPolyRectangle(pDraw, pGC, nrects, pRects)
697: DrawablePtr pDraw;
698: GCPtr pGC;
699: int nrects;
700: xRectangle *pRects;
701: {
702: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
703: register xRectangle *pRect;
704: register int nRect;
705: register int xorg,
706: yorg;
707: BoxRec cursorBox;
708:
709: if (pDraw->type == DRAWABLE_WINDOW &&
710: sunCursorLoc (pDraw->pScreen, &cursorBox)) {
711: xorg = ((WindowPtr)pDraw)->absCorner.x;
712: yorg = ((WindowPtr)pDraw)->absCorner.y;
713:
714: for (nRect = nrects, pRect = pRects; nRect--; pRect++) {
715: if (ORGRECT_OVERLAP(&cursorBox,xorg,yorg,pRect)){
716: sunRemoveCursor();
717: break;
718: }
719: }
720: }
721:
722: COMPARE_GCS(pGC,pShadowGC);
723: (* pShadowGC->PolyRectangle) (pDraw, pShadowGC, nrects, pRects);
724: }
725:
726: /*-
727: *-----------------------------------------------------------------------
728: * sunPolyArc --
729: * Using the bounding rectangle of each arc, remove the cursor
730: * if it overlaps any arc, then draw all the arcs.
731: *
732: * Results:
733: *
734: * Side Effects:
735: *
736: *-----------------------------------------------------------------------
737: */
738: void
739: sunPolyArc(pDraw, pGC, narcs, parcs)
740: DrawablePtr pDraw;
741: GCPtr pGC;
742: int narcs;
743: xArc *parcs;
744: {
745: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
746: register xArc *pArc;
747: register int nArc;
748: register int xorg,
749: yorg;
750: BoxRec cursorBox;
751:
752: if (pDraw->type == DRAWABLE_WINDOW &&
753: sunCursorLoc (pDraw->pScreen, &cursorBox)) {
754: xorg = ((WindowPtr)pDraw)->absCorner.x;
755: yorg = ((WindowPtr)pDraw)->absCorner.y;
756:
757: for (nArc = narcs, pArc = parcs; nArc--; pArc++) {
758: if (ORGRECT_OVERLAP(&cursorBox,xorg,yorg,pArc)){
759: sunRemoveCursor();
760: break;
761: }
762: }
763: }
764:
765: COMPARE_GCS(pGC,pShadowGC);
766: (* pShadowGC->PolyArc) (pDraw, pShadowGC, narcs, parcs);
767: }
768:
769: /*-
770: *-----------------------------------------------------------------------
771: * sunFillPolygon --
772: * Find the bounding box of the polygon to fill and remove the
773: * cursor if it overlaps this box...
774: *
775: * Results:
776: * None.
777: *
778: * Side Effects:
779: *
780: *-----------------------------------------------------------------------
781: */
782: void
783: sunFillPolygon(pDraw, pGC, shape, mode, count, pPts)
784: DrawablePtr pDraw;
785: register GCPtr pGC;
786: int shape, mode;
787: register int count;
788: DDXPointPtr pPts;
789: {
790: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
791: BoxRec cursorBox;
792:
793: if (pDraw->type == DRAWABLE_WINDOW &&
794: sunCursorLoc (pDraw->pScreen, &cursorBox)) {
795: sunSaveCursorBox(((WindowPtr)pDraw)->absCorner.x,
796: ((WindowPtr)pDraw)->absCorner.y,
797: mode,
798: pPts,
799: count,
800: &cursorBox);
801: }
802:
803: COMPARE_GCS(pGC,pShadowGC);
804: (* pShadowGC->FillPolygon) (pDraw, pShadowGC, shape, mode, count, pPts);
805: }
806:
807: /*-
808: *-----------------------------------------------------------------------
809: * sunPolyFillRect --
810: * Remove the cursor if it overlaps any of the filled rectangles
811: * to be drawn by the output routines.
812: *
813: * Results:
814: * None.
815: *
816: * Side Effects:
817: *
818: *-----------------------------------------------------------------------
819: */
820: void
821: sunPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
822: DrawablePtr pDrawable;
823: GCPtr pGC;
824: int nrectFill; /* number of rectangles to fill */
825: xRectangle *prectInit; /* Pointer to first rectangle to fill */
826: {
827: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
828: register xRectangle *pRect;
829: register int nRect;
830: register int xorg,
831: yorg;
832: BoxRec cursorBox;
833:
834: if (pDrawable->type == DRAWABLE_WINDOW &&
835: sunCursorLoc (pDrawable->pScreen, &cursorBox)) {
836: xorg = ((WindowPtr)pDrawable)->absCorner.x;
837: yorg = ((WindowPtr)pDrawable)->absCorner.y;
838:
839: for (nRect = nrectFill, pRect = prectInit; nRect--; pRect++) {
840: if (ORGRECT_OVERLAP(&cursorBox,xorg,yorg,pRect)){
841: sunRemoveCursor();
842: break;
843: }
844: }
845: }
846:
847: COMPARE_GCS(pGC,pShadowGC);
848: (* pShadowGC->PolyFillRect) (pDrawable, pShadowGC, nrectFill, prectInit);
849: }
850:
851: /*-
852: *-----------------------------------------------------------------------
853: * sunPolyFillArc --
854: * See if the cursor overlaps any of the bounding boxes for the
855: * filled arc and remove it if it does.
856: *
857: * Results:
858: * None.
859: *
860: * Side Effects:
861: *
862: *-----------------------------------------------------------------------
863: */
864: void
865: sunPolyFillArc(pDraw, pGC, narcs, parcs)
866: DrawablePtr pDraw;
867: GCPtr pGC;
868: int narcs;
869: xArc *parcs;
870: {
871: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
872: register xArc *pArc;
873: register int nArc;
874: register int xorg,
875: yorg;
876: BoxRec cursorBox;
877:
878: if (pDraw->type == DRAWABLE_WINDOW &&
879: sunCursorLoc (pDraw->pScreen, &cursorBox)) {
880: xorg = ((WindowPtr)pDraw)->absCorner.x;
881: yorg = ((WindowPtr)pDraw)->absCorner.y;
882:
883: for (nArc = narcs, pArc = parcs; nArc--; pArc++) {
884: if (ORGRECT_OVERLAP(&cursorBox,xorg,yorg,pArc)){
885: sunRemoveCursor();
886: break;
887: }
888: }
889: }
890:
891: COMPARE_GCS(pGC,pShadowGC);
892: (* pShadowGC->PolyFillArc) (pDraw, pShadowGC, narcs, parcs);
893: }
894:
895: /*-
896: *-----------------------------------------------------------------------
897: * sunText --
898: * Find the extent of a text operation and remove the cursor if they
899: * overlap. pDraw is assumed to be a window.
900: *
901: * Results:
902: *
903: * Side Effects:
904: *
905: *-----------------------------------------------------------------------
906: */
907: int
908: sunText(pDraw, pGC, x, y, count, chars, fontEncoding, drawFunc)
909: DrawablePtr pDraw;
910: GCPtr pGC;
911: int x,
912: y;
913: int count;
914: char *chars;
915: FontEncoding fontEncoding;
916: void (*drawFunc)();
917: {
918: CharInfoPtr *charinfo;
919: unsigned int n, w = 0;
920: register int xorg, yorg;
921: ExtentInfoRec extents;
922: BoxRec cursorBox;
923:
924: charinfo = (CharInfoPtr *) ALLOCATE_LOCAL(count * sizeof(CharInfoPtr));
925: if (charinfo == (CharInfoPtr *) NULL) {
926: return x;
927: }
928:
929: GetGlyphs(pGC->font, count, chars, fontEncoding, &n, charinfo);
930:
931: if (n != 0) {
932: QueryGlyphExtents(pGC->font, charinfo, n, &extents);
933: w = extents.overallWidth;
934:
935: if (sunCursorLoc(pDraw->pScreen, &cursorBox)) {
936: xorg = ((WindowPtr) pDraw)->absCorner.x;
937: yorg = ((WindowPtr) pDraw)->absCorner.y;
938:
939: if (BOX_OVERLAP(&cursorBox,
940: x + xorg + extents.overallLeft,
941: y + yorg - extents.overallAscent,
942: x + xorg + extents.overallRight,
943: y + yorg + extents.overallDescent)) {
944: sunRemoveCursor();
945: }
946: }
947:
948: (*drawFunc) (pDraw, pGC, x, y, n, charinfo, pGC->font->pGlyphs);
949:
950: }
951: DEALLOCATE_LOCAL(charinfo);
952: return x + w;
953: }
954:
955: /*-
956: *-----------------------------------------------------------------------
957: * sunPolyText8 --
958: *
959: * Results:
960: *
961: * Side Effects:
962: *
963: *-----------------------------------------------------------------------
964: */
965: int
966: sunPolyText8(pDraw, pGC, x, y, count, chars)
967: DrawablePtr pDraw;
968: GCPtr pGC;
969: int x, y;
970: int count;
971: char *chars;
972: {
973: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
974:
975: COMPARE_GCS(pGC,pShadowGC);
976: if (pDraw->type == DRAWABLE_WINDOW) {
977: return sunText (pDraw, pShadowGC, x, y, count, chars, Linear8Bit,
978: pShadowGC->PolyGlyphBlt);
979: } else {
980: return (* pShadowGC->PolyText8)(pDraw, pShadowGC, x, y, count, chars);
981: }
982: }
983:
984: /*-
985: *-----------------------------------------------------------------------
986: * sunPolyText16 --
987: *
988: * Results:
989: *
990: * Side Effects:
991: *
992: *-----------------------------------------------------------------------
993: */
994: int
995: sunPolyText16(pDraw, pGC, x, y, count, chars)
996: DrawablePtr pDraw;
997: GCPtr pGC;
998: int x, y;
999: int count;
1000: unsigned short *chars;
1001: {
1002: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1003:
1004: COMPARE_GCS(pGC,pShadowGC);
1005: if (pDraw->type == DRAWABLE_WINDOW) {
1006: return sunText (pDraw, pShadowGC, x, y, count, chars,
1007: (pShadowGC->font->pFI->lastRow == 0 ?
1008: Linear16Bit : TwoD16Bit),
1009: pShadowGC->PolyGlyphBlt);
1010: } else {
1011: return (* pShadowGC->PolyText16) (pDraw, pShadowGC, x, y,
1012: count, chars);
1013: }
1014: }
1015:
1016: /*-
1017: *-----------------------------------------------------------------------
1018: * sunImageText8 --
1019: *
1020: * Results:
1021: *
1022: * Side Effects:
1023: *
1024: *-----------------------------------------------------------------------
1025: */
1026: void
1027: sunImageText8(pDraw, pGC, x, y, count, chars)
1028: DrawablePtr pDraw;
1029: GCPtr pGC;
1030: int x, y;
1031: int count;
1032: char *chars;
1033: {
1034: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1035:
1036: COMPARE_GCS(pGC,pShadowGC);
1037: if (pDraw->type == DRAWABLE_WINDOW) {
1038: (void) sunText (pDraw, pShadowGC, x, y, count, chars,
1039: Linear8Bit, pShadowGC->ImageGlyphBlt);
1040: } else {
1041: (* pShadowGC->ImageText8) (pDraw, pShadowGC, x, y, count, chars);
1042: }
1043: }
1044:
1045: /*-
1046: *-----------------------------------------------------------------------
1047: * sunImageText16 --
1048: *
1049: * Results:
1050: *
1051: * Side Effects:
1052: *
1053: *-----------------------------------------------------------------------
1054: */
1055: void
1056: sunImageText16(pDraw, pGC, x, y, count, chars)
1057: DrawablePtr pDraw;
1058: GCPtr pGC;
1059: int x, y;
1060: int count;
1061: unsigned short *chars;
1062: {
1063: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1064:
1065: COMPARE_GCS(pGC,pShadowGC);
1066: if (pDraw->type == DRAWABLE_WINDOW) {
1067: (void) sunText (pDraw, pShadowGC, x, y, count, chars,
1068: (pShadowGC->font->pFI->lastRow == 0 ?
1069: Linear16Bit : TwoD16Bit),
1070: pShadowGC->ImageGlyphBlt);
1071: } else {
1072: (* pShadowGC->ImageText16) (pDraw, pShadowGC, x, y, count, chars);
1073: }
1074: }
1075:
1076: /*-
1077: *-----------------------------------------------------------------------
1078: * sunImageGlyphBlt --
1079: *
1080: * Results:
1081: *
1082: * Side Effects:
1083: *
1084: *-----------------------------------------------------------------------
1085: */
1086: void
1087: sunImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
1088: DrawablePtr pDrawable;
1089: GC *pGC;
1090: int x, y;
1091: unsigned int nglyph;
1092: CharInfoPtr *ppci; /* array of character info */
1093: pointer pglyphBase; /* start of array of glyphs */
1094: {
1095: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1096: BoxRec cursorBox;
1097: ExtentInfoRec extents;
1098: register int xorg,
1099: yorg;
1100:
1101: if (pDrawable->type == DRAWABLE_WINDOW &&
1102: sunCursorLoc (pDrawable->pScreen, &cursorBox)) {
1103: QueryGlyphExtents (pGC->font, ppci, nglyph, &extents);
1104: xorg = ((WindowPtr)pDrawable)->absCorner.x + x;
1105: yorg = ((WindowPtr)pDrawable)->absCorner.y + y;
1106: if (BOX_OVERLAP(&cursorBox,xorg+extents.overallLeft,
1107: yorg+extents.overallAscent,
1108: xorg+extents.overallRight,
1109: yorg+extents.overallDescent)) {
1110: sunRemoveCursor();
1111: }
1112: }
1113:
1114: COMPARE_GCS(pGC,pShadowGC);
1115: (* pShadowGC->ImageGlyphBlt) (pDrawable, pShadowGC, x, y, nglyph,
1116: ppci, pglyphBase);
1117: }
1118:
1119: /*-
1120: *-----------------------------------------------------------------------
1121: * sunPolyGlyphBlt --
1122: *
1123: * Results:
1124: *
1125: * Side Effects:
1126: *
1127: *-----------------------------------------------------------------------
1128: */
1129: void
1130: sunPolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
1131: DrawablePtr pDrawable;
1132: GCPtr pGC;
1133: int x, y;
1134: unsigned int nglyph;
1135: CharInfoPtr *ppci; /* array of character info */
1136: char *pglyphBase; /* start of array of glyphs */
1137: {
1138: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1139: BoxRec cursorBox;
1140: ExtentInfoRec extents;
1141: register int xorg,
1142: yorg;
1143:
1144: if (pDrawable->type == DRAWABLE_WINDOW &&
1145: sunCursorLoc (pDrawable->pScreen, &cursorBox)) {
1146: QueryGlyphExtents (pGC->font, ppci, nglyph, &extents);
1147: xorg = ((WindowPtr)pDrawable)->absCorner.x + x;
1148: yorg = ((WindowPtr)pDrawable)->absCorner.y + y;
1149: if (BOX_OVERLAP(&cursorBox,xorg+extents.overallLeft,
1150: yorg+extents.overallAscent,
1151: xorg+extents.overallRight,
1152: yorg+extents.overallDescent)){
1153: sunRemoveCursor();
1154: }
1155: }
1156:
1157: COMPARE_GCS(pGC,pShadowGC);
1158: (* pShadowGC->PolyGlyphBlt) (pDrawable, pShadowGC, x, y,
1159: nglyph, ppci, pglyphBase);
1160: }
1161:
1162: /*-
1163: *-----------------------------------------------------------------------
1164: * sunPushPixels --
1165: *
1166: * Results:
1167: *
1168: * Side Effects:
1169: *
1170: *-----------------------------------------------------------------------
1171: */
1172: void
1173: sunPushPixels(pGC, pBitMap, pDst, w, h, x, y)
1174: GCPtr pGC;
1175: PixmapPtr pBitMap;
1176: DrawablePtr pDst;
1177: int w, h, x, y;
1178: {
1179:
1180: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1181: BoxRec cursorBox;
1182: register int xorg,
1183: yorg;
1184:
1185: if (pDst->type == DRAWABLE_WINDOW &&
1186: sunCursorLoc (pDst->pScreen, &cursorBox)) {
1187: xorg = ((WindowPtr)pDst)->absCorner.x + x;
1188: yorg = ((WindowPtr)pDst)->absCorner.y + y;
1189:
1190: if (BOX_OVERLAP(&cursorBox,xorg,yorg,xorg+w,yorg+h)){
1191: sunRemoveCursor();
1192: }
1193: }
1194:
1195: COMPARE_GCS(pGC,pShadowGC);
1196: (* pShadowGC->PushPixels) (pShadowGC, pBitMap, pDst, w, h, x, y);
1197: }
1198:
1199: /*-
1200: *-----------------------------------------------------------------------
1201: * sunLineHelper --
1202: *
1203: * Results:
1204: *
1205: * Side Effects:
1206: *
1207: *-----------------------------------------------------------------------
1208: */
1209: void
1210: sunLineHelper (pDraw, pGC, caps, npt, pPts, xOrg, yOrg)
1211: DrawablePtr pDraw;
1212: GCPtr pGC;
1213: int caps;
1214: int npt;
1215: SppPointPtr pPts;
1216: int xOrg, yOrg;
1217: {
1218: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1219:
1220: COMPARE_GCS(pGC,pShadowGC);
1221: (* pShadowGC->LineHelper) (pDraw, pShadowGC, caps, npt, pPts, xOrg, yOrg);
1222: }
1223:
1224: /*-
1225: *-----------------------------------------------------------------------
1226: * sunChangeClip --
1227: * Front end for changing the clip in the GC. Just passes the command
1228: * on through the shadow GC.
1229: *
1230: *
1231: * Results:
1232: * None.
1233: *
1234: * Side Effects:
1235: * ???
1236: *
1237: *-----------------------------------------------------------------------
1238: */
1239: void
1240: sunChangeClip (pGC, type, pValue, numRects)
1241: GCPtr pGC;
1242: int type;
1243: pointer pValue;
1244: int numRects;
1245: {
1246: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1247:
1248: COMPARE_GCS(pGC,pShadowGC);
1249: (* pShadowGC->ChangeClip) (pShadowGC, type, pValue, numRects);
1250: /*
1251: * Now copy the clip info back from the shadow to the real
1252: * GC so that if we use it as the source for a CopyGC,
1253: * the clip info will get copied along with everything
1254: * else.
1255: */
1256: pGC->clientClip = pShadowGC->clientClip;
1257: pGC->clientClipType = pShadowGC->clientClipType;
1258: }
1259:
1260: /*-
1261: *-----------------------------------------------------------------------
1262: * sunDestroyClip --
1263: * Ditto for destroying the clipping region of the GC.
1264: *
1265: * Results:
1266: * None.
1267: *
1268: * Side Effects:
1269: * ???
1270: *
1271: *-----------------------------------------------------------------------
1272: */
1273: void
1274: sunDestroyClip (pGC)
1275: GCPtr pGC;
1276: {
1277: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1278:
1279: COMPARE_GCS(pGC,pShadowGC);
1280: (* pShadowGC->DestroyClip) (pShadowGC);
1281: }
1282:
1283: /*-
1284: *-----------------------------------------------------------------------
1285: * sunCopyClip --
1286: * Ditto for copying the clipping region of the GC.
1287: *
1288: * Results:
1289: * None.
1290: *
1291: * Side Effects:
1292: * ???
1293: *
1294: *-----------------------------------------------------------------------
1295: */
1296: void
1297: sunCopyClip (pgcDst, pgcSrc)
1298: GCPtr pgcDst, pgcSrc;
1299: {
1300: register GCPtr pShadowSrcGC = (GCPtr) pgcSrc->devPriv;
1301: register GCPtr pShadowDstGC = (GCPtr) pgcDst->devPriv;
1302:
1303: COMPARE_GCS(pgcSrc, pShadowSrcGC);
1304: COMPARE_GCS(pgcDst, pShadowDstGC);
1305: (* pShadowDstGC->CopyClip) (pShadowDstGC, pShadowSrcGC);
1306: }
1307:
1308: /*-
1309: *-----------------------------------------------------------------------
1310: * sunDestroyGC --
1311: * Function called when a GC is being freed. Simply unlinks and frees
1312: * the GCInterest structure.
1313: *
1314: * Results:
1315: * None.
1316: *
1317: * Side Effects:
1318: * The GCInterest structure is removed from the chain but its own
1319: * links are untouched (so FreeGC has something to follow...)
1320: *
1321: *-----------------------------------------------------------------------
1322: */
1323: void
1324: sunDestroyGC (pGC, pGCI)
1325: GCPtr pGC; /* GC pGCI is attached to */
1326: GCInterestPtr pGCI; /* GCInterest being destroyed */
1327: {
1328: if (pGC->devPriv)
1329: FreeGC ((GCPtr)pGC->devPriv);
1330: Xfree (pGCI);
1331: }
1332:
1333: /*-
1334: *-----------------------------------------------------------------------
1335: * sunValidateGC --
1336: * Called when a GC is about to be used for drawing. Copies all
1337: * changes from the GC to its shadow and validates the shadow.
1338: *
1339: * Results:
1340: * TRUE, for no readily apparent reason.
1341: *
1342: * Side Effects:
1343: * Vectors in the shadow GC will likely be changed.
1344: *
1345: *-----------------------------------------------------------------------
1346: */
1347: /*ARGSUSED*/
1348: static void
1349: sunValidateGC (pGC, pGCI, changes, pDrawable)
1350: GCPtr pGC;
1351: GCInterestPtr pGCI;
1352: Mask changes;
1353: DrawablePtr pDrawable;
1354: {
1355: register GCPtr pShadowGC = (GCPtr) pGC->devPriv;
1356:
1357: if ( pGC->depth != pDrawable->depth )
1358: FatalError( "sunValidateGC: depth mismatch.\n" );
1359:
1360: /*
1361: * sunValidateGC copies the GC to the shadow. Alas,
1362: * sunChangeClip has stored the new clip in the shadow,
1363: * where it will be overwritten, unless we pretend
1364: * that the clip hasn't changed.
1365: */
1366: changes &= ~GCClipMask;
1367:
1368: CopyGC (pGC, pShadowGC, changes);
1369: pShadowGC->serialNumber = pGC->serialNumber;
1370: COMPARE_GCS(pGC,pShadowGC);
1371: ValidateGC (pDrawable, pShadowGC);
1372: }
1373:
1374: /*-
1375: *-----------------------------------------------------------------------
1376: * sunCopyGC --
1377: * Called when a GC with its shadow is the destination of a copy.
1378: * Calls CopyGC to transfer the changes to the shadow GC as well.
1379: * Should not be used for the CopyGCSource since we like to copy from
1380: * the real GC to the shadow using CopyGC...
1381: *
1382: * Results:
1383: * None.
1384: *
1385: * Side Effects:
1386: * Any changes in the real GC are copied to the shadow.
1387: *
1388: *-----------------------------------------------------------------------
1389: */
1390: /*ARGSUSED*/
1391: void
1392: sunCopyGC (pGCDst, pGCI, changes, pGCSrc)
1393: GCPtr pGCDst;
1394: GCInterestPtr pGCI;
1395: int changes;
1396: GCPtr pGCSrc;
1397: {
1398: CopyGC (pGCSrc, (GCPtr) pGCDst->devPriv, changes);
1399: COMPARE_GCS(pGCSrc,(GCPtr) pGCDst->devPriv);
1400: }
1401:
1402: /*
1403: * Array of functions to replace the functions in the GC.
1404: * Caveat: Depends on the ordering of functions in the GC structure.
1405: */
1406: static void (* sunGCFuncs[]) () = {
1407: sunFillSpans,
1408: sunSetSpans,
1409:
1410: sunPutImage,
1411: sunCopyArea,
1412: sunCopyPlane,
1413: sunPolyPoint,
1414: sunPolylines,
1415: sunPolySegment,
1416: sunPolyRectangle,
1417: sunPolyArc,
1418: sunFillPolygon,
1419: sunPolyFillRect,
1420: sunPolyFillArc,
1421: (void(*)())sunPolyText8,
1422: (void(*)())sunPolyText16,
1423: sunImageText8,
1424: sunImageText16,
1425: sunImageGlyphBlt,
1426: sunPolyGlyphBlt,
1427: sunPushPixels,
1428: sunLineHelper,
1429: sunChangeClip,
1430: sunDestroyClip,
1431: sunCopyClip,
1432: };
1433:
1434: /*-
1435: *-----------------------------------------------------------------------
1436: * sunCreatePrivGC --
1437: * Create a GC private to the Sun DDX code. Such a GC is unhampered
1438: * by any shadow GC and should only be used by functions which know
1439: * what they are doing. This substitutes the old CreateGC function
1440: * in the drawable's screen's vector and calls the DIX CreateGC
1441: * function. Once done, it restores the CreateGC vector to its
1442: * proper state and returns the GCPtr CreateGC gave back.
1443: *
1444: * Results:
1445: * A pointer to the new GC.
1446: *
1447: * Side Effects:
1448: * The GC's graphicsExposures field is set FALSE.
1449: *
1450: *-----------------------------------------------------------------------
1451: */
1452: /*ARGSUSED*/
1453: GCPtr
1454: sunCreatePrivGC(pDrawable, mask, pval, pStatus)
1455: DrawablePtr pDrawable;
1456: BITS32 mask;
1457: long *pval;
1458: BITS32 *pStatus;
1459: {
1460: fbFd *fb;
1461: GCPtr pGC;
1462: BITS32 ge = FALSE;
1463:
1464: fb = &sunFbs[pDrawable->pScreen->myNum];
1465: pDrawable->pScreen->CreateGC = fb->CreateGC;
1466:
1467: pGC = GetScratchGC (pDrawable->depth, pDrawable->pScreen);
1468: ChangeGC (pGC, mask, pval);
1469: ChangeGC (pGC, GCGraphicsExposures, &ge);
1470:
1471: pDrawable->pScreen->CreateGC = sunCreateGC;
1472:
1473: return pGC;
1474: }
1475:
1476: /*-
1477: *-----------------------------------------------------------------------
1478: * sunCreateGC --
1479: * This function is used to get our own validation hooks into each
1480: * GC to preserve the cursor. It calls the regular creation routine
1481: * for the screen and then, if that was successful, tacks another
1482: * GCInterest structure onto the GC *after* the one placed on by
1483: * the screen-specific CreateGC...
1484: *
1485: * Results:
1486: * TRUE if created ok. FALSE otherwise.
1487: *
1488: * Side Effects:
1489: * A GCInterest structure is stuck on the end of the GC's list.
1490: *
1491: *-----------------------------------------------------------------------
1492: */
1493: Bool
1494: sunCreateGC (pGC)
1495: GCPtr pGC; /* The GC to play with */
1496: {
1497: GCInterestPtr pGCI;
1498: register GCPtr pShadowGC;
1499: int i;
1500:
1501: if ((*sunFbs[pGC->pScreen->myNum].CreateGC) (pGC)) {
1502:
1503: if (pGC->depth != pGC->pScreen->rootDepth) {
1504: /* This GC will never be used for painting the screen, so no shadow needed */
1505: return TRUE;
1506: }
1507:
1508: pShadowGC = (GCPtr) Xalloc (sizeof (GC));
1509: if (pShadowGC == (GCPtr)NULL) {
1510: return FALSE;
1511: }
1512:
1513: *pShadowGC = *pGC;
1514: pGC->devPriv = (pointer)pShadowGC;
1515: bcopy (sunGCFuncs, &pGC->FillSpans, sizeof (sunGCFuncs));
1516:
1517: pGCI = (GCInterestPtr) Xalloc (sizeof (GCInterestRec));
1518: if (!pGCI) {
1519: return FALSE;
1520: }
1521:
1522: /*
1523: * Any structure being shared between these two GCs must have its
1524: * reference count incremented. This includes:
1525: * font, tile, stipple.
1526: * Anything which doesn't have a reference count must be duplicated:
1527: * pCompositeClip, pAbsClientRegion.
1528: *
1529: */
1530: if (pGC->font) {
1531: pGC->font->refcnt++;
1532: }
1533: if (pGC->tile) {
1534: pGC->tile->refcnt++;
1535: }
1536: if (pGC->stipple) {
1537: pGC->stipple->refcnt++;
1538: }
1539: pShadowGC->dash = (unsigned char *)
1540: Xalloc(2 * sizeof(unsigned char));
1541: for (i=0; i<pGC->numInDashList; i++)
1542: pShadowGC->dash[i] = pGC->dash[i];
1543:
1544: #ifdef notdef
1545: if (pGC->pCompositeClip) {
1546: pShadowGC->pCompositeClip =
1547: (* pGC->pScreen->RegionCreate) (NULL, 1);
1548: (* pGC->pScreen->RegionCopy) (pShadowGC->pCompositeClip,
1549: pGC->pCompositeClip);
1550: }
1551: if (pGC->pAbsClientRegion) {
1552: pShadowGC->pAbsClientRegion=
1553: (* pGC->pScreen->RegionCreate) (NULL, 1);
1554: (* pGC->pScreen->RegionCopy) (pShadowGC->pAbsClientRegion,
1555: pGC->pAbsClientRegion);
1556: }
1557: #endif notdef
1558:
1559: pGC->pNextGCInterest = pGCI;
1560: pGC->pLastGCInterest = pGCI;
1561: pGCI->pNextGCInterest = (GCInterestPtr) &pGC->pNextGCInterest;
1562: pGCI->pLastGCInterest = (GCInterestPtr) &pGC->pNextGCInterest;
1563: pGCI->length = sizeof(GCInterestRec);
1564: pGCI->owner = 0; /* server owns this */
1565: pGCI->ValInterestMask = ~0; /* interested in everything */
1566: pGCI->ValidateGC = sunValidateGC;
1567: pGCI->ChangeInterestMask = 0; /* interested in nothing */
1568: pGCI->ChangeGC = (int (*)()) NULL;
1569: pGCI->CopyGCSource = (void (*)())NULL;
1570: pGCI->CopyGCDest = sunCopyGC;
1571: pGCI->DestroyGC = sunDestroyGC;
1572:
1573:
1574: /*
1575: * Because of this weird way of handling the GCInterest lists,
1576: * we need to modify the output library's GCInterest structure to
1577: * point to the pNextGCInterest field of the shadow GC...
1578: */
1579: pGCI = pShadowGC->pNextGCInterest;
1580: pGCI->pLastGCInterest = pGCI->pNextGCInterest =
1581: (GCInterestPtr) &pShadowGC->pNextGCInterest;
1582:
1583: return TRUE;
1584: } else {
1585: return FALSE;
1586: }
1587: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.