home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xsw / sepwin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-09  |  77.8 KB  |  3,431 lines
  1. /*
  2.  *    @(#) sepwin.c 9.2 93/09/15 SCOINC
  3.  */
  4. /***************************************************************************
  5.  *
  6.  *    Copyright (c) 1990-1993        The Santa Cruz Operation, Inc.
  7.  *
  8.  *    All rights reserved.  No part of this program or publication may be
  9.  *    reproduced, transmitted, transcribed, stored in a retrieval system,
  10.  *    or translated into any language or computer language, in any form or
  11.  *    by any means, electronic, mechanical, magnetic, optical, chemical,
  12.  *    biological, or otherwise, without the prior written permission of:
  13.  *
  14.  *        The Santa Cruz Operation , Inc.        (408) 425-7222
  15.  *        400 Encinal St., Santa Cruz, California 95060 USA
  16.  *
  17.  **************************************************************************/
  18. /*
  19.  * Modification History
  20.  *
  21.  * S001, 15-Sep-93, rickra
  22.  *    Added disk space window....
  23.  *    Some little bug fixes...
  24.  *    
  25.  * S000, 27-May-93, rickra
  26.  *        Initial check in....
  27.  *
  28.  */
  29. /*+-------------------------------------------------------------------------
  30.     sepwin.c - Create, Manage, and destroy the individual windows.....
  31.  
  32.  
  33.   Defined functions:
  34.  
  35. --------------------------------------------------------------------------*/
  36.  
  37. #include "include/unixincs.h"
  38. #include <X11/Xlib.h>
  39. #include <X11/Xutil.h>
  40. #include <X11/Intrinsic.h>
  41. #include <X11/Shell.h>
  42. #include <X11/StringDefs.h>
  43. #include <Xm/Protocols.h>
  44. #include <Xm/Xm.h>
  45. #include <Xm/MainW.h>
  46. #include <Xm/DrawingA.h>
  47. #include <Xm/PanedW.h>
  48. #include <Xm/ToggleB.h>
  49. #include <Xm/Form.h>
  50. #include <Xm/CascadeB.h>
  51. #include <Xm/PushB.h>
  52. #include <Xm/RowColumn.h>
  53. #include <Xm/Label.h>
  54.  
  55.  
  56.  
  57.  
  58. #include "include/buttons.h"
  59. #include "include/resources.h"
  60. #include "include/scales.h"
  61. #include "include/xsw.h"
  62. #include "include/sepwin.h"
  63. #include "include/menus.h"
  64.  
  65. char            widget_title[128];
  66. char            widget_icon_name[128];
  67.  
  68. char           *dupstr;
  69. Widget          temprc;
  70.  
  71.  
  72. extern MyResources res;
  73.  
  74. /*
  75.  * scrolled_ps (scrollbar, scrolled_ps_callback, cbs)
  76.  *
  77.  * This procedure is called when a scrolled window is scrolled horizontally...
  78.  *
  79.  */
  80.  
  81.  
  82. void
  83. scrolled_ps (scrollbar, scrolled_ps_callback, cbs)
  84.      Widget          scrollbar;
  85.      struct scrolled_ps_callback_struct *scrolled_ps_callback;
  86.      XmScrollBarCallbackStruct *cbs;
  87. {
  88.   int             value;
  89.   int             i, j;
  90.   int             scroll_bar_max;
  91.  
  92.   int             t1, t2, t3, t4, t5, t6;
  93.  
  94.   Arg             args[32];
  95.   int             argcount;
  96.  
  97.  
  98. /*
  99.   fprintf (stdout, " IN scrolled_ps\n");
  100. */
  101.  
  102.   argcount = 0;
  103.   XtSetArg (args[argcount], XmNmaximum, &scroll_bar_max);
  104.   argcount++;
  105.   XtGetValues (
  106.         scrolled_ps_callback ->
  107.         server_pointer ->
  108.         SEPERATE_WINDOWS_LIST[scrolled_ps_callback ->
  109.                       button_number].hsb, args, argcount);
  110.  
  111. /*
  112.   fprintf (stdout, " got values\n");
  113.   fprintf (stdout, "Scroll_bar max = %d\n", scroll_bar_max);
  114.   fprintf (stdout, "Xtnumber= %d\n", scrolled_ps_callback -> number_of_buttons);
  115. */
  116.  
  117.   for (i = 0; i < scrolled_ps_callback -> number_of_buttons; i++)
  118.     {
  119.  
  120.       if (scrolled_ps_callback -> ps_menu[i].type == SORT_BUTTON)
  121.     {
  122.  
  123. /*
  124.  * This needs to be changed so that BUTTON_ps_cpu and BUTTON_ps_io use the
  125.  * same logic.......
  126.  *
  127.  * BUTTON_ps_cpu BUTTON_ps_io need to use current_view......etc....
  128.  */
  129.  
  130.       {
  131.         if (cbs -> reason != XmCR_DRAG)
  132.           {
  133.  
  134.         argcount = 0;
  135.         XtSetArg (args[argcount], XmNmarginBottom, 0);
  136.         argcount++;
  137.         XtSetArg (args[argcount], XmNmarginTop, 0);
  138.         argcount++;
  139.         XtSetArg (args[argcount], XmNleftAttachment, XmATTACH_FORM);
  140.         argcount++;
  141.         XtSetArg (args[argcount], XmNleftOffset,
  142.               (4 + (scrolled_ps_callback -> ps_menu[i].offset * FWIDTH) - cbs -> value));
  143.         argcount++;
  144.         XtSetValues (
  145.                   scrolled_ps_callback -> server_pointer -> SEPERATE_WINDOWS_LIST[scrolled_ps_callback -> button_number].toggle_widget[i],
  146.                   args, argcount);
  147.  
  148.  
  149.         if (cbs -> value < ((scrolled_ps_callback -> ps_menu[i].offset * FWIDTH) + (strlen (scrolled_ps_callback -> ps_menu[i].name) * FWIDTH)))
  150.           {
  151.  
  152.             if (scrolled_ps_callback -> button_number == BUTTON_ps_mem)
  153.               {
  154.             if ((scrolled_ps_callback ->
  155.                  server_pointer -> ps_mem_screen_mode - 1) ==
  156.                 scrolled_ps_callback ->
  157.                 ps_menu[i].screen_number)
  158.  
  159.               XtManageChild (
  160.                       scrolled_ps_callback -> server_pointer -> SEPERATE_WINDOWS_LIST[scrolled_ps_callback -> button_number].toggle_widget[i]);
  161.  
  162.  
  163.  
  164.               }
  165.             else if (scrolled_ps_callback -> button_number == BUTTON_disk_space)
  166.               {
  167.             if ((scrolled_ps_callback ->
  168.                  server_pointer -> disk_space_screen_mode - 1) ==
  169.                 scrolled_ps_callback ->
  170.                 ps_menu[i].screen_number)
  171.  
  172.               XtManageChild (
  173.                       scrolled_ps_callback -> server_pointer -> SEPERATE_WINDOWS_LIST[scrolled_ps_callback -> button_number].toggle_widget[i]);
  174.  
  175.  
  176.  
  177.               }
  178.             else
  179.               XtManageChild (
  180.                       scrolled_ps_callback -> server_pointer -> SEPERATE_WINDOWS_LIST[scrolled_ps_callback -> button_number].toggle_widget[i]);
  181.  
  182.           }
  183.  
  184.           }
  185.         else
  186.           {
  187.         XtUnmanageChild (
  188.                   scrolled_ps_callback ->
  189.                   server_pointer ->
  190.                    SEPERATE_WINDOWS_LIST[scrolled_ps_callback ->
  191.                        button_number].toggle_widget[i]);
  192.  
  193.           }
  194.  
  195.  
  196.       }
  197.  
  198.  
  199.     }
  200.     }
  201.  
  202. }
  203.  
  204. void
  205. adjust_window_for_new_screen (SP,
  206.                   button_num,
  207.                   new_menulist,
  208.                   new_menulist_number,
  209.                   ps_screen,
  210.                   new_screen_mode)
  211.  
  212.      struct NetworkXswStruct *SP;
  213.      int             button_num;
  214.      ps_menu_struct *new_menulist;
  215.      int             new_menulist_number;
  216.      multi_screen_window_struct *ps_screen;
  217.      int             new_screen_mode;
  218.  
  219. {
  220.   XmString        default_title;
  221.   Arg             args[32];
  222.   int             argcount;
  223.   int             i;
  224.  
  225. /*
  226.   fprintf (stdout, "In adjust_window_for_new_screen\n");
  227. */
  228.  
  229.  
  230.  
  231. /*
  232.  * Set new title....
  233.  */
  234.  
  235.   default_title =
  236.     XmStringCreateSimple (ps_screen[new_screen_mode].default_title);
  237.  
  238.   argcount = 0;
  239.   XtSetArg (args[argcount], XmNlabelString, default_title);
  240.   argcount++;
  241.   XtSetValues (SP -> SEPERATE_WINDOWS_LIST[button_num].title_label,
  242.            args,
  243.            argcount);
  244.  
  245.  
  246.  
  247. /*
  248.  * Unmanage all current widgets except the pulldown menu.....
  249.  */
  250.  
  251.   for (i = 0; i < new_menulist_number; i++)
  252.     {
  253.       if (SP -> SEPERATE_WINDOWS_LIST[button_num].current_screen_mode ==
  254.       new_menulist[i].screen_number)
  255.     {
  256.       XtUnmanageChild (SP -> SEPERATE_WINDOWS_LIST[button_num].toggle_widget[i]);
  257.     }
  258.     }
  259.  
  260.   for (i = 0; i < new_menulist_number; i++)
  261.     {
  262.       if (new_screen_mode == new_menulist[i].screen_number)
  263.     {
  264.       XtManageChild (SP -> SEPERATE_WINDOWS_LIST[button_num].toggle_widget[i]);
  265.     }
  266.     }
  267.  
  268.  
  269.   SP -> SEPERATE_WINDOWS_LIST[button_num].current_screen_mode = new_screen_mode;
  270.  
  271.   XmStringFree (default_title);
  272.  
  273. }
  274.  
  275.  
  276. void
  277. ps_button_callback (my_widget, ps_button_struct, cbs)
  278.      Widget          my_widget;
  279.      struct ps_button_callback_struct *ps_button_struct;
  280.      XmToggleButtonCallbackStruct *cbs;
  281.  
  282. {
  283.  
  284.   struct NetworkXswStruct *SP = ps_button_struct -> server_pointer;
  285.  
  286. #if 0
  287.   XmString        cum_string, cur_string;
  288.   XmString        acsending_string, descending_string;
  289.   XmString        percent_string, ticks_string, minutes_string, count_string;
  290. #endif
  291.  
  292.  
  293.   XmString        label_string;
  294.  
  295.   XmString        default_title;
  296.  
  297.   Arg             args[32];
  298.   int             argcount;
  299.   struct NetworkXswStruct *temp_server;
  300.  
  301.   int             j = 0;
  302.   int             i = 0;
  303.  
  304.  
  305. /*
  306.   fprintf (stdout, "In ps_button_callback....\n");
  307. */
  308.  
  309.  
  310. #if 0
  311.  
  312.   cum_string = XmStringCreateSimple ("CUM");
  313.   cur_string = XmStringCreateSimple ("CUR");
  314.   acsending_string = XmStringCreateSimple ("A");
  315.   descending_string = XmStringCreateSimple ("D");
  316.   percent_string = XmStringCreateSimple ("%");
  317.   ticks_string = XmStringCreateSimple ("T");
  318.   minutes_string = XmStringCreateSimple ("M");
  319.   count_string = XmStringCreateSimple ("C");
  320.  
  321. #endif
  322.  
  323.  
  324.  
  325. /*
  326.  * Check to see if we are changeing the current ("VIEW") screen.... or else
  327.  * it must be a toggle widget......
  328.  */
  329.  
  330. #if 0
  331.   if (ps_button_struct -> ps_menu_index == -1)
  332.     {
  333.  
  334. /*
  335.       fprintf (stdout, "Chaning view....\n");
  336. */
  337.  
  338. /*
  339.  * Turn the button "ON" .....
  340.  */
  341.  
  342.       argcount = 0;
  343.       XtSetArg (args[argcount], XmNbackground,
  344.         colorAuxButtonOnBackground.pixel);
  345.       argcount++;
  346.       XtSetArg (args[argcount], XmNforeground,
  347.         colorAuxButtonOnForeground.pixel);
  348.       argcount++;
  349.       XtSetValues (my_widget, args, argcount);
  350.  
  351.  
  352. /*
  353.  * Turn "OFF" the old button.....
  354.  */
  355.  
  356.  
  357.  
  358.       argcount = 0;
  359.       XtSetArg (args[argcount], XmNbackground,
  360.         colorAuxButtonOffBackground.pixel);
  361.       argcount++;
  362.       XtSetArg (args[argcount], XmNforeground,
  363.         colorAuxButtonOffForeground.pixel);
  364.       argcount++;
  365.  
  366.  
  367. /*
  368.  * Currently, PS MEM has 4 screens.......
  369.  */
  370.  
  371.       if (ps_button_struct -> button_num == BUTTON_ps_mem)
  372.     {
  373.  
  374.       XtSetValues (
  375.             SP -> SEPERATE_WINDOWS_LIST[ps_button_struct ->
  376.                     button_num].screen_widget_list[SP ->
  377.                             ps_mem_screen_mode - 1],
  378.             args, argcount);
  379.  
  380.       /*
  381.        * If we are currently screen 1, then change
  382.        */
  383.  
  384.       adjust_window_for_new_screen (
  385.                      SP,
  386.                      ps_button_struct -> button_num,
  387.                      ps_mem_toggle_button_data,
  388.                        XtNumber (ps_mem_toggle_button_data),
  389.                      ps_button_struct -> ps_screen,
  390.                      ps_button_struct -> sort_mode);
  391.  
  392.  
  393.       if (ps_button_struct -> sort_mode == 1)
  394.         {
  395.  
  396.           SP -> ps_mem_screen_mode = 2;
  397.  
  398.         }
  399.       else if (ps_button_struct -> sort_mode == 2)
  400.         {
  401.  
  402.           SP -> ps_mem_screen_mode = 3;
  403.  
  404.         }
  405.       else if (ps_button_struct -> sort_mode == 3)
  406.         {
  407.  
  408.           SP -> ps_mem_screen_mode = 4;
  409.  
  410.         }
  411.       else if (ps_button_struct -> sort_mode == 0)
  412.         {
  413.  
  414.           SP -> ps_mem_screen_mode = 1;
  415.  
  416.         }
  417.       else
  418.         {
  419.  
  420.         }
  421.  
  422.     }
  423.  
  424.       else if (ps_button_struct -> button_num == BUTTON_disk_space)
  425.     {
  426.  
  427.       XtSetValues (SP -> SEPERATE_WINDOWS_LIST[ps_button_struct ->
  428.                     button_num].screen_widget_list[SP ->
  429.                         disk_space_screen_mode - 1],
  430.                args, argcount);
  431.  
  432.       /*
  433.        * If we are currently screen 1, then change
  434.        */
  435.  
  436.       adjust_window_for_new_screen (
  437.                      SP,
  438.                      ps_button_struct -> button_num,
  439.                      disk_space_toggle_button_data,
  440.                    XtNumber (disk_space_toggle_button_data),
  441.                      ps_button_struct -> ps_screen,
  442.                      ps_button_struct -> sort_mode);
  443.  
  444.  
  445.       if (ps_button_struct -> sort_mode == 1)
  446.         {
  447.  
  448.           SP -> disk_space_screen_mode = 2;
  449.  
  450.         }
  451.       else if (ps_button_struct -> sort_mode == 2)
  452.         {
  453.  
  454.           SP -> disk_space_screen_mode = 3;
  455.  
  456.         }
  457.       else if (ps_button_struct -> sort_mode == 0)
  458.         {
  459.  
  460.           SP -> disk_space_screen_mode = 1;
  461.  
  462.         }
  463.       else
  464.         {
  465.  
  466.         }
  467.  
  468.     }
  469.  
  470.     }
  471.   else
  472. /*
  473.  * Check to see if we are changeing the current ("OPTION") ....
  474.  */
  475.   if (ps_button_struct -> ps_menu_index == -2)
  476.     {
  477.  
  478. /*
  479.       fprintf (stdout, "Changing option the old way??....\n");
  480. */
  481.  
  482.  
  483.  
  484.  
  485.  
  486.     }
  487.  
  488.  
  489. /*
  490.  * If it is a SORT_BUTTON, then set the Old toggle button as inactive...
  491.  * and set the New toggle button as active...
  492.  */
  493.  
  494. #endif 
  495.  
  496.   if (ps_button_struct -> ps_menu[ps_button_struct -> ps_menu_index].type ==
  497.        SORT_BUTTON)
  498.     {
  499.  
  500.  
  501. /*
  502.       fprintf (stdout, "Sort button\n ");
  503. */
  504.  
  505.  
  506.  
  507.       argcount = 0;
  508.       XtSetArg (args[argcount], XmNbackground,
  509.         colorAuxButtonOffBackground.pixel);
  510.       argcount++;
  511.       XtSetArg (args[argcount], XmNforeground,
  512.         colorAuxButtonOffForeground.pixel);
  513.       argcount++;
  514.  
  515.       if (ps_button_struct -> button_num == BUTTON_ps_cpu)
  516.     {
  517.  
  518.       XtSetValues (SP -> SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].toggle_widget[SP -> ps_sort_mode],
  519.                args,
  520.                argcount);
  521.  
  522.       SP -> ps_sort_mode =
  523.         ps_button_struct -> sort_mode;
  524.  
  525.     }
  526.       else if (ps_button_struct -> button_num == BUTTON_ps_mem)
  527.     {
  528.  
  529. /*
  530.  * Need to set the current toggle widget indice......TURN OFF OLD BUTTON
  531.  */
  532.  
  533.       XtSetValues (
  534.             SP -> SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].view_current_sort_widget[SP -> ps_mem_screen_mode - 1],
  535.             args,
  536.             argcount);
  537.  
  538.  
  539.       SP -> ps_mem_sort_mode[SP -> ps_mem_screen_mode - 1] =
  540.         ps_button_struct -> sort_mode;
  541.  
  542.  
  543.     }
  544.       else if (ps_button_struct -> button_num == BUTTON_ps_io)
  545.     {
  546.       XtSetValues (SP -> SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].toggle_widget[SP -> ps_io_sort_mode],
  547.                args,
  548.                argcount);
  549.  
  550.       SP -> ps_io_sort_mode =
  551.         ps_button_struct -> sort_mode;
  552.  
  553.     }
  554.       else if (ps_button_struct -> button_num == BUTTON_disk_space)
  555.     {
  556.       XtSetValues (SP -> SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].view_current_sort_widget[SP -> disk_space_screen_mode - 1],
  557.                args,
  558.                argcount);
  559.  
  560.       SP -> disk_space_sort_mode[SP -> disk_space_screen_mode - 1] =
  561.         ps_button_struct -> sort_mode;
  562.  
  563.     }
  564.  
  565.  
  566. /*
  567.  * Turn on button pushed.......
  568.  */
  569.  
  570.       argcount = 0;
  571.       XtSetArg (args[argcount], XmNbackground,
  572.         colorAuxButtonOnBackground.pixel);
  573.       argcount++;
  574.       XtSetArg (args[argcount], XmNforeground,
  575.         colorAuxButtonOnForeground.pixel);
  576.       argcount++;
  577.       XtSetValues (my_widget, args, argcount);
  578.  
  579.  
  580.  
  581. /*
  582.  * If this is a VIEW  window, then need to keep track of the active sort
  583.  * for each view....
  584.  *
  585.  */
  586.  
  587.       if (ps_button_struct -> button_num == BUTTON_ps_mem)
  588.     SP -> SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].view_current_sort_widget[SP -> ps_mem_screen_mode - 1] = my_widget;
  589.       else
  590.     SP -> SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].view_current_sort_widget[SP -> disk_space_screen_mode - 1] = my_widget;
  591.  
  592.  
  593.  
  594.     }
  595.  
  596. #if 0
  597.   else if (ps_button_struct -> ps_menu[ps_button_struct -> ps_menu_index].type
  598.        == CUM_CUR_BUTTON)
  599.     {
  600. /*
  601.       fprintf (stdout, "cum/cur button\n ");
  602. */
  603.  
  604.  
  605.       argcount = 0;
  606.       XtSetArg (args[argcount], XmNlabelString, &label_string);
  607.       argcount++;
  608.       XtGetValues (my_widget, args, argcount);
  609. /*
  610.       fprintf (stdout, "about to string compare\n ");
  611. */
  612.       if (XmStringCompare (cum_string, label_string) == False)
  613.     {
  614.       argcount = 0;
  615.       XtSetArg (args[argcount], XmNlabelString, cum_string);
  616.       argcount++;
  617.       XtSetValues (my_widget, args, argcount);
  618.  
  619.       if (ps_button_struct -> button_num == BUTTON_ps_cpu)
  620.         {
  621.  
  622.           SP -> ps_display_mode = 13;
  623.  
  624.           if (SP -> ps_cpu_time_mode == 2)
  625.         {
  626.  
  627.           SP -> ps_cpu_time_mode = 0;
  628.  
  629.           for (j = 0; j < XtNumber (ps_toggle_button_data); j++)
  630.             if (ps_button_struct ->
  631.             ps_menu[j].type == PERCENT_OTHER_BUTTON)
  632.               {
  633.  
  634.             argcount = 0;
  635.             XtSetArg (args[argcount], XmNlabelString,
  636.                   minutes_string);
  637.             argcount++;
  638.             XtSetValues (SP ->
  639.                      SEPERATE_WINDOWS_LIST[BUTTON_ps_cpu].toggle_widget[j],
  640.                      args, argcount);
  641.  
  642.               }
  643.         }
  644.  
  645.  
  646.         }
  647.       else if (ps_button_struct -> button_num == BUTTON_ps_io)
  648.         {
  649.           SP -> ps_io_display_mode = 9;
  650.         }
  651.     }
  652.       else
  653.     {
  654.       argcount = 0;
  655.       XtSetArg (args[argcount], XmNlabelString, cur_string);
  656.       argcount++;
  657.       XtSetValues (my_widget, args, argcount);
  658.  
  659.       if (ps_button_struct -> button_num == BUTTON_ps_cpu)
  660.         {
  661.           SP -> ps_display_mode = 12;
  662.           if (SP -> ps_cpu_time_mode == 0)
  663.         {
  664.           if (SP -> ps_cpu_time_mode == 0)
  665.             {
  666.               SP -> ps_cpu_time_mode = 2;
  667.  
  668.               for (j = 0; j < XtNumber (ps_toggle_button_data); j++)
  669.             if (ps_button_struct -> ps_menu[j].type == PERCENT_OTHER_BUTTON)
  670.               {
  671.  
  672.                 argcount = 0;
  673.                 XtSetArg (args[argcount], XmNlabelString, ticks_string);
  674.                 argcount++;
  675.                 XtSetValues (SP ->
  676.                      SEPERATE_WINDOWS_LIST[BUTTON_ps_cpu].toggle_widget[j],
  677.                      args, argcount);
  678.  
  679.               }
  680.             }
  681.         }
  682.  
  683.         }
  684.       else if (ps_button_struct -> button_num == BUTTON_ps_io)
  685.         {
  686.           SP -> ps_io_display_mode = 8;
  687.         }
  688.  
  689.  
  690.     }
  691.     }
  692.  
  693.   else if (ps_button_struct -> ps_menu[ps_button_struct -> ps_menu_index].type
  694.        == ASCEND_DESCEND_BUTTON)
  695.     {
  696.  
  697.  
  698.  
  699.       argcount = 0;
  700.       XtSetArg (args[argcount], XmNlabelString, &label_string);
  701.       argcount++;
  702.       XtGetValues (my_widget, args, argcount);
  703.  
  704.  
  705.       if (XmStringCompare (acsending_string, label_string) == False)
  706.     {
  707.       argcount = 0;
  708.       XtSetArg (args[argcount], XmNlabelString, acsending_string);
  709.       argcount++;
  710.       XtSetValues (my_widget, args, argcount);
  711.  
  712.  
  713.       if (ps_button_struct -> button_num == BUTTON_ps_cpu)
  714.         SP -> ps_cpu_sort_order = 0;
  715.       else if (ps_button_struct -> button_num == BUTTON_ps_io)
  716.         SP -> ps_io_sort_order = 0;
  717. /*
  718.       else if (ps_button_struct -> button_num == BUTTON_ps_mem)
  719.         SP -> ps_mem_sort_order[SP -> ps_mem_screen_mode - 1] = 0;
  720.       else if (ps_button_struct -> button_num == BUTTON_disk_space)
  721.         SP -> disk_space_sort_order[SP -> disk_space_screen_mode - 1] = 0;
  722. */
  723.  
  724.  
  725.     }
  726.       else
  727.     {
  728.       argcount = 0;
  729.       XtSetArg (args[argcount], XmNlabelString, descending_string);
  730.       argcount++;
  731.       XtSetValues (my_widget, args, argcount);
  732.  
  733.       if (ps_button_struct -> button_num == BUTTON_ps_cpu)
  734.         SP -> ps_cpu_sort_order = 1;
  735.       else if (ps_button_struct -> button_num == BUTTON_ps_io)
  736.         SP -> ps_io_sort_order = 1;
  737. /*
  738.       else if (ps_button_struct -> button_num == BUTTON_ps_mem)
  739.         SP -> ps_mem_sort_order[SP -> ps_mem_screen_mode - 1] = 1;
  740.       else if (ps_button_struct -> button_num == BUTTON_disk_space)
  741.         SP -> disk_space_sort_order[SP -> disk_space_screen_mode - 1] = 1;
  742. */
  743.  
  744.  
  745.     }
  746.  
  747.  
  748.  
  749.     }
  750.   else if (ps_button_struct -> ps_menu[ps_button_struct -> ps_menu_index].type
  751.        == PERCENT_OTHER_BUTTON)
  752.     {
  753.  
  754.  
  755.  
  756.       argcount = 0;
  757.       XtSetArg (args[argcount], XmNlabelString, &label_string);
  758.       argcount++;
  759.       XtGetValues (my_widget, args, argcount);
  760.  
  761. /*
  762.  * Percent string ......
  763.  */
  764.       if (XmStringCompare (percent_string, label_string) == True)
  765.     {
  766.       if (ps_button_struct -> button_num == BUTTON_ps_cpu)
  767.         {
  768.           if (SP -> ps_display_mode == 13)
  769.         {
  770.           SP -> ps_cpu_time_mode = 0;
  771.  
  772.           argcount = 0;
  773.           XtSetArg (args[argcount], XmNlabelString, minutes_string);
  774.           argcount++;
  775.           XtSetValues (my_widget, args, argcount);
  776.         }
  777.           else
  778.         {
  779.           SP -> ps_cpu_time_mode = 2;
  780.  
  781.           argcount = 0;
  782.           XtSetArg (args[argcount], XmNlabelString, ticks_string);
  783.           argcount++;
  784.           XtSetValues (my_widget, args, argcount);
  785.         }
  786.         }
  787.       else if (ps_button_struct -> button_num == BUTTON_ps_io)
  788.         {
  789.           SP -> ps_io_time_mode = 0;
  790.  
  791.           argcount = 0;
  792.           XtSetArg (args[argcount], XmNlabelString, count_string);
  793.           argcount++;
  794.           XtSetValues (my_widget, args, argcount);
  795.  
  796.         }
  797.  
  798.     }
  799. /*
  800.  * Ticks string ......
  801.  */
  802.       else if (XmStringCompare (ticks_string, label_string) == True)
  803.     {
  804.       if (ps_button_struct -> button_num == BUTTON_ps_cpu)
  805.         {
  806.           if (SP -> ps_display_mode == 13)
  807.         {
  808.  
  809.         }
  810.           else
  811.         {
  812.           SP -> ps_cpu_time_mode = 1;
  813.           argcount = 0;
  814.           XtSetArg (args[argcount], XmNlabelString, percent_string);
  815.           argcount++;
  816.           XtSetValues (my_widget, args, argcount);
  817.         }
  818.  
  819.  
  820.         }
  821.       else if (ps_button_struct -> button_num == BUTTON_ps_io)
  822.         {
  823.  
  824.  
  825.         }
  826.  
  827.     }
  828. /*
  829.  * Minutes string ......
  830.  */
  831.  
  832.       else if (XmStringCompare (minutes_string, label_string) == True)
  833.     {
  834.       if (ps_button_struct -> button_num == BUTTON_ps_cpu)
  835.         {
  836.           if (SP -> ps_display_mode == 13)
  837.         {
  838.           SP -> ps_cpu_time_mode = 1;
  839.           argcount = 0;
  840.           XtSetArg (args[argcount], XmNlabelString, percent_string);
  841.           argcount++;
  842.           XtSetValues (my_widget, args, argcount);
  843.         }
  844.           else
  845.         {
  846.  
  847.         }
  848.  
  849.  
  850.         }
  851.       else if (ps_button_struct -> button_num == BUTTON_ps_io)
  852.         {
  853.  
  854.  
  855.         }
  856.  
  857.     }
  858.       else if (XmStringCompare (count_string, label_string) == True)
  859.     {
  860.       if (ps_button_struct -> button_num == BUTTON_ps_io)
  861.         {
  862.           SP -> ps_io_time_mode = 1;
  863.           argcount = 0;
  864.           XtSetArg (args[argcount], XmNlabelString, percent_string);
  865.           argcount++;
  866.           XtSetValues (my_widget, args, argcount);
  867.  
  868.         }
  869.     }
  870.  
  871.  
  872.     }
  873.  
  874. #endif
  875.  
  876.       temp_server = current_server;;
  877.       current_server = SP;
  878.  
  879.  
  880.   switch ( ps_button_struct -> button_num ) {
  881.  
  882.     case BUTTON_ps_cpu:
  883.               SP -> ps_button_change = 1;
  884.               update_ps_cpu (SP);
  885.  
  886.         break;
  887.  
  888.  
  889.     case BUTTON_ps_mem:
  890.               SP -> ps_mem_button_change = 1;
  891.               update_ps_mem (SP);
  892.  
  893.         break;
  894.  
  895.     case BUTTON_ps_io:
  896.         SP -> ps_io_button_change = 1;
  897.               update_ps_io(SP);
  898.  
  899.         break;
  900.  
  901.  
  902.     case BUTTON_disk_space:
  903.               update_disk_space(SP);
  904.  
  905.         break;
  906.  
  907.  
  908.   }
  909.  
  910.  
  911.       current_server = temp_server;
  912.  
  913.       XCopyArea (
  914.           SP ->
  915.           SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].display,
  916.           SP ->
  917.            SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].pixmap,
  918.           SP ->
  919.            SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].window,
  920.           SP ->
  921.           SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].gc,
  922.           0,
  923.           0,
  924.           SP ->
  925.        SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].draw_width,
  926.           SP ->
  927.       SEPERATE_WINDOWS_LIST[ps_button_struct -> button_num].draw_height,
  928.           0,
  929.           0);
  930.  
  931.  
  932. #if 0
  933.   XmStringFree (cum_string);
  934.   XmStringFree (cur_string);
  935.   XmStringFree (acsending_string);
  936.   XmStringFree (descending_string);
  937.   XmStringFree (percent_string);
  938.   XmStringFree (ticks_string);
  939.   XmStringFree (minutes_string);
  940. #endif
  941.  
  942. }
  943.  
  944. void
  945. option_callback (my_widget, window_button_struct, cbs)
  946.      Widget          my_widget;
  947.      struct window_button_callback_struct *window_button_struct;
  948.      XmToggleButtonCallbackStruct *cbs;
  949.  
  950. {
  951.   Arg             args[32];
  952.   int             argcount;
  953.  
  954.  
  955.   struct NetworkXswStruct *temp_server;
  956.   struct NetworkXswStruct *SP = window_button_struct -> server_pointer;
  957.  
  958. /*
  959.   fprintf (stdout, "In option_callback ...\n");
  960.  
  961.   fprintf (stdout, "dynamic window_indow = %d...\n",
  962.        window_button_struct -> dynamic_window_index);
  963.  
  964. */
  965.  
  966.   if (window_button_struct -> ps_menu_index == -2)
  967.     {
  968. /*
  969.       fprintf (stdout, "Chaning view....\n");
  970. */
  971.  
  972.  
  973.       if (window_button_struct -> button_num == BUTTON_disk_space)
  974.     {
  975. /*
  976.       fprintf (stdout, "Turning off old button....\n");
  977. */
  978.  
  979.  
  980. /*
  981.  * If our view has not changed, then we should re-set the toggle button state
  982.  * to true, and the just return.....
  983.  */
  984.  
  985.       if ((window_button_struct -> sort_mode + 1) == SP ->
  986.           disk_space_screen_mode)
  987.         {
  988.           XmToggleButtonSetState (my_widget, True, False);
  989.           return;
  990.         }
  991.  
  992.  
  993.       XmToggleButtonSetState (
  994.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  995.                          button_num].screen_widget_list[
  996.                       SP -> disk_space_screen_mode - 1],
  997.                    False, False);
  998.  
  999.  
  1000.       /*
  1001.        * If we are currently screen 1, then change
  1002.        */
  1003.  
  1004.       adjust_window_for_new_screen (
  1005.                      SP,
  1006.                      window_button_struct -> button_num,
  1007.                      disk_space_toggle_button_data,
  1008.                    XtNumber (disk_space_toggle_button_data),
  1009.                      window_button_struct -> ps_screen,
  1010.                      window_button_struct -> sort_mode);
  1011.  
  1012.       switch (window_button_struct -> sort_mode)
  1013.  
  1014.         {
  1015.  
  1016.         case 0:
  1017.           SP -> disk_space_screen_mode = 1;
  1018.  
  1019.           break;
  1020.  
  1021.         case 1:
  1022.           SP -> disk_space_screen_mode = 2;
  1023.  
  1024.           break;
  1025.  
  1026.         case 2:
  1027.           SP -> disk_space_screen_mode = 3;
  1028.  
  1029.           break;
  1030.  
  1031.  
  1032.         }
  1033.  
  1034.     }
  1035.       else if (window_button_struct -> button_num == BUTTON_ps_mem)
  1036.     {
  1037. /*
  1038.       fprintf (stdout, "Changing view for ps_mem....\n");
  1039. */
  1040. /*
  1041.  * If our view has not changed, then we should re-set the toggle button state
  1042.  * to true, and the just return.....
  1043.  */
  1044. /*
  1045.       fprintf (stdout, "Changing view for ps_mem....%d, %d\n",
  1046.            window_button_struct -> sort_mode + 1,
  1047.            SP -> ps_mem_screen_mode);
  1048. */
  1049.  
  1050.       if ((window_button_struct -> sort_mode + 1) == SP ->
  1051.           ps_mem_screen_mode)
  1052.         {
  1053.           XmToggleButtonSetState (my_widget, True, False);
  1054.           return;
  1055.         }
  1056. /*
  1057.       fprintf (stdout, "Turning off old button ps_mem....%d\n",
  1058.            SP -> ps_mem_screen_mode - 1);
  1059. */
  1060.  
  1061.       XmToggleButtonSetState (
  1062.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1063.                          button_num].screen_widget_list[
  1064.                           SP -> ps_mem_screen_mode - 1],
  1065.                    False, False);
  1066.  
  1067.  
  1068.       /*
  1069.        * If we are currently screen 1, then change
  1070.        */
  1071. /*
  1072.       fprintf (stdout, "About to adjust the ps_mem....\n");
  1073. */
  1074.  
  1075.       adjust_window_for_new_screen (
  1076.                      SP,
  1077.                      window_button_struct -> button_num,
  1078.                      ps_mem_toggle_button_data,
  1079.                        XtNumber (ps_mem_toggle_button_data),
  1080.                      window_button_struct -> ps_screen,
  1081.                      window_button_struct -> sort_mode);
  1082.  
  1083. /*
  1084.       fprintf (stdout, "Done adjust the ps_mem....\n");
  1085. */
  1086.  
  1087.       if (window_button_struct -> sort_mode == 1)
  1088.         {
  1089.  
  1090.           SP -> ps_mem_screen_mode = 2;
  1091.  
  1092.         }
  1093.       else if (window_button_struct -> sort_mode == 2)
  1094.         {
  1095.  
  1096.           SP -> ps_mem_screen_mode = 3;
  1097.  
  1098.         }
  1099.       else if (window_button_struct -> sort_mode == 3)
  1100.         {
  1101.  
  1102.           SP -> ps_mem_screen_mode = 4;
  1103.  
  1104.         }
  1105.       else if (window_button_struct -> sort_mode == 0)
  1106.         {
  1107.  
  1108.           SP -> ps_mem_screen_mode = 1;
  1109.  
  1110.         }
  1111.  
  1112.  
  1113.  
  1114.  
  1115.     }
  1116.  
  1117.     }
  1118.  
  1119.   if (window_button_struct -> type == ASCEND_DESCEND_BUTTON)
  1120.     {
  1121. /*
  1122.       fprintf (stdout, "GOT ascend/descend....%d\n",
  1123.            window_button_struct -> sort_mode);
  1124. */
  1125.       switch (window_button_struct -> sort_mode)
  1126.     {
  1127.     case 0:
  1128. /*
  1129.  * Need to determine whether it is going of or on....
  1130.  */
  1131.  
  1132.       if (XmToggleButtonGetState (my_widget))
  1133.         {
  1134. /*
  1135.           fprintf (stdout, "Chaning ascend/descend....\n");
  1136. */
  1137.  
  1138.           switch (window_button_struct -> button_num)
  1139.         {
  1140.  
  1141.         case BUTTON_disk_space:
  1142.           SP -> disk_space_sort_order = 1;
  1143.           break;
  1144.         case BUTTON_ps_mem:
  1145.           SP -> ps_mem_sort_order = 1;
  1146.           break;
  1147.         case BUTTON_ps_io:
  1148.           SP -> ps_io_sort_order = 1;
  1149.           break;
  1150.         case BUTTON_ps_cpu:
  1151.           SP -> ps_cpu_sort_order = 1;
  1152.           break;
  1153.  
  1154.  
  1155.  
  1156.         }
  1157. /*
  1158.  
  1159.           if (window_button_struct -> button_num == BUTTON_disk_space)
  1160.         SP -> disk_space_sort_order = 1;
  1161.           else if (window_button_struct -> button_num == BUTTON_ps_mem)
  1162.         SP -> ps_mem_sort_order = 1;
  1163. */
  1164.  
  1165.           XmToggleButtonSetState (
  1166.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1167.                          button_num].screen_widget_list[
  1168.               window_button_struct -> dynamic_window_index + 1],
  1169.                        False, False);
  1170.         }
  1171.       else
  1172.         {
  1173. /*
  1174.  * We were on, and we should stay ON....
  1175.  */
  1176.           XmToggleButtonSetState (my_widget, True, False);
  1177.           return;
  1178.         }
  1179.  
  1180.       break;
  1181.  
  1182.     case 1:
  1183.       if (XmToggleButtonGetState (my_widget))
  1184.         {
  1185.           switch (window_button_struct -> button_num)
  1186.         {
  1187.  
  1188.         case BUTTON_disk_space:
  1189.           SP -> disk_space_sort_order = 0;
  1190.           break;
  1191.         case BUTTON_ps_mem:
  1192.           SP -> ps_mem_sort_order = 0;
  1193.           break;
  1194.         case BUTTON_ps_io:
  1195.           SP -> ps_io_sort_order = 0;
  1196.           break;
  1197.         case BUTTON_ps_cpu:
  1198.           SP -> ps_cpu_sort_order = 0;
  1199.           break;
  1200.  
  1201.  
  1202.         }
  1203.  
  1204. /*
  1205.           if (window_button_struct -> button_num == BUTTON_disk_space)
  1206.         SP -> disk_space_sort_order = 0;
  1207.           else if (window_button_struct -> button_num == BUTTON_ps_mem)
  1208.         SP -> ps_mem_sort_order = 0;
  1209. */
  1210.  
  1211.           XmToggleButtonSetState (
  1212.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1213.                          button_num].screen_widget_list[
  1214.               window_button_struct -> dynamic_window_index - 1],
  1215.                        False, False);
  1216.         }
  1217.       else
  1218.         {
  1219. /*
  1220.  * We were on, and we should stay ON....
  1221.  */
  1222.           XmToggleButtonSetState (my_widget, True, False);
  1223.           return;
  1224.         }
  1225.  
  1226.       break;
  1227.  
  1228.     }
  1229.     }
  1230.  
  1231.   if (window_button_struct -> type == CUM_CUR_BUTTON)
  1232.     {
  1233. /*
  1234.       fprintf (stdout, "GOT CUM_CUR_BUTTON ....%d\n",
  1235.            window_button_struct -> sort_mode);
  1236. */
  1237.       switch (window_button_struct -> sort_mode)
  1238.     {
  1239.     case 0:
  1240. /*
  1241.  * Need to determine whether it is going of or on....
  1242.  */
  1243.  
  1244.       if (XmToggleButtonGetState (my_widget))
  1245.         {
  1246. /*
  1247.           fprintf (stdout, "Changing to cummulative....\n");
  1248. */
  1249.  
  1250.           switch (window_button_struct -> button_num)
  1251.         {
  1252.  
  1253.         case BUTTON_ps_io:
  1254.           SP -> ps_io_display_mode = 8;
  1255.           break;
  1256.         case BUTTON_ps_cpu:
  1257.           SP -> ps_display_mode = 12;
  1258.  
  1259.         /*
  1260.           * Stipple out minutes , and unstiplle ticks....
  1261.           */
  1262.  
  1263.                   argcount = 0;
  1264.                   XtSetArg (args[argcount], XmNsensitive, False);
  1265.                   argcount++;
  1266.                   XtSetValues (SP ->
  1267.                                SEPERATE_WINDOWS_LIST[window_button_struct ->
  1268.                                              button_num].screen_widget_list[
  1269.                                                      window_button_struct ->
  1270.                                  dynamic_window_index + 3], args, argcount);
  1271.  
  1272.                   argcount = 0;
  1273.                   XtSetArg (args[argcount], XmNsensitive, True);
  1274.                   argcount++;
  1275.                   XtSetValues (SP ->
  1276.                                SEPERATE_WINDOWS_LIST[window_button_struct ->
  1277.                                              button_num].screen_widget_list[
  1278.                                                      window_button_struct ->
  1279.                                  dynamic_window_index + 4], args, argcount);
  1280.  
  1281.  
  1282.         /*
  1283.           * If we are currently showing minutes , then we need to 
  1284.          *  change to ticks ....
  1285.           */
  1286.  
  1287.           if (SP -> ps_cpu_time_mode == 0)
  1288.             {
  1289.  
  1290.               SP -> ps_cpu_time_mode = 2;
  1291.         /*
  1292.           * Turn off minutes....
  1293.           */
  1294.                       argcount = 0;
  1295.                       XtSetArg (args[argcount], XmNset, False);
  1296.                       argcount++;
  1297.                       XtSetValues (SP ->
  1298.                                SEPERATE_WINDOWS_LIST[window_button_struct ->
  1299.                                              button_num].screen_widget_list[
  1300.                                                      window_button_struct ->
  1301.                                  dynamic_window_index + 3], args, argcount);
  1302.  
  1303.  
  1304.                 /*
  1305.                  * Turn on ticks....
  1306.                  */
  1307.  
  1308.                       argcount = 0;
  1309.                       XtSetArg (args[argcount], XmNset, True);
  1310.                       argcount++;
  1311.                       XtSetValues (SP ->
  1312.                                SEPERATE_WINDOWS_LIST[window_button_struct ->
  1313.                                              button_num].screen_widget_list[
  1314.                                                      window_button_struct ->
  1315.                                  dynamic_window_index + 4], args, argcount);
  1316.  
  1317.  
  1318.  
  1319.             }
  1320.  
  1321.  
  1322.           break;
  1323.  
  1324.         }
  1325.  
  1326.         /*
  1327.           * Now turn off CUMMULATIVE.....
  1328.           */
  1329.  
  1330.           XmToggleButtonSetState (
  1331.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1332.                          button_num].screen_widget_list[
  1333.               window_button_struct -> dynamic_window_index + 1],
  1334.                        False, False);
  1335.         }
  1336.       else
  1337.         {
  1338.         /*
  1339.           * We were on, and we should stay ON....
  1340.           */
  1341.  
  1342.           XmToggleButtonSetState (my_widget, True, False);
  1343.           return;
  1344.         }
  1345.  
  1346.       break;
  1347.  
  1348.     case 1:
  1349.       if (XmToggleButtonGetState (my_widget))
  1350.         {
  1351. /*
  1352.           fprintf (stdout, "Changing to current....\n");
  1353. */
  1354.  
  1355.           switch (window_button_struct -> button_num)
  1356.         {
  1357.  
  1358.         case BUTTON_ps_io:
  1359.           SP -> ps_io_display_mode = 9;
  1360.           break;
  1361.         case BUTTON_ps_cpu:
  1362.           SP -> ps_display_mode = 13;
  1363.  
  1364.         /*
  1365.           * Stipple out ticks, and unstiplle minutes....
  1366.           */
  1367.  
  1368.           argcount = 0;
  1369.           XtSetArg (args[argcount], XmNsensitive, False);
  1370.           argcount++;
  1371.           XtSetValues (SP ->
  1372.                    SEPERATE_WINDOWS_LIST[window_button_struct ->
  1373.                          button_num].screen_widget_list[
  1374.                              window_button_struct ->
  1375.                  dynamic_window_index + 3], args, argcount);
  1376.  
  1377.           argcount = 0;
  1378.           XtSetArg (args[argcount], XmNsensitive, True);
  1379.           argcount++;
  1380.           XtSetValues (SP ->
  1381.                    SEPERATE_WINDOWS_LIST[window_button_struct ->
  1382.                          button_num].screen_widget_list[
  1383.                              window_button_struct ->
  1384.                  dynamic_window_index + 2], args, argcount);
  1385.  
  1386.         /*
  1387.           * If we are currently showing ticks, then we need to 
  1388.          *  change to Minutes....
  1389.           */
  1390.  
  1391.           if (SP -> ps_cpu_time_mode == 2)
  1392.             {
  1393.  
  1394.               SP -> ps_cpu_time_mode = 0;
  1395.         /*
  1396.           * Turn off ticks....
  1397.           */
  1398.  
  1399.               argcount = 0;
  1400.               XtSetArg (args[argcount], XmNset, False);
  1401.               argcount++;
  1402.               XtSetValues (SP ->
  1403.                    SEPERATE_WINDOWS_LIST[window_button_struct ->
  1404.                          button_num].screen_widget_list[
  1405.                              window_button_struct ->
  1406.                  dynamic_window_index + 3], args, argcount);
  1407.  
  1408.  
  1409.         /*
  1410.           * Turn on minutes ....
  1411.           */
  1412.  
  1413.               argcount = 0;
  1414.               XtSetArg (args[argcount], XmNset, True);
  1415.               argcount++;
  1416.               XtSetValues (SP ->
  1417.                    SEPERATE_WINDOWS_LIST[window_button_struct ->
  1418.                          button_num].screen_widget_list[
  1419.                              window_button_struct ->
  1420.                  dynamic_window_index + 2], args, argcount);
  1421.  
  1422.  
  1423.  
  1424.             }
  1425.  
  1426.  
  1427.           break;
  1428.  
  1429.  
  1430.         }
  1431.  
  1432.         /*
  1433.           * Now turn off CURRENT.....
  1434.           */
  1435.  
  1436.           XmToggleButtonSetState (
  1437.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1438.                          button_num].screen_widget_list[
  1439.               window_button_struct -> dynamic_window_index - 1],
  1440.                        False, False);
  1441.         }
  1442.       else
  1443.         {
  1444. /*
  1445.  * We were on, and we should stay ON....
  1446.  */
  1447.           XmToggleButtonSetState (my_widget, True, False);
  1448.           return;
  1449.         }
  1450.  
  1451.       break;
  1452.  
  1453.     }
  1454.     }
  1455.   else if (window_button_struct -> type == PERCENT_OTHER_BUTTON)
  1456.     {
  1457. /*
  1458.       fprintf (stdout, "GOT percent/count ....%d\n",
  1459.            window_button_struct -> sort_mode);
  1460. */
  1461.  
  1462.       switch (window_button_struct -> sort_mode)
  1463.     {
  1464.     case 0:
  1465.     
  1466. /*    
  1467.       fprintf (stdout, "going to percent ....%d\n",
  1468.            window_button_struct -> sort_mode);
  1469. */
  1470.  
  1471.       if (XmToggleButtonGetState (my_widget))
  1472.         {
  1473.  
  1474.           switch (window_button_struct -> button_num)
  1475.         {
  1476.  
  1477.         case BUTTON_ps_io:
  1478.           SP -> ps_io_time_mode = 1;
  1479.           break;
  1480.  
  1481.  
  1482.         case BUTTON_ps_cpu:
  1483. /*
  1484.           fprintf (stdout, "Current time mode = %d\n",
  1485.                SP -> ps_cpu_time_mode);
  1486. */
  1487.  
  1488.           SP -> ps_cpu_time_mode = 1;
  1489.  
  1490.  
  1491.           break;
  1492.  
  1493.  
  1494.         }
  1495.  
  1496. /*
  1497.  * Turn of minutes and ticks....
  1498.  */
  1499.  
  1500.           XmToggleButtonSetState (
  1501.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1502.                          button_num].screen_widget_list[
  1503.               window_button_struct -> dynamic_window_index + 1],
  1504.                        False, False);
  1505.  
  1506.           XmToggleButtonSetState (
  1507.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1508.                          button_num].screen_widget_list[
  1509.               window_button_struct -> dynamic_window_index + 2],
  1510.                        False, False);
  1511.  
  1512.  
  1513.         }
  1514.       else
  1515.         {
  1516. /*
  1517.  * We were on, and we should stay ON....
  1518.  */
  1519.           XmToggleButtonSetState (my_widget, True, False);
  1520.           return;
  1521.         }
  1522.  
  1523.       break;
  1524.  
  1525.     case 1:
  1526.  
  1527.       if (XmToggleButtonGetState (my_widget))
  1528.         {
  1529. /*
  1530.           fprintf (stdout, "Chaning to minutes....\n");
  1531. */
  1532.           switch (window_button_struct -> button_num)
  1533.         {
  1534.  
  1535.         case BUTTON_ps_io:
  1536.           SP -> ps_io_time_mode = 0;
  1537.           break;
  1538.  
  1539.         case BUTTON_ps_cpu:
  1540. /*
  1541.           fprintf (stdout, "Current time mode = %d\n",
  1542.                SP -> ps_cpu_time_mode);
  1543. */
  1544.           if (SP -> ps_display_mode == 13)
  1545.             {
  1546.               SP -> ps_cpu_time_mode = 0;
  1547.  
  1548.             }
  1549.           else
  1550.             {
  1551. /*
  1552.               fprintf (stdout, "Minutes should be stippled out!\n");
  1553. */
  1554.  
  1555.             }
  1556.           break;
  1557.  
  1558.         }
  1559.  
  1560.         /*
  1561.           * Turn off ticks....
  1562.           */
  1563.  
  1564.           XmToggleButtonSetState (
  1565.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1566.                          button_num].screen_widget_list[
  1567.               window_button_struct -> dynamic_window_index - 1],
  1568.                        False, False);
  1569.         }
  1570.       else
  1571.         {
  1572.         /*
  1573.           * We were on, and we should stay ON....
  1574.           */
  1575.  
  1576.           XmToggleButtonSetState (my_widget, True, False);
  1577.           return;
  1578.         }
  1579.  
  1580.       break;
  1581.  
  1582.  
  1583.     case 2:
  1584.       if (XmToggleButtonGetState (my_widget))
  1585.         {
  1586. /*
  1587.           fprintf (stdout, "Chaning to ticks....\n");
  1588. */
  1589.           switch (window_button_struct -> button_num)
  1590.         {
  1591.  
  1592.         case BUTTON_ps_io:
  1593.           SP -> ps_io_time_mode = 0;
  1594.           break;
  1595.  
  1596.         case BUTTON_ps_cpu:
  1597. /*
  1598.           fprintf (stdout, "Current time mode = %d\n",
  1599.                SP -> ps_cpu_time_mode);
  1600. */
  1601.  
  1602.           if (SP -> ps_display_mode == 13)
  1603.             {
  1604. /*
  1605.               fprintf (stdout, "Ticks should be stippled out\n");
  1606. */
  1607.  
  1608.             }
  1609.           else
  1610.             {
  1611.               SP -> ps_cpu_time_mode = 2;
  1612.  
  1613.             }
  1614.           break;
  1615.  
  1616.         }
  1617.  
  1618.         /*
  1619.           * Turn of percent and minutes....
  1620.           */
  1621.  
  1622.           XmToggleButtonSetState (
  1623.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1624.                          button_num].screen_widget_list[
  1625.               window_button_struct -> dynamic_window_index - 2],
  1626.                        False, False);
  1627.           XmToggleButtonSetState (
  1628.              SP -> SEPERATE_WINDOWS_LIST[window_button_struct ->
  1629.                          button_num].screen_widget_list[
  1630.               window_button_struct -> dynamic_window_index - 1],
  1631.                        False, False);
  1632.         }
  1633.       else
  1634.         {
  1635.         /*
  1636.           * We were on, and we should stay ON....
  1637.           */
  1638.  
  1639.           XmToggleButtonSetState (my_widget, True, False);
  1640.           return;
  1641.         }
  1642.  
  1643.       break;
  1644.  
  1645.     }
  1646.     }
  1647.   else if (window_button_struct -> type == SHOW_NFS_BUTTON)
  1648.     {
  1649. /*
  1650.       fprintf (stdout, "SHOW_NFS_BUTTON was pressed\n");
  1651. */
  1652.       if (XmToggleButtonGetState (my_widget))
  1653.     {
  1654.       if (window_button_struct -> button_num == BUTTON_disk_space)
  1655.         {
  1656.           SP -> show_nfs = 1;
  1657.         }
  1658.     }
  1659.       else
  1660.     {
  1661.       if (window_button_struct -> button_num == BUTTON_disk_space)
  1662.         {
  1663.           SP -> show_nfs = 0;
  1664.         }
  1665.     }
  1666.     }
  1667.   else if (window_button_struct -> type == SHOW_TOTAL_BUTTON)
  1668.     {
  1669. /*
  1670.       fprintf (stdout, "SHOW_TOTAL_BUTTON was pressed\n");
  1671. */
  1672.  
  1673.       if (XmToggleButtonGetState (my_widget))
  1674.  
  1675.     {
  1676.       if (window_button_struct -> button_num == BUTTON_disk_space)
  1677.         {
  1678.           SP -> show_disk_totals = 1;
  1679.         }
  1680.     }
  1681.       else
  1682.     {
  1683.       if (window_button_struct -> button_num == BUTTON_disk_space)
  1684.         {
  1685.           SP -> show_disk_totals = 0;
  1686.         }
  1687.     }
  1688.     }
  1689.  
  1690.  
  1691.  
  1692. /*
  1693.  * If we have gotten this far, then the screen needs to be changed in some
  1694.  * manner.....
  1695.  */
  1696.  
  1697. /*
  1698.   fprintf (stdout, "About to update the WINDOW....\n");
  1699. */
  1700.  
  1701.   temp_server = current_server;;
  1702.   current_server = SP;
  1703.  
  1704.   switch (window_button_struct -> button_num)
  1705.     {
  1706.  
  1707.     case BUTTON_disk_space:
  1708.       update_disk_space (SP);
  1709.       break;
  1710.     case BUTTON_ps_mem:
  1711.       update_ps_mem (SP);
  1712.       break;
  1713.     case BUTTON_ps_io:
  1714.       update_ps_io (SP);
  1715.       break;
  1716.     case BUTTON_ps_cpu:
  1717.       update_ps_cpu (SP);
  1718.       break;
  1719.  
  1720.  
  1721.     }
  1722.  
  1723.   current_server = temp_server;
  1724.  
  1725.   XCopyArea (
  1726.           SP ->
  1727.       SEPERATE_WINDOWS_LIST[window_button_struct -> button_num].display,
  1728.           SP ->
  1729.        SEPERATE_WINDOWS_LIST[window_button_struct -> button_num].pixmap,
  1730.           SP ->
  1731.        SEPERATE_WINDOWS_LIST[window_button_struct -> button_num].window,
  1732.           SP ->
  1733.           SEPERATE_WINDOWS_LIST[window_button_struct -> button_num].gc,
  1734.           0,
  1735.           0,
  1736.           SP ->
  1737.        SEPERATE_WINDOWS_LIST[window_button_struct -> button_num].draw_width,
  1738.           SP ->
  1739.       SEPERATE_WINDOWS_LIST[window_button_struct -> button_num].draw_height,
  1740.           0,
  1741.           0);
  1742. /*
  1743.   fprintf (stdout, "Sort mode = %d\n", window_button_struct -> sort_mode);
  1744. */
  1745.  
  1746. }
  1747.  
  1748.  
  1749. static xs_window_menu_struct View_list_data[] =
  1750. {
  1751.   {"MB SPACE", 'M', option_callback,
  1752.    0, NULL, 0, NULL, 0, 0, TOGGLE_ON, 1},
  1753.   {"BLOCKS", 'B', option_callback,
  1754.    0, NULL, 0, NULL, 1, 1, TOGGLE_OFF, 1},
  1755.   {"INODES", 'I', option_callback,
  1756.    0, NULL, 0, NULL, 2, 2, TOGGLE_OFF, 1}
  1757. };
  1758.  
  1759.  
  1760.  
  1761. static xs_window_menu_struct Sort_list_data[] =
  1762. {
  1763.   {"DESCENDING", 'D', option_callback,
  1764.    0, NULL, 0, NULL, 3, 0, TOGGLE_ON, 1},
  1765.   {"ASCENDING", 'A', option_callback,
  1766.    0, NULL, 0, NULL, 4, 1, TOGGLE_OFF, 1}
  1767. };
  1768.  
  1769. static xs_window_menu_struct option_menu_data[] =
  1770. {
  1771.   {"VIEW", 'V', NULL, NULL, View_list_data, XtNumber (View_list_data), NULL, -1, 0, TOGGLE_OFF, 0},
  1772. {"SORTING ORDER", 'S', NULL, NULL, Sort_list_data, XtNumber (Sort_list_data),
  1773.  NULL, -1, 0, TOGGLE_OFF, 0},
  1774. {"SHOW NFS", 'N', option_callback, NULL, NULL, 0, NULL, 5, 0, TOGGLE_ON, 2},
  1775.   {"SHOW TOTAL", 'T', option_callback, NULL, NULL, NULL, NULL, 6, 0, TOGGLE_ON, 2}
  1776. };
  1777.  
  1778. static xs_window_menu_struct option_menu_bar_data[] =
  1779. {
  1780.   {"OPTIONS", 'O', NULL, NULL, option_menu_data,
  1781.    XtNumber (option_menu_data), NULL, -1, 0, TOGGLE_OFF, 0}
  1782. };
  1783.  
  1784.  
  1785. /*
  1786.  * Begin PS_MEM menu bar definitions....
  1787.  */
  1788.  
  1789.  
  1790. static xs_window_menu_struct ps_mem_view_menu_data[] =
  1791. {
  1792.   {"Core Storage Only: Private & Shared", 'P', option_callback,
  1793.    0, NULL, 0, NULL, 0, 0, TOGGLE_ON, 1},
  1794.   {"Core Storage Only", 'C', option_callback,
  1795.    0, NULL, 0, NULL, 1, 1, TOGGLE_OFF, 1},
  1796.   {"All Storage", 'A', option_callback,
  1797.    0, NULL, 0, NULL, 2, 2, TOGGLE_OFF, 1},
  1798.   {"Secondary Storage Only", 'S', option_callback,
  1799.    0, NULL, 0, NULL, 3, 3, TOGGLE_OFF, 1}
  1800. };
  1801.  
  1802.  
  1803. static xs_window_menu_struct ps_mem_sort_menu_data[] =
  1804. {
  1805.   {"DESCENDING", 'D', option_callback,
  1806.    0, NULL, 0, NULL, 4, 0, TOGGLE_ON, 1},
  1807.   {"ASCENDING", 'A', option_callback,
  1808.    0, NULL, 0, NULL, 5, 1, TOGGLE_OFF, 1}
  1809. };
  1810.  
  1811. static xs_window_menu_struct ps_mem_option_menu_data[] =
  1812. {
  1813.   {"VIEW", 'V', NULL, NULL, ps_mem_view_menu_data,
  1814.    XtNumber (ps_mem_view_menu_data), NULL, -1, 0, TOGGLE_OFF, 0},
  1815.   {"SORTING ORDER", 'O', NULL, NULL, ps_mem_sort_menu_data,
  1816.    XtNumber (ps_mem_sort_menu_data), NULL, -1, 0, TOGGLE_OFF, 0}
  1817. };
  1818.  
  1819. static xs_window_menu_struct ps_mem_option_menu_bar_data[] =
  1820. {
  1821.   {"OPTIONS", 'O', NULL, NULL, ps_mem_option_menu_data,
  1822.    XtNumber (ps_mem_option_menu_data), NULL, -1, 0, TOGGLE_OFF, 0}
  1823. };
  1824.  
  1825.  
  1826. /*
  1827.  * Begin PS_IO menu bar definitions....
  1828.  */
  1829.  
  1830. static xs_window_menu_struct ps_io_sort_menu_data[] =
  1831. {
  1832.   {"DESCENDING", 'D', option_callback,
  1833.    0, NULL, 0, NULL, 0, 0, TOGGLE_ON, 1},
  1834.   {"ASCENDING", 'A', option_callback,
  1835.    0, NULL, 0, NULL, 1, 1, TOGGLE_OFF, 1}
  1836. };
  1837.  
  1838. static xs_window_menu_struct ps_io_mode_menu_data[] =
  1839. {
  1840.   {"CURRENT", 'C', option_callback,
  1841.    0, NULL, 0, NULL, 2, 0, TOGGLE_ON, 1},
  1842.   {"CUMMULATIVE", 'M', option_callback,
  1843.    0, NULL, 0, NULL, 3, 1, TOGGLE_OFF, 1}
  1844. };
  1845.  
  1846. static xs_window_menu_struct ps_io_display_menu_data[] =
  1847. {
  1848.   {"PERCENT", 'P', option_callback,
  1849.    0, NULL, 0, NULL, 4, 0, TOGGLE_ON, 1},
  1850.   {"COUNT", 'C', option_callback,
  1851.    0, NULL, 0, NULL, 5, 1, TOGGLE_OFF, 1}
  1852. };
  1853.  
  1854.  
  1855.  
  1856.  
  1857. static xs_window_menu_struct ps_io_option_menu_data[] =
  1858. {
  1859.   {"SORTING ORDER", 'O', NULL, NULL, ps_io_sort_menu_data,
  1860.    XtNumber (ps_io_sort_menu_data), NULL, -1, 0, TOGGLE_OFF, 0},
  1861.   {"SORTING MODE", 'M', NULL, NULL, ps_io_mode_menu_data,
  1862.    XtNumber (ps_io_mode_menu_data), NULL, -1, 0, TOGGLE_OFF, 0}
  1863. /*
  1864.   {"DISPLAY TYPE", 'T', NULL, NULL, ps_io_display_menu_data,
  1865.    XtNumber (ps_io_display_menu_data), NULL, -1, 0, 0, 0}
  1866. */
  1867.  
  1868. /*                      ^^
  1869.     THIS MAY NEED TO CHANGE...........  ......
  1870.  
  1871. */
  1872.  
  1873. };
  1874.  
  1875. static xs_window_menu_struct ps_io_option_menu_bar_data[] =
  1876. {
  1877.   {"OPTIONS", 'O', NULL, NULL, ps_io_option_menu_data,
  1878.    XtNumber (ps_io_option_menu_data), NULL, -1, 0, TOGGLE_OFF, 0}
  1879. };
  1880.  
  1881. /*
  1882.  * Begin PS_CPU menu bar definitions....
  1883.  */
  1884.  
  1885. static xs_window_menu_struct ps_cpu_sort_menu_data[] =
  1886. {
  1887.   {"DESCENDING", 'D', option_callback,
  1888.    0, NULL, 0, NULL, 0, 0, TOGGLE_ON, 1},
  1889.   {"ASCENDING", 'A', option_callback,
  1890.    0, NULL, 0, NULL, 1, 1, TOGGLE_OFF, 1}
  1891. };
  1892. /*
  1893.  * If changing the relative positions of CURRENT/CUMMULATIVE to
  1894.  * PERCENT/MINUTES/TICKS, be sure to update the callbacks knowlege of
  1895.  * this change......
  1896.  */
  1897.  
  1898. static xs_window_menu_struct ps_cpu_mode_menu_data[] =
  1899. {
  1900.   {"CURRENT", 'C', option_callback,
  1901.    0, NULL, 0, NULL, 2, 0, TOGGLE_ON, 1},
  1902.   {"CUMMULATIVE", 'M', option_callback,
  1903.    0, NULL, 0, NULL, 3, 1, TOGGLE_OFF, 1}
  1904. };
  1905.  
  1906. static xs_window_menu_struct ps_cpu_display_menu_data[] =
  1907. {
  1908.   {"PERCENT", 'P', option_callback,
  1909.    0, NULL, 0, NULL, 4, 0, TOGGLE_ON, 1},
  1910.   {"MINUTES", 'M', option_callback,
  1911.    0, NULL, 0, NULL, 5, 1, TOGGLE_OFF | TOGGLE_STIPPLED, 1},
  1912.   {"TICKS", 'T', option_callback,
  1913.    0, NULL, 0, NULL, 6, 2, TOGGLE_OFF, 1},
  1914. };
  1915.  
  1916.  
  1917.  
  1918.  
  1919. static xs_window_menu_struct ps_cpu_option_menu_data[] =
  1920. {
  1921.   {"SORTING ORDER", 'O', NULL, NULL, ps_cpu_sort_menu_data,
  1922.    XtNumber (ps_cpu_sort_menu_data), NULL, -1, 0, TOGGLE_OFF, 0},
  1923.   {"SORTING MODE", 'M', NULL, NULL, ps_cpu_mode_menu_data,
  1924.    XtNumber (ps_cpu_mode_menu_data), NULL, -1, 0, TOGGLE_OFF, 0},
  1925.   {"DISPLAY TYPE", 'T', NULL, NULL, ps_cpu_display_menu_data,
  1926.    XtNumber (ps_cpu_display_menu_data), NULL, -1, 0, TOGGLE_OFF, 0}
  1927.  
  1928. };
  1929.  
  1930. static xs_window_menu_struct ps_cpu_option_menu_bar_data[] =
  1931. {
  1932.   {"OPTIONS", 'O', NULL, NULL, ps_cpu_option_menu_data,
  1933.    XtNumber (ps_cpu_option_menu_data), NULL, -1, 0, TOGGLE_OFF, 0}
  1934. };
  1935.  
  1936.  
  1937. int
  1938. fill_in_dynamic_window_button_struct (server_pointer,
  1939.                       button,
  1940.                       window_button_struct,
  1941.                       parent_name,
  1942.                       list,
  1943.                       entries,
  1944.                       current_index)
  1945.  
  1946.      struct NetworkXswStruct *server_pointer;
  1947.      int             button;
  1948.      struct window_button_callback_struct *window_button_struct;
  1949.      char           *parent_name;
  1950.      xs_window_menu_struct *list;
  1951.      int             entries;
  1952.      int             current_index;
  1953. {
  1954.  
  1955.   int             i = 0;
  1956.  
  1957.   for (i = 0; i < entries; i++)
  1958.     {
  1959.       if (list[i].sub_menu != NULL)
  1960.     {
  1961.       current_index =
  1962.         fill_in_dynamic_window_button_struct (server_pointer,
  1963.                           button,
  1964.                           window_button_struct,
  1965.                           list[i].name,
  1966.                           list[i].sub_menu,
  1967.                           list[i].n_sub_items,
  1968.                           current_index);
  1969.     }
  1970.       else
  1971.     {
  1972.       if (list[i].dynamic_data_index != -1)
  1973.         {
  1974. /*
  1975.  * Set up DEFAULT settings...
  1976.  */
  1977.           window_button_struct[current_index].sort_mode = list[i].sort_mode;
  1978.           window_button_struct[current_index].server_pointer =
  1979.         server_pointer;
  1980.           window_button_struct[current_index].button_num = button;
  1981.           window_button_struct[current_index].dynamic_window_index =
  1982.         current_index;
  1983.           window_button_struct[current_index].ps_menu = NULL;
  1984.           window_button_struct[current_index].ps_menu_index = 0;
  1985.           window_button_struct[current_index].ps_screen_number = 0;
  1986.  
  1987.           if (button == BUTTON_disk_space)
  1988.         window_button_struct[current_index].ps_screen =
  1989.           disk_space_screens;
  1990.           else if (button == BUTTON_ps_mem)
  1991.         window_button_struct[current_index].ps_screen =
  1992.           ps_mem_screens;
  1993.  
  1994. /*
  1995.  * Begin specific settings....
  1996.  */
  1997.  
  1998.           if (strcmp (parent_name, "VIEW") == 0)
  1999.         {
  2000. /*
  2001.           fprintf (stdout, "Setting type to VIEW at %d\n ",
  2002.                current_index);
  2003. */
  2004.           window_button_struct[current_index].ps_menu_index = -2;
  2005.           window_button_struct[current_index].ps_screen_number =
  2006.             list[i].sort_mode;
  2007.  
  2008.           current_index++;
  2009.         }
  2010.           else if (strcmp (parent_name, "SORTING ORDER") == 0)
  2011.         {
  2012. /*
  2013. fprintf (stdout, "Setting type to ASCEND_DESCEND_BUTTON at %d\n ",
  2014.         current_index);
  2015. */
  2016.           window_button_struct[current_index].type =
  2017.             ASCEND_DESCEND_BUTTON;
  2018.  
  2019.           current_index++;
  2020.         }
  2021.           else if (strcmp (parent_name, "SORTING MODE") == 0)
  2022.         {
  2023. /*
  2024.           fprintf (stdout, "Setting type to CUM_CUR_BUTTON at %d\n ",
  2025.                current_index);
  2026. */
  2027.           window_button_struct[current_index].type =
  2028.             CUM_CUR_BUTTON;
  2029.  
  2030.           current_index++;
  2031.         }
  2032.           else if (strcmp (parent_name, "DISPLAY TYPE") == 0)
  2033.         {
  2034. /*
  2035. fprintf (stdout, "Setting type to PERCENT_OTHER_BUTTON at %d\n ", 
  2036.         current_index);
  2037. */
  2038.           window_button_struct[current_index].type =
  2039.             PERCENT_OTHER_BUTTON;
  2040.  
  2041.           current_index++;
  2042.         }
  2043.  
  2044.  
  2045.  
  2046. /*
  2047.  * Begin stand alone options....
  2048.  */
  2049.           else if (strcmp (parent_name, "OPTIONS") == 0)
  2050.         {
  2051.  
  2052.           if (strcmp (list[i].name, "SHOW NFS") == 0)
  2053.             {
  2054. /*
  2055.               fprintf (stdout, "Setting type to SHOW NFS at %d\n ",
  2056.                    current_index);
  2057. */
  2058.               window_button_struct[current_index].type =
  2059.             SHOW_NFS_BUTTON;
  2060.               current_index++;
  2061.             }
  2062.           else if (strcmp (list[i].name, "SHOW TOTAL") == 0)
  2063.             {
  2064. /*
  2065.               fprintf (stdout, "Setting type to SHOW TOTAL at %d\n ",
  2066.                    current_index);
  2067. */
  2068.               window_button_struct[current_index].type =
  2069.             SHOW_TOTAL_BUTTON;
  2070.               current_index++;
  2071.             }
  2072.  
  2073.         }
  2074.         }
  2075.     }
  2076.     }
  2077.  
  2078.   return (current_index);
  2079.  
  2080.  
  2081.  
  2082. }
  2083.  
  2084. int
  2085. count_dynamic_entries (list, entries)
  2086.  
  2087.      xs_window_menu_struct *list;
  2088.      int             entries;
  2089.  
  2090. {
  2091.   int             result = 0;
  2092.   int             i;
  2093.  
  2094.   for (i = 0; i < entries; i++)
  2095.     {
  2096.  
  2097.       if (list[i].sub_menu != NULL)
  2098.     {
  2099.       result += count_dynamic_entries (list[i].sub_menu,
  2100.                        list[i].n_sub_items);
  2101.     }
  2102.       else
  2103.     {
  2104.       if (list[i].dynamic_data_index != -1)
  2105.         {
  2106.           result++;
  2107.         }
  2108.  
  2109.     }
  2110.     }
  2111.  
  2112.   return (result);
  2113.  
  2114. }
  2115.  
  2116.  
  2117. Widget         *
  2118. ps_create_menu_buttons (menulist,
  2119.             nitems,
  2120.  
  2121.             screenlist,
  2122.             screen_num,
  2123.  
  2124.             optionlist,
  2125.             option_num,    /* This is really bogus since it can
  2126.                      * be nested!!!!! */
  2127.  
  2128.             button,
  2129.             server_pointer)
  2130.  
  2131.      ps_menu_struct *menulist;
  2132.      int             nitems;
  2133.      multi_screen_window_struct *screenlist;
  2134.      int             screen_num;
  2135.  
  2136.      xs_window_menu_struct *optionlist;
  2137.      int             option_num;
  2138.  
  2139.      int             button;
  2140.      struct NetworkXswStruct *server_pointer;
  2141. {
  2142.  
  2143.   int             i, j;
  2144.   int             k = 0;
  2145.   int             sort_index = 0;
  2146.   int             temp_k = -1;
  2147.   int             result = 0;
  2148.  
  2149.   Arg             args[32];
  2150.   int             argcount;
  2151.   XFontStruct    *Current_Font;
  2152.   XmFontList      Font_List;
  2153.   Widget         *toggle_widget;
  2154.  
  2155.   struct ps_button_callback_struct *ps_button_struct;
  2156.   struct window_button_callback_struct *window_button_struct;
  2157.  
  2158.  
  2159. /*
  2160.  * Create the space for the toggle widgets....
  2161.  */
  2162.  
  2163.   toggle_widget =
  2164.     (Widget *) malloc (sizeof (Widget) * nitems);
  2165.  
  2166.  
  2167. /*
  2168.  * Create the toggle widgets...
  2169.  */
  2170.  
  2171.  
  2172.   Current_Font = XLoadQueryFont (display, server_pointer -> font_name);
  2173.   Font_List = XmFontListCreate (Current_Font, XmSTRING_DEFAULT_CHARSET);
  2174.  
  2175.  
  2176.   server_pointer -> ps_button_change = 1;
  2177.  
  2178.  
  2179. /*
  2180.       fprintf (stdout, "creating option widgets....\n");
  2181. */
  2182.  
  2183. /*
  2184.  * Create the Menu Bar
  2185.  */
  2186.       argcount = 0;
  2187.       XtSetArg (args[argcount], XmNtopAttachment, XmATTACH_WIDGET);
  2188.       argcount++;
  2189.       XtSetArg (args[argcount], XmNtopWidget,
  2190.         server_pointer -> SEPERATE_WINDOWS_LIST[button].title_label);
  2191.       argcount++;
  2192.       XtSetArg (args[argcount], XmNrightAttachment, XmATTACH_FORM);
  2193.       argcount++;
  2194.       XtSetArg (args[argcount], XmNrightOffset, 0);
  2195.       argcount++;
  2196.  
  2197.       XtSetArg (args[argcount], XmNmarginHeight, 0);
  2198.       argcount++;
  2199.       XtSetArg (args[argcount], XmNmarginWidth, 0);
  2200.       argcount++;
  2201.       XtSetArg (args[argcount], XmNshadowThickness, 1);
  2202.       argcount++;
  2203.  
  2204.       server_pointer -> SEPERATE_WINDOWS_LIST[button].option_menu_bar =
  2205.     XmCreateMenuBar (
  2206.              server_pointer -> SEPERATE_WINDOWS_LIST[button].form_w,
  2207.               "submenu", args, argcount);
  2208.  
  2209.  
  2210. /*
  2211.  * Create the menu widgets.....First one is "ON", the rest are "OFF"
  2212.  */
  2213.  
  2214.       server_pointer -> SEPERATE_WINDOWS_LIST[button].current_screen_mode = 0;
  2215.  
  2216. /*
  2217.  * Count how many dynamic callback entires are present....
  2218.  * Then make space for them....
  2219.  */
  2220.  
  2221.       result = count_dynamic_entries (optionlist, option_num);
  2222. /*
  2223.       fprintf (stdout, "The number of dynamic entires = %d\n", result);
  2224. */
  2225.  
  2226.       window_button_struct =
  2227.     (struct window_button_callback_struct *) calloc (result,
  2228.                  sizeof (struct window_button_callback_struct));
  2229.  
  2230. /*
  2231.  * Initialize call back data structures....
  2232.  */
  2233.  
  2234.       result = fill_in_dynamic_window_button_struct (server_pointer,
  2235.                              button,
  2236.                              window_button_struct,
  2237.                              NULL,
  2238.                              optionlist,
  2239.                              option_num,
  2240.                              0);
  2241.  
  2242. /*
  2243.       fprintf (stdout, "The number of dynamic entires filled = %d\n", result);
  2244. */
  2245.  
  2246. /*
  2247.  * Need an array of widgets that correspond to the VIEW buttons.....
  2248.  */
  2249.  
  2250.       server_pointer -> SEPERATE_WINDOWS_LIST[button].screen_widget_list =
  2251.     (Widget *) malloc (sizeof (Widget) * result);
  2252.  
  2253.       create_window_option_menu_bar (
  2254.         NULL,
  2255.         server_pointer ->
  2256.             SEPERATE_WINDOWS_LIST[button].option_menu_bar,
  2257.         optionlist,
  2258.         option_num,
  2259.         result,
  2260.         window_button_struct,
  2261.         server_pointer ->
  2262.             SEPERATE_WINDOWS_LIST[button].screen_widget_list);
  2263.  
  2264. /*
  2265.       fprintf (stdout, "DONE to set up menus....\n");
  2266. */
  2267.  
  2268.  
  2269.       XtManageChild (server_pointer ->
  2270.              SEPERATE_WINDOWS_LIST[button].option_menu_bar);
  2271.  
  2272.  
  2273.   for (i = 0; i < nitems; i++)
  2274.     {
  2275.  
  2276.  
  2277. /*
  2278.  * Set font, foreground, and background.....
  2279.  */
  2280.  
  2281.       argcount = 0;
  2282.       XtSetArg (args[argcount], XmNfontList, Font_List);
  2283.       argcount++;
  2284.       if (menulist[i].state)
  2285.     {
  2286.       XtSetArg (args[argcount], XmNbackground,
  2287.             colorAuxButtonOnBackground.pixel);
  2288.       argcount++;
  2289.       XtSetArg (args[argcount], XmNforeground,
  2290.             colorAuxButtonOnForeground.pixel);
  2291.       argcount++;
  2292.     }
  2293.       else
  2294.     {
  2295.       XtSetArg (args[argcount], XmNbackground,
  2296.             colorAuxButtonOffBackground.pixel);
  2297.       argcount++;
  2298.       XtSetArg (args[argcount], XmNforeground,
  2299.             colorAuxButtonOffForeground.pixel);
  2300.       argcount++;
  2301.     }
  2302.  
  2303.  
  2304. /*
  2305.  * Create the toggle button.....
  2306.  */
  2307.  
  2308.       if (menulist[i].type != SCREEN_SWITCH_BUTTON)
  2309.     {
  2310.  
  2311.  
  2312.       XtSetArg (args[argcount], XmNindicatorOn, False);
  2313.       argcount++;
  2314.  
  2315.     }
  2316.  
  2317.  
  2318. /*
  2319.  * Set up the position of the widget....
  2320.  */
  2321.  
  2322.       if (menulist[i].offset_side == LEFT_SIDE_OFFSET)
  2323.     {
  2324.       XtSetArg (args[argcount], XmNleftAttachment, XmATTACH_FORM);
  2325.       argcount++;
  2326.       XtSetArg (args[argcount], XmNleftOffset,
  2327.             4 + menulist[i].offset * FWIDTH);
  2328.     }
  2329.       else
  2330.     {
  2331.       XtSetArg (args[argcount], XmNrightAttachment, XmATTACH_FORM);
  2332.       argcount++;
  2333.       XtSetArg (args[argcount], XmNrightOffset,
  2334.             menulist[i].offset * FWIDTH);
  2335.     }
  2336.  
  2337.  
  2338. /*
  2339.  * All widgets will have top attachment to the label
  2340.  */
  2341.  
  2342.       argcount++;
  2343.       XtSetArg (args[argcount], XmNtopAttachment, XmATTACH_WIDGET);
  2344.       argcount++;
  2345.       XtSetArg (args[argcount], XmNtopWidget,
  2346.         server_pointer -> SEPERATE_WINDOWS_LIST[button].title_label);
  2347.       argcount++;
  2348.  
  2349.       {
  2350.  
  2351. /*
  2352.  * WHATS this difference between the IF and the ELSE logic???????
  2353.  */
  2354.     if (menulist[i].screen_number == 0)
  2355.       toggle_widget[i] =
  2356.         XtCreateManagedWidget (menulist[i].name,
  2357.                    xmToggleButtonWidgetClass,
  2358.              server_pointer -> SEPERATE_WINDOWS_LIST[button].form_w,
  2359.                    args,
  2360.                    argcount);
  2361.     else
  2362.       toggle_widget[i] =
  2363.         XtCreateWidget (menulist[i].name,
  2364.                 xmToggleButtonWidgetClass,
  2365.              server_pointer -> SEPERATE_WINDOWS_LIST[button].form_w,
  2366.                 args,
  2367.                 argcount);
  2368.  
  2369. /*
  2370.  * Initialize the current sort widget list.....
  2371.  */
  2372.  
  2373.     if ((menulist[i].state) && (menulist[i].type == SORT_BUTTON))
  2374.       {
  2375.         server_pointer -> SEPERATE_WINDOWS_LIST[button].view_current_sort_widget[k] = toggle_widget[i];
  2376.  
  2377.         k++;
  2378.  
  2379.       }
  2380.  
  2381. /*
  2382.  * Add the callback to this toggle button.....
  2383.  */
  2384.  
  2385.  
  2386.     ps_button_struct = (struct ps_button_callback_struct *) calloc (1,
  2387.                  sizeof (struct ps_button_callback_struct));
  2388.  
  2389. /*
  2390.  * For every new screen, sorting is zero relative.......so adjust for it..
  2391.  */
  2392.  
  2393.     if (menulist[i].screen_number == temp_k)
  2394.       {
  2395.         sort_index++;
  2396.       }
  2397.     else
  2398.       {
  2399.         sort_index = 0;
  2400.         temp_k = menulist[i].screen_number;
  2401.       }
  2402.  
  2403.     ps_button_struct -> sort_mode = sort_index;
  2404.     ps_button_struct -> server_pointer = server_pointer;
  2405.     ps_button_struct -> button_num = button;
  2406.     ps_button_struct -> ps_menu = menulist;
  2407.     ps_button_struct -> ps_menu_index = i;
  2408.  
  2409.  
  2410.     XtAddCallback (
  2411.             toggle_widget[i],
  2412.             XmNarmCallback,
  2413.             menulist[i].func,
  2414.             ps_button_struct);
  2415.       }
  2416.  
  2417.  
  2418.     }
  2419.  
  2420.   return (toggle_widget);
  2421.  
  2422.  
  2423. }
  2424.  
  2425.  
  2426. void
  2427. destroy_callback (my_widget, client_data, cbs)
  2428.      Widget          my_widget;
  2429.      DestroyCallbackClientData *client_data;
  2430.      XmAnyCallbackStruct *cbs;
  2431.  
  2432. {
  2433.  
  2434.   int             button;
  2435.   struct NetworkXswStruct *temp_server = NULL;
  2436.  
  2437.  
  2438. /*
  2439.  * This is not really destroying anything.... Depends what XmNdeleteResponse
  2440.  * is set to when the widget is created.....
  2441.  */
  2442.  
  2443.   temp_server = current_server;
  2444.  
  2445.  
  2446.   button = client_data -> button;
  2447.   current_server = (struct NetworkXswStruct *) client_data -> server_pointer;
  2448.  
  2449.   toggle_button_current_server = temp_server;
  2450.   set_display_mode (button);
  2451.   toggle_button_current_server = NULL;
  2452.  
  2453.   current_server = temp_server;
  2454.  
  2455. }
  2456.  
  2457.  
  2458.  
  2459. create_widget_title (button)
  2460.  
  2461.      int             button;
  2462.  
  2463. {
  2464.   switch (button)
  2465.     {
  2466.     case BUTTON_cpu:
  2467.       sprintf (widget_title,
  2468.            "Xsw (%s) : CPU",
  2469.            current_server -> server_name);
  2470.       sprintf (widget_icon_name,
  2471.            "Xsw:CPU->%s",
  2472.            current_server -> server_name);
  2473.  
  2474.  
  2475.       break;
  2476.     case BUTTON_wait:
  2477.       sprintf (widget_title,
  2478.            "Xsw (%s) : Wait",
  2479.            current_server -> server_name);
  2480.       sprintf (widget_icon_name,
  2481.            "Xsw:Wait->%s",
  2482.            current_server -> server_name);
  2483.       break;
  2484.     case BUTTON_other:
  2485.       sprintf (widget_title,
  2486.            "Xsw (%s) : Other",
  2487.            current_server -> server_name);
  2488.       sprintf (widget_icon_name,
  2489.            "Xsw:Other->%s",
  2490.            current_server -> server_name);
  2491.       break;
  2492.     case BUTTON_mem:
  2493.       sprintf (widget_title,
  2494.            "Xsw (%s) : MEM",
  2495.            current_server -> server_name);
  2496.       sprintf (widget_icon_name,
  2497.            "Xsw:MEM->%s",
  2498.            current_server -> server_name);
  2499.       break;
  2500.     case BUTTON_cache:
  2501.       sprintf (widget_title,
  2502.            "Xsw (%s) : Cache",
  2503.            current_server -> server_name);
  2504.       sprintf (widget_icon_name,
  2505.            "Xsw:Cache->%s",
  2506.            current_server -> server_name);
  2507.       break;
  2508.     case BUTTON_streams:
  2509.       sprintf (widget_title,
  2510.            "Xsw (%s) : Streams",
  2511.            current_server -> server_name);
  2512.       sprintf (widget_icon_name,
  2513.            "Xsw:Streams->%s",
  2514.            current_server -> server_name);
  2515.       break;
  2516.     case BUTTON_nfsstat:
  2517.       sprintf (widget_title,
  2518.            "Xsw (%s) : NFS stats",
  2519.            current_server -> server_name);
  2520.       sprintf (widget_icon_name,
  2521.            "Xsw:NFS stats->%s",
  2522.            current_server -> server_name);
  2523.       break;
  2524.     case BUTTON_sysinfo:
  2525.       sprintf (widget_title,
  2526.            "Xsw (%s) : Sysinfo",
  2527.            current_server -> server_name);
  2528.       sprintf (widget_icon_name,
  2529.            "Xsw:Sysinfo->%s",
  2530.            current_server -> server_name);
  2531.       break;
  2532.     case BUTTON_tune_var:
  2533.       sprintf (widget_title,
  2534.            "Xsw (%s) : VBT",
  2535.            current_server -> server_name);
  2536.       sprintf (widget_icon_name,
  2537.            "Xsw:VBT->%s",
  2538.            current_server -> server_name);
  2539.       break;
  2540.     case BUTTON_dev_stats:
  2541.       sprintf (widget_title,
  2542.            "Xsw (%s) : Dev. stats",
  2543.            current_server -> server_name);
  2544.       sprintf (widget_icon_name,
  2545.            "Xsw:Dev. Stats->%s",
  2546.            current_server -> server_name);
  2547.       break;
  2548.     case BUTTON_disk_space:
  2549.       sprintf (widget_title,
  2550.            "Xsw (%s) : Disk Space",
  2551.            current_server -> server_name);
  2552.       sprintf (widget_icon_name,
  2553.            "Xsw:Disk Space->%s",
  2554.            current_server -> server_name);
  2555.       break;
  2556.     case BUTTON_ps_mem:
  2557.       sprintf (widget_title,
  2558.            "Xsw (%s) : PS MEM",
  2559.            current_server -> server_name);
  2560.       sprintf (widget_icon_name,
  2561.            "Xsw:PS MEM->%s",
  2562.            current_server -> server_name);
  2563.       break;
  2564.     case BUTTON_ps_cpu:
  2565.       sprintf (widget_title,
  2566.            "Xsw (%s) : PS CPU",
  2567.            current_server -> server_name);
  2568.       sprintf (widget_icon_name,
  2569.            "Xsw:PS CPU->%s",
  2570.            current_server -> server_name);
  2571.       break;
  2572.     case BUTTON_ps_io:
  2573.       sprintf (widget_title,
  2574.            "Xsw (%s) : PS I/O",
  2575.            current_server -> server_name);
  2576.       sprintf (widget_icon_name,
  2577.            "Xsw:PS I/O->%s",
  2578.            current_server -> server_name);
  2579.       break;
  2580.  
  2581.     }
  2582. }
  2583.  
  2584. void
  2585. get_widget_geometry (button)
  2586.      int             button;
  2587.  
  2588. {
  2589.   XrmDatabase     the_database;
  2590.   char           *string_type;
  2591.   XrmValue        string_value;
  2592.   char           *query_string;
  2593.   char            temp;
  2594.  
  2595.   Position        x_position, y_position;
  2596.  
  2597.   Bool            result = 0;
  2598.  
  2599.  
  2600.   current_server -> SEPERATE_WINDOWS_LIST[button].class_name =
  2601.     (char *) malloc (strlen (current_server -> server_name) + 20
  2602.              * (sizeof (char)));
  2603.  
  2604.   sprintf (current_server -> SEPERATE_WINDOWS_LIST[button].class_name,
  2605.        "%s%s", Client_decl[button].classname,
  2606.        current_server -> server_name);
  2607.  
  2608.  
  2609.   query_string =
  2610.     (char *) malloc (strlen (current_server -> server_name) + 28
  2611.              * (sizeof (char)));
  2612.   sprintf (query_string,
  2613.        "%s%s",
  2614.        current_server -> SEPERATE_WINDOWS_LIST[button].class_name,
  2615.        ".geometry");
  2616.  
  2617. /*
  2618.   fprintf(stdout,"query string = %s\n",query_string);
  2619. */
  2620.  
  2621.   the_database = XrmGetDatabase (display);
  2622.  
  2623.   string_type = XtMalloc (sizeof (char) * 200);
  2624.  
  2625.   result = XrmGetResource (the_database,
  2626.                query_string,
  2627.                query_string,
  2628.                &string_type, &string_value);
  2629.  
  2630. /*
  2631.   fprintf(stdout,"result = %d\n",result);
  2632. */
  2633.  
  2634.   free (query_string);
  2635.  
  2636.   current_server -> SEPERATE_WINDOWS_LIST[button].GeometryQueryResults = result;
  2637.  
  2638.   if (result == 1)
  2639.     {
  2640.       sscanf (string_value.addr, "%d%c%d%d%d",
  2641.           ¤t_server -> SEPERATE_WINDOWS_LIST[button].width,
  2642.           &temp,
  2643.           ¤t_server -> SEPERATE_WINDOWS_LIST[button].height,
  2644.           &x_position, &y_position);
  2645.  
  2646. /*
  2647.       fprintf(stdout,"Xpostion = %d, Ypostion = %d\n",
  2648.         x_position,y_position);
  2649. */
  2650.  
  2651.       if (current_server -> SEPERATE_WINDOWS_LIST[button].width >
  2652.       current_server -> SEPERATE_WINDOWS_LIST[button].max_width)
  2653.     {
  2654.       current_server -> SEPERATE_WINDOWS_LIST[button].width =
  2655.         current_server -> SEPERATE_WINDOWS_LIST[button].max_width;
  2656.     }
  2657.  
  2658.       if (current_server -> SEPERATE_WINDOWS_LIST[button].width <
  2659.       current_server -> SEPERATE_WINDOWS_LIST[button].min_width)
  2660.     {
  2661.       current_server -> SEPERATE_WINDOWS_LIST[button].width =
  2662.         current_server -> SEPERATE_WINDOWS_LIST[button].min_width;
  2663.     }
  2664.  
  2665.       if (current_server -> SEPERATE_WINDOWS_LIST[button].height >
  2666.       current_server -> SEPERATE_WINDOWS_LIST[button].max_height)
  2667.     {
  2668. /*
  2669.     fprintf(stdout,"hight is to big\n");
  2670. */
  2671.       current_server -> SEPERATE_WINDOWS_LIST[button].height =
  2672.         current_server -> SEPERATE_WINDOWS_LIST[button].max_height;
  2673.     }
  2674.  
  2675.       if (current_server -> SEPERATE_WINDOWS_LIST[button].height <
  2676.       current_server -> SEPERATE_WINDOWS_LIST[button].min_height)
  2677.     {
  2678. /*
  2679.     fprintf(stdout,"hight is to small\n");
  2680. */
  2681.       current_server -> SEPERATE_WINDOWS_LIST[button].height =
  2682.         current_server -> SEPERATE_WINDOWS_LIST[button].min_height;
  2683.     }
  2684.  
  2685.  
  2686.     }
  2687.  
  2688.  
  2689.   XtFree (string_type);
  2690.  
  2691. }
  2692.  
  2693. void
  2694. create_shell_widget (button)
  2695.      int             button;
  2696. {
  2697.   Arg             args[20];
  2698.   int             argcount;
  2699.  
  2700.  
  2701.  
  2702.   DestroyCallbackClientData *destroy_client_data;
  2703.  
  2704.   argcount = 0;
  2705.   XtSetArg (args[argcount], XmNdeleteResponse, XmUNMAP);
  2706.   argcount++;
  2707.   XtSetArg (args[argcount], XmNiconName, widget_icon_name);
  2708.   argcount++;
  2709.   XtSetArg (args[argcount], XmNtitle, widget_title);
  2710.   argcount++;
  2711.   XtSetArg (args[argcount], XmNallowShellResize, True);
  2712.   argcount++;
  2713.   XtSetArg (args[argcount], XmNunitType, XmPIXELS);
  2714.   argcount++;
  2715.   XtSetArg (args[argcount], XmNsaveUnder, True);
  2716.   argcount++;
  2717.   XtSetArg (args[argcount], XmNmaxHeight,
  2718.         (XtArgVal) current_server ->
  2719.         SEPERATE_WINDOWS_LIST[button].max_height);
  2720.   argcount++;
  2721.  
  2722.  
  2723.   XtSetArg (args[argcount], XmNmaxWidth,
  2724.         (XtArgVal) current_server ->
  2725.         SEPERATE_WINDOWS_LIST[button].max_width);
  2726.   argcount++;
  2727.  
  2728.   XtSetArg (args[argcount], XmNminHeight,
  2729.         (XtArgVal) current_server ->
  2730.         SEPERATE_WINDOWS_LIST[button].min_height);
  2731.   argcount++;
  2732.  
  2733.   XtSetArg (args[argcount], XmNminWidth,
  2734.         (XtArgVal) current_server ->
  2735.         SEPERATE_WINDOWS_LIST[button].min_width);
  2736.   argcount++;
  2737.  
  2738.   XtSetArg (args[argcount], XmNheight,
  2739.         (XtArgVal) current_server ->
  2740.         SEPERATE_WINDOWS_LIST[button].height);
  2741.   argcount++;
  2742.  
  2743.   XtSetArg (args[argcount], XmNwidth,
  2744.         (XtArgVal) current_server ->
  2745.         SEPERATE_WINDOWS_LIST[button].width);
  2746.   argcount++;
  2747.  
  2748.  
  2749.   current_server -> SEPERATE_WINDOWS_LIST[button].shell_widget =
  2750.     XtCreatePopupShell (
  2751.          current_server -> SEPERATE_WINDOWS_LIST[button].class_name,
  2752.              topLevelShellWidgetClass,
  2753.              toplevel,
  2754.              args, argcount);
  2755.  
  2756.   destroy_client_data = (DestroyCallbackClientData *)
  2757.     malloc (sizeof (DestroyCallbackClientData));
  2758.  
  2759.   destroy_client_data -> button = button;
  2760.   destroy_client_data -> server_pointer = (caddr_t) current_server;
  2761.  
  2762.   current_server ->
  2763.     SEPERATE_WINDOWS_LIST[button].destroy_client_data_pointer =
  2764.     destroy_client_data;
  2765.  
  2766.   current_server -> SEPERATE_WINDOWS_LIST[button].display =
  2767.     XtDisplay (current_server -> SEPERATE_WINDOWS_LIST[button].shell_widget);
  2768.  
  2769.   current_server -> SEPERATE_WINDOWS_LIST[button].screen =
  2770.     DefaultScreen (current_server -> SEPERATE_WINDOWS_LIST[button].display);
  2771.  
  2772. /*
  2773.  * Add a protocol callback for the window manager. I want to know if
  2774.  * a user/WM closes one of the seperate windows via the window manager!
  2775.  */
  2776.  
  2777.  
  2778.  
  2779.   destroy_client_data -> WM_DELETE_WINDOW =
  2780.     XmInternAtom (current_server -> SEPERATE_WINDOWS_LIST[button].display,
  2781.           "WM_DELETE_WINDOW", False);
  2782.  
  2783.   XmAddWMProtocolCallback (current_server -> SEPERATE_WINDOWS_LIST[button].shell_widget,
  2784.                destroy_client_data -> WM_DELETE_WINDOW,
  2785.                destroy_callback,
  2786.                (caddr_t) destroy_client_data);
  2787.  
  2788. }
  2789.  
  2790.  
  2791. void
  2792. create_paned_widget (button)
  2793.      int             button;
  2794. {
  2795.   Arg             args[10];
  2796.   int             argcount;
  2797.  
  2798.   argcount = 0;
  2799.   XtSetArg (args[argcount], XmNseparatorOn, False);
  2800.   argcount++;
  2801.   XtSetArg (args[argcount], XmNskipAdjust, True);
  2802.   argcount++;
  2803.   XtSetArg (args[argcount], XmNallowResize, True);
  2804.   argcount++;
  2805.   XtSetArg (args[argcount], XmNmarginHeight, 0);
  2806.   argcount++;
  2807.   XtSetArg (args[argcount], XmNmarginWidth, 0);
  2808.   argcount++;
  2809.  
  2810.   XtSetArg (args[argcount], XmNheight,
  2811.         (XtArgVal) current_server ->
  2812.         SEPERATE_WINDOWS_LIST[button].height);
  2813.   argcount++;
  2814.  
  2815.   XtSetArg (args[argcount], XmNwidth,
  2816.         (XtArgVal) current_server ->
  2817.         SEPERATE_WINDOWS_LIST[button].width);
  2818.   argcount++;
  2819.  
  2820.  
  2821.   current_server -> SEPERATE_WINDOWS_LIST[button].paned_w =
  2822.     XtCreateManagedWidget ("paned",
  2823.                xmPanedWindowWidgetClass,
  2824.            current_server -> SEPERATE_WINDOWS_LIST[button].shell_widget,
  2825.                args,
  2826.                argcount);
  2827.  
  2828. }
  2829.  
  2830. create_main_window_widget (button)
  2831.      int             button;
  2832.  
  2833. {
  2834.   Arg             args[10];
  2835.   int             argcount;
  2836.   XFontStruct    *Current_Font;
  2837.   XmFontList      Font_List;
  2838.  
  2839.   char           *label_string = "XSW";
  2840.  
  2841.  
  2842.   argcount = 0;
  2843.   if ((button == BUTTON_ps_cpu) ||
  2844.       (button == BUTTON_ps_io) ||
  2845.       (button == BUTTON_ps_mem) ||
  2846.       (button == BUTTON_disk_space))
  2847.     {
  2848.  
  2849.  
  2850.       Current_Font = XLoadQueryFont (display, current_server -> font_name);
  2851.       Font_List = XmFontListCreate (Current_Font, XmSTRING_DEFAULT_CHARSET);
  2852.  
  2853. /*
  2854.  * Create the form for the toggle widgets...
  2855.  */
  2856.  
  2857.       argcount = 0;
  2858.       XtSetArg (args[argcount], XmNpaneMinimum, (FHEIGHT * 3));
  2859.       argcount++;
  2860.       XtSetArg (args[argcount], XmNpaneMaximum, (FHEIGHT * 3));
  2861.       argcount++;
  2862.       current_server -> SEPERATE_WINDOWS_LIST[button].form_w =
  2863.     XtCreateWidget ("paned",
  2864.             xmFormWidgetClass,
  2865.             current_server -> SEPERATE_WINDOWS_LIST[button].paned_w,
  2866.             args,
  2867.             argcount);
  2868.  
  2869.  
  2870.  
  2871.       argcount = 0;
  2872.       XtSetArg (args[argcount], XmNfontList, Font_List);
  2873.       argcount++;
  2874.       XtSetArg (args[argcount], XmNtopAttachment, XmATTACH_FORM);
  2875.       argcount++;
  2876.       XtSetArg (args[argcount], XmNleftAttachment, XmATTACH_FORM);
  2877.       argcount++;
  2878.       XtSetArg (args[argcount], XmNrightAttachment, XmATTACH_FORM);
  2879.       argcount++;
  2880.  
  2881.       if (button == BUTTON_ps_cpu)
  2882.     {
  2883.       label_string = ps_cpu_screens[0].default_title;
  2884.     }
  2885.       else if (button == BUTTON_ps_io)
  2886.     {
  2887.       label_string = ps_io_screens[0].default_title;
  2888.     }
  2889.       else if (button == BUTTON_ps_mem)
  2890.     {
  2891.       label_string = ps_mem_screens[0].default_title;
  2892.     }
  2893.       else if (button == BUTTON_disk_space)
  2894.     {
  2895.       label_string = disk_space_screens[0].default_title;
  2896.     }
  2897.  
  2898.       current_server -> SEPERATE_WINDOWS_LIST[button].title_label =
  2899.     XtCreateManagedWidget (label_string,
  2900.                    xmLabelWidgetClass,
  2901.              current_server -> SEPERATE_WINDOWS_LIST[button].form_w,
  2902.                    args,
  2903.                    argcount);
  2904.  
  2905.  
  2906.  
  2907.       if (button == BUTTON_ps_cpu)
  2908.     current_server -> SEPERATE_WINDOWS_LIST[button].toggle_widget =
  2909.       ps_create_menu_buttons (ps_toggle_button_data,
  2910.                   XtNumber (ps_toggle_button_data),
  2911.                   NULL, 0,
  2912.                   ps_cpu_option_menu_bar_data,
  2913.                   XtNumber (ps_cpu_option_menu_bar_data),
  2914.                   button,
  2915.                   current_server);
  2916.  
  2917.       else if (button == BUTTON_ps_mem)
  2918.     {
  2919.  
  2920.       current_server -> SEPERATE_WINDOWS_LIST[button].toggle_widget
  2921.         = ps_create_menu_buttons (ps_mem_toggle_button_data,
  2922.                       XtNumber (ps_mem_toggle_button_data),
  2923.                       ps_mem_screens,
  2924.                       XtNumber (ps_mem_screens),
  2925.                       ps_mem_option_menu_bar_data,
  2926.                       XtNumber (ps_mem_option_menu_bar_data),
  2927.                       button,
  2928.                       current_server);
  2929.  
  2930.     }
  2931.       else if (button == BUTTON_ps_io)
  2932.     {
  2933.       current_server ->
  2934.         SEPERATE_WINDOWS_LIST[button].toggle_widget =
  2935.         ps_create_menu_buttons (ps_io_toggle_button_data,
  2936.                     XtNumber (ps_io_toggle_button_data),
  2937.                     NULL, 0,
  2938.                     ps_io_option_menu_bar_data,
  2939.                     XtNumber (ps_io_option_menu_bar_data),
  2940.                     button,
  2941.                     current_server);
  2942.     }
  2943.       else if (button == BUTTON_disk_space)
  2944.     current_server ->
  2945.       SEPERATE_WINDOWS_LIST[button].toggle_widget =
  2946.       ps_create_menu_buttons (disk_space_toggle_button_data,
  2947.                   XtNumber (disk_space_toggle_button_data),
  2948.                   disk_space_screens,
  2949.                   XtNumber (disk_space_screens),
  2950.                   option_menu_bar_data,
  2951.                   XtNumber (option_menu_bar_data),
  2952.                   button,
  2953.                   current_server);
  2954.  
  2955.       XtManageChild (current_server -> SEPERATE_WINDOWS_LIST[button].form_w);
  2956.  
  2957.  
  2958.       argcount = 0;
  2959.       XtSetArg (args[argcount], XmNscrollingPolicy, XmAUTOMATIC);
  2960.       argcount++;
  2961.       XtSetArg (args[argcount], XmNincrement, FWIDTH);
  2962.       argcount++;
  2963.     }
  2964.  
  2965.   XtSetArg (args[argcount], XmNheight,
  2966.         (XtArgVal) current_server ->
  2967.         SEPERATE_WINDOWS_LIST[button].height);
  2968.   argcount++;
  2969.  
  2970.   XtSetArg (args[argcount], XmNwidth,
  2971.         (XtArgVal) current_server ->
  2972.         SEPERATE_WINDOWS_LIST[button].width);
  2973.   argcount++;
  2974.  
  2975.   current_server -> SEPERATE_WINDOWS_LIST[button].main_window_widget =
  2976.     XmCreateMainWindow (
  2977.             current_server -> SEPERATE_WINDOWS_LIST[button].paned_w,
  2978.              "mainWindow",
  2979.              args,
  2980.              argcount);
  2981.  
  2982. }
  2983.  
  2984.  
  2985. void
  2986. set_up_shell_max_sizes (button)
  2987.      int             button;
  2988. {
  2989.   Arg             args[10];
  2990.   int             argcount;
  2991.  
  2992.   argcount = 0;
  2993.   XtSetArg (args[argcount], XmNmaxHeight,
  2994.         (XtArgVal) current_server ->
  2995.         SEPERATE_WINDOWS_LIST[button].max_height);
  2996.   argcount++;
  2997.  
  2998.  
  2999.   XtSetArg (args[argcount], XmNmaxWidth,
  3000.         (XtArgVal) current_server ->
  3001.         SEPERATE_WINDOWS_LIST[button].max_width);
  3002.   argcount++;
  3003.  
  3004.   XtSetArg (args[argcount], XmNminHeight,
  3005.         (XtArgVal) current_server ->
  3006.         SEPERATE_WINDOWS_LIST[button].min_height);
  3007.   argcount++;
  3008.  
  3009.   XtSetArg (args[argcount], XmNminWidth,
  3010.         (XtArgVal) current_server ->
  3011.         SEPERATE_WINDOWS_LIST[button].min_width);
  3012.   argcount++;
  3013.  
  3014.  
  3015.   XtSetValues (
  3016.         current_server -> SEPERATE_WINDOWS_LIST[button].shell_widget,
  3017.         args, argcount);
  3018.  
  3019.  
  3020. }
  3021.  
  3022. void
  3023. set_up_shell_size (button)
  3024.      int             button;
  3025. {
  3026.   Arg             args[10];
  3027.   int             argcount;
  3028.  
  3029.   argcount = 0;
  3030.  
  3031. /*
  3032.   XtSetArg (args[argcount], XmNmaxHeight,
  3033.         (XtArgVal) current_server ->
  3034.         SEPERATE_WINDOWS_LIST[button].max_height);
  3035.   argcount++;
  3036.  
  3037.  
  3038.   XtSetArg (args[argcount], XmNmaxWidth,
  3039.         (XtArgVal) current_server ->
  3040.         SEPERATE_WINDOWS_LIST[button].max_width);
  3041.   argcount++;
  3042.  
  3043.   XtSetArg (args[argcount], XmNminHeight,
  3044.         (XtArgVal) current_server ->
  3045.         SEPERATE_WINDOWS_LIST[button].min_height);
  3046.   argcount++;
  3047.  
  3048.   XtSetArg (args[argcount], XmNminWidth,
  3049.         (XtArgVal) current_server ->
  3050.         SEPERATE_WINDOWS_LIST[button].min_width);
  3051.   argcount++;
  3052. */
  3053.  
  3054.  
  3055. /*
  3056.  * Should not have to set these! The window manager positions the window
  3057.  * for us.
  3058.  
  3059.   XtSetArg (args[argcount], XmNx,
  3060.         (XtArgVal) current_server ->
  3061.         SEPERATE_WINDOWS_LIST[button].x1);
  3062.   argcount++;
  3063.  
  3064.   XtSetArg (args[argcount], XmNy,
  3065.         (XtArgVal) current_server ->
  3066.         SEPERATE_WINDOWS_LIST[button].y1);
  3067.   argcount++;
  3068.  
  3069. */
  3070.  
  3071.   XtSetArg (args[argcount], XmNheight,
  3072.         (XtArgVal) current_server ->
  3073.         SEPERATE_WINDOWS_LIST[button].height);
  3074.   argcount++;
  3075.  
  3076.  
  3077.   XtSetArg (args[argcount], XmNwidth,
  3078.         (XtArgVal) current_server ->
  3079.         SEPERATE_WINDOWS_LIST[button].width);
  3080.   argcount++;
  3081.  
  3082.   XtSetValues (
  3083.         current_server -> SEPERATE_WINDOWS_LIST[button].shell_widget,
  3084.         args, argcount);
  3085.  
  3086.  
  3087. }
  3088.  
  3089.  
  3090.  
  3091. void
  3092. create_drawing_area (button)
  3093.      int             button;
  3094. {
  3095.  
  3096.   Arg             args[32];
  3097.   int             argcount;
  3098.  
  3099.   struct expose_callback_struct *expose_data;
  3100.  
  3101.   struct scrolled_ps_callback_struct *scrolled_ps_callback;
  3102.  
  3103. /*
  3104.  * Create the drawing area and manage it...
  3105.  */
  3106.  
  3107.   argcount = 0;
  3108.   XtSetArg (args[argcount], XmNallowShellResize, True);
  3109.   argcount++;
  3110.   XtSetArg (args[argcount], XmNforeground, foreground);
  3111.   argcount++;
  3112.   XtSetArg (args[argcount], XmNbackground, background);
  3113.   argcount++;
  3114.   XtSetArg (args[argcount], XmNunitType, XmPIXELS);
  3115.   argcount++;
  3116.   XtSetArg (args[argcount], XmNwidth,
  3117.         current_server -> SEPERATE_WINDOWS_LIST[button].draw_width);
  3118.   argcount++;
  3119.   XtSetArg (args[argcount], XmNheight,
  3120.         current_server -> SEPERATE_WINDOWS_LIST[button].draw_height);
  3121.   argcount++;
  3122.  
  3123.   current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW =
  3124.     XmCreateDrawingArea (
  3125.      current_server -> SEPERATE_WINDOWS_LIST[button].main_window_widget,
  3126.               "xsw-draw", args, argcount);
  3127.  
  3128.   XtManageChild (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW);
  3129.  
  3130.  
  3131.  
  3132. /*
  3133.  * Lets create a Pixmap the same size of the drawing area.........
  3134.  */
  3135.  
  3136.  
  3137.   current_server -> SEPERATE_WINDOWS_LIST[button].pixmap =
  3138.     XCreatePixmap (
  3139.       XtDisplay (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW),
  3140.             RootWindowOfScreen (
  3141.       XtScreen (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW)),
  3142.          current_server -> SEPERATE_WINDOWS_LIST[button].draw_width,
  3143.         current_server -> SEPERATE_WINDOWS_LIST[button].draw_height,
  3144.             DefaultDepthOfScreen (
  3145.      XtScreen (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW)));
  3146.  
  3147.  
  3148.  
  3149. /*
  3150.  * Set main window areas....
  3151.  */
  3152.  
  3153.  
  3154.   XmMainWindowSetAreas (
  3155.      current_server -> SEPERATE_WINDOWS_LIST[button].main_window_widget,
  3156.              NULL,
  3157.              NULL,
  3158.              NULL,
  3159.              NULL,
  3160.          current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW);
  3161.  
  3162. /*
  3163.  * Now manage the main window
  3164.  */
  3165.  
  3166.  
  3167.   XtManageChild (
  3168.     current_server -> SEPERATE_WINDOWS_LIST[button].main_window_widget);
  3169.  
  3170.   if ((button == BUTTON_ps_cpu) ||
  3171.       (button == BUTTON_ps_io) ||
  3172.       (button == BUTTON_ps_mem) ||
  3173.       (button == BUTTON_disk_space))
  3174.     {
  3175.  
  3176.  
  3177.       argcount = 0;
  3178.       XtSetArg (args[argcount], XmNhorizontalScrollBar,
  3179.         ¤t_server -> SEPERATE_WINDOWS_LIST[button].hsb);
  3180.       argcount++;
  3181.       XtGetValues (
  3182.      current_server -> SEPERATE_WINDOWS_LIST[button].main_window_widget,
  3183.             args,
  3184.             argcount);
  3185.  
  3186.       argcount = 0;
  3187.       XtSetArg (args[argcount], XmNrepeatDelay,
  3188.         0);
  3189.       argcount++;
  3190.       XtSetValues (
  3191.      current_server -> SEPERATE_WINDOWS_LIST[button].main_window_widget,
  3192.             args,
  3193.             argcount);
  3194.  
  3195.  
  3196.  
  3197.  
  3198.       scrolled_ps_callback =
  3199.     (struct scrolled_ps_callback_struct *)
  3200.     calloc (1,
  3201.         sizeof (struct scrolled_ps_callback_struct));
  3202.  
  3203.       scrolled_ps_callback -> server_pointer = current_server;
  3204.       scrolled_ps_callback -> button_number = button;
  3205.  
  3206.       if (button == BUTTON_ps_cpu)
  3207.     {
  3208.       scrolled_ps_callback -> ps_menu = ps_toggle_button_data;
  3209.       scrolled_ps_callback -> number_of_buttons = XtNumber (ps_toggle_button_data);
  3210.       scrolled_ps_callback -> number_of_screens = XtNumber (ps_cpu_screens);
  3211.     }
  3212.       if (button == BUTTON_ps_mem)
  3213.     {
  3214.       scrolled_ps_callback -> ps_menu = ps_mem_toggle_button_data;
  3215.       scrolled_ps_callback -> number_of_buttons = XtNumber (ps_mem_toggle_button_data);
  3216.       scrolled_ps_callback -> number_of_screens = XtNumber (ps_mem_screens);
  3217.     }
  3218.       if (button == BUTTON_ps_io)
  3219.     {
  3220.       scrolled_ps_callback -> ps_menu = ps_io_toggle_button_data;
  3221.       scrolled_ps_callback -> number_of_buttons = XtNumber (ps_io_toggle_button_data);
  3222.       scrolled_ps_callback -> number_of_screens = XtNumber (ps_io_screens);
  3223.     }
  3224.       if (button == BUTTON_disk_space)
  3225.     {
  3226.       scrolled_ps_callback -> ps_menu = disk_space_toggle_button_data;
  3227.       scrolled_ps_callback -> number_of_buttons = XtNumber (disk_space_toggle_button_data);
  3228.       scrolled_ps_callback -> number_of_screens = XtNumber (disk_space_screens);
  3229.     }
  3230.  
  3231.  
  3232.       XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].hsb,
  3233.              XmNvalueChangedCallback,
  3234.              scrolled_ps,
  3235.              scrolled_ps_callback);
  3236.       XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].hsb,
  3237.              XmNdragCallback,
  3238.              scrolled_ps,
  3239.              scrolled_ps_callback);
  3240.       XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].hsb,
  3241.              XmNincrementCallback,
  3242.              scrolled_ps,
  3243.              scrolled_ps_callback);
  3244.       XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].hsb,
  3245.              XmNdecrementCallback,
  3246.              scrolled_ps,
  3247.              scrolled_ps_callback);
  3248.       XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].hsb,
  3249.              XmNpageDecrementCallback,
  3250.              scrolled_ps,
  3251.              scrolled_ps_callback);
  3252.       XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].hsb,
  3253.              XmNpageIncrementCallback,
  3254.              scrolled_ps,
  3255.              scrolled_ps_callback);
  3256.       XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].hsb,
  3257.              XmNtoTopCallback,
  3258.              scrolled_ps,
  3259.              scrolled_ps_callback);
  3260.       XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].hsb,
  3261.              XmNtoBottomCallback,
  3262.              scrolled_ps,
  3263.              scrolled_ps_callback);
  3264.  
  3265.  
  3266.     }
  3267.  
  3268.  
  3269. /*
  3270.  * Add callbacks.....
  3271.  */
  3272.  
  3273.  
  3274.   expose_data = (struct expose_callback_struct *)
  3275.     calloc (1, sizeof (struct expose_callback_struct));
  3276.  
  3277.   expose_data -> server_pointer = current_server;
  3278.   expose_data -> button_number = button;
  3279.  
  3280.   XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW,
  3281.          XmNresizeCallback, expose_callback,
  3282.          expose_data);
  3283.  
  3284.   XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW,
  3285.          XmNexposeCallback, expose_callback,
  3286.          expose_data);
  3287.  
  3288.   XtAddCallback (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW,
  3289.          XmNinputCallback, input_callback,
  3290.          current_server);
  3291.  
  3292.  
  3293. /*
  3294.  * Pop up the window...
  3295.  */
  3296.  
  3297.   XtPopup (
  3298.   current_server -> SEPERATE_WINDOWS_LIST[button].shell_widget, XtGrabNone);
  3299.  
  3300. /*
  3301.  * Get the window ID, and Graphic Context
  3302.  */
  3303.  
  3304.  
  3305.   current_server -> SEPERATE_WINDOWS_LIST[button].window =
  3306.     XtWindow (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW);
  3307.  
  3308.   current_server -> SEPERATE_WINDOWS_LIST[button].gc =
  3309.     XCreateGC (current_server -> SEPERATE_WINDOWS_LIST[button].display,
  3310.            current_server -> SEPERATE_WINDOWS_LIST[button].window,
  3311.            0,
  3312.            NULL);
  3313.  
  3314. /*
  3315.  * Initialize pixmap....
  3316.  */
  3317.  
  3318.   XSetForeground (
  3319.            current_server -> SEPERATE_WINDOWS_LIST[button].display,
  3320.            current_server -> SEPERATE_WINDOWS_LIST[button].gc,
  3321.            background);
  3322.  
  3323.   XFillRectangle (
  3324.            current_server -> SEPERATE_WINDOWS_LIST[button].display,
  3325.            current_server -> SEPERATE_WINDOWS_LIST[button].pixmap,
  3326.            current_server -> SEPERATE_WINDOWS_LIST[button].gc,
  3327.            0,
  3328.            0,
  3329.            DisplayWidth (display, screen),
  3330.            DisplayHeight (display, screen));
  3331.  
  3332.  
  3333. /*
  3334.  * Set the user data of the drawing area to the graphic context...
  3335.  */
  3336.  
  3337.   argcount = 0;
  3338.   XtSetArg (args[argcount], XmNuserData, current_server ->
  3339.         SEPERATE_WINDOWS_LIST[button].gc);
  3340.   argcount++;
  3341.  
  3342.   XtSetValues (current_server -> SEPERATE_WINDOWS_LIST[button].DrawAreaW,
  3343.            args, argcount);
  3344.  
  3345. /*
  3346.  * Set Foreground, Background, and Font for this server....
  3347.  */
  3348.  
  3349.   XSetForeground (current_server -> SEPERATE_WINDOWS_LIST[button].display,
  3350.           current_server -> SEPERATE_WINDOWS_LIST[button].gc,
  3351.           foreground);
  3352.  
  3353.   XSetBackground (current_server -> SEPERATE_WINDOWS_LIST[button].display,
  3354.           current_server -> SEPERATE_WINDOWS_LIST[button].gc,
  3355.           background);
  3356.  
  3357.   XSetFont (current_server -> SEPERATE_WINDOWS_LIST[button].display,
  3358.         current_server -> SEPERATE_WINDOWS_LIST[button].gc,
  3359.         current_server -> My_font);
  3360.  
  3361. }
  3362.  
  3363.  
  3364. void
  3365. create_seperate_windows_widgets (button)
  3366.      int             button;
  3367.  
  3368. {
  3369.  
  3370.   void            draw_display (int, Window);
  3371.   struct ps_button_callback_struct *scrolled_ps_callback;
  3372.  
  3373.  
  3374.   XDefineCursor (display, XtWindow (toplevel), res.wait_cursor);
  3375.  
  3376.   create_widget_title (button);
  3377.  
  3378.   get_widget_geometry (button);
  3379.  
  3380.   create_shell_widget (button);
  3381.  
  3382.   create_paned_widget (button);
  3383.  
  3384.   create_main_window_widget (button);
  3385.  
  3386. /*
  3387.  
  3388.   create_drawing_area does the following:
  3389.  
  3390.   1) Create drawing area
  3391.   2) Create pixmap
  3392.   3) Set main window area
  3393.   4) Set up scroll bars for those windows that need it.
  3394.   5) Add expose call backs
  3395.   6) Pop up window
  3396.   7) Initialize window context variables
  3397.   8) Initialize pixmap
  3398.   9) Initialize drawing area context
  3399.  10) Set foreground, background, and font for current window.
  3400.  
  3401. */
  3402.  
  3403.   create_drawing_area (button);
  3404.  
  3405.   set_up_shell_size (button);
  3406.  
  3407.   XDefineCursor (display, XtWindow (toplevel), res.cursor);
  3408.  
  3409.   current_server -> SEPERATE_WINDOWS_LIST[button].first_expose = 1;
  3410.  
  3411.  
  3412.   if (button == BUTTON_ps_mem)
  3413.     {
  3414.       read_memory_stats (current_server);
  3415.     }
  3416.  
  3417.  
  3418.   current_server -> SEPERATE_WINDOWS_LIST[button].already_created = 1;
  3419.   current_server -> SEPERATE_WINDOWS_LIST[button].help_color_already_created = 0
  3420.     ;
  3421.  
  3422.  
  3423.   draw_display (1, current_server -> SEPERATE_WINDOWS_LIST[button].window);
  3424.   update_display (1, current_server -> SEPERATE_WINDOWS_LIST[button].window);
  3425.  
  3426.   XtResizeWindow (current_server -> SEPERATE_WINDOWS_LIST[button].shell_widget);
  3427.  
  3428. }
  3429.  
  3430. /* end of sepwin.c */
  3431.