home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / xgui / sources / ui_displwght.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  31.7 KB  |  1,101 lines
  1. /*****************************************************************************
  2.   FILE           : ui_displwght.c
  3.   SHORTNAME      : ui_displwght
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : contains all routines to display the weights as Hinton or
  7.                    WV- diagrams
  8.  
  9.  
  10.   NOTES          :  Functions: 
  11.              -- ui_displWeights
  12.                 Purpose : Main program to display the weights of the network
  13.                 Calls   : krui_getNoOfUnits()
  14.                           ui_confirmOk()
  15.                           DisplayPlanes()
  16.                           ui_xCreateButtonItem()
  17.                           ui_createMyScreen()
  18.          -- ui_wght_event:
  19.             Purpose : event handler for graphic window
  20.         Calls   :ui_wght_geometry();
  21.                      ui_displWeightsBW();
  22.              ui_displWeightsCOL();
  23.                  ui_wght_grid();
  24.              -- ui_displWeightsBW
  25.                 Purpose : Display the weights of the network in black and white
  26.                 Calls   : krui_getNoOfUnits()
  27.                           krui_getFirstUnit()
  28.                           krui_setCurrentUnit()
  29.                           krui_getFirstPredUnit()
  30.                           krui_getNextPredUnit()
  31.                           krui_getNextUnit()
  32.              -- ui_displWeightsCOL
  33.                 Purpose : Display the weights of the network in color
  34.                 Calls   : krui_getNoOfUnits()
  35.                           krui_getFirstUnit()
  36.                           krui_setCurrentUnit()
  37.                           krui_getFirstPredUnit()
  38.                           krui_getNextPredUnit()
  39.                           krui_getNextUnit()
  40.              -- ui_displWeightsFromUpdate
  41.                 Purpose : Interface program, used if net was updated and has 
  42.                           to be redrawn.
  43.                 Calls   : krui_getNoOfUnits()
  44.                           ui_displWeights()
  45.                           ui_displWeightsBW()
  46.                           ui_displWeightsCOL()
  47.              -- ui_wght_close
  48.                 Purpose : notify xgui about the destruction of the window
  49.                 Calls   : XtDestroyWidget()
  50.          -- ui_wght_info
  51.             Purpose : Program to display information about the weights
  52.          -- ui_wght_setup
  53.             Purpose : Setup panel for the grid width and the color scale 
  54.          -- ui_wght_close_setup
  55.             Purpose : notify xgui about the destruction of the setup 
  56.                   panel and read out the widget values
  57.          -- ui_wght_scale
  58.             Purpose : Program to display the scale of colors /scale of 
  59.                   square sizes
  60.          -- ui_wght_zoom_in
  61.             Purpose : Zomms onto the weight squares
  62.          -- ui_wght_zoom_out
  63.             Purpose : Zomms away from the weight squares
  64.          -- ui_wght_geometry
  65.             Purpose : compute the geometry of the displays and the 
  66.                   size of the squares
  67.          -- ui_wght_grid
  68.             Purpose : draws a grid over the weight squares and the axis
  69.  
  70.  
  71.   AUTHOR         : Guenter Mamier 
  72.   DATE           : 05.08.1993 
  73.  
  74.   CHANGED BY     : Sven Doering
  75.   IDENTIFICATION : @(#)ui_displwght.c    1.14 3/2/94
  76.   SCCS VERSION   : 1.14
  77.   LAST CHANGE    : 3/2/94
  78.  
  79.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  80.  
  81.  
  82. ******************************************************************************/
  83. #include <stdio.h>            /* For the Syntax message */
  84.  
  85. #include "ui.h"
  86.  
  87. #include <X11/Intrinsic.h>
  88. #include <X11/IntrinsicP.h>
  89. #include <X11/StringDefs.h>
  90. #include <X11/Xaw/Text.h>
  91. #include <X11/Xaw/TextSrc.h>
  92. #include <X11/Shell.h>
  93. #include <X11/cursorfont.h>
  94. #include <X11/Xaw/MenuButton.h>
  95. #include <X11/Xaw/Form.h>
  96. #include <X11/Xaw/Box.h>
  97. #include <X11/Xaw/Cardinals.h>
  98. #include <X11/Xaw/Command.h>
  99. #include <X11/Xaw/Dialog.h>
  100. #include <X11/Xaw/List.h>
  101. #include <X11/Xaw/Label.h>
  102. #include <X11/Xaw/AsciiText.h>
  103. #include <X11/Xaw/Scrollbar.h>
  104. #include <X11/Xaw/Viewport.h>
  105.  
  106. #include "kr_ui.h"
  107. #include "ui_xWidgets.h"
  108. #include "ui_confirmer.h"
  109. #include "ui_funcdispl.h"
  110.  
  111. #include "ui_displwght.ph"
  112. #include "ui_main.h"
  113. #include "ui_color.h"
  114. #include "ui_mainP.h"
  115. #include "ui_setup.h"
  116.  
  117.  
  118.  
  119. /*****************************************************************************
  120.   FUNCTION : ui_displWeights
  121.  
  122.   PURPOSE  : Main program to display the weights of the network
  123.   NOTES    : Initializes widgets and switches for color or b&w terminal
  124.   RETURNS  : 
  125.   UPDATE   : 29.01.92
  126. ******************************************************************************/
  127.  
  128. void ui_displWeights(Widget w, caddr_t call_data)
  129. {
  130.     Widget donebutton,setbutton,framewidget,zoomin,zoomout;
  131.     int maxunits;
  132.     Arg           args[25];   
  133.     Cardinal       n = 0;
  134.     char           buf[40];
  135.  
  136.  
  137.     /* do nothing, if no network is defined */
  138.  
  139.     if( (maxunits = krui_getNoOfUnits()) == 0){
  140.       ui_confirmOk("No network loaded !");
  141.       return;
  142.     }
  143.  
  144.  
  145.     /* If a weight window already exists, just put it on top */
  146.  
  147.     if(WEIGHT_WINDOW_created == 1){
  148.        Window root;
  149.        int    x, y;
  150.        unsigned int borderWidth, depth, width, height;
  151.        XWindowChanges xChange;
  152.  
  153.        (void) XGetGeometry(ui_display, XtWindow(WEIGHT_GRAPH_mainwidget),
  154.                &root,&x,&y,&width,&height,&borderWidth,&depth);
  155.        xChange.stack_mode = (int) Above;
  156.        XConfigureWindow(ui_display, XtWindow(WEIGHT_GRAPH_mainwidget), 
  157.             CWStackMode, &xChange);
  158.        return;
  159.     }
  160.  
  161.  
  162.     /* Create all necessary widgets */
  163.  
  164.     n = 0;
  165.     sprintf(buf,"Weight Visualization\n");
  166.     WEIGHT_GRAPH_mainwidget = 
  167.            XtCreatePopupShell(buf,topLevelShellWidgetClass,ui_toplevel,args,n);
  168.     n = 0;
  169.     framewidget = XtCreateManagedWidget("form",formWidgetClass,
  170.                     WEIGHT_GRAPH_mainwidget,args,n);
  171.     donebutton  = ui_xCreateButtonItem("done", framewidget, NULL, NULL);
  172.  
  173.     if(WEIGHT_gridWidth == 0)
  174.     WEIGHT_gridWidth = ((int)(0.1*maxunits)<1)? 1: 0.1*maxunits;
  175.     minWght = (float)-ui_maxWeight;
  176.     maxWght = (float)ui_maxWeight;
  177.     zoomin = ui_xCreateButtonItem("zoomin",framewidget,NULL,donebutton);
  178.     setbutton = ui_xCreateButtonItem("setup",framewidget,zoomin,NULL);
  179.     zoomout = ui_xCreateButtonItem("zoomout",framewidget,zoomin,donebutton);
  180.  
  181.     n = 0;
  182.     XtSetArg(args[n], XtNx, 0);n++;
  183.     XtSetArg(args[n], XtNy, 0);n++;
  184.     XtSetArg(args[n], XtNwidth, 210); n++;
  185.     XtSetArg(args[n], XtNheight, 25); n++;
  186.     XtSetArg(args[n], XtNinternalHeight, 1); n++;
  187.     XtSetArg(args[n], XtNinternalWidth , 1); n++;
  188.     XtSetArg(args[n], XtNborderWidth,  0); n++;
  189.     XtSetArg(args[n], XtNhorizDistance, 30);      n++;
  190.     XtSetArg(args[n], XtNfromHoriz, setbutton);      n++;
  191.     XtSetArg(args[n], XtNfromVert, NULL); n++;
  192.     XtSetArg(args[n], XtNleft  , XtChainLeft);  n++;
  193.     XtSetArg(args[n], XtNright , XtChainLeft); n++;
  194.     XtSetArg(args[n], XtNtop   , XtChainTop);   n++;
  195.     XtSetArg(args[n], XtNbottom, XtChainTop);n++;
  196.     scale = XtCreateManagedWidget("Label",formWidgetClass,framewidget,args,n);
  197.  
  198.     n = 0;
  199.     XtSetArg(args[n], XtNx, 0);n++;
  200.     XtSetArg(args[n], XtNy, 0);n++;
  201.     XtSetArg(args[n], XtNborderWidth,  1); n++;
  202.     XtSetArg(args[n], XtNwidth,  WEIGHT_windowsize+62); n++;
  203.     XtSetArg(args[n], XtNheight, WEIGHT_windowsize+62); n++;
  204.     XtSetArg(args[n], XtNallowHoriz, TRUE);n++;
  205.     XtSetArg(args[n], XtNallowVert, TRUE);n++;
  206.     XtSetArg(args[n], XtNforceBars, TRUE);n++;
  207.     XtSetArg(args[n], XtNfromHoriz, NULL);      n++;
  208.     XtSetArg(args[n], XtNfromVert, zoomin); n++;
  209.     XtSetArg(args[n], XtNvertDistance, 10); n++;
  210.     XtSetArg(args[n], XtNleft  , XtChainLeft);  n++;
  211.     XtSetArg(args[n], XtNright , XtChainRight); n++;
  212.     XtSetArg(args[n], XtNtop   , XtChainTop);   n++;
  213.     XtSetArg(args[n], XtNbottom, XtChainBottom);n++;
  214.     view = XtCreateManagedWidget("view",viewportWidgetClass,framewidget,args,n);
  215.     WEIGHT_GRAPH_displaywidget =
  216.            ui_createMyScreen("screen",view,WEIGHT_windowsize,WEIGHT_windowsize,
  217.                  NULL,scale);
  218.     WEIGHT_WINDOW_created = 1;
  219.  
  220.  
  221.     /* define the routines to be called for widget events */
  222.  
  223.     XtAddCallback(donebutton, XtNcallback,
  224.           (XtCallbackProc)ui_wght_close,WEIGHT_GRAPH_mainwidget);
  225.     XtAddCallback(setbutton, XtNcallback,(XtCallbackProc)ui_wght_setup,NULL);
  226.     XtAddCallback(zoomin, XtNcallback,(XtCallbackProc)ui_wght_zoom_in,NULL);
  227.     XtAddCallback(zoomout, XtNcallback,(XtCallbackProc)ui_wght_zoom_out,NULL);
  228.     XtAddEventHandler(WEIGHT_GRAPH_displaywidget,
  229.               ButtonPressMask|ButtonReleaseMask,FALSE,
  230.               (XtEventHandler) ui_wght_info,NULL);
  231.     XtAddEventHandler(WEIGHT_GRAPH_displaywidget, 
  232.               StructureNotifyMask | ExposureMask, GraphicsExpose,
  233.               (XtEventHandler) ui_wght_event,ui_display);
  234.  
  235.  
  236.     /* set the maximum size of each square and the size of the whole window */
  237.  
  238.     if(ui_col_monochromeMode){
  239.        /* B&W terminal => variable square size needed */
  240.        WEIGHT_squaresize = (maxunits > WEIGHT_viewsize/HINTON_squaresize)? 
  241.                        HINTON_squaresize: 
  242.                        (int)((float)WEIGHT_viewsize/(float)maxunits);
  243.        WEIGHT_windowsize = WEIGHT_squaresize*maxunits+40;
  244.     }else{
  245.        /* color terminal => fixed square size */
  246.        WEIGHT_squaresize = 
  247.               (maxunits > WEIGHT_viewsize/5)?5:(int)(WEIGHT_viewsize/maxunits);
  248.        WEIGHT_windowsize = WEIGHT_squaresize*maxunits+40;
  249.     }
  250.  
  251.  
  252.     /* Realize the window */
  253.  
  254.     XtPopup(WEIGHT_GRAPH_mainwidget, XtGrabNone);
  255.  
  256.     WEIGHT_GRAPH_screen = DefaultScreen(ui_display);
  257.     WEIGHT_GRAPH_win    = XtWindow(WEIGHT_GRAPH_displaywidget);
  258.  
  259.       
  260. }
  261.  
  262.  
  263.  
  264.  
  265. /*****************************************************************************
  266.   FUNCTION : ui_wght_event
  267.  
  268.   PURPOSE  : event handler for graphic window
  269.   NOTES    : 
  270.   RETURNS  :
  271.   UPDATE   : 20.02.92
  272. *****************************************************************************/
  273. static void ui_wght_event(Widget w, Display *display, XEvent *event)
  274. {
  275.  
  276.     int zooming    = 0;
  277.     int col_screen = 1;
  278.     int bw_screen  = 0;
  279.  
  280.     switch (event->type){
  281.         case Expose:
  282.                if (event->xexpose.count == 0)
  283.  
  284.            if(ui_col_monochromeMode){
  285.                /* this is a  B&W terminals, so use ui_displWeightsBW */
  286.                ui_wght_geometry(zooming);
  287.                    ui_displWeightsBW();
  288.                ui_wght_grid(bw_screen);
  289.            }else{
  290.                ui_wght_geometry(zooming);
  291.                ui_displWeightsCOL();
  292.                ui_wght_grid(col_screen);
  293.            }
  294.            break;
  295.     default:
  296.            break;
  297.     }
  298. }
  299.  
  300.  
  301.  
  302.  
  303. /*****************************************************************************
  304.   FUNCTION : ui_displWeightsBW
  305.  
  306.   PURPOSE  : Program to display the weights of the network in black and white
  307.   NOTES    :
  308.   RETURNS  : 
  309.   UPDATE   : 04.08.93
  310. ******************************************************************************/
  311.  
  312. static void ui_displWeightsBW(void)
  313. {
  314.    int  maxunits,step;
  315.    int  n,next,pred;
  316.    FlintType strength;
  317.    float reference;
  318.    int xx,yy;
  319.    uint dx,dy;
  320.  
  321.  
  322.    /* clear the window */
  323.  
  324.    XSetForeground(ui_display, WEIGHT_GRAPH_gc[0], 
  325.           BlackPixel(ui_display,WEIGHT_GRAPH_screen));
  326.    XSetBackground(ui_display, WEIGHT_GRAPH_gc[0], 
  327.           WhitePixel(ui_display,WEIGHT_GRAPH_screen));
  328.    XClearWindow(ui_display,WEIGHT_GRAPH_win);
  329.  
  330.  
  331.    /* draw the weight squares */
  332.  
  333.    n = 1;
  334.    next = krui_getFirstUnit();
  335.    krui_setCurrentUnit(next);
  336.    reference = (float)HINTON_squaresize / (float)((maxWght-minWght)/2); 
  337.    do{
  338.       if((pred=krui_getFirstPredUnit(&strength)) !=0){
  339.          do{
  340.         strength = (strength > maxWght)? maxWght: strength;
  341.         strength = (strength < minWght)? minWght: strength;
  342.         dx = dy = abs( (int)(reference * (float)strength));
  343.         xx = (int)(pred*HINTON_squaresize-HINTON_squaresize*0.5-dx*0.5)+20;
  344.         yy = (int)(next*HINTON_squaresize-HINTON_squaresize*0.5-dy*0.5)+20;
  345.  
  346.         if(strength > 0.0){
  347.            XFillRectangle(ui_display,WEIGHT_GRAPH_win,
  348.                   WEIGHT_GRAPH_gc[0],xx,yy,dx,dy);
  349.         }else{
  350.            XDrawRectangle(ui_display,WEIGHT_GRAPH_win,
  351.                   WEIGHT_GRAPH_gc[0],xx,yy,dx,dy);
  352.         }
  353.      }while( (pred=krui_getNextPredUnit(&strength)) != 0);
  354.       }
  355.     }while((next=krui_getNextUnit()) != 0);
  356.  
  357.   
  358.    /* draw the scale */
  359.  
  360.    ui_wght_scale(scale); 
  361.  
  362.  
  363.    /* get everything on the screen */
  364.  
  365.    XFlush(ui_display);
  366.  
  367. } 
  368.  
  369.  
  370.  
  371. /*****************************************************************************
  372.   FUNCTION : ui_displWeightsCOL
  373.  
  374.   PURPOSE  : Program to display the weights of the network in color
  375.   NOTES    :
  376.   RETURNS  : 
  377.   UPDATE   : 04.08.93
  378. ******************************************************************************/
  379.  
  380. static void ui_displWeightsCOL(void)
  381. {
  382.    int  next,pred;
  383.    FlintType strength;
  384.    float maxStrength;
  385.    int xx,yy;
  386.    uint dx,dy;
  387.  
  388.  
  389.    /* clear the window */
  390.    
  391.    XSetForeground(ui_display, WEIGHT_GRAPH_gc[20], 
  392.           BlackPixel(ui_display,WEIGHT_GRAPH_screen));
  393.    XSetBackground(ui_display, WEIGHT_GRAPH_gc[20], 
  394.           WhitePixel(ui_display,WEIGHT_GRAPH_screen));
  395.    XClearWindow(ui_display,WEIGHT_GRAPH_win);
  396.  
  397.  
  398.    /* draw the weight squares */
  399.  
  400.    dx = dy = WEIGHT_squaresize;
  401.    next = krui_getFirstUnit();
  402.    krui_setCurrentUnit(next);
  403.    do{
  404.       if((pred=krui_getFirstPredUnit(&strength)) !=0){
  405.          do{
  406.         xx = (int)(pred-1)*WEIGHT_squaresize+20;
  407.         yy = (int)(next-1)*WEIGHT_squaresize+20;
  408.         strength = 20*strength/(maxWght-minWght);
  409.         strength = (strength > 9)?  9: strength;
  410.         strength = (strength <-9)? -9: strength;
  411.         XFillRectangle(ui_display,WEIGHT_GRAPH_win,
  412.                WEIGHT_GRAPH_gc[(int)(10.0 + (float)strength)],
  413.                xx,yy,dx,dy);
  414.      }while( (pred=krui_getNextPredUnit(&strength)) != 0);
  415.       }
  416.     }while((next=krui_getNextUnit()) != 0);
  417.  
  418.  
  419.    /* draw the scale */
  420.  
  421.    ui_wght_scale(scale);
  422.  
  423.    /* get everything on the screen */
  424.  
  425.    XFlush(ui_display);
  426. }
  427.  
  428.  
  429.  
  430.  
  431. /*****************************************************************************
  432.   FUNCTION : ui_displWeightsFromUpdate
  433.  
  434.   PURPOSE  : Interface program, used if net was updated and has to be redrawn.
  435.   NOTES    :
  436.   RETURNS  : 
  437.   UPDATE   : 29.01.92
  438. ******************************************************************************/
  439. void ui_displWeightsFromUpdate(void)
  440. {
  441.    int maxunits;
  442.  
  443.    if( !WEIGHT_WINDOW_created )return;
  444.  
  445.  
  446.    if(((maxunits=krui_getNoOfUnits()) != old_maxunits)  && old_maxunits){
  447.       /* New network was loaded with different # of units *
  448.        * ==> new viewport has to be created               */
  449.       XtDestroyWidget(WEIGHT_GRAPH_mainwidget);
  450.       old_maxunits = maxunits;
  451.       WEIGHT_WINDOW_created = 0;
  452.       WEIGHT_viewsize   = 400;
  453.       HINTON_squaresize =  16;
  454.       WEIGHT_squaresize =   0;
  455.       ui_displWeights(WEIGHT_GRAPH_displaywidget,NULL);
  456.    }else{
  457.  
  458.       /* old network was only updated, so redraw is sufficient */
  459.       if(ui_col_monochromeMode){
  460.          ui_displWeightsBW();
  461.       }else{
  462.          ui_displWeightsCOL();
  463.      }
  464.  
  465.    }
  466. }
  467.  
  468.  
  469.  
  470. /*****************************************************************************
  471.   FUNCTION : ui_wght_close
  472.  
  473.   PURPOSE  : notify xgui about the destruction of the window
  474.   NOTES    :
  475.   RETURNS  : 
  476.   UPDATE   : 29.01.92
  477. ******************************************************************************/
  478. static void ui_wght_close(Widget dummy, Widget w, caddr_t call_data)
  479. {
  480.    XtDestroyWidget(w);
  481.    WEIGHT_WINDOW_created = 0;
  482.    WEIGHT_gridWidth = 0;
  483.    old_maxunits = 0;
  484. }
  485.  
  486.  
  487.  
  488. /*****************************************************************************
  489.   FUNCTION : ui_wght_info
  490.  
  491.   PURPOSE  : Program to display information about the weights
  492.   NOTES    :
  493.   RETURNS  : 
  494.   UPDATE   : 03.08.93
  495. ******************************************************************************/
  496.  
  497. static void ui_wght_info(Widget w, Display *display, XEvent *event)
  498. {
  499.     Widget ui_wei_popup;
  500.     static Bool ui_wei_exit = TRUE;
  501.     int xval,yval;
  502.     int actual_size;
  503.     FlintType con_weight;
  504.     char buf[40];
  505.     Widget label,form;
  506.     uint n;
  507.  
  508.     Arg args[5];
  509.     
  510.  
  511.    /* set the square size */
  512.  
  513.    if(ui_col_monochromeMode)
  514.        actual_size = HINTON_squaresize;
  515.    else 
  516.        actual_size = WEIGHT_squaresize;
  517.  
  518.  
  519.     switch(event->type){
  520.         case ButtonPress: 
  521.  
  522.              /* get unit numbers of clicked at connection */
  523.          xval = (int)((float)(event->xbutton.x-20) /
  524.               (float)(actual_size))+1;
  525.          yval = (int)((float)(event->xbutton.y-20) /
  526.               (float)actual_size)+1;
  527.  
  528.          /* do nothing for invalid numbers */
  529.          if(xval<0 || yval<0)return;
  530.          if(xval>krui_getNoOfUnits() || yval>krui_getNoOfUnits())return;
  531.  
  532.          /* create  label and popup */
  533.          if(krui_areConnected(xval,yval,&con_weight))
  534.             sprintf(buf,"Link %d -> %d \nhas weight %f"
  535.             ,xval,yval,con_weight);
  536.          else
  537.             sprintf(buf,"No connection from unit %d to unit %d\n",
  538.                xval,yval);
  539.          ui_wei_popup = XtCreatePopupShell("info",overrideShellWidgetClass,
  540.                            ui_toplevel,NULL, 0);
  541.          form = XtCreateManagedWidget("form",formWidgetClass,ui_wei_popup, 
  542.                        NULL,0);
  543.          n = 0;
  544.          XtSetArg(args[n], XtNfromHoriz, NULL); n++;
  545.          XtSetArg(args[n], XtNborderWidth, 0); n++;
  546.          XtSetArg(args[n], XtNlabel, buf); n++;
  547.          label = XtCreateManagedWidget("weiMsg",labelWidgetClass,form,
  548.                        args,n);
  549.          XawFormDoLayout(form, True);
  550.          XtRealizeWidget(ui_wei_popup);
  551.     
  552.          /* now move the popup to the mouse position */
  553.          {
  554.            Window root;
  555.            int    x, y;
  556.            unsigned int borderWidth, depth, width, height;
  557.            XWindowChanges xChange;
  558.  
  559.            (void) XGetGeometry(ui_display, XtWindow(ui_wei_popup),
  560.                    &root, &x, &y, &width, &height, 
  561.                    &borderWidth, &depth);
  562.  
  563.            xChange.x = event->xbutton.x_root;
  564.            xChange.y = event->xbutton.y_root;
  565.            xChange.stack_mode = (int) Above;
  566.            XConfigureWindow(ui_display, XtWindow(ui_wei_popup), 
  567.                 CWX BIT_OR CWY BIT_OR CWStackMode, &xChange);
  568.          }
  569.  
  570.          XtPopup(ui_wei_popup, XtGrabExclusive);
  571.          ui_wei_exit = FALSE;
  572.          while (NOT ui_wei_exit) {
  573.             XtAppNextEvent(ui_appContext, event);
  574.         if(event->type == ButtonRelease){
  575.            XtDestroyWidget(ui_wei_popup);
  576.            ui_wei_exit = TRUE;
  577.         }
  578.             (void) XtDispatchEvent(event);
  579.          }
  580.              break;
  581.  
  582.         default: /* ignore all other events */
  583.              break;
  584.     }
  585. }
  586.  
  587.  
  588.  
  589.  
  590. /*****************************************************************************
  591.   FUNCTION : ui_wght_setup
  592.  
  593.   PURPOSE  : Setup panel for the grid width and the color scale 
  594.   NOTES    :
  595.   RETURNS  : 
  596.   UPDATE   : 04.08.93
  597. ******************************************************************************/
  598.  
  599. static void ui_wght_setup(Widget button, caddr_t call_data)
  600. {
  601.  
  602.  
  603.     Widget      grid_lab,grid_win,WEIGHT_GRAPH_setupwidget;
  604.     Widget      ui_setupPanel,done,subframe,dummy,range_lab;
  605.     char        buf[80];
  606.     Position    x, y;
  607.     Dimension   width, height;
  608.     Arg        args[25];   
  609.     Cardinal    n = 0;
  610.  
  611.     int         titelWidth  = 32;
  612.     int         floatWidth  = 48;
  613.     int         maxunits;
  614.  
  615.  
  616.     maxunits = krui_getNoOfUnits();
  617.  
  618.     /* set Popup arguments */
  619.  
  620.     n = 0;
  621.     XtSetArg(args[0], XtNwidth, &width);n++;
  622.     XtSetArg(args[1], XtNheight, &height);n++;
  623.     XtGetValues(button, args, n);
  624.     XtTranslateCoords(button, (Position)(width/2), 
  625.               (Position)(height/2), &x, &y);
  626.     n = 0;
  627.     XtSetArg(args[n], XtNx, x);n++;
  628.     XtSetArg(args[n], XtNy, y+50);n++;
  629.  
  630.  
  631.     /* Now create Popup */
  632.  
  633.     WEIGHT_GRAPH_setupwidget = 
  634.     XtCreatePopupShell("Setup", transientShellWidgetClass, 
  635.                ui_toplevel, args, n);
  636.     ui_setupPanel =
  637.     XtCreateManagedWidget("form", formWidgetClass, 
  638.                   WEIGHT_GRAPH_setupwidget, NULL, ZERO);
  639.  
  640.     done = ui_xCreateButtonItem("done", ui_setupPanel, NULL, NULL);
  641.     XtAddCallback (done, XtNcallback, (XtCallbackProc)ui_wght_close_setup,
  642.            WEIGHT_GRAPH_setupwidget);
  643.  
  644.     n = 0;
  645.     XtSetArg(args[n], XtNx, 0);n++;
  646.     XtSetArg(args[n], XtNy, 0);n++;
  647.     XtSetArg(args[n], XtNborderWidth,  1); n++;
  648.     XtSetArg(args[n], XtNfromHoriz, NULL);      n++;
  649.     XtSetArg(args[n], XtNfromVert, done); n++;
  650.     XtSetArg(args[n], XtNleft  , XtChainLeft);  n++;
  651.     XtSetArg(args[n], XtNright , XtChainRight); n++;
  652.     XtSetArg(args[n], XtNtop   , XtChainTop);   n++;
  653.     XtSetArg(args[n], XtNbottom, XtChainBottom);n++;
  654.     subframe = XtCreateManagedWidget("sub",formWidgetClass,
  655.                            ui_setupPanel,args,n);
  656.     grid_lab = ui_xCreateLabelItem("grid width   :", subframe,104, NULL, NULL);
  657.  
  658.     sprintf(buf,"%d", WEIGHT_gridWidth);
  659.     grid_dia = ui_xCreateDialogItem("gridWidth", subframe, buf, 
  660.                     titelWidth, grid_lab,NULL);
  661.  
  662.     range_lab = ui_xCreateLabelItem("weight range :", subframe, 
  663.                     104, NULL, grid_lab);
  664.  
  665.     sprintf(buf,"%g",minWght);
  666.     bottomLabel = ui_xCreateDialogItem("bottLab", subframe, buf, 
  667.                        floatWidth,range_lab,grid_lab);
  668.     dummy = ui_xCreateLabelItem("to",subframe,24,bottomLabel,grid_lab);
  669.     
  670.     sprintf(buf,"%g",maxWght);
  671.     topLabel = ui_xCreateDialogItem("topLab", subframe, buf, 
  672.                     floatWidth, dummy,grid_lab);
  673.  
  674.     n = 0;
  675.     XtSetArg(args[n], XtNx, 0);n++;
  676.     XtSetArg(args[n], XtNy, 0);n++;
  677.     XtSetArg(args[n], XtNwidth, 210); n++;
  678.     XtSetArg(args[n], XtNheight, 25); n++;
  679.     XtSetArg(args[n], XtNinternalHeight, 1); n++;
  680.     XtSetArg(args[n], XtNinternalWidth , 1); n++;
  681.     XtSetArg(args[n], XtNborderWidth,  0); n++;
  682.     XtSetArg(args[n], XtNfromHoriz,range_lab);      n++;
  683.     XtSetArg(args[n], XtNfromVert, range_lab); n++;
  684.     XtSetArg(args[n], XtNleft  , XtChainRight);  n++;
  685.     XtSetArg(args[n], XtNright , XtChainRight); n++;
  686.     XtSetArg(args[n], XtNtop   , XtChainBottom);   n++;
  687.     XtSetArg(args[n], XtNbottom, XtChainBottom);n++;
  688.     scale2 = XtCreateManagedWidget("Label2",formWidgetClass,subframe,args,n);
  689.  
  690.     XtRealizeWidget(WEIGHT_GRAPH_setupwidget);
  691.     XtAddEventHandler(scale2, ExposureMask, GraphicsExpose,
  692.               (XtEventHandler) ui_wght_scale,NULL);
  693.  
  694.  
  695.     /* Realize the window */
  696.  
  697.     XtPopup(WEIGHT_GRAPH_setupwidget, XtGrabExclusive);
  698.  
  699.  
  700.     /* get everything on the screen */
  701.  
  702.     XFlush(ui_display);
  703. }              
  704.  
  705.  
  706. /*****************************************************************************
  707.   FUNCTION : ui_wght_close_setup
  708.  
  709.   PURPOSE  : notify xgui about the destruction of the setup panel and read 
  710.              out the widget values
  711.   NOTES    :
  712.   RETURNS  : 
  713.   UPDATE   : 29.01.92
  714. ******************************************************************************/
  715. static void ui_wght_close_setup(Widget dummy, Widget w, caddr_t call_data)
  716. {
  717.    int depth;
  718.    int test;
  719.  
  720.  
  721.    XtDestroyWidget(w);
  722.  
  723.    /* read/set the setup values */
  724.  
  725.    test = (int)ui_xIntFromAsciiWidget(grid_dia);
  726.    if(test > krui_getNoOfUnits()+10)
  727.        ui_confirmOk("Ignoring unplausible large grid size");
  728.    else if(test > 0)
  729.       WEIGHT_gridWidth = test;
  730.    else
  731.       ui_confirmOk("Negative grid size not allowed!!");
  732.  
  733.    maxWght = (float)ui_xFloatFromAsciiWidget(topLabel);
  734.    minWght = (float)ui_xFloatFromAsciiWidget(bottomLabel);
  735.  
  736.  
  737.    /* update display according to the new values */
  738.  
  739.    if(ui_col_colorDisplay){
  740.        ui_displWeightsCOL();
  741.        ui_wght_scale(scale);
  742.        ui_wght_grid(1);
  743.    }else{
  744.        ui_displWeightsBW();
  745.        ui_wght_scale(scale);
  746.        ui_wght_grid(0);
  747.    }
  748.  
  749.  
  750.    /* get everything on the screen */
  751.  
  752.    XFlush(ui_display);
  753.  
  754. }
  755.  
  756.  
  757.  
  758.  
  759.  
  760. /*****************************************************************************
  761.   FUNCTION : ui_wght_scale
  762.  
  763.   PURPOSE  : Program to display the scale of colors /scale of square sizes
  764.   NOTES    :
  765.   RETURNS  : 
  766.   UPDATE   : 04.08.93
  767. ******************************************************************************/
  768.  
  769. static void ui_wght_scale(Widget w)
  770. {
  771.     Window scale_win;
  772.     int n;
  773.     uint size = 10;
  774.     char buf[80];
  775.  
  776.     scale_win = XtWindow(w);
  777.     XClearWindow(ui_display,scale_win);
  778.     
  779.  
  780.     if(ui_col_monochromeMode){
  781.  
  782.        /* on B/W screens display a row of different sized squares */
  783.  
  784.        sprintf(buf,"%-g",minWght);
  785.        XDrawString(ui_display,scale_win,WEIGHT_GRAPH_gc[0],0,10,buf,
  786.            strlen(buf));
  787.        for(n=1; n<=10; n++){
  788.        size = (uint)(10 - n);
  789.        XDrawRectangle(ui_display,scale_win,WEIGHT_GRAPH_gc[0],
  790.               10*(n-1),14+(int)(n/2),size,size);
  791.        }
  792.        for(n=11; n<=19; n++){
  793.        size = (uint)(n - 10);
  794.        XFillRectangle(ui_display,scale_win,WEIGHT_GRAPH_gc[0],
  795.               10*(n-1),14+(int)((20-n)/2),size,size);       
  796.        }
  797.        sprintf(buf,"%g",maxWght);
  798.        XDrawString(ui_display,scale_win,WEIGHT_GRAPH_gc[0],190-strlen(buf)*7,
  799.            10,buf,strlen(buf));
  800.  
  801.     }else{ /* on color screens display the color range */
  802.  
  803.        sprintf(buf,"%-g",minWght);
  804.        XDrawString(ui_display,scale_win,WEIGHT_GRAPH_gc[20],0,10,buf,
  805.            strlen(buf));
  806.        for(n=1; n<=19; n++){
  807.        XFillRectangle(ui_display,scale_win,WEIGHT_GRAPH_gc[n],
  808.               10*(n-1),12,size,size);
  809.        }
  810.        sprintf(buf,"%g",maxWght);
  811.        XDrawString(ui_display,scale_win,WEIGHT_GRAPH_gc[20],190-strlen(buf)*7,
  812.            10,buf,strlen(buf));
  813.    }
  814. }
  815.  
  816.  
  817.  
  818. /*****************************************************************************
  819.   FUNCTION : ui_wght_zoom_in
  820.  
  821.   PURPOSE  : Zomms onto the weight squares
  822.   NOTES    :
  823.   RETURNS  : 
  824.   UPDATE   : 20.07.1993
  825. ******************************************************************************/
  826.  
  827. static void ui_wght_zoom_in(Widget w)
  828. {
  829.  
  830.  
  831.     /* delete the old screen display */
  832.  
  833.     XClearWindow(ui_display,WEIGHT_GRAPH_win);
  834.  
  835.  
  836.     /* compute new display geometry */
  837.  
  838.     ui_wght_geometry(1);
  839.  
  840.  
  841.     /* display the new setting */
  842.  
  843.     if(ui_col_monochromeMode){
  844.     ui_displWeightsBW();
  845.     ui_wght_grid(0);
  846.     }else{
  847.     ui_displWeightsCOL();
  848.     ui_wght_grid(1);
  849.     }
  850. }
  851.  
  852.  
  853.  
  854.  
  855. /*****************************************************************************
  856.   FUNCTION : ui_wght_zoom_out
  857.  
  858.   PURPOSE  : Zomms away from the weight squares
  859.   NOTES    :
  860.   RETURNS  : 
  861.   UPDATE   : 20.07.1993
  862. ******************************************************************************/
  863.  
  864. static void ui_wght_zoom_out(Widget w)
  865. {
  866.  
  867.  
  868.     /* delete the old screen display */
  869.  
  870.     XClearWindow(ui_display,WEIGHT_GRAPH_win);
  871.  
  872.  
  873.     /* compute new display geometry */
  874.  
  875.     ui_wght_geometry(-1);
  876.  
  877.  
  878.     /* display the new setting */
  879.  
  880.     if(ui_col_monochromeMode){
  881.     ui_displWeightsBW();
  882.     ui_wght_grid(0);
  883.     }else{
  884.     ui_displWeightsCOL();
  885.     ui_wght_grid(1);
  886.     }
  887. }
  888.  
  889.  
  890.  
  891. /*****************************************************************************
  892.   FUNCTION : ui_wght_geometry
  893.  
  894.   PURPOSE  : compute the geometry of the displays and the size of the squares
  895.   NOTES    :
  896.   RETURNS  : 
  897.   UPDATE   : 04.08.1993
  898. ******************************************************************************/
  899.  
  900. static void ui_wght_geometry(int zoom_fact)
  901. {
  902.     int  maxunits,step;
  903.     int  n,next,pred;
  904.     FlintType strength;
  905.     float maxStrength;
  906.     int xx,yy;
  907.     uint dx,dy;
  908.     XtWidgetGeometry geo_info, geo_data;
  909.     XtWidgetGeometry disp_info, disp_data;
  910.     XtWidgetGeometry view_info, view_data;
  911.     XtGeometryResult geo_result;
  912.     Dimension got_w,got_h;
  913.     XEvent *event;
  914.  
  915.  
  916.     /* do nothing, if no network defined */
  917.     
  918.     if( (maxunits = krui_getNoOfUnits()) == 0)return;
  919.  
  920.  
  921.     /* set the necessary xlib environment variables */
  922.  
  923.     if(ui_col_monochromeMode){ /* this is a  B&W terminal */
  924.  
  925.     WEIGHT_GRAPH_gc[0]  = XCreateGC(ui_display,WEIGHT_GRAPH_win,0,0); 
  926.  
  927.     /* set the labeling font */
  928.     XSetFont(ui_display, WEIGHT_GRAPH_gc[0], ui_fontStruct->fid);
  929.     
  930.     }else{ /* this is a color terminal */
  931.    
  932.     for(n=0;n<=20;n++)
  933.         WEIGHT_GRAPH_gc[n] = XCreateGC(ui_display,WEIGHT_GRAPH_win,0,0); 
  934.  
  935.     /* set the labeling font */
  936.     XSetFont(ui_display, WEIGHT_GRAPH_gc[20], ui_fontStruct->fid);
  937.  
  938.  
  939.     /* Allocate color table */
  940.  
  941.     WEIGHT_GRAPH_col = DefaultColormap(ui_display,WEIGHT_GRAPH_screen);
  942.     for(n=0; n<10;n++){
  943.         WEIGHT_GRAPH_color_def[n].red   = 65535;
  944.         WEIGHT_GRAPH_color_def[n].green = n*6553;
  945.         WEIGHT_GRAPH_color_def[n].blue  = n*6553;
  946.         XAllocColor(ui_display,WEIGHT_GRAPH_col,&WEIGHT_GRAPH_color_def[n]);
  947.         WEIGHT_GRAPH_color1[n] = WEIGHT_GRAPH_color_def[n].pixel;
  948.         XSetForeground(ui_display,WEIGHT_GRAPH_gc[n],
  949.                (uint) WEIGHT_GRAPH_color1[n]);
  950.         XSetBackground(ui_display,WEIGHT_GRAPH_gc[n], 
  951.                WhitePixel(ui_display,WEIGHT_GRAPH_screen));
  952.         WEIGHT_GRAPH_color_def[10+n].red   = 65535-n*6553;
  953.         WEIGHT_GRAPH_color_def[10+n].green = 65535;
  954.         WEIGHT_GRAPH_color_def[10+n].blue  = 65535-n*6553;
  955.         XAllocColor(ui_display,WEIGHT_GRAPH_col,
  956.             &WEIGHT_GRAPH_color_def[10+n]);
  957.         WEIGHT_GRAPH_color2[n] = WEIGHT_GRAPH_color_def[10+n].pixel;
  958.         XSetForeground(ui_display,WEIGHT_GRAPH_gc[10+n],
  959.                (uint) WEIGHT_GRAPH_color2[n]);
  960.         XSetBackground(ui_display,WEIGHT_GRAPH_gc[10+n],
  961.                WhitePixel(ui_display,WEIGHT_GRAPH_screen));
  962.     }
  963.     }
  964.     
  965.  
  966.     /* get widget geometry */
  967.  
  968.     geo_result = XtQueryGeometry(WEIGHT_GRAPH_mainwidget,&geo_data,&geo_info);
  969.  
  970.     if(geo_result != XtGeometryYes){
  971.     geo_info.height = 400;
  972.     geo_info.width  = 400;
  973.     }
  974.  
  975.     if(zoom_fact != 0){
  976.     XtResizeWidget(WEIGHT_GRAPH_mainwidget,geo_info.width,
  977.                geo_info.height,geo_info.border_width);
  978.     }
  979.  
  980.  
  981.     /* adjust squaresize */
  982.  
  983.     if(ui_col_monochromeMode){ /* this is a  B&W terminal */
  984.     HINTON_squaresize = HINTON_squaresize + zoom_fact;
  985.     if(HINTON_squaresize == 0)HINTON_squaresize = 1;
  986.     WEIGHT_windowsize = HINTON_squaresize*maxunits+40;
  987.     }else{ /* this is a color terminal */
  988.     WEIGHT_squaresize = WEIGHT_squaresize + zoom_fact;
  989.     if(WEIGHT_squaresize == 0)WEIGHT_squaresize = 1;
  990.     WEIGHT_windowsize = WEIGHT_squaresize*maxunits+62;
  991.     }
  992.  
  993.  
  994.     /* Resize all involved windows so that they fit the data and the screen */
  995.  
  996.     XtResizeWidget(WEIGHT_GRAPH_displaywidget,WEIGHT_windowsize+62,
  997.            WEIGHT_windowsize+62,0);
  998.     WEIGHT_viewsize = WEIGHT_squaresize * maxunits;
  999.  
  1000.     geo_result = XtQueryGeometry(WEIGHT_GRAPH_displaywidget,
  1001.                  &disp_data,&disp_info);
  1002.     geo_result = XtQueryGeometry(view,&view_data,&view_info);
  1003.     if(view_info.width > disp_info.width)
  1004.     XtResizeWidget(view,disp_info.width,
  1005.                disp_info.height,view_info.border_width);
  1006.     else
  1007.     if(disp_info.width < geo_info.width)
  1008.         XtResizeWidget(view,disp_info.width,
  1009.                disp_info.height,view_info.border_width);
  1010.     else
  1011.         XtResizeWidget(view,geo_info.width,
  1012.                geo_info.height,view_info.border_width);
  1013.  
  1014.     
  1015.     /* get everything on the screen */
  1016.  
  1017.     XFlush(ui_display);
  1018. }
  1019.  
  1020.  
  1021.  
  1022. /*****************************************************************************
  1023.   FUNCTION : ui_wght_grid
  1024.  
  1025.   PURPOSE  : draws a grid over the weight squares and the axis
  1026.   NOTES    : type == 1 for color display; == 0 for B/W
  1027.   RETURNS  : 
  1028.   UPDATE   : 20.07.1993
  1029. ******************************************************************************/
  1030. static void ui_wght_grid(int type)
  1031. {
  1032.  
  1033.    char outString[40];
  1034.    int  maxunits,step;
  1035.    int  n,next,pred;
  1036.    FlintType strength;  
  1037.    float maxStrength;
  1038.    int xx,yy;
  1039.    int actual_size;
  1040.    uint dx,dy;
  1041.    XPoint p1,p2,p3,p4;
  1042.    static char dash[]={6,6,6};
  1043.  
  1044.  
  1045.  
  1046.     /* do nothing, if no network defined */
  1047.     
  1048.     if( (maxunits = krui_getNoOfUnits()) == 0 || 
  1049.         (WEIGHT_squaresize == 0) )return;
  1050.  
  1051.  
  1052.    /* set the square size */
  1053.  
  1054.    if(ui_col_monochromeMode)
  1055.        actual_size = HINTON_squaresize;
  1056.    else 
  1057.        actual_size = WEIGHT_squaresize;
  1058.  
  1059.  
  1060.  
  1061.    /* set output grid of units */
  1062.  
  1063.    dash[0] = dash[1] = (int)(actual_size*0.5 +0.5);
  1064.    XSetDashes(ui_display,WEIGHT_GRAPH_gc[20*type],
  1065.           (int)(actual_size*0.5 +0.5)+20*type,dash,2);
  1066.    XSetLineAttributes(ui_display,WEIGHT_GRAPH_gc[20*type],0,LineOnOffDash,
  1067.               CapButt,JoinMiter);
  1068.    step = WEIGHT_gridWidth;
  1069.    n = step;
  1070.    while(n <= maxunits){
  1071.       sprintf(outString,"%d",n);
  1072.       p1.x = (int)(actual_size*n-actual_size*0.5)+20;
  1073.       p1.y = 10;
  1074.       p2.x = (maxunits)*actual_size+30;
  1075.       p2.y = (int)(actual_size*n-actual_size*0.5)+20;
  1076.       p3.x = 0; 
  1077.       p3.y = p2.y;
  1078.       p4.x = p1.x;
  1079.       p4.y = (maxunits)*actual_size+20;
  1080.       XDrawString(ui_display,WEIGHT_GRAPH_win,WEIGHT_GRAPH_gc[20*type],
  1081.           p1.x,p1.y,outString,(int)strlen(outString));
  1082.       XDrawString(ui_display,WEIGHT_GRAPH_win,WEIGHT_GRAPH_gc[20*type],
  1083.           p2.x,p2.y,outString,(int)strlen(outString));
  1084.       XDrawString(ui_display,WEIGHT_GRAPH_win,WEIGHT_GRAPH_gc[20*type],
  1085.           p3.x,p3.y,outString,(int)strlen(outString));
  1086.       XDrawString(ui_display,WEIGHT_GRAPH_win,WEIGHT_GRAPH_gc[20*type],
  1087.           p4.x,p4.y+20,outString,(int)strlen(outString));
  1088.       XDrawLine(ui_display,WEIGHT_GRAPH_win,WEIGHT_GRAPH_gc[20*type],
  1089.         p1.x,p1.y,p4.x,p4.y);
  1090.       XDrawLine(ui_display,WEIGHT_GRAPH_win,WEIGHT_GRAPH_gc[20*type],
  1091.         p2.x,p2.y,p3.x+10,p3.y);
  1092.       n += step;
  1093.    }
  1094.    XSetLineAttributes(ui_display,WEIGHT_GRAPH_gc[20*type],0,
  1095.               LineSolid,CapButt,JoinMiter);
  1096.  
  1097. }
  1098.  
  1099. /* end of file */
  1100. /* lines: 1094 */
  1101.