home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume8 / xfig2.8 / part07 / draw.c < prev    next >
C/C++ Source or Header  |  1990-07-02  |  8KB  |  382 lines
  1. /* 
  2.  *    FIG : Facility for Interactive Generation of figures
  3.  *
  4.  *    Copyright (c) 1988 by Supoj Sutanthavibul (supoj@sally.UTEXAS.EDU)
  5.  *    March 1988.
  6.  *
  7.  *    %W%    %G%
  8. */
  9. #include "fig.h"
  10. #include "resources.h"
  11. #include "object.h"
  12. #include "paintop.h"
  13.  
  14. extern int        pointmarker_shown, compoundbox_shown;
  15. extern int        background_color, foreground_color;
  16.  
  17. /* COMMENTED OUT
  18. erase_objects(objects)
  19. F_compound    *objects;
  20. {
  21.     erase_arcs(objects->arcs);
  22.     erase_ellipses(objects->ellipses);
  23.     erase_lines(objects->lines);
  24.     erase_texts(objects->texts);
  25.     erase_splines(objects->splines);
  26.     erase_compounds(objects->compounds);
  27.     }
  28. */
  29.  
  30. erase_splines(splines)
  31. F_spline    *splines;
  32. {
  33.     F_spline    *s;
  34.  
  35.     for (s = splines; s != NULL; s = s->next) {
  36.         if (pointmarker_shown) toggle_splinepointmarker(s);
  37.         draw_spline(s, ERASE);
  38.         };
  39.     }
  40.  
  41. erase_ellipses(ellipses)
  42. F_ellipse    *ellipses;
  43. {
  44.     F_ellipse    *e;
  45.  
  46.     for (e = ellipses; e != NULL; e = e->next) {
  47.         if (pointmarker_shown) toggle_ellipsepointmarker(e);
  48.         draw_ellipse(e, background_color);
  49.         };
  50.     }
  51.  
  52. erase_arcs(arcs)
  53. F_arc    *arcs;
  54. {
  55.     F_arc    *a;
  56.  
  57.     for (a = arcs; a != NULL; a = a->next) {
  58.         if (pointmarker_shown) toggle_arcpointmarker(a);
  59.         draw_arc(a, background_color);
  60.         };
  61.     }
  62.  
  63. erase_compounds(compounds)
  64. F_compound    *compounds;
  65. {
  66.     F_compound    *c;
  67.  
  68.     for (c = compounds; c != NULL; c = c->next) {
  69.         if (compoundbox_shown) draw_compoundbox(c, INV_PAINT);
  70.         erase_compound(c);
  71.         };
  72.     }
  73.  
  74. erase_lines(lines)
  75. F_line    *lines;
  76. {
  77.     F_line    *l;
  78.  
  79.     for (l = lines; l != NULL; l = l->next) {
  80.         if (pointmarker_shown) toggle_linepointmarker(l);
  81.         draw_line(l, ERASE);
  82.         };
  83.     }
  84.  
  85. erase_texts(texts)
  86. F_text    *texts;
  87. {
  88.     F_text    *t;
  89.  
  90.     for (t = texts; t != NULL; t = t->next) {
  91.         draw_text(t, INV_PAINT);
  92.         };
  93.     }
  94.  
  95. /*
  96. draw_objects(objects)
  97. F_compound    *objects;
  98. {
  99.     draw_arcs(objects->arcs);
  100.     draw_ellipses(objects->ellipses);
  101.     draw_lines(objects->lines);
  102.     draw_texts(objects->texts);
  103.     draw_splines(objects->splines);
  104.     draw_compounds(objects->compounds);
  105.     }
  106. */
  107.  
  108. draw_ellipses(ellipses)
  109. F_ellipse    *ellipses;
  110. {
  111.     F_ellipse    *e;
  112.  
  113.     for (e = ellipses; e != NULL; e = e->next) {
  114.         draw_ellipse(e, foreground_color);
  115.         if (pointmarker_shown) toggle_ellipsepointmarker(e);
  116.         };
  117.     }
  118.  
  119. draw_arcs(arcs)
  120. F_arc    *arcs;
  121. {
  122.     F_arc    *a;
  123.  
  124.     for (a = arcs; a != NULL; a = a->next) {
  125.         draw_arc(a, foreground_color);
  126.         if (pointmarker_shown) toggle_arcpointmarker(a);
  127.         };
  128.     }
  129.  
  130. draw_lines(lines)
  131. F_line    *lines;
  132. {
  133.     F_line    *l;
  134.  
  135.     for (l = lines; l != NULL; l = l->next) {
  136.         draw_line(l, PAINT);
  137.         if (pointmarker_shown) 
  138.         toggle_linepointmarker(l);
  139.         }
  140.     }
  141.  
  142. draw_splines(splines)
  143. F_spline    *splines;
  144. {
  145.     F_spline    *s;
  146.  
  147.     for (s = splines; s != NULL; s = s->next) {
  148.         draw_spline(s, PAINT);
  149.         if (pointmarker_shown) toggle_splinepointmarker(s);
  150.         };
  151.     }
  152.  
  153. draw_texts(texts)
  154. F_text    *texts;
  155. {
  156.     F_text    *t;
  157.  
  158.     for (t = texts; t != NULL; t = t->next) {
  159.         draw_text(t, PAINT);
  160.         };
  161.     }
  162.  
  163. draw_compounds(compounds)
  164. F_compound    *compounds;
  165. {
  166.     F_compound    *c;
  167.  
  168.     for (c = compounds; c != NULL; c = c->next) {
  169.         draw_compound(c);
  170.         if (compoundbox_shown) draw_compoundbox(c, INV_PAINT);
  171.         };
  172.     }
  173.  
  174. /*    draw arrow heading from (x1, y1) to (x2, y2)    */
  175.  
  176. draw_arrow(x1, y1, x2, y2, arrow, op)
  177. int    x1, y1, x2, y2, op;
  178. F_arrow    *arrow;
  179. {
  180.     float    x, y, xb, yb, dx, dy, l, sina, cosa;
  181.     int    xc, yc, xd, yd;
  182.     float    wid = arrow->wid, ht = arrow->ht;
  183.  
  184.     dx = x2 - x1;  dy = y1 - y2;
  185.     l = sqrt((double)(dx*dx + dy*dy));
  186.     if(l == 0)
  187.         return;
  188.     sina = dy / l;  cosa = dx / l;
  189.     xb = x2*cosa - y2*sina;
  190.     yb = x2*sina + y2*cosa;
  191.     x = xb - ht;
  192.     y = yb - wid / 2;
  193.     xc = x*cosa + y*sina + .5;
  194.     yc = -x*sina + y*cosa + .5;
  195.     y = yb + wid / 2;
  196.     xd = x*cosa + y*sina + .5;
  197.     yd = -x*sina + y*cosa + .5;
  198.     pw_vector(canvas_win, xc, yc, x2, y2, op, 
  199.            (int) arrow->thickness, arrow->style, 0.0);
  200.     pw_vector(canvas_win, xd, yd, x2, y2, op, 
  201.            (int) arrow->thickness, arrow->style, 0.0);
  202.     }
  203.  
  204. draw_spline(spline, op)
  205. F_spline    *spline;
  206. int        op;
  207. {
  208.     if (int_spline(spline))
  209.         draw_intspline(spline, op);
  210.     else if (spline->type == T_CLOSED_NORMAL)
  211.         draw_closed_spline(spline, op);
  212.     else if (spline->type == T_OPEN_NORMAL)
  213.         draw_open_spline(spline, op);
  214.     }
  215.  
  216. #define        STACK_DEPTH        32
  217. typedef        struct stack {
  218.             float    x1, y1, x2, y2, x3, y3, x4, y4;
  219.             }
  220.         Stack;
  221. static Stack    stack[20];
  222. static Stack    *stack_top;
  223. static int    stack_count;
  224.  
  225. clear_stack()
  226. {
  227.     stack_top = stack;
  228.     stack_count = 0;
  229.     }
  230.  
  231. push(x1, y1, x2, y2, x3, y3, x4, y4)
  232. float    x1, y1, x2, y2, x3, y3, x4, y4;
  233. {
  234.     stack_top->x1 = x1;
  235.     stack_top->y1 = y1;
  236.     stack_top->x2 = x2;
  237.     stack_top->y2 = y2;
  238.     stack_top->x3 = x3;
  239.     stack_top->y3 = y3;
  240.     stack_top->x4 = x4;
  241.     stack_top->y4 = y4;
  242.     stack_top++;
  243.     stack_count++;
  244.     }
  245.  
  246. int
  247. pop(x1, y1, x2, y2, x3, y3, x4, y4)
  248. float    *x1, *y1, *x2, *y2, *x3, *y3, *x4, *y4;
  249. {
  250.     if (stack_count == 0) return(0);
  251.     stack_top--;
  252.     stack_count--;
  253.     *x1 = stack_top->x1;
  254.     *y1 = stack_top->y1;
  255.     *x2 = stack_top->x2;
  256.     *y2 = stack_top->y2;
  257.     *x3 = stack_top->x3;
  258.     *y3 = stack_top->y3;
  259.     *x4 = stack_top->x4;
  260.     *y4 = stack_top->y4;
  261.     return(1);
  262.     }
  263.  
  264. draw_line(line, op)
  265. F_line    *line;
  266. int    op;
  267. {
  268.     F_point        *point;
  269.     XPoint        *points, *pptr;
  270.     int        npoints;
  271.     int        xx, yy, x, y;
  272.  
  273.     /* fill the object first then draw outline */
  274.     fill_object(line,op);
  275.  
  276.     if (line->type == T_ARC_BOX)    /* box with rounded corners */
  277.         {
  278.         draw_arc_box(line,op);
  279.         return;
  280.         }
  281.  
  282.     point = line->points;
  283.     /* get and save first point */
  284.     x = point->x;
  285.     y = point->y;
  286.     if (line->points->next == NULL) { /* A single point */
  287.         XDrawPoint(tool_d, canvas_win, gccache[op], x, y);
  288.         return;
  289.         }
  290.     if (line->back_arrow) /* backward arrow  */
  291.         draw_arrow(point->next->x, point->next->y, x, y, 
  292.         line->back_arrow, op);
  293.     if (line->style == SOLID_LINE)    /* accumulate the points for solid line */
  294.         {
  295.         npoints = 0;
  296.         /* count number of points in this object */
  297.         for ( ; point != NULL; point = point->next)
  298.             npoints++;
  299.         /* accumulate the points in an array */
  300.         if ((points = (XPoint *) malloc(npoints*sizeof(XPoint))) == 0)
  301.             {
  302.             fprintf(stderr,"draw_line(): No memory\n");
  303.             return;
  304.             }
  305.         pptr = points;
  306.         }
  307.     for (point=line->points; point != NULL; point = point->next) {
  308.         if (line->style == SOLID_LINE)
  309.             {
  310.             pptr->x = point->x;
  311.             pptr->y = point->y;
  312.             pptr++;
  313.             }
  314.         else    /* draw dashed or dotted line segment by segment
  315.                otherwise when moving one segment later there
  316.                is an alignment problem with the dashes */
  317.         pw_vector(canvas_win, x, y, point->x, point->y, op,
  318.             line->thickness, line->style, line->style_val);
  319.         xx = x; yy = y;
  320.         x = point->x;
  321.         y = point->y;
  322.         }
  323.     if (line->style == SOLID_LINE)
  324.         {
  325.         pw_lines(canvas_win, points, npoints, op, 
  326.         line->thickness, line->style, line->style_val, 0);
  327.         free(points);
  328.         }
  329.     if (line->for_arrow) 
  330.         draw_arrow(xx, yy, x, y, line->for_arrow, op);
  331.     }
  332.  
  333. draw_arc_box(line, op)
  334. F_line *line;
  335. int op;
  336.     {
  337.     F_point        *point;
  338.     int        xmin,xmax,ymin,ymax;
  339.     int        thick, style;
  340.     float        val;
  341.     int        radius,diam;
  342.     GC        gc;
  343.  
  344.     thick = line->thickness;
  345.     if (thick == 0)
  346.         return;
  347.     point = line->points;
  348.     style = line->style;
  349.     val   = line->style_val;
  350.     radius = line->radius;
  351.  
  352.     xmin = xmax = point->x;
  353.     ymin = ymax = point->y;
  354.     while (point->next)        /* find lower left (upper-left on screen) */
  355.         {            /* and upper right (lower right on screen) */
  356.         point = point->next;
  357.         if (point->x < xmin)
  358.             xmin = point->x;
  359.         else if (point->x > xmax)
  360.             xmax = point->x;
  361.         if (point->y < ymin)
  362.             ymin = point->y;
  363.         else if (point->y > ymax)
  364.             ymax = point->y;
  365.         }
  366.     set_line_stuff(thick,style,val,op);
  367.     gc = gccache[op];
  368.     diam = 2*radius;
  369.     XDrawArc(tool_d, canvas_win, gc, xmin, ymin,
  370.             diam, diam, 90*64, 90*64);
  371.     XDrawLine(tool_d, canvas_win, gc, xmin, ymin+radius, xmin, ymax-radius+1);
  372.     XDrawArc(tool_d, canvas_win, gc, xmin, ymax-diam,
  373.             diam, diam, 180*64, 90*64);
  374.     XDrawLine(tool_d, canvas_win, gc, xmin+radius, ymax, xmax-radius+1, ymax);
  375.     XDrawArc(tool_d, canvas_win, gc, xmax-diam, ymax-diam,
  376.             diam, diam, 270*64, 90*64);
  377.     XDrawLine(tool_d, canvas_win, gc, xmax, ymax-radius, xmax, ymin+radius-1);
  378.     XDrawArc(tool_d, canvas_win, gc, xmax-diam, ymin,
  379.             diam, diam, 0*64, 90*64);
  380.     XDrawLine(tool_d, canvas_win, gc, xmax-radius, ymin, xmin+radius-1, ymin);
  381.     }
  382.