![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to draw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / postscript / dpost|
Return to draw.c CVS log | Up to [Research Unix] / researchv10no / cmd / postscript / dpost |
1.1 root 1: /*
2: *
3: * Drawing routines used by dpost. Almost no real work is done here. Instead
4: * the required calculations are done in special Postscript procedures that
5: * include:
6: *
7: *
8: * Dl
9: *
10: * x1 y1 x y Dl -
11: *
12: * Starts a new path and then draws a line from the current point
13: * (x, y) to (x1, y1).
14: *
15: * De
16: *
17: * x y a b De -
18: *
19: * Starts a new path and then draws an ellipse that has its left side
20: * at the current point (x, y) and horizontal and vertical axes lengths
21: * given by a and b respectively.
22: *
23: * Da
24: *
25: * x y dx1 dy1 dx2 dy2 Da -
26: *
27: * Starts a new segment and then draws a circular arc from the current
28: * point (x, y) to (x + dx1 + dx2, y + dy1 + dy2). The center of the
29: * circle is at (x + dx1, y + dy1). Arcs always go counter-clockwise
30: * from the starting point to the end point.
31: *
32: * DA
33: *
34: * x y dx1 dy1 dx2 dy2 DA -
35: *
36: * Draws a clockwise arc from (x, y) to (x + dx1 + dx2, y + dy1 + dy2)
37: * with center at (x + dx1, y + dy1). Only needed when we're building
38: * large paths that use arcs and want to control the current point. The
39: * arguments passed to drawarc() will be whatever they would have been
40: * for a counter-clockwise arc, so we need to map them into appropriate
41: * arguments for PostScript's arcn operator. The mapping is,
42: *
43: * x = hpos + dx1' + dx2'
44: * y = vpos + dy1' + dy2'
45: * dx1 = -dx2'
46: * dy1 = -dy2'
47: * dx2 = -dx1'
48: * dy2 = -dy1'
49: *
50: * where primed values represent the drawarc() arguments and (hpos, vpos)
51: * is our current position.
52: *
53: * Ds
54: *
55: * x0 y0 x1 y1 x2 y2 Ds -
56: *
57: * Starts a new segment and then draws a quadratic spline connecting
58: * point ((x0 + x1)/2, (y0 + y1)/2) to ((x1 + x2)/2, (y1 + y2)/2).
59: * The points used in Postscript's curveto procedure are given by,
60: *
61: * x0' = (x0 + 5 * x1) / 6
62: * x1' = (x2 + 5 * x1) / 6
63: * x2' = (x1 + x2) / 2
64: *
65: * with similar equations for the y coordinates.
66: *
67: * By default all the PostScript drawing procedures begin with a newpath (just to
68: * be safe) and end with a stroke, which essentially isolates the path elements
69: * built by the drawing procedures. In order to accommodate big paths built from
70: * smaller pieces each of the PostScript drawing procedures can forced to retain
71: * the path that's being built. That's what happens in beginpath() when an "x X
72: * BeginPath" command is read. beginpath() sets the PostScript variable inpath to
73: * true, and that essentially eliminates the newpath/stroke pair that bracket the
74: * individual pieces. In that case the path is terminated and drawn when dpost
75: * reads an "x X DrawPath" command.
76: *
77: * Early versions of dpost included the PostScript drawing procedures as part of
78: * the prologue, and as a result they were included with every job, even if they
79: * were never used. This version has separated the drawing procedures from the
80: * default prologue (they're now in *drawfile) and only includes them if they're
81: * really needed, which is yet another convenient violation of page independence.
82: * Routine getdraw() is responsible for adding *drawfile to the output file, and
83: * if it can't read *drawfile it continues on as if nothing happened. That means
84: * everything should still work if you append *drawfile to *prologue and then
85: * delete *drawfile.
86: *
87: */
88:
89: #include <stdio.h>
90: #include <math.h>
91:
92: #include "gen.h" /* general purpose definitions */
93: #include "ext.h" /* external variable definitions */
94: #include "motion.h" /* positioning macros */
95:
96: int gotdraw = FALSE; /* TRUE when *drawfile has been added */
97: int gotbaseline = FALSE; /* TRUE after *baselinefile is added */
98: int inpath = FALSE; /* TRUE if we're putting pieces together */
99:
100: /*
101: *
102: * All these should be defined in file dpost.c.
103: *
104: */
105:
106: extern int hpos;
107: extern int vpos;
108: extern int encoding;
109: extern int maxencoding;
110: extern int realencoding;
111:
112: extern char *drawfile;
113: extern char *baselinefile;
114: extern FILE *tf;
115:
116: /*****************************************************************************/
117:
118: getdraw()
119:
120: {
121:
122: /*
123: *
124: * Responsible for making sure the PostScript drawing procedures are downloaded
125: * from *drawfile. Stuff is done at most once per job, and only if the job needs
126: * them. For now I've decided not to quit if we can't read the drawing file. That
127: * pretty much assumes an old version of prologue is being used that includes all
128: * the drawing procedures.
129: *
130: */
131:
132: if ( gotdraw == FALSE )
133: exportfile(drawfile);
134:
135: if ( tf == stdout )
136: gotdraw = TRUE;
137:
138: } /* End of getdraw */
139:
140: /*****************************************************************************/
141:
142: drawline(dx, dy)
143:
144: int dx, dy; /* endpoint is (hpos+dx, vpos+dy) */
145:
146: {
147:
148: /*
149: *
150: * Draws a line from (hpos, vpos) to (hpos+dx, vpos+dy), and leaves the current
151: * position at the endpoint.
152: *
153: */
154:
155: if ( dx == 0 && dy == 0 )
156: drawcirc(1);
157: else fprintf(tf, "%d %d %d %d Dl\n", hpos + dx, vpos + dy, hpos, vpos);
158:
159: if ( dobbox == TRUE ) {
160: cover((double)hpos, (double)-vpos);
161: cover((double)(hpos + dx), (double)-(vpos + dy));
162: } /* End if */
163:
164: hgoto(hpos+dx); /* where troff expects to be */
165: vgoto(vpos+dy);
166:
167: resetpos(); /* not sure where the printer is */
168:
169: } /* End of drawline */
170:
171: /*****************************************************************************/
172:
173: drawcirc(d)
174:
175: int d; /* diameter of the circle */
176:
177: {
178:
179: /*
180: *
181: * Draws a circle of diameter d with the left 'side' of the circle at the
182: * current point. After we're finished drawing we move the current position
183: * to the right side.
184: *
185: */
186:
187: drawellip(d, d);
188:
189: } /* End of drawcirc */
190:
191: /*****************************************************************************/
192:
193: drawellip(a, b)
194:
195: int a, b; /* axes lengths for the ellipse */
196:
197: {
198:
199: /*
200: *
201: * Draws an ellipse having axes lengths horizontally and vertically of a and
202: * b. The left side of the ellipse is at the current point. After we're done
203: * drawing the path we move the current position to the right side.
204: *
205: */
206:
207: if ( a == 0 && b == 0 )
208: return;
209:
210: fprintf(tf, "%d %d %d %d De\n", hpos, vpos, a, b);
211:
212: if ( dobbox == TRUE ) {
213: cover((double)hpos, (double)-(vpos + b/2));
214: cover((double)(hpos+a), (double)-(vpos - b/2));
215: } /* End if */
216:
217: hgoto(hpos + a); /* where troff expects to be */
218: vgoto(vpos);
219:
220: resetpos(); /* not sure where the printer is */
221:
222: } /* End of drawellip */
223:
224: /*****************************************************************************/
225:
226: drawarc(dx1, dy1, dx2, dy2, c)
227:
228: int dx1, dy1; /* vector from current pos to center */
229: int dx2, dy2; /* from center to end of the arc */
230: int c; /* clockwise if c is A */
231:
232: {
233:
234: /*
235: *
236: * If c isn't set to 'A' a counter-clockwise arc is drawn from the current point
237: * (hpos, vpos) to (hpos+dx1+dx2, vpos+dy1+dy2). The center of the circle is the
238: * point (hpos+dx1, vpos+dy1). If c is 'A' the arc goes clockwise from the point
239: * (hpos+dx1+dx2, vpos+dy1+dy2) to (hpos, vpos). Clockwise arcs are only needed
240: * if we're building a larger path out of pieces that include arcs, and want to
241: * have PostScript manage the path for us. Arguments (for a clockwise arc) are
242: * what would have been supplied if the arc was drawn in a counter-clockwise
243: * direction, and are converted to values suitable for use with PostScript's arcn
244: * operator.
245: *
246: */
247:
248: if ( (dx1 != 0 || dy1 != 0) && (dx2 != 0 || dy2 != 0) ) {
249: if ( c != 'A' )
250: fprintf(tf, "%d %d %d %d %d %d Da\n", hpos, vpos, dx1, dy1, dx2, dy2);
251: else fprintf(tf, "%d %d %d %d %d %d DA\n", hpos+dx1+dx2, vpos+dy1+dy2,
252: -dx2, -dy2, -dx1, -dy1);
253:
254: if ( dobbox == TRUE )
255: arc_extreme(dx1, dy1, dx2, dy2);
256: } /* End if */
257:
258: hgoto(hpos + dx1 + dx2); /* where troff expects to be */
259: vgoto(vpos + dy1 + dy2);
260:
261: resetpos(); /* not sure where the printer is */
262:
263: } /* End of drawarc */
264:
265: /*****************************************************************************/
266:
267: drawspline(fp, flag)
268:
269: FILE *fp; /* input for point list */
270: int flag; /* flag!=1 connect end points */
271:
272: {
273:
274: int x[100], y[100];
275: int i, N;
276:
277: /*
278: *
279: * Spline drawing routine for Postscript printers. The complicated stuff is
280: * handled by procedure Ds, which should be defined in the library file. I've
281: * seen wrong implementations of troff's spline drawing, so fo the record I'll
282: * write down the parametric equations and the necessary conversions to Bezier
283: * cubic splines (as used in Postscript).
284: *
285: *
286: * Parametric equation (x coordinate only):
287: *
288: *
289: * (x2 - 2 * x1 + x0) 2 (x0 + x1)
290: * x = ------------------ * t + (x1 - x0) * t + ---------
291: * 2 2
292: *
293: *
294: * The coefficients in the Bezier cubic are,
295: *
296: *
297: * A = 0
298: * B = (x2 - 2 * x1 + x0) / 2
299: * C = x1 - x0
300: *
301: *
302: * while the current point is,
303: *
304: * current-point = (x0 + x1) / 2
305: *
306: * Using the relationships given in the Postscript manual (page 121) it's easy to
307: * see that the control points are given by,
308: *
309: *
310: * x0' = (x0 + 5 * x1) / 6
311: * x1' = (x2 + 5 * x1) / 6
312: * x2' = (x1 + x2) / 2
313: *
314: *
315: * where the primed variables are the ones used by curveto. The calculations
316: * shown above are done in procedure Ds using the coordinates set up in both
317: * the x[] and y[] arrays.
318: *
319: * A simple test of whether your spline drawing is correct would be to use cip
320: * to draw a spline and some tangent lines at appropriate points and then print
321: * the file.
322: *
323: */
324:
325: for ( N = 2; N < sizeof(x)/sizeof(x[0]); N++ )
326: if (fscanf(fp, "%d %d", &x[N], &y[N]) != 2)
327: break;
328:
329: x[0] = x[1] = hpos;
330: y[0] = y[1] = vpos;
331:
332: for (i = 1; i < N; i++) {
333: x[i+1] += x[i];
334: y[i+1] += y[i];
335: } /* End for */
336:
337: x[N] = x[N-1];
338: y[N] = y[N-1];
339:
340: for (i = ((flag!=1)?0:1); i < ((flag!=1)?N-1:N-2); i++) {
341: fprintf(tf, "%d %d %d %d %d %d Ds\n", x[i], y[i], x[i+1], y[i+1], x[i+2], y[i+2]);
342: if ( dobbox == TRUE ) { /* could be better */
343: cover((double)(x[i] + x[i+1])/2,(double)-(y[i] + y[i+1])/2);
344: cover((double)x[i+1], (double)-y[i+1]);
345: cover((double)(x[i+1] + x[i+2])/2, (double)-(y[i+1] + y[i+2])/2);
346: } /* End if */
347: } /* End for */
348:
349: hgoto(x[N]); /* where troff expects to be */
350: vgoto(y[N]);
351:
352: resetpos(); /* not sure where the printer is */
353:
354: } /* End of drawspline */
355:
356: /*****************************************************************************/
357:
358: arc_extreme(dx1, dy1, dx2, dy2)
359:
360: int dx1, dy1, dx2, dy2;
361:
362: {
363:
364: double x0, y0, x1, y1, xc, yc; /* start, end, center */
365: double r, xmin, ymin, xmax, ymax;
366: int j, k;
367:
368: /*
369: *
370: * bounding box of a circular arc Eric Grosse 24 May 84
371: *
372: * Conceptually, this routine generates a list consisting of the start,
373: * end, and whichever north, east, south, and west points lie on the arc.
374: * The bounding box is then the range of this list.
375: * list = {start,end}
376: * j = quadrant(start)
377: * k = quadrant(end)
378: * if( j==k && long way 'round ) append north,west,south,east
379: * else
380: * while( j != k )
381: * append center+radius*[j-th of north,west,south,east unit vectors]
382: * j += 1 (mod 4)
383: * return( bounding box of list )
384: * The following code implements this, with simple optimizations.
385: *
386: */
387:
388: x0 = hpos;
389: y0 = -vpos;
390: x1 = hpos + dx1 + dx2;
391: y1 = -(vpos + dy1 + dy2);
392: xc = hpos + dx1;
393: yc = -(vpos + dy1);
394:
395: x0 -= xc; y0 -= yc; /* move to center */
396: x1 -= xc; y1 -= yc;
397: xmin = (x0<x1)?x0:x1; ymin = (y0<y1)?y0:y1;
398: xmax = (x0>x1)?x0:x1; ymax = (y0>y1)?y0:y1;
399: r = sqrt(x0*x0 + y0*y0);
400: if (r > 0.0) {
401: j = quadrant(x0,y0);
402: k = quadrant(x1,y1);
403: if (j == k && y1*x0 < x1*y0) {
404: /* viewed as complex numbers, if Im(z1/z0)<0, arc is big */
405: if( xmin > -r) xmin = -r; if( ymin > -r) ymin = -r;
406: if( xmax < r) xmax = r; if( ymax < r) ymax = r;
407: } else {
408: while (j != k) {
409: switch (j) {
410: case 1: if( ymax < r) ymax = r; break; /* north */
411: case 2: if( xmin > -r) xmin = -r; break; /* west */
412: case 3: if( ymin > -r) ymin = -r; break; /* south */
413: case 4: if( xmax < r) xmax = r; break; /* east */
414: } /* End switch */
415: j = j%4 + 1;
416: } /* End while */
417: } /* End else */
418: } /* End if */
419:
420: xmin += xc; ymin += yc;
421: xmax += xc; ymax += yc;
422: cover(xmin, ymin);
423: cover(xmax, ymax);
424:
425: } /* End of arc_extreme */
426:
427: /*****************************************************************************/
428:
429: quadrant(x,y)
430:
431: double x, y;
432:
433: {
434:
435: if ( x>=0.0 && y> 0.0) return(1);
436: else if( x< 0.0 && y>=0.0) return(2);
437: else if( x<=0.0 && y< 0.0) return(3);
438: else if( x> 0.0 && y<=0.0) return(4);
439: else return 0; /* shut up lint */
440:
441: } /* End of quadrant */
442:
443: /*****************************************************************************/
444:
445: beginpath(buf, copy)
446:
447: char *buf; /* whatever followed "x X BeginPath" */
448: int copy; /* ignore *buf if FALSE */
449:
450: {
451:
452: /*
453: *
454: * Called from devcntrl() whenever an "x X BeginPath" command is read. It's used
455: * to mark the start of a sequence of drawing commands that should be grouped
456: * together and treated as a single path. By default the drawing procedures in
457: * *drawfile treat each drawing command as a separate object, and usually start
458: * with a newpath (just as a precaution) and end with a stroke. The newpath and
459: * stroke isolate individual drawing commands and make it impossible to deal with
460: * composite objects. "x X BeginPath" can be used to mark the start of drawing
461: * commands that should be grouped together and treated as a single object, and
462: * part of what's done here ensures that the PostScript drawing commands defined
463: * in *drawfile skip the newpath and stroke, until after the next "x X DrawPath"
464: * command. At that point the path that's been built up can be manipulated in
465: * various ways (eg. filled and/or stroked with a different line width).
466: *
467: * String *buf is unnecessary and is only included for compatibility with an early
468: * verion of that's still in use. In that version "x X BeginObject" marked the
469: * start of a graphical object, and whatever followed it was passed along in *buf
470: * and copied to the output file. Color selection is one of the options that's
471: * available in parsebuf(), so if we get here we add *colorfile to the output
472: * file before doing anything important.
473: *
474: */
475:
476: if ( inpath == FALSE ) {
477: flushtext();
478: getdraw();
479: getcolor();
480: fprintf(tf, "gsave\n");
481: fprintf(tf, "newpath\n");
482: fprintf(tf, "%d %d m\n", hpos, vpos);
483: fprintf(tf, "/inpath true def\n");
484: if ( copy == TRUE )
485: fprintf(tf, "%s", buf);
486: inpath = TRUE;
487: } /* End if */
488:
489: } /* End of beginpath */
490:
491: /*****************************************************************************/
492:
493: drawpath(buf, copy)
494:
495: char *buf;
496: int copy;
497:
498: {
499:
500: /*
501: *
502: * Called from devcntrl() whenever an "x X DrawPath" command is read. It marks the
503: * end of the path started by the last "x X BeginPath" command and uses whatever
504: * has been passed along in *buf to manipulate the path (eg. fill and/or stroke
505: * the path). Once that's been done the drawing procedures are restored to their
506: * default behavior in which each drawing command is treated as an isolated path.
507: * The new version (called after "x X DrawPath") has copy set to FALSE, and calls
508: * parsebuf() to figure out what goes in the output file. It's a feeble attempt
509: * to free users and preprocessors (like pic) from having to know PostScript. The
510: * comments in parsebuf() describe what's handled.
511: *
512: * In the early version a path was started with "x X BeginObject" and ended with
513: * "x X EndObject". In both cases *buf was just copied to the output file, and
514: * was expected to be legitimate PostScript that manipulated the current path.
515: * The old escape sequence will be supported for a while (for Ravi), and always
516: * call this routine with copy set to TRUE.
517: *
518: *
519: */
520:
521: if ( inpath == TRUE ) {
522: if ( copy == TRUE )
523: fprintf(tf, "%s", buf);
524: else parsebuf(buf);
525: fprintf(tf, "grestore\n");
526: fprintf(tf, "/inpath false def\n");
527: reset();
528: inpath = FALSE;
529: } /* End if */
530:
531: } /* End of drawpath */
532:
533: /*****************************************************************************/
534:
535: parsebuf(buf)
536:
537: char *buf; /* whatever followed "x X DrawPath" */
538:
539: {
540:
541: char *p; /* usually the next token */
542: char *p1; /* for grabbing arguments */
543: char *pend; /* end of the original string (ie. *buf) */
544: int gsavelevel = 0; /* non-zero if we've done a gsave */
545:
546: /*
547: *
548: * Simple minded attempt at parsing the string that followed an "x X DrawPath"
549: * command. Everything not recognized here is simply ignored - there's absolutely
550: * no error checking and what was originally in buf is clobbered by strtok().
551: * A typical *buf might look like,
552: *
553: * gray .9 fill stroke
554: *
555: * to fill the current path with a gray level of .9 and follow that by stroking the
556: * outline of the path. Since unrecognized tokens are ignored the last example
557: * could also be written as,
558: *
559: * with gray .9 fill then stroke
560: *
561: * The "with" and "then" strings aren't recognized tokens and are simply discarded.
562: * The "stroke", "fill", and "wfill" force out appropriate PostScript code and are
563: * followed by a grestore. In otherwords changes to the grahics state (eg. a gray
564: * level or color) are reset to default values immediately after the stroke, fill,
565: * or wfill tokens. For now "fill" gets invokes PostScript's eofill operator and
566: * "wfill" calls fill (ie. the operator that uses the non-zero winding rule).
567: *
568: * The tokens that cause temporary changes to the graphics state are "gray" (for
569: * setting the gray level), "color" (for selecting a known color from the colordict
570: * dictionary defined in *colorfile), and "line" (for setting the line width). All
571: * three tokens can be extended since strncmp() makes the comparison. For example
572: * the strings "line" and "linewidth" accomplish the same thing. Colors are named
573: * (eg. "red"), but must be appropriately defined in *colorfile. For now all three
574: * tokens must be followed immediately by their single argument. The gray level
575: * (ie. the argument that follows "gray") should be a number between 0 and 1, with
576: * 0 for black and 1 for white.
577: *
578: * To pass straight PostScript through enclose the appropriate commands in double
579: * quotes. Straight PostScript is only bracketed by the outermost gsave/grestore
580: * pair (ie. the one from the initial "x X BeginPath") although that's probably
581: * a mistake. Suspect I may have to change the double quote delimiters.
582: *
583: */
584:
585: pend = buf + strlen(buf);
586: p = strtok(buf, " \n");
587:
588: while ( p != NULL ) {
589: if ( gsavelevel == 0 ) {
590: fprintf(tf, "gsave\n");
591: gsavelevel++;
592: } /* End if */
593: if ( strcmp(p, "stroke") == 0 ) {
594: fprintf(tf, "closepath stroke\ngrestore\n");
595: gsavelevel--;
596: } else if ( strcmp(p, "openstroke") == 0 ) {
597: fprintf(tf, "stroke\ngrestore\n");
598: gsavelevel--;
599: } else if ( strcmp(p, "fill") == 0 ) {
600: fprintf(tf, "eofill\ngrestore\n");
601: gsavelevel--;
602: } else if ( strcmp(p, "wfill") == 0 ) {
603: fprintf(tf, "fill\ngrestore\n");
604: gsavelevel--;
605: } else if ( strcmp(p, "sfill") == 0 ) {
606: fprintf(tf, "eofill\ngrestore\ngsave\nstroke\ngrestore\n");
607: gsavelevel--;
608: } else if ( strncmp(p, "gray", strlen("gray")) == 0 ) {
609: p1 = strtok(NULL, " \n");
610: fprintf(tf, "%s setgray\n", p1);
611: } else if ( strncmp(p, "color", strlen("color")) == 0 ) {
612: p1 = strtok(NULL, " \n");
613: fprintf(tf, "/%s setcolor\n", p1);
614: } else if ( strncmp(p, "line", strlen("line")) == 0 ) {
615: p1 = strtok(NULL, " \n");
616: fprintf(tf, "%s resolution mul 2 div setlinewidth\n", p1);
617: } else if ( strncmp(p, "reverse", strlen("reverse")) == 0 )
618: fprintf(tf, "reversepath\n");
619: else if ( *p == '"' ) {
620: for ( ; gsavelevel > 0; gsavelevel-- )
621: fprintf(tf, "grestore\n");
622: if ( (p1 = p + strlen(p)) < pend )
623: *p1 = ' ';
624: p = strtok(p, "\"\n");
625: fprintf(tf, "%s\n", p);
626: } /* End else */
627: p = strtok(NULL, " \n");
628: } /* End while */
629:
630: for ( ; gsavelevel > 0; gsavelevel-- )
631: fprintf(tf, "grestore\n");
632:
633: } /* End of parsebuf */
634:
635: /*****************************************************************************/
636:
637: getbaseline()
638:
639: {
640:
641: /*
642: *
643: * Responsible for making sure the PostScript procedures needed for printing text
644: * along an arbitrary baseline are downloaded from *baselinefile. Done at most
645: * once per job, and only if the the stuff is really used.
646: *
647: */
648:
649: if ( gotbaseline == FALSE )
650: exportfile(baselinefile);
651:
652: if ( tf == stdout )
653: gotbaseline = TRUE;
654:
655: } /* End of getbaseline */
656:
657: /*****************************************************************************/
658:
659: newbaseline(buf)
660:
661: char *buf; /* whatever followed "x X NewBaseline" */
662:
663: {
664:
665: char *p; /* for eliminating white space etc. */
666:
667: /*
668: *
669: * Called from devcntrl() whenever an "x X NewBaseline" command is recognized. We
670: * assume whatever is in *buf is a set of parametric equations that describe the
671: * new baseline. Equations for x(t), y(t), dx/dt, and dy/dt must be written in
672: * PostScript, bracketed by { and } characters, and supplied in exactly that order.
673: * In particular the equation for x must come first in *buf and it ends up as the
674: * last one on the stack, while the equation for dy/dt comes last (in *buf) and
675: * ends up on the top of the PostScript stack. For example if *buf is given by,
676: *
677: * {} {180 mul 3.1416 div cos} {pop 1} {180 mul 3.1416 div sin neg}
678: *
679: * text will be printed along the curve y = cos(x).
680: *
681: * Angles given in radians must be converted to degrees for the PostScript trig
682: * functions, and things are scaled so that 1 unit maps into 1 inch. In the last
683: * example the cosine curve that describes the baseline has an amplitude of 1 inch.
684: * As another example of this rather confusing syntax if *buf is,
685: *
686: * {} {} {pop 1} {pop 1}
687: *
688: * the baseline will be the 45 degree line y = x.
689: *
690: * When any of the four functions is used they're called with a single number on
691: * the stack that's equal to the current value of the parameter t. The coordinate
692: * system axes run parallel to the PostScript coordinate system that's currently
693: * being used.
694: *
695: */
696:
697: for ( p = buf; *p; p++ ) /* eliminate trailing '\n' */
698: if ( *p == '\n' ) {
699: *p = '\0';
700: break;
701: } /* End if */
702:
703: for ( p = buf; *p && (*p == ' ' || *p == ':'); p++ ) ;
704:
705: if ( *p != '\0' ) { /* something's there */
706: flushtext();
707: getbaseline();
708: fprintf(tf, "mark resolution %s newbaseline\n", p);
709: reset();
710: } /* End if */
711:
712: } /* End of newbaseline */
713:
714: /*****************************************************************************/
715:
716: drawtext(buf)
717:
718: char *buf; /* whatever followed "x X DrawText */
719:
720: {
721:
722: char *p; /* for eliminating white space etc. */
723:
724: /*
725: *
726: * Called from devcntrl() whenever an "x X DrawText command is recognized. *buf
727: * should contain three arguments in the following order. First comes the text we
728: * want to print along the current baseline. Right now the string should be given
729: * as a PostScript string using characters '(' and ')' as the delimiters. Next in
730: * *buf comes a justification mode that can be the words left, right, or center.
731: * Last comes a number that represents the starting value of the parameter t that's
732: * given as the argument to the parametric equations that describe the current
733: * baseline. For example if *buf is given by,
734: *
735: * (hello world) left .5
736: *
737: * hello world will be printed along the path described by the current baseline
738: * and left justified at whatever (x(.5), y(.5)) happens to be. Usually will be
739: * preceeded by an "x X NewBaseline" call that defines the current baseline. The
740: * origin of the coordinate system used by the parametric equations will be the
741: * current point.
742: *
743: */
744:
745: for ( p = buf; *p; p++ ) /* eliminate trailing '\n' */
746: if ( *p == '\n' ) {
747: *p = '\0';
748: break;
749: } /* End if */
750:
751: for ( p = buf; *p && (*p == ' ' || *p == ':'); p++ ) ;
752:
753: if ( *p != '\0' ) { /* something's there */
754: flushtext();
755: getbaseline();
756: xymove(hpos, vpos);
757: fprintf(tf, "mark %s drawfunnytext\n", p);
758: resetpos();
759: } /* End if */
760:
761: } /* End of drawtext */
762:
763: /*****************************************************************************/
764:
765: settext(buf)
766:
767: char *buf;
768:
769: {
770:
771: char *p;
772:
773: /*
774: *
775: * Does whatever is needed to ensure any text that follows will be set along the
776: * curve described by the PostScript procedures listed in *buf. If *buf doesn't
777: * contain anything useful (eg. just a newline) things are restored to whatever
778: * they originally were. Doesn't work well if we try to start in the middle of a
779: * line of text.
780: *
781: * The parametric equations needed are,
782: *
783: * x = f(t)
784: * y = g(t)
785: * dx/dt = f'(t)
786: * dy/dt = g'(t)
787: *
788: * and must be given as proper PostScript procedures. The equation for x must come
789: * first (ie. it ends up on the bottom of the stack) and the equation for dy/dt
790: * must be given last (ie. it ends up on top of the stack). For example if *buf
791: * is given by,
792: *
793: * {} {180 mul 3.1416 div cos} {pop 1} {180 mul 3.1416 div sin neg}
794: *
795: * text will be set along the curve y=cos(x).
796: *
797: */
798:
799: flushtext();
800: getbaseline();
801:
802: for ( p = buf; *p && *p == ' '; p++ ) ;
803:
804: if ( *p && *p != '\n' ) {
805: encoding = maxencoding + 2;
806: fprintf(tf, "mark resolution %s newbaseline\n", buf);
807: } else encoding = realencoding;
808:
809: fprintf(tf, "%d setdecoding\n", encoding);
810: resetpos();
811:
812: } /* End of settext */
813:
814: /*****************************************************************************/
815:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.