![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to miarc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mi|
Return to miarc.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / mi |
1.1 root 1: /***********************************************************
2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
4:
5: All Rights Reserved
6:
7: Permission to use, copy, modify, and distribute this software and its
8: documentation for any purpose and without fee is hereby granted,
9: provided that the above copyright notice appear in all copies and that
10: both that copyright notice and this permission notice appear in
11: supporting documentation, and that the names of Digital or MIT not be
12: used in advertising or publicity pertaining to distribution of the
13: software without specific, written prior permission.
14:
15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
21: SOFTWARE.
22:
23: ******************************************************************/
24: /* $Header: miarc.c,v 1.46 87/08/31 16:39:34 toddb Exp $ */
25: /* Author: Todd Newman */
26: #include "X.h"
27: #include "Xprotostr.h"
28: #include "misc.h"
29: #include "gcstruct.h"
30: #include "scrnintstr.h"
31: #include "pixmapstr.h"
32: #include "windowstr.h"
33: #include "mifpoly.h"
34:
35: extern double sqrt(), cos(), sin(), atan();
36: /* these are from our <math.h>, but I'm told some systems don't have
37: * math.h and that they're not in all versions of math.h. Psi! */
38: #define M_PI 3.14159265358979323846
39: #define M_PI_2 1.57079632679489661923
40:
41:
42: #define SAMESIGN(a, b) ((((a) >= 0) && ((b) >= 0)) ||\
43: (((a) <= 0) && ((b) <= 0)))
44:
45: /* This contains the information needed to draw one arc of a polyarc.
46: * An array of them can be allocated if the polyarc has more than 1 part */
47: typedef struct
48: {
49: int cpt;
50: DDXPointPtr pPts;
51: } POLYARCINFO;
52:
53: #define GCValsFunction 0
54: #define GCValsForeground 1
55: #define GCValsBackground 2
56: #define GCValsLineWidth 3
57: #define GCValsCapStyle 4
58: #define GCValsJoinStyle 5
59: #define GCValsArcMode 6
60: static int gcvals[]= {GXcopy, 1, 0, 0, 0, 0, 0};
61:
62: /* MIPOLYARC -- Public entry for the polyarc call.
63: * Strategy: Similar in many ways to that for wide lines.
64: * In general, we will each arc segment as a polyline. (We can make the arc
65: * arbitrarily smooth by increasing the number of segments and shortening
66: * the length of each segment.)
67: * If there's only 1 arc, or if the arc is draw with zero width lines, we
68: * don't have to worry about the rasterop or join styles.
69: * Otherwise, we set up pDrawTo and pGCTo according to the rasterop, then
70: * draw using pGCTo and pDrawTo. If the raster-op was "tricky," that is,
71: * if it involves the destination, then we use PushPixels to move the bits
72: * from the scratch drawable to pDraw. (See the wide line code for a
73: * fuller explanation of this.)
74: */
75: void
76: miPolyArc(pDraw, pGC, narcs, parcs)
77: DrawablePtr pDraw;
78: GCPtr pGC;
79: int narcs;
80: xArc *parcs;
81: {
82: register int i, j;
83: register DDXPointPtr ppt; /* Points for the current arc */
84: register DDXPointPtr pAllPts; /* Points for all arcs so far */
85: register int cpt, /* count of points in current arc */
86: cptAll; /* count of points in all arcs */
87: DDXPointPtr pPts; /* Points for the current arc */
88: int xMin, xMax, yMin, yMax, yOrg, xOrg, dx, dy,
89: ifirst, ilast, count, gcmode, arcmode, width;
90: Bool fAllOne, fTricky;
91: PixmapPtr pDrawTo;
92: GCPtr pGCTo;
93: POLYARCINFO *polyarcs;
94: DDXPointRec LastPt;
95:
96:
97: width = pGC->lineWidth;
98: if(width == 0 || narcs == 1)
99: {
100: /* don't have to worry about overlap or joinstyles */
101: for(i = 0; i < narcs; i++)
102: {
103: pPts = (DDXPointPtr)NULL;
104: if( cpt = miGetArcPts(&parcs[i], 0, &pPts))
105: {
106: (*pGC->Polylines)(pDraw, pGC, CoordModeOrigin, cpt, pPts);
107: Xfree(pPts);
108: }
109: }
110: }
111: else
112: {
113: count = 0;
114: ifirst = 0;
115: fAllOne = FALSE;
116: pPts = (DDXPointPtr) NULL;
117: pAllPts = (DDXPointPtr) NULL;
118: polyarcs = (POLYARCINFO *)ALLOCATE_LOCAL(narcs * sizeof(POLYARCINFO));
119: if(!polyarcs)
120: return;
121:
122: xMin = yMin = MAXSHORT;
123: xMax = yMax = MINSHORT;
124:
125: /* Get all points for all the arcs. */
126: for(i = 0; i < narcs; i++)
127: {
128: pPts = (DDXPointPtr) NULL;
129: if((cpt = miGetArcPts(&parcs[i], 0, &pPts)) == 0)
130: {
131: /* One of the arcs was empty. Give up */
132: while(--i >= 0)
133: {
134: Xfree(polyarcs[i].pPts);
135: }
136: DEALLOCATE_LOCAL(polyarcs);
137: return;
138: }
139: polyarcs[i].cpt = cpt;
140: polyarcs[i].pPts = pPts;
141: ppt = pPts;
142: for(j = 0; j < cpt; j++)
143: {
144: xMin = min(xMin, ppt->x);
145: yMin = min(yMin, ppt->y);
146: xMax = max(xMax, ppt->x);
147: yMax = max(yMax, ppt->y);
148: ppt++;
149: }
150: }
151: /* Set up pDrawTo and pGCTo based on the rasterop */
152: switch(pGC->alu)
153: {
154: case GXclear: /* 0 */
155: case GXcopy: /* src */
156: case GXcopyInverted: /* NOT src */
157: case GXset: /* 1 */
158: fTricky = FALSE;
159: pDrawTo = (PixmapPtr) pDraw;
160: pGCTo = pGC;
161: if(pGCTo->arcMode != ArcChord)
162: {
163: arcmode = pGCTo->arcMode;
164: DoChangeGC(pGCTo, GCArcMode, &gcvals[GCValsArcMode], 0);
165: ValidateGC(pDrawTo, pGCTo);
166: }
167: else
168: arcmode = ArcChord;
169:
170: break;
171: case GXand: /* src AND dst */
172: case GXandReverse: /* src AND NOT dst */
173: case GXandInverted: /* NOT src AND dst */
174: case GXnoop: /* dst */
175: case GXxor: /* src XOR dst */
176: case GXor: /* src OR dst */
177: case GXnor: /* NOT src AND NOT dst */
178: case GXequiv: /* NOT src XOR dst */
179: case GXinvert: /* NOT dst */
180: case GXorReverse: /* src OR NOT dst */
181: case GXorInverted: /* NOT src OR dst */
182: case GXnand: /* NOT src OR NOT dst */
183: fTricky = TRUE;
184:
185: pGCTo = GetScratchGC(1, pDraw->pScreen);
186: gcvals[GCValsLineWidth] = pGC->lineWidth;
187: gcvals[GCValsCapStyle] = pGC->capStyle;
188: gcvals[GCValsJoinStyle] = pGC->joinStyle;
189:
190: /* Also what about arcmode?? */
191: gcmode = GCFunction | GCForeground | GCBackground | GCLineWidth |
192: GCCapStyle | GCJoinStyle;
193: DoChangeGC(pGCTo, gcmode, gcvals, 0);
194:
195: xOrg = xMin - (width + 1)/2;
196: yOrg = yMin - (width + 1)/2;
197: dx = xMax - xMin + width + 1;
198: dy = yMax - yMin + width + 1;
199: for(i = 0; i < narcs; i++)
200: {
201: cpt = polyarcs[i].cpt;
202: ppt = polyarcs[i].pPts;
203: for(j = 0; j < cpt; j++)
204: {
205: ppt->x -= xOrg;
206: ppt->y -= yOrg;
207: ppt++;
208: }
209: }
210:
211: /* allocate a 1 bit deep pixmap of the appropriate size, and
212: * validate it */
213: pDrawTo = (PixmapPtr)(*pDraw->pScreen->CreatePixmap)
214: (pDraw->pScreen, dx, dy, 1, XYBitmap);
215: ValidateGC(pDrawTo, pGCTo);
216: miClearDrawable(pDrawTo, pGCTo);
217: }
218:
219: ilast = narcs - 1;
220:
221: /* If the last arc joins with the first, find all the final arcs
222: * that join together and join them with the initial ones.
223: */
224: if(PtEqual(polyarcs[0].pPts[0],
225: polyarcs[ilast].pPts[polyarcs[ilast].cpt - 1]) )
226: {
227: count = 1;
228: while(PtEqual (polyarcs[ilast].pPts[0],
229: polyarcs[ilast - 1].pPts[polyarcs[ilast - 1].cpt - 1]) )
230: {
231: if(ilast <= 1)
232: {
233: fAllOne = TRUE;
234: break;
235: }
236: else
237: {
238: ilast--;
239: count++;
240: }
241: }
242: if(!fAllOne)
243: {
244: while(PtEqual(polyarcs[ifirst].pPts[polyarcs[ifirst].cpt -1],
245: polyarcs[ifirst + 1].pPts[0]))
246: ifirst++;
247: cptAll = polyarcs[ilast].cpt;
248: pAllPts = polyarcs[ilast].pPts;
249: polyarcs[ilast++].pPts = (DDXPointPtr) NULL;
250: for(; ilast < narcs; ilast++)
251: {
252: cpt = polyarcs[ilast].cpt;
253: pAllPts = (DDXPointPtr) Xrealloc(pAllPts,
254: (cptAll+cpt-1) * sizeof(DDXPointRec));
255: bcopy((char *) &polyarcs[ilast].pPts[1],
256: (char *) &pAllPts[cptAll],
257: (cpt - 1) * sizeof(DDXPointRec));
258: cptAll += cpt - 1;
259: }
260: for( i = 0; i <= ifirst; i++)
261: {
262: cpt = polyarcs[i].cpt;
263: pAllPts = (DDXPointPtr) Xrealloc(pAllPts,
264: (cptAll+cpt-1) * sizeof(DDXPointRec));
265: bcopy((char *) &polyarcs[i].pPts[1],
266: (char *) &pAllPts[cptAll],
267: (cpt - 1) * sizeof(DDXPointRec));
268: cptAll += cpt - 1;
269: }
270: (*pGCTo->Polylines)(pDrawTo, pGCTo, CoordModeOrigin,
271: cptAll, pAllPts);
272: /* Don't need to free pAllPts, because we're sure to
273: * Xrealloc it again */
274: if(fTricky)
275: {
276: (*pGC->PushPixels)(pGC, pDrawTo, pDraw, dx, dy,
277: xOrg, yOrg);
278: miClearDrawable(pDrawTo, pGCTo);
279: }
280: }
281: ifirst++;
282: }
283: narcs -= count;
284:
285: /* Now draw all the (remaining) arcs */
286: cptAll = 0;
287: for(i = ifirst; i < narcs; i++)
288: {
289: cpt = polyarcs[i].cpt;
290: pPts = polyarcs[i].pPts;
291:
292: if((i > ifirst) && PtEqual(pPts[0], LastPt))
293: {
294: pAllPts = (DDXPointPtr)
295: Xrealloc(pAllPts,
296: (cptAll-1 + cpt) * sizeof(DDXPointRec));
297: bcopy((char *)&pPts[1],
298: (char *)&pAllPts[cptAll],
299: (cpt - 1) * sizeof(DDXPointRec));
300: cptAll += cpt - 1;
301: }
302: else
303: {
304: /* Flush what we have so far and start collecting again */
305: if(cptAll > 0)
306: {
307: (*pGC->Polylines)(pDrawTo, pGCTo, CoordModeOrigin,
308: cptAll, pAllPts);
309: Xfree(pAllPts);
310: if(fTricky)
311: {
312: (*pGC->PushPixels)(pGC, pDrawTo, pDraw, dx, dy,
313: xOrg, yOrg);
314: miClearDrawable(pDrawTo, pGCTo);
315: }
316: }
317: cptAll = cpt;
318: pAllPts = pPts;
319: }
320: LastPt = pPts[cpt-1];
321: } /* end for each remaining arc */
322:
323:
324: if(cptAll > 0)
325: {
326: (*pGC->Polylines)(pDrawTo,pGCTo, CoordModeOrigin, cptAll, pAllPts);
327: Xfree(pAllPts);
328: }
329: if(fTricky)
330: (*pGC->PushPixels)(pGC, pDrawTo, pDraw, dx, dy, xOrg, yOrg);
331: for(i = 0; i < narcs; i++)
332: {
333: Xfree(polyarcs[i].pPts);
334: }
335: DEALLOCATE_LOCAL(polyarcs);
336: if(fTricky)
337: {
338: (*pGCTo->pScreen->DestroyPixmap)(pDrawTo);
339: FreeScratchGC(pGCTo);
340: }
341: else
342: if(arcmode != ArcChord)
343: {
344: DoChangeGC(pGCTo, GCArcMode, &arcmode, 0);
345: ValidateGC(pDrawTo, pGCTo);
346: }
347: }
348: }
349:
350: /* 360 degrees * 64 sub-degree positions */
351: #define FULLCIRCLE 64 * 360
352:
353: /* MIPOLYFILLARC -- The public entry for the PolyFillArc request.
354: * Since we don't have to worry about overlapping segments, we can just
355: * fill each arc as it comes. As above, we convert the arc into a set of
356: * line segments and then fill the resulting polygon.
357: */
358: void
359: miPolyFillArc(pDraw, pGC, narcs, parcs)
360: DrawablePtr pDraw;
361: GCPtr pGC;
362: int narcs;
363: xArc *parcs;
364: {
365: int i, cpt;
366: DDXPointPtr pPts;
367:
368: for(i = 0; i < narcs; i++)
369: {
370: /* We do this test every time because a full circle PieSlice isn't
371: * really a slice, but a full pie, and the Chord code (below) should
372: * handle it better */
373: if(pGC->arcMode == ArcPieSlice && parcs[i].angle2 < FULLCIRCLE)
374: {
375: cpt = 1;
376: pPts = (DDXPointPtr)Xalloc(sizeof(DDXPointRec));
377: if(cpt = miGetArcPts(&parcs[i], cpt, &pPts))
378: {
379: pPts[0].x = parcs[i].x + parcs[i].width/2;
380: pPts[0].y = parcs[i].y + parcs[i].height/2;
381: (*pGC->FillPolygon)(pDraw, pGC, Convex,
382: CoordModeOrigin, cpt + 1, pPts);
383: Xfree((char *) pPts);
384: }
385: }
386: else /* Chord */
387: {
388: pPts = (DDXPointPtr)NULL;
389: if(cpt = miGetArcPts(&parcs[i], 0, &pPts))
390: {
391: (*pGC->FillPolygon)(pDraw, pGC, Convex,
392: CoordModeOrigin, cpt, pPts);
393: Xfree((char *) pPts);
394: }
395: }
396: }
397: }
398:
399: /* MIGETARCPTS -- Converts an arc into a set of line segments -- a helper
400: * routine for arc and line (round cap) code.
401: * Returns the number of points in the arc. Note that it takes a pointer
402: * to a pointer to where it should put the points and an index (cpt).
403: * This procedure allocates the space necessary to fit the arc points.
404: * Sometimes it's convenient for those points to be at the end of an existing
405: * array. (For example, if we want to leave a spare point to make sectors
406: * instead of segments.) So we pass in the Xalloc()ed chunk that contains the
407: * array and an index saying where we should start stashing the points.
408: * If there isn't an array already, we just pass in a null pointer and
409: * count on Xrealloc() to handle the null pointer correctly.
410: */
411: int
412: miGetArcPts(parc, cpt, ppPts)
413: xArc *parc; /* points to an arc */
414: int cpt; /* number of points already in arc list */
415: DDXPointPtr *ppPts; /* pointer to pointer to arc-list -- modified */
416: {
417: double st, /* Start Theta, start angle */
418: et, /* End Theta, offset from start theta */
419: dt, /* Delta Theta, angle to sweep ellipse */
420: cdt, /* Cos Delta Theta, actually 2 cos(dt) */
421: x0, y0, /* the recurrence formula needs two points to start */
422: x1, y1,
423: x2, y2, /* this will be the new point generated */
424: xc, yc; /* the center point */
425: int count, i;
426: DDXPointPtr poly;
427:
428: /* The spec says that positive angles indicate counterclockwise motion.
429: * Given our coordinate system (with 0,0 in the upper left corner),
430: * the screen appears flipped in Y. The easiest fix is to negate the
431: * angles given */
432:
433: /* Throw out multiples of 360 degrees. */
434: i = -parc->angle1;
435: if(i < 0)
436: {
437: while (i < -FULLCIRCLE)
438: i += FULLCIRCLE;
439: }
440: else
441: {
442: while(i > FULLCIRCLE)
443: i -= FULLCIRCLE;
444: }
445: st = (double ) i;
446: st *= ((double)M_PI) / (64 * 180); /* convert to degrees, then to rads */
447:
448: i = -parc->angle2;
449: /* If it's more than one full rotation, make it exactly 1 rotation */
450: if(i > FULLCIRCLE || i < -FULLCIRCLE)
451: {
452: i = FULLCIRCLE;
453: }
454: et = (double) i;
455: et *= ((double)M_PI) / (64 * 180); /* convert to degrees, then to rads */
456:
457: /* Try to get a delta theta that is within 1/2 pixel. Then adjust it
458: * so that it divides evenly into the total.
459: * I'm just using cdt 'cause I'm lazy.
460: */
461: cdt = max(parc->width, parc->height)/2;
462: if(cdt <= 0)
463: return 0;
464: dt = ( (double)2.0 / sqrt(cdt));
465: count = et/dt;
466: count = abs(count) + 1;
467: dt = et/count;
468: count++;
469:
470: cdt = 2 * cos(dt);
471:
472: poly = (DDXPointPtr) Xrealloc(*ppPts, (count + cpt) * sizeof(DDXPointRec));
473: *ppPts = poly;
474:
475: xc = parc->width/2.0; /* store half width and half height */
476: yc = parc->height/2.0;
477:
478:
479: x0 = xc * cos(st);
480: y0 = yc * sin(st);
481: x1 = xc * cos(st + dt);
482: y1 = yc * sin(st + dt);
483: xc += parc->x; /* by adding initial point, these become */
484: yc += parc->y; /* the center point */
485: poly[cpt].x = ROUNDTOINT(xc + x0);
486: poly[cpt].y = ROUNDTOINT(yc + y0);
487: poly[cpt + 1].x = ROUNDTOINT(xc + x1);
488: poly[cpt + 1].y = ROUNDTOINT(yc + y1);
489:
490: for(i = 2; i < count; i++)
491: {
492: x2 = cdt * x1 - x0;
493: y2 = cdt * y1 - y0;
494: poly[cpt + i].x = ROUNDTOINT(xc + x2);
495: poly[cpt + i].y = ROUNDTOINT(yc + y2);
496:
497: x0 = x1; y0 = y1;
498: x1 = x2; y1 = y2;
499: }
500: /* adjust the last point */
501: poly[cpt +i -1].x = ROUNDTOINT(cos(st + et) * parc->width/2.0 + xc);
502: poly[cpt +i -1].y = ROUNDTOINT(sin(st + et) * parc->height/2.0 + yc);
503:
504: return(count);
505: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.