/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* gos720 src/gos/2d/XTOP/programs/editres/widgets.c 1.1                  */
/*                                                                        */
/* Licensed Materials - Property of IBM                                   */
/*                                                                        */
/* COPYRIGHT International Business Machines Corp. 1996                   */
/* All Rights Reserved                                                    */
/*                                                                        */
/* US Government Users Restricted Rights - Use, duplication or            */
/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp.      */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
/* SCCSID_BEGIN_TAG                                                    */
#ifndef lint
static char sccsid[] = "@(#)40  1.1  src/gos/2d/XTOP/programs/editres/widgets.c, xsample, gos720 7/15/96 17:10:32";
#endif
/* SCCSID_END_TAG                                                      */
/*
 * $XConsortium: widgets.c,v 1.22 94/04/17 20:38:58 dave Exp $
 *
Copyright (c) 1989  X Consortium

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

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
X CONSORTIUM 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 X Consortium 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 X Consortium.
 */

/*
 * 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 void CreateResourceNameForm(), SetToggleGroupLeaders(), CreateLists();
static void CreateCommandMenu(), CreateTreeCommandMenu(), FreeClientData();
static void FreeResBox(), CreateValueWidget(), PopupOnNode();
static Widget CreateTopArea();
static void MakeBoxLookNice();

extern void GetResourceList(), AnyChosen(), SetResourceString();
extern void PannerCallback(), PortholeCallback(), DumpTreeToFile();
extern void Quit(), SendTree(), FlashActiveWidgets();
extern void TreeSelect(), TreeRelabel(), TreeActivate(), FindWidget();
extern void ResourceListCallback(), PopdownResBox(), SaveResource();
extern void GetNamesAndClasses(), ApplyResource(), ActivateResourceWidgets();
extern void ActivateWidgetsAndSetResourceString(), SetFile();

extern void InitSetValues();



/*      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(entries, num, sensitive)
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++) {
	void (*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;
    ResourceBoxInfo * res_box;

    res_box = (ResourceBoxInfo *) XtMalloc(sizeof(ResourceBoxInfo));
    node->resources->res_box = res_box;

    res_box->shell = XtCreatePopupShell(global_effective_toolkit,
					/*RESOURCE_BOX,*/
					transientShellWidgetClass,
					node->widget, NULL, ZERO);
    XtAddCallback(res_box->shell, XtNdestroyCallback,
		  FreeResBox, (XtPointer) node);

    pane = XtCreateManagedWidget("pane", panedWidgetClass, 
				 res_box->shell, NULL, ZERO);

    res_box->res_label = XtCreateManagedWidget("resourceLabel", 
					       labelWidgetClass, 
					       pane, NULL, ZERO);

    CreateResourceNameForm(pane, node);
    CreateLists(pane, 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, *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;
    if (endbox < 0)
	any_width += dot_star_width / 2;
    else if (endbox > 0)
	any_width += (dot_star_width - dot_star_width / 2);

    num_args = 0;
    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;
{
    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++; }
    res_box->norm_list = XtCreateManagedWidget("namesList", listWidgetClass, 
				      parent, 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++;	
	res_box->cons_list = XtCreateManagedWidget("constraintList", 
						   listWidgetClass, 
						   parent, 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;
    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);

    if (x < 0)
	x = 0;
    else {
	Position max_loc = WidthOfScreen(XtScreen(shell)) - 
	                     (Position) (width + 2 * bw);
	if (x > max_loc)
	    x = max_loc;
    }

    if (y < 0) 
	y = 0;
    else {
	Position max_loc = HeightOfScreen(XtScreen(shell)) - 
	                     (Position) (height + 2 * bw);
	if (y > max_loc)
	    y = max_loc;
    }

    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);
    } 
}