home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d3xx / d386 / xlispstat.lha / XLispStat / src1.lzh / IView / iview.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-09  |  32.1 KB  |  1,206 lines
  1. /* XLISP-STAT 2.1 Copyright (c) 1990, by Luke Tierney                  */
  2. /* Additions to Xlisp 2.1, Copyright (c) 1989 by David Michael Betz    */
  3. /* You may give out copies of this software; for conditions see the    */
  4. /* file COPYING included with this distribution.                       */
  5.  
  6. #include "xlisp.h"
  7. #include "osdef.h"
  8. #ifdef ANSI
  9. #include "xlproto.h"
  10. #include "xlsproto.h"
  11. #include "iviewproto.h"
  12. #include "Stproto.h"
  13. #else
  14. #include "xlfun.h"
  15. #include "xlsfun.h"
  16. #include "iviewfun.h"
  17. #include "Stfun.h"
  18. #endif ANSI
  19.  
  20. /* forward declarations */
  21. #ifdef ANSI
  22. void IViewDrawDataLine(IVIEW_WINDOW,unsigned,unsigned,unsigned,int,int,int,int,
  23.      int,int,int,ColorCode),
  24.      IViewDrawDataString(IVIEW_WINDOW,unsigned,unsigned,unsigned,int,int,int,
  25.      int,int,int,int,ColorCode),
  26.      DrawPoint(IVIEW_WINDOW,int,PointState,int,int,int,int,int,int,int,int,int),
  27.      DrawLabel(IVIEW_WINDOW,int,int,int,int,int,int,int,int,int);
  28. double NiceValue(double);
  29. #else
  30. void IViewDrawDataLine(),
  31.      IViewDrawDataString(),
  32.      DrawPoint(),
  33.      DrawLabel();
  34. double NiceValue();
  35. #endif
  36.  
  37. #define LABEL_OFFSET 5
  38.  
  39. #ifndef TRUE
  40. #define TRUE 1
  41. #endif TRUE
  42. #ifndef FALSE
  43. #define FALSE 0
  44. #endif FALSE
  45.  
  46. /**************************************************************************/
  47. /**                                                                      **/
  48. /**                    General IView Data Functions                      **/
  49. /**                                                                      **/
  50. /**************************************************************************/
  51. int StGrNumVariables(gwinfo)
  52.     /* char */StGWWinInfo *gwinfo; /* changed JKL */
  53. {
  54.   return(IViewDataNumVariables(StGrData(gwinfo)));
  55. }
  56. /*       macros in iviewdef.h JKL
  57. int IViewNumVariables(w)
  58.      IVIEW_WINDOW w;
  59. {
  60.   return(IViewDataNumVariables(IViewData(w)));
  61. }
  62.  
  63. void IViewSetVariableLabel(w, var, s)
  64.      IVIEW_WINDOW w;
  65.      int var;
  66.      char *s;
  67. {
  68.   IViewDataSetVariableLabel(IViewData(w), var, s);
  69. }
  70.  
  71. char *IViewVariableLabel(w, var)
  72.      IVIEW_WINDOW w;
  73.      int var;
  74. {
  75.   return(IViewDataVariableLabel(IViewData(w), var));
  76. }
  77. */
  78. void IViewSetRange(w, var, low, high)
  79.      IVIEW_WINDOW w;
  80.      int var;
  81.      double low, high;
  82. {
  83.   double scale, shift;
  84.  
  85.   scale = IViewScale(w, var);
  86.   shift = IViewShift(w, var);
  87.   low = scale * low + shift;
  88.   high = scale * high + shift;
  89.   IViewSetScaledRange(w, var, low, high);
  90. }
  91.  
  92. void IViewGetRange(w, var, low, high)
  93.      IVIEW_WINDOW w;
  94.      int var;
  95.      double *low, *high;
  96. {
  97.   double scale, shift;
  98.  
  99.   scale = IViewScale(w, var);
  100.   shift = IViewShift(w, var);
  101.   IViewGetScaledRange(w, var, low, high);
  102.   if (scale > 0.0) {
  103.     if (low != nil) *low = (*low - shift) / scale;
  104.     if (high != nil) *high = (*high - shift) / scale;
  105.   }
  106. }
  107. /* macros in iviewdef.h JKL
  108. void IViewSetScaledRange(w, var, low, high)
  109.      IVIEW_WINDOW w;
  110.      int var;
  111.      double low, high;
  112. {
  113.   IViewDataSetRange(IViewData(w), var, low, high);
  114. }
  115.  
  116. void IViewGetScaledRange(w, var, low, high)
  117.      IVIEW_WINDOW w;
  118.      int var;
  119.      double *low, *high;
  120. {
  121.   IViewDataGetRange(IViewData(w), var, low, high);
  122. }
  123.  
  124. void IViewSetScreenRange(w, var, low, high)
  125.      IVIEW_WINDOW w;
  126.      int var, low, high;
  127. {
  128.   IViewDataSetScreenRange(IViewData(w), var, low, high);
  129. }
  130.  
  131. void IViewGetScreenRange(w, var, low, high)
  132.      IVIEW_WINDOW w;
  133.      int var, *low, *high;
  134. {
  135.   IViewDataGetScreenRange(IViewData(w), var, low, high);
  136. }
  137.  
  138. void IViewSetIdentityTransformation(w)
  139.     IVIEW_WINDOW w;
  140. {
  141.   IViewDataSetIdentityTransformation(IViewData(w));
  142. }
  143.  
  144. void IViewSetTransformation(w, a)
  145.     IVIEW_WINDOW w;
  146.     double **a;
  147. {
  148.   IViewDataSetTransformation(IViewData(w), a);
  149. }
  150.  
  151. double **IViewTransformation(w)
  152.     IVIEW_WINDOW w;
  153. {
  154.   return(IViewDataTransformation(IViewData(w)));
  155. }
  156.  
  157. int IViewIsTransformed(w)
  158.     IVIEW_WINDOW w;
  159. {
  160.   return(IViewDataIsTransformed(IViewData(w)));
  161. }
  162.  
  163. void IViewApplyTransformation(w, a, inbasis)
  164.     IVIEW_WINDOW w;
  165.     double **a;
  166.     int *inbasis;
  167. {
  168.   IViewDataApplyTransformation(IViewData(w), a, inbasis);
  169. }
  170. */
  171. double IViewEncodeValue(w, value, var)
  172.     IVIEW_WINDOW w;
  173.     double value;
  174.     int var;
  175. {
  176.   double scale = IViewScale(w, var), shift = IViewShift(w, var);
  177.   if (scale == 1.0 && shift == 0.0) return(value);
  178.   else return(scale * value + shift);
  179. }
  180.  
  181. double IViewDecodeValue(w, value, var)
  182.     IVIEW_WINDOW w;
  183.     double value;
  184.     int var;
  185. {
  186.   double scale = IViewScale(w, var), shift = IViewShift(w, var);
  187.   return((scale > 0.0) ? (value - shift) / scale : 0.0);
  188. }
  189.  
  190. /**************************************************************************/
  191. /**                                                                      **/
  192. /**                      IView Point Data Functions                      **/
  193. /**                                                                      **/
  194. /**************************************************************************/
  195. /* macros in iviewdef.h JKL
  196. void IViewAddPoints(w, n)
  197.      IVIEW_WINDOW w;
  198.      int n;
  199. {
  200.   IViewDataAddPoints(IViewData(w), n);
  201. }
  202.  
  203. void IViewClearPoints(w)
  204.      IVIEW_WINDOW w;
  205. {
  206.   IViewDataClearPoints(IViewData(w));
  207. }
  208.  
  209. int IViewNumPoints(w)
  210.      IVIEW_WINDOW w;
  211. {
  212.   return(IViewDataNumPoints(IViewData(w)));
  213. }
  214.  
  215. void IViewSetPointValue(w, var, point, value)
  216.      IVIEW_WINDOW w;
  217.      int var, point;
  218.      double value;
  219. {
  220.   IViewDataSetPointValue(IViewData(w), var, point, IViewEncodeValue(w, value, var));
  221. }
  222.  
  223. double IViewPointValue(w, var, point)
  224.      IVIEW_WINDOW w;
  225.      int var, point;
  226. {
  227.   return(IViewDecodeValue(w, IViewDataPointValue(IViewData(w), var, point), var));
  228. }
  229.  
  230. void IViewSetPointScaledValue(w, var, point, value)
  231.      IVIEW_WINDOW w;
  232.      int var, point;
  233.      double value;
  234. {
  235.   IViewDataSetPointValue(IViewData(w), var, point, value);
  236. }
  237.  
  238. double IViewPointScaledValue(w, var, point)
  239.      IVIEW_WINDOW w;
  240.      int var, point;
  241. {
  242.   return(IViewDataPointValue(IViewData(w), var, point));
  243. }
  244.  
  245. double IViewPointTransformedValue(w, var, point)
  246.      IVIEW_WINDOW w;
  247.      int var, point;
  248. {
  249.   return(IViewDataPointTransformedValue(IViewData(w), var, point));
  250. }
  251.  
  252. int IViewPointScreenValue(w, var, point)
  253.      IVIEW_WINDOW w;
  254.      int var, point;
  255. {
  256.   return(IViewDataPointScreenValue(IViewData(w), var, point));
  257. }
  258.  
  259. void IViewGetScreenPointValues(w, point, x)
  260.     IVIEW_WINDOW w;
  261.     int point, *x;
  262. {
  263.   IViewDataGetScreenPointValues(IViewData(w), point, x);
  264. }
  265.  
  266. void IViewSetPointMask(w, point, masked)
  267.      IVIEW_WINDOW w;
  268.      int point;
  269.      int masked;
  270. {
  271.   IViewDataSetPointMask(IViewData(w), point, masked);
  272. }
  273.  
  274. int IViewPointMasked(w, point)
  275.      IVIEW_WINDOW w;
  276.      int point;
  277. {
  278.   return(IViewDataPointMasked(IViewData(w),  point));
  279. }
  280.  
  281. void IViewSetPointColor(w, point, color)
  282.      IVIEW_WINDOW w;
  283.      int point;
  284.      int color;
  285. {
  286.   IViewDataSetPointColor(IViewData(w), point, color);
  287. }
  288.  
  289. int IViewPointColor(w, point)
  290.      IVIEW_WINDOW w;
  291.      int point;
  292. {
  293.   return(IViewDataPointColor(IViewData(w),  point));
  294. }
  295. */
  296. void IViewSetPointState(w, point, state)
  297.      IVIEW_WINDOW w;
  298.      int point;
  299.      PointState state;
  300. {
  301.   if (IViewPointState(w, point) != state) {
  302.     IViewSetPointScreenState(w, point, IViewPointState(w, point));
  303.     IViewDataSetPointState(IViewData(w), point, state);
  304.     IViewAdjustOwnScreenPoint(w, point);
  305.     IViewSetPointScreenState(w, point, IViewPointState(w, point));
  306.     if (IViewIsLinked(w)) IViewMatchPointState(w, point);
  307.   }
  308. }
  309. /* macros in iviewdef.h JKL
  310. PointState IViewPointState(w, point)
  311.      IVIEW_WINDOW w;
  312.      int point;
  313. {
  314.   return(IViewDataPointState(IViewData(w),  point));
  315. }
  316.  
  317. void IViewSetPointScreenState(w, point, state)
  318.      IVIEW_WINDOW w;
  319.      int point;
  320.      PointState state;
  321. {
  322.   IViewDataSetPointScreenState(IViewData(w), point, state);
  323. }
  324.  
  325. PointState IViewPointScreenState(w, point)
  326.      IVIEW_WINDOW w;
  327.      int point;
  328. {
  329.   return(IViewDataPointScreenState(IViewData(w),  point));
  330. }
  331.  
  332. void IViewResetScreenStates(w)
  333.      IVIEW_WINDOW w;
  334. {
  335.   IViewDataResetScreenStates(IViewData(w));
  336. }
  337.  
  338. void IViewSetPointMark(w, point, marked)
  339.      IVIEW_WINDOW w;
  340.      int point;
  341.      int marked;
  342. {
  343.   IViewDataSetPointMark(IViewData(w), point, marked);
  344. }
  345.  
  346. int IViewPointMarked(w, point)
  347.      IVIEW_WINDOW w;
  348.      int point;
  349. {
  350.   return(IViewDataPointMarked(IViewData(w),  point));
  351. }
  352.  
  353. void IViewClearPointMarks(w)
  354.      IVIEW_WINDOW w;
  355. {
  356.   IViewDataClearPointMarks(IViewData(w));
  357. }
  358.  
  359. void IViewSetPointLabel(w, point, s)
  360.      IVIEW_WINDOW w;
  361.      int point;
  362.      char *s;
  363. {
  364.   IViewDataSetPointLabel(IViewData(w), point, s);
  365. }
  366.  
  367. char *IViewPointLabel(w, point)
  368.      IVIEW_WINDOW w;
  369.      int point;
  370. {
  371.   return(IViewDataPointLabel(IViewData(w), point));
  372. }
  373.  
  374. void IViewSetPointSymbol(w, point, sym, hsym)
  375.      IVIEW_WINDOW w;
  376.      int point, sym, hsym;
  377. {
  378.   IViewDataSetPointSymbol(IViewData(w),  point, sym, hsym);
  379. }
  380.  
  381. void IViewGetPointSymbol(w, point, sym, hsym)
  382.      IVIEW_WINDOW w;
  383.      int point, *sym, *hsym;
  384. {
  385.   IViewDataGetPointSymbol(IViewData(w),  point, sym, hsym);
  386. }
  387. */
  388. /**************************************************************************/
  389. /**                                                                      **/
  390. /**                      IView Line Data Functions                       **/
  391. /**                                                                      **/
  392. /**************************************************************************/
  393. /* macros in iviewdef.h JKL
  394. int IViewNumLines(w)
  395.      IVIEW_WINDOW w;
  396. {
  397.   return(IViewDataNumLines(IViewData(w)));
  398. }
  399.  
  400. void IViewAddLines(w, n)
  401.      IVIEW_WINDOW w;
  402.      int n;
  403. {
  404.   IViewDataAddLines(IViewData(w), n);
  405. }
  406.  
  407. void IViewClearLines(w)
  408.      IVIEW_WINDOW w;
  409. {
  410.   IViewDataClearLines(IViewData(w));
  411. }
  412.  
  413. void IViewSetLineValue(w, var, line, value)
  414.     IVIEW_WINDOW w;
  415.     int var, line;
  416.     double value;
  417. {
  418.   IViewDataSetLineValue(IViewData(w), var, line, IViewEncodeValue(w, value, var));
  419. }
  420.  
  421. double IViewLineValue(w, var, line)
  422.     IVIEW_WINDOW w;
  423.     int var, line;
  424. {
  425.   return(IViewDecodeValue(w, IViewDataLineValue(IViewData(w), var, line), var));
  426. }
  427.  
  428. void IViewSetLineScaledValue(w, var, line, value)
  429.     IVIEW_WINDOW w;
  430.     int var, line;
  431.     double value;
  432. {
  433.   IViewDataSetLineValue(IViewData(w), var, line, value);
  434. }
  435.  
  436. double IViewLineScaledValue(w, var, line)
  437.     IVIEW_WINDOW w;
  438.     int var, line;
  439. {
  440.   return(IViewDataLineValue(IViewData(w), var, line));
  441. }
  442.  
  443. double IViewLineTransformedValue(w, var, line)
  444.     IVIEW_WINDOW w;
  445.     int var, line;
  446. {
  447.   return(IViewDataLineTransformedValue(IViewData(w), var, line));
  448. }
  449.  
  450. int IViewLineScreenValue(w, var, line)
  451.     IVIEW_WINDOW w;
  452.     int var, line;
  453. {
  454.   return(IViewDataLineScreenValue(IViewData(w), var, line));
  455. }
  456.  
  457. void IViewSetLineMask(w, line, masked)
  458.      IVIEW_WINDOW w;
  459.      int line;
  460.      int masked;
  461. {
  462.   IViewDataSetLineMask(IViewData(w), line, masked);
  463. }
  464.  
  465. int IViewLineMasked(w, line)
  466.      IVIEW_WINDOW w;
  467.      int line;
  468. {
  469.   return(IViewDataLineMasked(IViewData(w),  line));
  470. }
  471.  
  472. void IViewSetLineColor(w, line, color)
  473.      IVIEW_WINDOW w;
  474.      int line;
  475.      int color;
  476. {
  477.   IViewDataSetLineColor(IViewData(w), line, color);
  478. }
  479.  
  480. int IViewLineColor(w, line)
  481.      IVIEW_WINDOW w;
  482.      int line;
  483. {
  484.   return(IViewDataLineColor(IViewData(w),  line));
  485. }
  486.  
  487. void IViewSetNextLine(w, line, next)
  488.      IVIEW_WINDOW w;
  489.      int line;
  490.      int next;
  491. {
  492.   IViewDataSetNextLine(IViewData(w), line, next);
  493. }
  494.  
  495. int IViewNextLine(w, line)
  496.     IVIEW_WINDOW w;
  497.     int line;
  498. {
  499.   return(IViewDataNextLine(IViewData(w), line));
  500. }
  501.  
  502. void IViewSetLineType(w, line, type)
  503.      IVIEW_WINDOW w;
  504.      int line;
  505.      int type;
  506. {
  507.   IViewDataSetLineType(IViewData(w), line, type);
  508. }
  509.  
  510. int IViewLineType(w, line)
  511.     IVIEW_WINDOW w;
  512.     int line;
  513. {
  514.   return(IViewDataLineType(IViewData(w), line));
  515. }
  516.  
  517. void IViewSetLineWidth(w, line, width)
  518.      IVIEW_WINDOW w;
  519.      int line, width;
  520. {
  521.   IViewDataSetLineWidth(IViewData(w), line, width);
  522. }
  523.  
  524. void IViewGetLineWidth(w, line, width)
  525.     IVIEW_WINDOW w;
  526.     int line, *width;
  527. {
  528.   IViewDataGetLineWidth(IViewData(w), line, width);
  529. }
  530. */
  531. #ifdef USESTRINGS
  532. /**************************************************************************/
  533. /**                                                                      **/
  534. /**                     IView String Data Functions                      **/
  535. /**                                                                      **/
  536. /**************************************************************************/
  537. /* macros in iviewdef.h JKL
  538. int IViewNumStrings(w)
  539.      IVIEW_WINDOW w;
  540. {
  541.   return(IViewDataNumStrings(IViewData(w)));
  542. }
  543.  
  544. void IViewAddStrings(w, n)
  545.      IVIEW_WINDOW w;
  546.      int n;
  547. {
  548.   IViewDataAddStrings(IViewData(w), n);
  549. }
  550.  
  551. void IViewClearStrings(w)
  552.      IVIEW_WINDOW w;
  553. {
  554.   IViewDataClearStrings(IViewData(w));
  555. }
  556.  
  557. void IViewSetStringValue(w, var, string, value)
  558.     IVIEW_WINDOW w;
  559.     int var, string;
  560.     double value;
  561. {
  562.   IViewDataSetStringValue(IViewData(w), var, string, IViewEncodeValue(w, value, var));
  563. }
  564.  
  565. double IViewStringValue(w, var, string)
  566.     IVIEW_WINDOW w;
  567.     int var, string;
  568. {
  569.   return(IViewDecodeValue(w, IViewDataStringValue(IViewData(w), var, string), var));
  570. }
  571.  
  572. void IViewSetStringScaledValue(w, var, string, value)
  573.     IVIEW_WINDOW w;
  574.     int var, string;
  575.     double value;
  576. {
  577.   IViewDataSetStringValue(IViewData(w), var, string, value);
  578. }
  579.  
  580. double IViewStringScaledValue(w, var, string)
  581.     IVIEW_WINDOW w;
  582.     int var, string;
  583. {
  584.   return(IViewDataStringValue(IViewData(w), var, string));
  585. }
  586.  
  587. double IViewStringTransformedValue(w, var, string)
  588.     IVIEW_WINDOW w;
  589.     int var, string;
  590. {
  591.   return(IViewDataStringTransformedValue(IViewData(w), var, string));
  592. }
  593.  
  594. int IViewStringScreenValue(w, var, string)
  595.     IVIEW_WINDOW w;
  596.     int var, string;
  597. {
  598.   return(IViewDataStringScreenValue(IViewData(w), var, string));
  599. }
  600.  
  601. void IViewSetStringMask(w, string, masked)
  602.      IVIEW_WINDOW w;
  603.      int string;
  604.      int masked;
  605. {
  606.   IViewDataSetStringMask(IViewData(w), string, masked);
  607. }
  608.  
  609. int IViewStringMasked(w, string)
  610.      IVIEW_WINDOW w;
  611.      int string;
  612. {
  613.   return(IViewDataStringMasked(IViewData(w),  string));
  614. }
  615.  
  616. void IViewSetStringColor(w, string, color)
  617.      IVIEW_WINDOW w;
  618.      int string;
  619.      int color;
  620. {
  621.   IViewDataSetStringColor(IViewData(w), string, color);
  622. }
  623.  
  624. int IViewStringColor(w, string)
  625.      IVIEW_WINDOW w;
  626.      int string;
  627. {
  628.   return(IViewDataStringColor(IViewData(w),  string));
  629. }
  630.  
  631. void IViewSetStringString(w, string, str)
  632.     IVIEW_WINDOW w;
  633.     int string;
  634.     char *str;
  635. {
  636.   IViewDataSetStringString(IViewData(w), string, str);
  637. }
  638.  
  639. char *IViewStringString(w, string)
  640.     IVIEW_WINDOW w;
  641.     int string;
  642. {
  643.   return(IViewDataStringString(IViewData(w), string));
  644. }
  645.  
  646. void IViewSetStringModifiers(w, string, up, h, v)
  647.     IVIEW_WINDOW w;
  648.     int string, up, h, v;
  649. {
  650.   IViewDataSetStringModifiers(IViewData(w), string, up, h, v);
  651. }
  652.  
  653. void IViewGetStringModifiers(w, string, up, h, v)
  654.     IVIEW_WINDOW w;
  655.     int string, *up, *h, *v;
  656. {
  657.   IViewDataGetStringModifiers(IViewData(w), string, up, h, v);
  658. }*/
  659. #endif /* USESTRINGS */
  660.  
  661. /**************************************************************************/
  662. /**                                                                      **/
  663. /**                     IView Data Drawing Functions                     **/
  664. /**                                                                      **/
  665. /**************************************************************************/
  666.  
  667. void IViewDrawDataPoints(w, var1, var2, m, n)
  668.      IVIEW_WINDOW w;
  669.      unsigned var1, var2, m, n;
  670. {
  671.   IViewDataDrawPoints(IViewData(w), w, var1, var2, m, n, LABEL_OFFSET);
  672. }
  673.  
  674. static void IViewDrawDataLine(w, var1, var2, line,
  675.                          left, top, width, height, orig_x, orig_y,
  676.                          use_color, draw_color)
  677.      IVIEW_WINDOW w;
  678.      unsigned var1, var2, line;
  679.      int left, top, width, height, orig_x, orig_y, use_color/*, draw_color*/;
  680.      ColorCode draw_color; /* changed JKL */
  681. {
  682.   int n = IViewNumLines(w);
  683.   int x, y, nx, ny;
  684.   int next;
  685. /*  int right = left + width, bottom = top + height;*/
  686.   int type, /*color,*/ linewidth/*, penheight*/;
  687.   ColorCode color; /* changed JKL */
  688.   /*char*/ StGWWinInfo *gwinfo; /* changed JKL */
  689.  
  690.   gwinfo = IViewWindowWinInfo(w);
  691.   
  692.   if (line >= n || IViewLineMasked(w, line)) return;
  693.   x = orig_x + IViewLineScreenValue(w, var1, line);
  694.   y = orig_y - IViewLineScreenValue(w, var2, line);
  695. /*  if (x < left || x > right) return;
  696.   if (y < top || y > bottom) return;*/
  697.  
  698.   next = IViewNextLine(w, line);
  699.   if (next >= n || next < 0 || IViewLineMasked(w, next)) return;
  700.   nx = orig_x + IViewLineScreenValue(w, var1, next);
  701.   ny = orig_y - IViewLineScreenValue(w, var2, next);
  702. /*  if (nx < left || nx > right) return;
  703.   if (ny < top || ny > bottom) return;*/
  704.   
  705.   IViewGetLineWidth(w, line, &linewidth);
  706.   StGWSetLineWidth(gwinfo, linewidth);
  707.   type = IViewLineType(w, line);
  708.   if (use_color) {
  709.     color = IViewLineColor(w, line);
  710.     if (color >= 0) StGWSetDrawColor(gwinfo, color);
  711.     else StGWSetDrawColor(gwinfo, draw_color);
  712.   }
  713.   StGWSetLineType(gwinfo, type);
  714.   StGWDrawLine(gwinfo, x, y, nx, ny);
  715. }
  716.  
  717. void IViewDrawDataLines(w, var1, var2, m, n)
  718.     IVIEW_WINDOW w;
  719.     unsigned var1, var2, m, n;
  720. {
  721.   int vars = IViewNumVariables(w);
  722.   int i, left, top, width, height, x, y, use_color;
  723.   int line_type, line_width/*, draw_color*/;
  724.   ColorCode draw_color; /* changed JKL */
  725.   /*char*/ StGWWinInfo *gwinfo;/* changed JKL */
  726.  
  727.   gwinfo = IViewWindowWinInfo(w);
  728.   
  729.   if (var1 >= vars || var2 >= vars) return;
  730.   if (n > IViewNumLines(w)) return;
  731.   
  732.   StGrGetContentRect(gwinfo, &left, &top, &width, &height);
  733.   StGrGetContentOrigin(gwinfo, &x, &y);
  734.   use_color = StGWUseColor(gwinfo);
  735.   line_type = StGWLineType(gwinfo);
  736.   StGWGetLineWidth(gwinfo, &line_width);
  737.   if (use_color) draw_color = StGWDrawColor(gwinfo);
  738.  
  739.   for (i = m; i < n; i++)
  740.     IViewDrawDataLine(w, var1, var2, i, left, top, width, height, x, y,
  741.                       use_color, draw_color);
  742.  
  743.   StGWSetLineType(gwinfo, line_type);
  744.   StGWSetLineWidth(gwinfo, line_width);
  745.   if (use_color) StGWSetDrawColor(gwinfo, draw_color);
  746. }
  747.  
  748. #ifdef USESTRINGS
  749. static void IViewDrawDataString(w, var1, var2, string,
  750.                          left, top, width, height, orig_x, orig_y,
  751.                          use_color, draw_color)
  752.      IVIEW_WINDOW w;
  753.      unsigned var1, var2, string;
  754.      int left, top, width, height, orig_x, orig_y;
  755.      int use_color/*, draw_color*/;
  756.      ColorCode draw_color;/* changed JKL */
  757. {
  758.   int n = IViewNumStrings(w);
  759.   int x, y;
  760. /*  int right = left + width, bottom = top + height; not needed JKL */
  761.   int up, h, v;
  762.   /*int*/ ColorCode color; /* changed JKL */
  763.   char *s;
  764.   /*char*/ StGWWinInfo *gwinfo = IViewWindowWinInfo(w); /* changed JKL */
  765.  
  766.   if (string >= n || IViewStringMasked(w, string)) return;
  767.   x = orig_x + IViewStringScreenValue(w, var1, string);
  768.   y = orig_y - IViewStringScreenValue(w, var2, string);
  769. /*  if (x < left || x > right) return;
  770.   if (y < top || y > bottom) return;*/
  771.   
  772.   if (use_color) {
  773.     color = IViewStringColor(w, string);
  774.     if (color >= 0) StGWSetDrawColor(gwinfo, color);
  775.     else StGWSetDrawColor(gwinfo, draw_color);
  776.   }
  777.   IViewGetStringModifiers(w, string, &up, &h, &v);
  778.   s = IViewStringString(w, string);
  779.   if (s != nil) {
  780.     if (up) StGWDrawTextUp(gwinfo, s, x, y, h, v);
  781.     else StGWDrawText(gwinfo, s, x, y, h, v);
  782.   }
  783. }
  784.  
  785. void IViewDrawDataStrings(w, var1, var2, m, n)
  786.     IVIEW_WINDOW w;
  787.     unsigned var1, var2, m, n;
  788. {
  789.   int vars = IViewNumVariables(w);
  790.   int i, left, top, width, height, x, y, use_color/*, draw_color*/;
  791.   ColorCode draw_color; /* changed JKL */
  792.   /*char*/ StGWWinInfo *gwinfo; /* changed JKL */
  793.  
  794.   gwinfo = IViewWindowWinInfo(w);
  795.   
  796.   if (var1 >= vars || var2 >= vars) return;
  797.   if (n > IViewNumStrings(w)) return;
  798.   
  799.   StGrGetContentRect(gwinfo, &left, &top, &width, &height);
  800.   StGrGetContentOrigin(gwinfo, &x, &y);
  801.   use_color = StGWUseColor(gwinfo);
  802.   if (use_color) draw_color = StGWDrawColor(gwinfo);
  803.   for (i = m; i < n; i++)
  804.     IViewDrawDataString(w, var1, var2, i, left, top,
  805.                         width, height, x, y, use_color, draw_color);
  806.   if (use_color) StGWSetDrawColor(gwinfo, draw_color);
  807. }
  808. #endif /* USESTRINGS */
  809.  
  810. void IViewDepthCuePoints(w, var, cut1, cut2, cut3, m, n)
  811.      IVIEW_WINDOW w;
  812.      unsigned var, cut1, cut2, cut3, m, n;
  813. {
  814.   IViewDataCuePoints(IViewData(w), var, cut1, cut2, cut3, m, n);
  815. }
  816.  
  817. /**************************************************************************/
  818. /**                                                                      **/
  819. /**                     Standard Callback Functions                      **/
  820. /**                                                                      **/
  821. /**************************************************************************/
  822.  
  823. void IViewStdResize(w)
  824.     IVIEW_WINDOW w;
  825. {
  826.   int left, top, width, height, x, y, size;
  827.   int m_left, m_top, m_right, m_bottom;
  828.   int i , vars = IViewNumVariables(w);
  829.   /*char*/ StGWWinInfo *gwinfo = IViewWindowWinInfo(w);/* changed JKL */
  830.  
  831.   width = StGWCanvasWidth(gwinfo);
  832.   height = StGWCanvasHeight(gwinfo);
  833.   StGrGetMargin(gwinfo, &m_left, &m_top, &m_right, &m_bottom);
  834.   left = m_left;
  835.   top = m_top;
  836.   width -= m_left + m_right;
  837.   height -= m_top + m_bottom;
  838.   IViewGetAxisMargin(w, &m_left, &m_top, &m_right, &m_bottom);
  839.   left += m_left;
  840.   top += m_top;
  841.   width -= m_left + m_right;
  842.   height -= m_top + m_bottom;
  843.   if (IViewFixedAspect(w)) {
  844.     size = (width > height) ? height : width;
  845.     left += (width - size) / 2;
  846.     top += (height - size) / 2;
  847.     StGrSetContentRect(gwinfo, left, top, size, size);
  848.     StGrSetContentOrigin(gwinfo, left, top + size);
  849.     for (i = 0; i < vars; i++) IViewSetScreenRange(w, i, 0, size);
  850.   }
  851.   else {
  852.     StGrSetContentRect(gwinfo, left, top, width, height);
  853.     StGrSetContentOrigin(gwinfo, left, top + height);
  854.     StGrGetContentVariables(gwinfo, &x, &y);
  855.     IViewSetScreenRange(w, x, 0, width);
  856.     IViewSetScreenRange(w, y, 0, height);
  857.     for (i = 0; i < vars; i++) 
  858.       if (i != x && i != y)
  859.     IViewSetScreenRange(w, i, 0, width);
  860.   }
  861.   IViewResizeOverlays(w);
  862. }
  863.  
  864. void IViewStdRedraw(w)
  865.     IVIEW_WINDOW w;
  866. {
  867.   int left, top, height, width/*, ctop*/;
  868.   /*char*/ StGWWinInfo *gwinfo = IViewWindowWinInfo(w); /* changed JKL */
  869.   
  870.   StGWStartBuffering(gwinfo);
  871.   
  872.   if (IViewMouseMode(w) == brushing) IViewEraseBrush(w);
  873.   StGWGetViewRect(gwinfo, &left, &top, &width, &height);  
  874.   StGWSetClipRect(gwinfo, TRUE, left, top, width, height);
  875.   IViewRedrawBackground(w);
  876.   IViewRedrawOverlays(w);
  877.   IViewRedrawContent(w);
  878.   StGWBufferToScreen(gwinfo, left, top, width, height);
  879.   if (IViewMouseMode(w) == brushing) IViewDrawBrush(w);
  880.   StGrSetDirty(gwinfo, FALSE);
  881. }
  882.  
  883. void IViewStdRedrawBackground(w)
  884.     IVIEW_WINDOW w;
  885. {
  886.   int left, top, height, width;
  887.   /*char*/ StGWWinInfo *gwinfo = IViewWindowWinInfo(w);/* changed JKL */
  888.   
  889.   StGWStartBuffering(gwinfo);
  890.   
  891.   if (IViewMouseMode(w) == brushing) IViewEraseBrush(w);
  892.   StGWGetViewRect(gwinfo, &left, &top, &width, &height);  
  893.   StGWSetClipRect(gwinfo, TRUE, left, top, width, height);
  894.   StGWEraseRect(gwinfo, left, top, width, height);
  895.   IViewDrawAxes(w);
  896.   StGWBufferToScreen(gwinfo, left, top, width, height);
  897.   if (IViewMouseMode(w) == brushing) IViewDrawBrush(w);
  898. }
  899.  
  900. void IViewGetContentMarginRect(w, left, top, width, height)
  901.     IVIEW_WINDOW w;
  902.     int *left, *top, *width, *height;
  903. {
  904.   int cleft, ctop, cwidth, cheight, mleft, mtop, mright, mbottom;
  905.   int x_showing, y_showing;
  906.   /*char*/ StGWWinInfo *gwinfo = IViewWindowWinInfo(w); /* changed JKL */
  907.   
  908.   StGrGetContentRect(gwinfo, &cleft, &ctop, &cwidth, &cheight);
  909. #ifdef DODO
  910.   StGrGetMargin(gwinfo, &mleft, &mtop, &mright, &mbottom);
  911. #endif /* DODO */
  912.   IViewGetAxisMargin(w, &mleft, &mtop, &mright, &mbottom);
  913.   IViewGetXaxis(w, &x_showing, nil, nil);
  914.   IViewGetYaxis(w, &y_showing, nil, nil);
  915.   if (y_showing || x_showing) {
  916.     cwidth += mright;
  917.     ctop -= mtop; cheight += mtop;
  918.     if (! y_showing) { cleft -= mleft; cwidth += mleft; }
  919.     if (! x_showing) cheight += mbottom;
  920.   }
  921.   if (left != nil) *left = cleft;
  922.   if (top != nil) *top = ctop;
  923.   if (width != nil) *width = cwidth;
  924.   if (height != nil) *height = cheight;
  925. }
  926.  
  927. void IViewStdRedrawContent(w)
  928.     IVIEW_WINDOW w;
  929. {
  930.   int left, top, width, height, vleft, vtop, vwidth, vheight;
  931.   int x, y;
  932.   /*char*/ StGWWinInfo *gwinfo; /* changed JKL */
  933.   
  934.   gwinfo = IViewWindowWinInfo(w);
  935.  
  936.   if (IViewMouseMode(w) == brushing) IViewEraseBrush(w);
  937.   IViewGetContentMarginRect(w, &left, &top, &width, &height);
  938.   StGrGetContentVariables(gwinfo, &x, &y);
  939.   
  940.   StGWStartBuffering(gwinfo);
  941.   StGWSetClipRect(gwinfo, TRUE, left, top, width + 1, height + 1);
  942.   StGWEraseRect(gwinfo, left, top, width + 1, height + 1);
  943.   IViewDrawDataPoints(w, x, y, 0, IViewNumPoints(w));
  944.   IViewDrawDataLines(w, x, y, 0, IViewNumLines(w));
  945. #ifdef USESTRINGS
  946.   IViewDrawDataStrings(w, x, y, 0, IViewNumStrings(w));
  947. #endif /* USESTRINGS */
  948.   StGWBufferToScreen(gwinfo, left, top, width + 1, height + 1);
  949.   StGWGetViewRect(gwinfo, &vleft, &vtop, &vwidth, &vheight);
  950.   StGWSetClipRect(gwinfo, TRUE, vleft, vtop, vwidth, vheight);
  951.   if (IViewMouseMode(w) == brushing) IViewDrawBrush(w);
  952.   IViewResetScreenStates(w);
  953. }
  954.  
  955. void IViewStdMarkPointsInRect(w, left, top, width, height)
  956.      IVIEW_WINDOW w;
  957.      int left, top, width, height;
  958. {
  959.   int c_left, c_top, c_width, c_height, x, y, center_x, center_y;
  960.   int i, n = IViewNumPoints(w), vars = IViewNumVariables(w);
  961.   unsigned var1, var2;
  962.   /*char*/StGWWinInfo *gwinfo = IViewWindowWinInfo(w);/* changed JKL */
  963.   
  964.   StGrGetContentRect(gwinfo, &c_left, &c_top, &c_width, &c_height);
  965.   StGrGetContentOrigin(gwinfo, ¢er_x, ¢er_y);
  966.   StGrGetContentVariables(gwinfo, &var1, &var2);
  967.   
  968.   if (var1 >= vars || var2 >= vars) return;
  969.   
  970.   for (i = 0; i < n; i++) {
  971.     x = center_x + IViewPointScreenValue(w, var1, i);
  972.     y = center_y - IViewPointScreenValue(w, var2, i);
  973.     if ((x >= left && x <= left + width && y >= top && y <= top + height)
  974.         && (! IViewPointMasked(w, i) && IViewPointState(w, i) != pointInvisible))
  975.       IViewSetPointMark(w, i, TRUE);
  976.     else IViewSetPointMark(w, i, FALSE);
  977.   }
  978. }
  979.  
  980. static void DrawPoint(w, i, state, var1, var2, left, top, width, height,
  981.                  center_x, center_y, use_color)
  982.     IVIEW_WINDOW w;
  983.     int i;
  984.     PointState state;
  985.     int var1, var2, left, top, width, height, center_x, center_y;
  986.     int use_color;
  987. {
  988.   int x, y, sym, hsym;
  989.   /*int*/ ColorCode color, oldcolor;/* changed JKL */
  990.   /*char*/StGWWinInfo *gwinfo;/* changed JKL */
  991.  
  992.   gwinfo = IViewWindowWinInfo(w);
  993.   
  994.   if (use_color) {
  995.     oldcolor = StGWDrawColor(gwinfo);
  996.     color = IViewPointColor(w, i);
  997.     if (color >= 0) StGWSetDrawColor(gwinfo, color);
  998.   }
  999.   x = center_x + IViewPointScreenValue(w, var1, i);
  1000.   y = center_y - IViewPointScreenValue(w, var2, i);
  1001.   IViewGetPointSymbol(w, i, &sym, &hsym);
  1002.   if (state == pointNormal) StGWReplaceSymbol(gwinfo, hsym, sym, x, y);
  1003.   else StGWReplaceSymbol(gwinfo, sym, hsym, x, y);
  1004.   if (use_color && color >= 0) StGWSetDrawColor(gwinfo, oldcolor);
  1005. }
  1006.  
  1007. static void DrawLabel(w, i, var1, var2, left, top, width, height,
  1008.                  center_x, center_y)
  1009.     IVIEW_WINDOW w;
  1010.     int i;
  1011.     int var1, var2, left, top, width, height, center_x, center_y;
  1012. {
  1013.   /*char*/ StGWWinInfo *gwinfo = IViewWindowWinInfo(w);/* changed JKL */
  1014.   int x, y, mode = StGWDrawMode(gwinfo);
  1015.  
  1016.   StGWSetDrawMode(gwinfo, 1);
  1017.   x = center_x + IViewPointScreenValue(w, var1, i);
  1018.   y = center_y - IViewPointScreenValue(w, var2, i);
  1019.   StGWDrawString(gwinfo, IViewPointLabel(w, i), 
  1020.                            x + LABEL_OFFSET, y - LABEL_OFFSET);
  1021.   StGWSetDrawMode(gwinfo, mode);
  1022. }
  1023.  
  1024. void IViewStdAdjustScreen(w)
  1025.     IVIEW_WINDOW w;
  1026. {
  1027.   /*char*/ StGWWinInfo *gwinfo = IViewWindowWinInfo(w); /* changed JKL */
  1028.   if (StGrDirty(gwinfo)) IViewRedrawContent(w);
  1029.   StGrSetDirty(gwinfo, FALSE);
  1030.   IViewResetScreenStates(w);
  1031. }
  1032.  
  1033. void IViewStdAdjustPointsInRect(w, left, top, width, height, state)
  1034.     IVIEW_WINDOW w;
  1035.     int left, top, width, height;
  1036.     PointState state;
  1037. {
  1038.   int i, n = IViewNumPoints(w);
  1039.   PointState point_state;
  1040.   int masked, in_rect;
  1041.  
  1042.   IViewCheckLinks(w);
  1043.  
  1044.   if (IViewMouseMode(w) == brushing) IViewEraseBrush(w);
  1045.   
  1046.   IViewMarkPointsInRect(w, left, top, width, height);
  1047.   for (i = 0; i < n; i++) {
  1048.     masked = IViewPointMasked(w, i);
  1049.     point_state = IViewPointState(w, i);
  1050.     if (! masked && point_state != pointInvisible) {
  1051.       in_rect = IViewPointMarked(w, i);
  1052.       if (in_rect && (int) point_state < (int) state) {
  1053.         IViewSetPointState(w, i, state);
  1054.       }
  1055.       else if (! in_rect 
  1056.            && state == pointHilited && point_state == pointHilited) {
  1057.         IViewSetPointState(w, i, pointNormal);
  1058.       }
  1059.     }
  1060.   }
  1061.   IViewAdjustScreens(w);
  1062.   if (IViewMouseMode(w) == brushing) IViewDrawBrush(w);
  1063. }
  1064.  
  1065.  
  1066. void IViewStdAdjustScreenPoint(w, i)
  1067.     IVIEW_WINDOW w;
  1068.     int i;
  1069. {
  1070.   unsigned var1, var2;
  1071.   int left, top, width, height, x, y;
  1072.   PointState point_state, screen_state;
  1073.   int masked, showingLabels = IViewShowingLabels(w);
  1074.   /*char*/ StGWWinInfo *gwinfo = IViewWindowWinInfo(w);/* changed JKL */
  1075.   int use_color = StGWUseColor(gwinfo);
  1076.   
  1077.   StGrGetContentRect(gwinfo, &left, &top, &width, &height);
  1078.   StGrGetContentOrigin(gwinfo, &x, &y);
  1079.   StGrGetContentVariables(gwinfo, &var1, &var2);
  1080.   
  1081.   masked = IViewPointMasked(w, i);
  1082.   point_state = IViewPointState(w, i);
  1083.   screen_state = IViewPointScreenState(w, i);
  1084.   if (! masked && point_state != screen_state) {
  1085.     IViewSetPointScreenState(w, i, point_state);
  1086.     if (point_state == pointInvisible || screen_state == pointInvisible) {
  1087.       StGrSetDirty(gwinfo, TRUE);
  1088.     }
  1089.     else if ((int) point_state > (int) screen_state) { 
  1090.       if (IViewMouseMode(w) == brushing) IViewEraseBrush(w);
  1091.       DrawPoint(w, i, point_state, var1, var2, left, top, width, height, x, y, use_color);
  1092.       if (showingLabels)
  1093.         DrawLabel(w, i, var1, var2, left, top, width, height, x, y); /* to draw */
  1094.       if (IViewMouseMode(w) == brushing) IViewDrawBrush(w);
  1095.     }
  1096.     else {
  1097.       if (IViewMouseMode(w) == brushing) IViewEraseBrush(w);
  1098.       if (showingLabels)
  1099.         DrawLabel(w, i, var1, var2, left, top, width, height, x, y); /* to erase */
  1100.       DrawPoint(w, i, point_state, var1, var2, left, top, width, height, x, y, use_color);
  1101.       if (IViewMouseMode(w) == brushing) IViewDrawBrush(w);
  1102.     }
  1103.   }
  1104. }
  1105.  
  1106. /**************************************************************************/
  1107. /**                                                                      **/
  1108. /**                       IView Rotation Functions                       **/
  1109. /**                                                                      **/
  1110. /**************************************************************************/
  1111.  
  1112. void IViewRotate2(w, var1, var2, newalpha)
  1113.     IVIEW_WINDOW w;
  1114.     unsigned var1, var2;
  1115.     double newalpha;
  1116. {
  1117.   static int *inbasis;
  1118.   static double **a;
  1119.   static int maxvars = 0;
  1120.   static double alpha = 0.0, s = 0.0, c = 1.0;
  1121.   int i, j, vars = IViewNumVariables(w);
  1122.   
  1123.   if (var1 >= vars || var2 >= vars) return;
  1124.   
  1125.   if (vars > maxvars) {
  1126.     maxvars = vars;
  1127.     if (a != nil) StFree(a[0]);
  1128.     StFree(a);
  1129.     StFree(inbasis);
  1130.     a = (double **) StCalloc(sizeof(double *), maxvars);
  1131.     a[0] = (double *) StCalloc(sizeof(double), maxvars * maxvars);
  1132.     for (i = 1; i < vars; i++) a[i] = a[0] + i * maxvars;
  1133.     inbasis = (int *) StCalloc(sizeof(int), maxvars);
  1134.   }
  1135.   
  1136.   if (alpha != newalpha) {
  1137.     alpha = newalpha;
  1138.     s = sin(alpha);
  1139.     c = cos(alpha);
  1140.   }
  1141.   
  1142.   for (i = 0; i < vars; i++) {
  1143.     inbasis[i] = FALSE;
  1144.     for (j = 0; j < vars; j++) a[i][j] = (i == j) ? 1.0 : 0.0;
  1145.   }
  1146.   a[var1][var1] =  c; a[var1][var2] = -s;
  1147.   a[var2][var1] =  s; a[var2][var2] =  c;
  1148.   inbasis[var1] = TRUE; inbasis[var2] = TRUE;
  1149.  
  1150.   IViewApplyTransformation(w, a, inbasis);
  1151. }
  1152.   
  1153. /**************************************************************************/
  1154. /**                                                                      **/
  1155. /**                        Miscellaneous Functions                       **/
  1156. /**                                                                      **/
  1157. /**************************************************************************/
  1158.  
  1159. static double NiceValue(x)
  1160.      double x;
  1161. {
  1162.   long ilx;
  1163.   double lx, v1, v2, v3, v4;
  1164.   
  1165.   if (x <= 0.0) return (0.0);
  1166.   else {
  1167.     lx = log(x) / log(10.0);
  1168.     ilx = floor(lx);
  1169.     v1 = pow(10.0, (float) ilx);
  1170.     v2 = pow(10.0, (float) ilx) * 2.0;
  1171.     v3 = pow(10.0, (float) ilx) * 5.0;
  1172.     v4 = pow(10.0, (float) ilx + 1);
  1173.     
  1174.     if ((fabs(x - v1) < fabs(x - v2))
  1175.     && (fabs(x - v1) < fabs(x - v3))
  1176.     && (fabs(x - v1) < fabs(x - v4)))
  1177.       return(v1);
  1178.     else if ((fabs(x - v2) < fabs(x - v3))
  1179.          && (fabs(x - v2) < fabs(x - v4)))
  1180.       return(v2);
  1181.     else if (fabs(x - v3) < fabs(x - v4))
  1182.       return(v3);
  1183.     else
  1184.       return(v4);
  1185.   }
  1186. }
  1187.  
  1188. void GetNiceRange(low, high, ticks)
  1189.      double *low, *high;
  1190.      int *ticks;
  1191. {
  1192.   double delta;
  1193.   
  1194.   if (fabs(*high) >= HUGE || fabs(*low) >= HUGE) return;
  1195.   if ((*high <= *low) || (*ticks < 2)) return;
  1196.   
  1197.   delta = NiceValue((*high - *low) / (*ticks - 1));
  1198.   if (delta <= 0.0) return;
  1199.   
  1200.   *low = floor(*low / delta + .01) * delta;   /* adjust by .01 for rounding */
  1201.   *high = ceil(*high / delta - .01) * delta;
  1202.   
  1203.   *ticks = 1 + (.01 + (*high - *low) / delta); /* add .01 for rounding */
  1204. }
  1205.  
  1206.