![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to midash.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 midash.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: midash.c,v 1.7 87/09/10 09:48:55 rws Exp $ */
25: #include "miscstruct.h"
26: #include "mistruct.h"
27:
28: miDashPtr CheckDashStorage();
29:
30: /* return a list of DashRec. there will be an extra
31: entry at the end holding the last point of the polyline.
32: this means that the code that actually draws dashes can
33: get a pair of points for every dash. only the point in the last
34: dash record is useful; the other fields are not used.
35: nseg is the number of segments, not the number of points.
36:
37: example:
38:
39: dash1.start
40: dash2.start
41: dash3.start
42: last-point
43:
44: defines a list of segments
45: (dash1.pt, dash2.pt)
46: (dash2.pt, dash3.pt)
47: (dash3.pt, last-point)
48: and nseg == 3.
49:
50: NOTE:
51: EVEN_DASH == ~ODD_DASH
52: */
53:
54: miDashPtr
55: miDashLine(npt, ppt, nDash, pDash, offset, pnseg)
56: int npt;
57: DDXPointPtr ppt;
58: int nDash;
59: unsigned char *pDash;
60: int offset;
61: int *pnseg;
62: {
63: DDXPointRec pt1, pt2;
64: int lenCur; /* npt used from this dash */
65: int lenMax; /* npt in this dash */
66: int iDash = 0; /* index of current dash */
67: int which; /* EVEN_DASH or ODD_DASH */
68: miDashPtr pseg; /* list of dash segments */
69: miDashPtr psegBase; /* start of list */
70: int nseg = 0; /* number of dashes so far */
71: int nsegMax = 0; /* num segs we can fit in this list */
72:
73: int x, y, len;
74: int adx, ady, signdx, signdy;
75: int du, dv, e1, e2, e;
76:
77: lenCur = offset;
78: which = EVEN_DASH;
79: while(lenCur > pDash[iDash])
80: {
81: lenCur -= pDash[iDash];
82: iDash++;
83: if (iDash >= nDash)
84: iDash = 0;
85: which = ~which;
86: }
87: lenMax = pDash[iDash];
88:
89: psegBase = (miDashPtr)NULL;
90:
91: while(--npt)
92: {
93: pt1 = *ppt++;
94: pt2 = *ppt;
95:
96: adx = pt2.x - pt1.x;
97: ady = pt2.y - pt1.y;
98: signdx = sign(adx);
99: signdy = sign(ady);
100: adx = abs(adx);
101: ady = abs(ady);
102:
103: if (adx > ady)
104: {
105: du = adx;
106: dv = ady;
107: len = adx;
108: }
109: else
110: {
111: du = ady;
112: dv = adx;
113: len = ady;
114: }
115:
116: e1 = dv * 2;
117: e2 = e1 - 2*du;
118: e = e1 - du;
119: x = pt1.x;
120: y = pt1.y;
121:
122: nseg++;
123: pseg = CheckDashStorage(&psegBase, nseg, &nsegMax);
124: pseg->pt = pt1;
125: pseg->e1 = e1;
126: pseg->e2 = e2;
127: pseg->e = e;
128: pseg->which = which;
129: pseg->newLine = 1;
130:
131: while (len--)
132: {
133: if (adx > ady)
134: {
135: /* X_AXIS */
136: if (((signdx > 0) && (e < 0)) ||
137: ((signdx <=0) && (e <=0))
138: )
139: {
140: e += e1;
141: }
142: else
143: {
144: y += signdy;
145: e += e2;
146: }
147: x += signdx;
148: }
149: else
150: {
151: /* Y_AXIS */
152: if (((signdx > 0) && (e < 0)) ||
153: ((signdx <=0) && (e <=0))
154: )
155: {
156: e +=e1;
157: }
158: else
159: {
160: x += signdx;
161: e += e2;
162: }
163: y += signdy;
164: }
165:
166: lenCur++;
167: if (lenCur >= lenMax)
168: {
169: nseg++;
170: pseg = CheckDashStorage(&psegBase, nseg, &nsegMax);
171: pseg->pt.x = x;
172: pseg->pt.y = y;
173: pseg->e1 = e1;
174: pseg->e2 = e2;
175: pseg->e = e;
176: which = ~which;
177: pseg->which = which;
178: pseg->newLine = 0;
179:
180: /* move on to next dash */
181: iDash++;
182: if (iDash >= nDash)
183: iDash = 0;
184: lenMax = pDash[iDash];
185: lenCur = 0;
186: }
187: } /* while len-- */
188: } /* while --npt */
189:
190: *pnseg = nseg;
191: pseg = CheckDashStorage(&psegBase, nseg+1, &nsegMax);
192: pseg->pt = pt2;
193: return psegBase;
194: }
195:
196:
197: #define NSEGDELTA 16
198:
199: /* returns a pointer to the pseg[nseg-1], growing the storage as
200: necessary. this interface seems unnecessarily cumbersome.
201:
202: */
203:
204: static
205: miDashPtr
206: CheckDashStorage(ppseg, nseg, pnsegMax)
207: miDashPtr *ppseg; /* base pointer */
208: int nseg; /* number of segment we want to write to */
209: int *pnsegMax; /* size (in segments) of list so far */
210: {
211: if (nseg > *pnsegMax)
212: {
213: *pnsegMax += NSEGDELTA;
214: *ppseg = (miDashPtr)Xrealloc(*ppseg,
215: (*pnsegMax)*sizeof(miDashRec));
216: }
217: return(*ppseg+(nseg-1));
218: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.