![[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 |
researchv10 Norman
/*
*
* Drawing routines used by dpost. Almost no real work is done here. Instead
* the required calculations are done in special Postscript procedures that
* include:
*
*
* Dl
*
* x1 y1 x y Dl -
*
* Starts a new path and then draws a line from the current point
* (x, y) to (x1, y1).
*
* De
*
* x y a b De -
*
* Starts a new path and then draws an ellipse that has its left side
* at the current point (x, y) and horizontal and vertical axes lengths
* given by a and b respectively.
*
* Da
*
* x y dx1 dy1 dx2 dy2 Da -
*
* Starts a new segment and then draws a circular arc from the current
* point (x, y) to (x + dx1 + dx2, y + dy1 + dy2). The center of the
* circle is at (x + dx1, y + dy1). Arcs always go counter-clockwise
* from the starting point to the end point.
*
* DA
*
* x y dx1 dy1 dx2 dy2 DA -
*
* Draws a clockwise arc from (x, y) to (x + dx1 + dx2, y + dy1 + dy2)
* with center at (x + dx1, y + dy1). Only needed when we're building
* large paths that use arcs and want to control the current point. The
* arguments passed to drawarc() will be whatever they would have been
* for a counter-clockwise arc, so we need to map them into appropriate
* arguments for PostScript's arcn operator. The mapping is,
*
* x = hpos + dx1' + dx2'
* y = vpos + dy1' + dy2'
* dx1 = -dx2'
* dy1 = -dy2'
* dx2 = -dx1'
* dy2 = -dy1'
*
* where primed values represent the drawarc() arguments and (hpos, vpos)
* is our current position.
*
* Ds
*
* x0 y0 x1 y1 x2 y2 Ds -
*
* Starts a new segment and then draws a quadratic spline connecting
* point ((x0 + x1)/2, (y0 + y1)/2) to ((x1 + x2)/2, (y1 + y2)/2).
* The points used in Postscript's curveto procedure are given by,
*
* x0' = (x0 + 5 * x1) / 6
* x1' = (x2 + 5 * x1) / 6
* x2' = (x1 + x2) / 2
*
* with similar equations for the y coordinates.
*
* By default all the PostScript drawing procedures begin with a newpath (just to
* be safe) and end with a stroke, which essentially isolates the path elements
* built by the drawing procedures. In order to accommodate big paths built from
* smaller pieces each of the PostScript drawing procedures can forced to retain
* the path that's being built. That's what happens in beginpath() when an "x X
* BeginPath" command is read. beginpath() sets the PostScript variable inpath to
* true, and that essentially eliminates the newpath/stroke pair that bracket the
* individual pieces. In that case the path is terminated and drawn when dpost
* reads an "x X DrawPath" command.
*
* Early versions of dpost included the PostScript drawing procedures as part of
* the prologue, and as a result they were included with every job, even if they
* were never used. This version has separated the drawing procedures from the
* default prologue (they're now in *drawfile) and only includes them if they're
* really needed, which is yet another convenient violation of page independence.
* Routine getdraw() is responsible for adding *drawfile to the output file, and
* if it can't read *drawfile it continues on as if nothing happened. That means
* everything should still work if you append *drawfile to *prologue and then
* delete *drawfile.
*
*/
#include <stdio.h>
#include <math.h>
#include "gen.h" /* general purpose definitions */
#include "ext.h" /* external variable definitions */
#include "motion.h" /* positioning macros */
int gotdraw = FALSE; /* TRUE when *drawfile has been added */
int gotbaseline = FALSE; /* TRUE after *baselinefile is added */
int inpath = FALSE; /* TRUE if we're putting pieces together */
/*
*
* All these should be defined in file dpost.c.
*
*/
extern int hpos;
extern int vpos;
extern int encoding;
extern int maxencoding;
extern int realencoding;
extern char *drawfile;
extern char *baselinefile;
extern FILE *tf;
/*****************************************************************************/
getdraw()
{
/*
*
* Responsible for making sure the PostScript drawing procedures are downloaded
* from *drawfile. Stuff is done at most once per job, and only if the job needs
* them. For now I've decided not to quit if we can't read the drawing file. That
* pretty much assumes an old version of prologue is being used that includes all
* the drawing procedures.
*
*/
if ( gotdraw == FALSE )
exportfile(drawfile);
if ( tf == stdout )
gotdraw = TRUE;
} /* End of getdraw */
/*****************************************************************************/
drawline(dx, dy)
int dx, dy; /* endpoint is (hpos+dx, vpos+dy) */
{
/*
*
* Draws a line from (hpos, vpos) to (hpos+dx, vpos+dy), and leaves the current
* position at the endpoint.
*
*/
if ( dx == 0 && dy == 0 )
drawcirc(1);
else fprintf(tf, "%d %d %d %d Dl\n", hpos + dx, vpos + dy, hpos, vpos);
if ( dobbox == TRUE ) {
cover((double)hpos, (double)-vpos);
cover((double)(hpos + dx), (double)-(vpos + dy));
} /* End if */
hgoto(hpos+dx); /* where troff expects to be */
vgoto(vpos+dy);
resetpos(); /* not sure where the printer is */
} /* End of drawline */
/*****************************************************************************/
drawcirc(d)
int d; /* diameter of the circle */
{
/*
*
* Draws a circle of diameter d with the left 'side' of the circle at the
* current point. After we're finished drawing we move the current position
* to the right side.
*
*/
drawellip(d, d);
} /* End of drawcirc */
/*****************************************************************************/
drawellip(a, b)
int a, b; /* axes lengths for the ellipse */
{
/*
*
* Draws an ellipse having axes lengths horizontally and vertically of a and
* b. The left side of the ellipse is at the current point. After we're done
* drawing the path we move the current position to the right side.
*
*/
if ( a == 0 && b == 0 )
return;
fprintf(tf, "%d %d %d %d De\n", hpos, vpos, a, b);
if ( dobbox == TRUE ) {
cover((double)hpos, (double)-(vpos + b/2));
cover((double)(hpos+a), (double)-(vpos - b/2));
} /* End if */
hgoto(hpos + a); /* where troff expects to be */
vgoto(vpos);
resetpos(); /* not sure where the printer is */
} /* End of drawellip */
/*****************************************************************************/
drawarc(dx1, dy1, dx2, dy2, c)
int dx1, dy1; /* vector from current pos to center */
int dx2, dy2; /* from center to end of the arc */
int c; /* clockwise if c is A */
{
/*
*
* If c isn't set to 'A' a counter-clockwise arc is drawn from the current point
* (hpos, vpos) to (hpos+dx1+dx2, vpos+dy1+dy2). The center of the circle is the
* point (hpos+dx1, vpos+dy1). If c is 'A' the arc goes clockwise from the point
* (hpos+dx1+dx2, vpos+dy1+dy2) to (hpos, vpos). Clockwise arcs are only needed
* if we're building a larger path out of pieces that include arcs, and want to
* have PostScript manage the path for us. Arguments (for a clockwise arc) are
* what would have been supplied if the arc was drawn in a counter-clockwise
* direction, and are converted to values suitable for use with PostScript's arcn
* operator.
*
*/
if ( (dx1 != 0 || dy1 != 0) && (dx2 != 0 || dy2 != 0) ) {
if ( c != 'A' )
fprintf(tf, "%d %d %d %d %d %d Da\n", hpos, vpos, dx1, dy1, dx2, dy2);
else fprintf(tf, "%d %d %d %d %d %d DA\n", hpos+dx1+dx2, vpos+dy1+dy2,
-dx2, -dy2, -dx1, -dy1);
if ( dobbox == TRUE )
arc_extreme(dx1, dy1, dx2, dy2);
} /* End if */
hgoto(hpos + dx1 + dx2); /* where troff expects to be */
vgoto(vpos + dy1 + dy2);
resetpos(); /* not sure where the printer is */
} /* End of drawarc */
/*****************************************************************************/
drawspline(fp, flag)
FILE *fp; /* input for point list */
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 (fscanf(fp, "%d %d", &x[N], &y[N]) != 2)
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];
} /* End for */
x[N] = x[N-1];
y[N] = y[N-1];
for (i = ((flag!=1)?0:1); i < ((flag!=1)?N-1:N-2); i++) {
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]);
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);
} /* End if */
} /* End for */
hgoto(x[N]); /* where troff expects to be */
vgoto(y[N]);
resetpos(); /* not sure where the printer is */
} /* End of drawspline */
/*****************************************************************************/
arc_extreme(dx1, dy1, dx2, dy2)
int dx1, dy1, dx2, dy2;
{
double x0, y0, x1, y1, xc, yc; /* start, end, center */
double r, xmin, ymin, xmax, ymax;
int j, k;
/*
*
* bounding box of a circular arc Eric Grosse 24 May 84
*
* Conceptually, this routine generates a list consisting of the start,
* end, and whichever north, east, south, and west points lie on the arc.
* The bounding box is then the range of this list.
* list = {start,end}
* j = quadrant(start)
* k = quadrant(end)
* if( j==k && long way 'round ) append north,west,south,east
* else
* while( j != k )
* append center+radius*[j-th of north,west,south,east unit vectors]
* j += 1 (mod 4)
* return( bounding box of list )
* The following code implements this, with simple optimizations.
*
*/
x0 = hpos;
y0 = -vpos;
x1 = hpos + dx1 + dx2;
y1 = -(vpos + dy1 + dy2);
xc = hpos + dx1;
yc = -(vpos + dy1);
x0 -= xc; y0 -= yc; /* move to center */
x1 -= xc; y1 -= yc;
xmin = (x0<x1)?x0:x1; ymin = (y0<y1)?y0:y1;
xmax = (x0>x1)?x0:x1; ymax = (y0>y1)?y0:y1;
r = sqrt(x0*x0 + y0*y0);
if (r > 0.0) {
j = quadrant(x0,y0);
k = quadrant(x1,y1);
if (j == k && y1*x0 < x1*y0) {
/* viewed as complex numbers, if Im(z1/z0)<0, arc is big */
if( xmin > -r) xmin = -r; if( ymin > -r) ymin = -r;
if( xmax < r) xmax = r; if( ymax < r) ymax = r;
} else {
while (j != k) {
switch (j) {
case 1: if( ymax < r) ymax = r; break; /* north */
case 2: if( xmin > -r) xmin = -r; break; /* west */
case 3: if( ymin > -r) ymin = -r; break; /* south */
case 4: if( xmax < r) xmax = r; break; /* east */
} /* End switch */
j = j%4 + 1;
} /* End while */
} /* End else */
} /* End if */
xmin += xc; ymin += yc;
xmax += xc; ymax += yc;
cover(xmin, ymin);
cover(xmax, ymax);
} /* End of arc_extreme */
/*****************************************************************************/
quadrant(x,y)
double x, y;
{
if ( x>=0.0 && y> 0.0) return(1);
else if( x< 0.0 && y>=0.0) return(2);
else if( x<=0.0 && y< 0.0) return(3);
else if( x> 0.0 && y<=0.0) return(4);
else return 0; /* shut up lint */
} /* End of quadrant */
/*****************************************************************************/
beginpath(buf, copy)
char *buf; /* whatever followed "x X BeginPath" */
int copy; /* ignore *buf if FALSE */
{
/*
*
* 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).
*
* String *buf is unnecessary and is only included for compatibility with an early
* verion of that's still in use. In that version "x X BeginObject" marked the
* start of a graphical object, and whatever followed it was passed along in *buf
* and copied to the output file. 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 ) {
flushtext();
getdraw();
getcolor();
fprintf(tf, "gsave\n");
fprintf(tf, "newpath\n");
fprintf(tf, "%d %d m\n", hpos, vpos);
fprintf(tf, "/inpath true def\n");
if ( copy == TRUE )
fprintf(tf, "%s", buf);
inpath = TRUE;
} /* End if */
} /* End of beginpath */
/*****************************************************************************/
drawpath(buf, copy)
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.
*
*
*/
if ( inpath == TRUE ) {
if ( copy == TRUE )
fprintf(tf, "%s", buf);
else parsebuf(buf);
fprintf(tf, "grestore\n");
fprintf(tf, "/inpath false def\n");
reset();
inpath = FALSE;
} /* End if */
} /* End of drawpath */
/*****************************************************************************/
parsebuf(buf)
char *buf; /* whatever followed "x X DrawPath" */
{
char *p; /* usually the next token */
char *p1; /* for grabbing arguments */
char *pend; /* end of the original string (ie. *buf) */
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.
*
*/
pend = buf + strlen(buf);
p = strtok(buf, " \n");
while ( p != NULL ) {
if ( gsavelevel == 0 ) {
fprintf(tf, "gsave\n");
gsavelevel++;
} /* End if */
if ( strcmp(p, "stroke") == 0 ) {
fprintf(tf, "closepath stroke\ngrestore\n");
gsavelevel--;
} else if ( strcmp(p, "openstroke") == 0 ) {
fprintf(tf, "stroke\ngrestore\n");
gsavelevel--;
} else if ( strcmp(p, "fill") == 0 ) {
fprintf(tf, "eofill\ngrestore\n");
gsavelevel--;
} else if ( strcmp(p, "wfill") == 0 ) {
fprintf(tf, "fill\ngrestore\n");
gsavelevel--;
} else if ( strcmp(p, "sfill") == 0 ) {
fprintf(tf, "eofill\ngrestore\ngsave\nstroke\ngrestore\n");
gsavelevel--;
} else if ( strncmp(p, "gray", strlen("gray")) == 0 ) {
p1 = strtok(NULL, " \n");
fprintf(tf, "%s setgray\n", p1);
} else if ( strncmp(p, "color", strlen("color")) == 0 ) {
p1 = strtok(NULL, " \n");
fprintf(tf, "/%s setcolor\n", p1);
} else if ( strncmp(p, "line", strlen("line")) == 0 ) {
p1 = strtok(NULL, " \n");
fprintf(tf, "%s resolution mul 2 div setlinewidth\n", p1);
} else if ( strncmp(p, "reverse", strlen("reverse")) == 0 )
fprintf(tf, "reversepath\n");
else if ( *p == '"' ) {
for ( ; gsavelevel > 0; gsavelevel-- )
fprintf(tf, "grestore\n");
if ( (p1 = p + strlen(p)) < pend )
*p1 = ' ';
p = strtok(p, "\"\n");
fprintf(tf, "%s\n", p);
} /* End else */
p = strtok(NULL, " \n");
} /* End while */
for ( ; gsavelevel > 0; gsavelevel-- )
fprintf(tf, "grestore\n");
} /* End of parsebuf */
/*****************************************************************************/
getbaseline()
{
/*
*
* Responsible for making sure the PostScript procedures needed for printing text
* along an arbitrary baseline are downloaded from *baselinefile. Done at most
* once per job, and only if the the stuff is really used.
*
*/
if ( gotbaseline == FALSE )
exportfile(baselinefile);
if ( tf == stdout )
gotbaseline = TRUE;
} /* End of getbaseline */
/*****************************************************************************/
newbaseline(buf)
char *buf; /* whatever followed "x X NewBaseline" */
{
char *p; /* for eliminating white space etc. */
/*
*
* Called from devcntrl() whenever an "x X NewBaseline" command is recognized. We
* assume whatever is in *buf is a set of parametric equations that describe the
* new baseline. Equations for x(t), y(t), dx/dt, and dy/dt must be written in
* PostScript, bracketed by { and } characters, and supplied in exactly that order.
* In particular the equation for x must come first in *buf and it ends up as the
* last one on the stack, while the equation for dy/dt comes last (in *buf) and
* ends up on the top of the PostScript stack. For example if *buf is given by,
*
* {} {180 mul 3.1416 div cos} {pop 1} {180 mul 3.1416 div sin neg}
*
* text will be printed along the curve y = cos(x).
*
* Angles given in radians must be converted to degrees for the PostScript trig
* functions, and things are scaled so that 1 unit maps into 1 inch. In the last
* example the cosine curve that describes the baseline has an amplitude of 1 inch.
* As another example of this rather confusing syntax if *buf is,
*
* {} {} {pop 1} {pop 1}
*
* the baseline will be the 45 degree line y = x.
*
* When any of the four functions is used they're called with a single number on
* the stack that's equal to the current value of the parameter t. The coordinate
* system axes run parallel to the PostScript coordinate system that's currently
* being used.
*
*/
for ( p = buf; *p; p++ ) /* eliminate trailing '\n' */
if ( *p == '\n' ) {
*p = '\0';
break;
} /* End if */
for ( p = buf; *p && (*p == ' ' || *p == ':'); p++ ) ;
if ( *p != '\0' ) { /* something's there */
flushtext();
getbaseline();
fprintf(tf, "mark resolution %s newbaseline\n", p);
reset();
} /* End if */
} /* End of newbaseline */
/*****************************************************************************/
drawtext(buf)
char *buf; /* whatever followed "x X DrawText */
{
char *p; /* for eliminating white space etc. */
/*
*
* Called from devcntrl() whenever an "x X DrawText command is recognized. *buf
* should contain three arguments in the following order. First comes the text we
* want to print along the current baseline. Right now the string should be given
* as a PostScript string using characters '(' and ')' as the delimiters. Next in
* *buf comes a justification mode that can be the words left, right, or center.
* Last comes a number that represents the starting value of the parameter t that's
* given as the argument to the parametric equations that describe the current
* baseline. For example if *buf is given by,
*
* (hello world) left .5
*
* hello world will be printed along the path described by the current baseline
* and left justified at whatever (x(.5), y(.5)) happens to be. Usually will be
* preceeded by an "x X NewBaseline" call that defines the current baseline. The
* origin of the coordinate system used by the parametric equations will be the
* current point.
*
*/
for ( p = buf; *p; p++ ) /* eliminate trailing '\n' */
if ( *p == '\n' ) {
*p = '\0';
break;
} /* End if */
for ( p = buf; *p && (*p == ' ' || *p == ':'); p++ ) ;
if ( *p != '\0' ) { /* something's there */
flushtext();
getbaseline();
xymove(hpos, vpos);
fprintf(tf, "mark %s drawfunnytext\n", p);
resetpos();
} /* End if */
} /* End of drawtext */
/*****************************************************************************/
settext(buf)
char *buf;
{
char *p;
/*
*
* Does whatever is needed to ensure any text that follows will be set along the
* curve described by the PostScript procedures listed in *buf. If *buf doesn't
* contain anything useful (eg. just a newline) things are restored to whatever
* they originally were. Doesn't work well if we try to start in the middle of a
* line of text.
*
* The parametric equations needed are,
*
* x = f(t)
* y = g(t)
* dx/dt = f'(t)
* dy/dt = g'(t)
*
* and must be given as proper PostScript procedures. The equation for x must come
* first (ie. it ends up on the bottom of the stack) and the equation for dy/dt
* must be given last (ie. it ends up on top of the stack). For example if *buf
* is given by,
*
* {} {180 mul 3.1416 div cos} {pop 1} {180 mul 3.1416 div sin neg}
*
* text will be set along the curve y=cos(x).
*
*/
flushtext();
getbaseline();
for ( p = buf; *p && *p == ' '; p++ ) ;
if ( *p && *p != '\n' ) {
encoding = maxencoding + 2;
fprintf(tf, "mark resolution %s newbaseline\n", buf);
} else encoding = realencoding;
fprintf(tf, "%d setdecoding\n", encoding);
resetpos();
} /* End of settext */
/*****************************************************************************/
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.