home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / endo / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-12  |  21.7 KB  |  644 lines
  1. /*************************************************************************
  2.  *                                                                       *
  3.  *  Copyright (c) 1992, 1993 Ronald Joe Record                           *
  4.  *                                                                       *
  5.  *  All rights reserved. No part of this program or publication may be   *
  6.  *  reproduced, transmitted, transcribed, stored in a retrieval system,  *
  7.  *  or translated into any language or computer language, in any form or *
  8.  *  by any means, electronic, mechanical, magnetic, optical, chemical,   *
  9.  *  biological, or otherwise, without the prior written permission of:   *
  10.  *                                                                       *
  11.  *      Ronald Joe Record (408) 458-3718                                 *
  12.  *      212 Owen St., Santa Cruz, California 95062 USA                   *
  13.  *                                                                       *
  14.  *************************************************************************/
  15.  
  16. /* Endo - iterate an endomorphism of the plane */
  17.  
  18. /* Written by Ron Record (rr@sco) 17 Jan 1992 */
  19.  
  20. /* INTRO
  21.  * -----
  22.  * The basic idea is to iterate an endomorphism of the plane (R x R).
  23.  * Each point (x,y) is mapped to (f(x,y),g(x,y)). The new point is
  24.  * then mapped to (f(f(x,y),g(x,y)),g(f(x,y),g(x,y))) and so on. Each
  25.  * point is then colored according to how many iterates it took to get
  26.  * within some "delta" of a previous iterate (e.g. a periodic orbit is
  27.  * detected). In addition, another window can be "popped up" and a display
  28.  * of each point's trajectory viewed. A third window displaying the iterates
  29.  * of the "critical curve" can also be popped up. The critical curve is 
  30.  * composed of those points where the determinant of the jacobian is zero.
  31.  * A fourth window displaying Lyapunov exponent values for a region of
  32.  * parameter space may also be viewed.
  33.  * 
  34.  * ACKNOWLEDGEMENTS
  35.  * ----------------
  36.  * The Winter 1992 seminar at UCSC led by Dr. Ralph Abraham was the
  37.  * inspiration for the study of iterated endomorphisms of the plane.
  38.  * Techniques for calculating the critical arcs and absorbing regions
  39.  * were drawn from Laura Gardini of the Istituto di Scienze economiche,
  40.  * Universita' di Urbino. Studies of various maps of the plane were used
  41.  * including papers by Jon von Neumann, Graciela Chichilnisky, John 
  42.  * Guckenheimer, G. Oster, A. Ipaktchi, Wulf Gaertner, Jochen Jungeilges,
  43.  * Ralph Abraham, B. P. Wood, A. J. Lichtenberg, Z. You, E.J. Kostelich,
  44.  * J. A. Yorke, R. Brown, L. Chua, K. Judd, A. I. Mees, K. Aihara, and
  45.  * M. Toyoda. For a complete bibliography, see the README.
  46.  */
  47.  
  48. #include "patchlevel.h"
  49. #include "x.h"
  50.  
  51. static char *version = ENDO_VERSION;
  52.  
  53. int demo = 0, cdown = 1, pdown = 1, adown = 1, ldown = 1, tdown = 1, idown = 1;
  54. int nonleg = 0, updt = 0, reverse_video=0;
  55. static int spacing;
  56. static unsigned char wname[256];
  57. static XSizeHints hint;
  58. extern int MapSelect(), Tit_Event();
  59. extern void Show_Maps(), Clear(), init_color();
  60.  
  61. main(ac, av)
  62.     int ac;
  63.     char **av;
  64. {
  65.     static int ascent, descent, dir, i;
  66.     static XCharStruct overall;
  67.     static XWindowChanges values;
  68.     extern int axes, numattrs;
  69.     extern void init_data(), parseargs(), Save_Parms();
  70.     extern void Draw_Axes(), Draw_Diagonal();
  71.  
  72.     parseargs(ac, av);
  73.     dpy = XOpenDisplay("");
  74.     screen = DefaultScreen(dpy);
  75.     if (reverse_video)
  76.         background = WhitePixel(dpy, screen);
  77.     else
  78.         background = BlackPixel(dpy, screen);
  79.     if (mapindex == -1) {
  80.         Save_Parms(1);
  81.         Change_Parms(0);
  82.     }
  83.     setupmem();
  84.     init_data();
  85.     CreateXorGC(which); 
  86.     if (displayplanes > 1)
  87.         foreground = STARTCOLOR;
  88.     else
  89.         if (reverse_video)
  90.             foreground = BlackPixel(dpy,XDefaultScreen(dpy));
  91.         else
  92.             foreground = WhitePixel(dpy,XDefaultScreen(dpy));
  93.     hint.flags = PPosition|PSize;
  94.     /*
  95.     * Create the window/pixmap used to display the title screen trajectories
  96.     */
  97.     hint.x = 0;
  98.     hint.y = 0;
  99.     hint.width = XDisplayWidth(dpy, screen);
  100.     hint.height = XDisplayHeight(dpy, screen);
  101.     pixtra = XCreatePixmap(dpy, DefaultRootWindow(dpy), hint.width, 
  102.                 hint.height, DefaultDepth(dpy, screen));
  103.     trajec = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy),
  104.                 hint.x, hint.y, hint.width, hint.height,
  105.                 5, foreground, background);
  106.     XSetNormalHints(dpy, trajec, &hint);
  107.     XSelectInput(dpy,trajec,KeyPressMask|ButtonPressMask|ExposureMask);
  108.     /*
  109.     * Create the window used to display the Lyapunov exponents
  110.     */
  111.     hint.width = width;
  112.     hint.height = height;
  113.     pixmap = XCreatePixmap(dpy, DefaultRootWindow(dpy), width, height, 
  114.                     DefaultDepth(dpy, screen));
  115.     lyajec = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), hint.x, hint.y, 
  116.                     width, height, 5, foreground, background);
  117.     /* Title */
  118.     sprintf((char *) wname, LYAP_NAME);
  119.       XSetStandardProperties(dpy, lyajec, wname, "Lyapunov", None, av, ac, &hint);
  120.     XSetNormalHints(dpy, lyajec, &hint);
  121.     cmap = XCreateColormap(dpy, trajec, DefaultVisual(dpy, screen), AllocAll);
  122.     if (mapindex == -1) {
  123.         XMapRaised(dpy, lyajec);
  124.         init_color(dpy, lyajec, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  125.                     numcolors, numwheels, "endo", "Endo", numattrs);
  126.         ldown=0;
  127.         Clear(lyajec);
  128.         which = lyajec;
  129.         Title_Page();
  130.     }
  131.     if (pixmap)    /* reallocate lyapunov pixmap if necessary */
  132.         XFreePixmap(dpy, pixmap);
  133.     pixmap = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  134.             width, height, DefaultDepth(dpy, screen));
  135.     values.x = Max(XDisplayWidth(dpy, screen) - width, 0);
  136.     values.y = Max(XDisplayHeight(dpy, screen) - height, 0);
  137.     values.width = width;
  138.     values.height = height;
  139.     XConfigureWindow(dpy,lyajec,CWX|CWY|CWWidth|CWHeight,&values);
  140.     /* Title */
  141.     XStoreName(dpy, lyajec, LYAP_NAME);
  142.     if (pixtra)    /* reallocate trajectory pixmap if necessary */
  143.         XFreePixmap(dpy, pixtra);
  144.     pixtra = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  145.             trawidth, traheight, DefaultDepth(dpy, screen));
  146.     values.x = Max((XDisplayWidth(dpy, screen)/2) - (width/2), 0);
  147.     values.y = Max(INFO_HEIGHT, (XDisplayHeight(dpy, screen) / 2) -
  148.             (height / 2)) + 30;
  149.     values.width = trawidth;
  150.     values.height = traheight;
  151.     XConfigureWindow(dpy,trajec,CWX|CWY|CWWidth|CWHeight,&values);
  152.     /* Title */
  153.     if (lyap)
  154.         sprintf((char *) wname, BIF_NAME);
  155.     else if (histogram)
  156.         sprintf((char *) wname, HIST_NAME);
  157.     else
  158.         sprintf((char *) wname, TRAJ_NAME);
  159.       XSetStandardProperties(dpy, trajec, wname, "Orbits", None, av, ac, &hint);
  160.     /*
  161.      * Create the window used to display the rate of attraction
  162.      */
  163.     hint.x = 0;
  164.     hint.y = Max(XDisplayHeight(dpy,screen) - height, 0);
  165.     canvas = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), hint.x, hint.y, 
  166.                     width, height, 5, foreground, background);
  167.     pixmap = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  168.             width, height, DefaultDepth(dpy, screen));
  169.     /* Title */
  170.     sprintf((char *) wname, ATTR_NAME);
  171.       XSetStandardProperties(dpy, canvas, wname, "Endo", None, av, ac, &hint);
  172.     XSetNormalHints(dpy, canvas, &hint);
  173.     /*
  174.     * Create the window used to display the critical curves
  175.     */
  176.     hint.x = Max(XDisplayWidth(dpy, screen) - criwidth, 0);
  177.     hint.y = 0;
  178.     crijec = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), hint.x, hint.y, 
  179.                     criwidth, criheight, 5, foreground, background);
  180.     pixcri = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  181.             criwidth, criheight, DefaultDepth(dpy, screen));
  182.     /* Title */
  183.     sprintf((char *) wname, CRIT_NAME);
  184.       XSetStandardProperties(dpy, crijec, wname, "Curves", None, av, ac, &hint);
  185.     XSetNormalHints(dpy, crijec, &hint);
  186.     /*
  187.     * Create the window used to adjust the color map indexing
  188.     */
  189.     hint.x = XDisplayWidth(dpy, screen) - ADJWIDTH - 20;
  190.     hint.y = XDisplayHeight(dpy, screen) - ADJHEIGHT - 20;
  191.     colwin = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), hint.x, hint.y, 
  192.                     ADJWIDTH, ADJHEIGHT, 5, foreground, background);
  193.     /* Title */
  194.     sprintf((char *) wname, ADJ_NAME);
  195.       XSetStandardProperties(dpy, colwin, wname, "Index Map", None,av,ac,&hint);
  196.     XSetNormalHints(dpy, colwin, &hint);
  197.     /*
  198.     * Create the window used to display the color bar histogram index
  199.     */
  200.     hint.x = Max(XDisplayWidth(dpy, screen) - HISBARWID - 20, 0);
  201.     hint.y = 0;
  202.     hisbar = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), hint.x, hint.y, 
  203.                     HISBARWID, HISBARHGT, 5, foreground, background);
  204.     /* Title */
  205.     sprintf((char *) wname, BAR_NAME);
  206.       XSetStandardProperties(dpy, hisbar, wname, "Color Index", None,av,ac,&hint);
  207.     XSetNormalHints(dpy, hisbar, &hint);
  208.     /*
  209.     * Create the window used to display pre-iterates of the critical curves
  210.     */
  211.     hint.x = 0;
  212.     hint.y = 0;
  213.     prejec = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), hint.x, hint.y, 
  214.                     width, height, 5, foreground, background);
  215.     pixpre = XCreatePixmap(dpy, DefaultRootWindow(dpy), 
  216.             width, height, DefaultDepth(dpy, screen));
  217.     /* Title */
  218.     sprintf((char *) wname, PRE_NAME);
  219.       XSetStandardProperties(dpy, prejec, wname, "Pre-Curves", None,av,ac,&hint);
  220.     XSetNormalHints(dpy, prejec, &hint);
  221.     /*
  222.     * Create the window used to display the parameter and map information
  223.     */
  224.     if (displayplanes > 1)
  225.         XQueryTextExtents(dpy,(XID)XGContextFromGC(Data_GC[CG]),"X",
  226.             1,&dir,&ascent,&descent,&overall);
  227.     else
  228.         XQueryTextExtents(dpy,(XID)XGContextFromGC(Data_GC[1]),"X",
  229.             1,&dir,&ascent,&descent,&overall);
  230.     hint.x = 0;
  231.     hint.y = 0;
  232.     hint.width = INFO_WIDTH * overall.width;
  233.     hint.height = INFO_HEIGHT * (ascent + descent);
  234.     info = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), hint.x, hint.y, 
  235.                     hint.width, hint.height, 5, foreground, background);
  236.     /* Title */
  237.     sprintf((char *) wname, INFO_NAME);
  238.       XSetStandardProperties(dpy, info, wname, "Info", None, av, ac, &hint);
  239.     XSetNormalHints(dpy, info, &hint);
  240.     /*
  241.     * Create the window used to display the help info
  242.     */
  243.     hint.x = hint.width + 20;
  244.     hint.width = HELP_WIDTH * overall.width;
  245.     hint.height = HELP_HEIGHT * (ascent + descent);
  246.     help = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), hint.x, hint.y, 
  247.                     hint.width, hint.height, 5, foreground, background);
  248.     /* Title */
  249.     sprintf((char *) wname, HELP_NAME);
  250.       XSetStandardProperties(dpy, help, wname, "Help", None, av, ac, &hint);
  251.     XSetNormalHints(dpy, help, &hint);
  252.     XSelectInput(dpy,lyajec,KeyPressMask|ButtonPressMask|ButtonMotionMask|
  253.         ButtonReleaseMask|ExposureMask|StructureNotifyMask|FocusChangeMask);
  254.     XSelectInput(dpy,trajec,KeyPressMask|ButtonPressMask|ButtonMotionMask|
  255.         ButtonReleaseMask|ExposureMask|StructureNotifyMask|FocusChangeMask);
  256.     XSelectInput(dpy,canvas,KeyPressMask|ButtonPressMask|ButtonMotionMask|
  257.         ButtonReleaseMask|ExposureMask|StructureNotifyMask|FocusChangeMask);
  258.     XSelectInput(dpy,crijec,KeyPressMask|ButtonPressMask|ButtonMotionMask|
  259.         ButtonReleaseMask|ExposureMask|StructureNotifyMask|FocusChangeMask);
  260.     XSelectInput(dpy,prejec,KeyPressMask|ButtonPressMask|ButtonMotionMask|
  261.         ButtonReleaseMask|ExposureMask|StructureNotifyMask|FocusChangeMask);
  262.     XSelectInput(dpy,colwin,KeyPressMask|ButtonPressMask|ButtonMotionMask|
  263.         ButtonReleaseMask|ExposureMask|FocusChangeMask);
  264.     XSelectInput(dpy,info,KeyPressMask|ExposureMask|FocusChangeMask);
  265.     XSelectInput(dpy,help,KeyPressMask|ExposureMask|FocusChangeMask);
  266.     XSelectInput(dpy,hisbar,KeyPressMask|ExposureMask|FocusChangeMask);
  267.     Raise_Maps();
  268.     if (displayplanes > 1)
  269.         init_color(dpy, info, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  270.                     numcolors, numwheels, "endo", "Endo", numattrs);
  271.     else
  272.         XQueryColors(dpy, DefaultColormap(dpy, DefaultScreen(dpy)), Colors, 
  273.                         numcolors);
  274.     rubber_data.band_cursor=XCreateFontCursor(dpy, XC_hand2);
  275.     Draw_Diagonal(trajec);
  276.     Draw_Axes(trajec, axes);
  277.     if (demo)
  278.         for (;;) {
  279.             main_event();
  280.             if (!run) {
  281.                 Cleanup();
  282.                 exit(0);
  283.             }
  284.         }
  285.         else
  286.             for (;;)
  287.                 main_event();
  288. }
  289.  
  290. int
  291. coltohist(n, max, min)
  292. int n, max, min;
  293. {
  294.     extern int start;
  295.  
  296.     return(((n*(max - min)/(numcolors - start - 1)) + min));
  297. }
  298.  
  299. void
  300. updtbar(win, h, H, m, max, min)
  301. Window win;
  302. int h, H, m, max, min;
  303. {
  304.     static char str[32];
  305.     static int k, n, Y0;
  306.     static double d;
  307.     extern int start;
  308.     extern double sea_level, sky_level;
  309.  
  310.     k = numcolors - start - 1;
  311.     if (m)
  312.         Y0 = H;
  313.     else
  314.         Y0 = h;
  315.     if (nonleg) {
  316.         d = sky_level - sea_level;
  317.         sprintf(str, "%d", (int)(sea_level * (max-min)) + min);
  318.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-1, str, strlen(str));
  319.         if (win == trajec)
  320.             XDrawImageString(dpy,pixtra,Data_GC[1], 0, Y0-1, str, strlen(str));
  321.         sprintf(str, "%d", (int)(sky_level * (max-min)) + min);
  322.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-h+10, str, strlen(str));
  323.         if (win == trajec)
  324.             XDrawImageString(dpy,pixtra,Data_GC[1],0,Y0-h+10,str,strlen(str));
  325.         sprintf(str, "%d", 
  326.                     (int)(((0.75*d)+sea_level)*(max-min)) + min);
  327.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-(3*h/4), str, strlen(str));
  328.         if (win == trajec)
  329.            XDrawImageString(dpy,pixtra,Data_GC[1],0,Y0-(3*h/4),str,strlen(str));
  330.         sprintf(str, "%d",
  331.                     (int)(((0.25*d)+sea_level)*(max-min)) + min);
  332.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-(h/4), str, strlen(str));
  333.         if (win == trajec)
  334.             XDrawImageString(dpy,pixtra,Data_GC[1],0,Y0-(h/4),str,strlen(str));
  335.         sprintf(str, "%d",
  336.                     (int)(((0.5*d)+sea_level)*(max-min)) + min);
  337.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-(h/2), str, strlen(str));
  338.         if (win == trajec)
  339.             XDrawImageString(dpy,pixtra,Data_GC[1],0,Y0-(h/2),str,strlen(str));
  340.     }
  341.     else {
  342.         n = coltohist(get_hist_index(sea_level) - start, max, min);
  343.         sprintf(str, "%d",n);
  344.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-1, str, strlen(str));
  345.         if (win == trajec)
  346.             XDrawImageString(dpy,pixtra,Data_GC[1], 0, Y0-1, str, strlen(str));
  347.         n = coltohist(get_hist_index(sky_level)
  348.                 - start, max, min);
  349.         sprintf(str, "%d", n);
  350.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-h+10, str, strlen(str));
  351.         if (win == trajec)
  352.             XDrawImageString(dpy,pixtra,Data_GC[1],0,Y0-h+10,str,strlen(str));
  353.         n = coltohist(get_hist_index(0.75)-start, max, min);
  354.         sprintf(str, "%d", n);
  355.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-(3*h/4), str, strlen(str));
  356.         if (win == trajec)
  357.            XDrawImageString(dpy,pixtra,Data_GC[1],0,Y0-(3*h/4),str,strlen(str));
  358.         n = coltohist(get_hist_index(0.25)-start, max, min);
  359.         sprintf(str, "%d", n);
  360.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-(h/4), str, strlen(str));
  361.         if (win == trajec)
  362.             XDrawImageString(dpy,pixtra,Data_GC[1],0,Y0-(h/4),str,strlen(str));
  363.         n = coltohist(get_hist_index(0.5)-start, max, min);
  364.         sprintf(str, "%d", n);
  365.         XDrawImageString(dpy,win,Data_GC[1], 0, Y0-(h/2), str, strlen(str));
  366.         if (win == trajec)
  367.             XDrawImageString(dpy,pixtra,Data_GC[1],0,Y0-(h/2),str,strlen(str));
  368.     }
  369. }
  370.  
  371. void
  372. fillbar(win, h, H, n) /* window, bar height, window height, corner */
  373. Window win;
  374. int h, H, n;
  375. {
  376.     Window r;
  377.     static int x, y;
  378.     unsigned int new_w, new_h, bw, d;
  379.     static int i, j, k, Y0;
  380.     extern int maxhist, minhist, start;
  381.  
  382.     if (win == hisbar)
  383.         XGetGeometry(dpy,win,&r,&x,&y,&new_w,&new_h,&bw,&d);
  384.     if (nonleg) {
  385.         k = numcolors - start - 1;
  386.         for (i=0; i<h; i++) {
  387.             j = get_hist_index((double)i/(double)h);
  388.             if (n) /* lower left corner */
  389.                 Y0 = H - i;
  390.             else /* upper left corner */
  391.                 Y0 = h - i;
  392.             if (win == trajec) {
  393.                 XDrawLine(dpy, win, Data_GC[j], 0, Y0, HISBARWID - 1, Y0);
  394.                 XDrawLine(dpy, pixtra, Data_GC[j], 0, Y0, HISBARWID - 1, Y0);
  395.             }
  396.             else
  397.                 XDrawLine(dpy, win, Data_GC[j], 0, Y0, new_w, Y0);
  398.         }
  399.     }
  400.     else {
  401.         j = h/numfreecols + 1;
  402.         for (i=MINCOLINDEX; i<numcolors; i++) {
  403.             if (n) /* lower left corner */
  404.                 Y0 = H-(h*(i-MINCOLINDEX)/numfreecols)-j;
  405.             else /* upper left corner */
  406.                 Y0 = h-(h*(i-MINCOLINDEX)/numfreecols)-j;
  407.             if (win == trajec) {
  408.                 XFillRectangle(dpy, win, Data_GC[i], 0, Y0, HISBARWID, j);
  409.                 XFillRectangle(dpy, pixtra, Data_GC[i], 0, Y0, HISBARWID, j);
  410.             }
  411.             else
  412.                 XFillRectangle(dpy, win, Data_GC[i], 0, Y0, new_w, j);
  413.         }
  414.     }
  415.     if (updt)
  416.         if (portrait && histogram)
  417.             updtbar(win, h, H, n, maxhist, minhist);
  418.         else
  419.             updtbar(win, h, H, n, maxperiod, minperiod);
  420. }
  421.  
  422. void
  423. drawmap(a1, b1, a2, b2)
  424. double a1, b1, a2, b2;
  425. {
  426.     static int i, j, k, l;
  427.     static double d;
  428.     extern int histex, start;
  429.  
  430.     if ((histex == 0) || (histex == 1) || (histex == -2)) {
  431.         i = (int)(a1*ADJWIDTH);
  432.         j = (int)(b1*ADJHEIGHT);
  433.         XDrawLine(dpy, colwin, RubberGC, 0, ADJHEIGHT, i, ADJHEIGHT - j);
  434.         if (histex == 0) {
  435.             k = (int)(a2*ADJWIDTH);
  436.             l = (int)(b2*ADJHEIGHT);
  437.             XDrawLine(dpy, colwin, RubberGC, i, ADJHEIGHT-j, k, ADJHEIGHT-l);
  438.             XDrawLine(dpy, colwin, RubberGC, k, ADJHEIGHT-l, ADJWIDTH, 0);
  439.         }
  440.         else if (histex == -2) {
  441.             XDrawLine(dpy, colwin, RubberGC, i, ADJHEIGHT-j, ADJWIDTH-i, j);
  442.             XDrawLine(dpy, colwin, RubberGC, ADJWIDTH-i, j, ADJWIDTH, 0);
  443.         }
  444.         else
  445.             XDrawLine(dpy, colwin, RubberGC, i, ADJHEIGHT-j, ADJWIDTH, 0);
  446.     }
  447.     else {
  448.         d = (double)(numcolors - start - 1);
  449.         for (i=0; i<ADJWIDTH; i++) {
  450.             j = get_hist_index((double)(i)/(double)ADJWIDTH);
  451.             XDrawPoint(dpy,colwin,RubberGC,i,ADJHEIGHT-(j*ADJHEIGHT/numcolors));
  452.         }
  453.     }
  454. }
  455.  
  456. void
  457. Erase_Therm(w, p, wid, hei)
  458. Window w;
  459. Pixmap p;
  460. int wid, hei;
  461. {
  462.     XFillRectangle(dpy,w,Data_GC[0],wid-THERMWIDTH,0,THERMWIDTH,hei);
  463.     XFillRectangle(dpy,p,Data_GC[0],wid-THERMWIDTH,0,THERMWIDTH,hei);
  464. }
  465.  
  466. void
  467. Updt_Therm(w, p, wid, hei, oldparm, newparm)
  468. Window w;
  469. Pixmap p;
  470. int wid, hei;
  471. double oldparm, newparm;
  472. {
  473.     static char str[32];
  474.     static int y_str, x_rect, i, j;
  475.     static double rat;
  476.     extern double therm_min, therm_max;
  477.     extern int therm_index;
  478.  
  479.     x_rect = wid - THERMWIDTH;
  480.     rat = (oldparm-therm_min) / (therm_max-therm_min);
  481.     j = hei/numfreecols + 1;
  482.     i = MINCOLINDEX + (rat * numfreecols);
  483.     y_str = hei - (int)((double)(hei)
  484.         *((oldparm-therm_min) / (therm_max-therm_min)));
  485.     XFillRectangle(dpy, w, Data_GC[i], x_rect, y_str, THERMWIDTH, j);
  486.     XFillRectangle(dpy, p, Data_GC[i], x_rect, y_str, THERMWIDTH, j);
  487.     sprintf(str, " >>> %6.5lf", newparm);
  488.     rat = (therm_max - newparm) / (therm_max-therm_min);
  489.     y_str = (int)((double)(hei-spacing * rat));
  490.     XDrawString(dpy,w,BlackOnWhiteGC, x_rect, y_str, str, strlen(str));
  491.     XDrawString(dpy,p,BlackOnWhiteGC, x_rect, y_str, str, strlen(str));
  492. }
  493.  
  494. void
  495. Draw_Therm(w, p, wid, hei)
  496. Window w;
  497. Pixmap p;
  498. int wid, hei;
  499. {
  500.     static char str[32];
  501.     static int y_str, x_rect, i, j;
  502.     static int ascent, descent, dir;
  503.     static XCharStruct overall;
  504.     static double rat;
  505.     extern double therm_min, therm_max;
  506.     extern int therm_index;
  507.  
  508.     x_rect = wid - THERMWIDTH;
  509.     j = hei/numfreecols + 1;
  510.     for (i=MINCOLINDEX; i<numcolors; i++) {
  511.         y_str = hei -
  512.             (((double)(i-MINCOLINDEX)/(double)numfreecols)*(hei+j))-j;
  513.         XFillRectangle(dpy, w, Data_GC[i], x_rect, y_str, THERMWIDTH, j);
  514.         XFillRectangle(dpy, p, Data_GC[i], x_rect, y_str, THERMWIDTH, j);
  515.     }
  516.     rat = (therm_max - therm_min);
  517.     XQueryTextExtents(dpy,(XID)XGContextFromGC(BlackOnWhiteGC),"X",
  518.             1,&dir,&ascent,&descent,&overall);
  519.     spacing = ascent + descent;
  520.     y_str = hei - spacing/2;
  521.     sprintf(str, " Min=%6.5lf", therm_min);
  522.     XDrawString(dpy,w,BlackOnWhiteGC, x_rect, y_str, str, strlen(str));
  523.     XDrawString(dpy,p,BlackOnWhiteGC, x_rect, y_str, str, strlen(str));
  524.     y_str = spacing;
  525.     sprintf(str, " Max=%6.5lf", therm_max);
  526.     XDrawString(dpy,w,BlackOnWhiteGC, x_rect, y_str, str, strlen(str));
  527.     XDrawString(dpy,p,BlackOnWhiteGC, x_rect, y_str, str, strlen(str));
  528.     rat = (therm_max - params[therm_index]) / (therm_max-therm_min);
  529.     sprintf(str, " >>> %6.5lf", (double)params[therm_index]);
  530.     i = 2*spacing;
  531.     spacing = (int)(3.5 * (double)spacing);
  532.     y_str = (int)((double)(hei-spacing)*rat)+i;
  533.     XDrawString(dpy,w,BlackOnWhiteGC, x_rect, y_str, str, strlen(str));
  534.     XDrawString(dpy,p,BlackOnWhiteGC, x_rect, y_str, str, strlen(str));
  535. }
  536.  
  537. Raise_Maps()
  538. {
  539.     extern double A, B, C, D;
  540.     extern int cornerbar, numattrs;
  541.  
  542.     if (precrit && (precrit != 3) && (!(precrit > 6))) {
  543.         XMapRaised(dpy, prejec);
  544.         stacktop = prejec;
  545.         init_color(dpy, prejec, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  546.                     numcolors, numwheels, "endo", "Endo", numattrs);
  547.         pdown=0;
  548.         Clear(prejec);
  549.     }
  550.     if (critical) {
  551.         XMapRaised(dpy, crijec);
  552.         stacktop = crijec;
  553.         init_color(dpy, crijec, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  554.                     numcolors, numwheels, "endo", "Endo", numattrs);
  555.         cdown=0;
  556.         Clear(crijec);
  557.         if (thermometer)
  558.             Draw_Therm(crijec, pixcri, criwidth, criheight);
  559.     }
  560.     if (lyap >= 2) {
  561.         XMapRaised(dpy, lyajec);
  562.         stacktop = lyajec;
  563.         init_color(dpy, lyajec, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  564.                     numcolors, numwheels, "endo", "Endo", numattrs);
  565.         ldown=0;
  566.         Clear(lyajec);
  567.         which = lyajec;
  568.     }
  569.     if (lyap == 0) {
  570.         XMapRaised(dpy, canvas);
  571.         stacktop = canvas;
  572.         init_color(dpy, canvas, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  573.                     numcolors, numwheels, "endo", "Endo", numattrs);
  574.         adown = 0;
  575.         Clear(canvas);
  576.         which = canvas;
  577.         if (thermometer)
  578.             Draw_Therm(canvas, pixmap, width, height);
  579.     }
  580.     if (showbar == 1) {
  581.         XMapRaised(dpy, hisbar);
  582.         init_color(dpy, hisbar, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  583.                     numcolors, numwheels, "endo", "Endo", numattrs);
  584.         fillbar(hisbar, HISBARHGT, HISBARHGT, cornerbar);
  585.     }
  586.     else if (showbar == 2)
  587.         fillbar(trajec, traheight/2, traheight, cornerbar);
  588.     if (adjcol) {
  589.         XMapRaised(dpy, colwin);
  590.         init_color(dpy, colwin, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  591.                     numcolors, numwheels, "endo", "Endo", numattrs);
  592.         drawmap(A, B, C, D);
  593.     }
  594.     if (portrait) {
  595.         XMapRaised(dpy, trajec);
  596.         stacktop = trajec;
  597.         init_color(dpy, trajec, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  598.                     numcolors, numwheels, "endo", "Endo", numattrs);
  599.         tdown=0;
  600.         Clear(trajec);
  601.         if (thermometer)
  602.             Draw_Therm(trajec, pixtra, trawidth, traheight);
  603.     }
  604. }
  605.  
  606. int xmargin, ymargin;
  607.  
  608. Title_Page()
  609. {
  610.     extern void Save_Parms();
  611.     extern int numattrs;
  612.  
  613.     if (XDisplayWidth(dpy, screen) < 800) {
  614.         xmargin = (XDisplayWidth(dpy, screen) - DEMO_16_WIDTH) / 2;
  615.         ymargin = (XDisplayHeight(dpy, screen) - DEMO_16_WIDTH) / 2;
  616.     }
  617.     else {
  618.         xmargin = (XDisplayWidth(dpy, screen) - DEMO_WIDTH) / 2;
  619.         ymargin = (XDisplayHeight(dpy, screen) - DEMO_WIDTH) / 2;
  620.     }
  621.     XStoreName(dpy, trajec, TITLE_NAME);
  622.     XMapRaised(dpy, trajec);
  623.     numwheels = MAXWHEELS;
  624.     init_color(dpy, trajec, cmap, Colors, STARTCOLOR, MINCOLINDEX,
  625.                     numcolors, numwheels, "endo", "Endo", numattrs);
  626.     stacktop = trajec;
  627.     tdown=0;
  628.     Clear(trajec);
  629.     for(;;)
  630.         if (Tit_Event())
  631.             break;
  632.     Clear(trajec);
  633.     Save_Parms(0);
  634.     XStoreName(dpy, trajec, SELECT_NAME);
  635.     mapindex = 10 + MAP_OFF;
  636.     Show_Maps(mapindex);
  637.     for(;;)
  638.         if (MapSelect())
  639.             break;
  640.     XUnmapWindow(dpy, lyajec); ldown=1;
  641.     XUnmapWindow(dpy, trajec); tdown=1;
  642.     xmargin = ymargin = 0;
  643. }
  644.