![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to print.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / picasso|
Return to print.c CVS log | Up to [Research Unix] / researchv10no / cmd / picasso |
1.1 root 1: /* Copyright (c) 1988 AT&T */
2: /* All Rights Reserved */
3:
4: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T */
5: /* The copyright notice above does not evidence any */
6: /* actual or intended publication of such source code. */
7:
8: /* @(#)picasso:print.c 1.0 */
9:
10: #include <assert.h>
11: #include <ctype.h>
12: #include <string.h>
13: #include "picasso.h"
14: #include "y.tab.h"
15:
16: extern int eqn_count;
17: int flyback;
18: int redo_gbox = 0;
19: int objcount = 0;
20:
21: print_buf()
22: {
23: int n;
24: obj *p;
25:
26: if (++objcount > objbuf) {
27: p = objhead->o_next;
28: if (p->o_type != BLOCK)
29: print_obj(p->o_layer, p);
30: else if (p->o_val[N_VAL].o == (obj *)0)
31: return;
32: else for (n = draftlayer; n <= top_layer; n++)
33: print_obj(n,p);
34: freenode(p);
35: }
36: }
37:
38: extern FILE *pipefp, *eqnfp;
39: extern char psfname[];
40:
41: print(c) /* show everything (above draft layers) */
42: int c;
43: {
44: int n;
45:
46: /* Added 10/15/90--DBK. Is there any reason NOT to do this? */
47: redo_gbox = 1;
48: if (pipefp) {
49: pclose(pipefp);
50: pipefp = NULL;
51: if ((eqnfp = fopen(psfname,"r")) == NULL)
52: fatal("cannot read eqn output");
53: }
54: flyback = (c == 'F');
55: if (c != 'N')
56: for (n = draftlayer; n <= top_layer; ++n)
57: print_layer(n);
58: if (eqnfp) {
59: fclose(eqnfp);
60: eqnfp = NULL;
61: eqn_count = 0;
62: unlink(psfname);
63: }
64: }
65:
66: print_layer(n) /* show contents of a single layer (maybe a draft layer) */
67: int n;
68: {
69: obj *p;
70:
71: for (p = objhead->o_next; p!= objtail; p = p->o_next)
72: p = print_obj(n, p);
73: }
74:
75: print_bnd(p, q) /* show everything (non-draft) between given bounds */
76: obj *p, *q;
77: {
78: int n;
79:
80: for (n = draftlayer; n <= top_layer; ++n)
81: print_layer_bnd(n, p, q);
82: }
83:
84: print_layer_bnd(n, p, q) /* show objects in layer n from p to q */
85: int n;
86: obj *p, *q;
87: {
88: obj *r;
89: float x0, y0, x1, y1, bnd[4];
90:
91: if (p->o_x < q->o_x)
92: { x0 = p->o_x; x1 = q->o_x; }
93: else
94: { x0 = q->o_x; x1 = p->o_x; }
95: if (p->o_y < q->o_y)
96: { y0 = p->o_y; y1 = q->o_y; }
97: else
98: { y0 = q->o_y; y1 = p->o_y; }
99:
100: for (r = objhead->o_next; r!= objtail; r = r->o_next)
101: if (r->o_x >= x0 && r->o_x <= x1
102: && r->o_y >= y0 && r->o_y <= y1)
103: r = print_obj(n, r);
104: }
105:
106: obj *print_obj(layer, p)
107: int layer;
108: obj *p;
109: {
110: double r, dx, dy, ox, oy, x0, y0, x1, y1;
111: obj *q;
112: int n;
113:
114: if (redo_gbox) {
115: float bnd[4];
116: Gbox[2] = Gbox[3] = -(Gbox[0] = Gbox[1] = 32767);
117: for (q = objhead->o_next; q != objtail; q = q->o_next) {
118: get_bounds(q, bnd, 1);
119: track_bounds (bnd[0], bnd[1], bnd[2], bnd[3]);
120: if (q->o_type == BLOCK)
121: q = q->o_val[N_VAL].o;
122: }
123: redo_gbox = 0;
124: }
125: openpl("");
126: if (p->o_type != BLOCK && p->o_layer != layer)
127: return p;
128: if (p->o_type <= TEXT && (p->o_mxx!=1 || p->o_myy!=1 || p->o_mxy!=0 ||
129: p->o_myx!=0 || p->o_mxt!=0 || p->o_myt!=0))
130: return print_xform(layer,p);
131:
132: ox = p->o_x;
133: oy = p->o_y;
134: if (p->o_type < TEXT && (p->o_attr & (FILLED | EDGED)))
135: chk_attrs (p);
136: switch (p->o_type) {
137:
138: case TROFF:
139: n = p->o_nt1;
140: if (text[n].t_type & EQNTXT)
141: puteqn(ox, oy, text[n].t_type, atoi(text[n].t_val));
142: else
143: troff(text[n].t_val);
144: return p;
145: case BLOCK:
146: for (q = p->o_next; q != p->o_val[N_VAL].o; q = q->o_next)
147: if (q->o_type <= TEXT || q->o_nt2 > q->o_nt1)
148: q = print_obj(layer,q);
149: p = q;
150: break;
151: case PSFILE:
152: puteps(p);
153: /* CAREFUL!! THIS FLOWS THROUGH INTO BOX!! */
154: case BOX:
155: if (p->o_attr & (FILLED|EDGED)) {
156: x0 = ox - p->o_wid/2; x1 = ox + p->o_wid/2;
157: y0 = oy - p->o_ht/2; y1 = oy + p->o_ht/2;
158: r = p->o_val[N_VAL].f;
159: box(x0, y0, x1, y1, r);
160: }
161: break;
162: case CIRCLE:
163: case ELLIPSE:
164: if (p->o_attr & (FILLED|EDGED))
165: ellipse(ox,oy,p->o_wid/2,0.,0.,p->o_ht/2,0.,2*M_PI,0);
166: break;
167: case SECTOR:
168: case ARC:
169: if (p->o_attr & (FILLED|EDGED)) {
170: register double ang1, ang2;
171:
172: if (p->o_attr & HEAD12) {
173: print_xform(layer, p);
174: break;
175: }
176: r = p->o_val[N_VAL+0].f;
177: x0 = p->o_val[N_VAL+2].f; /* starting point */
178: y0 = p->o_val[N_VAL+3].f;
179: x1 = p->o_val[N_VAL+4].f; /* ending point */
180: y1 = p->o_val[N_VAL+5].f;
181: ang1 = atan2(y0-oy, x0-ox);
182: ang2 = atan2(y1-oy, x1-ox);
183: ellipse(ox, oy, r, 0., 0., r, ang1, ang2, p->o_type);
184: }
185: break;
186: case LINE:
187: case ARROW:
188: case SPLINE:
189: if (p->o_attr & (FILLED|EDGED)) {
190: int c, nxy;
191:
192: if (p->o_attr & HEAD12) {
193: print_xform(layer, p);
194: break;
195: }
196: r = p->o_val[N_VAL+0].f;
197: nxy = p->o_val[N_VAL+3].f; /* segment count */
198: x0 = p->o_val[N_VAL+4].f; /* first point */
199: y0 = p->o_val[N_VAL+5].f;
200: x1 = p->o_val[N_VAL+4+2*nxy].f; /* last point */
201: y1 = p->o_val[N_VAL+5+2*nxy].f;
202: c = (x0 == x1 && y0 == y1); /* flags closure */
203: if (nxy == 1)
204: line(x0, y0, x1, y1);
205: else if (p->o_type == SPLINE)
206: spline(nxy, c, &p->o_val[N_VAL+4]);
207: else
208: pline (nxy, c, &p->o_val[N_VAL+4], r);
209: }
210: break;
211: }
212: if (p->o_nt1 < p->o_nt2)
213: objtext(ox, oy, p);
214: return p;
215: }
216:
217: obj *print_xform (layer,p)
218: int layer;
219: obj *p;
220: {
221: double r, ox, oy, dx, dy, x0, y0, x1, y1, M[4];
222: double b, tx0, ty0, tx1, ty1;
223: valtype *X;
224: obj *q;
225: int n;
226:
227: if (p->o_type == BLOCK) {
228: for (q = p->o_next; q != p->o_val[N_VAL].o; q = q->o_next)
229: if (q->o_type <= TEXT || q->o_nt2 > q->o_nt1)
230: q = print_xform(layer,q);
231: p = q;
232: }
233: if (p->o_layer != layer && p->o_type != BLOCK)
234: return p;
235: #if 0
236: if (p->o_type == TEXT) {
237: ox = Xformx(p->o_parent, 1, p->o_x, p->o_y);
238: oy = Xformy(p->o_parent, 0, p->o_x, p->o_y);
239: }
240: else {
241: #endif
242: ox = Xformx(p, 1, p->o_x, p->o_y);
243: oy = Xformy(p, 0, p->o_x, p->o_y);
244: #if 0
245: }
246: #endif
247: X = (valtype *)0;
248: if (p->o_type < TEXT && (p->o_attr & (FILLED | EDGED)))
249: chk_attrs (p);
250:
251: switch (p->o_type) {
252:
253: case TROFF:
254: n = p->o_nt1;
255: if (text[n].t_type & EQNTXT)
256: puteqn(ox, oy, text[n].t_type, atoi(text[n].t_val));
257: else
258: troff(text[n].t_val);
259: return p;
260: case PSFILE:
261: puteps(p);
262: /* CAREFUL!! THIS FLOWS THROUGH INTO BOX!! */
263: case BOX:
264: if (p->o_attr & (FILLED|EDGED)) {
265: if ((X = (valtype *)malloc(10*sizeof(valtype))) == NULL)
266: yyerror("out of room in print_xform");
267: r = p->o_val[N_VAL].f;
268: X[6].f = X[0].f = -(X[2].f = X[4].f = p->o_wid/2);
269: X[1].f = X[3].f = -(X[5].f = X[7].f = p->o_ht/2);
270: for (n = 0; n < 8; n += 2) {
271: x1 = ox + Linx(p, 0, X[n].f, X[n+1].f);
272: X[n+1].f = oy + Liny(p, 0, X[n].f, X[n+1].f);
273: X[n].f = x1;
274: }
275: X[n] = X[0]; X[++n] = X[1];
276: x1 = Linx(p, 0, r, 0.);
277: r = Liny(p, 0, r, 0.);
278: r = sqrt(x1 * x1 + r * r);
279: pline(4, 1, X, r);
280: }
281: break;
282: case CIRCLE:
283: case ELLIPSE:
284: if (p->o_attr & (FILLED|EDGED)) {
285: get_matrix(&x0, &y0, &x1, &y1);
286: x0 *= p->o_wid/2;
287: y0 *= p->o_wid/2;
288: x1 *= p->o_ht/2;
289: y1 *= p->o_ht/2;
290: ellipse(ox, oy, x0, y0, x1, y1, 0., 2*M_PI, 0);
291: }
292: break;
293: case SECTOR:
294: case ARC:
295: if (p->o_attr & (FILLED|EDGED)) {
296: register double ang1, ang2;
297: double xa, ya;
298: double dx0, dy0, dx1, dy1;
299:
300: r = p->o_val[N_VAL+0].f;
301: x0 = p->o_val[N_VAL+2].f; /* starting point */
302: y0 = p->o_val[N_VAL+3].f;
303: x1 = p->o_val[N_VAL+4].f; /* ending point */
304: y1 = p->o_val[N_VAL+5].f;
305: get_matrix(M, M+1, M+2, M+3);
306: /*
307: * If there are arrowheads and non-zero line thickness, we
308: * should adjust the end points so as to get nice arrowheads.
309: */
310: if (p->o_attr & HEAD12) {
311: dx0 = Xformx(p, 1, x0, y0); /* Remember */
312: dy0 = Xformy(p, 0, x0, y0); /* directions for */
313: dx1 = Xformx(p, 0, x1, y1); /* arrowheads */
314: dy1 = Xformy(p, 0, x1, y1);
315: /* in here we need to change the points used to compute
316: the angles. */
317: dx = p->o_val[N_VAL+8].f;
318: dy = p->o_val[N_VAL+9].f;
319: if (p->o_weight > 0.) {
320: double linex, liney, a;
321:
322: b = p->o_weight / 2 / p->o_val[N_VAL+8].f;
323: b *= sqrt(dx*dx + 4*dy*dy);
324: if (p->o_attr & HEAD2) {
325: linex = - (y1 - p->o_y);
326: liney = (x1 - p->o_x);
327: a = b / sqrt(linex*linex + liney*liney);
328: x1 -= a * linex;
329: y1 -= a * liney;
330: }
331: if (p->o_attr & HEAD1) {
332: linex = (y0 - p->o_y);
333: liney = - (x0 - p->o_x);
334: a = b / sqrt(linex*linex + liney*liney);
335: x0 -= a * linex;
336: y0 -= a * liney;
337: }
338: }
339: }
340: tx0 = Xformx(p, 1, x0, y0); /* transformed starting point */
341: ty0 = Xformy(p, 0, x0, y0);
342: tx1 = Xformx(p, 0, x1, y1); /* transformed ending point */
343: ty1 = Xformy(p, 0, x1, y1);
344: ang1 = atan2(ty0 - oy, tx0 - ox);
345: ang2 = atan2(ty1 - oy, tx1 - ox);
346:
347: dx = M[0] * M[3] - M[1] * M[2];
348: if (dx < 0) { /* reflection */
349: xa = ang1;
350: ang1 = ang2;
351: ang2 = xa;
352: M[0] = -M[0];
353: M[2] = -M[2];
354: }
355: ellipse(ox, oy, r*M[0], r*M[1], r*M[2], r*M[3],
356: ang1, ang2, p->o_type);
357:
358: if (p->o_attr & (HEAD1 | HEAD2)) {
359: ang1 = 0;
360: if (dx < 0) {
361: ang1 = M_PI;
362: dx = -dx;
363: }
364: dy = dx = sqrt(dx);
365: dx *= p->o_val[N_VAL+8].f;
366: dy *= p->o_val[N_VAL+9].f;
367: if (p->o_attr & HEAD1)
368: arrow(tx0-(dy0-oy), ty0+(dx0-ox), tx0, ty0,
369: dx, dy, dy/r/2 + ang1, p->o_attr);
370: if (p->o_attr & HEAD2)
371: arrow(tx1+(dy1-oy), ty1-(dx1-ox), tx1, ty1,
372: dx, dy, -dy/r/2 + ang1, p->o_attr);
373: }
374: }
375: break;
376: case LINE:
377: case ARROW:
378: case SPLINE:
379: if (p->o_attr & (FILLED|EDGED)) {
380: int c, i, nxy;
381:
382: r = p->o_val[N_VAL+0].f;
383: x1 = Linx(p, 0, r, 0.);
384: r = Liny(p, 0, r, 0.);
385: r = sqrt(x1 * x1 + r * r);
386: nxy = p->o_val[N_VAL+3].f; /* segment count */
387: X = (valtype *)malloc((2*nxy+2)*sizeof(valtype));
388: if (X == NULL)
389: yyerror("out of room in print_xform");
390: for (i = 0, n = N_VAL+4; i <= 2 * nxy; ) {
391: register double xx = p->o_val[n++].f,
392: yy = p->o_val[n++].f;
393: X[i++].f = Xformx(p, 0, xx, yy);
394: X[i++].f = Xformy(p, 0, xx, yy);
395: }
396: x0 = X[0].f;
397: y0 = X[1].f;
398: x1 = X[i-2].f;
399: y1 = X[i-1].f;
400: tx0 = ty0 = tx1 = ty1 = 0.;
401: n = 2 * nxy - 2;
402: if (p->o_attr & HEAD12) {
403: get_matrix(M, M+1, M+2, M+3);
404: /* DBK: I added the fabs to eliminate sqrt errors
405: * and make it same as xprint.c. 9/20/90 */
406: dy = dx = sqrt(fabs(M[0]*M[3] - M[1]*M[2]));
407: dx *= p->o_val[N_VAL+1].f;
408: dy *= p->o_val[N_VAL+2].f;
409: if (p->o_weight > 0.) {
410: double linex, liney, a;
411:
412: b = p->o_weight / 2 / p->o_val[N_VAL+1].f;
413: b *= sqrt(dx*dx + 4*dy*dy);
414: if (p->o_attr & HEAD2) {
415: linex = x1 - X[n].f;
416: liney = y1 - X[n+1].f;
417: a = b / sqrt(linex*linex + liney*liney);
418: tx1 = -a * linex;
419: ty1 = -a * liney;
420: x1 = X[n+2].f += tx1;
421: y1 = X[n+3].f += ty1;
422: }
423: if (p->o_attr & HEAD1) {
424: linex = x0 - X[2].f;
425: liney = y0 - X[3].f;
426: a = b / sqrt(linex*linex + liney*liney);
427: tx0 = -a * linex;
428: ty0 = -a * liney;
429: x0 = X[0].f += tx0;
430: y0 = X[1].f += ty0;
431: }
432: }
433: }
434: /* The first two args are just to give a direction to
435: * the second two. To make sure that the direction
436: * isn't reversed, adjust the first two by the same
437: * amount as we adjusted x1 and y1 above.
438: */
439: c = (x0 == x1 && y0 == y1); /* flags closure */
440: if (nxy == 1)
441: line(X[0].f, X[1].f, X[2].f, X[3].f);
442: else if (p->o_type == SPLINE)
443: spline(nxy, c, X);
444: else
445: pline (nxy, c, X, r);
446: if (p->o_attr & HEAD2) {
447: tx1 += X[n].f;
448: ty1 += X[n+1].f;
449: arrow(tx1, ty1, x1, y1, dx, dy, 0.0, p->o_attr);
450: }
451: if (p->o_attr & HEAD1) {
452: tx0 += X[2].f;
453: ty0 += X[3].f;
454: arrow(tx0, ty0, x0, y0, dx, dy, 0.0, p->o_attr);
455: }
456: }
457: break;
458: case TEXT:
459: tmp_xform(p);
460: #if 0
461: dotext(ox, oy, p);
462: #else
463: dotext(p->o_x, p->o_y, p);
464: #endif
465: undo_tmpx();
466: return p;
467: }
468: if (X)
469: free(X);
470: if (p->o_nt1 < p->o_nt2)
471: objtext(ox, oy, p);
472: return p;
473: }
474:
475: objtext(x, y, p)
476: double x, y;
477: obj *p;
478: {
479: double *bnd;
480: int i, t;
481:
482: t = text[p->o_nt1].t_type;
483: for (i = p->o_nt1; i < p->o_nt2; i++)
484: if (text[i].t_type != t)
485: break;
486: if (i >= p->o_nt2 && p->o_type != TEXT) { /* all strings same type */
487: bnd = text_bounds(p);
488: if (t & RJUST)
489: x += (bnd[2] - bnd[0]) / 2;
490: if (t & LJUST)
491: x -= (bnd[2] - bnd[0]) / 2;
492: }
493: dotext(x, y, p);
494: }
495:
496: dotext(x, y, p) /* print text strings of p in proper vertical spacing */
497: double x, y;
498: obj *p;
499: {
500: double h, v, w, dely;
501: int i, j, n, t;
502:
503: i = p->o_nt1;
504: j = text[i].t_line; /* sequence # of first line */
505: n = text[p->o_nt2-1].t_line - j; /* total number of lines (-1) */
506: v = abs(text[i].t_size) / (2 * pgscale);
507: dely = abs(text[i].t_space) / (2 * pgscale);
508: v = n * dely - v/2;
509: new_color(p->o_text);
510: for (h = w = 0; i < p->o_nt2; ++j, v -= 2*dely, h = w = 0) {
511: t = text[i].t_type;
512: if (t & ABOVE)
513: v += dely;
514: else if (t & BELOW)
515: v -= dely;
516: for (n = i; text[n].t_line == j; n++)
517: w += text[n].t_width*72/pgscale;
518: if (t & RJUST)
519: h = w;
520: else if (t & CENTER)
521: h = w/2;
522: newlabel(t, text[i].t_val, abs(text[i].t_font), x-h, y+v,
523: text[i].t_size / pgscale,
524: text[i].t_width * 72 / pgscale);
525: while (++i < n)
526: addlabel(text[i].t_type, text[i].t_val,
527: text[i].t_font, text[i].t_size / pgscale,
528: text[i].t_width * 72 / pgscale);
529: }
530: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.