Importing from X.Org 7.2RC2

1 files changed, 1045 insertions, 0 deletions

diff --git a/app/editres/widgets.c b/app/editres/widgets.c
new file mode 100644
index 000000000..9782cca61
--- /dev/null
+++ b/app/editres/widgets.c
@@ -0,0 +1,1045 @@
+/*
+ * $Xorg: widgets.c,v 1.4 2001/02/09 02:05:30 xorgcvs Exp $
+ *
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ */
+/* $XFree86: xc/programs/editres/widgets.c,v 1.5 2001/01/17 23:44:52 dawes Exp $ */
+
+/*
+ * Code for creating all widgets used by EditRes.
+ */
+
+#include <stdio.h>
+#include <X11/Intrinsic.h>
+#include <X11/StringDefs.h>	/* Get standard string definations. */
+
+#include <X11/Xaw/AsciiText.h>
+#include <X11/Xaw/Box.h>	
+#include <X11/Xaw/Cardinals.h>	
+#include <X11/Xaw/Label.h>	
+#include <X11/Xaw/List.h>	
+#include <X11/Xaw/MenuButton.h>	
+#include <X11/Xaw/Paned.h>	
+#include <X11/Xaw/Panner.h>	
+#include <X11/Xaw/Porthole.h>	
+#include <X11/Xaw/SmeBSB.h>	
+#include <X11/Xaw/SmeLine.h>	
+#include <X11/Xaw/SimpleMenu.h>	
+#include <X11/Xaw/Toggle.h>	
+#include <X11/Xaw/Tree.h>
+#include <X11/Xaw/Viewport.h>	
+
+#include "editresP.h"
+
+
+
+/*
+ * functions.
+ */
+
+static Widget CreateTopArea ( Widget parent );
+static void CreateCommandMenu ( Widget parent, String toolkit );
+static void CreateTreeCommandMenu ( Widget parent, String toolkit );
+static void CreateResourceNameForm ( Widget parent, WNode * node );
+static void SetToggleGroupLeaders ( WNode * node );
+static void MakeBoxLookNice ( Widget dot, Widget star, Widget any, 
+			      Widget single, Widget name, Widget class, 
+			      int endbox );
+static void CreateLists ( Widget parent, WNode * node, char **names, 
+			  char **cons_names );
+static void CreateValueWidget ( Widget parent, WNode * node );
+static void PopupOnNode ( WNode * node, Widget shell );
+static void FreeClientData ( Widget w, XtPointer ptr, XtPointer junk );
+static void FreeResBox ( Widget w, XtPointer ptr, XtPointer junk );
+
+
+
+/*      Function Name: RebuildMenusAndLabel
+ *      Description: Determins if the user has selected an application
+ *                   which uses a different toolkit.  Xt is the default.
+ *                   If this is so, destroys and recreates the menus and
+ *                   information label at the top of the application.
+ *      Arguments: toolkit - name of the toolkit.
+ *      Returns: none.
+ */
+
+static Widget box = NULL;
+static Widget hPane = NULL;
+
+#define Offset(index) sizeof(String) * index
+
+#define res_entry(index, name, class) \
+  {name, class, XtRString, sizeof(String), \
+     Offset(index), XtRString, (XtPointer)NULL}
+
+static XtResource resources[] = {
+  res_entry(0, "label0", "Label0"),
+  res_entry(1, "label1", "Label1"),
+  res_entry(2, "label2", "Label2"),
+  res_entry(3, "label3", "Label3"),
+  res_entry(4, "label4", "Label4"),
+  res_entry(5, "label5", "Label5"),
+  res_entry(6, "label6", "Label6"),
+  res_entry(7, "label7", "Label7"),
+  res_entry(8, "label8", "Label8"),
+  res_entry(9, "label9", "Label9"),
+  res_entry(11, "label11", "Label11"),
+  res_entry(12, "label12", "Label12"),
+  res_entry(13, "label13", "Label13"),
+  res_entry(14, "label14", "Label14"),
+  res_entry(15, "label15", "Label15"),
+  res_entry(16, "label16", "Label16"),
+  res_entry(17, "label17", "Label17"),
+  res_entry(18, "label18", "Label18"),
+  res_entry(19, "label19", "Label19"),
+  res_entry(20, "label20", "Label20"),
+  res_entry(21, "label21", "Label21"),
+  res_entry(22, "label22", "Label22"),
+  res_entry(23, "label23", "Label23"),
+  res_entry(24, "label24", "Label24"),
+  res_entry(25, "label25", "Label25"),
+  res_entry(26, "label26", "Label26"),
+  res_entry(27, "label27", "Label27"),
+  res_entry(28, "label28", "Label28"),
+  res_entry(29, "label29", "Label29"),
+  res_entry(30, "label30", "Label30"),
+  res_entry(31, "label31", "Label31"),
+  res_entry(32, "label32", "Label32"),
+  res_entry(33, "label33", "Label33"),
+  res_entry(34, "label34", "Label34"),
+  res_entry(35, "label35", "Label35"),
+  res_entry(36, "label36", "Label36")
+};
+
+#undef res_entry
+
+#undef Offset
+
+void 
+RebuildMenusAndLabel(toolkit)
+     String toolkit;
+{
+  if (strcmp(global_effective_toolkit, toolkit)) {
+    CreateCommandMenu(box, toolkit);
+    CreateTreeCommandMenu(box, toolkit);
+    XtDestroyWidget(global_screen_data.info_label);
+    global_screen_data.info_label = XtCreateManagedWidget(toolkit, 
+							  labelWidgetClass,
+							  hPane, NULL, ZERO);
+    /* get the new toolkit label application resources for info_label */
+    XtGetApplicationResources(global_screen_data.info_label,
+			      res_labels, resources,
+			      XtNumber(resources), NULL, 0);
+				  
+    global_effective_toolkit = toolkit;
+  }
+}
+
+
+
+/*      Function Name: BuildWidgetTree
+ *      Description: Creates all widgets for Editres.
+ *      Arguments: parent - the shell to put them into.
+ *      Returns: none.
+ */
+
+void 
+BuildWidgetTree(parent)
+Widget parent;
+{
+    Widget paned, porthole, panner;
+
+    paned = XtCreateManagedWidget("paned", panedWidgetClass, parent,
+                                  NULL, ZERO);
+
+    panner = CreateTopArea(paned);
+
+    porthole = XtCreateManagedWidget("porthole", portholeWidgetClass,
+                                     paned, NULL, ZERO);
+
+/*
+ * Allow the panner and porthole to talk to each other.
+ */
+
+    XtAddCallback(porthole, 
+                  XtNreportCallback, PortholeCallback, (XtPointer) panner);
+    XtAddCallback(panner, 
+                  XtNreportCallback, PannerCallback, (XtPointer) porthole);
+
+    global_tree_parent = porthole;
+}
+
+
+
+
+/*	Function Name: CreateTopArea
+ *	Description: Creates the top part of the display
+ *	Arguments: parent - widget to put this menu bar into.
+ *	Returns: none. 
+ */
+
+
+static Widget
+CreateTopArea(parent)
+Widget parent;
+{
+    Widget panner;
+
+    box = XtCreateManagedWidget("box", boxWidgetClass, parent, NULL, ZERO);
+
+    CreateCommandMenu(box, "xt");
+    CreateTreeCommandMenu(box, "xt");
+
+    hPane = XtCreateManagedWidget("hPane",panedWidgetClass, parent, NULL,ZERO);
+
+    {
+	panner = XtCreateManagedWidget("panner", pannerWidgetClass, 
+				       hPane, NULL, ZERO);
+
+	global_screen_data.info_label = XtCreateManagedWidget("xt", 
+							     labelWidgetClass,
+							     hPane, NULL,ZERO);
+
+	/* get the "xt label" application resources for info_label */
+	XtGetApplicationResources(global_screen_data.info_label,
+				  res_labels, resources,
+				  XtNumber(resources), NULL, 0);
+				  
+    }
+
+    return(panner);
+}
+
+
+
+/*	Function Name: SetEntriesInsensitive
+ *	Description: Make menu entries unusable.
+ *	Arguments: entries - address of widget array.
+ *                 num - number of widgets.
+ *                 sensitive - whether to sensitize or desensitize.
+ *	Returns: none.
+ */
+void
+SetEntriesSensitive(Widget *entries, int num, Boolean sensitive)
+{
+int i; for (i=0; i<num; i++) XtSetSensitive(entries[i], sensitive); 
+}
+
+
+
+/*	Function Name: CreateCommandMenu
+ *	Description: Creates the command menu.
+ *	Arguments: parent - widget to put this menu into.
+ *                 toolkit - name given to the SimpleMenu widget.
+ *	Returns: none.
+ */
+
+static Widget cmenu = NULL, cbutton = NULL;
+/* at first most menu entries are insensitive */
+static Boolean CM_set_insensitive = True;
+Widget CM_entries[NUM_CM_ENTRIES];
+
+static void
+CreateCommandMenu(parent, toolkit)
+Widget parent;
+String toolkit;
+{
+    Arg args[1];
+
+    if (cmenu) { XtDestroyWidget(cmenu); CM_set_insensitive = False; }
+    else 
+      cbutton = XtCreateManagedWidget("commands", menuButtonWidgetClass,
+				      parent, NULL, ZERO);
+
+    /* set the menu name to the toolkit name */
+    XtSetArg(args[0], XtNmenuName, toolkit);
+    XtSetValues(cbutton, args, ONE);
+
+    cmenu = XtCreatePopupShell(toolkit, simpleMenuWidgetClass, cbutton,
+			       NULL, ZERO);
+    
+    CM_entries[0] = XtCreateManagedWidget("sendTree", smeBSBObjectClass,cmenu,
+					   NULL, ZERO);
+    XtAddCallback(CM_entries[0], XtNcallback, SendTree, (XtPointer) TRUE);
+
+    CM_entries[1]=XtCreateManagedWidget("refreshTree",smeBSBObjectClass,cmenu,
+					 NULL, ZERO);
+    XtAddCallback(CM_entries[1], XtNcallback, SendTree, (XtPointer) FALSE);
+
+    CM_entries[2] = XtCreateManagedWidget("dumpTreeToFile", 
+					   smeBSBObjectClass,cmenu,
+					   NULL, ZERO);
+    XtAddCallback(CM_entries[2], XtNcallback, DumpTreeToFile, NULL);
+
+    CM_entries[3] = XtCreateManagedWidget("line", smeLineObjectClass, cmenu,
+				  NULL, ZERO);
+    CM_entries[4]= XtCreateManagedWidget("getResourceList", 
+					  smeBSBObjectClass,cmenu,
+					  NULL, ZERO);
+    XtAddCallback(CM_entries[4], XtNcallback, GetResourceList, NULL);
+
+    CM_entries[5] = XtCreateManagedWidget("setValues", smeBSBObjectClass, 
+					   cmenu,
+					   NULL, ZERO);
+    XtAddCallback(CM_entries[5], XtNcallback, InitSetValues, NULL);
+
+    CM_entries[6] = XtCreateManagedWidget("line", smeLineObjectClass, cmenu,
+					   NULL, ZERO);
+
+    CM_entries[7] = XtCreateManagedWidget("quit", smeBSBObjectClass, cmenu,
+					   NULL, ZERO);
+    XtAddCallback(CM_entries[7], XtNcallback, Quit, NULL);
+
+    if (CM_set_insensitive) 
+      SetEntriesSensitive(&CM_entries[CM_OFFSET], CM_NUM, False);
+}
+
+
+
+/*	Function Name: CreateTreeCommandMenu
+ *	Description: Creats the command menu.
+ *	Arguments: parent - widget to put this menu into.
+ *	Returns: none.
+ */
+
+#define SELECT 0
+#define ACTIVATE 1
+#define LABEL 2
+#define LINE 3
+#define FIND 4
+#define FLASH 5
+
+struct tree_ops_menu {
+    char * name;
+    int type;
+    XtPointer data;
+};
+
+static Widget tmenu = NULL, tbutton = NULL;
+/* at first most menu entries are insensitive */
+static Boolean TM_set_insensitive = True;
+Widget TM_entries[NUM_TM_ENTRIES];
+
+static void
+CreateTreeCommandMenu(parent, toolkit)
+Widget parent;
+String toolkit;
+{
+    int i, number;
+    static struct tree_ops_menu tree_menu[] = {
+	{ "showClientWidget", FIND, (XtPointer) NULL },
+        { "selectAll", SELECT, (XtPointer) SelectAll },
+	{ "unselectAll", SELECT, (XtPointer) SelectNone },
+	{ "invertAll", SELECT, (XtPointer) SelectInvert },
+	{ "line", LINE, (XtPointer) NULL },
+	{ "selectChildren", SELECT, (XtPointer) SelectChildren },
+        { "selectParent", SELECT, (XtPointer) SelectParent },
+	{ "selectDescendants", SELECT, (XtPointer) SelectDescendants },
+        { "selectAncestors", SELECT, (XtPointer) SelectAncestors },
+        { "line", LINE, (XtPointer) NULL },
+        { "showWidgetNames", LABEL, (XtPointer) NameLabel },
+        { "showClassNames", LABEL, (XtPointer) ClassLabel },
+        { "showWidgetIDs", LABEL, (XtPointer) IDLabel},
+        { "showWidgetWindows", LABEL, (XtPointer) WindowLabel },
+        { "line", LINE, (XtPointer) NULL },
+	{ "flashActiveWidgets", FLASH, (XtPointer) NULL }
+    };
+    Arg args[1];
+
+    if (tmenu) { XtDestroyWidget(tmenu); TM_set_insensitive = False; }
+    else
+      tbutton = XtCreateManagedWidget("treeCommands", menuButtonWidgetClass,
+				      parent, NULL, ZERO);
+
+    XtSetArg(args[0], XtNmenuName, toolkit);
+    XtSetValues(tbutton, args, ONE);
+
+    tmenu = XtCreatePopupShell(toolkit, simpleMenuWidgetClass, tbutton,
+			      NULL, ZERO);
+
+    for ( i = 0, number = XtNumber(tree_menu) ; i < number ; i++) {
+	XtCallbackProc func;
+	WidgetClass class = smeBSBObjectClass;
+
+	switch (tree_menu[i].type) {
+	case SELECT:
+	    func = TreeSelect;
+	    break;
+	case LABEL:
+	    func = TreeRelabel;
+	    break;
+	case LINE:
+	    func = NULL;
+	    class = smeLineObjectClass;
+	    break;
+	case FIND:
+	    func = FindWidget;
+	    break;
+	case FLASH:
+	    func = FlashActiveWidgets;
+	    break;
+	default:
+	    continue;
+	}
+
+	TM_entries[i] = XtCreateManagedWidget(tree_menu[i].name, class, tmenu,
+				      NULL, ZERO);
+	if (func != NULL) 
+	    XtAddCallback(TM_entries[i], XtNcallback, func,tree_menu[i].data);
+    }
+    if (TM_set_insensitive) SetEntriesSensitive(&TM_entries[TM_OFFSET],
+						 TM_NUM, False);
+}
+
+
+
+static Pixmap old_pixmap;
+
+/*	Function Name: PrepareToLayoutTree
+ *	Description: prepares the Tree widget to be layed out.
+ *	Arguments: tree - the Tree widget.
+ *	Returns: none
+ */
+
+void
+PrepareToLayoutTree(tree)
+Widget tree;
+{
+    Arg args[1];
+
+    XtSetArg(args[0], XtNbackgroundPixmap, &old_pixmap);
+    XtGetValues(XtParent(tree), args, ONE);
+
+    XtSetArg(args[0], XtNbackgroundPixmap, None);
+    XtSetValues(XtParent(tree), args, ONE);
+
+    XtUnmapWidget(tree);
+}
+
+
+
+/*	Function Name: LayoutTree
+ *	Description: Laysout the tree widget.
+ *	Arguments: tree - the widget tree.
+ *	Returns: none.
+ */
+
+void
+LayoutTree(tree)
+Widget tree;
+{
+    Arg args[1];
+    
+    XawTreeForceLayout(tree);
+    XtMapWidget(tree); 
+
+    XtSetArg(args[0], XtNbackgroundPixmap, old_pixmap);
+    XtSetValues(XtParent(tree), args, ONE);
+}
+
+
+
+/************************************************************
+ *
+ * Functions for creating the Resource Box.
+ *
+ ************************************************************/
+
+/*	Function Name: CreateResourceBoxWidgets
+ *	Description: Creates the widgets that make up the resource box.
+ *	Arguments: node - the widget node.
+ *                 names - the list of names that make up the normal resources.
+ *                 cons_names - the list of names that make up 
+ *                              the constraint resources. 
+ *	Returns: none.
+ */
+
+void
+CreateResourceBoxWidgets(node, names, cons_names)
+WNode * node;
+char **names, **cons_names;
+{
+    Widget pane, box, button, viewport, pane_child;
+    ResourceBoxInfo * res_box;
+    Dimension max_width = WidthOfScreen(XtScreen(node->widget)) - 20;
+    Dimension max_height = HeightOfScreen(XtScreen(node->widget)) - 40;
+
+    res_box = (ResourceBoxInfo *) XtMalloc(sizeof(ResourceBoxInfo));
+    node->resources->res_box = res_box;
+
+    res_box->shell = XtVaCreatePopupShell(global_effective_toolkit,
+					  /*RESOURCE_BOX,*/
+					  transientShellWidgetClass,
+					  node->widget,
+					  XtNmaxWidth, max_width,
+					  XtNmaxHeight, max_height, NULL);
+    XtAddCallback(res_box->shell, XtNdestroyCallback,
+		  FreeResBox, (XtPointer) node);
+
+    pane = XtCreateManagedWidget("pane", panedWidgetClass, 
+				 res_box->shell, NULL, ZERO);
+
+    viewport = XtCreateManagedWidget("mainViewport", viewportWidgetClass,
+				     pane, NULL, 0);
+    pane_child = XtCreateManagedWidget("pane", panedWidgetClass, 
+				       viewport, NULL, ZERO);
+
+    res_box->res_label = XtCreateManagedWidget("resourceLabel", 
+					       labelWidgetClass, 
+					       pane_child, NULL, ZERO);
+
+    CreateResourceNameForm(pane_child, node);
+    CreateLists(pane_child, node, names, cons_names);
+    CreateValueWidget(pane, node);
+
+    XtSetKeyboardFocus(pane, res_box->value_wid); /* send keyboard to value. */
+
+    box = XtCreateManagedWidget("commandBox", boxWidgetClass,
+				 pane, NULL, ZERO);
+
+    button = XtCreateManagedWidget("setFile", commandWidgetClass,
+				   box, NULL, ZERO);
+    XtAddCallback(button, XtNcallback, SetFile, NULL);
+
+    button = XtCreateManagedWidget("save", commandWidgetClass,
+				   box, NULL, ZERO);
+    XtAddCallback(button, XtNcallback, SaveResource,(XtPointer) res_box);
+
+    button = XtCreateManagedWidget("apply", commandWidgetClass,
+				   box, NULL, ZERO);
+    XtAddCallback(button, XtNcallback, ApplyResource,(XtPointer) node);
+
+    button = XtCreateManagedWidget("saveAndApply", commandWidgetClass,
+				   box, NULL, ZERO);
+    XtAddCallback(button, XtNcallback, SaveResource,(XtPointer) res_box);
+    XtAddCallback(button, XtNcallback, ApplyResource,(XtPointer) node);
+
+    button = XtCreateManagedWidget("cancel", commandWidgetClass,
+				   box, NULL, ZERO);
+    XtAddCallback(button,XtNcallback,PopdownResBox,(XtPointer)res_box->shell);
+
+    SetToggleGroupLeaders(node);
+    PopupOnNode(node, res_box->shell);
+}
+
+
+
+/*	Function Name: CreateResourceNameForm
+ *	Description: Creates the Form widget with children that represent
+ *                   the full resource name for this object.
+ *	Arguments: parent - parent of the form.
+ *                 node - the node corrosponding to this object.
+ *	Returns: none
+ */
+
+static void
+CreateResourceNameForm(parent, node)
+Widget parent;
+WNode * node;
+{
+    ResourceBoxInfo * res_box = node->resources->res_box;
+    AnyInfo *new_info = NULL, *old_info;
+    char **names, **classes;
+    Widget form;
+    NameInfo * name_info = NULL;
+    Cardinal num_args;
+    Arg args[10];
+    int i;
+    Widget dot, star, name, class, single, any;
+
+    GetNamesAndClasses(node, &names, &classes);
+
+    form = XtCreateManagedWidget("namesAndClasses", formWidgetClass,
+				 parent, NULL, ZERO);
+
+    name = class = any = NULL;
+    i = 0;
+    old_info = NULL;
+    while (TRUE) {
+
+	num_args = 0;
+	XtSetArg(args[num_args], XtNfromHoriz, name); num_args++;
+	XtSetArg(args[num_args], XtNradioData, "."); num_args++;
+	dot = XtCreateManagedWidget("dot", toggleWidgetClass, 
+				    form, args, num_args);
+	XtAddCallback(dot, XtNcallback, 
+		      ActivateWidgetsAndSetResourceString,(XtPointer) node);
+
+	num_args = 0;
+	XtSetArg(args[num_args], XtNfromHoriz, class); num_args++;
+	XtSetArg(args[num_args], XtNfromVert, dot); num_args++;
+	XtSetArg(args[num_args], XtNradioGroup, dot); num_args++;
+	XtSetArg(args[num_args], XtNradioData, "*"); num_args++;
+	star = XtCreateManagedWidget("star", toggleWidgetClass, 
+				     form, args, num_args);
+	XtAddCallback(star,XtNcallback, 
+		      ActivateWidgetsAndSetResourceString, (XtPointer) node);
+
+	if (name_info != NULL) {
+	    name_info->next = (NameInfo *) XtMalloc(sizeof(NameInfo));
+	    name_info = name_info->next;
+	}
+	else
+	    res_box->name_info = 
+		     name_info = (NameInfo *) XtMalloc(sizeof(NameInfo));
+
+	name_info->sep_leader = dot;
+	name_info->name_leader = NULL;
+
+	if (names[i] != NULL) {
+	    new_info = (AnyInfo *) XtMalloc(sizeof(AnyInfo));
+	    new_info->node = node;
+	    new_info->left_dot = dot;
+	    new_info->left_star = star;
+	    new_info->left_count = 0;
+	    if (old_info != NULL) 
+		old_info->right_count = &(new_info->left_count);
+	}
+	else if (old_info != NULL) 
+	    old_info->right_count = NULL;
+
+	if (old_info != NULL) {
+	    old_info->right_dot = dot;
+	    old_info->right_star = star;
+
+	    XtAddCallback(any, XtNcallback, AnyChosen, (XtPointer) old_info);
+	    XtAddCallback(any, XtNdestroyCallback, 
+			  FreeClientData, (XtPointer) old_info);
+	}
+
+	if ( names[i] == NULL) /* no more name and class boxes. */
+	    break;
+
+	old_info = new_info;
+
+	num_args = 0;
+	XtSetArg(args[num_args], XtNfromHoriz, dot); num_args++;
+	XtSetArg(args[num_args], XtNlabel, names[i]); num_args++;
+	XtSetArg(args[num_args], XtNradioData, names[i]); num_args++;
+	name = XtCreateManagedWidget("name", toggleWidgetClass, 
+				     form, args, num_args);
+	XtAddCallback(name,XtNcallback,
+		      ActivateWidgetsAndSetResourceString,(XtPointer) node);
+
+	num_args = 0;
+	XtSetArg(args[num_args], XtNfromHoriz, star); num_args++;
+	XtSetArg(args[num_args], XtNfromVert, name); num_args++;
+	XtSetArg(args[num_args], XtNlabel, classes[i]); num_args++;
+	XtSetArg(args[num_args], XtNradioGroup, name); num_args++;
+	XtSetArg(args[num_args], XtNradioData, classes[i]); num_args++;
+	class = XtCreateManagedWidget("class", toggleWidgetClass, 
+				      form,args,num_args);
+	XtAddCallback(class, XtNcallback,
+		      ActivateWidgetsAndSetResourceString,(XtPointer) node);
+
+	num_args = 0;
+	XtSetArg(args[num_args], XtNfromHoriz, star); num_args++;
+	XtSetArg(args[num_args], XtNfromVert, class); num_args++;
+	XtSetArg(args[num_args], XtNradioData, "?"); num_args++;
+	XtSetArg(args[num_args], XtNradioGroup, name); num_args++;
+	single = XtCreateManagedWidget("single", toggleWidgetClass, 
+				       form, args, num_args);
+	XtAddCallback(single,XtNcallback,
+		      ActivateWidgetsAndSetResourceString,(XtPointer) node);
+
+	num_args = 0;
+	XtSetArg(args[num_args], XtNfromHoriz, any); num_args++;
+	XtSetArg(args[num_args], XtNfromVert, single); num_args++;
+	XtSetArg(args[num_args], XtNradioGroup, name); num_args++;
+	XtSetArg(args[num_args], XtNradioData, ANY_RADIO_DATA); num_args++;
+	any = XtCreateManagedWidget("any", toggleWidgetClass, 
+				    form, args, num_args);
+
+	name_info->name_leader = name;
+
+	MakeBoxLookNice(dot, star, any, single, name, class,
+			(i == 0 ? -1 : (names[i + 1] ? 0 : 1)));
+
+	i++;
+    }
+
+    name_info->next = NULL;
+    XtFree((char *)names);		/* Free what you allocate... */
+    XtFree((char *)classes);
+}
+
+
+
+/*	Function Name: SetToggleGroupLeaders
+ *	Description: Sets the leaders of each toggle group.
+ *                 node - The widget node containing this res box.
+ *	Returns: none
+ */
+
+static void
+SetToggleGroupLeaders(node)
+WNode * node;
+{
+    NameInfo *name;
+    ResourceBoxInfo * res_box = node->resources->res_box;
+    static Arg args[] = {
+	{XtNstate, (XtArgVal) TRUE}
+    };
+
+    for (name  = res_box->name_info; name != NULL; name = name->next) {
+	XtSetValues(name->sep_leader, args, XtNumber(args));
+	if (name->name_leader != NULL)
+	    XtSetValues(name->name_leader, args, XtNumber(args));
+    }
+    SetResourceString(NULL, (XtPointer) node, NULL);
+}
+
+
+
+/*	Function Name: MakeBoxLookNice
+ *	Description: Resizes the box that contains the resource names
+ *                   to look a bit nicer.
+ *	Arguments: dot, star - the widgets containing the separator types.
+ *                 any, single, name, class - the widgets that contain the
+ *                                     name and class of this object.
+ *	Returns: none.
+ */
+ 
+static void
+MakeBoxLookNice(dot, star, any, single, name, class, endbox)
+Widget dot, star, any, single, name, class;
+int endbox;
+{
+
+#define MAX_HDIST 3
+
+    Arg args[10];
+    Cardinal num_args;
+    Dimension any_width, name_class_width, dot_star_width;
+    Dimension width_1, width_2;
+    int h_dist[MAX_HDIST];
+    int i;
+
+    /*
+     * Make sure that the dot and star widgets are the same size.
+     */
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[0])); num_args++;
+    XtSetArg(args[num_args], XtNwidth, &width_1); num_args++;
+    XtGetValues(dot, args, num_args);
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[1])); num_args++;
+    XtSetArg(args[num_args], XtNwidth, &width_2); num_args++;
+    XtGetValues(star, args, num_args);
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[2])); num_args++;
+    XtSetArg(args[num_args], XtNwidth, &any_width); num_args++;
+    XtGetValues(any, args, num_args);
+    
+    dot_star_width = (width_1 > width_2) ? width_1 : width_2;
+    for (i = 1 ; i < MAX_HDIST; i++) {
+	if (h_dist[i] > h_dist[0]) h_dist[0] = h_dist[i];
+    }
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNhorizDistance, h_dist[0]); num_args++;
+    XtSetValues(any, args, num_args);
+    
+    /*
+     * Add a new arg, and continue...
+     */
+    XtSetArg(args[num_args], XtNwidth, dot_star_width); num_args++; 
+    XtSetValues(star, args, num_args);
+    XtSetValues(dot, args, num_args);
+
+
+    /*
+     * Now make sure that the Any Widget is as wide as the longest
+     * of the name and class widgets, plus space for the dot and star widgets.
+     * Don't forget the Form widget's internal space.
+     */
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNwidth, &width_1); num_args++;
+    XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[0])); num_args++;
+    XtGetValues(name, args, num_args);
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNwidth, &width_2); num_args++;
+    XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[1])); num_args++;
+    XtGetValues(class, args, num_args);
+
+    if (width_2 > width_1) width_1 = width_2;
+    if (h_dist[1] > h_dist[0]) h_dist[0] = h_dist[1];
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNwidth, &width_2); num_args++;
+    XtSetArg(args[num_args], XtNhorizDistance, &(h_dist[1])); num_args++;
+    XtGetValues(single, args, num_args);
+
+    name_class_width = (width_1 > width_2) ? width_1 : width_2;
+    if (h_dist[1] > h_dist[0]) h_dist[0] = h_dist[1];
+    if (any_width > name_class_width)
+	name_class_width = any_width;
+    any_width = dot_star_width + h_dist[0] + name_class_width;
+
+    num_args = 0;
+    if (endbox < 0) {
+	any_width -= dot_star_width & 1;
+	XtSetArg(args[num_args], XtNhorizDistance,
+		 h_dist[2] + (dot_star_width >> 1) + (dot_star_width & 1));
+	++num_args;
+    }
+
+    XtSetArg(args[num_args], XtNwidth, any_width); num_args++;
+    XtSetValues(any, args, num_args);	
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNwidth, name_class_width); num_args++;
+    XtSetArg(args[num_args], XtNhorizDistance, h_dist[0]); num_args++;
+    XtSetValues(name, args, num_args);	
+    XtSetValues(class, args, num_args);	
+    XtSetValues(single, args, num_args);	
+}
+
+
+
+/*	Function Name: CreateLists
+ *	Description: Creates the list widgets for the normal and constraint 
+ *                   resources
+ *	Arguments: parent - parent of the lists.
+ *                 node - The widget node containing this res box.
+ *                 names, cons_names - lists for norm and cons resource boxes.
+ *	Returns: none
+ */
+
+static char* noneList[] = {"None"};
+
+static void
+CreateLists(parent, node, names, cons_names) 
+Widget parent;
+WNode * node;
+char **names, **cons_names;
+{
+    Widget viewport;
+    Cardinal num_args;
+    ResourceBoxInfo * res_box = node->resources->res_box;
+    Arg args[3];
+
+    (void) XtCreateManagedWidget("namesLabel", labelWidgetClass, 
+				 parent, NULL, ZERO);
+    
+    num_args = 0;
+    /* if the first list item is the widget name we want an empty
+     * list.
+     */
+    if (!names) {
+        XtSetArg(args[num_args], XtNlist, noneList); num_args++;
+        XtSetArg(args[num_args], XtNnumberStrings, 1); num_args++;
+        XtSetArg(args[num_args], XtNsensitive, False); num_args++;
+    }
+    else { XtSetArg(args[num_args], XtNlist, names); num_args++; }
+    viewport = XtCreateManagedWidget("normalViewport", viewportWidgetClass,
+				     parent, NULL, 0);
+    res_box->norm_list = XtCreateManagedWidget("namesList", listWidgetClass, 
+				      viewport, args, num_args);
+    XtAddCallback(res_box->norm_list, XtNcallback, 
+		  ResourceListCallback, (XtPointer) node);
+    XtAddCallback(res_box->norm_list, XtNdestroyCallback, 
+		  FreeClientData, (XtPointer) names);
+
+    if (cons_names != NULL) {
+	(void) XtCreateManagedWidget("constraintLabel", labelWidgetClass, 
+				     parent, NULL, ZERO);
+	
+	num_args = 0;
+	XtSetArg(args[num_args], XtNlist, cons_names); num_args++;	
+	viewport = XtCreateManagedWidget("constraintViewport", viewportWidgetClass,
+					 parent, NULL, 0);
+	res_box->cons_list = XtCreateManagedWidget("constraintList", 
+						   listWidgetClass, 
+						   viewport, args, num_args);
+	XtAddCallback(res_box->cons_list, XtNcallback, 
+		      ResourceListCallback, (XtPointer) node);
+	XtAddCallback(res_box->cons_list, XtNdestroyCallback, 
+		      FreeClientData, (XtPointer) cons_names);
+    }
+    else 
+	res_box->cons_list = NULL;
+}
+
+/*	Function Name: CreateValueWidget
+ *	Description: Creates the value widget for entering the resources value.
+ *	Arguments: parent - parent of this widget.
+ *                 res_box - the resource box info.
+ *	Returns: none.
+ */
+
+static void
+CreateValueWidget(parent, node)
+Widget parent;
+WNode * node;
+{
+    Widget form, label;
+    Cardinal num_args;
+    Arg args[10];
+    ResourceBoxInfo * res_box = node->resources->res_box;
+    
+    form = XtCreateManagedWidget("valueForm", formWidgetClass,
+				 parent, NULL, ZERO);
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNleft, XawChainLeft); num_args++;
+    XtSetArg(args[num_args], XtNright, XawChainLeft); num_args++;
+    XtSetArg(args[num_args], XtNtop, XawChainTop); num_args++;
+    XtSetArg(args[num_args], XtNbottom, XawChainBottom); num_args++;
+    label = XtCreateManagedWidget("valueLabel", labelWidgetClass, 
+				 form, args, num_args);
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNfromHoriz, label); num_args++;
+    XtSetArg(args[num_args], XtNleft, XawChainLeft); num_args++;
+    XtSetArg(args[num_args], XtNright, XawChainRight); num_args++;
+    XtSetArg(args[num_args], XtNtop, XawChainTop); num_args++;
+    XtSetArg(args[num_args], XtNbottom, XawChainBottom); num_args++;
+    res_box->value_wid = XtCreateManagedWidget("valueText", 
+					       asciiTextWidgetClass, 
+					       form, args, num_args);
+#ifdef notdef
+    XtAddCallback(XawTextGetSource(res_box->value_wid), XtNcallback,
+		  SetResourceString, (XtPointer) node);
+#endif
+}
+
+
+
+/*	Function Name: PopupOnNode
+ *	Description: Pops a shell widget up centered on the node specified.
+ *	Arguments: node - the node.
+ *                 shell - the shell to popup.
+ *	Returns: none.
+ */
+
+extern Atom wm_delete_window;
+
+static void
+PopupOnNode(node, shell)
+WNode * node;
+Widget shell;
+{
+    Arg args[3];
+    Cardinal num_args;
+    Position x, y, max_loc;
+    Dimension width, height, bw;
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNwidth, &width); num_args++;
+    XtSetArg(args[num_args], XtNheight, &height); num_args++;
+    XtSetArg(args[num_args], XtNborderWidth, &bw); num_args++;
+    XtGetValues(node->widget, args, num_args);
+    XtTranslateCoords(node->widget, 
+		      (Position) (width/2 + bw), (Position) (height/2 + bw),
+		      &x, &y);
+    
+    XtOverrideTranslations
+      (shell, XtParseTranslationTable ("<Message>WM_PROTOCOLS: quit()"));
+    XtRealizeWidget(shell);
+    wm_delete_window = XInternAtom(XtDisplay(shell), "WM_DELETE_WINDOW",
+				   False);
+    (void) XSetWMProtocols (XtDisplay(shell), XtWindow(shell),
+                            &wm_delete_window, 1);
+    XtGetValues(shell, args, num_args);	/* use same arg_list. */
+
+    x -= (Position) (width/2 + bw);
+    y -= (Position) (height/2 + bw);
+
+    max_loc = WidthOfScreen(XtScreen(shell)) - (Position) (width + 2 * bw);
+    if (x > max_loc)
+	x = max_loc;
+    if (x < 0)
+	x = 0;
+
+    max_loc = HeightOfScreen(XtScreen(shell)) - (Position) (height + 2 * bw);
+    if (y > max_loc)
+	y = max_loc;
+    if (y < 0) 
+	y = 0;
+
+    num_args = 0;
+    XtSetArg(args[num_args], XtNx, x); num_args++;
+    XtSetArg(args[num_args], XtNy, y); num_args++;
+    XtSetValues(shell, args, num_args);
+
+    XtPopup(shell, XtGrabNone);
+}
+
+
+
+/*	Function Name: FreeClientData
+ *	Description: Frees the client data passed to this function.
+ *	Arguments: w - UNUSED.
+ *                 list_ptr - pointer to the list to check.
+ *                 junk - UNUSED.
+ *	Returns: none
+ */
+
+/* ARGSUSED */
+static void
+FreeClientData(w, ptr, junk)
+Widget w;
+XtPointer ptr, junk;
+{
+    XtFree(ptr);
+}
+
+
+
+/*	Function Name: FreeResBox.
+ *	Description: Frees resource box allocated memory.
+ *	Arguments: w - UNUSED.
+ *                 ptr - pointer to the node that has this resources box.
+ *                 junk - UNUSED.
+ *	Returns: none
+ */
+
+/* ARGSUSED */
+static void
+FreeResBox(w, ptr, junk)
+Widget w;
+XtPointer ptr, junk;
+{
+    WNode * node = (WNode *) ptr;
+    NameInfo *old_name, *name = node->resources->res_box->name_info;
+
+    global_resource_box_up = FALSE;
+    
+    XtFree((XtPointer) node->resources->res_box);
+    node->resources->res_box = NULL;
+
+    while (name != NULL) {
+	old_name = name;
+	name = name->next;
+	XtFree((XtPointer) old_name);
+    } 
+}
+
+
+