1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <math.h>
5 #include "grap.h"
6 #include "y.tab.h"
7 
8 #define	MAXTICK	200
9 int	ntick	= 0;
10 double	tickval[MAXTICK];	/* tick values (one axis at a time */
11 char	*tickstr[MAXTICK];	/* and labels */
12 
13 int	tside	= 0;
14 int	tlist	= 0;		/* 1 => explicit values given */
15 int	toffside = 0;		/* no ticks on these sides */
16 int	goffside = 0;		/* no ticks on grid on these sides */
17 int	tick_dir = OUT;
18 double	ticklen	= TICKLEN;	/* default tick length */
19 int	autoticks = LEFT|BOT;
20 int	autodir = 0;		/* set LEFT, etc. if automatic ticks go in */
21 
22 void savetick(double f, char *s)	/* remember tick location and label */
23 {
24 	if (ntick >= MAXTICK)
25 		ERROR "too many ticks (%d)", MAXTICK FATAL;
26 	tickval[ntick] = f;
27 	tickstr[ntick] = s;
28 	ntick++;
29 }
30 
31 void dflt_tick(double f)
32 {
33 	if (f >= 0.0)
34 		savetick(f, tostring("%g"));
35 	else
36 		savetick(f, tostring("\\%g"));
37 }
38 
39 void tickside(int n)	/* remember which side these ticks/gridlines go on */
40 {
41 	tside |= n;
42 }
43 
44 void tickoff(int side)	/* remember explicit sides */
45 {
46 	toffside |= side;
47 }
48 
49 void gridtickoff(void)	/* turn grid ticks off on the side previously specified (ugh) */
50 {
51 	goffside = tside;
52 }
53 
54 void setlist(void)	/* remember that there was an explicit list */
55 {
56 	tlist = 1;
57 }
58 
59 void tickdir(int dir, double val, int explicit)	/* remember in/out [expr] */
60 {
61 	tick_dir = dir;
62 	if (explicit)
63 		ticklen = val;
64 }
65 
66 void ticks(void)		/* set autoticks after ticks statement */
67 {
68 	/* was there an explicit "ticks [side] off"? */
69 	if (toffside)
70 		autoticks &= ~toffside;
71 	/* was there an explicit list? (eg "ticks at ..." or "ticks from ...") */
72 	if (tlist) {
73 		if (tside & (BOT|TOP))
74 			autoticks &= ~(BOT|TOP);
75 		if (tside & (LEFT|RIGHT))
76 			autoticks &= ~(LEFT|RIGHT);
77 	}
78 	/* was there a side without a list? (eg "ticks left in") */
79 	if (tside && !tlist) {
80 		if (tick_dir == IN)
81 			autodir |= tside;
82 		if (tside & (BOT|TOP))
83 			autoticks = (autoticks & ~(BOT|TOP)) | (tside & (BOT|TOP));
84 		if (tside & (LEFT|RIGHT))
85 			autoticks = (autoticks & ~(LEFT|RIGHT)) | (tside & (LEFT|RIGHT));
86 	}
87 	tlist = tside = toffside = goffside = 0;
88 	tick_dir = OUT;
89 }
90 
91 double modfloor(double f, double t)
92 {
93 	t = fabs(t);
94 	return floor(f/t) * t;
95 }
96 
97 double modceil(double f, double t)
98 {
99 	t = fabs(t);
100 	return ceil(f/t) * t;
101 }
102 
103 double	xtmin, xtmax;	/* range of ticks */
104 double	ytmin, ytmax;
105 double	xquant, xmult;	/* quantization & scale for auto x ticks */
106 double	yquant, ymult;
107 double	lograt = 5;
108 
109 void do_autoticks(Obj *p)	/* make set of ticks for default coord only */
110 {
111 	double x, xl, xu, q;
112 
113 	if (p == NULL)
114 		return;
115 	fprintf(tfd, "Autoticks:\t# x %g..%g, y %g..%g",
116 		p->pt.x, p->pt1.x, p->pt.y, p->pt1.y);
117 	fprintf(tfd, ";   xt %g,%g, yt %g,%g, xq,xm = %g,%g, yq,ym = %g,%g\n",
118 		xtmin, xtmax, ytmin, ytmax, xquant, xmult, yquant, ymult);
119 	if ((autoticks & (BOT|TOP)) && p->pt1.x >= p->pt.x) {	/* make x ticks */
120 		q = xquant;
121 		xl = p->pt.x;
122 		xu = p->pt1.x;
123 		if (xl >= xu)
124 			dflt_tick(xl);
125 		else if ((p->log & XFLAG) && xu/xl >= lograt) {
126 			for (x = q; x < xu; x *= 10) {
127 				logtick(x, xl, xu);
128 				if (xu/xl <= 100) {
129 					logtick(2*x, xl, xu);
130 					logtick(5*x, xl, xu);
131 				}
132 			}
133 		} else {
134 			xl = modceil(xtmin - q/100, q);
135 			xu = modfloor(xtmax + q/100, q) + q/2;
136 			for (x = xl; x <= xu; x += q)
137 				dflt_tick(x);
138 		}
139 		tside = autoticks & (BOT|TOP);
140 		ticklist(p, 0);
141 	}
142 	if ((autoticks & (LEFT|RIGHT)) && p->pt1.y >= p->pt.y) {	/* make y ticks */
143 		q = yquant;
144 		xl = p->pt.y;
145 		xu = p->pt1.y;
146 		if (xl >= xu)
147 			dflt_tick(xl);
148 		else if ((p->log & YFLAG) && xu/xl >= lograt) {
149 			for (x = q; x < xu; x *= 10) {
150 				logtick(x, xl, xu);
151 				if (xu/xl <= 100) {
152 					logtick(2*x, xl, xu);
153 					logtick(5*x, xl, xu);
154 				}
155 			}
156 		} else {
157 			xl = modceil(ytmin - q/100, q);
158 			xu = modfloor(ytmax + q/100, q) + q/2;
159 			for (x = xl; x <= xu; x += q)
160 				dflt_tick(x);
161 		}
162 		tside = autoticks & (LEFT|RIGHT);
163 		ticklist(p, 0);
164 	}
165 }
166 
167 void logtick(double v, double lb, double ub)
168 {
169 	float slop = 1.0;	/* was 1.001 */
170 
171 	if (slop * lb <= v && ub >= slop * v)
172 		dflt_tick(v);
173 }
174 
175 Obj *setauto(void)	/* compute new min,max, and quant & mult */
176 {
177 	Obj *p, *q;
178 
179 	if ((q = lookup("lograt",0)) != NULL)
180 		lograt = q->fval;
181 	for (p = objlist; p; p = p->next)
182 		if (p->type == NAME && strcmp(p->name,dflt_coord) == 0)
183 			break;
184 	if (p) {
185 		if ((p->log & XFLAG) && p->pt1.x/p->pt.x >= lograt)
186 			autolog(p, 'x');
187 		else
188 			autoside(p, 'x');
189 		if ((p->log & YFLAG) && p->pt1.y/p->pt.y >= lograt)
190 			autolog(p, 'y');
191 		else
192 			autoside(p, 'y');
193 	}
194 	return p;
195 }
196 
197 void autoside(Obj *p, int side)
198 {
199 	double r, s, d, ub, lb;
200 
201 	if (side == 'x') {
202 		xtmin = lb = p->pt.x;
203 		xtmax = ub = p->pt1.x;
204 	} else {
205 		ytmin = lb = p->pt.y;
206 		ytmax = ub = p->pt1.y;
207 	}
208 	if (ub <= lb)
209 		return;	/* cop out on little ranges */
210 	d = ub - lb;
211 	r = s = 1;
212 	while (d * s < 10)
213 		s *= 10;
214 	d *= s;
215 	while (10 * r < d)
216 		r *= 10;
217 	if (r > d/3)
218 		r /= 2;
219 	else if (r <= d/6)
220 		r *= 2;
221 	if (side == 'x') {
222 		xquant = r / s;
223 	} else {
224 		yquant = r / s;
225 	}
226 }
227 
228 void autolog(Obj *p, int side)
229 {
230 	double r, s, t, ub, lb;
231 	int flg;
232 
233 	if (side == 'x') {
234 		xtmin = lb = p->pt.x;
235 		xtmax = ub = p->pt1.x;
236 		flg = p->coord & XFLAG;
237 	} else {
238 		ytmin = lb = p->pt.y;
239 		ytmax = ub = p->pt1.y;
240 		flg = p->coord & YFLAG;
241 	}
242 	for (s = 1; lb * s < 1; s *= 10)
243 		;
244 	lb *= s;
245 	ub *= s;
246 	for (r = 1; 10 * r < lb; r *= 10)
247 		;
248 	for (t = 1; t < ub; t *= 10)
249 		;
250 	if (side == 'x')
251 		xquant = r / s;
252 	else
253 		yquant = r / s;
254 	if (flg)
255 		return;
256 	if (ub / lb < 100) {
257 		if (lb >= 5 * r)
258 			r *= 5;
259 		else if (lb >= 2 * r)
260 			r *= 2;
261 		if (ub * 5 <= t)
262 			t /= 5;
263 		else if (ub * 2 <= t)
264 			t /= 2;
265 		if (side == 'x') {
266 			xtmin = r / s;
267 			xtmax = t / s;
268 		} else {
269 			ytmin = r / s;
270 			ytmax = t / s;
271 		}
272 	}
273 }
274 
275 void iterator(double from, double to, int op, double by, char *fmt)	/* create an iterator */
276 {
277 	double x;
278 
279 	/* should validate limits, etc. */
280 	/* punt for now */
281 
282 	dprintf("iterate from %g to %g by %g, op = %c, fmt=%s\n",
283 		from, to, by, op, fmt ? fmt : "");
284 	switch (op) {
285 	case '+':
286 	case ' ':
287 		for (x = from; x <= to + (SLOP-1) * by; x += by)
288 			if (fmt)
289 				savetick(x, tostring(fmt));
290 			else
291 				dflt_tick(x);
292 		break;
293 	case '-':
294 		for (x = from; x >= to; x -= by)
295 			if (fmt)
296 				savetick(x, tostring(fmt));
297 			else
298 				dflt_tick(x);
299 		break;
300 	case '*':
301 		for (x = from; x <= SLOP * to; x *= by)
302 			if (fmt)
303 				savetick(x, tostring(fmt));
304 			else
305 				dflt_tick(x);
306 		break;
307 	case '/':
308 		for (x = from; x >= to; x /= by)
309 			if (fmt)
310 				savetick(x, tostring(fmt));
311 			else
312 				dflt_tick(x);
313 		break;
314 	}
315 	if (fmt)
316 		free(fmt);
317 }
318 
319 void ticklist(Obj *p, int explicit)	/* fire out the accumulated ticks */
320 					/* 1 => list, 0 => auto */
321 {
322 	if (p == NULL)
323 		return;
324 	fprintf(tfd, "Ticks_%s:\n\tticklen = %g\n", p->name, ticklen);
325 	print_ticks(TICKS, explicit, p, "ticklen", "");
326 }
327 
328 void print_ticks(int type, int explicit, Obj *p, char *lenstr, char *descstr)
329 {
330 	int i, logflag, inside;
331 	char buf[100];
332 	double tv;
333 
334 	for (i = 0; i < ntick; i++)	/* any ticks given explicitly? */
335 		if (tickstr[i] != NULL)
336 			break;
337 	if (i >= ntick && type == TICKS)	/* no, so use values */
338 		for (i = 0; i < ntick; i++) {
339 			if (tickval[i] >= 0.0)
340 				sprintf(buf, "%g", tickval[i]);
341 			else
342 				sprintf(buf, "\\-%g", -tickval[i]);
343 			tickstr[i] = tostring(buf);
344 		}
345 	else
346 		for (i = 0; i < ntick; i++) {
347 			if (tickstr[i] != NULL) {
348 				sprintf(buf, tickstr[i], tickval[i]);
349 				free(tickstr[i]);
350 				tickstr[i] = tostring(buf);
351 			}
352 		}
353 	logflag = sidelog(p->log, tside);
354 	for (i = 0; i < ntick; i++) {
355 		tv = tickval[i];
356 		halfrange(p, tside, tv);
357 		if (logflag) {
358 			if (tv <= 0.0)
359 				ERROR "can't take log of tick value %g", tv FATAL;
360 			logit(tv);
361 		}
362 		if (type == GRID)
363 			inside = LEFT|RIGHT|TOP|BOT;
364 		else if (explicit)
365 			inside = (tick_dir == IN) ? tside : 0;
366 		else
367 			inside = autodir;
368 		if (tside & BOT)
369 			maketick(type, p->name, BOT, inside, tv, tickstr[i], lenstr, descstr);
370 		if (tside & TOP)
371 			maketick(type, p->name, TOP, inside, tv, tickstr[i], lenstr, descstr);
372 		if (tside & LEFT)
373 			maketick(type, p->name, LEFT, inside, tv, tickstr[i], lenstr, descstr);
374 		if (tside & RIGHT)
375 			maketick(type, p->name, RIGHT, inside, tv, tickstr[i], lenstr, descstr);
376 		if (tickstr[i]) {
377 			free(tickstr[i]);
378 			tickstr[i] = NULL;
379 		}
380 	}
381 	ntick = 0;
382 }
383 
384 void maketick(int type, char *name, int side, int inflag, double val, char *lab, char *lenstr, char *descstr)
385 {
386 	char *sidestr, *td;
387 
388 	fprintf(tfd, "\tline %s ", descstr);
389 	inflag &= side;
390 	switch (side) {
391 	case BOT:
392 	case 0:
393 		td = inflag ? "up" : "down";
394 		fprintf(tfd, "%s %s from (x_%s(%g),0)", td, lenstr, name, val);
395 		break;
396 	case TOP:
397 		td = inflag ? "down" : "up";
398 		fprintf(tfd, "%s %s from (x_%s(%g),frameht)", td, lenstr, name, val);
399 		break;
400 	case LEFT:
401 		td = inflag ? "right" : "left";
402 		fprintf(tfd, "%s %s from (0,y_%s(%g))", td, lenstr, name, val);
403 		break;
404 	case RIGHT:
405 		td = inflag ? "left" : "right";
406 		fprintf(tfd, "%s %s from (framewid,y_%s(%g))", td, lenstr, name, val);
407 		break;
408 	}
409 	fprintf(tfd, "\n");
410 	if (type == GRID && (side & goffside))	/* wanted no ticks on grid */
411 		return;
412 	sidestr = tick_dir == IN ? "start" : "end";
413 	if (lab != NULL) {
414 		/* BUG: should fix size of lab here */
415 		double wid = strlen(lab)/7.5 + (tick_dir == IN ? 0 : 0.1);	/* estimate width at 15 chars/inch */
416 		switch (side) {
417 		case BOT: case 0:
418 			/* can drop "box invis" with new pic */
419 			fprintf(tfd, "\tbox invis \"%s\" ht .25 wid 0 with .n at last line.%s",
420 				lab, sidestr);
421 			break;
422 		case TOP:
423 			fprintf(tfd, "\tbox invis \"%s\" ht .2 wid 0 with .s at last line.%s",
424 				lab, sidestr);
425 			break;
426 		case LEFT:
427 			fprintf(tfd, "\t\"%s \" wid %.2f rjust at last line.%s",
428 				lab, wid, sidestr);
429 			break;
430 		case RIGHT:
431 			fprintf(tfd, "\t\" %s\" wid %.2f ljust at last line.%s",
432 				lab, wid, sidestr);
433 			break;
434 		}
435 		/* BUG: works only if "down x" comes before "at wherever" */
436 		lab_adjust();
437 		fprintf(tfd, "\n");
438 	}
439 }
440 
441 Attr	*grid_desc	= 0;
442 
443 void griddesc(Attr *a)
444 {
445 	grid_desc = a;
446 }
447 
448 void gridlist(Obj *p)
449 {
450 	char *framestr;
451 
452 	if ((tside & (BOT|TOP)) || tside == 0)
453 		framestr = "frameht";
454 	else
455 		framestr = "framewid";
456 	fprintf(tfd, "Grid_%s:\n", p->name);
457 	tick_dir = IN;
458 	print_ticks(GRID, 0, p, framestr, desc_str(grid_desc));
459 	if (grid_desc) {
460 		freeattr(grid_desc);
461 		grid_desc = 0;
462 	}
463 }
464 
465 char *desc_str(Attr *a)	/* convert DOT to "dotted", etc. */
466 {
467 	static char buf[50], *p;
468 
469 	if (a == NULL)
470 		return p = "";
471 	switch (a->type) {
472 	case DOT:	p = "dotted"; break;
473 	case DASH:	p = "dashed"; break;
474 	case INVIS:	p = "invis"; break;
475 	default:	p = "";
476 	}
477 	if (a->fval != 0.0) {
478 		sprintf(buf, "%s %g", p, a->fval);
479 		return buf;
480 	} else
481 		return p;
482 }
483 
484 int
485 sidelog(int logflag, int side)	/* figure out whether to scale a side */
486 {
487 	if ((logflag & XFLAG) && ((side & (BOT|TOP)) || side == 0))
488 		return 1;
489 	else if ((logflag & YFLAG) && (side & (LEFT|RIGHT)))
490 		return 1;
491 	else
492 		return 0;
493 }