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

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

通讯编程

开发平台：

Visual C++

xgraph.c：源码内容
  1. /* $Header: /usr/src/mash/repository/vint/xgraph/xgraph.c,v 1.3 1999/12/19 00:52:07 heideman Exp $ */
  2. /*
  3.  * xgraph - A Simple Plotter for X
  4.  *
  5.  * David Harrison
  6.  * University of California,  Berkeley
  7.  * 1986, 1987, 1988, 1989
  8.  *
  9.  * Please see copyright.h concerning the formal reproduction rights
  10.  * of this software.
  11.  *
  12.  * $Log: xgraph.c,v $
  13.  * Revision 1.3  1999/12/19 00:52:07  heideman
  14.  * warning suppresion, slightly different flot ahndling
  15.  *
  16.  * Revision 1.2  1999/12/03 23:17:46  heideman
  17.  * apply xgraph_no_animation.patch
  18.  *
  19.  * Revision 1.1.1.1  1999/12/03 23:15:52  heideman
  20.  * xgraph-12.0
  21.  *
  22.  */
  23. #ifndef lint
  24. static char rcsid[] = "$Id: xgraph.c,v 1.3 1999/12/19 00:52:07 heideman Exp $";
  25. #endif
  27. #include "copyright.h"
  28. #include <stdio.h>
  29. #include <math.h>
  30. #include <pwd.h>
  31. #include <ctype.h>
  32. #include "xgraph.h"
  33. #include "xtb.h"
  34. #include "hard_devices.h"
  35. #include "params.h"
  38. extern void init_X();
  39. extern void do_error();
  41. #ifdef DO_DER
  42. extern void Bounds();
  43. #endif /* DO_DER */
  45. static char *tildeExpand();
  46. static void ReverseIt();
  47. static void Traverse();
  48. static int XErrHandler();
  51. NewDataSet PlotData[MAXSETS],
  52.            DataD1[MAXSETS],
  53.            DataD2[MAXSETS];
  55. XSegment *Xsegs[2]; /* Point space for X */
  57. /* Basic transformation stuff */
  58. double llx,
  59.         lly,
  60.         urx,
  61.         ury; /* Bounding box of all data */
  63. static XContext win_context = (XContext) 0;
  65. /* Other globally set defaults */
  67. Display *disp; /* Open display            */
  68. Visual *vis; /* Standard visual         */
  69. Colormap cmap; /* Standard colormap       */
  70. int     screen; /* Screen number           */
  71. int     depth; /* Depth of screen         */
  73. int numFiles = 0; /* Number of input files   */
  74. char *inFileNames[MAXSETS]; /* File names              */
  76. /* Total number of active windows */
  77. int Num_Windows = 0;
  78. char *Prog_Name;
  79. char *disp_name;
  83. main(argc, argv)
  84. int     argc;
  85. char   *argv[];
  87. /*
  88.  * This sets up the hard-wired defaults and reads the X defaults.
  89.  * The command line format is: xgraph [host:display].
  90.  */
  91. {
  92.     Window  primary,
  93.             NewWindow();
  94.     XEvent  theEvent;
  95.     LocalWin *win_info;
  96.     Cursor  zoomCursor;
  97.     FILE   *strm;
  98.     XColor  fg_color,
  99.             bg_color;
  100.     char    keys[MAXKEYS];
  101.     int     nbytes,
  102.             idx,
  103.             maxitems = 0,
  104.             flags;
  105.     int     errs = 0;
  107.     /* Open up new display */
  108.     Prog_Name = argv[0];
  109.     disp_name = "";
  111.     /* Parse the argument list looking for input files */
  112.     flags = ParseArgs(argc, argv, 0);
  114.     if (flags == D_XWINDOWS) {
  115. disp = XOpenDisplay(disp_name);
  116. if (!disp) {
  117.     (void) fprintf(stderr,
  118.    "%s: cannot open display `%s'n",
  119.    argv[0], disp_name);
  120.     exit(1);
  121. }
  122. XSetErrorHandler(XErrHandler);
  123.     }
  125.     /* Set up hard-wired defaults and allocate spaces */
  126.     InitSets(flags);
  128.     /* Read X defaults and override hard-coded defaults */
  129.     if (PM_INT("Output Device") == D_XWINDOWS)
  130. ReadDefaults();
  133.     /* Read the data into the data sets */
  134.     llx = lly = MAXFLOAT;
  135.     urx = ury = -MAXFLOAT;
  136.     for (idx = 0; idx < numFiles; idx++) {
  137. strm = fopen(inFileNames[idx], "r");
  138. if (!strm) {
  139.     (void) fprintf(stderr, "Warning:  cannot open file `%s'n",
  140.    inFileNames[idx]);
  141. }
  142. else {
  143.     if ((maxitems = ReadData(strm, inFileNames[idx])) < 0) {
  144. errs++;
  145.     }
  146.     (void) fclose(strm);
  147. }
  148.     }
  149.     if (!numFiles) {
  150. if ((maxitems = ReadData(stdin, (char *) 0)) < 0) {
  151.     errs++;
  152. }
  153.     }
  154.     if (errs) {
  155. (void) fprintf(stderr, "Problems found with input data.n");
  156. exit(1);
  157.     }
  159.     /* Parse the argument list to set options */
  160.     (void) ParseArgs(argc, argv, 1);
  161.     if (PM_BOOL("Animate")) param_set("TitleText",STR,"Animated X Graph");
  163.     if (maxitems == 0) {
  164. (void) fprintf(stderr, "Nothing to plot.n");
  165. exit(1);
  166.     }
  168.     Xsegs[0] = (XSegment *) Malloc((unsigned) (maxitems * sizeof(XSegment)));
  169.     Xsegs[1] = (XSegment *) Malloc((unsigned) (maxitems * sizeof(XSegment)));
  171.     /* Reverse Video Hack */
  172.     if (PM_BOOL("ReverseVideo"))
  173. ReverseIt();
  174.     hard_init();
  175.     if (PM_BOOL("Debug")) {
  176. if (PM_INT("Output Device") == D_XWINDOWS)
  177.     (void) XSynchronize(disp, 1);
  178. param_dump();
  179.     }
  181.     /* Logarithmic and bounding box computation */
  182.     flags = 0;
  183.     if (PM_BOOL("LogX"))
  184. flags |= LOG_X;
  185.     if (PM_BOOL("LogY"))
  186. flags |= LOG_Y;
  187.     if (PM_BOOL("StackGraph"))
  188. flags |= STK;
  189.     if (PM_BOOL("FitX"))
  190. flags |= FITX;
  191.     if (PM_BOOL("FitY"))
  192. flags |= FITY;
  193.     Traverse(flags);
  195.     /* Nasty hack here for bar graphs */
  196.     if (PM_BOOL("BarGraph")) {
  197. double  base;
  199. llx -= PM_DBL("BarWidth");
  200. urx += PM_DBL("BarWidth");
  201. base = PM_DBL("BarBase");
  202. if (base < lly)
  203.     lly = base;
  204. if (base > ury)
  205.     ury = base;
  206.     }
  208.     /* Create initial window */
  209.     if (PM_INT("Output Device") == D_XWINDOWS) {
  210.         double asp;
  212.         asp = 1.0;
  213. xtb_init(disp, screen, PM_PIXEL("Foreground"), PM_PIXEL("Background"),
  214.  PM_FONT("LabelFont"));
  215.         
  216. primary = NewWindow(Prog_Name,
  217.     PM_DBL("XLowLimit"), PM_DBL("YLowLimit"),
  218.     PM_DBL("XHighLimit"), PM_DBL("YHighLimit"),
  219.     asp,0);
  220. if (!primary) {
  221.     (void) fprintf(stderr, "Main window would not openn");
  222.     exit(1);
  223. }
  225. zoomCursor = XCreateFontCursor(disp, XC_sizing);
  226. fg_color = PM_COLOR("Foreground");
  227. bg_color = PM_COLOR("Background");
  228. XRecolorCursor(disp, zoomCursor, &fg_color, &bg_color);
  230. Num_Windows = 1;
  231. while (Num_Windows > 0) {
  232.     XNextEvent(disp, &theEvent);
  233.     if (xtb_dispatch(&theEvent) != XTB_NOTDEF)
  234. continue;
  235.     if (XFindContext(theEvent.xany.display,
  236.      theEvent.xany.window,
  237.      win_context, (caddr_t *) & win_info)) {
  238. /* Nothing found */
  239. continue;
  240.     }
  241.     switch (theEvent.type) {
  242.     case Expose:
  243. if (theEvent.xexpose.count <= 0) {
  244.     XWindowAttributes win_attr;
  246.     XGetWindowAttributes(disp, theEvent.xany.window, &win_attr);
  247.     win_info->dev_info.area_w = win_attr.width;
  248.     win_info->dev_info.area_h = win_attr.height;
  249.     init_X(win_info->dev_info.user_state);
  250.                     EraseData(win_info);
  251.     DrawWindow(win_info);
  252. }
  253. break;
  254.     case KeyPress:
  255. nbytes = XLookupString(&theEvent.xkey, keys, MAXKEYS,
  256.        (KeySym *) 0, (XComposeStatus *) 0);
  257. for (idx = 0; idx < nbytes; idx++) {
  258.     if (keys[idx] == CONTROL_D) {
  259. /* Delete this window */
  260. DelWindow(theEvent.xkey.window, win_info);
  261.     }
  262.     else if (keys[idx] == CONTROL_C) {
  263. /* Exit program */
  264. Num_Windows = 0;
  265.     }
  266.     else if (keys[idx] == 'h') {
  267. PrintWindow(theEvent.xany.window, win_info);
  268.     }
  269. }
  270. break;
  271.     case ButtonPress:
  272. /* Handle creating a new window */
  273. Num_Windows += HandleZoom(Prog_Name,
  274.   &theEvent.xbutton,
  275.   win_info, zoomCursor);
  276. break;
  277.     default:
  278. (void) fprintf(stderr, "Unknown event type: %xn",
  279.        theEvent.type);
  280. break;
  281.     }
  282. }
  283.     }
  284.     else {
  285. int     Device = PM_INT("Output Device");
  286. int     dflag = strcmp(PM_STR("Disposition"), "To Device") == 0;
  288. primary = NewWindow(Prog_Name,
  289.     PM_DBL("XLowLimit"), PM_DBL("YLowLimit"),
  290.     PM_DBL("XHighLimit"), PM_DBL("YHighLimit"),
  291.     1.0,0);
  292. do_hardcopy(Prog_Name, primary,
  293.     hard_devices[Device].dev_init,
  294.     dflag ? hard_devices[Device].dev_spec : 0,
  295.     PM_STR("FileOrDev"), (double) 19,
  296.     hard_devices[Device].dev_title_font,
  297.     hard_devices[Device].dev_title_size,
  298.     hard_devices[Device].dev_axis_font,
  299.     hard_devices[Device].dev_axis_size,
  300.     PM_BOOL("Document") * D_DOCU);
  301.     }
  302.     return 0;
  303. }
  306. #define BLACK_THRES 30000
  308. static void
  309. ReversePix(param_name)
  310. char   *param_name; /* Name of color parameter */
  312. /*
  313.  * Looks up `param_name' in the parameters database.  If found, the
  314.  * color is examined and judged to be either black or white based
  315.  * upon its red, green, and blue intensities.  The sense of the
  316.  * color is then reversed and reset to its opposite.
  317.  */
  318. {
  319.     params  val;
  321.     if (param_get(param_name, &val)) {
  322. if ((val.pixv.value.red < BLACK_THRES) &&
  323.     (val.pixv.value.green < BLACK_THRES) &&
  324.     (val.pixv.value.blue < BLACK_THRES)) {
  325.     /* Color is black */
  326.     param_reset(param_name, "white");
  327. }
  328. else {
  329.     /* Color is white */
  330.     param_reset(param_name, "black");
  331. }
  332.     }
  333.     else {
  334. (void) fprintf(stderr, "Cannot reverse color `%s'n", param_name);
  335.     }
  336. }
  338. static void
  339. ReverseIt()
  340. /*
  341.  * This routine attempts to implement reverse video.  It steps through
  342.  * all of the important colors in the parameters database and makes
  343.  * black white (and vice versa).
  344.  */
  345. {
  346.     int     i;
  347.     char    buf[1024];
  349.     for (i = 0; i < MAXATTR; i++) {
  350. (void) sprintf(buf, "%d.Color", i);
  351. ReversePix(buf);
  352.     }
  353.     ReversePix("Foreground");
  354.     ReversePix("Border");
  355.     ReversePix("ZeroColor");
  356.     ReversePix("Background");
  357. }
  360. static void
  361. Traverse(flags)
  362. int     flags; /* Options */
  364. /*
  365.  * Traverses through all of the data applying certain options to the
  366.  * data and computing the overall bounding box.  The flags are:
  367.  *   LOG_X Take the log of the X axis
  368.  *   LOG_Y Take the log of the Y axis
  369.  *   STK Stack coordinates.
  370.  *   FITX Fit x-coordinates from zero to one
  371.  *   FITY Fit y-coordinates from zero to one
  372.  */
  373. {
  374.     int     i,
  375.             j;
  376.     PointList *spot;
  377.     PointList *pspot;
  379.     static char *paramstr[] =
  380.     {
  381. "Cannot plot negative %s valuesn",
  382. "when the logarithmic option is selected.n",
  383. "Number of points in %d and %d don't match for stacking.n",
  384. "Point %d in %d and %d doesn't match for stacking.n",
  385. "Set %d has 0 %s.n"
  386.     };
  388.     if (flags & (FITX|FITY)) 
  389. for (i = 0; i < MAXSETS; i++) 
  390.     for (spot = PlotData[i].list; spot; spot = spot->next) {
  391. float minx, maxx, miny, maxy;
  392. minx = maxx = spot->xvec[0];
  393. maxy = miny = spot->yvec[0];
  394. for (j = 1; j < spot->numPoints; j++) {
  395.     minx = MIN(minx, spot->xvec[j]);
  396.     miny = MIN(miny, spot->yvec[j]);
  397.     maxx = MAX(maxx, spot->xvec[j]);
  398.     maxy = MAX(maxy, spot->yvec[j]);
  399. }
  400. maxx = maxx - minx;
  401. maxy = maxy - miny;
  402. if (maxx == 0.0) {
  403.     (void) fprintf(stderr, paramstr[3], i, "width");
  404.     maxx = 1.0;
  405. }
  406. if (maxy == 0.0) {
  407.     (void) fprintf(stderr, paramstr[3], i, "height");
  408.     maxy = 1.0;
  409. }
  410. switch (flags & (FITX|FITY)) {
  411. case FITX:
  412.     for (j = 0; j < spot->numPoints; j++) 
  413. spot->xvec[j] = (-minx + spot->xvec[j]) / maxx;
  414.     break;
  415. case FITY:
  416.     for (j = 0; j < spot->numPoints; j++) 
  417. spot->yvec[j] = (-miny + spot->yvec[j]) / maxy;
  418.     break;
  419. case FITX|FITY:
  420.     for (j = 0; j < spot->numPoints; j++) {
  421. spot->xvec[j] = (-minx + spot->xvec[j]) / maxx;
  422. spot->yvec[j] = (-miny + spot->yvec[j]) / maxy;
  423.     }
  424.     break;
  425. default:
  426.     abort();
  427. }
  428.     }
  430.     if (flags & STK)
  431. for (i = 1; i < MAXSETS; i++) {
  432.     for (spot = PlotData[i].list, pspot = PlotData[i - 1].list;
  433.  spot && pspot; spot = spot->next, pspot = pspot->next) {
  434. if (spot->numPoints != pspot->numPoints) {
  435.     (void) fprintf(stderr, paramstr[2], i - 1, i);
  436.     exit(1);
  437. }
  438. for (j = 0; j < spot->numPoints; j++) {
  439.     if (spot->xvec[j] != pspot->xvec[j]) {
  440. (void) fprintf(stderr, paramstr[3], j, i - 1, i);
  441. exit(1);
  442.     }
  443.     spot->yvec[j] += pspot->yvec[j];
  444. }
  445.     }
  446. }
  449.     for (i = 0; i < MAXSETS; i++) {
  450. for (spot = PlotData[i].list; spot; spot = spot->next) {
  451.     for (j = 0; j < spot->numPoints; j++) {
  452. if (flags & LOG_Y) {
  453.     if (spot->yvec[j] > 0.0) {
  454. spot->yvec[j] = log10(spot->yvec[j]);
  455.     }
  456.     else if (spot->yvec[j] == 0)
  457. spot->yvec[j] = 0.0;
  458.     else {
  459. (void) fprintf(stderr, paramstr[0], "Y");
  460. (void) fprintf(stderr, paramstr[1]);
  461. exit(1);
  462.     }
  463. }
  464. if (flags & LOG_X) {
  465.     if (spot->xvec[j] > 0.0) {
  466. spot->xvec[j] = log10(spot->xvec[j]);
  467.     }
  468.     else if (spot->xvec[j] == 0)
  469. spot->xvec[j] = 0.0;
  470.     else {
  471. (void) fprintf(stderr, paramstr[0], "X");
  472. (void) fprintf(stderr, paramstr[1]);
  473. exit(1);
  474.     }
  475. }
  476. /* Update global bounding box */
  477. if (spot->xvec[j] < llx)
  478.     llx = spot->xvec[j];
  479. if (spot->xvec[j] > urx)
  480.     urx = spot->xvec[j];
  481. if (spot->yvec[j] < lly)
  482.     lly = spot->yvec[j];
  483. if (spot->yvec[j] > ury)
  484.     ury = spot->yvec[j];
  485.     }
  486. }
  487.     }
  488. }
  492. /*
  493.  * Button handling functions
  494.  */
  496. /*ARGSUSED*/
  497. xtb_hret
  498. del_func(win, bval, info)
  499. Window  win; /* Button window    */
  500. int     bval; /* Button value     */
  501. char   *info; /* User information */
  503. /*
  504.  * This routine is called when the `Close' button is pressed in
  505.  * an xgraph window.  It causes the window to go away.
  506.  */
  507. {
  508.     Window  the_win = (Window) info;
  509.     LocalWin *win_info;
  511.     xtb_bt_set(win, 1, (char *) 0, 0);
  512.     if (!XFindContext(disp, the_win, win_context, (caddr_t *) & win_info)) {
  513. if (win_info->flags & HARDCOPY_IN_PROGRESS) {
  514.     do_error("Can't close window whilenhardcopy dialog is posted.n");
  515.     xtb_bt_set(win, 0, (char *) 0, 0);
  516. }
  517. else {
  518.     DelWindow(the_win, win_info);
  519. }
  520.     }
  521.     return XTB_HANDLED;
  522. }
  524. /*ARGSUSED*/
  525. xtb_hret
  526. hcpy_func(win, bval, info)
  527. Window  win; /* Button Window    */
  528. int     bval; /* Button value     */
  529. char   *info; /* User Information */
  531. /*
  532.  * This routine is called when the hardcopy button is pressed
  533.  * in an xgraph window.  It causes the output dialog to be
  534.  * posted.
  535.  */
  536. {
  537.     Window  the_win = (Window) info;
  538.     LocalWin *win_info;
  540.     xtb_bt_set(win, 1, (char *) 0, 0);
  541.     if (!XFindContext(disp, the_win, win_context, (caddr_t *) & win_info)) {
  542. win_info->flags |= HARDCOPY_IN_PROGRESS;
  543. PrintWindow(the_win, win_info);
  544. win_info->flags &= (~HARDCOPY_IN_PROGRESS);
  545.     }
  546.     xtb_bt_set(win, 0, (char *) 0, 0);
  547.     return XTB_HANDLED;
  548. }
  550. static
  551. /*ARGSUSED*/
  552.         xtb_hret
  553. abt_func(win, bval, info)
  554. Window  win; /* Button window    */
  555. int     bval; /* Button value     */
  556. char   *info; /* User information */
  557. {
  558.     static char *msg_fmt =
  559.     "Version %sn
  560. XGraph + Animation and Derivativesn
  561. Modification of code by David Harrisonn
  562. University of California, Berkeleyn
  563. (davidh@ic.Berkeley.EDU or n
  564. ...!ucbvax!ucbic!davidh)n
  565. Animation, differentiation, and a few othern
  566. new features added by Paul Walker,n
  567. National Center for Supercomputer Applicationsn
  568. and Univ. Illinois at U-C Dept of Physics.n
  569. Send comments or suggestions ton
  570. pwalker@ncsa.uiuc.edun";
  571.     static int active = 0;
  572.     char    msg_buf[1024];
  574.     if (!active) {
  575. active = 1;
  576. xtb_bt_set(win, 1, (char *) 0, 0);
  577. (void) sprintf(msg_buf, msg_fmt, VERSION_STRING);
  578. msg_box("XGraph", msg_buf);
  579. xtb_bt_set(win, 0, (char *) 0, 0);
  580. active = 0;
  581.     }
  582.     return XTB_HANDLED;
  583. }
  586. #ifdef DO_DER
  587. static
  588. /*ARGSUSED  PW*/
  589.         xtb_hret
  590. rew_func(win, bval, info)
  591. Window  win; /* Button window    */
  592. int     bval; /* Button value     */
  593. char   *info; /* User information */
  594. {
  595.     /* This routine added, Paul Walker, to rewind the animation and start
  596.        it over.  The only even moderatly tricky part is erasing the last
  597.        item, which still lives, and redrawing the axis.  I do it by just
  598.        copying the "Expose" information from the main routine. */
  599.     Window  the_win = (Window) info;
  600.     LocalWin *win_info;
  602.     /* Set animation to True */
  603.     param_set("Animate",BOOL,"on");
  605.     if (!XFindContext(disp, the_win, win_context, (caddr_t *) & win_info)) {
  606.   XWindowAttributes win_attr;
  608.   XGetWindowAttributes(disp, the_win, &win_attr);
  609.   win_info->dev_info.area_w = win_attr.width;
  610.   win_info->dev_info.area_h = win_attr.height;
  611.   init_X(win_info->dev_info.user_state);
  612.           EraseData (win_info);
  613.   DrawWindow(win_info);
  614.     }
  616.     return XTB_HANDLED;
  617. }
  619. static
  620. /*ARGSUSED  PW*/
  621.         xtb_hret
  622. der_func(win, bval, info)
  623. Window  win; /* Button window    */
  624. int     bval; /* Button value     */
  625. char   *info; /* User information */
  626. {
  627.     /* This routine added, Paul Walker, to rewind the animation and start
  628.        it over.  The only even moderatly tricky part is erasing the last
  629.        item, which still lives, and redrawing the axis.  I do it by just
  630.        copying the "Expose" information from the main routine. */
  631.     Window  the_win = (Window) info;
  632.     Window new_win;
  633.     LocalWin *win_info;
  634.     double loX,loY,hiX,hiY,asp;
  635.     static char *msg_fmt =
  636.     "Version %sn
  637. Currently unable to displayn
  638. or calculate derivativesn
  639. higher than 2nd ordern";
  640.     static int active = 0;
  641.     char    msg_buf[1024];
  643.     XFindContext(disp, the_win, win_context, (caddr_t *) & win_info);
  644.     if (win_info->DOrder == 2) {
  646.       if (!active) {
  647. active = 1;
  648. xtb_bt_set(win, 1, (char *) 0, 0);
  649. (void) sprintf(msg_buf, msg_fmt, VERSION_STRING);
  650. msg_box("XGraph", msg_buf);
  651. xtb_bt_set(win, 0, (char *) 0, 0);
  652. active = 0;
  653.       }
  654.       return XTB_HANDLED;
  655.     }
  656.     Num_Windows += 1;
  657.     asp = 1.0;
  658.     Bounds(&loX,&loY,&hiX,&hiY,win_info->DOrder+1);
  659.     new_win = NewWindow("Derivatives", loX, loY, hiX, hiY, asp, 
  660.       win_info->DOrder+1);
  662.     if (!XFindContext(disp, new_win, win_context, (caddr_t *) & win_info)) {
  663.   XWindowAttributes win_attr;
  665.   XGetWindowAttributes(disp, new_win, &win_attr);
  666.   win_info->dev_info.area_w = win_attr.width;
  667.   win_info->dev_info.area_h = win_attr.height;
  668.   init_X(win_info->dev_info.user_state);
  669.           EraseData (win_info);
  670.   DrawWindow(win_info);
  671.     }
  673.     return XTB_HANDLED;
  674. }
  677. static
  678. /*ARGSUSED  PW*/
  679.         xtb_hret
  680. rpl_func(win, bval, info)
  681. Window  win; /* Button window    */
  682. int     bval; /* Button value     */
  683. char   *info; /* User information */
  684. {
  685.     /* Puts us back into static mode ... */
  686.     Window  the_win = (Window) info;
  687.     LocalWin *win_info;
  689.     /* Set animation to True */
  690.     param_set("Animate",BOOL,"off");
  692.     if (!XFindContext(disp, the_win, win_context, (caddr_t *) & win_info)) {
  693.   XWindowAttributes win_attr;
  695.   XGetWindowAttributes(disp, the_win, &win_attr);
  696.   win_info->dev_info.area_w = win_attr.width;
  697.   win_info->dev_info.area_h = win_attr.height;
  698.   init_X(win_info->dev_info.user_state);
  699.           EraseData (win_info);
  700.   DrawWindow(win_info);
  701.     }
  703.     return XTB_HANDLED;
  704. }
  705. /* End change PW */
  707. #endif /* DO_DER */
  709. #define NORMSIZE 600
  710. #define MINDIM 100
  712. Window
  713. NewWindow(progname, lowX, lowY, upX, upY, asp, DO)
  714. char   *progname; /* Name of program    */
  715. double  lowX,
  716.         lowY; /* Lower left corner  */
  717. double  upX,
  718.         upY; /* Upper right corner */
  719. double  asp; /* Aspect ratio       */
  720. int     DO;                     /* Derivative Order.  */
  722. /*
  723.  * Creates and maps a new window.  This includes allocating its
  724.  * local structure and associating it with the XId for the window.
  725.  * The aspect ratio is specified as the ratio of width over height.
  726.  */
  727. {
  728.     Window  new_window;
  729.     LocalWin *new_info;
  730.     static Cursor theCursor = (Cursor) 0;
  731.     XSizeHints sizehints;
  732.     XSetWindowAttributes wattr;
  733.     XWMHints wmhints;
  734.     XColor  fg_color,
  735.             bg_color;
  736.     int     geo_mask;
  737.     int     width,
  738.             height;
  739.     unsigned long wamask;
  740.     char    defSpec[120];
  741.     double  pad;
  743.     new_info = (LocalWin *) Malloc(sizeof(LocalWin));
  744.     new_info->DOrder = DO;
  746.     if (upX > lowX) {
  747. new_info->loX = lowX;
  748. new_info->hiX = upX;
  749.     }
  750.     else {
  751. new_info->loX = llx;
  752. new_info->hiX = urx;
  753.     }
  754.     if (upY > lowY) {
  755. new_info->loY = lowY;
  756. new_info->hiY = upY;
  757.     }
  758.     else {
  759. new_info->loY = lly;
  760. new_info->hiY = ury;
  761.     }
  763.     /* Increase the padding for aesthetics */
  764.     if (new_info->hiX - new_info->loX == 0.0) {
  765. pad = MAX(0.5, fabs(new_info->hiX / 2.0));
  766. new_info->hiX += pad;
  767. new_info->loX -= pad;
  768.     }
  769.     if (new_info->hiY - new_info->loY == 0) {
  770. pad = MAX(0.5, fabs(ury / 2.0));
  771. new_info->hiY += pad;
  772. new_info->loY -= pad;
  773.     }
  775.     /* Add 10% padding to bounding box (div by 20 yeilds 5%) */
  776.     pad = (new_info->hiX - new_info->loX) / 20.0;
  777.     new_info->loX -= pad;
  778.     new_info->hiX += pad;
  779.     pad = (new_info->hiY - new_info->loY) / 20.0;
  780.     new_info->loY -= pad;
  781.     new_info->hiY += pad;
  783.     /* Aspect ratio computation */
  784.     if (asp < 1.0) {
  785. height = NORMSIZE;
  786. width = ((int) (((double) NORMSIZE) * asp));
  787.     }
  788.     else {
  789. width = NORMSIZE;
  790. height = ((int) (((double) NORMSIZE) / asp));
  791.     }
  792.     height = MAX(MINDIM, height);
  793.     width = MAX(MINDIM, width);
  794.     if (PM_INT("Output Device") == D_XWINDOWS) {
  795. (void) sprintf(defSpec, "%dx%d+100+100", width, height);
  797. wamask = CWBackPixel | CWBorderPixel | CWColormap;
  798. wattr.background_pixel = PM_PIXEL("Background");
  799. wattr.border_pixel = PM_PIXEL("Border");
  800. wattr.colormap = cmap;
  802. sizehints.flags = PPosition | PSize;
  803. sizehints.x = sizehints.y = 100;
  804. sizehints.width = width;
  805. sizehints.height = height;
  807. geo_mask = XParseGeometry(PM_STR("Geometry"), 
  808.   &sizehints.x, &sizehints.y,
  809.   (unsigned int *) &sizehints.width,
  810.   (unsigned int *) &sizehints.height);
  811. if (geo_mask & (XValue|YValue)) 
  812.     sizehints.flags = (sizehints.flags & ~PPosition) | USPosition;
  813. if (geo_mask & (WidthValue | HeightValue)) 
  814.     sizehints.flags = (sizehints.flags & ~PSize) | USSize;
  816. new_window = XCreateWindow(disp, RootWindow(disp, screen),
  817.    sizehints.x, sizehints.y,
  818.    (unsigned int) sizehints.width,
  819.    (unsigned int) sizehints.height,
  820.    (unsigned int) PM_INT("BorderSize"),
  821.    depth, InputOutput, vis,
  822.    wamask, &wattr);
  825. if (new_window) {
  826.     xtb_frame cl_frame,
  827.             hd_frame,
  828.             ab_frame,
  829.                     rw_frame,
  830.                     rp_frame,
  831.                     dx_frame;
  833.     XStoreName(disp, new_window, progname);
  834.     XSetIconName(disp, new_window, progname);
  836.     wmhints.flags = InputHint | StateHint;
  837.     wmhints.input = True;
  838.     wmhints.initial_state = NormalState;
  839.     XSetWMHints(disp, new_window, &wmhints);
  841.     XSetWMNormalHints(disp, new_window, &sizehints);
  843.     /* Set device info */
  844.     set_X(new_window, &(new_info->dev_info));
  846.     if (!PM_BOOL("NoButton")) {
  847. /* Make buttons */
  848. xtb_bt_new(new_window, "Close", del_func,
  849.    (xtb_data) new_window, &cl_frame);
  850. new_info->close = cl_frame.win;
  851. XMoveWindow(disp, new_info->close, (int) BTNPAD, (int) BTNPAD);
  852. xtb_bt_new(new_window, "Hdcpy", hcpy_func,
  853.    (xtb_data) new_window, &hd_frame);
  854. new_info->hardcopy = hd_frame.win;
  855. XMoveWindow(disp, new_info->hardcopy,
  856.     (int) (BTNPAD + cl_frame.width + BTNINTER),
  857.     BTNPAD);
  858. xtb_bt_new(new_window, "About", abt_func,
  859.    (xtb_data) new_window, &ab_frame);
  860. new_info->about = ab_frame.win;
  861. XMoveWindow(disp, new_info->about,
  862.     (int) (BTNPAD + cl_frame.width + BTNINTER +
  863.    hd_frame.width + BTNINTER), BTNPAD);
  864. #ifdef DO_DER
  865.                 /* These buttons added PW */
  866. xtb_bt_new(new_window, "Anim", rew_func,
  867.    (xtb_data) new_window, &rw_frame);
  868. new_info->rewind = rw_frame.win;
  869. XMoveWindow(disp, new_info->rewind,
  870.     (int) (BTNPAD + cl_frame.width + BTNINTER +
  871.    hd_frame.width + BTNINTER +
  872.                            ab_frame.width + BTNINTER), BTNPAD);
  873. xtb_bt_new(new_window, "Replot", rpl_func,
  874.    (xtb_data) new_window, &rp_frame);
  875. new_info->replot = rp_frame.win;
  876. XMoveWindow(disp, new_info->replot,
  877.     (int) (BTNPAD + cl_frame.width + BTNINTER +
  878.    hd_frame.width + BTNINTER +
  879.                            ab_frame.width + BTNINTER +
  880.    rw_frame.width + BTNINTER), BTNPAD);
  881. xtb_bt_new(new_window, "Deriv", der_func,
  882.    (xtb_data) new_window, &dx_frame);
  883. new_info->deriv = dx_frame.win;
  884. XMoveWindow(disp, new_info->deriv,
  885.     (int) (BTNPAD + cl_frame.width + BTNINTER +
  886.    hd_frame.width + BTNINTER +
  887.                            ab_frame.width + BTNINTER +
  888.    rw_frame.width + BTNINTER +
  889.    rp_frame.width + BTNINTER), BTNPAD); 
  890. #endif /* DO_DER */
  892. new_info->flags = 0;
  893.     }
  894.     XSelectInput(disp, new_window,
  895.  ExposureMask | KeyPressMask | ButtonPressMask);
  896.     if (!theCursor) {
  897. theCursor = XCreateFontCursor(disp, XC_top_left_arrow);
  898. fg_color = PM_COLOR("Foreground");
  899. bg_color = PM_COLOR("Background");
  900. XRecolorCursor(disp, theCursor, &fg_color, &bg_color);
  901.     }
  902.     XDefineCursor(disp, new_window, theCursor);
  903.     if (!win_context) {
  904. win_context = XUniqueContext();
  905.     }
  906.     XSaveContext(disp, new_window, win_context, (caddr_t) new_info);
  907.     XMapWindow(disp, new_window);
  908.     return new_window;
  909. }
  910. else {
  911.     return (Window) 0;
  912. }
  913.     }
  914.     else {
  915. new_info->dev_info.area_h = 1.0;
  916. new_info->dev_info.area_w = 1.0;
  917. return ((Window) new_info);
  918.     }
  919. }
  922. DelWindow(win, win_info)
  923. Window  win; /* Window     */
  924. LocalWin *win_info; /* Local Info */
  926. /*
  927.  * This routine actually deletes the specified window and
  928.  * decrements the window count.
  929.  */
  930. {
  931.     xtb_data info;
  933.     XDeleteContext(disp, win, win_context);
  934.     xtb_bt_del(win_info->close, &info);
  935.     xtb_bt_del(win_info->hardcopy, &info);
  936.     xtb_bt_del(win_info->about, &info);
  937.     Free((char *) win_info);
  938.     XDestroyWindow(disp, win);
  939.     Num_Windows -= 1;
  940. }
  942. PrintWindow(win, win_info)
  943. Window  win; /* Window       */
  944. LocalWin *win_info; /* Local Info   */
  946. /*
  947.  * This routine posts a dialog asking about the hardcopy
  948.  * options desired.  If the user hits `OK',  the hard
  949.  * copy is performed.
  950.  */
  951. {
  952.     ho_dialog(win, Prog_Name, (char *) win_info);
  953. }
  956. static XRectangle boxEcho;
  957. static GC echoGC = (GC) 0;
  959. #define DRAWBOX 
  960. if (startX < curX) { 
  961.    boxEcho.x = startX; 
  962.    boxEcho.width = curX - startX; 
  963. } else { 
  964.    boxEcho.x = curX; 
  965.    boxEcho.width = startX - curX; 
  966. } 
  967. if (startY < curY) { 
  968.    boxEcho.y = startY; 
  969.    boxEcho.height = curY - startY; 
  970. } else { 
  971.    boxEcho.y = curY; 
  972.    boxEcho.height = startY - curY; 
  973. } 
  974. XDrawRectangles(disp, win, echoGC, &boxEcho, 1);
  976. #define TRANX(xval) 
  977. (((double) ((xval) - wi->XOrgX)) * wi->XUnitsPerPixel + wi->UsrOrgX)
  979. #define TRANY(yval) 
  980. (wi->UsrOppY - (((double) ((yval) - wi->XOrgY)) * wi->YUnitsPerPixel))
  983. int
  984. HandleZoom(progname, evt, wi, cur)
  985. char   *progname;
  986. XButtonPressedEvent *evt;
  987. LocalWin *wi;
  988. Cursor  cur;
  989. {
  990.     Window  win,
  991.             new_win;
  992.     Window  root_rtn,
  993.             child_rtn;
  994.     XEvent  theEvent;
  995.     int     startX,
  996.             startY,
  997.             curX,
  998.             curY,
  999.             newX,
  1000.             newY,
  1001.             stopFlag,
  1002.             numwin = 0;
  1003.     int     root_x,
  1004.             root_y;
  1005.     unsigned int mask_rtn;
  1006.     double  loX,
  1007.             loY,
  1008.             hiX,
  1009.             hiY,
  1010.             asp;
  1012.     win = evt->window;
  1013.     if (XGrabPointer(disp, win, True,
  1014.      (unsigned int) (ButtonPressMask | ButtonReleaseMask |
  1015.    PointerMotionMask | PointerMotionHintMask),
  1016.      GrabModeAsync, GrabModeAsync,
  1017.      win, cur, CurrentTime) != GrabSuccess) {
  1018. XBell(disp, 0);
  1019. return 0;
  1020.     }
  1021.     if (echoGC == (GC) 0) {
  1022. unsigned long gcmask;
  1023. XGCValues gcvals;
  1025. gcmask = GCForeground | GCFunction;
  1026. gcvals.foreground = PM_PIXEL("ZeroColor") ^ PM_PIXEL("Background");
  1027. gcvals.function = GXxor;
  1028. echoGC = XCreateGC(disp, win, gcmask, &gcvals);
  1029.     }
  1030.     startX = evt->x;
  1031.     startY = evt->y;
  1032.     XQueryPointer(disp, win, &root_rtn, &child_rtn, &root_x, &root_y,
  1033.   &curX, &curY, &mask_rtn);
  1034.     /* Draw first box */
  1035.     DRAWBOX;
  1036.     stopFlag = 0;
  1037.     while (!stopFlag) {
  1038. XNextEvent(disp, &theEvent);
  1039. switch (theEvent.xany.type) {
  1040. case MotionNotify:
  1041.     XQueryPointer(disp, win, &root_rtn, &child_rtn, &root_x, &root_y,
  1042.   &newX, &newY, &mask_rtn);
  1043.     /* Undraw the old one */
  1044.     DRAWBOX;
  1045.     /* Draw the new one */
  1046.     curX = newX;
  1047.     curY = newY;
  1048.     DRAWBOX;
  1049.     break;
  1050. case ButtonRelease:
  1051.     DRAWBOX;
  1052.     XUngrabPointer(disp, CurrentTime);
  1053.     stopFlag = 1;
  1054.     if ((startX - curX != 0) && (startY - curY != 0)) {
  1055. /* Figure out relative bounding box */
  1056. loX = TRANX(startX);
  1057. loY = TRANY(startY);
  1058. hiX = TRANX(curX);
  1059. hiY = TRANY(curY);
  1060. if (loX > hiX) {
  1061.     double  temp;
  1063.     temp = hiX;
  1064.     hiX = loX;
  1065.     loX = temp;
  1066. }
  1067. if (loY > hiY) {
  1068.     double  temp;
  1070.     temp = hiY;
  1071.     hiY = loY;
  1072.     loY = temp;
  1073. }
  1074. /* physical aspect ratio */
  1075. asp = ((double) ABS(startX - curX)) / 
  1076.        ((double) ABS(startY - curY));
  1077. new_win = NewWindow(progname, loX, loY, hiX, hiY, asp,
  1078.                   wi->DOrder);
  1079. if (new_win) {
  1080.     numwin = 1;
  1081. }
  1082. else {
  1083.     numwin = 0;
  1084. }
  1085.     }
  1086.     else {
  1087. numwin = 0;
  1088.     }
  1089.     break;
  1090. default:
  1091.     printf("unknown event: %dn", theEvent.xany.type);
  1092.     break;
  1093. }
  1094.     }
  1095.     return numwin;
  1096. }
  1099. #define RND(val) ((int) ((val) + 0.5))
  1101. /*ARGSUSED*/
  1102. void
  1103. do_hardcopy(prog, info, init_fun, dev_spec, file_or_dev, maxdim,
  1104.     ti_fam, ti_size, ax_fam, ax_size, doc_p)
  1105. char   *prog; /* Program name for Xdefaults    */
  1106. char   *info; /* Some state information        */
  1107. int     (*init_fun) (); /* Hardcopy init function        */
  1108. char   *dev_spec; /* Device specification (if any) */
  1109. char   *file_or_dev; /* Filename or device spec       */
  1110. double  maxdim; /* Maximum dimension in cm       */
  1111. char   *ti_fam,
  1112.        *ax_fam; /* Font family names             */
  1113. double  ti_size,
  1114.         ax_size; /* Font sizes in points          */
  1115. int     doc_p; /* Documentation predicate       */
  1117. /*
  1118.  * This routine resets the function pointers to those specified
  1119.  * by `init_fun' and causes a screen redisplay.  If `dev_spec'
  1120.  * is non-zero,  it will be considered a sprintf string with
  1121.  * one %s which will be filled in with `file_or_dev' and fed
  1122.  * to popen(3) to obtain a stream.  Otherwise,  `file_or_dev'
  1123.  * is considered to be a file and is opened for writing.  The
  1124.  * resulting stream is fed to the initialization routine for
  1125.  * the device.
  1126.  */
  1127. {
  1128.     LocalWin *curWin = (LocalWin *) info;
  1129.     LocalWin thisWin;
  1130.     FILE   *out_stream;
  1131.     char    buf[MAXBUFSIZE],
  1132.             err[MAXBUFSIZE],
  1133.             ierr[ERRBUFSIZE];
  1134.     char    tilde[MAXBUFSIZE * 10];
  1135.     int     final_w,
  1136.             final_h,
  1137.             flags;
  1138.     double  ratio;
  1140.     if (dev_spec) {
  1141. (void) sprintf(buf, dev_spec, file_or_dev);
  1142. out_stream = popen(buf, "w");
  1143. if (!out_stream) {
  1144.     sprintf(err, "Unable to issue command:n  %sn", buf);
  1145.     do_error(err);
  1146.     return;
  1147. }
  1148.     }
  1149.     else {
  1150. tildeExpand(tilde, file_or_dev);
  1151. out_stream = fopen(tilde, "w");
  1152. if (!out_stream) {
  1153.     sprintf(err, "Unable to open file `%s'n", tilde);
  1154.     do_error(err);
  1155.     return;
  1156. }
  1157.     }
  1158.     if (curWin != (LocalWin *) 0) {
  1159. thisWin = *curWin;
  1160. ratio = ((double) thisWin.dev_info.area_w) /
  1161.     ((double) thisWin.dev_info.area_h);
  1162.     }
  1163.     else
  1164. ratio = 1.0;
  1166.     if (thisWin.dev_info.area_w > thisWin.dev_info.area_h) {
  1167. final_w = RND(maxdim * 10000.0 * PM_DBL("Scale"));
  1168. final_h = RND(maxdim / ratio * 10000.0 * PM_DBL("Scale"));
  1169.     }
  1170.     else {
  1171. final_w = RND(maxdim * ratio * 10000.0 * PM_DBL("Scale"));
  1172. final_h = RND(maxdim * 10000.0 * PM_DBL("Scale"));
  1173.     }
  1174.     ierr[0] = '';
  1175.     flags = 0;
  1176.     if (doc_p)
  1177. flags |= D_DOCU;
  1178.     if ((*init_fun) (out_stream, final_w, final_h, ti_fam, ti_size,
  1179.      ax_fam, ax_size, flags, &(thisWin.dev_info), ierr)) {
  1180. DrawWindow(&thisWin);
  1181. if (thisWin.dev_info.xg_end) {
  1182.     thisWin.dev_info.xg_end(thisWin.dev_info.user_state);
  1183. }
  1184.     }
  1185.     else {
  1186. do_error(ierr);
  1187.     }
  1188.     if (dev_spec) {
  1189. (void) pclose(out_stream);
  1190.     }
  1191.     else {
  1192. (void) fclose(out_stream);
  1193.     }
  1194. }
  1197. static char *
  1198. tildeExpand(out, in)
  1199. char   *out; /* Output space for expanded file name */
  1200. char   *in; /* Filename with tilde                 */
  1202. /*
  1203.  * This routine expands out a file name passed in `in' and places
  1204.  * the expanded version in `out'.  It returns `out'.
  1205.  */
  1206. {
  1207.     char    username[50],
  1208.            *userPntr;
  1209.     struct passwd *userRecord;
  1211.     out[0] = '';
  1213.     /* Skip over the white space in the initial path */
  1214.     while ((*in == ' ') ||(*in == 't'))
  1215. in    ++;
  1217.     /* Tilde? */
  1218.     if (in[0] == TILDE) {
  1219. /* Copy user name into 'username' */
  1220. in    ++;
  1222. userPntr = &(username[0]);
  1223. while ((*in !='') &&(*in !='/')) {
  1224.     *(userPntr++) = *(in ++);
  1225. }
  1226. *(userPntr) = '';
  1227. /* See if we have to fill in the user name ourselves */
  1228. if (strlen(username) == 0) {
  1229.     userRecord = getpwuid(getuid());
  1230. }
  1231. else {
  1232.     userRecord = getpwnam(username);
  1233. }
  1234. if (userRecord) {
  1235.     /* Found user in passwd file.  Concatenate user directory */
  1236.     strcat(out, userRecord->pw_dir);
  1237. }
  1238.     }
  1240.     /* Concantenate remaining portion of file name */
  1241.     strcat(out, in);
  1242.     return out;
  1243. }
  1247. #define ERR_MSG_SIZE 2048
  1249. /*ARGSUSED*/
  1250. static int
  1251. XErrHandler(disp_ptr, evt)
  1252. Display *disp_ptr;
  1253. XErrorEvent *evt;
  1255. /*
  1256.  * Displays a nicely formatted message and core dumps.
  1257.  */
  1258. {
  1259.     char    err_buf[ERR_MSG_SIZE],
  1260.             mesg[ERR_MSG_SIZE],
  1261.             number[ERR_MSG_SIZE];
  1262.     char   *mtype = "XlibMessage";
  1264.     XGetErrorText(disp_ptr, evt->error_code, err_buf, ERR_MSG_SIZE);
  1265.     (void) fprintf(stderr, "X Error: %sn", err_buf);
  1266.     XGetErrorDatabaseText(disp_ptr, mtype, "MajorCode",
  1267.   "Request Major code %d", mesg, ERR_MSG_SIZE);
  1268.     (void) fprintf(stderr, mesg, evt->request_code);
  1269.     (void) sprintf(number, "%d", evt->request_code);
  1270.     XGetErrorDatabaseText(disp_ptr, "XRequest", number, "", err_buf,
  1271.   ERR_MSG_SIZE);
  1272.     (void) fprintf(stderr, " (%s)n", err_buf);
  1274.     abort();
  1275. }