home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / xgui / sources / ui_xWidgets.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  45.0 KB  |  1,508 lines
  1. /*****************************************************************************
  2.   FILE           : ui_xWidgets.c
  3.   SHORTNAME      : xWidgets 
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : easy creating of labels, string-edit, buttons, radio-buttons
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Tilman Sommer 
  10.   DATE           : 13.7.1990
  11.  
  12.   CHANGED BY     : Michael Vogt, Guenter Mamier
  13.   IDENTIFICATION : @(#)ui_xWidgets.c    1.23 3/2/94
  14.   SCCS VERSION   : 1.23 
  15.   LAST CHANGE    : 3/2/94  
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20. #include <stdlib.h>
  21. #include <stdio.h>
  22. #include <string.h>
  23.  
  24. #include "ui.h"
  25. #include "ui_action.h"
  26. #include "ui_main.h"
  27. #include "ui_mainP.h"
  28.  
  29. #include <X11/Shell.h>
  30. #include <X11/Xaw/Form.h>
  31. #include <X11/Xaw/List.h>
  32. #include <X11/Xaw/Command.h>
  33. #include <X11/Xaw/Toggle.h>
  34. #include <X11/Xaw/AsciiText.h>
  35. #include <X11/Xaw/AsciiSrc.h>
  36. #include <X11/Xaw/Label.h>
  37. #include <X11/Xaw/MenuButton.h>
  38. #include <X11/Xaw/Scrollbar.h>
  39.  
  40. #ifndef Widgets
  41. #include <X11/Intrinsic.h>
  42. #endif
  43.  
  44.  
  45. #include "windows.xbm"
  46. #include "selected.xbm"
  47. #include "flags.xbm"
  48. #include "ok.xbm"
  49. #include "yes.xbm"
  50. #include "no.xbm"
  51. #include "save.xbm"
  52. #include "load.xbm"
  53. #include "first.xbm"
  54. #include "prev.xbm"
  55. #include "next.xbm"
  56. #include "last.xbm"
  57. #include "def.xbm"
  58. #include "set.xbm"
  59. #include "done.xbm"
  60. #include "select.xbm"
  61. #include "add.xbm"
  62. #include "delete.xbm"
  63. #include "choose.xbm"
  64. #include "new.xbm"
  65. #include "newL.xbm"
  66. #include "look.xbm"
  67. #include "more.xbm"
  68. #include "topics.xbm"
  69. #include "step.xbm"
  70. #include "test.xbm"
  71. #include "stop.xbm"
  72. #include "reset.xbm"
  73. #include "info.xbm"
  74. #include "single.xbm"
  75. #include "all.xbm"
  76. #include "layers.xbm"
  77. #include "setup.xbm"
  78. #include "freeze.xbm"
  79. #include "icon.xbm"
  80. #include "show.xbm"
  81. #include "mode.xbm"
  82. #include "options.xbm"
  83. #include "on.xbm"
  84. #include "off.xbm"
  85. #include "value.xbm"
  86. #include "direction.xbm"
  87. #include "shuffle.xbm"
  88. #include "colors.xbm"
  89. #include "modify.xbm"
  90. #include "goto.xbm"
  91. #include "init.xbm"
  92. #include "connect.xbm"
  93. #include "disconnect.xbm"
  94. #include "standard.xbm"
  95. #include "feedforward.xbm"
  96. #include "net.xbm"
  97. #include "pat.xbm"
  98. #include "cfg.xbm"
  99. #include "txt.xbm"
  100. #include "help.xbm"
  101. #include "print.xbm"
  102. #include "printer.xbm"
  103. #include "postscript.xbm"
  104. #include "eps.xbm"
  105. #include "dina4.xbm"
  106. #include "dina3.xbm"
  107. #include "usletter.xbm"
  108. #include "file.xbm"
  109. #include "portrait.xbm"
  110. #include "landscape.xbm"
  111. #include "network.xbm"
  112. #include "fixed.xbm"
  113. #include "value2.xbm"
  114. #include "rectangle.xbm"
  115. #include "circle.xbm"
  116. #include "solid2.xbm"
  117. #include "trans.xbm"
  118. #include "cancel.xbm"
  119. #include "create.xbm"
  120. #include "append.xbm"
  121. #include "res.xbm"
  122. #include "default.xbm"
  123. #include "text.xbm"
  124. #include "selection.xbm"
  125. #include "background.xbm"
  126. #include "maspar.xbm"
  127. #include "view.xbm"
  128. #include "norm.xbm"
  129. #include "super3d.xbm"
  130. #include "zoomin.xbm"
  131. #include "zoomout.xbm"
  132. #include "winner.xbm"
  133. #include "use.xbm"
  134. #include "delSet.xbm"
  135. #include "subpat.xbm"
  136.  
  137. /* ui_x...FromAsciiWidget */
  138. #define MAX_INPUT_BUFLEN 20
  139.  
  140. #include "ui_xWidgets.ph"
  141.  
  142.  
  143. #ifdef _UNUSED_FUNCTIONS_
  144. /*****************************************************************************
  145.   FUNCTION :  ui_addString
  146.  
  147.   PURPOSE  : adds a string to a specified array of (char *)
  148.   NOTES    : 
  149.   RETURNS  :
  150.   UPDATE   : 1.5.1990
  151. ******************************************************************************/
  152.  
  153.  
  154.  
  155. void ui_addString(char **arrayPtr,int *numItems, int *allocatedItems,char *string)
  156. {
  157.     if (*numItems == *allocatedItems) {
  158.     *allocatedItems += 10;
  159.     arrayPtr = 
  160.         (char **) XtRealloc(*arrayPtr, sizeof(String) * (*allocatedItems));
  161.     }
  162.     arrayPtr[(*numItems)++] = XtNewString(string); 
  163. }
  164.  
  165. #endif
  166.  
  167. /*****************************************************************************
  168.   FUNCTION :  ui_xAddListEntry
  169.  
  170.   PURPOSE  : adds a list entry to the specified list-widget
  171.   NOTES    : Changed version of the function Okay in the example program
  172.              xwidgets.c of the Athena Toolkit.
  173.   RETURNS  : void
  174.   UPDATE   : 1.5.1990
  175. ******************************************************************************/
  176.  
  177.  
  178.  
  179. void ui_xAddListEntry(struct SimpleListType *listDescriptorPtr,String string)
  180. {
  181.     if (listDescriptorPtr->noOfItems == listDescriptorPtr->noOfAllocItems) {
  182.     listDescriptorPtr->noOfAllocItems += 10;
  183.      (listDescriptorPtr->listPtr) = 
  184.         (String *) XtRealloc((char *) listDescriptorPtr->listPtr, 
  185.                  (unsigned int) sizeof(String *) * listDescriptorPtr->noOfAllocItems);
  186.     }
  187.     (listDescriptorPtr->listPtr)[(listDescriptorPtr->noOfItems)++] = 
  188.     XtNewString(string); 
  189.     XawListChange(listDescriptorPtr->listWidget, listDescriptorPtr->listPtr, 
  190.           listDescriptorPtr->noOfItems, 0, True);
  191. }
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  
  198. /*****************************************************************************
  199.   FUNCTION :                   ui_xSetResize
  200.  
  201.   PURPOSE  : used to set the resize resource of a asciiText widget
  202.   NOTES    :
  203.   RETURNS  : void
  204.   UPDATE   :
  205. *****************************************************************************/
  206.  
  207. void ui_xSetResize(Widget widget,Boolean state)
  208. {
  209.     Cardinal      n;
  210.     Arg           args[3];
  211.  
  212.     n = 0;
  213.     if (state) 
  214.     XtSetArg(args[n], XtNresize, XawtextResizeWidth);
  215.     else 
  216.     XtSetArg(args[n], XtNresize, XawtextResizeNever);
  217.     
  218.     n++;
  219.     XtSetArg(args[n], XtNresizable, state); n++;
  220.     XtSetValues(widget, args, n);
  221. }
  222.  
  223.  
  224. /*****************************************************************************
  225.   FUNCTION :                   ui_xSetLabel
  226.  
  227.   PURPOSE  : used to set the label of a widget
  228.   NOTES    :
  229.   RETURNS  : void
  230.   UPDATE   :
  231. *****************************************************************************/
  232.  
  233. void ui_xSetLabel(Widget widget,char *newLabel)
  234. {
  235.     Cardinal      n;
  236.     Arg           args[2];
  237.  
  238.     n = 0;
  239.     XtSetArg(args[n], XtNlabel, newLabel); n++;
  240.     XtSetValues(widget, args, n);
  241. }
  242.  
  243.  
  244.  
  245. /*****************************************************************************
  246.   FUNCTION :                   ui_xSetString
  247.  
  248.   PURPOSE  : used to set the string resource of a widget
  249.   NOTES    :
  250.   RETURNS  : void
  251.   UPDATE   :
  252. *****************************************************************************/
  253.  
  254. void ui_xSetString(Widget widget,char *contents)
  255. {
  256.     Cardinal      n;
  257.     Arg           args[3];
  258.     uint           lenContents;
  259.     char          editBuf[61];
  260.  
  261.     if (contents == NULL)
  262.     lenContents = 0;
  263.     else {
  264.     lenContents = strlen(contents);
  265.     if (lenContents > 60) lenContents = 60;
  266.     strncpy(editBuf,contents,lenContents);
  267.     }
  268.  
  269.     editBuf[lenContents] = '\0';
  270.  
  271.     n = 0;
  272.     XtSetArg(args[n], XtNstring,editBuf); n++;
  273.     XtSetArg(args[n], XtNinsertPosition, lenContents); n++;
  274.     XtSetValues(widget, args, n);
  275. }
  276.  
  277.  
  278.  
  279.  
  280. /*****************************************************************************
  281.   FUNCTION : ui_xStringFromAsciiWidget
  282.  
  283.   PURPOSE  : used to get a string from an ascii widget
  284.   NOTES    :
  285.   RETURNS  : void
  286.   UPDATE   :
  287. *****************************************************************************/
  288.  
  289. void ui_xStringFromAsciiWidget(Widget widget,char *stringVar,int maxLen)
  290. {
  291.     Widget        asciiSrc;
  292.     XawTextBlock  textBlock;
  293.     Cardinal      n;
  294.     Arg           args[5];
  295.  
  296.     n = 0;
  297.     XtSetArg(args[n], XtNtextSource, &asciiSrc); n++;
  298.     XtGetValues(widget, args, n);
  299.     
  300.     (void) XawTextSourceRead(asciiSrc, 0, &textBlock, maxLen-1);
  301.  
  302.     if (textBlock.length > maxLen-1) 
  303.     textBlock.length = maxLen-1;
  304.     
  305.     strncpy(stringVar, textBlock.ptr,(uint) textBlock.length);
  306.     stringVar[textBlock.length] = '\0';  /* this is for safeness */
  307. }
  308.  
  309.  
  310.     
  311.  
  312.  
  313.  
  314. /*****************************************************************************
  315.   FUNCTION : ui_xFloatFromAsciiWidget
  316.  
  317.   PURPOSE  : used to get a string from a PANEL_TEXT item and transform it
  318.              to an float.
  319.   NOTES    :
  320.   RETURNS  : The numerical value hold from panelItem
  321.   UPDATE   :
  322. *****************************************************************************/
  323.  
  324. float ui_xFloatFromAsciiWidget(Widget widget)
  325. {
  326.     Widget        asciiSrc;
  327.     XawTextBlock  textBlock;
  328.     char          buf[MAX_INPUT_BUFLEN + 1];
  329.     Cardinal      n;
  330.     Arg           args[5];
  331.     float         rVal;
  332.  
  333.     n = 0;
  334.     XtSetArg(args[n], XtNtextSource, &asciiSrc); n++;
  335.     XtGetValues(widget, args, n);
  336.     
  337.     (void) XawTextSourceRead(asciiSrc, 0, &textBlock, MAX_INPUT_BUFLEN);
  338.  
  339.     if (textBlock.length > MAX_INPUT_BUFLEN) 
  340.     textBlock.length = MAX_INPUT_BUFLEN;
  341.     
  342.     strncpy(buf, textBlock.ptr, (uint) textBlock.length);
  343.     buf[textBlock.length] = '\0';  /* this is for safeness */
  344.     if (strlen(buf) == 0) return(0.0);
  345.     else {
  346.     sscanf(buf,"%f", &rVal);
  347.     return(rVal);
  348.     }
  349. }
  350.  
  351.  
  352. /*****************************************************************************
  353.   FUNCTION : ui_xUtilIntFromAsciiWidget
  354.  
  355.   PURPOSE  : used to get a string from a PANEL_TEXT item and transform it
  356.              to an integer.
  357.   NOTES    :
  358.   RETURNS  : The numerical value hold from panelItem
  359.   UPDATE   :
  360. *****************************************************************************/
  361.  
  362. int ui_xIntFromAsciiWidget(Widget widget)
  363. {
  364.     Widget        asciiSrc;
  365.     XawTextBlock  textBlock;
  366.     char          buf[MAX_INPUT_BUFLEN + 1];
  367.     Cardinal      n;
  368.     Arg           args[5];
  369.  
  370.     n = 0;
  371.     XtSetArg(args[n], XtNtextSource, &asciiSrc); n++;
  372.     XtGetValues(widget, args, n);
  373.     
  374.     (void) XawTextSourceRead(asciiSrc, 0, &textBlock, MAX_INPUT_BUFLEN);
  375.  
  376.     if (textBlock.length > MAX_INPUT_BUFLEN) 
  377.     textBlock.length = MAX_INPUT_BUFLEN;
  378.     
  379.     strncpy(buf, textBlock.ptr,(uint) textBlock.length);
  380.     buf[textBlock.length] = '\0';  /* this is for safeness */
  381.     if (strlen(buf) == 0) return(0);
  382.     else return(atoi(buf));
  383. }
  384.  
  385.  
  386.  
  387.  
  388.  
  389. /*****************************************************************************
  390.   FUNCTION : ui_xGetDimensions
  391.  
  392.   PURPOSE  : get width and height of specified widget
  393.   NOTES    :
  394.   RETURNS  : void
  395.   UPDATE   : 1.2.1990
  396. ******************************************************************************/
  397.  
  398. void ui_xGetDimensions(Widget widget,Dimension *width,Dimension *height)
  399. {
  400.     Cardinal   n;
  401.     Arg           args[15];
  402.  
  403.     n = 0;
  404.     XtSetArg(args[n], XtNwidth,  width); n++;
  405.     XtSetArg(args[n], XtNheight, height); n++;
  406.     XtGetValues(widget, args, n);
  407. }
  408.  
  409.  
  410.  
  411. /*****************************************************************************
  412.   FUNCTION : ui_xGetToggleState
  413.  
  414.   PURPOSE  : returns the state of the specified toggle
  415.   NOTES    : TRUE means PUSHED;
  416.  
  417.   RETURNS  : State of the Toggle
  418.   UPDATE   : 26.8.1990
  419. ******************************************************************************/
  420.  
  421. Bool ui_xGetToggleState(Widget w)
  422. {
  423.     Cardinal  n;
  424.     Arg       args[2];
  425.     Boolean   state;
  426.  
  427.     n=0;
  428.     XtSetArg(args[n], XtNstate, &state); n++;
  429.     XtGetValues(w, args, n);
  430.     return(state == TRUE); /* prevents compatibiltiy problems */
  431. }
  432.  
  433.  
  434.  
  435.  
  436. /*****************************************************************************
  437.   FUNCTION : ui_xSetToggleState
  438.  
  439.   PURPOSE  : sets the state of the specified toggle
  440.   NOTES    : 
  441.   RETURNS  : void
  442.   UPDATE   : 26.8.1990
  443. ******************************************************************************/
  444.  
  445. void ui_xSetToggleState(Widget w,Bool state)
  446. {
  447.     Cardinal n;
  448.     Arg       args[2];
  449.  
  450.     n=0;
  451.     XtSetArg(args[n], XtNstate, (Boolean) state); n++;
  452.     XtSetValues(w, args, n);
  453. }
  454.  
  455.  
  456.  
  457.  
  458. /*****************************************************************************
  459.   FUNCTION : ui_xCreateLabelItem
  460.  
  461.   PURPOSE  : create a label widget
  462.   NOTES    :
  463.   RETURNS  : The Widgetnumber of the Label
  464.   UPDATE   : 15.5.1990
  465. ******************************************************************************/
  466.  
  467.  
  468. Widget   ui_xCreateLabelItem(char *name,Widget parent,Dimension width,Widget left,Widget top)
  469. { 
  470.     Cardinal n;
  471.     Widget   w;
  472.     Arg         args[15];
  473.  
  474.     n = 0;
  475.     if (strcmp(name,"noSel") == 0) {
  476.     XtSetArg(args[n], XtNbitmap, 
  477.          (Pixmap) XCreateBitmapFromData(ui_display, 
  478.                         XDefaultRootWindow(ui_display),
  479.                         selected_bits, selected_width,
  480.                         selected_height)); n++;
  481.     }
  482.     if (strcmp(name,"flags") == 0) {
  483.     XtSetArg(args[n], XtNbitmap, 
  484.          (Pixmap) XCreateBitmapFromData(ui_display, 
  485.                         XDefaultRootWindow(ui_display),
  486.                         flags_bits, flags_width,
  487.                         flags_height)); n++;
  488.     }    
  489.     XtSetArg(args[n], XtNborderWidth, 0); n++;
  490.     if (width != 0) {
  491.     XtSetArg(args[n], XtNwidth, (XtArgVal) width); n++;
  492.     XtSetArg(args[n], XtNresize, FALSE); n++;
  493.     } else {
  494.     XtSetArg(args[n], XtNresizable, True); n++;    
  495.     XtSetArg(args[n], XtNresize,    TRUE); n++;
  496.     }
  497.     XtSetArg(args[n], XtNjustify, XtJustifyLeft); n++;
  498. /*    XtSetArg(args[n], XtNinternalHeight, 1); n++;
  499.     XtSetArg(args[n], XtNinternalWidth , 1); n++;
  500. */    XtSetArg(args[n], XtNfromHoriz, left); n++;
  501.     XtSetArg(args[n], XtNfromVert , top);  n++;
  502.     XtSetArg(args[n], XtNleft  , XtChainLeft); n++;
  503.     XtSetArg(args[n], XtNright , XtChainLeft); n++;
  504.     XtSetArg(args[n], XtNtop   , XtChainTop); n++;
  505.     XtSetArg(args[n], XtNbottom, XtChainTop); n++;
  506.     w = XtCreateManagedWidget(name, labelWidgetClass, parent, args, n);
  507.     return(w);
  508. }
  509.  
  510. /*****************************************************************************
  511.   FUNCTION : ui_xCreateFrameLabelItem
  512.  
  513.   PURPOSE  : create a label widget
  514.   NOTES    :
  515.   RETURNS  : The Widgetnumber of the Label
  516.   UPDATE   : 15.5.1990
  517. ******************************************************************************/
  518. Widget   ui_xCreateFrameLabelItem(char *name,Widget parent,Dimension width,Widget left,Widget top)
  519. { 
  520.     Cardinal n;
  521.     Widget   w;
  522.     Arg         args[15];
  523.  
  524.     n = 0;
  525.     if (strcmp(name,"noSel") == 0) {
  526.     XtSetArg(args[n], XtNbitmap, 
  527.          (Pixmap) XCreateBitmapFromData(ui_display, 
  528.                         XDefaultRootWindow(ui_display),
  529.                         selected_bits, selected_width,
  530.                         selected_height)); n++;
  531.     }
  532.     if (strcmp(name,"flags") == 0) {
  533.     XtSetArg(args[n], XtNbitmap, 
  534.          (Pixmap) XCreateBitmapFromData(ui_display, 
  535.                         XDefaultRootWindow(ui_display),
  536.                         flags_bits, flags_width,
  537.                         flags_height)); n++;
  538.     }    
  539.     XtSetArg(args[n], XtNborderWidth, 1); n++;
  540.     if (width != 0) {
  541.     XtSetArg(args[n], XtNheight, 17); n++;
  542.     XtSetArg(args[n], XtNwidth, (XtArgVal) width); n++;
  543.     XtSetArg(args[n], XtNresize, FALSE); n++;
  544.     } else {
  545.     XtSetArg(args[n], XtNresizable, True); n++;    
  546.     XtSetArg(args[n], XtNresize,    TRUE); n++;
  547.     }
  548.     XtSetArg(args[n], XtNjustify, XtJustifyLeft); n++;
  549.     XtSetArg(args[n], XtNinternalHeight, 3); n++;
  550.     XtSetArg(args[n], XtNinternalWidth , 4); n++;
  551.     XtSetArg(args[n], XtNfromHoriz, left); n++;
  552.     XtSetArg(args[n], XtNfromVert , top);  n++;
  553.     XtSetArg(args[n], XtNleft  , XtChainLeft); n++;
  554.     XtSetArg(args[n], XtNright , XtChainLeft); n++;
  555.     XtSetArg(args[n], XtNtop   , XtChainTop); n++;
  556.     XtSetArg(args[n], XtNbottom, XtChainTop); n++;
  557.     w = XtCreateManagedWidget(name, labelWidgetClass, parent, args, n);
  558.     return(w);
  559. }
  560.  
  561.  
  562.  
  563.  
  564. /*****************************************************************************
  565.   FUNCTION : ui_xCreateDialogItem
  566.  
  567.   PURPOSE  : create an ascii text widget (edit type = string)
  568.   NOTES    :
  569.   RETURNS  : The Widgetnumber of the text Widget
  570.   UPDATE   : 1.2.1990
  571. ******************************************************************************/
  572.  
  573.  
  574.  
  575. Widget  ui_xCreateDialogItem(char *name,Widget parent,char *contents,Dimension  width,Widget left,Widget top)
  576. { 
  577.     Cardinal        n;
  578.     Widget          w;
  579.     Arg                args[25];
  580.     char            buf[61];
  581.     static XtActionsRec  ActionRec [] = {{"ui_noreturn",(XtActionProc) ui_noreturn}};
  582.     XtTranslations Translation;
  583.  
  584.     uint lenContents;
  585.  
  586.     if (contents == NULL) 
  587.     lenContents = 0;
  588.     else {
  589.     lenContents = strlen(contents);
  590.     if (lenContents > 60) lenContents = 60;
  591.     }
  592.     strncpy(buf,contents,lenContents);
  593.     buf[lenContents] = '\0';
  594.  
  595.  
  596.     n = 0;
  597.     XtSetArg(args[n], XtNborderWidth,  1); n++;
  598.     XtSetArg(args[n], XtNstring   , buf); n++;
  599.     if (width != 0) {
  600.     XtSetArg(args[n], XtNresize   , XawtextResizeNever); n++;
  601.     XtSetArg(args[n], XtNwidth    , width);  n++;
  602.     } else {
  603.     XtSetArg(args[n], XtNwidth    , 8*lenContents + 20);  n++;
  604.     XtSetArg(args[n], XtNresizable, True); n++;    
  605.     XtSetArg(args[n], XtNresize   , XawtextResizeWidth); n++;
  606.     }    
  607.     XtSetArg(args[n], XtNscrollHorizontal, XawtextScrollNever); n++;
  608.     XtSetArg(args[n], XtNscrollVertical  , XawtextScrollNever); n++;
  609.     XtSetArg(args[n], XtNinsertPosition  , lenContents);  n++;
  610.     XtSetArg(args[n], XtNeditType , XawtextEdit);  n++;
  611.     XtSetArg(args[n], XtNtype     , XawAsciiString);  n++;
  612.     XtSetArg(args[n], XtNfromVert , top);  n++;
  613.     XtSetArg(args[n], XtNfromHoriz, left);  n++;
  614.     XtSetArg(args[n], XtNleft  , XtChainLeft); n++;
  615.     XtSetArg(args[n], XtNright , XtChainLeft); n++;
  616.     XtSetArg(args[n], XtNtop   , XtChainTop); n++;
  617.     XtSetArg(args[n], XtNbottom, XtChainTop); n++;
  618.     w = XtCreateManagedWidget(name, asciiTextWidgetClass, parent, args, n);
  619. #ifndef _HPUX_SOURCE
  620.     XtAppAddActions (ui_appContext, ActionRec, XtNumber (ActionRec));
  621.     Translation = XtParseTranslationTable ("<Key>Return: ui_noreturn()");
  622.     XtOverrideTranslations (w, Translation);
  623. #endif
  624.     return(w);
  625. }
  626.  
  627.  
  628.  
  629. /*****************************************************************************
  630.   FUNCTION : ui_xCreateButtonItem
  631.  
  632.   PURPOSE  : create a command widget
  633.   NOTES    :
  634.   RETURNS  : The Widgetnumber of the command widget
  635.   UPDATE   : 18.5.1990
  636. ******************************************************************************/
  637.  
  638. Widget  ui_xCreateButtonItem(char *name,Widget parent,Widget left,Widget top)
  639. { 
  640.     Cardinal n;
  641.     Widget   w;
  642.     Arg         args[15];
  643.  
  644.     n = 0;
  645.     if (strcmp(name,"init") == 0) {
  646.     XtSetArg(args[n], XtNbitmap, 
  647.          (Pixmap) XCreateBitmapFromData(ui_display, 
  648.                         XDefaultRootWindow(ui_display),
  649.                         init_bits, init_width,
  650.                         init_height)); n++;
  651.     }
  652.     if (strcmp(name,"goto") == 0) {
  653.     XtSetArg(args[n], XtNbitmap, 
  654.          (Pixmap) XCreateBitmapFromData(ui_display, 
  655.                         XDefaultRootWindow(ui_display),
  656.                         goto_bits, goto_width,
  657.                         goto_height)); n++;
  658.     }
  659.     if (strcmp(name,"modify") == 0) {
  660.     XtSetArg(args[n], XtNbitmap, 
  661.          (Pixmap) XCreateBitmapFromData(ui_display, 
  662.                         XDefaultRootWindow(ui_display),
  663.                         modify_bits, modify_width,
  664.                         modify_height)); n++;
  665.     }
  666.     if (strcmp(name,"ok") == 0) {
  667.     XtSetArg(args[n], XtNbitmap, 
  668.          (Pixmap) XCreateBitmapFromData(ui_display, 
  669.                         XDefaultRootWindow(ui_display),
  670.                         ok_bits, ok_width,
  671.                         ok_height)); n++;
  672.     }
  673.     if (strcmp(name,"yes") == 0) {
  674.     XtSetArg(args[n], XtNbitmap, 
  675.          (Pixmap) XCreateBitmapFromData(ui_display, 
  676.                         XDefaultRootWindow(ui_display),
  677.                         yes_bits, yes_width,
  678.                         yes_height)); n++;
  679.     }
  680.     if (strcmp(name,"no") == 0) {
  681.     XtSetArg(args[n], XtNbitmap, 
  682.          (Pixmap) XCreateBitmapFromData(ui_display, 
  683.                         XDefaultRootWindow(ui_display),
  684.                         no_bits, no_width,
  685.                         no_height)); n++;
  686.     }
  687.     if (strcmp(name,"save") == 0) {
  688.     XtSetArg(args[n], XtNbitmap, 
  689.          (Pixmap) XCreateBitmapFromData(ui_display, 
  690.                         XDefaultRootWindow(ui_display),
  691.                         save_bits, save_width,
  692.                         save_height)); n++;
  693.     }
  694.     if (strcmp(name,"load") == 0) {
  695.     XtSetArg(args[n], XtNbitmap, 
  696.          (Pixmap) XCreateBitmapFromData(ui_display, 
  697.                         XDefaultRootWindow(ui_display),
  698.                         load_bits, load_width,
  699.                         load_height)); n++;
  700.     }
  701.     if (strcmp(name,"first") == 0) {
  702.     XtSetArg(args[n], XtNbitmap, 
  703.          (Pixmap) XCreateBitmapFromData(ui_display, 
  704.                         XDefaultRootWindow(ui_display),
  705.                         first_bits, first_width,
  706.                         first_height)); n++;
  707.     }
  708.     if (strcmp(name,"prev") == 0) {
  709.     XtSetArg(args[n], XtNbitmap, 
  710.          (Pixmap) XCreateBitmapFromData(ui_display, 
  711.                         XDefaultRootWindow(ui_display),
  712.                         prev_bits, prev_width,
  713.                         prev_height)); n++;
  714.     }
  715.     if (strcmp(name,"next") == 0) {
  716.     XtSetArg(args[n], XtNbitmap, 
  717.          (Pixmap) XCreateBitmapFromData(ui_display, 
  718.                         XDefaultRootWindow(ui_display),
  719.                         next_bits, next_width,
  720.                         next_height)); n++;
  721.     }
  722.     if (strcmp(name,"last") == 0) {
  723.     XtSetArg(args[n], XtNbitmap, 
  724.          (Pixmap) XCreateBitmapFromData(ui_display, 
  725.                         XDefaultRootWindow(ui_display),
  726.                         last_bits, last_width,
  727.                         last_height)); n++;
  728.     }
  729.     if (strcmp(name,"default") == 0) {
  730.     XtSetArg(args[n], XtNbitmap, 
  731.          (Pixmap) XCreateBitmapFromData(ui_display, 
  732.                         XDefaultRootWindow(ui_display),
  733.                         def_bits, def_width,
  734.                         def_height)); n++;
  735.     }
  736.     if (strcmp(name,"set") == 0) {
  737.     XtSetArg(args[n], XtNbitmap, 
  738.          (Pixmap) XCreateBitmapFromData(ui_display, 
  739.                         XDefaultRootWindow(ui_display),
  740.                         set_bits, set_width,
  741.                         set_height)); n++;
  742.     }
  743.     if (strcmp(name,"done") == 0) {
  744.     XtSetArg(args[n], XtNbitmap, 
  745.          (Pixmap) XCreateBitmapFromData(ui_display, 
  746.                         XDefaultRootWindow(ui_display),
  747.                         done_bits, done_width,
  748.                         done_height)); n++;
  749.     }
  750.     if (strcmp(name,"select") == 0) {
  751.     XtSetArg(args[n], XtNbitmap, 
  752.          (Pixmap) XCreateBitmapFromData(ui_display, 
  753.                         XDefaultRootWindow(ui_display),
  754.                         select_bits, select_width,
  755.                         select_height)); n++;
  756.     }
  757.     if (strcmp(name,"add") == 0) {
  758.     XtSetArg(args[n], XtNbitmap, 
  759.          (Pixmap) XCreateBitmapFromData(ui_display, 
  760.                         XDefaultRootWindow(ui_display),
  761.                         add_bits, add_width,
  762.                         add_height)); n++;
  763.     }
  764.     if (strcmp(name,"delete") == 0) {
  765.     XtSetArg(args[n], XtNbitmap, 
  766.          (Pixmap) XCreateBitmapFromData(ui_display, 
  767.                         XDefaultRootWindow(ui_display),
  768.                         delete_bits, delete_width,
  769.                         delete_height)); n++;
  770.     }
  771.     if (strcmp(name,"choose") == 0) {
  772.     XtSetArg(args[n], XtNbitmap, 
  773.          (Pixmap) XCreateBitmapFromData(ui_display, 
  774.                         XDefaultRootWindow(ui_display),
  775.                         choose_bits, choose_width,
  776.                         choose_height)); n++;
  777.     }
  778.     if (strcmp(name,"new") == 0) {
  779.     XtSetArg(args[n], XtNbitmap, 
  780.          (Pixmap) XCreateBitmapFromData(ui_display, 
  781.                         XDefaultRootWindow(ui_display),
  782.                         new_bits, new_width,
  783.                         new_height)); n++;
  784.     }
  785.     if (strcmp(name,"newL") == 0) {
  786.     XtSetArg(args[n], XtNbitmap, 
  787.          (Pixmap) XCreateBitmapFromData(ui_display, 
  788.                         XDefaultRootWindow(ui_display),
  789.                         newL_bits, newL_width,
  790.                         newL_height)); n++;
  791.     }
  792.     if (strcmp(name,"look") == 0) {
  793.     XtSetArg(args[n], XtNbitmap, 
  794.          (Pixmap) XCreateBitmapFromData(ui_display, 
  795.                         XDefaultRootWindow(ui_display),
  796.                         look_bits, look_width,
  797.                         look_height)); n++;
  798.     }
  799.     if (strcmp(name,"more") == 0) {
  800.     XtSetArg(args[n], XtNbitmap, 
  801.          (Pixmap) XCreateBitmapFromData(ui_display, 
  802.                         XDefaultRootWindow(ui_display),
  803.                         more_bits, more_width,
  804.                         more_height)); n++;
  805.     }
  806.     if (strcmp(name,"topics") == 0) {
  807.     XtSetArg(args[n], XtNbitmap, 
  808.          (Pixmap) XCreateBitmapFromData(ui_display, 
  809.                         XDefaultRootWindow(ui_display),
  810.                         topics_bits, topics_width,
  811.                         topics_height)); n++;
  812.     }
  813.     if (strcmp(name,"multiStep") == 0) {
  814.     XtSetArg(args[n], XtNbitmap, 
  815.          (Pixmap) XCreateBitmapFromData(ui_display, 
  816.                         XDefaultRootWindow(ui_display),
  817.                         step_bits, step_width,
  818.                         step_height)); n++;
  819.     }
  820.     if (strcmp(name,"stop") == 0) {
  821.     XtSetArg(args[n], XtNbitmap, 
  822.          (Pixmap) XCreateBitmapFromData(ui_display, 
  823.                         XDefaultRootWindow(ui_display),
  824.                         stop_bits, stop_width,
  825.                         stop_height)); n++;
  826.     }
  827.     if (strcmp(name,"reset") == 0) {
  828.     XtSetArg(args[n], XtNbitmap, 
  829.          (Pixmap) XCreateBitmapFromData(ui_display, 
  830.                         XDefaultRootWindow(ui_display),
  831.                         reset_bits, reset_width,
  832.                         reset_height)); n++;
  833.     }
  834.     if (strcmp(name,"info") == 0) {
  835.     XtSetArg(args[n], XtNbitmap, 
  836.          (Pixmap) XCreateBitmapFromData(ui_display, 
  837.                         XDefaultRootWindow(ui_display),
  838.                         info_bits, info_width,
  839.                         info_height)); n++;
  840.     }
  841.     if (strcmp(name,"single") == 0) {
  842.     XtSetArg(args[n], XtNbitmap, 
  843.          (Pixmap) XCreateBitmapFromData(ui_display, 
  844.                         XDefaultRootWindow(ui_display),
  845.                         single_bits, single_width,
  846.                         single_height)); n++;
  847.     }
  848.     if (strcmp(name,"all") == 0) {
  849.     XtSetArg(args[n], XtNbitmap, 
  850.          (Pixmap) XCreateBitmapFromData(ui_display, 
  851.                         XDefaultRootWindow(ui_display),
  852.                         all_bits, all_width,
  853.                         all_height)); n++;
  854.     }
  855.     if (strcmp(name,"test") == 0) {
  856.     XtSetArg(args[n], XtNbitmap, 
  857.          (Pixmap) XCreateBitmapFromData(ui_display, 
  858.                         XDefaultRootWindow(ui_display),
  859.                         test_bits, test_width,
  860.                         test_height)); n++;
  861.     }
  862.     if (strcmp(name,"layers") == 0) {
  863.     XtSetArg(args[n], XtNbitmap, 
  864.          (Pixmap) XCreateBitmapFromData(ui_display, 
  865.                         XDefaultRootWindow(ui_display),
  866.                         layers_bits, layers_width,
  867.                         layers_height)); n++;
  868.     }
  869.     if (strcmp(name,"setup") == 0) {
  870.     XtSetArg(args[n], XtNbitmap, 
  871.          (Pixmap) XCreateBitmapFromData(ui_display, 
  872.                         XDefaultRootWindow(ui_display),
  873.                         setup_bits, setup_width,
  874.                         setup_height)); n++;
  875.     }
  876.     if (strcmp(name,"help") == 0) {
  877.     XtSetArg(args[n], XtNbitmap, 
  878.          (Pixmap) XCreateBitmapFromData(ui_display, 
  879.                         XDefaultRootWindow(ui_display),
  880.                         help_bits, help_width,
  881.                         help_height)); n++;
  882.     }
  883.     if (strcmp(name,"print") == 0) {
  884.     XtSetArg(args[n], XtNbitmap, 
  885.          (Pixmap) XCreateBitmapFromData(ui_display, 
  886.                         XDefaultRootWindow(ui_display),
  887.                         print_bits, print_width,
  888.                         print_height)); n++;
  889.     }
  890.     if (strcmp(name,"network") == 0) {
  891.     XtSetArg(args[n], XtNbitmap, 
  892.          (Pixmap) XCreateBitmapFromData(ui_display, 
  893.                         XDefaultRootWindow(ui_display),
  894.                         network_bits, network_width,
  895.                         network_height)); n++;
  896.     }
  897.     if (strcmp(name,"default2") == 0) {
  898.         XtSetArg(args[n], XtNbitmap, 
  899.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  900.                                                 XDefaultRootWindow(ui_display),
  901.                                                 default_bits, default_width,
  902.                                                default_height)); n++;
  903.     }
  904.     if (strcmp(name,"cancel") == 0) {
  905.         XtSetArg(args[n], XtNbitmap, 
  906.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  907.                                                 XDefaultRootWindow(ui_display),
  908.                                                 cancel_bits, cancel_width,
  909.                                                 cancel_height)); n++;
  910.     }
  911.     if (strcmp(name,"color") == 0) {
  912.     XtSetArg(args[n], XtNbitmap, 
  913.          (Pixmap) XCreateBitmapFromData(ui_display, 
  914.                         XDefaultRootWindow(ui_display),
  915.                         color_bits, color_width,
  916.                         color_height)); n++;
  917.     }
  918.     if (strcmp(name,"maspar") == 0) {
  919.     XtSetArg(args[n], XtNbitmap, 
  920.          (Pixmap) XCreateBitmapFromData(ui_display, 
  921.                         XDefaultRootWindow(ui_display),
  922.                         maspar_bits, maspar_width,
  923.                         maspar_height)); n++;
  924.     }
  925.     if (strcmp(name,"view") == 0) {
  926.     XtSetArg(args[n], XtNbitmap, 
  927.          (Pixmap) XCreateBitmapFromData(ui_display, 
  928.                         XDefaultRootWindow(ui_display),
  929.                         view_bits, view_width,
  930.                         view_height)); n++;
  931.      }
  932.      if (strcmp(name,"zoomin") == 0) {
  933.        XtSetArg(args[n], XtNbitmap, 
  934.                 (Pixmap) XCreateBitmapFromData(ui_display, 
  935.                                                XDefaultRootWindow(ui_display),
  936.                                                zoomin_bits, zoomin_width,
  937.                                                zoomin_height)); n++;
  938.      }
  939.      if (strcmp(name,"zoomout") == 0) {
  940.        XtSetArg(args[n], XtNbitmap, 
  941.                 (Pixmap) XCreateBitmapFromData(ui_display, 
  942.                                                XDefaultRootWindow(ui_display),
  943.                                                zoomout_bits, zoomout_width,
  944.                                                zoomout_height)); n++;
  945.     }
  946.     if (strcmp(name,"super3d") == 0) {
  947.     XtSetArg(args[n], XtNbitmap, 
  948.          (Pixmap) XCreateBitmapFromData(ui_display, 
  949.                         XDefaultRootWindow(ui_display),
  950.                         super3d_bits, super3d_width,
  951.                         super3d_height)); n++;
  952.     }
  953.     if (strcmp(name,"STree") == 0) {
  954.     XtSetArg(args[n], XtNbitmap, 
  955.          (Pixmap) XCreateBitmapFromData(ui_display, 
  956.                         XDefaultRootWindow(ui_display),
  957.                         stree_bits, stree_width,
  958.                         stree_height)); n++;
  959.     }
  960.     if (strcmp(name,"subpat") == 0) {
  961.     XtSetArg(args[n], XtNbitmap, 
  962.          (Pixmap) XCreateBitmapFromData(ui_display, 
  963.                         XDefaultRootWindow(ui_display),
  964.                         subpat_bits, subpat_width,
  965.                         subpat_height)); n++;
  966.     }
  967.  
  968.     XtSetArg(args[n], XtNborderWidth, 0 /*!*/); n++;
  969.     XtSetArg(args[n], XtNinternalHeight, 1); n++;
  970.     XtSetArg(args[n], XtNinternalWidth , 1); n++;
  971.     XtSetArg(args[n], XtNfromVert , top);  n++;
  972.     XtSetArg(args[n], XtNfromHoriz, left);  n++;
  973.     XtSetArg(args[n], XtNleft  , XtChainLeft); n++;
  974.     XtSetArg(args[n], XtNright , XtChainLeft); n++;
  975.     XtSetArg(args[n], XtNtop   , XtChainTop); n++;
  976.     XtSetArg(args[n], XtNbottom, XtChainTop); n++;
  977.     w = XtCreateManagedWidget(name, commandWidgetClass, parent, args, n);
  978.     return(w);
  979. }
  980.  
  981.  
  982.  
  983. /*****************************************************************************
  984.   FUNCTION : ui_xCreateMenuButtonItem
  985.  
  986.   PURPOSE  : create a menu button widget
  987.   NOTES    :
  988.   RETURNS  : The Widgetnumber
  989.   UPDATE   : 13.7.1990
  990. ******************************************************************************/
  991.  
  992. Widget  ui_xCreateMenuButtonItem(char *name,Widget parent,Widget left,Widget top)
  993. { 
  994.     Cardinal n;
  995.     Widget   w;
  996.     Arg         args[15];
  997.  
  998.     n = 0;
  999.     if (strcmp(name,"color") == 0) {
  1000.     XtSetArg(args[n], XtNbitmap, 
  1001.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1002.                         XDefaultRootWindow(ui_display),
  1003.                         color_bits, color_width,
  1004.                         color_height)); n++;
  1005.     }
  1006.     if (strcmp(name,"windows") == 0) {
  1007.     XtSetArg(args[n], XtNbitmap, 
  1008.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1009.                         XDefaultRootWindow(ui_display),
  1010.                         windows_bits, windows_width,
  1011.                         windows_height)); n++;
  1012.     }
  1013.     if (strcmp(name,"icon") == 0) {
  1014.     XtSetArg(args[n], XtNbitmap, 
  1015.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1016.                         XDefaultRootWindow(ui_display),
  1017.                         icon_bits, icon_width,
  1018.                         icon_height)); n++;
  1019.     }
  1020.     if (strcmp(name,"show") == 0) {
  1021.     XtSetArg(args[n], XtNbitmap, 
  1022.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1023.                         XDefaultRootWindow(ui_display),
  1024.                         show_bits, show_width,
  1025.                         show_height)); n++;
  1026.     }
  1027.     if (strcmp(name,"mode") == 0) {
  1028.     XtSetArg(args[n], XtNbitmap, 
  1029.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1030.                         XDefaultRootWindow(ui_display),
  1031.                         mode_bits, mode_width,
  1032.                         mode_height)); n++;
  1033.     }
  1034.     if (strcmp(name,"options") == 0) {
  1035.     XtSetArg(args[n], XtNbitmap, 
  1036.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1037.                         XDefaultRootWindow(ui_display),
  1038.                         options_bits, options_width,
  1039.                         options_height)); n++;
  1040.     }
  1041.     if (strcmp(name,"use") == 0) {
  1042.     XtSetArg(args[n], XtNbitmap, 
  1043.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1044.                         XDefaultRootWindow(ui_display),
  1045.                         use_bits, use_width,
  1046.                         use_height)); n++;
  1047.     }
  1048.     if (strcmp(name,"del") == 0) {
  1049.     XtSetArg(args[n], XtNbitmap, 
  1050.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1051.                         XDefaultRootWindow(ui_display),
  1052.                         delSet_bits, delSet_width,
  1053.                         delSet_height)); n++;
  1054.     }
  1055.  
  1056.     XtSetArg(args[n], XtNborderWidth, 0 /*!*/); n++;
  1057.     XtSetArg(args[n], XtNinternalHeight, 1); n++;
  1058.     XtSetArg(args[n], XtNinternalWidth , 1); n++;
  1059.     XtSetArg(args[n], XtNfromVert , top);  n++;
  1060.     XtSetArg(args[n], XtNfromHoriz, left);  n++;
  1061.     XtSetArg(args[n], XtNleft  , XtChainLeft); n++;
  1062.     XtSetArg(args[n], XtNright , XtChainLeft); n++;
  1063.     XtSetArg(args[n], XtNtop   , XtChainTop); n++;
  1064.     XtSetArg(args[n], XtNbottom, XtChainTop); n++;
  1065.     w = XtCreateManagedWidget(name, menuButtonWidgetClass, parent, args, n);
  1066.     return(w);
  1067. }
  1068.  
  1069.  
  1070.  
  1071.  
  1072. /*****************************************************************************
  1073.   FUNCTION : ui_xCreateToggleItem
  1074.  
  1075.   PURPOSE  : create a toggle widget
  1076.   NOTES    :
  1077.   RETURNS  : The Widgetnumber
  1078.   UPDATE   : 26.6.1990
  1079. ******************************************************************************/
  1080.  
  1081. Widget  ui_xCreateToggleItem(char *name,Widget  parent,Widget  group,Widget  left,Widget  top)
  1082. { 
  1083.     Cardinal n;
  1084.     Widget   w;
  1085.     Arg         args[15];
  1086.  
  1087.     n = 0;
  1088.     if (strcmp(name,"on") == 0) {
  1089.     XtSetArg(args[n], XtNbitmap, 
  1090.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1091.                         XDefaultRootWindow(ui_display),
  1092.                         on_bits, on_width,
  1093.                         on_height)); n++;
  1094.     }
  1095.     if (strcmp(name,"off") == 0) {
  1096.     XtSetArg(args[n], XtNbitmap, 
  1097.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1098.                         XDefaultRootWindow(ui_display),
  1099.                         off_bits, off_width,
  1100.                         off_height)); n++;
  1101.     }
  1102.     if (strcmp(name,"value") == 0) {
  1103.     XtSetArg(args[n], XtNbitmap, 
  1104.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1105.                         XDefaultRootWindow(ui_display),
  1106.                         value_bits, value_width,
  1107.                         value_height)); n++;
  1108.     }
  1109.     if (strcmp(name,"direction") == 0) {
  1110.     XtSetArg(args[n], XtNbitmap, 
  1111.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1112.                         XDefaultRootWindow(ui_display),
  1113.                         direction_bits, direction_width,
  1114.                         direction_height)); n++;
  1115.     }
  1116.     if (strcmp(name,"shuffle") == 0) {
  1117.     XtSetArg(args[n], XtNbitmap, 
  1118.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1119.                         XDefaultRootWindow(ui_display),
  1120.                         shuffle_bits, shuffle_width,
  1121.                         shuffle_height)); n++;
  1122.     }
  1123.     if (strcmp(name,"freeze") == 0) {
  1124.     XtSetArg(args[n], XtNbitmap, 
  1125.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1126.                         XDefaultRootWindow(ui_display),
  1127.                         freeze_bits, freeze_width,
  1128.                         freeze_height)); n++;
  1129.     }
  1130.     if (strcmp(name,"connect") == 0) {
  1131.     XtSetArg(args[n], XtNbitmap, 
  1132.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1133.                         XDefaultRootWindow(ui_display),
  1134.                         connect_bits, connect_width,
  1135.                         connect_height)); n++;
  1136.     }
  1137.     if (strcmp(name,"disconnect") == 0) {
  1138.     XtSetArg(args[n], XtNbitmap, 
  1139.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1140.                         XDefaultRootWindow(ui_display),
  1141.                         disconnect_bits, disconnect_width,
  1142.                         disconnect_height)); n++;
  1143.     }
  1144.     if (strcmp(name,"standard") == 0) {
  1145.     XtSetArg(args[n], XtNbitmap, 
  1146.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1147.                         XDefaultRootWindow(ui_display),
  1148.                         standard_bits, standard_width,
  1149.                         standard_height)); n++;
  1150.     }
  1151.     if (strcmp(name,"feedforward") == 0) {
  1152.     XtSetArg(args[n], XtNbitmap, 
  1153.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1154.                         XDefaultRootWindow(ui_display),
  1155.                         feedforward_bits, feedforward_width,
  1156.                         feedforward_height)); n++;
  1157.     }
  1158.     if (strcmp(name,"net") == 0) {
  1159.     XtSetArg(args[n], XtNbitmap, 
  1160.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1161.                         XDefaultRootWindow(ui_display),
  1162.                         net_bits, net_width,
  1163.                         net_height)); n++;
  1164.     }
  1165.     if (strcmp(name,"pat") == 0) {
  1166.     XtSetArg(args[n], XtNbitmap, 
  1167.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1168.                         XDefaultRootWindow(ui_display),
  1169.                         pat_bits, pat_width,
  1170.                         pat_height)); n++;
  1171.     }
  1172.     if (strcmp(name,"cfg") == 0) {
  1173.     XtSetArg(args[n], XtNbitmap, 
  1174.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1175.                         XDefaultRootWindow(ui_display),
  1176.                         cfg_bits, cfg_width,
  1177.                         cfg_height)); n++;
  1178.     }
  1179.     if (strcmp(name,"txt") == 0) {
  1180.     XtSetArg(args[n], XtNbitmap, 
  1181.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1182.                         XDefaultRootWindow(ui_display),
  1183.                         txt_bits, txt_width,
  1184.                         txt_height)); n++;
  1185.     }
  1186.     if (strcmp(name,"printer") == 0) {
  1187.     XtSetArg(args[n], XtNbitmap, 
  1188.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1189.                         XDefaultRootWindow(ui_display),
  1190.                         printer_bits, printer_width,
  1191.                         printer_height)); n++;
  1192.     }
  1193.     if (strcmp(name,"file") == 0) {
  1194.     XtSetArg(args[n], XtNbitmap, 
  1195.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1196.                         XDefaultRootWindow(ui_display),
  1197.                         file_bits, file_width,
  1198.                         file_height)); n++;
  1199.     }
  1200.     if (strcmp(name,"postscript") == 0) {
  1201.     XtSetArg(args[n], XtNbitmap, 
  1202.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1203.                         XDefaultRootWindow(ui_display),
  1204.                         postscript_bits, postscript_width,
  1205.                         postscript_height)); n++;
  1206.     }
  1207.     if (strcmp(name,"eps") == 0) {
  1208.     XtSetArg(args[n], XtNbitmap, 
  1209.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1210.                         XDefaultRootWindow(ui_display),
  1211.                         eps_bits, eps_width,
  1212.                         eps_height)); n++;
  1213.     }
  1214.     if (strcmp(name,"dina4") == 0) {
  1215.     XtSetArg(args[n], XtNbitmap, 
  1216.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1217.                         XDefaultRootWindow(ui_display),
  1218.                         dina4_bits, dina4_width,
  1219.                         dina4_height)); n++;
  1220.     }
  1221.     if (strcmp(name,"dina3") == 0) {
  1222.     XtSetArg(args[n], XtNbitmap, 
  1223.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1224.                         XDefaultRootWindow(ui_display),
  1225.                         dina3_bits, dina3_width,
  1226.                         dina3_height)); n++;
  1227.     }
  1228.     if (strcmp(name,"usletter") == 0) {
  1229.     XtSetArg(args[n], XtNbitmap, 
  1230.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1231.                         XDefaultRootWindow(ui_display),
  1232.                         usletter_bits, usletter_width,
  1233.                         usletter_height)); n++;
  1234.     }
  1235.     if (strcmp(name,"portrait") == 0) {
  1236.     XtSetArg(args[n], XtNbitmap, 
  1237.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1238.                         XDefaultRootWindow(ui_display),
  1239.                         portrait_bits, portrait_width,
  1240.                         portrait_height)); n++;
  1241.     }
  1242.     if (strcmp(name,"landscape") == 0) {
  1243.     XtSetArg(args[n], XtNbitmap, 
  1244.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1245.                         XDefaultRootWindow(ui_display),
  1246.                         landscape_bits, landscape_width,
  1247.                         landscape_height)); n++;
  1248.     }
  1249.     if (strcmp(name,"fixed") == 0) {
  1250.     XtSetArg(args[n], XtNbitmap, 
  1251.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1252.                         XDefaultRootWindow(ui_display),
  1253.                         fixed_bits, fixed_width,
  1254.                         fixed_height)); n++;
  1255.     }
  1256.     if (strcmp(name,"value2") == 0) {
  1257.     XtSetArg(args[n], XtNbitmap, 
  1258.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1259.                         XDefaultRootWindow(ui_display),
  1260.                         value2_bits, value2_width,
  1261.                         value2_height)); n++;
  1262.     }
  1263.     if (strcmp(name,"rectangle") == 0) {
  1264.     XtSetArg(args[n], XtNbitmap, 
  1265.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1266.                         XDefaultRootWindow(ui_display),
  1267.                         rectangle_bits, rectangle_width,
  1268.                         rectangle_height)); n++;
  1269.     }
  1270.     if (strcmp(name,"circle") == 0) {
  1271.     XtSetArg(args[n], XtNbitmap, 
  1272.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1273.                         XDefaultRootWindow(ui_display),
  1274.                         circle_bits, circle_width,
  1275.                         circle_height)); n++;
  1276.     }
  1277.     if (strcmp(name,"solid2") == 0) {
  1278.     XtSetArg(args[n], XtNbitmap, 
  1279.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1280.                         XDefaultRootWindow(ui_display),
  1281.                         solid2_bits, solid2_width,
  1282.                         solid2_height)); n++;
  1283.     }
  1284.     if (strcmp(name,"trans") == 0) {
  1285.     XtSetArg(args[n], XtNbitmap, 
  1286.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1287.                         XDefaultRootWindow(ui_display),
  1288.                         trans_bits, trans_width,
  1289.                         trans_height)); n++;
  1290.     }
  1291.     if (strcmp(name,"create") == 0) {
  1292.         XtSetArg(args[n], XtNbitmap, 
  1293.                  (Pixmap) XCreateBitmapFromData(ui_display,                                                 XDefaultRootWindow(ui_display),
  1294.                                                 create_bits, create_width,
  1295.                                                 create_height)); n++;
  1296.     }
  1297.     if (strcmp(name,"append") == 0) {
  1298.         XtSetArg(args[n], XtNbitmap, 
  1299.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  1300.                                                 XDefaultRootWindow(ui_display),
  1301.                                                 append_bits, append_width,
  1302.                                                 append_height)); n++;
  1303.     }
  1304.     if (strcmp(name,"res") == 0) {
  1305.         XtSetArg(args[n], XtNbitmap, 
  1306.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  1307.                                                 XDefaultRootWindow(ui_display),
  1308.                                                 res_bits, res_width,
  1309.                                                 res_height)); n++;
  1310.     }
  1311.     if (strcmp(name,"yes") == 0) {
  1312.         XtSetArg(args[n], XtNbitmap, 
  1313.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  1314.                                                 XDefaultRootWindow(ui_display),
  1315.                                                 yes_bits, yes_width,
  1316.                                                 yes_height)); n++;
  1317.     }
  1318.     if (strcmp(name,"no") == 0) {
  1319.         XtSetArg(args[n], XtNbitmap, 
  1320.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  1321.                                                 XDefaultRootWindow(ui_display),
  1322.                                                 no_bits, no_width,
  1323.                                                 no_height)); n++;
  1324.     }
  1325.     if (strcmp(name,"text") == 0) {
  1326.         XtSetArg(args[n], XtNbitmap, 
  1327.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  1328.                                                 XDefaultRootWindow(ui_display),
  1329.                                                 text_bits, text_width,
  1330.                                                 text_height)); n++;
  1331.     }
  1332.     if (strcmp(name,"selection") == 0) {
  1333.         XtSetArg(args[n], XtNbitmap, 
  1334.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  1335.                                                 XDefaultRootWindow(ui_display),
  1336.                                                 selection_bits, selection_width,
  1337.                                                 selection_height)); n++;
  1338.     }
  1339.     if (strcmp(name,"background") == 0) {
  1340.         XtSetArg(args[n], XtNbitmap, 
  1341.                  (Pixmap) XCreateBitmapFromData(ui_display, 
  1342.                                                 XDefaultRootWindow(ui_display),
  1343.                                                 background_bits, background_width,
  1344.                                                 background_height)); n++;
  1345.     }
  1346.     if (strcmp(name,"norm") == 0) {
  1347.     XtSetArg(args[n], XtNbitmap, 
  1348.          (Pixmap) XCreateBitmapFromData(ui_display, 
  1349.                         XDefaultRootWindow(ui_display),
  1350.                         norm_bits, norm_width,
  1351.                         norm_height)); n++;
  1352.     }
  1353.  
  1354.     XtSetArg(args[n], XtNborderWidth, 0 /*!*/); n++;
  1355.     XtSetArg(args[n], XtNradioGroup, group); n++;
  1356.     XtSetArg(args[n], XtNinternalHeight, 1); n++;
  1357.     XtSetArg(args[n], XtNinternalWidth , 1); n++;
  1358.     XtSetArg(args[n], XtNfromVert , top);  n++;
  1359.     XtSetArg(args[n], XtNfromHoriz, left);  n++;
  1360.     XtSetArg(args[n], XtNleft  , XtChainLeft); n++;
  1361.     XtSetArg(args[n], XtNright , XtChainLeft); n++;
  1362.     XtSetArg(args[n], XtNtop   , XtChainTop); n++;
  1363.     XtSetArg(args[n], XtNbottom, XtChainTop); n++;
  1364.     w = XtCreateManagedWidget(name, toggleWidgetClass, parent, args, n);
  1365.     return(w);
  1366. }
  1367.  
  1368.  
  1369.  
  1370.  
  1371. /*****************************************************************************
  1372.   FUNCTION : ui_xCreateScrollbarItem
  1373.  
  1374.   PURPOSE  : create a scrollbar widget
  1375.   NOTES    :
  1376.   RETURNS  : THE Widgetnumber
  1377.   UPDATE   : 2.8.1990
  1378. ******************************************************************************/
  1379.  
  1380. Widget  ui_xCreateScrollbarItem(char *name,Widget parent,Dimension length,float topOfThumb,Widget left,Widget top)
  1381. { 
  1382.     Cardinal n;
  1383.     Widget   w;
  1384.     Arg         args[20];
  1385.  
  1386.  
  1387.     n = 0;
  1388.     XtSetArg(args[n], XtNborderWidth, 1); n++;
  1389.     XtSetArg(args[n], XtNlength, length); n++; 
  1390.     XtSetArg(args[n], XtNthickness, 15); n++;
  1391.  
  1392.     /* see X11R4, Athena, pg. 37: setting float resources */
  1393.     /* But it doesn't work ! */
  1394.   /*  if (sizeof(float) > sizeof(XtArgVal)) {
  1395.     XtSetArg(args[n], XtNtopOfThumb, &topOfThumb); n++; 
  1396.     } else {
  1397.     XtArgVal *l_top = (XtArgVal *) &topOfThumb;
  1398.     XtSetArg(args[n], XtNtopOfThumb, *l_top); n++;
  1399.     } */
  1400.     
  1401.  
  1402. /*    XtSetArg(args[n], XtNinternalHeight, 1); n++;
  1403.     XtSetArg(args[n], XtNinternalWidth , 1); n++;
  1404. */
  1405.     XtSetArg(args[n], XtNfromVert , top);  n++;
  1406.     XtSetArg(args[n], XtNfromHoriz, left);  n++;
  1407.     XtSetArg(args[n], XtNleft  , XtChainLeft); n++;
  1408.     XtSetArg(args[n], XtNright , XtChainLeft); n++;
  1409.     XtSetArg(args[n], XtNtop   , XtChainTop); n++;
  1410.     XtSetArg(args[n], XtNbottom, XtChainTop); n++;
  1411.     w = XtCreateManagedWidget(name, scrollbarWidgetClass, parent, args, n);
  1412.     XawScrollbarSetThumb(w,topOfThumb,-1.0);
  1413.     return(w);
  1414. }
  1415.  
  1416.  
  1417.  
  1418. static void ui_noreturn(Widget w,Widget pannel,caddr_t call_data)
  1419. {
  1420.     /* do nothing */
  1421. }
  1422.  
  1423. /*****************************************************************************
  1424.   FUNCTION : ui_checkWindowPosition
  1425.  
  1426.   PURPOSE  : checks, if the widget is completely visible an moves the
  1427.              window if necessary
  1428.   NOTES    : 
  1429.   RETURNS  : void
  1430.   UPDATE   :
  1431. ******************************************************************************/
  1432.  
  1433. void ui_checkWindowPosition(Widget w)
  1434.  
  1435. {
  1436.     int                DisplayX, DisplayY;
  1437.     int                n;
  1438.     Arg                args[15];
  1439.     Dimension          WindowX, WindowY;
  1440.     Dimension          WindowWidth, WindowHeight;
  1441.  
  1442. #define WINDOW_HEADER 30
  1443.  
  1444.     /* Getting the size of the screen */
  1445.     DisplayX = DisplayWidth (ui_display, DefaultScreen(ui_display));
  1446.     DisplayY = DisplayHeight (ui_display, DefaultScreen(ui_display));
  1447.     
  1448.     /* Getting the size and position of the window */
  1449.     XtRealizeWidget(w);
  1450.     n = 0;
  1451.     XtSetArg(args[n], XtNx, &WindowX);       n++;
  1452.     XtSetArg(args[n], XtNy, &WindowY);       n++;
  1453.     XtSetArg(args[n], XtNwidth, &WindowWidth);   n++;
  1454.     XtSetArg(args[n], XtNheight, &WindowHeight);  n++;
  1455.     XtGetValues(w, args, n);
  1456.  
  1457.     /* Calculating the new position */
  1458.     if ((WindowWidth+WindowX) > DisplayX)  
  1459.     WindowX = DisplayX-WindowWidth;
  1460.     if (DisplayX-WindowWidth < 0)  
  1461.     WindowX = 0;
  1462.     if ((WindowHeight+WindowY+WINDOW_HEADER) > DisplayY)
  1463.         WindowY = DisplayY-WindowHeight-WINDOW_HEADER;
  1464.     if (DisplayY-WindowHeight-WINDOW_HEADER < 0)
  1465.      WindowY = 0;
  1466.  
  1467.     /* Setting the new position */
  1468.     n = 0;
  1469.     XtSetArg(args[n], XtNx, WindowX);       n++;
  1470.     XtSetArg(args[n], XtNy, WindowY);       n++;
  1471.     XtSetValues(w, args, n);
  1472. }
  1473.  
  1474.  
  1475. /*****************************************************************************
  1476.   FUNCTION : ui_xDontResizeWidget
  1477.  
  1478.   PURPOSE  : reads the current height and width of the widget and sets it
  1479.              as min and max 
  1480.   NOTES    :
  1481.   RETURNS  : void
  1482.  
  1483.   UPDATE   :
  1484. ******************************************************************************/
  1485.  
  1486. void ui_xDontResizeWidget (Widget w)
  1487.  
  1488. {
  1489.   int n;
  1490.   Arg args[5];
  1491.   Position x, y;
  1492.  
  1493.   n=0;
  1494.   XtSetArg (args[n], XtNwidth, &x);   n++;
  1495.   XtSetArg (args[n], XtNheight, &y);  n++;
  1496.   XtGetValues  (w, args,  n);
  1497.   n=0;
  1498.   XtSetArg (args[n], XtNmaxWidth, x);   n++;
  1499.   XtSetArg (args[n], XtNmaxHeight, y);  n++;
  1500.   XtSetArg (args[n], XtNminWidth, x);   n++;
  1501.   XtSetArg (args[n], XtNminHeight, y);  n++;
  1502.   XtSetValues  (w, args,  n);
  1503. }
  1504.  
  1505.  
  1506. /* end of file */
  1507. /* lines: 1365 */
  1508.