[unix-history] / usr / src / local / ditroff / ditroff.okeeffe / pic / print.c

#ifndef lint
static char sccsid[] = "@(#)print.c	2.1 (CWI) 85/07/23";
#endif lint
#include	<stdio.h>
#include	"pic.h"
#include	"y.tab.h"
print()
{
	obj *p;
	int i, j, k, m;
	float x0, y0, x1, y1, ox, oy, dx, dy, ndx, ndy;

	for (i = 0; i < nobj; i++) {
		p = objlist[i];
		ox = p->o_x;
		oy = p->o_y;
		if (p->o_count >= 1)
			x1 = p->o_val[0];
		if (p->o_count >= 2)
			y1 = p->o_val[1];
		m = p->o_mode;
		switch (p->o_type) {
		case TROFF:
			troff(text[p->o_nt1].t_val);
			break;
		case BOX:
		case BLOCK:
			move(ox, oy);
			dotext(p);	/* if there are any text strings */
			x0 = ox - x1 / 2;
			y0 = oy - y1 / 2;
			x1 = ox + x1 / 2;
			y1 = oy + y1 / 2;
			if (p->o_attr & INVIS || p->o_type == BLOCK)
				;	/* nothing at all */
			else if (p->o_attr & (DOTBIT|DASHBIT))
				dotbox(x0, y0, x1, y1, p->o_attr, p->o_ddval);
			else
				box(x0, y0, x1, y1);
			if (ishor(m))
				move(isright(m) ? x1 : x0, oy);	/* right side */
			else
				move(ox, isdown(m) ? y0 : y1);	/* bottom */
			break;
		case BLOCKEND:
			break;
		case CIRCLE:
			move(ox, oy);
			dotext(p);
			if ((p->o_attr & INVIS) == 0)
				circle(ox, oy, x1);
			if (ishor(m))
				move(ox + isright(m) ? x1 : -x1, oy);
			else
				move(ox, oy + isup(m) ? x1 : -x1);
			break;
		case ELLIPSE:
			move(ox, oy);
			dotext(p);
			if ((p->o_attr & INVIS) == 0)
				ellipse(ox, oy, x1, y1);
			if (ishor(m))
				move(ox + isright(m) ? x1 : -x1, oy);
			else
				move(ox, oy - isdown(m) ? y1 : -y1);
			break;
		case ARC:
			move(ox, oy);
			dotext(p);
			if (p->o_attr & HEAD1)
				arrow(x1 - (y1 - oy), y1 + (x1 - ox),
				      x1, y1, p->o_val[4], p->o_val[5], p->o_val[5]/p->o_val[6]/2, p->o_nhead);
                        if (p->o_attr & INVIS)
                                /* probably wrong when it's cw */
                                move(x1, y1);
                        else
				arc(ox, oy, x1, y1, p->o_val[2], p->o_val[3]);
			if (p->o_attr & HEAD2)
				arrow(p->o_val[2] + p->o_val[3] - oy, p->o_val[3] - (p->o_val[2] - ox),
				      p->o_val[2], p->o_val[3], p->o_val[4], p->o_val[5], -p->o_val[5]/p->o_val[6]/2, p->o_nhead);
			if (p->o_attr & CW_ARC)
				move(x1, y1);	/* because drawn backwards */
			break;
		case LINE:
		case ARROW:
		case SPLINE:
			move((ox + x1)/2, (oy + y1)/2);	/* center */
			dotext(p);
			if (p->o_attr & HEAD1)
				arrow(ox + p->o_val[5], oy + p->o_val[6], ox, oy, p->o_val[2], p->o_val[3], 0.0, p->o_nhead);
                        if (p->o_attr & INVIS)
                                move(x1, y1);
			else if (p->o_type == SPLINE)
				spline(ox, oy, p->o_val[4], &p->o_val[5]);
			else {
				dx = ox;
				dy = oy;
				for (k=0, j=5; k < p->o_val[4]; k++, j += 2) {
					ndx = dx + p->o_val[j];
					ndy = dy + p->o_val[j+1];
					if (p->o_attr & (DOTBIT|DASHBIT))
						dotline(dx, dy, ndx, ndy, p->o_attr, p->o_ddval);
					else
						line(dx, dy, ndx, ndy);
					dx = ndx;
					dy = ndy;
				}
			}
			if (p->o_attr & HEAD2) {
				dx = ox;
				dy = oy;
				for (k = 0, j = 5; k < p->o_val[4] - 1; k++, j += 2) {
					dx += p->o_val[j];
					dy += p->o_val[j+1];
				}
				arrow(dx, dy, x1, y1, p->o_val[2], p->o_val[3], 0.0, p->o_nhead);
			}
			break;
		case MOVE:
		case TEXT:
			move(ox, oy);
			dotext(p);
			break;
		}
	}
}

