开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
draw.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：33k
源码类别：

通讯编程

开发平台：

Visual C++

draw.c：源码内容
  1. /* $Header: /usr/src/mash/repository/vint/xgraph/draw.c,v 1.1.1.1 1999/12/03 23:15:53 heideman Exp $ */
  2. /*
  3.  * draw.c: xgraph drawing code
  4.  *
  5.  * Routines:
  6.  * void DrawWindow();
  7.  *
  8.  * $Log: draw.c,v $
  9.  * Revision 1.1.1.1  1999/12/03 23:15:53  heideman
  10.  * xgraph-12.0
  11.  *
  12.  */
  13. #ifndef lint
  14. static char rcsid[] = "$Id: draw.c,v 1.1.1.1 1999/12/03 23:15:53 heideman Exp $";
  15. #endif
  17. #include "copyright.h"
  18. #include <stdio.h>
  19. #include <math.h>
  20. #include <pwd.h>
  21. #include <ctype.h>
  22. #include "xgraph.h"
  23. #include "xtb.h"
  24. #include "hard_devices.h"
  25. #include "params.h"
  28. static void DrawTitle();
  29. static void DrawGridAndAxis();
  30. static void WriteValue();
  31. static void DrawData();
  32. static void DrawLegend();
  33. static int TransformCompute();
  34. static double initGrid();
  35. static double stepGrid();
  36. static double RoundUp();
  37. static void set_mark_flags();
  39. void
  40. DrawWindow(win_info)
  41. LocalWin *win_info; /* Window information */
  43. /*
  44.  * Draws the data in the window.  Does not clear the window.
  45.  * The data is scaled so that all of the data will fit.
  46.  * Grid lines are drawn at the nearest power of 10 in engineering
  47.  * notation.  Draws axis numbers along bottom and left hand edges.
  48.  * Centers title at top of window.
  49.  */
  50. {
  51.     /* Figure out the transformation constants */
  52.     if (TransformCompute(win_info)) {
  54. /* Draw the title */
  55. DrawTitle(win_info);
  57. /* Draw the legend */
  58. if (!PM_BOOL("NoLegend"))
  59.     DrawLegend(win_info);
  61. /* Draw the axis unit labels,  grid lines,  and grid labels */
  62. DrawGridAndAxis(win_info);
  64. /* Draw the data sets themselves */
  65. DrawData(win_info);
  66.     }
  67. }
  72. static void
  73. DrawTitle(wi)
  74. LocalWin *wi; /* Window information    */
  76. /*
  77.  * This routine draws the title of the graph centered in
  78.  * the window.  It is spaced down from the top by an amount
  79.  * specified by the constant PADDING.  The font must be
  80.  * fixed width.  The routine returns the height of the
  81.  * title in pixels.
  82.  */
  83. {
  84.     if (wi->DOrder == 0) 
  85.       wi->dev_info.xg_text(wi->dev_info.user_state,
  86.  (int)(wi->dev_info.area_w*0.95) ,
  87.  wi->dev_info.axis_pad,
  88.  PM_STR("TitleText"), T_UPPERRIGHT, T_TITLE);
  89.     else if (wi->DOrder == 1)
  90.       wi->dev_info.xg_text(wi->dev_info.user_state,
  91.  (int)(wi->dev_info.area_w*0.95) ,
  92.  wi->dev_info.axis_pad,
  93.  "First Derivative", T_UPPERRIGHT, T_TITLE);
  94.     else if (wi->DOrder == 2)
  95.       wi->dev_info.xg_text(wi->dev_info.user_state,
  96.  (int)(wi->dev_info.area_w*0.95) ,
  97.  wi->dev_info.axis_pad,
  98.  "Second Derivative", T_UPPERRIGHT, T_TITLE);
  99. }
  104. static int
  105. TransformCompute(wi)
  106. LocalWin *wi; /* Window information          */
  108. /*
  109.  * This routine figures out how to draw the axis labels and grid lines.
  110.  * Both linear and logarithmic axes are supported.  Axis labels are
  111.  * drawn in engineering notation.  The power of the axes are labeled
  112.  * in the normal axis labeling spots.  The routine also figures
  113.  * out the necessary transformation information for the display
  114.  * of the points (it touches XOrgX, XOrgY, UsrOrgX, UsrOrgY, and
  115.  * UnitsPerPixel).
  116.  */
  117. {
  118.     double  bbCenX,
  119.             bbCenY,
  120.             bbHalfWidth,
  121.             bbHalfHeight;
  122.     int     idx,
  123.             maxName,
  124.             leftWidth;
  125.     char    err[MAXBUFSIZE];
  126.     char   *XUnitText = PM_STR("XUnitText");
  128.     /*
  129.      * First,  we figure out the origin in the X window.  Above the space we
  130.      * have the title and the Y axis unit label. To the left of the space we
  131.      * have the Y axis grid labels.
  132.      */
  134.     wi->XOrgX = wi->dev_info.bdr_pad + (7 * wi->dev_info.axis_width)
  135. + wi->dev_info.bdr_pad;
  136.     wi->XOrgY = wi->dev_info.bdr_pad + wi->dev_info.title_height
  137. + wi->dev_info.bdr_pad + wi->dev_info.axis_height
  138. + wi->dev_info.axis_height / 2 + wi->dev_info.bdr_pad;
  140.     /*
  141.      * Now we find the lower right corner.  Below the space we have the X axis
  142.      * grid labels.  To the right of the space we have the X axis unit label
  143.      * and the legend.  We assume the worst case size for the unit label.
  144.      */
  146.     maxName = 0;
  147.     for (idx = 0; idx < MAXSETS; idx++) {
  148. if (PlotData[idx].list) {
  149.     int     tempSize;
  151.     tempSize = strlen(PlotData[idx].setName);
  152.     if (tempSize > maxName)
  153. maxName = tempSize;
  154. }
  155.     }
  156.     if (PM_BOOL("NoLegend"))
  157. maxName = 0;
  158.     /* Worst case size of the X axis label: */
  159.     leftWidth = (strlen(XUnitText)) * wi->dev_info.axis_width;
  160.     if ((maxName * wi->dev_info.axis_width) + wi->dev_info.bdr_pad > leftWidth)
  161. leftWidth = maxName * wi->dev_info.axis_width + wi->dev_info.bdr_pad;
  163.     wi->XOppX = wi->dev_info.area_w - wi->dev_info.bdr_pad - leftWidth;
  164.     wi->XOppY = wi->dev_info.area_h - wi->dev_info.bdr_pad
  165. - wi->dev_info.axis_height - wi->dev_info.bdr_pad;
  167.     if ((wi->XOrgX >= wi->XOppX) || (wi->XOrgY >= wi->XOppY)) {
  168. do_error(strcpy(err, "Drawing area is too smalln"));
  169. return 0;
  170.     }
  172.     /*
  173.      * We now have a bounding box for the drawing region. Figure out the units
  174.      * per pixel using the data set bounding box.
  175.      */
  176.     wi->XUnitsPerPixel = (wi->hiX - wi->loX) / 
  177.  ((double) (wi->XOppX - wi->XOrgX));
  178.     wi->YUnitsPerPixel = (wi->hiY - wi->loY) / 
  179.  ((double) (wi->XOppY - wi->XOrgY));
  181.     /*
  182.      * Find origin in user coordinate space.  We keep the center of the
  183.      * original bounding box in the same place.
  184.      */
  185.     bbCenX = (wi->loX + wi->hiX) / 2.0;
  186.     bbCenY = (wi->loY + wi->hiY) / 2.0;
  187.     bbHalfWidth = ((double) (wi->XOppX - wi->XOrgX)) / 2.0 * wi->XUnitsPerPixel;
  188.     bbHalfHeight = ((double) (wi->XOppY - wi->XOrgY)) / 2.0 * wi->YUnitsPerPixel;
  189.     wi->UsrOrgX = bbCenX - bbHalfWidth;
  190.     wi->UsrOrgY = bbCenY - bbHalfHeight;
  191.     wi->UsrOppX = bbCenX + bbHalfWidth;
  192.     wi->UsrOppY = bbCenY + bbHalfHeight;
  194.     /*
  195.      * Everything is defined so we can now use the SCREENX and SCREENY
  196.      * transformations.
  197.      */
  198.     return 1;
  199. }
  201. static void
  202. DrawGridAndAxis(wi)
  203. LocalWin *wi; /* Window information         */
  205. /*
  206.  * This routine draws grid line labels in engineering notation,
  207.  * the grid lines themselves,  and unit labels on the axes.
  208.  */
  209. {
  210.     int     expX,
  211.             expY; /* Engineering powers */
  212.     int     startX;
  213.     int     Yspot,
  214.             Xspot;
  215.     char    power[10],
  216.             value[10],
  217.             final[MAXBUFSIZE + 10];
  218.     double  Xincr,
  219.             Yincr,
  220.             Xstart,
  221.             Ystart,
  222.             Yindex,
  223.             Xindex,
  224.             larger;
  225.     XSegment segs[2];
  226.     double  initGrid(),
  227.             stepGrid();
  228.     int     tickFlag = PM_BOOL("Ticks");
  229.     int     axisFlag = PM_BOOL("TickAxis");
  230.     int     logXFlag = PM_BOOL("LogX");
  231.     int     logYFlag = PM_BOOL("LogY");
  232.     char   *XUnitText = PM_STR("XUnitText");
  233.     char   *YUnitText = PM_STR("YUnitText");
  235.     /*
  236.      * Grid display powers are computed by taking the log of the largest
  237.      * numbers and rounding down to the nearest multiple of 3.
  238.      */
  239.     if (logXFlag) {
  240. expX = 0;
  241.     }
  242.     else {
  243. if (fabs(wi->UsrOrgX) > fabs(wi->UsrOppX)) {
  244.     larger = fabs(wi->UsrOrgX);
  245. }
  246. else {
  247.     larger = fabs(wi->UsrOppX);
  248. }
  249. expX = ((int) floor(nlog10(larger) / 3.0)) * 3;
  250.     }
  251.     if (logYFlag) {
  252. expY = 0;
  253.     }
  254.     else {
  255. if (fabs(wi->UsrOrgY) > fabs(wi->UsrOppY)) {
  256.     larger = fabs(wi->UsrOrgY);
  257. }
  258. else {
  259.     larger = fabs(wi->UsrOppY);
  260. }
  261. expY = ((int) floor(nlog10(larger) / 3.0)) * 3;
  262.     }
  264.     /*
  265.      * With the powers computed,  we can draw the axis labels.
  266.      */
  267.     if (expY != 0) {
  268. (void) strcpy(final, YUnitText);
  269. (void) strcat(final, " x 10");
  270. Xspot = wi->dev_info.bdr_pad +
  271.     ((strlen(YUnitText) + 5) * wi->dev_info.axis_width);
  272. Yspot = wi->dev_info.bdr_pad * 2 + wi->dev_info.title_height +
  273.     wi->dev_info.axis_height / 2;
  274. wi->dev_info.xg_text(wi->dev_info.user_state,
  275.      Xspot, Yspot, final, T_RIGHT, T_AXIS);
  276. (void) sprintf(power, "%d", expY);
  277. wi->dev_info.xg_text(wi->dev_info.user_state,
  278.      Xspot, Yspot, power, T_LOWERLEFT, T_AXIS);
  279.     }
  280.     else {
  281. Yspot = wi->dev_info.bdr_pad * 2 + wi->dev_info.title_height;
  282. wi->dev_info.xg_text(wi->dev_info.user_state,
  283.      wi->dev_info.bdr_pad, Yspot, YUnitText,
  284.      T_UPPERLEFT, T_AXIS);
  285.     }
  287.     startX = wi->dev_info.area_w - wi->dev_info.bdr_pad;
  288.     if (expX != 0) {
  289. (void) sprintf(power, "%d", expX);
  290. startX -= (strlen(power) * wi->dev_info.axis_width);
  291. wi->dev_info.xg_text(wi->dev_info.user_state,
  292.      startX, wi->XOppY, power, T_LOWERLEFT, T_AXIS);
  293. (void) strcpy(final, XUnitText);
  294. (void) strcat(final, " x 10");
  295. wi->dev_info.xg_text(wi->dev_info.user_state,
  296.      startX, wi->XOppY, final, T_RIGHT, T_AXIS);
  297.     }
  298.     else {
  299. wi->dev_info.xg_text(wi->dev_info.user_state,
  300.      startX, wi->XOppY, XUnitText, T_RIGHT, T_AXIS);
  301.     }
  303.     /*
  304.      * First,  the grid line labels
  305.      */
  306.     Yincr = (wi->dev_info.axis_pad + wi->dev_info.axis_height) *
  307.     wi->YUnitsPerPixel;
  308.     Ystart = initGrid(wi->UsrOrgY, Yincr, logYFlag);
  309.     for (Yindex = Ystart; Yindex < wi->UsrOppY; Yindex = stepGrid()) {
  310. Yspot = SCREENY(wi, Yindex);
  311. /* Write the axis label */
  312. WriteValue(value, PM_STR("Format X"), Yindex, expY, logYFlag);
  313. wi->dev_info.xg_text(wi->dev_info.user_state,
  314.      wi->dev_info.bdr_pad +
  315.      (7 * wi->dev_info.axis_width),
  316.      Yspot, value, T_RIGHT, T_AXIS);
  317.     }
  319.     Xincr = (wi->dev_info.axis_pad + (wi->dev_info.axis_width * 7)) * 
  320.     wi->XUnitsPerPixel;
  321.     Xstart = initGrid(wi->UsrOrgX, Xincr, logXFlag);
  323.     for (Xindex = Xstart; Xindex < wi->UsrOppX; Xindex = stepGrid()) {
  324. Xspot = SCREENX(wi, Xindex);
  325. /* Write the axis label */
  326. WriteValue(value, PM_STR("Format Y"), Xindex, expX, logXFlag);
  327. wi->dev_info.xg_text(wi->dev_info.user_state,
  328.      Xspot,
  329.      wi->dev_info.area_h - wi->dev_info.bdr_pad,
  330.      value, T_BOTTOM, T_AXIS);
  331.     }
  333.     /*
  334.      * Now,  the grid lines or tick marks
  335.      */
  336.     Yincr = (wi->dev_info.axis_pad + wi->dev_info.axis_height) * 
  337.     wi->YUnitsPerPixel;
  338.     Ystart = initGrid(wi->UsrOrgY, Yincr, logYFlag);
  339.     for (Yindex = Ystart; Yindex < wi->UsrOppY; Yindex = stepGrid()) {
  340. Yspot = SCREENY(wi, Yindex);
  341. /* Draw the grid line or tick mark */
  342. if (tickFlag && !(axisFlag && Yindex == Ystart)) {
  343.     segs[0].x1 = wi->XOrgX;
  344.     segs[0].x2 = wi->XOrgX + wi->dev_info.tick_len;
  345.     segs[1].x1 = wi->XOppX - wi->dev_info.tick_len;
  346.     segs[1].x2 = wi->XOppX;
  347.     segs[0].y1 = segs[0].y2 = segs[1].y1 = segs[1].y2 = Yspot;
  348. }
  349. else {
  350.     segs[0].x1 = wi->XOrgX;
  351.     segs[0].x2 = wi->XOppX;
  352.     segs[0].y1 = segs[0].y2 = Yspot;
  353. }
  354. if ((ABS(Yindex) < ZERO_THRES) && !logYFlag) {
  355.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  356. 1, segs, PM_INT("ZeroWidth"),
  357. L_ZERO, 0, 0);
  358.     if (tickFlag) {
  359. wi->dev_info.xg_seg(wi->dev_info.user_state,
  360.     1, &(segs[1]), PM_INT("ZeroWidth"),
  361.     L_ZERO, 0, 0);
  362.     }
  363. }
  364. else {
  365.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  366. 1, segs, PM_INT("GridSize"),
  367. L_AXIS, 0, 0);
  368.     if (tickFlag) {
  369. wi->dev_info.xg_seg(wi->dev_info.user_state,
  370.     1, &(segs[1]), PM_INT("GridSize"),
  371.     L_AXIS, 0, 0);
  372.     }
  373. }
  374.     }
  376.     Xincr = (wi->dev_info.axis_pad + (wi->dev_info.axis_width * 7)) *
  377. wi->XUnitsPerPixel;
  378.     Xstart = initGrid(wi->UsrOrgX, Xincr, logXFlag);
  379.     for (Xindex = Xstart; Xindex < wi->UsrOppX; Xindex = stepGrid()) {
  380. Xspot = SCREENX(wi, Xindex);
  381. /* Draw the grid line or tick marks */
  382. if (tickFlag && !(axisFlag && Xindex == Xstart)) {
  383.     segs[0].x1 = segs[0].x2 = segs[1].x1 = segs[1].x2 = Xspot;
  384.     segs[0].y1 = wi->XOrgY;
  385.     segs[0].y2 = wi->XOrgY + wi->dev_info.tick_len;
  386.     segs[1].y1 = wi->XOppY - wi->dev_info.tick_len;
  387.     segs[1].y2 = wi->XOppY;
  388. }
  389. else {
  390.     segs[0].x1 = segs[0].x2 = Xspot;
  391.     segs[0].y1 = wi->XOrgY;
  392.     segs[0].y2 = wi->XOppY;
  393. }
  394. if ((ABS(Xindex) < ZERO_THRES) && !logXFlag) {
  395.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  396. 1, segs, PM_INT("ZeroWidth"), L_ZERO, 0, 0);
  397.     if (tickFlag) {
  398. wi->dev_info.xg_seg(wi->dev_info.user_state,
  399.     1, &(segs[1]), PM_INT("ZeroWidth"),
  400.     L_ZERO, 0, 0);
  402.     }
  403. }
  404. else {
  405.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  406. 1, segs, PM_INT("GridSize"), L_AXIS, 0, 0);
  407.     if (tickFlag) {
  408. wi->dev_info.xg_seg(wi->dev_info.user_state,
  409.      1, &(segs[1]), PM_INT("GridSize"), L_AXIS, 0, 0);
  410.     }
  411. }
  412.     }
  413.     /* Check to see if he wants a bounding box */
  414.     if (PM_BOOL("BoundBox")) {
  415. XSegment bb[4];
  417. /* Draw bounding box */
  418. bb[0].x1 = bb[0].x2 = bb[1].x1 = bb[3].x2 = wi->XOrgX;
  419. bb[0].y1 = bb[2].y2 = bb[3].y1 = bb[3].y2 = wi->XOrgY;
  420. bb[1].x2 = bb[2].x1 = bb[2].x2 = bb[3].x1 = wi->XOppX;
  421. bb[0].y2 = bb[1].y1 = bb[1].y2 = bb[2].y1 = wi->XOppY;
  422. wi->dev_info.xg_seg(wi->dev_info.user_state,
  423.     4, bb, PM_INT("GridSize"), L_AXIS, 0, 0);
  424.     }
  425. }
  427. static double gridBase,
  428.         gridStep,
  429.         gridJuke[101];
  430. static int gridNJuke,
  431.         gridCurJuke;
  433. #define ADD_GRID(val) (gridJuke[gridNJuke++] = log10(val))
  435. static double
  436. initGrid(low, step, logFlag)
  437. double  low; /* desired low value          */
  438. double  step; /* desired step (user coords) */
  439. int     logFlag; /* is axis logarithmic?       */
  440. {
  441.     double  ratio,
  442.             x;
  443.     double  RoundUp(),
  444.             stepGrid();
  446.     gridNJuke = gridCurJuke = 0;
  447.     gridJuke[gridNJuke++] = 0.0;
  449.     if (logFlag) {
  450. ratio = pow(10.0, step);
  451. gridBase = floor(low);
  452. gridStep = ceil(step);
  453. if (ratio <= 3.0) {
  454.     if (ratio > 2.0) {
  455. ADD_GRID(3.0);
  456.     }
  457.     else if (ratio > 1.333) {
  458. ADD_GRID(2.0);
  459. ADD_GRID(5.0);
  460.     }
  461.     else if (ratio > 1.25) {
  462. ADD_GRID(1.5);
  463. ADD_GRID(2.0);
  464. ADD_GRID(3.0);
  465. ADD_GRID(5.0);
  466. ADD_GRID(7.0);
  467.     }
  468.     else {
  469. for (x = 1.0; x < 10.0 && (x + .5) / (x + .4) >= ratio; x += .5) {
  470.     ADD_GRID(x + .1);
  471.     ADD_GRID(x + .2);
  472.     ADD_GRID(x + .3);
  473.     ADD_GRID(x + .4);
  474.     ADD_GRID(x + .5);
  475. }
  476. if (floor(x) != x)
  477.     ADD_GRID(x += .5);
  478. for (; x < 10.0 && (x + 1.0) / (x + .5) >= ratio; x += 1.0) {
  479.     ADD_GRID(x + .5);
  480.     ADD_GRID(x + 1.0);
  481. }
  482. for (; x < 10.0 && (x + 1.0) / x >= ratio; x += 1.0) {
  483.     ADD_GRID(x + 1.0);
  484. }
  485. if (x == 7.0) {
  486.     gridNJuke--;
  487.     x = 6.0;
  488. }
  489. if (x < 7.0) {
  490.     ADD_GRID(x + 2.0);
  491. }
  492. if (x == 10.0)
  493.     gridNJuke--;
  494.     }
  495.     x = low - gridBase;
  496.     for (gridCurJuke = -1; x >= gridJuke[gridCurJuke + 1]; gridCurJuke++) {
  497.     }
  498. }
  499.     }
  500.     else {
  501. gridStep = RoundUp(step);
  502. gridBase = floor(low / gridStep) * gridStep;
  503.     }
  504.     return (stepGrid());
  505. }
  507. static double
  508. stepGrid()
  509. {
  510.     if (++gridCurJuke >= gridNJuke) {
  511. gridCurJuke = 0;
  512. gridBase += gridStep;
  513.     }
  514.     return (gridBase + gridJuke[gridCurJuke]);
  515. }
  517. static double
  518. RoundUp(val)
  519. double  val; /* Value */
  521. /*
  522.  * This routine rounds up the given positive number such that
  523.  * it is some power of ten times either 1, 2, or 5.  It is
  524.  * used to find increments for grid lines.
  525.  */
  526. {
  527.     int     exponent,
  528.             idx;
  530.     exponent = (int) floor(nlog10(val));
  531.     if (exponent < 0) {
  532. for (idx = exponent; idx < 0; idx++) {
  533.     val *= 10.0;
  534. }
  535.     }
  536.     else {
  537. for (idx = 0; idx < exponent; idx++) {
  538.     val /= 10.0;
  539. }
  540.     }
  541.     if (val > 5.0)
  542. val = 10.0;
  543.     else if (val > 2.0)
  544. val = 5.0;
  545.     else if (val > 1.0)
  546. val = 2.0;
  547.     else
  548. val = 1.0;
  549.     if (exponent < 0) {
  550. for (idx = exponent; idx < 0; idx++) {
  551.     val /= 10.0;
  552. }
  553.     }
  554.     else {
  555. for (idx = 0; idx < exponent; idx++) {
  556.     val *= 10.0;
  557. }
  558.     }
  559.     return val;
  560. }
  562. static void
  563. WriteValue(str, fmt, val, expv, logFlag)
  564. char   *str; /* String to write into */
  565. char   *fmt; /* Format to print str  */
  566. double  val; /* Value to print       */
  567. int     expv; /* Exponent             */
  568. int     logFlag; /* Is this a log axis?  */
  570. /*
  571.  * Writes the value provided into the string in a fixed format
  572.  * consisting of seven characters.  The format is:
  573.  *   -ddd.dd
  574.  */
  575. {
  576.     int     idx;
  578.     if (logFlag) {
  579. if (val == floor(val)) {
  580.     if (strcmp(fmt, "%.2f") == 0)
  581. fmt = "%.0e";
  582.     val = pow(10.0, val);
  583. }
  584. else {
  585.     if (strcmp(fmt, "%.2f") == 0)
  586. fmt = "%.2g";
  587.     val = pow(10.0, val - floor(val));
  588. }
  589.     }
  590.     else {
  591. if (expv < 0) {
  592.     for (idx = expv; idx < 0; idx++) {
  593. val *= 10.0;
  594.     }
  595. }
  596. else {
  597.     for (idx = 0; idx < expv; idx++) {
  598. val /= 10.0;
  599.     }
  600. }
  601.     }
  602.     if (strchr(fmt, 'd') || strchr(fmt, 'x'))
  603. (void) sprintf(str, fmt, (int) val);
  604.     else
  605. (void) sprintf(str, fmt, val);
  606. }
  609. #define LEFT_CODE 0x01
  610. #define RIGHT_CODE 0x02
  611. #define BOTTOM_CODE 0x04
  612. #define TOP_CODE 0x08
  614. /* Clipping algorithm from Neumann and Sproull by Cohen and Sutherland */
  615. #define C_CODE(xval, yval, rtn) 
  616. rtn = 0; 
  617. if ((xval) < wi->UsrOrgX) rtn = LEFT_CODE; 
  618. else if ((xval) > wi->UsrOppX) rtn = RIGHT_CODE; 
  619. if ((yval) < wi->UsrOrgY) rtn |= BOTTOM_CODE; 
  620. else if ((yval) > wi->UsrOppY) rtn |= TOP_CODE
  622. void
  623. EraseData(wi)
  624. LocalWin *wi;
  626. /*
  627.  * This routine draws the data sets themselves using the macros
  628.  * for translating coordinates.
  629.  */
  630. {
  631.     double  sx1,
  632.             sy1,
  633.             sx2,
  634.             sy2,
  635.             tx = 0,
  636.             ty = 0;
  637.     int     idx,
  638.             subindex;
  639.     int     code1,
  640.             code2,
  641.             cd,
  642.             mark_inside;
  643.     int     X_idx, StoreIDX; /* PW */
  644.     XSegment *ptr;
  645.     PointList *thisList,
  646.               *lastList;
  647.     int     markFlag,
  648.             pixelMarks,
  649.             bigPixel,
  650.             colorMark;
  651.     int     noLines = PM_BOOL("NoLines");
  652.     int     lineWidth = PM_INT("LineWidth");
  654.     /* PW Suggests we Flush and set first */
  655.     set_mark_flags(&markFlag, &pixelMarks, &bigPixel, &colorMark);
  656.     for (idx = 0; idx < MAXSETS; idx++) {
  657.         if (wi->DOrder == 0)
  658.   thisList = PlotData[idx].list;
  659.         else if (wi->DOrder == 1)
  660.     thisList = DataD1[idx].list;
  661.         else if (wi->DOrder == 2)
  662.     thisList = DataD2[idx].list;
  663.         else {
  664.           printf ("Internal Error differentiating - order > 2!n");
  665.           exit (1);
  666.         }
  667. while (thisList) {
  668.     X_idx = 0;
  669.     for (subindex = 0; subindex < thisList->numPoints - 1; subindex++) {
  670. /* Put segment in (sx1,sy1) (sx2,sy2) */
  671. sx1 = thisList->xvec[subindex];
  672. sy1 = thisList->yvec[subindex];
  673. sx2 = thisList->xvec[subindex + 1];
  674. sy2 = thisList->yvec[subindex + 1];
  675. /* Now clip to current window boundary */
  676. C_CODE(sx1, sy1, code1);
  677. C_CODE(sx2, sy2, code2);
  678. mark_inside = (code1 == 0);
  679. while (code1 || code2) {
  680.     if (code1 & code2)
  681. break;
  682.     cd = (code1 ? code1 : code2);
  683.     if (cd & LEFT_CODE) { /* Crosses left edge */
  684. ty = sy1 + (sy2 - sy1) * (wi->UsrOrgX - sx1) / 
  685.  (sx2 - sx1);
  686. tx = wi->UsrOrgX;
  687.     }
  688.     else if (cd & RIGHT_CODE) { /* Crosses right edge */
  689. ty = sy1 + (sy2 - sy1) * (wi->UsrOppX - sx1) / 
  690.  (sx2 - sx1);
  691. tx = wi->UsrOppX;
  692.     }
  693.     else if (cd & BOTTOM_CODE) {/* Crosses bottom edge */
  694. tx = sx1 + (sx2 - sx1) * (wi->UsrOrgY - sy1) / 
  695.  (sy2 - sy1);
  696. ty = wi->UsrOrgY;
  697.     }
  698.     else if (cd & TOP_CODE) { /* Crosses top edge */
  699. tx = sx1 + (sx2 - sx1) * (wi->UsrOppY - sy1) / 
  700.  (sy2 - sy1);
  701. ty = wi->UsrOppY;
  702.     }
  703.     if (cd == code1) {
  704. sx1 = tx;
  705. sy1 = ty;
  706. C_CODE(sx1, sy1, code1);
  707.     }
  708.     else {
  709. sx2 = tx;
  710. sy2 = ty;
  711. C_CODE(sx2, sy2, code2);
  712.     }
  713. }
  714. if (!code1 && !code2) {
  715.     /* Add segment to list */
  716.     Xsegs[0][X_idx].x1 = Xsegs[1][X_idx].x1;
  717.     Xsegs[0][X_idx].y1 = Xsegs[1][X_idx].y1;
  718.     Xsegs[0][X_idx].x2 = Xsegs[1][X_idx].x2;
  719.     Xsegs[0][X_idx].y2 = Xsegs[1][X_idx].y2;
  720.     Xsegs[1][X_idx].x1 = SCREENX(wi, sx1);
  721.     Xsegs[1][X_idx].y1 = SCREENY(wi, sy1);
  722.     Xsegs[1][X_idx].x2 = SCREENX(wi, sx2);
  723.     Xsegs[1][X_idx].y2 = SCREENY(wi, sy2);
  724.     X_idx++;
  725. }
  727. /* Draw markers if requested and they are in drawing region */
  728. if (markFlag && mark_inside) {
  729.     if (pixelMarks) {
  730. if (bigPixel) {
  731.     wi->dev_info.xg_dot(wi->dev_info.user_state,
  732. Xsegs[1][X_idx - 1].x1,
  733. Xsegs[1][X_idx - 1].y1,
  734. P_DOT, 0, idx % MAXATTR);
  735. }
  736. else {
  737.     wi->dev_info.xg_dot(wi->dev_info.user_state,
  738. Xsegs[1][X_idx - 1].x1,
  739. Xsegs[1][X_idx - 1].y1,
  740. P_PIXEL, 0, PIXVALUE(idx));
  741. }
  742.     }
  743.     else {
  744. /* Distinctive markers */
  745. wi->dev_info.xg_dot(wi->dev_info.user_state,
  746.     Xsegs[1][X_idx - 1].x1,
  747.     Xsegs[1][X_idx - 1].y1,
  748.     P_MARK, MARKSTYLE(idx),
  749.     PIXVALUE(idx));
  750.     }
  751. }
  753. /* Draw bar elements if requested */
  754. if (PM_BOOL("BarGraph")) {
  755.     int     barPixels,
  756.             baseSpot;
  757.     XSegment line;
  759.     barPixels = (int) ((PM_DBL("BarWidth") /
  760. wi->XUnitsPerPixel) + 0.5);
  761.     if (barPixels <= 0)
  762. barPixels = 1;
  763.     baseSpot = SCREENY(wi, PM_DBL("BarBase"));
  764.     line.x1 = line.x2 = Xsegs[1][X_idx - 1].x1 + 
  765. (int) ((PM_DBL("BarOffset") * idx /
  766.     wi->XUnitsPerPixel) + 0.5);
  767.     if (PM_BOOL("StackGraph") && idx != 0)
  768. line.y1 = Xsegs[0][X_idx - 1].y1;
  769.     else
  770. line.y1 = baseSpot;
  771.     line.y2 = Xsegs[1][X_idx - 1].y1;
  772.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  773. 1, &line, barPixels, L_VAR,
  774. LINESTYLE(idx), PIXVALUE(idx));
  775. }
  776.     }
  777.     /* Handle last marker */
  778.     if (markFlag && (thisList->numPoints > 0)) {
  779. C_CODE(thisList->xvec[thisList->numPoints - 1],
  780.        thisList->yvec[thisList->numPoints - 1],
  781.        mark_inside);
  782. if (mark_inside == 0) {
  783.     if (pixelMarks) {
  784. if (bigPixel) {
  785.     wi->dev_info.xg_dot(wi->dev_info.user_state,
  786. Xsegs[1][X_idx - 1].x2,
  787. Xsegs[1][X_idx - 1].y2,
  788. P_DOT, 0, idx % MAXATTR);
  789. }
  790. else {
  791.     wi->dev_info.xg_dot(wi->dev_info.user_state,
  792. Xsegs[1][X_idx - 1].x2,
  793. Xsegs[1][X_idx - 1].y2,
  794. P_PIXEL, 0, PIXVALUE(idx));
  795. }
  796.     }
  797.     else {
  798. /* Distinctive markers */
  799. wi->dev_info.xg_dot(wi->dev_info.user_state,
  800.     Xsegs[1][X_idx - 1].x2,
  801.     Xsegs[1][X_idx - 1].y2,
  802.     P_MARK, MARKSTYLE(idx),
  803.     PIXVALUE(idx));
  804.     }
  805. }
  806.     }
  807.     /* Handle last bar */
  808.     if ((thisList->numPoints > 0) && PM_BOOL("BarGraph")) {
  809. int     barPixels,
  810.         baseSpot;
  811. XSegment line;
  813. barPixels = (int) ((PM_DBL("BarWidth") / 
  814.    wi->XUnitsPerPixel) + 0.5);
  815. if (barPixels <= 0)
  816.     barPixels = 1;
  817. baseSpot = SCREENY(wi, PM_DBL("BarBase"));
  818. line.x1 = line.x2 = Xsegs[1][X_idx - 1].x2 +
  819. (int) ((PM_DBL("BarOffset") * idx /
  820.     wi->XUnitsPerPixel) + 0.5);
  821. if (PM_BOOL("StackGraph") && idx != 0)
  822.     line.y1 = Xsegs[0][X_idx - 1].y2;
  823. else
  824.     line.y1 = baseSpot;
  825. line.y2 = Xsegs[1][X_idx - 1].y2;
  826. wi->dev_info.xg_seg(wi->dev_info.user_state,
  827.     1, &line, barPixels, L_VAR,
  828.     LINESTYLE(idx), PIXVALUE(idx));
  829.     }
  831.     /* Erase segments */
  832.     if ((thisList->numPoints > 0) && (!noLines) && (X_idx > 0)) {
  833. ptr = Xsegs[1];
  834. while (X_idx > wi->dev_info.max_segs) {
  835.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  836. wi->dev_info.max_segs, ptr,
  837. lineWidth, L_VAR,
  838. 16, (int)(1));
  839. /*LINESTYLE(8), (int)(1));*/
  840.     ptr += wi->dev_info.max_segs;
  841.     X_idx -= wi->dev_info.max_segs;
  842. }
  843. wi->dev_info.xg_seg(wi->dev_info.user_state,
  844.     X_idx, ptr,
  845.     lineWidth, L_VAR,
  846.     16,(int)(1));
  847.     }
  848.     /* Next subset */
  849.             thisList = thisList->next;
  850. }
  851.     }
  852.     XFlush (disp);
  853. }
  856. static void
  857. DrawData(wi)
  858. LocalWin *wi;
  860. /*
  861.  * This routine draws the data sets themselves using the macros
  862.  * for translating coordinates.
  863.  */
  864. {
  865.     double  sx1,
  866.             sy1,
  867.             sx2,
  868.             sy2,
  869.             tx = 0,
  870.             ty = 0;
  871.     int     idx,
  872.             subindex;
  873.     int     code1,
  874.             code2,
  875.             cd,
  876.             mark_inside;
  877.     int     X_idx, StoreIDX; /* PW */
  878.     XSegment *ptr;
  879.     PointList *thisList,
  880.               *lastList;
  881.     int     markFlag,
  882.             pixelMarks,
  883.             bigPixel,
  884.             colorMark;
  885.     int     noLines = PM_BOOL("NoLines");
  886.     int     lineWidth = PM_INT("LineWidth");
  887.     /* PW */
  888.     int     theDelay;
  890.     /* PW Suggests we Flush and set first */
  891.     theDelay = PM_INT("DelayValue")*100000;
  892.     XFlush(disp);
  893.     if (PM_BOOL("Animate")) sleep(1);
  894.     set_mark_flags(&markFlag, &pixelMarks, &bigPixel, &colorMark);
  895.     for (idx = 0; idx < MAXSETS; idx++) {
  896.         if (wi->DOrder == 0)
  897.   thisList = PlotData[idx].list;
  898.         else if (wi->DOrder == 1)
  899.     thisList = DataD1[idx].list;
  900.         else if (wi->DOrder == 2)
  901.     thisList = DataD2[idx].list;
  902.         else {
  903.           printf ("Internal Error differentiating - order > 2!n");
  904.           exit (1);
  905.         }
  906. while (thisList) {
  907.     X_idx = 0;
  908.     for (subindex = 0; subindex < thisList->numPoints - 1; subindex++) {
  909. /* Put segment in (sx1,sy1) (sx2,sy2) */
  910. sx1 = thisList->xvec[subindex];
  911. sy1 = thisList->yvec[subindex];
  912. sx2 = thisList->xvec[subindex + 1];
  913. sy2 = thisList->yvec[subindex + 1];
  914. /* Now clip to current window boundary */
  915. C_CODE(sx1, sy1, code1);
  916. C_CODE(sx2, sy2, code2);
  917. mark_inside = (code1 == 0);
  918. while (code1 || code2) {
  919.     if (code1 & code2)
  920. break;
  921.     cd = (code1 ? code1 : code2);
  922.     if (cd & LEFT_CODE) { /* Crosses left edge */
  923. ty = sy1 + (sy2 - sy1) * (wi->UsrOrgX - sx1) / 
  924.  (sx2 - sx1);
  925. tx = wi->UsrOrgX;
  926.     }
  927.     else if (cd & RIGHT_CODE) { /* Crosses right edge */
  928. ty = sy1 + (sy2 - sy1) * (wi->UsrOppX - sx1) / 
  929.  (sx2 - sx1);
  930. tx = wi->UsrOppX;
  931.     }
  932.     else if (cd & BOTTOM_CODE) {/* Crosses bottom edge */
  933. tx = sx1 + (sx2 - sx1) * (wi->UsrOrgY - sy1) / 
  934.  (sy2 - sy1);
  935. ty = wi->UsrOrgY;
  936.     }
  937.     else if (cd & TOP_CODE) { /* Crosses top edge */
  938. tx = sx1 + (sx2 - sx1) * (wi->UsrOppY - sy1) / 
  939.  (sy2 - sy1);
  940. ty = wi->UsrOppY;
  941.     }
  942.     if (cd == code1) {
  943. sx1 = tx;
  944. sy1 = ty;
  945. C_CODE(sx1, sy1, code1);
  946.     }
  947.     else {
  948. sx2 = tx;
  949. sy2 = ty;
  950. C_CODE(sx2, sy2, code2);
  951.     }
  952. }
  953. if (!code1 && !code2) {
  954.     /* Add segment to list */
  955.     Xsegs[0][X_idx].x1 = Xsegs[1][X_idx].x1;
  956.     Xsegs[0][X_idx].y1 = Xsegs[1][X_idx].y1;
  957.     Xsegs[0][X_idx].x2 = Xsegs[1][X_idx].x2;
  958.     Xsegs[0][X_idx].y2 = Xsegs[1][X_idx].y2;
  959.     Xsegs[1][X_idx].x1 = SCREENX(wi, sx1);
  960.     Xsegs[1][X_idx].y1 = SCREENY(wi, sy1);
  961.     Xsegs[1][X_idx].x2 = SCREENX(wi, sx2);
  962.     Xsegs[1][X_idx].y2 = SCREENY(wi, sy2);
  963.     X_idx++;
  964. }
  966. /* Draw markers if requested and they are in drawing region */
  967. if (markFlag && mark_inside) {
  968.     if (pixelMarks) {
  969. if (bigPixel) {
  970.     wi->dev_info.xg_dot(wi->dev_info.user_state,
  971. Xsegs[1][X_idx - 1].x1,
  972. Xsegs[1][X_idx - 1].y1,
  973. P_DOT, 0, idx % MAXATTR);
  974. }
  975. else {
  976.     wi->dev_info.xg_dot(wi->dev_info.user_state,
  977. Xsegs[1][X_idx - 1].x1,
  978. Xsegs[1][X_idx - 1].y1,
  979. P_PIXEL, 0, PIXVALUE(idx));
  980. }
  981.     }
  982.     else {
  983. /* Distinctive markers */
  984. wi->dev_info.xg_dot(wi->dev_info.user_state,
  985.     Xsegs[1][X_idx - 1].x1,
  986.     Xsegs[1][X_idx - 1].y1,
  987.     P_MARK, MARKSTYLE(idx),
  988.     PIXVALUE(idx));
  989.     }
  990. }
  992. /* Draw bar elements if requested */
  993. if (PM_BOOL("BarGraph")) {
  994.     int     barPixels,
  995.             baseSpot;
  996.     XSegment line;
  998.     barPixels = (int) ((PM_DBL("BarWidth") /
  999. wi->XUnitsPerPixel) + 0.5);
  1000.     if (barPixels <= 0)
  1001. barPixels = 1;
  1002.     baseSpot = SCREENY(wi, PM_DBL("BarBase"));
  1003.     line.x1 = line.x2 = Xsegs[1][X_idx - 1].x1 + 
  1004. (int) ((PM_DBL("BarOffset") * idx /
  1005.     wi->XUnitsPerPixel) + 0.5);
  1006.     if (PM_BOOL("StackGraph") && idx != 0)
  1007. line.y1 = Xsegs[0][X_idx - 1].y1;
  1008.     else
  1009. line.y1 = baseSpot;
  1010.     line.y2 = Xsegs[1][X_idx - 1].y1;
  1011.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  1012. 1, &line, barPixels, L_VAR,
  1013. LINESTYLE(idx), PIXVALUE(idx));
  1014. }
  1015.     }
  1016.     /* Handle last marker */
  1017.     if (markFlag && (thisList->numPoints > 0)) {
  1018. C_CODE(thisList->xvec[thisList->numPoints - 1],
  1019.        thisList->yvec[thisList->numPoints - 1],
  1020.        mark_inside);
  1021. if (mark_inside == 0) {
  1022.     if (pixelMarks) {
  1023. if (bigPixel) {
  1024.     wi->dev_info.xg_dot(wi->dev_info.user_state,
  1025. Xsegs[1][X_idx - 1].x2,
  1026. Xsegs[1][X_idx - 1].y2,
  1027. P_DOT, 0, idx % MAXATTR);
  1028. }
  1029. else {
  1030.     wi->dev_info.xg_dot(wi->dev_info.user_state,
  1031. Xsegs[1][X_idx - 1].x2,
  1032. Xsegs[1][X_idx - 1].y2,
  1033. P_PIXEL, 0, PIXVALUE(idx));
  1034. }
  1035.     }
  1036.     else {
  1037. /* Distinctive markers */
  1038. wi->dev_info.xg_dot(wi->dev_info.user_state,
  1039.     Xsegs[1][X_idx - 1].x2,
  1040.     Xsegs[1][X_idx - 1].y2,
  1041.     P_MARK, MARKSTYLE(idx),
  1042.     PIXVALUE(idx));
  1043.     }
  1044. }
  1045.     }
  1046.     /* Handle last bar */
  1047.     if ((thisList->numPoints > 0) && PM_BOOL("BarGraph")) {
  1048. int     barPixels,
  1049.         baseSpot;
  1050. XSegment line;
  1052. barPixels = (int) ((PM_DBL("BarWidth") / 
  1053.    wi->XUnitsPerPixel) + 0.5);
  1054. if (barPixels <= 0)
  1055.     barPixels = 1;
  1056. baseSpot = SCREENY(wi, PM_DBL("BarBase"));
  1057. line.x1 = line.x2 = Xsegs[1][X_idx - 1].x2 +
  1058. (int) ((PM_DBL("BarOffset") * idx /
  1059.     wi->XUnitsPerPixel) + 0.5);
  1060. if (PM_BOOL("StackGraph") && idx != 0)
  1061.     line.y1 = Xsegs[0][X_idx - 1].y2;
  1062. else
  1063.     line.y1 = baseSpot;
  1064. line.y2 = Xsegs[1][X_idx - 1].y2;
  1065. wi->dev_info.xg_seg(wi->dev_info.user_state,
  1066.     1, &line, barPixels, L_VAR,
  1067.     LINESTYLE(idx), PIXVALUE(idx));
  1068.     }
  1070.     /* Draw segments */
  1071.             if (!PM_BOOL("Animate")) {
  1072.       if (thisList->numPoints > 0 && (!noLines) && (X_idx > 0)) {
  1073. ptr = Xsegs[1];
  1074. while (X_idx > wi->dev_info.max_segs) {
  1075.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  1076. wi->dev_info.max_segs, ptr,
  1077. lineWidth, L_VAR,
  1078. LINESTYLE(idx), PIXVALUE(idx));
  1079.     ptr += wi->dev_info.max_segs;
  1080.     X_idx -= wi->dev_info.max_segs;
  1081. }
  1082. wi->dev_info.xg_seg(wi->dev_info.user_state,
  1083.     X_idx, ptr,
  1084.     lineWidth, L_VAR,
  1085.     LINESTYLE(idx), PIXVALUE(idx));
  1086.       }
  1087.             } else {
  1088.               StoreIDX = X_idx;
  1089.       if (thisList->numPoints > 0 && (!noLines) && (X_idx > 0)) {
  1090. ptr = Xsegs[1];
  1091. while (X_idx > wi->dev_info.max_segs) {
  1092.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  1093. wi->dev_info.max_segs, ptr,
  1094. lineWidth, L_VAR,
  1095. LINESTYLE(1), PIXVALUE(2));
  1096.     ptr += wi->dev_info.max_segs;
  1097.     X_idx -= wi->dev_info.max_segs;
  1098. }
  1099. wi->dev_info.xg_seg(wi->dev_info.user_state,
  1100.     X_idx, ptr,
  1101.     lineWidth, L_VAR,
  1102.     LINESTYLE(1), PIXVALUE(2));
  1103.       }
  1104.               XFlush (disp);
  1105.       for (X_idx=1;X_idx<theDelay;X_idx++);
  1106.               X_idx = StoreIDX;
  1107.       if ((thisList->numPoints > 0) && (!noLines) && (X_idx > 0)) {
  1108. ptr = Xsegs[1];
  1109. while (X_idx > wi->dev_info.max_segs) {
  1110.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  1111. wi->dev_info.max_segs, ptr,
  1112. lineWidth, L_VAR,
  1113. 16, (int)(1));
  1114. /*LINESTYLE(8), (int)(1));*/
  1115.     ptr += wi->dev_info.max_segs;
  1116.     X_idx -= wi->dev_info.max_segs;
  1117. }
  1118. wi->dev_info.xg_seg(wi->dev_info.user_state,
  1119.     X_idx, ptr,
  1120.     lineWidth, L_VAR,
  1121.     16,(int)(1));
  1122.       }
  1123.             }
  1124.     /* Next subset */
  1125.             lastList = thisList;
  1126.             thisList = thisList->next;
  1127. } /* End While */
  1128.       }
  1129.         if (PM_BOOL("Animate")) {
  1130.           X_idx = StoreIDX;
  1131.           thisList = lastList;
  1132.   if (thisList->numPoints > 0 && (!noLines) && (X_idx > 0)) {
  1133.     ptr = Xsegs[1];
  1134.        while (X_idx > wi->dev_info.max_segs) {
  1135.     wi->dev_info.xg_seg(wi->dev_info.user_state,
  1136. wi->dev_info.max_segs, ptr,
  1137. lineWidth, L_VAR,
  1138. LINESTYLE(1), PIXVALUE(2));
  1139.     ptr += wi->dev_info.max_segs;
  1140.     X_idx -= wi->dev_info.max_segs;
  1141. }
  1142. wi->dev_info.xg_seg(wi->dev_info.user_state,
  1143.     X_idx, ptr,
  1144.     lineWidth, L_VAR,
  1145.     LINESTYLE(1), PIXVALUE(2));
  1146.     }
  1147.           }
  1148.     XFlush (disp);
  1149. }
  1153. static void
  1154. DrawLegend(wi)
  1155. LocalWin *wi;
  1157. /*
  1158.  * This draws a legend of the data sets displayed.  Only those that
  1159.  * will fit are drawn.
  1160.  */
  1161. {
  1162.     int     idx,
  1163.             spot,
  1164.             lineLen,
  1165.             oneLen, 
  1166.     incr;
  1167.     XSegment leg_line;
  1168.     int     markFlag,
  1169.             pixelMarks,
  1170.             bigPixel,
  1171.             colorMark;
  1173.     set_mark_flags(&markFlag, &pixelMarks, &bigPixel, &colorMark);
  1174.     spot = wi->XOrgY;
  1175.     lineLen = 0;
  1176.     incr = 2 + wi->dev_info.axis_height + wi->dev_info.bdr_pad;
  1177.     /* First pass draws the text */
  1178.     for (idx = 0; idx < MAXSETS; idx++) {
  1179. if ((PlotData[idx].list) &&
  1180.     (spot + wi->dev_info.axis_height + 2 < wi->XOppY)) {
  1181.     /* Meets the criteria */
  1182.     oneLen = strlen(PlotData[idx].setName);
  1183.     if (oneLen > lineLen)
  1184. lineLen = oneLen;
  1185.     wi->dev_info.xg_text(wi->dev_info.user_state,
  1186.  wi->XOppX + wi->dev_info.bdr_pad,
  1187.  spot + 2,
  1188.  PlotData[idx].setName,
  1189.  T_UPPERLEFT, T_AXIS);
  1190.     spot += incr;
  1191. }
  1192.     }
  1193.     lineLen = lineLen * wi->dev_info.axis_width;
  1194.     leg_line.x1 = wi->XOppX + wi->dev_info.bdr_pad;
  1195.     leg_line.x2 = leg_line.x1 + lineLen;
  1196.     spot = wi->XOrgY;
  1197.     /* second pass draws the lines */
  1198.     for (idx = 0; idx < MAXSETS; idx++) {
  1199. if ((PlotData[idx].list) &&
  1200.     (spot + wi->dev_info.axis_height + 2 < wi->XOppY)) {
  1201.     leg_line.y1 = leg_line.y2 = spot - wi->dev_info.legend_pad;
  1202.     if (PM_BOOL("BarGraph")) 
  1203. wi->dev_info.xg_seg(wi->dev_info.user_state,
  1204.     1, &leg_line,
  1205.     incr / 4,
  1206.     L_VAR, LINESTYLE(idx), PIXVALUE(idx));
  1207.     if (!PM_BOOL("NoLines"))
  1208. wi->dev_info.xg_seg(wi->dev_info.user_state,
  1209.     1, &leg_line, 1, L_VAR,
  1210.     LINESTYLE(idx), PIXVALUE(idx));
  1211.     if (markFlag && !pixelMarks) {
  1212. wi->dev_info.xg_dot(wi->dev_info.user_state,
  1213.     leg_line.x1, leg_line.y1,
  1214.     P_MARK, MARKSTYLE(idx), PIXVALUE(idx));
  1216.     }
  1217.     spot += incr;
  1218. }
  1219.     }
  1220. }
  1221. static void
  1222. set_mark_flags(markFlag, pixelMarks, bigPixel, colorMark)
  1223. int    *markFlag;
  1224. int    *pixelMarks;
  1225. int    *bigPixel;
  1226. int    *colorMark;
  1228. /*
  1229.  * Determines the values of the old boolean flags based on the
  1230.  * new values in the parameters database.
  1231.  */
  1232. {
  1233.     *markFlag = 0;
  1234.     *pixelMarks = 0;
  1235.     *colorMark = 0;
  1236.     *bigPixel = 0;
  1237.     if (PM_BOOL("Markers")) {
  1238. *markFlag = 1;
  1239. *pixelMarks = 0;
  1240. *colorMark = 0;
  1241.     }
  1242.     if (PM_BOOL("PixelMarkers")) {
  1243. *markFlag = 1;
  1244. *pixelMarks = 1;
  1245. *bigPixel = 0;
  1246.     }
  1247.     if (PM_BOOL("LargePixels")) {
  1248. *markFlag = 1;
  1249. *pixelMarks = 1;
  1250. *bigPixel = 1;
  1251.     }
  1252.     if (PM_BOOL("StyleMarkers")) {
  1253. *markFlag = 1;
  1254. *pixelMarks = 0;
  1255. *colorMark = 1;
  1256.     }
  1257. }
  1258.  
  1259. #undef DELAY