BOOLEAN drawflag = FALSE;
BOOLEAN inpath = FALSE; /* TRUE if we're putting pieces together */
void
cover(double x, double y) {
}
void
drawspline(Biobufhdr *Bp, int flag) { /* flag!=1 connect end points */
int x[100], y[100];
int i, N;
/*
*
* Spline drawing routine for Postscript printers. The complicated stuff is
* handled by procedure Ds, which should be defined in the library file. I've
* seen wrong implementations of troff's spline drawing, so fo the record I'll
* write down the parametric equations and the necessary conversions to Bezier
* cubic splines (as used in Postscript).
*
*
* Parametric equation (x coordinate only):
*
*
* (x2 - 2 * x1 + x0) 2 (x0 + x1)
* x = ------------------ * t + (x1 - x0) * t + ---------
* 2 2
*
*
* The coefficients in the Bezier cubic are,
*
*
* A = 0
* B = (x2 - 2 * x1 + x0) / 2
* C = x1 - x0
*
*
* while the current point is,
*
* current-point = (x0 + x1) / 2
*
* Using the relationships given in the Postscript manual (page 121) it's easy to
* see that the control points are given by,
*
*
* x0' = (x0 + 5 * x1) / 6
* x1' = (x2 + 5 * x1) / 6
* x2' = (x1 + x2) / 2
*
*
* where the primed variables are the ones used by curveto. The calculations
* shown above are done in procedure Ds using the coordinates set up in both
* the x[] and y[] arrays.
*
* A simple test of whether your spline drawing is correct would be to use cip
* to draw a spline and some tangent lines at appropriate points and then print
* the file.
*
*/
for (N=2; N<sizeof(x)/sizeof(x[0]); N++)
if (Bgetfield(Bp, 'd', &x[N], 0)<=0 || Bgetfield(Bp, 'd', &y[N], 0)<=0)
break;
x[0] = x[1] = hpos;
y[0] = y[1] = vpos;
for (i = 1; i < N; i++) {
x[i+1] += x[i];
y[i+1] += y[i];
}
x[N] = x[N-1];
y[N] = y[N-1];
for (i = ((flag!=1)?0:1); i < ((flag!=1)?N-1:N-2); i++) {
endstring();
if (pageon())
Bprint(Bstdout, "%d %d %d %d %d %d Ds\n", x[i], y[i], x[i+1], y[i+1], x[i+2], y[i+2]);
/* if (dobbox == TRUE) { /* could be better */
/* cover((double)(x[i] + x[i+1])/2,(double)-(y[i] + y[i+1])/2);
/* cover((double)x[i+1], (double)-y[i+1]);
/* cover((double)(x[i+1] + x[i+2])/2, (double)-(y[i+1] + y[i+2])/2);
/* }
*/
}
hpos = x[N]; /* where troff expects to be */
vpos = y[N];
}
void
draw(Biobufhdr *Bp) {
int r, x1, y1, x2, y2, i;
int d1, d2;
drawflag = TRUE;
r = Bgetrune(Bp);
switch(r) {
case 'l':
if (Bgetfield(Bp, 'd', &x1, 0)<=0 || Bgetfield(Bp, 'd', &y1, 0)<=0 || Bgetfield(Bp, 'r', &i, 0)<=0)
error(FATAL, "draw line function, destination coordinates not found.\n");
endstring();
if (pageon())
Bprint(Bstdout, "%d %d %d %d Dl\n", hpos, vpos, hpos+x1, vpos+y1);
hpos += x1;
vpos += y1;
break;
case 'c':
if (Bgetfield(Bp, 'd', &d1, 0)<=0)
error(FATAL, "draw circle function, diameter coordinates not found.\n");
endstring();
if (pageon())
Bprint(Bstdout, "%d %d %d %d De\n", hpos, vpos, d1, d1);
hpos += d1;
break;
case 'e':
if (Bgetfield(Bp, 'd', &d1, 0)<=0 || Bgetfield(Bp, 'd', &d2, 0)<=0)
error(FATAL, "draw ellipse function, diameter coordinates not found.\n");
/*
* Called from devcntrl() whenever an "x X BeginPath" command is read. It's used
* to mark the start of a sequence of drawing commands that should be grouped
* together and treated as a single path. By default the drawing procedures in
* *drawfile treat each drawing command as a separate object, and usually start
* with a newpath (just as a precaution) and end with a stroke. The newpath and
* stroke isolate individual drawing commands and make it impossible to deal with
* composite objects. "x X BeginPath" can be used to mark the start of drawing
* commands that should be grouped together and treated as a single object, and
* part of what's done here ensures that the PostScript drawing commands defined
* in *drawfile skip the newpath and stroke, until after the next "x X DrawPath"
* command. At that point the path that's been built up can be manipulated in
* various ways (eg. filled and/or stroked with a different line width).
*
* Color selection is one of the options that's available in parsebuf(),
* so if we get here we add *colorfile to the output file before doing
* anything important.
*
*/
if (inpath == FALSE) {
endstring();
/* getdraw(); */
/* getcolor(); */
Bprint(Bstdout, "gsave\n");
Bprint(Bstdout, "newpath\n");
Bprint(Bstdout, "%d %d m\n", hpos, vpos);
Bprint(Bstdout, "/inpath true def\n");
if ( copy == TRUE )
Bprint(Bstdout, "%s\n", buf);
inpath = TRUE;
}
}
static void parsebuf(char*);
void
drawpath(char *buf, int copy) {
/*
*
* Called from devcntrl() whenever an "x X DrawPath" command is read. It marks the
* end of the path started by the last "x X BeginPath" command and uses whatever
* has been passed along in *buf to manipulate the path (eg. fill and/or stroke
* the path). Once that's been done the drawing procedures are restored to their
* default behavior in which each drawing command is treated as an isolated path.
* The new version (called after "x X DrawPath") has copy set to FALSE, and calls
* parsebuf() to figure out what goes in the output file. It's a feeble attempt
* to free users and preprocessors (like pic) from having to know PostScript. The
* comments in parsebuf() describe what's handled.
*
* In the early version a path was started with "x X BeginObject" and ended with
* "x X EndObject". In both cases *buf was just copied to the output file, and
* was expected to be legitimate PostScript that manipulated the current path.
* The old escape sequence will be supported for a while (for Ravi), and always
* call this routine with copy set to TRUE.
*
*
*/
static void
parsebuf(char *buf)
{
char *p; /* usually the next token */
char *q;
int gsavelevel = 0; /* non-zero if we've done a gsave */
/*
*
* Simple minded attempt at parsing the string that followed an "x X DrawPath"
* command. Everything not recognized here is simply ignored - there's absolutely
* no error checking and what was originally in buf is clobbered by strtok().
* A typical *buf might look like,
*
* gray .9 fill stroke
*
* to fill the current path with a gray level of .9 and follow that by stroking the
* outline of the path. Since unrecognized tokens are ignored the last example
* could also be written as,
*
* with gray .9 fill then stroke
*
* The "with" and "then" strings aren't recognized tokens and are simply discarded.
* The "stroke", "fill", and "wfill" force out appropriate PostScript code and are
* followed by a grestore. In otherwords changes to the grahics state (eg. a gray
* level or color) are reset to default values immediately after the stroke, fill,
* or wfill tokens. For now "fill" gets invokes PostScript's eofill operator and
* "wfill" calls fill (ie. the operator that uses the non-zero winding rule).
*
* The tokens that cause temporary changes to the graphics state are "gray" (for
* setting the gray level), "color" (for selecting a known color from the colordict
* dictionary defined in *colorfile), and "line" (for setting the line width). All
* three tokens can be extended since strncmp() makes the comparison. For example
* the strings "line" and "linewidth" accomplish the same thing. Colors are named
* (eg. "red"), but must be appropriately defined in *colorfile. For now all three
* tokens must be followed immediately by their single argument. The gray level
* (ie. the argument that follows "gray") should be a number between 0 and 1, with
* 0 for black and 1 for white.
*
* To pass straight PostScript through enclose the appropriate commands in double
* quotes. Straight PostScript is only bracketed by the outermost gsave/grestore
* pair (ie. the one from the initial "x X BeginPath") although that's probably
* a mistake. Suspect I may have to change the double quote delimiters.
*
*/
