#include <stdio.h>
#include <math.h>
#include "pic.h"
#include "y.tab.h"

void dotext(obj *);
void dotline(double, double, double, double, int, double);
void dotbox(double, double, double, double, int, double);
void ellipse(double, double, double, double);
void circle(double, double, double);
void arc(double, double, double, double, double, double);
void arrow(double, double, double, double, double, double, double, int);
void line(double, double, double, double);
void box(double, double, double, double);
void spline(double x, double y, double n, ofloat *p, int dashed, double ddval);
void move(double, double);
void troff(char *);
void dot(void);
void fillstart(double), fillend(int vis, int noedge);

void print(void)
{
       obj *p;
       int i, j, k, m;
       int fill, vis, invis;
       double 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;
               fill = p->o_attr & FILLBIT;
               invis = p->o_attr & INVIS;
               vis = !invis;
               switch (p->o_type) {
               case TROFF:
                       troff(text[p->o_nt1].t_val);
                       break;
               case BOX:
               case BLOCK:
                       x0 = ox - x1 / 2;
                       y0 = oy - y1 / 2;
                       x1 = ox + x1 / 2;
                       y1 = oy + y1 / 2;
                       if (fill) {
                               move(x0, y0);
                               fillstart(p->o_fillval);
                       }
                       if (p->o_type == BLOCK)
                               ;       /* nothing at all */
                       else if (invis && !fill)
                               ;       /* 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 (fill)
                               fillend(vis, fill);
                       move(ox, oy);
                       dotext(p);      /* if there are any text strings */
                       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:
                       if (fill)
                               fillstart(p->o_fillval);
                       if (vis || fill)
                               circle(ox, oy, x1);
                       if (fill)
                               fillend(vis, fill);
                       move(ox, oy);
                       dotext(p);
                       if (ishor(m))
                               move(ox + isright(m) ? x1 : -x1, oy);
                       else
                               move(ox, oy + isup(m) ? x1 : -x1);
                       break;
               case ELLIPSE:
                       if (fill)
                               fillstart(p->o_fillval);
                       if (vis || fill)
                               ellipse(ox, oy, x1, y1);
                       if (fill)
                               fillend(vis, fill);
                       move(ox, oy);
                       dotext(p);
                       if (ishor(m))
                               move(ox + isright(m) ? x1 : -x1, oy);
                       else
                               move(ox, oy - isdown(m) ? y1 : -y1);
                       break;
               case ARC:
                       if (fill) {
                               move(ox, oy);
                               fillstart(p->o_fillval);
                       }
                       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 (invis && !fill)
                               /* 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 (fill)
                               fillend(vis, fill);
                       if (p->o_attr & CW_ARC)
                               move(x1, y1);   /* because drawn backwards */
                       move(ox, oy);
                       dotext(p);
                       break;
               case LINE:
               case ARROW:
               case SPLINE:
                       if (fill) {
                               move(ox, oy);
                               fillstart(p->o_fillval);
                       }
                       if (vis && 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 (invis && !fill)
                               move(x1, y1);
                       else if (p->o_type == SPLINE)
                               spline(ox, oy, p->o_val[4], &p->o_val[5], p->o_attr & (DOTBIT|DASHBIT), p->o_ddval);
                       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 (vis && 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);
                       }
                       if (fill)
                               fillend(vis, fill);
                       move((ox + x1)/2, (oy + y1)/2); /* center */
                       dotext(p);
                       break;
               case MOVE:
                       move(ox, oy);
                       break;
               case TEXT:
                       move(ox, oy);
                       if (vis)
                               dotext(p);
                       break;
               }
       }
}

void dotline(double x0, double y0, double x1, double y1, int ddtype, double ddval) /* dotted line */
{
       static double prevval = 0.05;   /* 20 per inch by default */
       int i, numdots;
       double a, b, 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 = (double) i / (double) 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;
}

void dotbox(double x0, double y0, double x1, double y1, int ddtype, double ddval)       /* dotted or dashed box */
{
       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);
}

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

       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;
       }
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.