![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to milines.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 milines.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: milines.c,v 1.45 87/09/11 07:20:09 toddb Exp $ */
25:
26: /*
27: *
28: * Written by Todd Newman
29: * loosely based on long ago code and recent advice
30: * from Brian Kelleher, John Danskin
31: *
32: * Draw fat lines using a convex polygon routine.
33: */
34:
35: #include <stdio.h>
36: extern double hypot();
37: #include "X.h"
38: #include "windowstr.h"
39: #include "Xprotostr.h"
40: #include "gcstruct.h"
41: #include "scrnintstr.h"
42: #include "miscstruct.h"
43: #include "pixmapstr.h"
44: #include "mifpoly.h"
45: #include "mi.h"
46:
47: #define GCVALSALU 0
48: #define GCVALSFORE 1
49: #define GCVALSBACK 2
50: #define GCVALSWIDTH 3
51: #define GCVALSCAPSTYLE 4
52: #define GCVALSJOINSTYLE 5
53: #define GCVALSARCMODE 6
54: static int gcvals[] = {GXcopy, 1, 0, 0, 0, 0, ArcChord};
55:
56: #define SAMESIGN(a, b) ((((a) >= 0) && ((b) >= 0)) ||\
57: (((a) <= 0) && ((b) <= 0)))
58:
59: SppPointRec IntersectLines();
60:
61: /* MIWIDELINE - Public entry for PolyLine call
62: * handles 1 segment wide lines specially. Then it sets up the GC/Drawable
63: * based on the raster op. If the raster op is one that doesn't look at
64: * the destination, then we can draw directly onto the drawable. If the
65: * raster op does look at the destination (e.g., Xor), then we will draw
66: * with GXcopy onto a side bitmap and then squeegee the appropriate pattern
67: * (foreground, or tile, or stipple) onto the real drawable.
68: * We call one of two helpers (miMiter or miNonMiter) to actually draw
69: * the line segments. Which helper we call is determined by the device
70: * specific GC validator (e.g., mfbValidateGC).
71: */
72: void
73: miWideLine(pDrawable, pGC, mode, npt, pPts)
74: DrawablePtr pDrawable;
75: GCPtr pGC;
76: int mode;
77: int npt;
78: DDXPointPtr pPts;
79: {
80: int width = pGC->lineWidth;
81: SppPointPtr pSppPts, pSppT;
82: int gcflags, i, xOrg, yOrg, fTricky, arcmode;
83: int xMin, xMax, yMin, yMax, dx, dy;
84: DrawablePtr pDrawTo;
85: GCPtr pGCTo;
86:
87:
88: /* make everything absolute */
89: if (mode == CoordModePrevious)
90: {
91: DDXPointPtr pptTmp;
92: int nptTmp;
93:
94: pptTmp = pPts + 1;
95: nptTmp = npt - 1;
96: while (nptTmp--)
97: {
98: pptTmp->x += (pptTmp-1)->x;
99: pptTmp->y += (pptTmp-1)->y;
100: pptTmp++;
101: }
102: }
103: switch(pGC->alu)
104: {
105: case GXclear: /* 0 */
106: case GXcopy: /* src */
107: case GXcopyInverted: /* NOT src */
108: case GXset: /* 1 */
109: fTricky = FALSE;
110: xOrg = yOrg = 0;
111: pDrawTo = pDrawable;
112: pGCTo = pGC;
113: arcmode = pGCTo->arcMode;
114: if(arcmode != ArcChord)
115: {
116: DoChangeGC(pGCTo, GCArcMode, &gcvals[GCVALSARCMODE], 0);
117: ValidateGC(pDrawTo, pGCTo);
118: }
119:
120: break;
121: case GXand: /* src AND dst */
122: case GXandReverse: /* src AND NOT dst */
123: case GXandInverted: /* NOT src AND dst */
124: case GXnoop: /* dst */
125: case GXxor: /* src XOR dst */
126: case GXor : /* src OR dst */
127: case GXnor: /* NOT src AND NOT dst */
128: case GXequiv: /* NOT src XOR dst */
129: case GXinvert: /* NOT dst */
130: case GXorReverse: /* src OR NOT dst */
131: case GXorInverted: /* NOT src OR dst */
132: case GXnand: /* NOT src OR NOT dst */
133: fTricky = TRUE;
134: yMin = yMax = pPts[0].y;
135: xMin = xMax = pPts[0].x;
136:
137: for (i = 1; i < npt; i++)
138: {
139: xMin = min(xMin, pPts[i].x);
140: xMax = max(xMax, pPts[i].x);
141: yMin = min(yMin, pPts[i].y);
142: yMax = max(yMax, pPts[i].y);
143: }
144: xOrg = xMin - (width + 1)/2;
145: yOrg = yMin - (width + 1)/2;
146: dx = xMax - xMin + width + 1;
147: dy = yMax - yMin + width + 1;
148: pDrawTo = (DrawablePtr) (*pDrawable->pScreen->CreatePixmap)
149: (pDrawable->pScreen, dx, dy, 1, XYBitmap);
150: pGCTo = GetScratchGC(1, pDrawable->pScreen);
151: gcvals[GCVALSWIDTH] = width;
152: gcvals[GCVALSCAPSTYLE] = pGC->capStyle;
153: gcvals[GCVALSJOINSTYLE] = pGC->joinStyle;
154: gcflags = GCFunction|GCForeground|GCBackground|GCLineWidth |
155: GCCapStyle | GCJoinStyle;
156: if(pGCTo->arcMode != ArcChord)
157: gcflags |= GCArcMode;
158: arcmode = ArcChord;
159: DoChangeGC(pGCTo, gcflags, gcvals, 0);
160: ValidateGC(pDrawTo, pGCTo);
161: miClearDrawable(pDrawTo, pGCTo);
162:
163: }
164: pSppPts = (SppPointPtr) Xalloc((npt + 1) * sizeof(SppPointRec));
165: pSppT = pSppPts;
166: /* convert points to DblPts */
167: for(i = 0; i < npt; i++)
168: {
169: pSppT->x = (double) pPts->x;
170: pSppT++->y = (double) pPts++->y;
171:
172: }
173:
174: /* Draw the lines with the appropriate join style.
175: * We always wants caps drawn. */
176: (*pGCTo->LineHelper) (pDrawTo, pGCTo, TRUE, npt, pSppPts, xOrg, yOrg);
177:
178: if(arcmode != ArcChord)
179: {
180: DoChangeGC(pGCTo, GCArcMode, &arcmode, 0);
181: ValidateGC(pDrawTo, pGCTo);
182: }
183: if(fTricky)
184: {
185: if (pGC->miTranslate && (pDrawable->type == DRAWABLE_WINDOW) )
186: {
187: xOrg += ((WindowPtr)pDrawable)->absCorner.x;
188: yOrg += ((WindowPtr)pDrawable)->absCorner.y;
189: }
190:
191: (*pGC->PushPixels)(pGC, pDrawTo, pDrawable, dx, dy, xOrg, yOrg);
192: (*pDrawable->pScreen->DestroyPixmap)(pDrawTo);
193: FreeScratchGC(pGCTo);
194: }
195: }
196:
197: /* MIONESEGWIDE -- private helper for wide line code
198: * Draw wide line which only has 1 segment. This is so easy that it's worth
199: * special casing. Regardless of the raster op, this can't self-intersect.
200: * Also handles fluke cases where we're called with only 1 point
201: */
202: static
203: void
204: miOneSegWide(pDrawable, pGC, npt, pPts, caps, xOrg, yOrg)
205: DrawablePtr pDrawable;
206: GCPtr pGC;
207: int npt;
208: SppPointPtr pPts;
209: int caps, xOrg, yOrg;
210: {
211: SppPointRec PolyPoints[4];
212: int width = pGC->lineWidth;
213:
214: if(npt == 1)
215: {
216: Xrealloc(pPts, 2 * sizeof(SppPointRec));
217: pPts[1] = pPts[0];
218: }
219: if(caps && pGC->capStyle == CapProjecting)
220: {
221: if(PtEqual(pPts[0], pPts[1]))
222: {
223: pPts[0].y -= width/2.0;
224: pPts[1].y += width/2.0;
225: }
226: else
227: {
228: pPts[0] = miExtendSegment(pPts[0], pPts[1], width/2);
229: pPts[1] = miExtendSegment(pPts[1], pPts[0], width/2);
230: }
231: }
232: miGetPts(pPts[0], pPts[1], &PolyPoints[0],
233: &PolyPoints[1], &PolyPoints[2], &PolyPoints[3], width);
234: miFillSppPoly(pDrawable, pGC, 4, PolyPoints, -xOrg, -yOrg);
235: if(caps && pGC->capStyle == CapRound)
236: {
237: miRoundCap(pDrawable, pGC, pPts[0], pPts[1], PolyPoints[0],
238: PolyPoints[3], FirstEnd, xOrg, yOrg);
239: miRoundCap(pDrawable, pGC, pPts[1], pPts[0], PolyPoints[2],
240: PolyPoints[1], SecondEnd, xOrg, yOrg);
241: }
242: }
243:
244: /* MIMITER -- helper for wide line code, stuffed into GC.lineHelper by
245: * validation routine
246: * draw wide polylines by finding the polygon that outlines
247: * each wide line segment, and drawing that. Uses GC's fill polygon routine.
248: *
249: * internal vertexes are joined with a mitre as in PostScript.
250: * vertices at the beginning and end of the polyline
251: * are given the appropriate end unless they meet at the same point in which
252: * case they are mitred together. */
253:
254: void
255: miMiter (pDraw, pGC, caps, npt, pPts, xOrg, yOrg)
256: DrawablePtr pDraw;
257: GCPtr pGC;
258: int caps;
259: int npt;
260: SppPointPtr pPts;
261: int xOrg, yOrg;
262: {
263: int width = pGC->lineWidth;
264: SppPointRec PolyPoints[4], FirstEdge[2];
265: SppPointRec p1, p2, p3, p4, p5, p6, p7, p8;
266: int edges_match, i,
267: capStyle = pGC->capStyle;
268:
269: /*
270: * special case length 1 polyline
271: */
272: if(npt <= 2)
273: {
274: miOneSegWide(pDraw, pGC, npt, pPts, caps, xOrg, yOrg);
275: return;
276: }
277: miGetPts(pPts[0], pPts[1], &p1, &p2, &p3, &p4, width);
278:
279: /*
280: * start on first edge of first point
281: */
282: if (PtEqual(pPts[0], pPts[npt-1]))
283: {
284: /*
285: * edges match so mitre them
286: */
287: edges_match = 1;
288: miGetPts(pPts[npt-2], pPts[npt-1], &p5, &p6, &p7, &p8, width);
289:
290: PolyPoints[3] = IntersectLines(p1, p2, p5, p6);
291: PolyPoints[2] = IntersectLines(p3, p4, p7, p8);
292:
293: FirstEdge[0] = PolyPoints[3];
294: FirstEdge[1] = PolyPoints[2];
295: }
296: else
297: {
298: edges_match = 0;
299: PolyPoints[3] = p1;
300: PolyPoints[2] = p4;
301: if (caps && capStyle == CapProjecting)
302: {
303: pPts[0] = miExtendSegment(pPts[0], pPts[1], width/2);
304: miGetPts(pPts[0], pPts[1], &p1, &p2, &p3, &p4, width);
305: pPts[npt-1] = miExtendSegment(pPts[npt-1], pPts[npt-2], width/2);
306: }
307: else if (caps && capStyle == CapRound)
308: {
309: miRoundCap(pDraw, pGC, pPts[0], pPts[1], p1, p4, FirstEnd,
310: xOrg, yOrg);
311: miGetPts(pPts[npt-1], pPts[npt-2], &p5, &p6, &p7, &p8, width);
312: miRoundCap(pDraw, pGC, pPts[npt-1], pPts[npt-2], p5, p8, FirstEnd,
313: xOrg, yOrg);
314: }
315: }
316:
317: for (i = 1; i < (npt - 1); i++)
318: {
319: /*
320: * find the next edge
321: * build a polygon out of the next edge and the last one
322: * send the polygon
323: * bump to next
324: */
325: miGetPts(pPts[i], pPts[i+1], &p5, &p6, &p7, &p8, width);
326:
327: PolyPoints[0] = PolyPoints[3];
328: PolyPoints[1] = PolyPoints[2];
329: PolyPoints[2] = IntersectLines(p4, p3, p7, p8);
330: PolyPoints[3] = IntersectLines(p1, p2, p5, p6);
331:
332: miFillSppPoly(pDraw, pGC, 4, PolyPoints, -xOrg, -yOrg);
333:
334: p1 = p5; p2 = p6; p3 = p7; p4 = p8;
335:
336: }
337:
338: PolyPoints[0] = PolyPoints[3];
339: PolyPoints[1] = PolyPoints[2];
340:
341: if (edges_match)
342: {
343: PolyPoints[2] = FirstEdge[1];
344: PolyPoints[3] = FirstEdge[0];
345: }
346: else
347: {
348: miGetPts(pPts[npt-2], pPts[npt-1], &p5, &p6, &p7, &p8, width);
349: PolyPoints[2] = p7;
350: PolyPoints[3] = p6;
351: }
352:
353: miFillSppPoly(pDraw, pGC, 4, PolyPoints, -xOrg, -yOrg);
354: }
355:
356: /* MINOTMITER -- helper for wide line code, stuffed into GC.lineHelper by
357: * validation routine
358: *
359: * internal vertexes are joined with a bevel or rounded joint as in PostScript.
360: * vertices at the beginning and end of the polyline
361: * are given the appropriate end unless they meet at the same point in which
362: * case they are drawn with the appropriate join. */
363:
364: typedef struct {
365: int c;
366: SppPointRec v0, v1, v2, v3, v4;
367: SppPointRec p1, p2, p3, p4;
368: } POLYLINEINFO;
369:
370: void
371: miNotMiter (pDraw, pGC, caps, npt, pPts, xOrg, yOrg)
372: DrawablePtr pDraw;
373: GCPtr pGC;
374: int caps;
375: int npt;
376: SppPointPtr pPts;
377: int xOrg, yOrg;
378: {
379: int i, c,
380: width = pGC->lineWidth,
381: capStyle = pGC->capStyle,
382: joinStyle = pGC->joinStyle;
383: Bool edges_match;
384: SppPointRec FirstEdge[4], /* 2 extra for special npt == 2 */
385: wedge[3],
386: p, p1, p2, p3, p4, p5, p6, p7, p8, center;
387: POLYLINEINFO *plinfo;
388:
389: /* special case length 1 polyline */
390: if(npt <= 2)
391: {
392: miOneSegWide(pDraw, pGC, npt, pPts, caps, xOrg, yOrg);
393: return;
394: }
395: if(!(plinfo = (POLYLINEINFO *) ALLOCATE_LOCAL(npt * sizeof(POLYLINEINFO))))
396: return;
397: miGetPts(pPts[0], pPts[1], &p1, &p2, &p3, &p4, width);
398: /* save the points, in case this is hard */
399: plinfo[0].p1 = p1;
400: plinfo[0].p2 = p2;
401: plinfo[0].p3 = p3;
402: plinfo[0].p4 = p4;
403:
404: /*
405: * If ends meet, calculate angle of final intersection and points
406: * of intersection for it.
407: */
408: if(PtEqual(pPts[0], pPts[npt-1]))
409: {
410: edges_match = TRUE;
411: miGetPts(pPts[npt-2], pPts[npt-1], &p5, &p6, &p7, &p8, width);
412:
413: c = (pPts[0].x - pPts[npt-2].x)*(pPts[1].y - pPts[0].y) -
414: (pPts[1].x - pPts[0].x)*(pPts[0].y - pPts[npt-2].y);
415: plinfo[0].c = c;
416:
417: if(c > 0) /* it's a clockwise turn */
418: {
419: p = IntersectLines(p1, p2, p5, p6);
420: plinfo[0].v0 = p4;
421: plinfo[0].v1 = p7;
422: plinfo[0].v2 = p;
423: FirstEdge[0] = p;
424: FirstEdge[1] = p7;
425: if(joinStyle == JoinRound)
426: {
427: center.x = (p4.x + p7.x)/2;
428: center.y = (p4.y + p7.y)/2;
429: miRoundCap(pDraw, pGC, center, p, p4, p7, NotEnd, xOrg, yOrg);
430: }
431: }
432: else if (c < 0) /* counterclockwise */
433: {
434: p = IntersectLines(p3, p4, p7, p8);
435: plinfo[0].v0 = p;
436: plinfo[0].v1 = p6;
437: plinfo[0].v2 = p1;
438: FirstEdge[0] = p6;
439: FirstEdge[1] = p;
440: if(joinStyle == JoinRound)
441: {
442: center.x = (p6.x + p1.x)/2;
443: center.y = (p6.y + p1.y)/2;
444: miRoundCap(pDraw, pGC, center, p, p1, p6, NotEnd, xOrg, yOrg);
445: }
446: }
447: else /* straight line intersection */
448: {
449: plinfo[0].v1 = p4;
450: plinfo[0].v2 = p1;
451: FirstEdge[0] = p6;
452: FirstEdge[1] = p7;
453:
454: }
455: }
456: else /* Ends don't meet */
457: {
458: if(caps)
459: {
460: if(capStyle == CapProjecting)
461: {
462: pPts[0] = miExtendSegment(pPts[0], pPts[1], width/2);
463: miGetPts(pPts[0], pPts[1], &p1, &p2, &p3, &p4, width);
464: plinfo[0].p1 = p1;
465: plinfo[0].p2 = p2;
466: plinfo[0].p3 = p3;
467: plinfo[0].p4 = p4;
468: pPts[npt-1] =
469: miExtendSegment(pPts[npt-1], pPts[npt-2], width/2);
470: } else if (capStyle == CapRound)
471: {
472: miRoundCap(pDraw, pGC, pPts[0], pPts[1], p1, p4, FirstEnd,
473: xOrg, yOrg);
474: miGetPts(pPts[npt-1], pPts[npt-2], &p5, &p6, &p7, &p8, width);
475: miRoundCap(pDraw, pGC, pPts[npt-1], pPts[npt-2], p5, p8,
476: FirstEnd, xOrg, yOrg);
477: }
478: }
479: edges_match = FALSE;
480: plinfo[0].c = 0; /* treat no connection as straight connection */
481: plinfo[0].v1 = p4;
482: plinfo[0].v2 = p1;
483:
484: }
485:
486: for (i = 1; i < (npt - 1); i++)
487: {
488: /* Find the point of intersection with the previous segment.
489: * Make sure it's on this segment */
490: if(plinfo[i-1].c > 0)
491: {
492: p = plinfo[i-1].v2;
493: }
494: else if (plinfo[i-1].c < 0)
495: {
496: p = plinfo[i-1].v0;
497: }
498: miGetPts(pPts[i], pPts[i+1], &p5, &p6, &p7, &p8, width);
499:
500: plinfo[i].p1 = p5;
501: plinfo[i].p2 = p6;
502: plinfo[i].p3 = p7;
503: plinfo[i].p4 = p8;
504:
505: /* Figure out whether this angle turns clockwise or not by taking
506: * the total cross product of the three vectors formed by drawing
507: * vectors between the start of the previous segment and the start
508: * and end of this one */
509: if(i == npt - 1)
510: c = 0;
511: else
512: c = (pPts[i].x - pPts[i-1].x)*(pPts[i + 1].y - pPts[i].y) -
513: (pPts[i + 1].x - pPts[i].x)*(pPts[i].y - pPts[i-1].y);
514: plinfo[i].c = c;
515:
516:
517: if(c > 0) /* counter-clockwise */
518: {
519: p = IntersectLines(p1, p2, p5, p6);
520: plinfo[i].v0 = p8;
521: plinfo[i].v1 = p3;
522: plinfo[i].v2 = p;
523:
524: plinfo[i-1].v3 = p;
525: plinfo[i-1].v4 = p3;
526: if(joinStyle == JoinRound)
527: {
528: center.x = (p8.x + p3.x)/2;
529: center.y = (p8.y + p3.y)/2;
530: miRoundCap(pDraw, pGC, center, p, p8, p3, NotEnd, xOrg, yOrg);
531: }
532: }
533: else if (c < 0)
534: {
535: p = IntersectLines(p3, p4, p7, p8);
536: plinfo[i].v0 = p;
537: plinfo[i].v1 = p2;
538: plinfo[i].v2 = p5;
539:
540: plinfo[i-1].v3 = p2;
541: plinfo[i-1].v4 = p;
542: if(joinStyle == JoinRound)
543: {
544: center.x = (p2.x + p5.x)/2;
545: center.y = (p2.y + p5.y)/2;
546: miRoundCap(pDraw, pGC, center, p, p2, p5, NotEnd, xOrg, yOrg);
547: }
548: }
549: else /* straight line intersection */
550: {
551: plinfo[i].v1 = p2;
552: plinfo[i].v2 = p3;
553: plinfo[i-1].v3 = p2;
554: plinfo[i-1].v4 = p3;
555:
556: }
557:
558: p1 = p5; p2 = p6; p3 = p7; p4 = p8;
559: }
560:
561: /* Special case for final segment --
562: */
563: if(plinfo[i-1].c > 0)
564: {
565: p = plinfo[i-1].v2;
566: }
567: else if (plinfo[i-1].c < 0)
568: {
569: p = plinfo[i-1].v0;
570: }
571:
572: if (edges_match)
573: {
574: plinfo[i-1].v3 = FirstEdge[0];
575: plinfo[i-1].v4 = FirstEdge[1];
576: if(plinfo[i-1].c > 0)
577: {
578: p = plinfo[i-1].v2;
579: }
580: else if (plinfo[i-1].c < 0)
581: {
582: p = plinfo[i-1].v0;
583: }
584: }
585: else
586: {
587: miGetPts(pPts[npt-2], pPts[npt-1], &p5, &p6, &p7, &p8, width);
588: plinfo[i-1].v3 = p6;
589: plinfo[i-1].v4 = p7;
590: }
591: /*
592: * plinfo[i].c is 0 if there is no notch, either because the lines meet
593: * at 180 degrees, or the lines don't meet.
594: * Since we've set the alu to GCCopy, we don't worry about drawing
595: * points twice.
596: */
597: for(i = 0; i < (npt - 1); i++)
598: {
599: if(plinfo[i].c < 0)
600: {
601: wedge[1] = plinfo[i].p1;
602: wedge[2] = i ? plinfo[i - 1].p2 : plinfo[npt-2].p2;
603: }
604: else if (plinfo[i].c > 0)
605: {
606: wedge[1] = plinfo[i].p4;
607: wedge[2] = i ? plinfo[i-1].p3 : plinfo[npt-2].p3;
608: }
609:
610: if(plinfo[i].c)
611: {
612: wedge[0] = pPts[i];
613: /* Check that points aren't colinear */
614: if(!(wedge[0].x == wedge[1].x && wedge[1].x == wedge[2].x) &&
615: !(wedge[0].y == wedge[1].y && wedge[1].y == wedge[2].y))
616: {
617: miFillSppPoly(pDraw, pGC, 3, wedge, -xOrg, -yOrg);
618: }
619: }
620: miFillSppPoly(pDraw, pGC, 4, &plinfo[i].p1, -xOrg, -yOrg);
621: }
622: DEALLOCATE_LOCAL(plinfo);
623: }
624:
625: /* MIGETPTS -- helper function
626: * Get the corners of the polygon formed for a line with the endpoints
627: * p1In, p2In and the given width stuff the corners into *p1Out, *p2Out ...
628: * p1Out and p4Out are always on the same end as p1In.
629: */
630: void
631: miGetPts(p1In, p2In, p1Out, p2Out, p3Out, p4Out, width)
632: SppPointRec p1In, p2In;
633: SppPointPtr p1Out, p2Out, p3Out, p4Out;
634: int width;
635: {
636: double hyp; /* true distance of line (hypotenuse) */
637: double dx, dy;
638: double tmpdx, tmpdy;
639:
640: tmpdx = (double)(p1In.x - p2In.x);
641: tmpdy = (double)(p1In.y - p2In.y);
642:
643: hyp = hypot(tmpdx, tmpdy);
644: if (!ISZERO(hyp))
645: {
646: /* NOTE: the division by 2 must be done in floating point */
647: dy = (tmpdx * width/2.0) / hyp;
648: dx = (tmpdy * width/2.0) / hyp;
649:
650: p1Out->x = (p1In.x + dx);
651: p1Out->y = (p1In.y - dy);
652:
653: p2Out->x = (p2In.x + dx);
654: p2Out->y = (p2In.y - dy);
655:
656: p3Out->x = (p2In.x - dx);
657: p3Out->y = (p2In.y + dy);
658:
659: p4Out->x = (p1In.x - dx);
660: p4Out->y = (p1In.y + dy);
661: }
662: else
663: {
664: /* Bizarre answer, but it's what the spec calls for */
665: p1Out->x = p2Out->x = p1In.x - width/2.0;
666: p3Out->x = p4Out->x = p1In.x + width/2.0;
667: p1Out->y = p2Out->y = p3Out->y = p4Out->y = p1In.y;
668: }
669: }
670:
671: /* INTERSECTLINES -- private helper for line code
672: * Return the intersection of the line from p1 to p2 with
673: * the line from p3 to p4.
674: *
675: * First, reduce the lines to: y = m1x + b, and y = m2x + c.
676: * Then do the standard math.
677: */
678: static
679: SppPointRec
680: IntersectLines(p1, p2, p3, p4)
681: SppPointRec p1, p2, p3, p4;
682: {
683: SppPointRec i;
684: double m1, m2;
685: double b1, b2;
686: double dx1, dx2;
687: double tx;
688:
689: dx1 = p2.x - p1.x;
690: dx2 = p4.x - p3.x;
691:
692: if (ISZERO(dx1))
693: {
694: if (! ISZERO(dx2))
695: {
696: i.y = p3.y + ((p4.y - p3.y) * (p1.x - p3.x)) / (p4.x - p3.x);
697: i.x = p1.x;
698: }
699: else
700: i = p2;
701: }
702: else if (ISZERO(dx2))
703: {
704: i.y = p1.y + ((p2.y - p1.y) * (p3.x - p1.x)) / (p2.x - p1.x);
705: i.x = p3.x;
706: }
707: else
708: {
709: m1 = (p2.y - p1.y) / dx1;
710: m2 = (p4.y - p3.y) / dx2;
711:
712: b1 = p2.y - (m1 * p2.x);
713: b2 = p4.y - (m2 * p4.x);
714:
715: if (! ISEQUAL(m1, m2))
716: i.x = (tx = ((b2-b1) / (m1-m2)));
717: else
718: i.x = (tx = p2.x);
719:
720: i.y = m1 * tx + b1;
721: }
722: return(i);
723: }
724:
725:
726: /* MIEXTENDSEGMENT -- a private helper function
727: * Calcuate point p3 made by extending the segment backward (away from p2)
728: * by a length d */
729:
730: SppPointRec
731: miExtendSegment(p1, p2, d)
732: SppPointRec p1, p2;
733: int d;
734: {
735: SppPointRec p3;
736: double l, dx, dy, hypot();
737:
738: dx = p2.x - p1.x;
739: dy = p2.y - p1.y;
740: l = hypot(dx, dy);
741: if(!ISZERO(l))
742: {
743: p3.x = (p2.x - (l + d)/l * dx);
744: p3.y = (p2.y - (l + d)/l * dy);
745: }
746: else
747: {
748: ErrorF("ExtendSegment called with coincident points.\n");
749: p3 = p2;
750: }
751: return(p3);
752: }
753:
754: /* MIROUNDCAP -- a private helper function
755: * Put Rounded cap on end. pCenter is the center of this end of the line
756: * pEnd is the center of the other end of the line. pCorner is one of the
757: * two corners at this end of the line. It doesn't matter which of the two
758: * corners you give it. pOtherCorner is the other one.
759: */
760: void
761: miRoundCap(pDraw, pGC, pCenter, pEnd, pCorner, pOtherCorner, fLineEnd,
762: xOrg, yOrg)
763: DrawablePtr pDraw;
764: GCPtr pGC;
765: SppPointRec pCenter, pEnd;
766: SppPointRec pCorner, pOtherCorner;
767: int fLineEnd, xOrg, yOrg;
768: {
769: int c, i, signc, cpt;
770: double width;
771: double dx, dy, hypot();
772: xArc arc;
773: DDXPointPtr pArcPts;
774: SppPointPtr pPts;
775: int arcmode = pGC->arcMode;
776:
777: if(arcmode != ArcChord)
778: {
779: DoChangeGC(pGC, GCArcMode, &gcvals[GCVALSARCMODE], 0);
780: ValidateGC(pDraw, pGC);
781: }
782: if (fLineEnd == NotEnd)
783: {
784: dx = pCenter.x - pCorner.x;
785: dy = pCenter.y - pCorner.y;
786: width = hypot(dx, dy);
787: }
788: else
789: width = pGC->lineWidth;
790: if(PtEqual(pCenter, pEnd))
791: {
792: signc = 1;
793: }
794: else
795: {
796: c = (pCenter.x - pEnd.x) * (pCorner.y - pCenter.y) -
797: (pCorner.x - pCenter.x) * (pCenter.y - pEnd.y);
798: signc = -sign(c);
799: }
800:
801: /* These come back scaled by 64 and all ready to use */
802: arc.x = ROUNDTOINT(pCenter.x - width/2);
803: arc.y = ROUNDTOINT(pCenter.y - width/2);
804: arc.width = ROUNDTOINT(width);
805: arc.height = arc.width;
806: arc.angle1 = -PtToAngle(pCenter, pCorner);
807: arc.angle2 = -signc * 180 * 64;
808: pArcPts = (DDXPointPtr)NULL;
809: if( cpt = miGetArcPts(&arc, 0, &pArcPts))
810: {
811: /* by drawing with miFillSppPoly and setting the endpoints of the arc
812: * to be the corners, we assure that the cap will meet up with the
813: * rest of the line */
814: pPts = (SppPointPtr) Xalloc(cpt * sizeof(SppPointRec));
815: for(i = 1; i < cpt -1; i++)
816: {
817: pPts[i].x = (double) pArcPts[i].x;
818: pPts[i].y = (double) pArcPts[i].y;
819: }
820: pPts[0] = pCorner;
821: pPts[cpt - 1] = pOtherCorner;
822: miFillSppPoly(pDraw, pGC, cpt, pPts, -xOrg, -yOrg);
823: Xfree((char *)pArcPts);
824: Xfree((char *)pPts);
825: if(arcmode != ArcChord)
826: {
827: DoChangeGC(pGC, GCArcMode, &arcmode, 0);
828: ValidateGC(pDraw, pGC);
829: }
830: }
831: }
832:
833: /* these are from <math.h>, but I'm told some systems don't have math.h Psi! */
834: extern double sqrt(), cos(), sin(), atan();
835: #define M_PI 3.14159265358979323846
836: #define M_PI_2 1.57079632679489661923
837:
838: /* PTTOANGLE -- a private helper function
839: * Given two points, compute the slope of the line segment
840: * Result is in radians * 64
841: */
842: static
843: int
844: PtToAngle(c, p)
845: SppPointRec c, p;
846: {
847: double dx, dy, theta;
848:
849: dx = p.x - c.x;
850: dy = p.y - c.y;
851: if(dx == 0)
852: {
853: theta = (dy > 0) ? M_PI_2 : -M_PI_2;
854: }
855: else
856: theta =(atan(dy/dx));
857: if(dx < 0)
858: theta += M_PI;
859: theta = (theta * 64 * 180/M_PI);
860: return(ROUNDTOINT(theta));
861: }
862:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.