home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / prgramer / adaptor / src / xoptions.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-08  |  25.6 KB  |  722 lines
  1. /**************************************************************************
  2. *                                                                         *
  3. *  Author      : Dr. Thomas Brandes, GMD, I1.HR                           *
  4. *  Date        : Nov 92                                                   *
  5. *  Last Update : Jan 93                                                   *
  6. *                                                                         *
  7. *  Module      : xoptions                                                 *
  8. *                                                                         *
  9. *  Function    : Athena Widgets for setting options of ADAPTOR            *
  10. *                                                                         *
  11. *  Export :                                                               *
  12. *                                                                         *
  13. *  Update :    Jan 93, Werner Meurer, GMD, I1.HR                          *
  14. *                                                                         *
  15. *    - make help available                                                *
  16. *    - split (yes|no)                                                     *
  17. *    - more target machines (CM5, KSR1)                                   *
  18. *    - static size of arrays can be specified                             *
  19. *    - minimal number of processors can be asked for interactively        *
  20. *                                                                         *
  21. **************************************************************************/
  22.  
  23.  
  24. /****************************************************************************
  25. *                                                                           *
  26. *     Options - Menu       -------------------------------------------      *
  27. *                          |                                         |      *
  28. *                          |  Machine  Model  Arrays  Language       |      *
  29. *                          |                                         |      *
  30. *                          -------------------------------------------      *
  31. *                                                                           *
  32. *                                                                           *
  33. ****************************************************************************/
  34.  
  35. #include "xglobal.h"
  36. #include "xhelp.h"
  37. #include "xoptions.h"
  38. #include "xreadint.h"
  39. #include "global.h"
  40.  
  41. bool check_options ();  /* imported from adapt */
  42.  
  43. #define DEBUG(x)    
  44.  
  45. void OptDone();
  46.  
  47. static Widget pshell;  /* global used */
  48.  
  49. static Widget label_machine, label_model, label_array, label_language,
  50.        label_ddefault, label_split, label_minproc;
  51. static Widget menu_machine, menu_model, menu_array, menu_language,
  52.        menu_ddefault, menu_split, menu_minproc;
  53. static Widget top_machine, top_model, top_array, top_language,
  54.        top_ddefault, top_split, top_minproc;
  55.  
  56. static Widget optdialog,optdone,lentry;
  57.  
  58. /***************************************************************************
  59. *                                                                          *
  60. *   Possible Values for the Options                                        *
  61. *                                                                          *
  62. *     most things are imported from global.h                               *
  63. *                                                                          *
  64. ***************************************************************************/
  65.  
  66.  
  67.  
  68. static char minproc_string [10];
  69.  
  70. /***************************************************************************
  71. *                                                                          *
  72. *   Selection Functions for the different Options                          *
  73. *                                                                          *
  74. ***************************************************************************/
  75.  
  76. void select_machine  (w, client_data, garbage)
  77. Widget w;
  78. XtPointer client_data;
  79. XtPointer garbage;  /* call_data */
  80. {   char *name;
  81.     Widget parent;
  82.     name = XtName (w);
  83.     printf("Machine %s has been selected.\n", name);
  84.  
  85.     /* set the new selected value global for translation */
  86.     target_machine = (int) client_data;
  87.  
  88.     /* set the selected label */
  89.     parent = XtParent (w);
  90.     parent = XtParent (parent);
  91.     XtUnmanageChild (parent);
  92.     XtVaSetValues (parent, XtNlabel, name, NULL);
  93.     XtManageChild (parent);
  94. }
  95.  
  96. void select_model  (w, client_data, garbage)
  97. Widget w;
  98. XtPointer client_data;
  99. XtPointer garbage;  /* call_data */
  100. {   char *name;
  101.     Widget parent;
  102.     name = XtName (w);
  103.     printf("Model %s has been selected.\n", name);
  104.  
  105.     /* set the new selected value global for translation */
  106.     target_model = (int) client_data;
  107.  
  108.     /* set the selected label */
  109.     parent = XtParent (w);
  110.     parent = XtParent (parent);
  111.     XtUnmanageChild (parent);
  112.     XtVaSetValues (parent, XtNlabel, name, NULL);
  113.     XtManageChild (parent);
  114. }
  115.  
  116. void set_static(size)
  117. int size;
  118. {
  119.     if (size == 0)
  120.         array_kind = DYNAMIC_ARRAYS; /* dynamic */
  121.     else
  122.     {
  123.         array_kind = STATIC_ARRAYS; /* static */
  124.         StaticArraySize = size;    /* set array size */
  125.     }
  126. }
  127.  
  128. /************************************************************************/
  129. /* get_int_from_widget()                        */
  130. /* INPUT:    w is the widget which called the procedure        */
  131. /*        client_data is the user defined data (parameter)    */
  132. /*        call_data is x-window defined data            */
  133. /* OUTPUT:    failure messages in the message window            */
  134. /************************************************************************/
  135. void get_int_from_widget (w, client_data, garbage)
  136. Widget w;
  137. XtPointer client_data;
  138. XtPointer garbage;  /* call_data */
  139. {   char *name;
  140.     name = XtName (w);
  141. DEBUG(printf("get_int_from_widget\n"));
  142.     if (strcmp(name,array_items[no_array-1]) == 0) /* spezific for array_kind     */
  143.     {
  144.     open_integer_input_window(w,client_data,garbage);
  145.     }
  146. }
  147.  
  148. /************************************************************************/
  149. /* select_array()                            */
  150. /* INPUT:    w is the widget which called the procedure        */
  151. /*        client_data is the user defined data (parameter)    */
  152. /*        call_data is x-window defined data            */
  153. /* OUTPUT:    selected array type                    */
  154. /* The procedure sets array type                     */
  155. /************************************************************************/
  156. void select_array  (w, client_data, garbage)
  157. Widget w;
  158. XtPointer client_data;
  159. XtPointer garbage;  /* call_data */
  160. {
  161.     Widget parent;
  162.     char name[20];
  163. DEBUG(printf("select_array\n"));
  164.     if ((int) client_data == 0)
  165.     strcpy(name,array_items[(int) client_data]);
  166.     else
  167.     sprintf(name,"s=%d",StaticArraySize);
  168.     printf("For Arrays %s has been selected.\n", name);
  169.  
  170.     /* set the new selected value global for translation */
  171.     array_kind = (int) client_data;
  172.  
  173.     /* set the selected label */
  174.     parent = XtParent (w);
  175.     parent = XtParent (parent);
  176.     XtUnmanageChild (parent);
  177.     XtVaSetValues (parent, XtNlabel, name, NULL);
  178.     XtManageChild (parent);
  179. }
  180.  
  181. /************************************************************************/
  182. /* get_int()                                */
  183. /* INPUT:    w is the widget which called the procedure        */
  184. /*        client_data is the user defined data (parameter)    */
  185. /*        call_data is x-window defined data            */
  186. /* OUTPUT:    none                            */
  187. /* The procedure calles the procedures to get an integer input form an    */
  188. /* new window                                 */
  189. /************************************************************************/
  190. void get_int(w,client_data,call_data)
  191. Widget w;
  192. XtPointer client_data;
  193. XtPointer call_data;
  194. {
  195. DEBUG(printf("get_int\n"));
  196.     get_int_from_widget(w,client_data,call_data);
  197.     select_array(w,client_data,call_data);
  198. }
  199.  
  200. /************************************************************************/
  201. /* select_split()                            */
  202. /* INPUT:    w is the widget which called the procedure        */
  203. /*        client_data is the user defined data (parameter)    */
  204. /*        call_data is x-window defined data            */
  205. /* OUTPUT:    Split yes/no                        */
  206. /* sets the split flag                            */
  207. /************************************************************************/
  208. void select_split(w, client_data, garbage)
  209. Widget w;
  210. XtPointer client_data;
  211. XtPointer garbage;  /* call_data */
  212. {   char *name;
  213.     Widget parent;
  214.     name = XtName (w);
  215. DEBUG(printf("select_split\n"));
  216.     printf("Split %s has been selected.\n", name);
  217.  
  218.     /* set the new selected value global for translation */
  219.     split_flag = (int) client_data;
  220.  
  221.     /* set the selected label */
  222.     parent = XtParent (w);
  223.     parent = XtParent (parent);
  224.     XtUnmanageChild (parent);
  225.     XtVaSetValues (parent, XtNlabel, name, NULL);
  226.     XtManageChild (parent);
  227. }
  228.  
  229. void select_language  (w, client_data, garbage)
  230. Widget w;
  231. XtPointer client_data;
  232. XtPointer garbage;  /* call_data */
  233. {   char *name;
  234.     Widget parent;
  235.     name = XtName (w);
  236. DEBUG(printf("select_language\n"));
  237.     printf("Language %s has been selected.\n", name);
  238.  
  239.     /* set the new selected value global for translation */
  240.     target_language = (int) client_data;
  241.  
  242.     /* set the selected label */
  243.     parent = XtParent (w);
  244.     parent = XtParent (parent);
  245.     XtUnmanageChild (parent);
  246.     XtVaSetValues (parent, XtNlabel, name, NULL);
  247.     XtManageChild (parent);
  248. }
  249.  
  250. void select_ddefault  (w, client_data, garbage)
  251. Widget w;
  252. XtPointer client_data;
  253. XtPointer garbage;  /* call_data */
  254. {   char *name;
  255.     Widget parent;
  256.     name = XtName (w);
  257. DEBUG(printf("select_ddefault"));
  258.     printf("Distribution %s has been selected.\n", name);
  259.  
  260.     /* set the new selected value global for translation */
  261.  
  262.     ddefault_kind = (int) client_data;
  263.  
  264.     /* set the selected label */
  265.     parent = XtParent (w);
  266.     parent = XtParent (parent);
  267.     XtUnmanageChild (parent);
  268.     XtVaSetValues (parent, XtNlabel, name, NULL);
  269.     XtManageChild (parent);
  270. }
  271.  
  272. void select_minproc  (w, client_data, garbage)
  273. Widget w;
  274. XtPointer client_data;
  275. XtPointer garbage;  /* call_data */
  276. {   char *name;
  277.     Widget parent;
  278.     int  sdata;
  279.     name = XtName (w);
  280. DEBUG(printf("select_minproc\n"));
  281.     printf("Minimal Procs item %s has been selected.\n", name);
  282.  
  283.     /* set the new selected value global for translation */
  284.     sdata = (int) client_data;
  285.     if (sdata == 0) MinProc = 1;
  286.     if (sdata == 1) MinProc = 2;
  287.     if (sdata == 2) MinProc = 4;
  288.     if (sdata == 3) MinProc = 8;
  289.     if (sdata == 4) MinProc += 1;
  290.     if (sdata == 5) MinProc -= 1;
  291.     if (sdata == 6) MinProc *= 2;
  292.     if (sdata == 7) MinProc /= 2;
  293.     if (MinProc <= 0) MinProc = 1;
  294.     sprintf (minproc_string, "p=%d", MinProc);
  295.  
  296.     /* set the selected label */
  297.     parent = XtParent (w);
  298.     parent = XtParent (parent);
  299.     XtUnmanageChild (parent);
  300.     XtVaSetValues (parent, XtNlabel, minproc_string, NULL);
  301.     XtManageChild (parent);
  302. }
  303.  
  304. /***************************************************************************
  305. *                                                                          *
  306. *   Pop Up of the Options Menu                                             *
  307. *                                                                          *
  308. ***************************************************************************/
  309.  
  310. void PopupOptions(w, client_data, call_data)
  311. Widget w;
  312. XtPointer client_data; /* cast to topLevel */
  313. XtPointer call_data;
  314. {
  315.    Widget poswidget = (Widget) client_data;
  316.    Position x, y;
  317.    Dimension width, height;
  318. DEBUG(printf("PopupOptions\n"));
  319.  
  320.    /* * get the coordinates of the middle of poswidget widget.  */
  321.  
  322.    XtVaGetValues(poswidget,
  323.               XtNwidth, &width,
  324.               XtNheight, &height,
  325.               NULL);
  326.  
  327.    /* translate coordinates in application top-level window
  328.     * into coordinates from root window origin.               */
  329.  
  330.    XtTranslateCoords(poswidget,        /* Widget */
  331.            (Position) width/2,        /* x */
  332.            (Position) height/2,       /* y */
  333.            &x, &y);          /* coords on root window */
  334.  
  335.    /* move popup shell to this position (it's not visible yet) */
  336.  
  337.    XtVaSetValues(pshell,
  338.                    XtNx, x,
  339.                    XtNy, y+70, /* +70 to see the message window */
  340.                    NULL);
  341.  
  342.    XtPopup(pshell, XtGrabNonexclusive);
  343. }
  344.  
  345. /***************************************************************************
  346. *                                                                          *
  347. *   Command for quitting the Opton Menu                                    *
  348. *                                                                          *
  349. ***************************************************************************/
  350.  
  351. void OptDone(w, client_data, call_data)
  352. Widget w;
  353. XtPointer client_data; /* cast to dialog */
  354. XtPointer call_data;
  355. {
  356. DEBUG(printf("OptDone\n"));
  357.     /****************************************************************/
  358.     /* If the window for integer size input is open, you        */
  359.     /* must not quit options                    */
  360.     /****************************************************************/
  361.     if (sshell != 0)
  362.     {
  363.         strcpy(last_message,"Input window for array size is open");
  364.         set_message();
  365.         return;
  366.     }
  367.     if (check_options())
  368.     {
  369.             Widget dialog = (Widget) client_data;
  370.             XtPopdown(pshell);
  371.     }
  372.     else
  373.     {       /* last_message has been set by check_options */
  374.         set_message();
  375.     }
  376. }
  377.  
  378. void GenOptionsShell (topLevel)
  379. Widget topLevel;
  380.  
  381. {
  382.   int i, n;
  383.   Arg args[10];
  384.  
  385. DEBUG(printf("GenOptionsShell\n"));
  386.   pshell = XtVaCreatePopupShell(
  387.           "Options",
  388.           transientShellWidgetClass,
  389.           topLevel,
  390.           NULL);              /* terminate varargs list */
  391.  
  392.   optdialog = XtVaCreateManagedWidget(
  393.               "optdialog",            /* widget name   */
  394.               formWidgetClass,        /* widget class */
  395.               pshell,                 /* parent widget*/
  396.               NULL);                  /* terminate varargs list */
  397.  
  398.   optdone = XtVaCreateManagedWidget(
  399.           "optdone",                      /* widget name   */
  400.           commandWidgetClass,             /* widget class */
  401.           optdialog,                      /* parent widget*/
  402.           XtNlabel, "Quit Options",
  403.           NULL);              /* terminate varargs list */
  404.  
  405.   XtAddCallback (optdone, XtNcallback, OptDone, optdialog);
  406.  
  407.   /********************************************************
  408.   *                                                       *
  409.   *   T A R G E T   M A C H I N E   M E N U               *
  410.   *                                                       *
  411.   ********************************************************/
  412.  
  413.   n = 0;
  414.   XtSetArg (args[n], XtNlabel, "Target Machine  "); n++;
  415.   XtSetArg (args[n], XtNborderWidth, 0); n++;
  416.   XtSetArg (args[n], XtNfromVert, optdone); n++;
  417.  
  418.   label_machine = XtCreateManagedWidget ("Machine", labelWidgetClass,
  419.                           optdialog, args, n);
  420.  
  421.   make_help_available (label_machine);
  422.  
  423.   n = 0;
  424.   XtSetArg (args[n], XtNfromVert, label_machine); n++;
  425.  
  426.   top_machine  = XtCreateManagedWidget(machine_items[target_machine],
  427.                           menuButtonWidgetClass, optdialog,
  428.                           args, n);
  429.  
  430.   menu_machine = XtCreatePopupShell("menu", simpleMenuWidgetClass,
  431.                                     top_machine, NULL, 0);
  432.  
  433.   for (i=0;i<no_machine;i++)
  434.     { lentry = XtCreateManagedWidget (machine_items[i],
  435.                         smeBSBObjectClass, menu_machine, NULL, 0);
  436.       XtAddCallback (lentry, XtNcallback, select_machine, (XtPointer) i);
  437.     }
  438.  
  439.   /********************************************************
  440.   *                                                       *
  441.   *   T A R G E T   M O D E L     M E N U                 *
  442.   *                                                       *
  443.   ********************************************************/
  444.  
  445.   n = 0;
  446.   XtSetArg (args[n], XtNlabel, "Model     "); n++;
  447.   XtSetArg (args[n], XtNborderWidth, 0); n++;
  448.   XtSetArg (args[n], XtNfromVert, optdone); n++;
  449.   XtSetArg (args[n], XtNfromHoriz, label_machine); n++;
  450.  
  451.   label_model = XtCreateManagedWidget ("Model", labelWidgetClass,
  452.                           optdialog, args, n);
  453.  
  454.   make_help_available (label_model);
  455.  
  456.   n = 0;
  457.   XtSetArg (args[n], XtNfromVert, label_model); n++;
  458.   XtSetArg (args[n], XtNfromHoriz, label_machine); n++;
  459.  
  460.   top_model  = XtCreateManagedWidget(model_items[target_model],
  461.                           menuButtonWidgetClass, optdialog,
  462.                           args, n);
  463.  
  464.   menu_model = XtCreatePopupShell("menu", simpleMenuWidgetClass,
  465.                                     top_model, NULL, 0);
  466.  
  467.   for (i=0;i<no_model;i++)
  468.     { lentry = XtCreateManagedWidget (model_items[i],
  469.                         smeBSBObjectClass, menu_model, NULL, 0);
  470.       XtAddCallback (lentry, XtNcallback, select_model, (XtPointer) i);
  471.     }
  472.  
  473.   /********************************************************
  474.   *                                                       *
  475.   *   A R R A Y   K I N D      M E N U                    *
  476.   *                                                       *
  477.   ********************************************************/
  478.  
  479.   n = 0;
  480.   XtSetArg (args[n], XtNlabel, "Arrays     "); n++;
  481.   XtSetArg (args[n], XtNborderWidth, 0); n++;
  482.   XtSetArg (args[n], XtNfromVert, optdone); n++;
  483.   XtSetArg (args[n], XtNfromHoriz, label_model); n++;
  484.  
  485.   label_array = XtCreateManagedWidget ("Arrays", labelWidgetClass,
  486.                           optdialog, args, n);
  487.  
  488.   make_help_available (label_array);
  489.  
  490.   n = 0;
  491.   XtSetArg (args[n], XtNfromVert, label_array); n++;
  492.   XtSetArg (args[n], XtNfromHoriz, label_model); n++;
  493.   if (array_kind == 1)
  494.   {
  495.     char label[MAXLENGTH];
  496.     sprintf(label,"s=%d",StaticArraySize);
  497.     top_array  = XtCreateManagedWidget(label,
  498.                           menuButtonWidgetClass, optdialog,
  499.                           args, n);
  500.   }
  501.   else
  502.   {
  503.     top_array  = XtCreateManagedWidget(array_items[array_kind],
  504.                           menuButtonWidgetClass, optdialog,
  505.                           args, n);
  506.   }
  507.  
  508.   menu_array = XtCreatePopupShell("menu", simpleMenuWidgetClass,
  509.                                     top_array, NULL, 0);
  510.  
  511.   for (i=0;i<no_array;i++)
  512.     { lentry = XtCreateManagedWidget (array_items[i],
  513.                         smeBSBObjectClass, menu_array, NULL, 0);
  514.       XtAddCallback (lentry, XtNcallback,
  515.     get_int, (XtPointer) i);
  516.     }
  517.  
  518.   /********************************************************
  519.   *                                                       *
  520.   *   S P L I T      M E N U                              *
  521.   *                                                       *
  522.   ********************************************************/
  523.  
  524.   n = 0;
  525.   XtSetArg (args[n], XtNlabel, "Split "); n++;
  526.   XtSetArg (args[n], XtNborderWidth, 0); n++;
  527.   XtSetArg (args[n], XtNfromVert, optdone); n++;
  528.   XtSetArg (args[n], XtNfromHoriz, label_array); n++;
  529.  
  530.   label_split = XtCreateManagedWidget ("Split", labelWidgetClass,
  531.                           optdialog, args, n);
  532.  
  533.   make_help_available (label_split);
  534.  
  535.   n = 0;
  536.   XtSetArg (args[n], XtNfromVert, label_split); n++;
  537.   XtSetArg (args[n], XtNfromHoriz, label_array); n++;
  538.  
  539.   top_split= XtCreateManagedWidget(split_items[split_flag],
  540.                           menuButtonWidgetClass, optdialog,
  541.                           args, n);
  542.  
  543.   menu_split= XtCreatePopupShell("menu", simpleMenuWidgetClass,
  544.                                     top_split, NULL, 0);
  545.  
  546.   for (i=0;i<no_split;i++)
  547.     { lentry = XtCreateManagedWidget (split_items[i],
  548.                         smeBSBObjectClass, menu_split, NULL, 0);
  549.       XtAddCallback (lentry, XtNcallback, select_split, (XtPointer) i);
  550.     }
  551.  
  552.   /********************************************************
  553.   *                                                       *
  554.   *   T A R G E T   L A N G U A G E     M E N U           *
  555.   *                                                       *
  556.   ********************************************************/
  557.  
  558.   n = 0;
  559.   XtSetArg (args[n], XtNlabel, "Language   "); n++;
  560.   XtSetArg (args[n], XtNborderWidth, 0); n++;
  561.   XtSetArg (args[n], XtNfromVert, optdone); n++;
  562.   XtSetArg (args[n], XtNfromHoriz, label_split); n++;
  563.  
  564.   label_language = XtCreateManagedWidget ("Language", labelWidgetClass,
  565.                           optdialog, args, n);
  566.  
  567.   make_help_available (label_language);
  568.  
  569.   n = 0;
  570.   XtSetArg (args[n], XtNfromVert, label_language); n++;
  571.   XtSetArg (args[n], XtNfromHoriz, label_split); n++;
  572.  
  573.   top_language  = XtCreateManagedWidget(language_items[target_language],
  574.                           menuButtonWidgetClass, optdialog,
  575.                           args, n);
  576.  
  577.   menu_language = XtCreatePopupShell("menu", simpleMenuWidgetClass,
  578.                                     top_language, NULL, 0);
  579.  
  580.   for (i=0;i<no_language;i++)
  581.     { lentry = XtCreateManagedWidget (language_items[i],
  582.                         smeBSBObjectClass, menu_language, NULL, 0);
  583.       XtAddCallback (lentry, XtNcallback, select_language, (XtPointer) i);
  584.     }
  585.  
  586.   /********************************************************
  587.   *                                                       *
  588.   *   D E F A U L T  D I S T R I B U T I O N   M E N U    *
  589.   *                                                       *
  590.   ********************************************************/
  591.  
  592.   n = 0;
  593.   XtSetArg (args[n], XtNlabel, "Default Dst"); n++;
  594.   XtSetArg (args[n], XtNborderWidth, 0); n++;
  595.   XtSetArg (args[n], XtNfromVert, optdone); n++;
  596.   XtSetArg (args[n], XtNfromHoriz, label_language); n++;
  597.  
  598.   label_ddefault = XtCreateManagedWidget ("Distribution", labelWidgetClass,
  599.                           optdialog, args, n);
  600.  
  601.   make_help_available (label_ddefault);
  602.  
  603.   n = 0;
  604.   XtSetArg (args[n], XtNfromVert, label_ddefault); n++;
  605.   XtSetArg (args[n], XtNfromHoriz, label_language); n++;
  606.  
  607.   top_ddefault  = XtCreateManagedWidget(ddefault_items[ddefault_kind],
  608.                           menuButtonWidgetClass, optdialog,
  609.                           args, n);
  610.  
  611.   menu_ddefault = XtCreatePopupShell("menu", simpleMenuWidgetClass,
  612.                                     top_ddefault, NULL, 0);
  613.  
  614.   for (i=0;i<no_ddefault;i++)
  615.     { lentry = XtCreateManagedWidget (ddefault_items[i],
  616.                         smeBSBObjectClass, menu_ddefault, NULL, 0);
  617.       XtAddCallback (lentry, XtNcallback, select_ddefault, (XtPointer) i);
  618.     }
  619.  
  620.   /********************************************************
  621.   *                                                       *
  622.   *   M i n i m a l    P R O C          M E N U           *
  623.   *                                                       *
  624.   ********************************************************/
  625.  
  626.   /* MinProc global from global.h, minimal number of processors */
  627.   sprintf (minproc_string, "p=%d", MinProc);
  628.  
  629.   n = 0;
  630.   XtSetArg (args[n], XtNlabel, "MinProc"); n++;
  631.   XtSetArg (args[n], XtNborderWidth, 0); n++;
  632.   XtSetArg (args[n], XtNfromVert, optdone); n++;
  633.   XtSetArg (args[n], XtNfromHoriz, label_ddefault); n++;
  634.  
  635.   label_minproc = XtCreateManagedWidget ("MinProc", labelWidgetClass,
  636.                           optdialog, args, n);
  637.  
  638.   make_help_available (label_minproc);
  639.  
  640.   n = 0;
  641.   XtSetArg (args[n], XtNfromVert, label_minproc); n++;
  642.   XtSetArg (args[n], XtNfromHoriz, label_ddefault); n++;
  643.  
  644.   top_minproc  = XtCreateManagedWidget(minproc_string,
  645.                           menuButtonWidgetClass, optdialog,
  646.                           args, n);
  647.  
  648.   menu_minproc = XtCreatePopupShell("menu", simpleMenuWidgetClass,
  649.                                     top_minproc, NULL, 0);
  650.  
  651.   for (i=0;i<(no_minproc - 1);i++)
  652.     { lentry = XtCreateManagedWidget (minproc_items[i],
  653.                         smeBSBObjectClass, menu_minproc, NULL, 0);
  654.       XtAddCallback (lentry, XtNcallback, select_minproc, (XtPointer) i);
  655.     }
  656.   lentry = XtCreateManagedWidget (minproc_items[i],
  657.                     smeBSBObjectClass, menu_minproc, NULL, 0);
  658.   XtAddCallback (lentry, XtNcallback, open_integer_input_window, (XtPointer) i);
  659. DEBUG(printf("GenOptionsShell ende\n"));
  660. }
  661.  
  662. void set_minproc(number)
  663. int number;
  664. {
  665. DEBUG(printf("set_minproc\n"));
  666.     MinProc = number;
  667. }
  668.  
  669. /************************************************************************/
  670. /* integer_init_or_writeback()                        */
  671. /* INPUT:    name is the name of the grandpa's Widget        */
  672. /*        number is the integer value to write back        */
  673. /*        mode is an integer which desides to itit or writeback    */
  674. /*        Its value can be INIT or WRITEBACK            */
  675. /* OUTPUT:    stores the integer value                */
  676. /* return value:    0 if writebackmode                */
  677. /*            init value on initmode                */
  678. /************************************************************************/
  679. int integer_init_or_writeback(name,number,mode)
  680. char *name;
  681. int number;
  682. int mode;
  683. {
  684. DEBUG(printf("integer_init_or_writeback\n"));
  685.  
  686. /* set StaticArraySize or init with its value                */
  687.     if (strcmp(name,array_items[no_array-1]) == 0)
  688.     {
  689.         if (mode == WRITEBACK)
  690.         {
  691.         char array_label[MAXLENGTH];
  692.         set_static(number);
  693.         sprintf (array_label, "s=%d", StaticArraySize);
  694.         /* set the selected label */
  695.         XtUnmanageChild (top_array);
  696.         XtVaSetValues (top_array, XtNlabel, array_label, NULL);
  697.         XtManageChild (top_array);
  698.         }
  699.         else
  700.         return(StaticArraySize);
  701.     }
  702. /* set MinProc and the label of the Widget with MinProc or init with     */
  703. /* its value                                */
  704.     if (strcmp(name,minproc_items[no_minproc-1]) == 0)
  705.     {
  706.         if (mode == WRITEBACK)
  707.         {
  708.         set_minproc(number);
  709.         sprintf (minproc_string, "p=%d", MinProc);
  710.         /* set the selected label */
  711.         XtUnmanageChild (top_minproc);
  712.         XtVaSetValues (top_minproc, XtNlabel, minproc_string, NULL);
  713.         XtManageChild (top_minproc);
  714.         }
  715.         else
  716.         return(MinProc);
  717.     }
  718. /* return 0 on writebackmode                        */
  719. DEBUG(printf("integer_init_or_writeback ende\n"));
  720.     return(0);
  721. }
  722.