![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sunBW2zoid.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 sunBW2zoid.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / sun |
1.1 root 1: /* $Header: sunBW2zoid.c,v 4.1 87/09/10 18:25:11 sun Exp $ */
2: /*-
3: * sunBW2zoids.c --
4: * Functions for handling the sun BWTWO board for the zoids extension.
5: *
6: */
7:
8: /************************************************************
9: Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
10:
11: All Rights Reserved
12:
13: Permission to use, copy, modify, and distribute this
14: software and its documentation for any purpose and without
15: fee is hereby granted, provided that the above copyright no-
16: tice appear in all copies and that both that copyright no-
17: tice and this permission notice appear in supporting docu-
18: mentation, and that the names of Sun or MIT not be used in
19: advertising or publicity pertaining to distribution of the
20: software without specific prior written permission. Sun and
21: M.I.T. make no representations about the suitability of this
22: software for any purpose. It is provided "as is" without any
23: express or implied warranty.
24:
25: SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
26: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
27: NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
28: ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
29: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
30: PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
31: OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
32: THE USE OR PERFORMANCE OF THIS SOFTWARE.
33:
34: ********************************************************/
35:
36: #ifndef lint
37: static char sccsid[] = "%W %G Copyright 1987 Sun Micro";
38: #endif
39:
40: #include "sun.h"
41: #include "resource.h"
42:
43:
44: /*
45: * ZOIDS should only ever be defined if SUN_WINDOWS is also defined.
46: */
47: #ifdef ZOIDS
48: /*
49: * For tiled & stippled trapezoids,
50: * make a mem_point(), pointing at the tile or stipple
51: * image. Tile the scratch_pr with the mpr, the size of pDraw.
52: * Use the scratch_pr as the source
53: * in calls to pr_polygon_2(). Tiles use PIX_SRC; stipples use
54: * PIX_SRC|PIX_DST.
55: */
56:
57: #define X_ALIGN 0
58: #define Y_ALIGN 1
59:
60: static Pixrect *
61: getMpr(pPixmap)
62: PixmapPtr pPixmap;
63: {
64: register Pixrect *pMpr;
65:
66: pMpr = mem_point(pPixmap->width, pPixmap->height,
67: 1, pPixmap->devPrivate);
68: return pMpr;
69: }
70:
71: static Pixrect *
72: getSubregion(pDraw, pScratch)
73: DrawablePtr pDraw;
74: Pixrect *pScratch;
75: {
76: register Pixrect *pSubpr;
77: register int w, h;
78:
79: if (pDraw->type == DRAWABLE_WINDOW) {
80: w = ((WindowPtr) pDraw)->clientWinSize.width;
81: h = ((WindowPtr) pDraw)->clientWinSize.height;
82: } else {
83: w = ((PixmapPtr) pDraw)->width;
84: h = ((PixmapPtr) pDraw)->height;
85: }
86: pSubpr = pr_region(pScratch, 0, 0, w, h);
87: return (pSubpr);
88: }
89:
90: static void
91: tileRegion(pScratch, pTile)
92: Pixrect *pScratch, *pTile;
93: {
94: pr_replrop(pScratch, 0, 0, pScratch->pr_size.x, pScratch->pr_size.y,
95: PIX_SRC, pTile, 0, 0);
96: }
97:
98: static int
99: orderXzoid(pZoid, pPtList)
100: xXTraps *pZoid;
101: struct pr_pos *pPtList;
102: {
103: int npts = 2;
104:
105: if (pZoid->x2 == pZoid->x1)
106: return (0);
107: pPtList[0].x = pZoid->x1;
108: pPtList[0].y = pZoid->y1;
109: pPtList[1].x = pZoid->x2;
110: pPtList[1].y = pZoid->y3;
111: if (pZoid->y4 != pPtList[1].y) {
112: pPtList[2].x = pZoid->x2;
113: pPtList[2].y = pZoid->y4;
114: npts++;
115: }
116: if (pZoid->y2 != pPtList[0].y) {
117: pPtList[npts].x = pZoid->x1;
118: pPtList[npts].y = pZoid->y2;
119: npts++;
120: }
121: if (npts == 2)
122: npts = 0;
123:
124: return (npts);
125: }
126:
127: static int
128: orderYzoid(pZoid, pPtList)
129: xYTraps *pZoid;
130: struct pr_pos *pPtList;
131: {
132: int npts = 2;
133:
134: if (pZoid->y2 == pZoid->y1)
135: return (0);
136: pPtList[0].x = pZoid->x1;
137: pPtList[0].y = pZoid->y1;
138: pPtList[1].x = pZoid->x3;
139: pPtList[1].y = pZoid->y2;
140: if (pZoid->x4 != pPtList[1].x) {
141: pPtList[2].x = pZoid->x4;
142: pPtList[2].y = pZoid->y2;
143: npts++;
144: }
145: if (pZoid->x2 != pPtList[0].x) {
146: pPtList[npts].x = pZoid->x2;
147: pPtList[npts].y = pZoid->y1;
148: npts++;
149: }
150: if (npts == 2)
151: npts = 0;
152:
153: return (npts);
154: }
155:
156: static void
157: solidXzoid(pPixscreen, pZoid, pPixsrc, sx, sy)
158: Pixrect *pPixscreen,
159: *pPixsrc; /* unused */
160: xXTraps *pZoid;
161: int sx, sy; /* unused */
162: {
163: int npts;
164: struct pr_pos ptlist[4];
165:
166: if ((npts = orderXzoid(pZoid, ptlist)) > 0)
167: pr_polygon_2(pPixscreen, 0, 0, 1, &npts, ptlist,
168: PIX_SET, NULL, 0, 0);
169: }
170:
171: static void
172: solidYzoid(pPixscreen, pZoid, pPixsrc, sx, sy)
173: Pixrect *pPixscreen,
174: *pPixsrc; /* unused */
175: xYTraps *pZoid;
176: int sx, sy; /* unused */
177: {
178: int npts;
179: struct pr_pos ptlist[4];
180:
181: if ((npts = orderYzoid(pZoid, ptlist)) > 0)
182: pr_polygon_2(pPixscreen, 0, 0, 1, &npts, ptlist,
183: PIX_SET, NULL, 0, 0);
184: }
185:
186: static void
187: tiledXzoid(pPixscreen, pZoid, pPixsrc, sx, sy)
188: Pixrect *pPixscreen,
189: *pPixsrc;
190: xXTraps *pZoid;
191: int sx, sy;
192: {
193: int npts;
194: struct pr_pos ptlist[4];
195:
196: if ((npts = orderXzoid(pZoid, ptlist)) > 0)
197: pr_polygon_2(pPixscreen, 0, 0, 1, &npts, ptlist,
198: PIX_SRC, pPixsrc, sx, sy);
199: }
200:
201: static void
202: tiledYzoid(pPixscreen, pZoid, pPixsrc, sx, sy)
203: Pixrect *pPixscreen,
204: *pPixsrc;
205: xYTraps *pZoid;
206: int sx, sy;
207: {
208: int npts;
209: struct pr_pos ptlist[4];
210:
211: if ((npts = orderYzoid(pZoid, ptlist)) > 0)
212: pr_polygon_2(pPixscreen, 0, 0, 1, &npts, ptlist,
213: PIX_SRC, pPixsrc, sx, sy);
214: }
215:
216: static void
217: stippledXzoid(pPixscreen, pZoid, pPixsrc, sx, sy)
218: Pixrect *pPixscreen,
219: *pPixsrc;
220: xXTraps *pZoid;
221: int sx, sy;
222: {
223: int npts;
224: struct pr_pos ptlist[4];
225:
226: if ((npts = orderXzoid(pZoid, ptlist)) > 0)
227: pr_polygon_2(pPixscreen, 0, 0, 1, &npts, ptlist,
228: PIX_SRC|PIX_DST, pPixsrc, sx, sy);
229: }
230:
231: static void
232: stippledYzoid(pPixscreen, pZoid, pPixsrc, sx, sy)
233: Pixrect *pPixscreen,
234: *pPixsrc;
235: xYTraps *pZoid;
236: int sx, sy;
237: {
238: int npts;
239: struct pr_pos ptlist[4];
240:
241: if ((npts = orderYzoid(pZoid, ptlist)) > 0)
242: pr_polygon_2(pPixscreen, 0, 0, 1, &npts, ptlist,
243: PIX_SRC|PIX_DST, pPixsrc, sx, sy);
244: }
245:
246: static void
247: XzoidBbox(pzoid, pbox)
248: xXTraps *pzoid;
249: BoxRec *pbox;
250: {
251: pbox->x1 = min (pzoid->x1, pzoid->x2);
252: pbox->y1 = min (min (pzoid->y1, pzoid->y2), min (pzoid->y3, pzoid->y4));
253: pbox->x2 = max (pzoid->x1, pzoid->x2);
254: pbox->y2 = max (max (pzoid->y1, pzoid->y2), max (pzoid->y3, pzoid->y4));
255: }
256:
257: static void
258: YzoidBbox(pzoid, pbox)
259: xYTraps *pzoid;
260: BoxRec *pbox;
261: {
262: pbox->x1 = min (min (pzoid->x1, pzoid->x2), min (pzoid->x3, pzoid->x4));
263: pbox->y1 = min (pzoid->y1, pzoid->y2);
264: pbox->x2 = max (max (pzoid->x1, pzoid->x2), max (pzoid->x3, pzoid->x4));
265: pbox->y2 = max (pzoid->y1, pzoid->y2);
266: }
267:
268: /*
269: * X aligned
270: *
271: * [x2,y3]
272: * +
273: * A /|
274: * [x1,y1] / |
275: * + |
276: * | |
277: * + |
278: * [x1,y2] \ |
279: * B \|
280: * +
281: * [x2,y4]
282: *
283: * A: y1-y3 y1-y3
284: * y = ----- x + (y1 - ----- x1)
285: * x1-x2 x1-x2
286: *
287: * B: y2-y4 y2-y4
288: * y = ----- x + (y2 - ----- x1)
289: * x1-x2 x1-x2
290: */
291: #define Ax2y(_x) (int) (((((long)pz->y1 - (long)pz->y3) * (long)(_x))/ \
292: ((long)pz->x1 - (long)pz->x2)) + (long)pz->y1 - \
293: ((((long)pz->y1 - (long)pz->y3)*(long)pz->x1)/ \
294: ((long)pz->x1 - (long)pz->x2)))
295: #define Bx2y(_x) (int) (((((long)pz->y2 - (long)pz->y4) * (long)(_x))/ \
296: ((long)pz->x1 - (long)pz->x2)) + (long)pz->y2 - \
297: ((((long)pz->y2 - (long)pz->y4)*(long)pz->x1)/ \
298: ((long)pz->x1 - (long)pz->x2)))
299: #define Ay2x(_y) (int) (((((long)pz->x1 - (long)pz->x2) * (long)(_y))/ \
300: ((long)pz->y1 - (long)pz->y3)) + (long)pz->x1 - \
301: ((((long)pz->x1 - (long)pz->x2)*(long)pz->y1)/ \
302: ((long)pz->y1 - (long)pz->y3)))
303: #define By2x(_y) (int) (((((long)pz->x1 - (long)pz->x2) * (long)(_y))/ \
304: ((long)pz->y2 - (long)pz->y4)) + (long)pz->x1 - \
305: ((((long)pz->x1 - (long)pz->x2)*(long)pz->y2)/ \
306: ((long)pz->y2 - (long)pz->y4)))
307: static int
308: intersectXzoid(pbox, pzoid, subzoid)
309: BoxRec *pbox;
310: xXTraps *pzoid;
311: xXTraps *subzoid;
312: {
313: int nzoids = 1;
314: register int tx, ty, i;
315: xXTraps *pz;
316:
317: pz = subzoid;
318: *pz = *pzoid;
319: if (pzoid->x1 < pbox->x1) {
320: pz->y1 = Ax2y (pbox->x1);
321: pz->y2 = Bx2y (pbox->x1);
322: pz->x1 = pbox->x1;
323: }
324: if (pzoid->x2 > pbox->x2) {
325: pz->y3 = Ax2y (pbox->x2);
326: pz->y4 = Bx2y (pbox->x2);
327: pz->x2 = pbox->x2;
328: }
329: /* did we just clip out the zoid? */
330: if (pz->y1 > pbox->y2 && pz->y3 > pbox->y2)
331: return (0);
332: if (pz->y2 < pbox->y1 && pz->y4 < pbox->y1)
333: return (0);
334: /* does zoid side A cross box side A? */
335: if ((pz->y1 < pbox->y1 && pz->y3 > pbox->y1)
336: || (pz->y1 > pbox->y1 && pz->y3 < pbox->y1)) {
337: tx = Ay2x(pbox->y1); /* side A crosses at [tx,pbox->y1] */
338: ty = Bx2y(tx);
339: *(pz+1) = *pz;
340: nzoids++;
341: /* does either subside of side B cross the box? */
342: if ((pz->y2 < pbox->y2 && ty > pbox->y2)
343: || (pz->y2 > pbox->y2 && ty < pbox->y2)) {
344: /* left subside crosses; keep right side in pz */
345: pz->x1 = tx;
346: pz->y1 = pbox->y1;
347: pz->y2 = ty;
348: pz++;
349: pz->x2 = tx;
350: pz->y3 = pbox->y1;
351: pz->y4 = ty;
352: } else {
353: /* keep left side in pz */
354: pz->x2 = tx;
355: pz->y3 = pbox->y1;
356: pz->y4 = ty;
357: pz++;
358: pz->x1 = tx;
359: pz->y1 = pbox->y1;
360: pz->y2 = ty;
361: }
362: } else
363: /* does zoid side A cross box side B? */
364: if ((pz->y1 < pbox->y2 && pz->y3 > pbox->y2)
365: || (pz->y1 > pbox->y2 && pz->y3 < pbox->y2)) {
366: tx = Ay2x(pbox->y2); /* side A crosses at [tx,pbox->y2] */
367: ty = Bx2y(tx);
368: /* pbox contains only a triangle. */
369: if (pz->y1 < pbox->y2) { /* left part of side A is inside */
370: pz->x2 = tx;
371: pz->y3 = pbox->y2;
372: pz->y4 = ty;
373: } else { /* right part of side A is inside */
374: pz->x1 = tx;
375: pz->y1 = pbox->y2;
376: pz->y2 = ty;
377: }
378: }
379: /* does zoid side B cross box side B? */
380: if ((pz->y2 < pbox->y2 && pz->y4 > pbox->y2)
381: || (pz->y2 > pbox->y2 && pz->y4 < pbox->y2)) {
382: tx = By2x(pbox->y2); /* side B crosses at [tx,pbox->y2] */
383: ty = Ax2y(tx);
384: *(pz+1) = *pz;
385: nzoids++;
386: /* side A doesn't cross; keep left side in pz */
387: pz->x2 = tx;
388: pz->y3 = ty;
389: pz->y4 = pbox->y2;
390: pz++;
391: pz->x1 = tx;
392: pz->y1 = ty;
393: pz->y2 = pbox->y2;
394: } else
395: /* does zoid side B cross box side A? */
396: if ((pz->y2 < pbox->y1 && pz->y4 > pbox->y1)
397: || (pz->y2 > pbox->y1 && pz->y4 < pbox->y1)) {
398: tx = By2x(pbox->y1); /* side B crosses at [tx,pbox->y1] */
399: ty = Ax2y(tx);
400: /* pbox contains only a triangle. */
401: if (pz->y2 > pbox->y1) { /* left part of side B is inside */
402: pz->x2 = tx;
403: pz->y3 = ty;
404: pz->y4 = pbox->y1;
405: } else { /* right part of side B is inside */
406: pz->x1 = tx;
407: pz->y1 = ty;
408: pz->y2 = pbox->y1;
409: }
410: }
411: /* finish the clipping, now that nothing crosses */
412: for (i = 0, pz = subzoid; i < nzoids; i++, pz++) {
413: if (pz->y1 < pbox->y1 || pz->y3 < pbox->y1) {
414: pz->y1 = pz->y3 = pbox->y1;
415: }
416: if (pz->y2 > pbox->y2 || pz->y4 > pbox->y2) {
417: pz->y2 = pz->y4 = pbox->y2;
418: }
419: }
420:
421: return (nzoids);
422: }
423:
424: /*
425: * Y aligned
426: *
427: * [x1,y1] [x2,y1]
428: * +-----------+
429: * A / \ B
430: * +---------------+
431: * [x3,y2] [x4,y2]
432: *
433: * A: y1-y2 y1-y2
434: * y = ----- x + (y1 - ----- x1)
435: * x1-x3 x1-x3
436: *
437: * B: y1-y2 y1-y2
438: * y = ----- x + (y1 - ----- x2)
439: * x2-x4 x2-x4
440: */
441: #undef Ax2y
442: #undef Bx2y
443: #undef Ay2x
444: #undef By2x
445: #define Ax2y(_x) (int) (((((long)pz->y1 - (long)pz->y2) * (long)(_x))/ \
446: ((long)pz->x1 - (long)pz->x3)) + (long)pz->y1 - \
447: ((((long)pz->y1 - (long)pz->y2)*(long)pz->x1)/ \
448: ((long)pz->x1 - (long)pz->x3)))
449: #define Bx2y(_x) (int) (((((long)pz->y1 - (long)pz->y2) * (long)(_x))/ \
450: ((long)pz->x2 - (long)pz->x4)) + (long)pz->y1 - \
451: ((((long)pz->y1 - (long)pz->y2)*(long)pz->x2)/ \
452: ((long)pz->x2 - (long)pz->x4)))
453: #define Ay2x(_y) (int) (((((long)pz->x1 - (long)pz->x3) * (long)(_y))/ \
454: ((long)pz->y1 - (long)pz->y2)) + (long)pz->x1 - \
455: ((((long)pz->x1 - (long)pz->x3)*(long)pz->y1)/ \
456: ((long)pz->y1 - (long)pz->y2)))
457: #define By2x(_y) (int) (((((long)pz->x2 - (long)pz->x4) * (long)(_y))/ \
458: ((long)pz->y1 - (long)pz->y2)) + (long)pz->x2 - \
459: ((((long)pz->x2 - (long)pz->x4)*(long)pz->y1)/ \
460: ((long)pz->y1 - (long)pz->y2)))
461: static int
462: intersectYzoid(pbox, pzoid, subzoid)
463: BoxRec *pbox;
464: xYTraps *pzoid;
465: xYTraps *subzoid;
466: {
467: int nzoids = 1;
468: register int tx, ty, i;
469: xYTraps *pz;
470:
471: pz = subzoid;
472: *pz = *pzoid;
473: if (pzoid->y1 < pbox->y1) {
474: pz->x1 = Ay2x (pbox->y1);
475: pz->x2 = By2x (pbox->y1);
476: pz->y1 = pbox->y1;
477: }
478: if (pzoid->y2 > pbox->y2) {
479: pz->x3 = Ay2x (pbox->y2);
480: pz->x4 = By2x (pbox->y2);
481: pz->y2 = pbox->y2;
482: }
483: /* did we just clip out the zoid? */
484: if (pz->x1 > pbox->x2 && pz->x3 > pbox->x2)
485: return (0);
486: if (pz->x2 < pbox->x1 && pz->x4 < pbox->x1)
487: return (0);
488: /* does zoid side A cross box side A? */
489: if ((pz->x1 < pbox->x1 && pz->x3 > pbox->x1)
490: || (pz->x1 > pbox->x1 && pz->x3 < pbox->x1)) {
491: ty = Ax2y(pbox->x1); /* side A crosses at [pbox->x1,ty] */
492: tx = By2x(ty);
493: *(pz+1) = *pz;
494: nzoids++;
495: /* does either subside of side B cross the box? */
496: if ((pz->x2 < pbox->x2 && tx > pbox->x2)
497: || (pz->x2 > pbox->x2 && tx < pbox->x2)) {
498: /* top subside crosses; keep bottom side in pz */
499: pz->y1 = ty;
500: pz->x1 = pbox->x1;
501: pz->x2 = tx;
502: pz++;
503: pz->y2 = ty;
504: pz->x3 = pbox->x1;
505: pz->x4 = tx;
506: } else {
507: /* keep top side in pz */
508: pz->y2 = ty;
509: pz->x3 = pbox->x1;
510: pz->x4 = tx;
511: pz++;
512: pz->y1 = ty;
513: pz->x1 = pbox->x1;
514: pz->x2 = tx;
515: }
516: } else
517: /* does zoid side A cross box side B? */
518: if ((pz->x1 < pbox->x2 && pz->x3 > pbox->x2)
519: || (pz->x1 > pbox->x2 && pz->x3 < pbox->x2)) {
520: ty = Ax2y(pbox->x2); /* side A crosses at [pbox->x2,ty] */
521: tx = By2x(ty);
522: /* pbox contains only a triangle. */
523: if (pz->x1 < pbox->x2) { /* top part of side A is inside */
524: pz->y2 = ty;
525: pz->x3 = pbox->x2;
526: pz->x4 = tx;
527: } else { /* bottom part of side A is inside */
528: pz->y1 = ty;
529: pz->x1 = pbox->x2;
530: pz->x2 = tx;
531: }
532: }
533: /* does zoid side B cross box side B? */
534: if ((pz->x2 < pbox->x2 && pz->x4 > pbox->x2)
535: || (pz->x2 > pbox->x2 && pz->x4 < pbox->x2)) {
536: ty = Bx2y(pbox->x2); /* side B crosses at [pbox->x2,ty] */
537: tx = Ay2x(ty);
538: *(pz+1) = *pz;
539: nzoids++;
540: /* side A doesn't cross; keep top side in pz */
541: pz->y2 = ty;
542: pz->x3 = tx;
543: pz->x4 = pbox->x2;
544: pz++;
545: pz->y1 = ty;
546: pz->x1 = tx;
547: pz->x2 = pbox->x2;
548: } else
549: /* does zoid side B cross box side A? */
550: if ((pz->x2 < pbox->x1 && pz->x4 > pbox->x1)
551: || (pz->x2 > pbox->x1 && pz->x4 < pbox->x1)) {
552: ty = Bx2y(pbox->x1); /* side B crosses at [pbox->x1,ty] */
553: tx = Ay2x(ty);
554: /* pbox contains only a triangle. */
555: if (pz->x2 > pbox->x1) { /* top part of side B is inside */
556: pz->y2 = ty;
557: pz->x3 = tx;
558: pz->x4 = pbox->x1;
559: } else { /* bottom part of side B is inside */
560: pz->y1 = ty;
561: pz->x1 = tx;
562: pz->x2 = pbox->x1;
563: }
564: }
565: /* finish the clipping, now that nothing crosses */
566: for (i = 0, pz = subzoid; i < nzoids; i++, pz++) {
567: if (pz->x1 < pbox->x1 || pz->x3 < pbox->x1) {
568: pz->x1 = pz->x3 = pbox->x1;
569: }
570: if (pz->x2 > pbox->x2 || pz->x4 > pbox->x2) {
571: pz->x2 = pz->x4 = pbox->x2;
572: }
573: }
574:
575: return (nzoids);
576: }
577:
578: static void
579: fillZoids(pDrawable, pGC, ntraps, traplist, alignment, pPaint)
580: DrawablePtr pDrawable;
581: GCPtr pGC;
582: int ntraps;
583: xXYTraps *traplist;
584: int alignment;
585: void (* pPaint) ();
586: {
587: /* rip off from mfbPolyFillRect() */
588: register BoxPtr pbox; /* pointer to current box in clip region */
589: int i; /* loop index */
590:
591: register xXYTraps *pzoid; /* pointer to current zoid to be filled */
592: int xorg, yorg; /* origin of window */
593: int nrectClip; /* number of rectangles in clip region */
594: short alu; /* gc filling function */
595: Pixrect *pTile; /* temporary for replropping scratch_pr */
596: Pixrect *pScratch; /* temporary for replropping scratch_pr */
597: mfbPrivGC *privGC; /* for reducing pointer dereferencing */
598:
599:
600: if (!(pGC->planemask & 1))
601: return;
602:
603: privGC = (mfbPrivGC *)((GCPtr)pGC->devPriv)->devPriv;
604: nrectClip = privGC->pCompositeClip->numRects;
605:
606: if (pDrawable->type == DRAWABLE_WINDOW)
607: {
608: xorg = ((WindowPtr)pDrawable)->absCorner.x;
609: yorg = ((WindowPtr)pDrawable)->absCorner.y;
610: (((PixmapPtr)(pDrawable->pScreen->devPrivate))->devPrivate);
611: /* translate the rectangle list */
612: for (i = 0, pzoid = traplist; i < ntraps; i++, pzoid++)
613: {
614: if (alignment == X_ALIGN) {
615: pzoid->Xt.x1 += xorg;
616: pzoid->Xt.x2 += xorg;
617: pzoid->Xt.y1 += yorg;
618: pzoid->Xt.y2 += yorg;
619: pzoid->Xt.y3 += yorg;
620: pzoid->Xt.y4 += yorg;
621: } else {
622: pzoid->Yt.y1 += yorg;
623: pzoid->Yt.y2 += yorg;
624: pzoid->Yt.x1 += xorg;
625: pzoid->Yt.x2 += xorg;
626: pzoid->Yt.x3 += xorg;
627: pzoid->Yt.x4 += xorg;
628: }
629: }
630: }
631: else
632: {
633: xorg = 0;
634: yorg = 0;
635: }
636:
637:
638: if((alu = pGC->alu) == GXnoop)
639: return; /* hey, this is easy! */
640:
641: switch (pGC->fillStyle)
642: {
643: case FillSolid:
644: alu = privGC->rop; /* used reduced ROP */
645: pScratch = (Pixrect *)NULL;
646: break;
647:
648: case FillStippled:
649: alu = privGC->rop; /* used reduced ROP */
650: pTile = getMpr(privGC->pRotatedStipple);
651: pScratch = getSubregion(pDrawable,
652: sunFbData[pDrawable->pScreen->myNum].scratch_pr);
653: tileRegion(pScratch, pTile);
654: pr_destroy(pTile);
655: break;
656:
657: case FillTiled:
658: pTile = getMpr(privGC->pRotatedTile);
659: pScratch = getSubregion(pDrawable,
660: sunFbData[pDrawable->pScreen->myNum].scratch_pr);
661: tileRegion(pScratch, pTile);
662: pr_destroy(pTile);
663: break;
664: }
665:
666: for (pzoid = traplist, --ntraps; ntraps >= 0; ++pzoid, --ntraps) {
667: BoxRec boxS, boxD;
668:
669: if (alignment == X_ALIGN)
670: XzoidBbox(pzoid, &boxS);
671: else
672: YzoidBbox(pzoid, &boxS);
673:
674: /* if lower right is out, the whole box is */
675: if ((boxS.x2 <= 0) || (boxS.y2 <= 0))
676: continue;
677:
678: /* clip left and top to drawable's origin */
679: if (boxS.x1 < 0)
680: boxS.x1 = 0;
681:
682: if (boxS.y1 < 0)
683: boxS.y1 = 0;
684:
685: /* If the box is completely out of this clip rectangle, ignore it.
686: * if it is completely within, draw it,
687: * otherwise, draw the part that is within this region
688: */
689: switch ((*pGC->pScreen->RectIn)
690: (privGC->pCompositeClip, &boxS))
691: {
692: case rgnOUT:
693: break;
694: case rgnIN:
695: {
696: /* Draw entire zoid */
697: (*pPaint)(sunFbData[pDrawable->pScreen->myNum].pr,
698: pzoid, pScratch, -xorg, -yorg);
699: break;
700: }
701: case rgnPART:
702: {
703: pbox = privGC->pCompositeClip->rects;
704: for (i = nrectClip; i > 0; --i, ++pbox) {
705: /* Clip box to each rect in turn
706: and draw the clipped box */
707:
708: boxD.x1 = max(boxS.x1, pbox->x1);
709: boxD.y1 = max(boxS.y1, pbox->y1);
710: boxD.x2 = min(boxS.x2, pbox->x2);
711: boxD.y2 = min(boxS.y2, pbox->y2);
712:
713: if(boxD.x1 < boxD.x2 && boxD.y1 < boxD.y2) {
714: /* Construct subzoid and draw it.
715: * Note: sometimes 3 subzoids are needed.
716: */
717: xXYTraps subzoid[3], *pz;
718: int nzoids;
719:
720: if (alignment == X_ALIGN) {
721: nzoids = intersectXzoid(&boxD, pzoid, subzoid);
722: } else {
723: nzoids = intersectYzoid(&boxD, pzoid, subzoid);
724: }
725: for (pz=subzoid; nzoids > 0; pz++, --nzoids) {
726: (*pPaint)(
727: sunFbData[pDrawable->pScreen->myNum].pr,
728: pz, pScratch, -xorg, -yorg);
729: }
730: }
731: }
732: break;
733: }
734: } /* switch RectIn */
735: } /* for each pzoid */
736: if (pScratch)
737: pr_destroy(pScratch);
738: }
739:
740: void
741: sunBW2SolidXZoids(pDraw, pGC, ntraps, traplist)
742: DrawablePtr pDraw;
743: GCPtr pGC;
744: int ntraps;
745: xXYTraps *traplist;
746: {
747: fillZoids(pDraw, pGC, ntraps, traplist, X_ALIGN, solidXzoid);
748: }
749:
750: void
751: sunBW2SolidYZoids(pDraw, pGC, ntraps, traplist)
752: DrawablePtr pDraw;
753: GCPtr pGC;
754: int ntraps;
755: xXYTraps *traplist;
756: {
757: fillZoids(pDraw, pGC, ntraps, traplist, Y_ALIGN, solidYzoid);
758: }
759:
760: void
761: sunBW2TiledXZoids(pDraw, pGC, ntraps, traplist)
762: DrawablePtr pDraw;
763: GCPtr pGC;
764: int ntraps;
765: xXYTraps *traplist;
766: {
767: fillZoids(pDraw, pGC, ntraps, traplist, X_ALIGN, tiledXzoid);
768: }
769:
770: void
771: sunBW2TiledYZoids(pDraw, pGC, ntraps, traplist)
772: DrawablePtr pDraw;
773: GCPtr pGC;
774: int ntraps;
775: xXYTraps *traplist;
776: {
777: fillZoids(pDraw, pGC, ntraps, traplist, Y_ALIGN, tiledYzoid);
778: }
779:
780: void
781: sunBW2StipXZoids(pDraw, pGC, ntraps, traplist)
782: DrawablePtr pDraw;
783: GCPtr pGC;
784: int ntraps;
785: xXYTraps *traplist;
786: {
787: fillZoids(pDraw, pGC, ntraps, traplist, X_ALIGN, stippledXzoid);
788: }
789:
790: void
791: sunBW2StipYZoids(pDraw, pGC, ntraps, traplist)
792: DrawablePtr pDraw;
793: GCPtr pGC;
794: int ntraps;
795: xXYTraps *traplist;
796: {
797: fillZoids(pDraw, pGC, ntraps, traplist, Y_ALIGN, stippledYzoid);
798: }
799: #endif ZOIDS
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.