dotline(x0, y0, x1, y1, ddtype, ddval) /* dotted line */
	float x0, y0, x1, y1;
	int ddtype;
	float ddval;
{
	static float prevval = 0.05;	/* 20 per inch by default */
	int i, numdots;
	double a, b, sqrt(), dx, dy;

	if (ddval == 0)
		ddval = prevval;
	prevval = ddval;
	/* don't save dot/dash value */
	dx = x1 - x0;
	dy = y1 - y0;
	if (ddtype & DOTBIT) {
		numdots = sqrt(dx*dx + dy*dy) / prevval + 0.5;
		if (numdots > 0)
			for (i = 0; i <= numdots; i++) {
				a = (float) i / (float) numdots;
				move(x0 + (a * dx), y0 + (a * dy));
				dot();
			}
	} else if (ddtype & DASHBIT) {
		double d, dashsize, spacesize;
		d = sqrt(dx*dx + dy*dy);
		if (d <= 2 * prevval) {
			line(x0, y0, x1, y1);
			return;
		}
		numdots = d / (2 * prevval) + 1;	/* ceiling */
		dashsize = prevval;
		spacesize = (d - numdots * dashsize) / (numdots - 1);
		for (i = 0; i < numdots-1; i++) {
			a = i * (dashsize + spacesize) / d;
			b = a + dashsize / d;
			line(x0 + (a*dx), y0 + (a*dy), x0 + (b*dx), y0 + (b*dy));
			a = b;
			b = a + spacesize / d;
			move(x0 + (a*dx), y0 + (a*dy));
		}
		line(x0 + (b * dx), y0 + (b * dy), x1, y1);
	}
	prevval = 0.05;
}

dotbox(x0, y0, x1, y1, ddtype, ddval)	/* dotted or dashed box */
	float x0, y0, x1, y1;
	int ddtype;
	float ddval;
{
	dotline(x0, y0, x1, y0, ddtype, ddval);
	dotline(x1, y0, x1, y1, ddtype, ddval);
	dotline(x1, y1, x0, y1, ddtype, ddval);
	dotline(x0, y1, x0, y0, ddtype, ddval);
}

dotext(p)	/* print text strings of p in proper vertical spacing */
	obj *p;
{
	int i, nhalf;

	nhalf = p->o_nt2 - p->o_nt1 - 1;
	for (i = p->o_nt1; i < p->o_nt2; i++) {
		label(text[i].t_val, text[i].t_type, nhalf);
		nhalf -= 2;
	}
}
Commit	Line	Data
4a7a11d3	1	#ifndef lint
ff32afa0	2	static char sccsid[] = "@(#)print.c 2.1 (CWI) 85/07/23";
4a7a11d3	3	#endif lint
4a7a11d3 JA	4	#include <stdio.h>
	5	#include "pic.h"
	6	#include "y.tab.h"
4a7a11d3 JA	7	print()
4a7a11d3 JA	8	{
ff32afa0 JA	9	obj *p;
ff32afa0 JA	10	int i, j, k, m;
4a7a11d3 JA	11	float x0, y0, x1, y1, ox, oy, dx, dy, ndx, ndy;
	12
	13	for (i = 0; i < nobj; i++) {
4a7a11d3 JA	14	p = objlist[i];
	15	ox = p->o_x;
	16	oy = p->o_y;
	17	if (p->o_count >= 1)
	18	x1 = p->o_val[0];
	19	if (p->o_count >= 2)
	20	y1 = p->o_val[1];
	21	m = p->o_mode;
	22	switch (p->o_type) {
	23	case TROFF:
	24	troff(text[p->o_nt1].t_val);
	25	break;
	26	case BOX:
	27	case BLOCK:
	28	move(ox, oy);
	29	dotext(p); /* if there are any text strings */
	30	x0 = ox - x1 / 2;
	31	y0 = oy - y1 / 2;
	32	x1 = ox + x1 / 2;
	33	y1 = oy + y1 / 2;
	34	if (p->o_attr & INVIS \|\| p->o_type == BLOCK)
	35	; /* nothing at all */
ff32afa0 JA	36	else if (p->o_attr & (DOTBIT\|DASHBIT))
ff32afa0 JA	37	dotbox(x0, y0, x1, y1, p->o_attr, p->o_ddval);
4a7a11d3	38	else
ff32afa0	39	box(x0, y0, x1, y1);
4a7a11d3 JA	40	if (ishor(m))
	41	move(isright(m) ? x1 : x0, oy); /* right side */
	42	else
	43	move(ox, isdown(m) ? y0 : y1); /* bottom */
	44	break;
	45	case BLOCKEND:
	46	break;
4a7a11d3 JA	47	case CIRCLE:
	48	move(ox, oy);
	49	dotext(p);
	50	if ((p->o_attr & INVIS) == 0)
	51	circle(ox, oy, x1);
	52	if (ishor(m))
	53	move(ox + isright(m) ? x1 : -x1, oy);
	54	else
	55	move(ox, oy + isup(m) ? x1 : -x1);
	56	break;
	57	case ELLIPSE:
	58	move(ox, oy);
	59	dotext(p);
	60	if ((p->o_attr & INVIS) == 0)
	61	ellipse(ox, oy, x1, y1);
	62	if (ishor(m))
	63	move(ox + isright(m) ? x1 : -x1, oy);
	64	else
	65	move(ox, oy - isdown(m) ? y1 : -y1);
	66	break;
	67	case ARC:
	68	move(ox, oy);
	69	dotext(p);
	70	if (p->o_attr & HEAD1)
	71	arrow(x1 - (y1 - oy), y1 + (x1 - ox),
ff32afa0	72	x1, y1, p->o_val[4], p->o_val[5], p->o_val[5]/p->o_val[6]/2, p->o_nhead);
4a7a11d3 JA	73	if (p->o_attr & INVIS)
	74	/* probably wrong when it's cw */
	75	move(x1, y1);
	76	else
ff32afa0	77	arc(ox, oy, x1, y1, p->o_val[2], p->o_val[3]);
4a7a11d3 JA	78	if (p->o_attr & HEAD2)
4a7a11d3 JA	79	arrow(p->o_val[2] + p->o_val[3] - oy, p->o_val[3] - (p->o_val[2] - ox),
ff32afa0	80	p->o_val[2], p->o_val[3], p->o_val[4], p->o_val[5], -p->o_val[5]/p->o_val[6]/2, p->o_nhead);
4a7a11d3 JA	81	if (p->o_attr & CW_ARC)
	82	move(x1, y1); /* because drawn backwards */
	83	break;
	84	case LINE:
	85	case ARROW:
	86	case SPLINE:
	87	move((ox + x1)/2, (oy + y1)/2); /* center */
	88	dotext(p);
	89	if (p->o_attr & HEAD1)
ff32afa0	90	arrow(ox + p->o_val[5], oy + p->o_val[6], ox, oy, p->o_val[2], p->o_val[3], 0.0, p->o_nhead);
4a7a11d3 JA	91	if (p->o_attr & INVIS)
	92	move(x1, y1);
	93	else if (p->o_type == SPLINE)
	94	spline(ox, oy, p->o_val[4], &p->o_val[5]);
	95	else {
4a7a11d3 JA	96	dx = ox;
4a7a11d3 JA	97	dy = oy;
ff32afa0	98	for (k=0, j=5; k < p->o_val[4]; k++, j += 2) {
4a7a11d3 JA	99	ndx = dx + p->o_val[j];
4a7a11d3 JA	100	ndy = dy + p->o_val[j+1];
ff32afa0 JA	101	if (p->o_attr & (DOTBIT\|DASHBIT))
ff32afa0 JA	102	dotline(dx, dy, ndx, ndy, p->o_attr, p->o_ddval);
4a7a11d3	103	else
ff32afa0	104	line(dx, dy, ndx, ndy);
4a7a11d3 JA	105	dx = ndx;
	106	dy = ndy;
	107	}
	108	}
	109	if (p->o_attr & HEAD2) {
4a7a11d3 JA	110	dx = ox;
4a7a11d3 JA	111	dy = oy;
ff32afa0	112	for (k = 0, j = 5; k < p->o_val[4] - 1; k++, j += 2) {
4a7a11d3 JA	113	dx += p->o_val[j];
	114	dy += p->o_val[j+1];
	115	}
ff32afa0	116	arrow(dx, dy, x1, y1, p->o_val[2], p->o_val[3], 0.0, p->o_nhead);
4a7a11d3 JA	117	}
	118	break;
	119	case MOVE:
4a7a11d3 JA	120	case TEXT:
4a7a11d3 JA	121	move(ox, oy);
ff32afa0	122	dotext(p);
4a7a11d3 JA	123	break;
	124	}
	125	}
	126	}
	127
	128	dotline(x0, y0, x1, y1, ddtype, ddval) /* dotted line */
	129	float x0, y0, x1, y1;
	130	int ddtype;
	131	float ddval;
	132	{
	133	static float prevval = 0.05; /* 20 per inch by default */
	134	int i, numdots;
	135	double a, b, sqrt(), dx, dy;
	136
	137	if (ddval == 0)
	138	ddval = prevval;
	139	prevval = ddval;
	140	/* don't save dot/dash value */
	141	dx = x1 - x0;
	142	dy = y1 - y0;
ff32afa0	143	if (ddtype & DOTBIT) {
4a7a11d3 JA	144	numdots = sqrt(dxdx + dydy) / prevval + 0.5;
	145	if (numdots > 0)
	146	for (i = 0; i <= numdots; i++) {
	147	a = (float) i / (float) numdots;
	148	move(x0 + (a * dx), y0 + (a * dy));
	149	dot();
	150	}
ff32afa0	151	} else if (ddtype & DASHBIT) {
4a7a11d3 JA	152	double d, dashsize, spacesize;
	153	d = sqrt(dxdx + dydy);
	154	if (d <= 2 * prevval) {
	155	line(x0, y0, x1, y1);
	156	return;
	157	}
	158	numdots = d / (2 * prevval) + 1; /* ceiling */
	159	dashsize = prevval;
	160	spacesize = (d - numdots * dashsize) / (numdots - 1);
	161	for (i = 0; i < numdots-1; i++) {
	162	a = i * (dashsize + spacesize) / d;
	163	b = a + dashsize / d;
	164	line(x0 + (adx), y0 + (ady), x0 + (bdx), y0 + (bdy));
	165	a = b;
	166	b = a + spacesize / d;
	167	move(x0 + (adx), y0 + (ady));
	168	}
	169	line(x0 + (b * dx), y0 + (b * dy), x1, y1);
	170	}
	171	prevval = 0.05;
	172	}
	173
	174	dotbox(x0, y0, x1, y1, ddtype, ddval) /* dotted or dashed box */
	175	float x0, y0, x1, y1;
	176	int ddtype;
	177	float ddval;
	178	{
	179	dotline(x0, y0, x1, y0, ddtype, ddval);
	180	dotline(x1, y0, x1, y1, ddtype, ddval);
	181	dotline(x1, y1, x0, y1, ddtype, ddval);
	182	dotline(x0, y1, x0, y0, ddtype, ddval);
	183	}
	184
	185	dotext(p) /* print text strings of p in proper vertical spacing */
ff32afa0	186	obj *p;
4a7a11d3 JA	187	{
	188	int i, nhalf;
	189
	190	nhalf = p->o_nt2 - p->o_nt1 - 1;
	191	for (i = p->o_nt1; i < p->o_nt2; i++) {
	192	label(text[i].t_val, text[i].t_type, nhalf);
	193	nhalf -= 2;
	194	}
	195	}