[moira.git] / clients / mmoira / formup.c

#include	<stdio.h>
#include	<X11/StringDefs.h>
#include	<X11/IntrinsicP.h>
#include	<X11/Shell.h>
#include	<X11/Core.h>
#include	<X11/CoreP.h>
#include	<Xm/Xm.h>
#include	<Xm/BulletinB.h>
#include	<Xm/Label.h>
#include	<Xm/Text.h>
#include	<Xm/PushB.h>
#include	<Xm/PushBG.h>
#include	<Xm/CascadeB.h>
#include	<Xm/ToggleB.h>
#include	<Xm/ToggleBG.h>
#include	<Xm/RowColumn.h>
#include	<Xm/Separator.h>
#include	"mmoira.h"

static char rcsid[] = "$Header$";

#define	MAX(a,b)	((a > b) ? a : b)
#define	MIN(a,b)	((a < b) ? a : b)

int	hpad = 10;
int	vpad = 5;

void	manage_widget();
Widget	CreateForm();
Widget	CreateMenu();
Widget	BuildMenuTree();
Widget	MakeRadioField();
int	button_callback();
void	radio_callback();
void	string_callback();
void	boolean_callback();
void	menu_callback();

extern void	UpdateForm();
extern int	PopupErrorMessage();
extern void	PopupHelpWindow();
extern int	AppendToLog();
extern void	MakeWatchCursor();
extern void	MakeNormalCursor();
extern Widget	SetupLogWidget();


void
manage_widget(w, widget, call_data)
Widget	w, widget;
XmAnyCallbackStruct	*call_data;
{
	XtManageChild(widget);	
}

int
button_callback(w, client_data, call_data)
Widget		w;
EntryForm	*client_data;
XmAnyCallbackStruct	*call_data;
{
	char	output[100];
	static int	mode = 0;

/*	sprintf (output, "Button %x was hit...\n", w);
	if (mode) {
		MakeWatchCursor(toplevel);
		MakeWatchCursor(entryformwidget);
		mode = 0;
	}
	else {
		MakeNormalCursor(toplevel);
		MakeNormalCursor(entryformwidget);
		mode = 1;
	}
	AppendToLog(output);
	PopupErrorMessage("Sorry, no functionality here!\nSecond line", "No further help is available");
*/
	XtUnmanageChild(client_data->formpointer);

}


Widget
BuildMenuTree(topW, spec)
Widget		topW;
MenuItem	*spec;
{
	return (CreateMenu(topW, spec->submenu, XmHORIZONTAL));
}

/*
** Read the specification and put up a menu to match...
*/

Widget
CreateMenu(parent, spec, orientation)
Widget		parent;
MenuItem	**spec;
int		orientation;
{
	Widget		menuparent;
	MenuItem	*curmenuitem;
	Widget		childbutton, childmenu;
	Arg		wargs[10];
	int		n;
	XmString	label;		/* !@#$%^ compound string required */

	label = XmStringCreate(	"Complete junk", XmSTRING_DEFAULT_CHARSET);

	n = 0;
	XtSetArg(wargs[n], XmNlabelString, label);	n++;

	if (orientation == XmHORIZONTAL) {
		XtSetArg(wargs[n], XmNspacing, 5);	n++;
		menuparent = XmCreateMenuBar(	parent, "randommenu", 
					wargs, n);
		XtManageChild(menuparent);
	}
	else
		menuparent = XmCreatePulldownMenu(parent, "randommenu", 
						wargs, n);

	for (	curmenuitem = (*spec);
		curmenuitem;
		spec++, curmenuitem = (*spec)) {

#ifdef	DEBUG
		printf ("Making entry:  %s\n", curmenuitem->label);
#endif
		label = XmStringCreate(	curmenuitem->label,
					XmSTRING_DEFAULT_CHARSET);
		n = 0;
		XtSetArg(wargs[n], XmNlabelString, label);	n++;

		if (curmenuitem->submenu) {
#ifdef	DEBUG
			printf ("It has a submenu, which I'm recursing on...\n");
#endif
			childmenu = CreateMenu(	menuparent, 
						curmenuitem->submenu,
						XmVERTICAL);
			XtSetArg(wargs[n], XmNsubMenuId, childmenu);	n++;

			childbutton = XtCreateManagedWidget(	"child",
					xmCascadeButtonWidgetClass,
					menuparent, wargs, n);

		}

		else {
			childbutton = XtCreateManagedWidget(	"child",
					xmPushButtonGadgetClass,
					menuparent, wargs, n);

			XtAddCallback(	childbutton, 
					XmNactivateCallback, 
					menu_callback, curmenuitem);
		}
	}

	return (menuparent);
}

/*
** Read the specification and put up a form to match...
*/

Widget
CreateForm(parent, spec)
Widget		parent;
EntryForm	*spec;
{
	Widget		bb;
	Arg		wargs[10];
	int		n;
	XmString	label;		/* compound string required */
	Dimension	height_so_far = 0, width_so_far = 0;
	Dimension	height, width;
	Widget		titleW, instructionW;
	Position	x, y;
	Widget		shellparent;

	if (spec->formpointer) {
		UpdateForm(spec);
		return(spec->formpointer);
	}

	height_so_far = vpad;

#define GETSIZE(foo)	n = 0; \
			XtSetArg(wargs[n], XtNwidth, &width);	n++; \
			XtSetArg(wargs[n], XtNheight, &height);	n++; \
			XtGetValues (foo, wargs, n); \

#define STORESIZE	if (width > width_so_far) width_so_far = width;\
			height_so_far += height + vpad;


	n = 0;
	XtSetArg(wargs[n], XmNautoUnmanage, False);		n++;
	bb = XmCreateBulletinBoardDialog(parent, "board", wargs, n);

	spec->formpointer = bb;

#ifdef FORMTITLES
	label = XmStringCreate(spec->formname, XmSTRING_DEFAULT_CHARSET);
	n = 0;
	XtSetArg(wargs[n], XmNlabelString, label);		n++;
	XtSetArg(wargs[n], XtNx, 0);				n++;
	XtSetArg(wargs[n], XtNy, 0);				n++;
	titleW = XtCreateManagedWidget(	"title",
				xmLabelWidgetClass,
				bb, wargs, n);
	GETSIZE(titleW);
	STORESIZE;
#endif

	label = XmStringCreate(spec->instructions, XmSTRING_DEFAULT_CHARSET);
	n = 0;
	XtSetArg(wargs[n], XmNlabelString, label);		n++;
	XtSetArg(wargs[n], XtNx, 0);				n++;
	XtSetArg(wargs[n], XtNy, height_so_far);		n++;
	instructionW = XtCreateManagedWidget(	"instructions",
				xmLabelWidgetClass,
				bb, wargs, n);
	GETSIZE(instructionW);
	STORESIZE;

	height = height_so_far;
	width = width_so_far;
	MakeInputLines(bb, &height, &width, spec);
	STORESIZE;

	height = height_so_far;
	width = width_so_far;
	MakeButtons(bb, &height, &width, spec);
	STORESIZE;

/*
** Center the title of the form
*/
#ifdef FORMTITLES
	n = 0;
	XtSetArg(wargs[n], XtNwidth, &width);			n++;
	XtGetValues (titleW, wargs, n);

	x = (width_so_far - width) / 2;

	n = 0;
	XtSetArg(wargs[n], XtNx, x);				n++;
	XtSetValues (titleW, wargs, n);
#endif
	n = 0;
	XtSetArg(wargs[n], XtNwidth, &width);			n++;
	XtGetValues (instructionW, wargs, n);

	x = (width_so_far - width) / 2;

	n = 0;
	XtSetArg(wargs[n], XtNx, x);				n++;
	XtSetValues (instructionW, wargs, n);

	return((Widget) bb);
}

/*
** Pheight and pwidth start with the values-to-date of the bboard so far.
** Return your height and width in them when you're done.
**
** Positioning the widgets happens in two phases: 
**	First, we set their y-positions as we create them.
**	After they're created, we go back and adjust the x-positions
**	according to the widest left side noted.
*/

MakeInputLines(parent, pheight, pwidth, spec)
Widget		parent;
Dimension	*pheight;
Dimension	*pwidth;
EntryForm	*spec;
{
	UserPrompt	*current;
	XmString	label;		/* compound string required */
	Arg		wargs[10];
	int		i, n;
	Widget		child;
	Dimension	width, height, maxleftwidth = 0, maxrightwidth = 0;
	Dimension	localy, leftheight = 0, rightheight = 0;
	UserPrompt      **myinputlines = spec->inputlines;
	int		foo = 30;
	Widget		children[20];

	for (	current = (*myinputlines), localy = 0,  i = 0;
		current; 
		myinputlines++, current = (*myinputlines), i++) {


#ifdef	DEBUG
		printf ("Making entry %d: %s of type %d\n", 
				i, current->prompt, current->type);
#endif
/*
** First, make the prompt
*/
		label = XmStringCreate(	current->prompt, 
					XmSTRING_DEFAULT_CHARSET);
		n = 0;
		XtSetArg(wargs[n], XmNlabelString, label);	n++;
		XtSetArg(wargs[n], XtNy, localy + *pheight);	n++;
		child = XtCreateManagedWidget(	"prompt",
				xmLabelWidgetClass,
				parent, wargs, n);

		GETSIZE(child);
		leftheight = height;
		if (width > maxleftwidth)
			maxleftwidth = width;

/*
** Second, make the input widget
*/
		n = 0;
		XtSetArg(wargs[n], XtNy, localy + *pheight);	n++;
		XtSetArg(wargs[n], XmNtraversalOn, True);	n++;
		XtSetArg(wargs[n], XtNsensitive, 
			!(current->insensitive));		n++;
		switch (current->type) {
		case FT_STRING:
			children[i] = XtCreateManagedWidget(	"textwidget",
						xmTextWidgetClass,
						parent, wargs, n);
			XtAddCallback(	children[i], XmNvalueChangedCallback,
				string_callback, current);
			if (current->returnvalue.stringvalue) {
				XmTextSetString (children[i], current->returnvalue.stringvalue);
			}
			GETSIZE (children[i]);
			rightheight = height;
			if (width > maxrightwidth)
				maxrightwidth = width;
			break;

		case FT_BOOLEAN:
			XtSetArg(wargs[n], XmNset,
				 current->returnvalue.booleanvalue ? True : False);	n++;

			if (current->returnvalue.booleanvalue)
				label = XmStringCreate(	"(True)", XmSTRING_DEFAULT_CHARSET);
			else
				label = XmStringCreate(	"(False)", XmSTRING_DEFAULT_CHARSET);
			XtSetArg(wargs[n], XmNlabelString, label);	n++;

			children[i] = XtCreateManagedWidget(	"ignore this",
						xmToggleButtonWidgetClass,
						parent, wargs, n);

			XtAddCallback(	children[i], XmNvalueChangedCallback,
				boolean_callback, current);

			GETSIZE (children[i]);
			rightheight = height;
			if (width > maxrightwidth)
				maxrightwidth = width;
			break;

		case FT_KEYWORD:
			children[i] = 
				MakeRadioField(parent, current, &rightheight);
			XtManageChild(children[i]);
			XtSetValues(children[i], wargs, n);
			GETSIZE (children[i]);
			if (width > maxrightwidth)
				maxrightwidth = width;
			break;

		default:
			printf ("Sorry, don't recognize that type\n");
			break;
		}
		XmAddTabGroup(children[i]);
		current->mywidget = children[i];

		localy += MAX(rightheight, leftheight) + vpad;
	}

/*
** Now slide the input widgets right as far as the widest prompt.
*/
	n = 0;
	XtSetArg(wargs[n], XtNx, maxleftwidth + hpad);	n++;
	for (; i; i--)
		XtSetValues (children[i - 1], wargs, n);

	*pheight = localy - vpad;
	*pwidth = maxleftwidth + maxrightwidth + hpad;
}

/*
** All the junk about keeping track of the sum of the children's heights
** is because the !#$% RowColumn widget doesn't sum them for us, NOR
** does it accept SetValues on its XtNHeight!  Thanks, Motif!
*/

Widget
MakeRadioField(parent, prompt, pheight)
Widget		parent;
UserPrompt	*prompt;
Dimension	*pheight;
{
	Widget	radioparent, child;
	char	*current;
	Arg	wargs[10];
	int	count, n;
	XmString	label;	/* accursed compound string required */
	Dimension	height, width;
	char	**keywords;


	if (!prompt->keywords) {
		fprintf (stderr, "Warning:  No list of keywords for widget\n");
		return;
	}
	for (	count = 0, keywords = prompt->keywords;
		*keywords; 
		keywords++, count++);

/*
** Although the XmNnumColumns resource is documented as actually
** representing the number of _rows_ when XmNorientation is set to XmVERTICAL,
** it doesn't.  So I need to count the items myself and manually set the
** number of columns to get a maximum of five rows.  There's no XmNnumRows
** resource.  Thanks, Motif!
*/

	n = 0;
	XtSetArg(wargs[n], XmNspacing, 0);	n++;

	if (count > 5) {
		XtSetArg(wargs[n], XmNnumColumns, 1 + (count-1) / 5);		n++;
		XtSetArg(wargs[n], XmNorientation, XmVERTICAL);	n++;
		XtSetArg(wargs[n], XmNpacking, XmPACK_COLUMN);	n++;
	}

	radioparent = XmCreateRadioBox(parent, "radio", wargs, n);

	keywords = prompt->keywords;
	for (current=(*keywords); current; keywords++, current=(*keywords)) {
		n = 0;
		label = XmStringCreate(current, XmSTRING_DEFAULT_CHARSET);
		XtSetArg(wargs[n], XmNlabelString, label);	n++;
		if ((prompt->returnvalue.stringvalue) &&
			(!strcmp (current, prompt->returnvalue.stringvalue))) {
			XtSetArg(wargs[n], XmNset, True);	n++;
		}
		else {
			XtSetArg(wargs[n], XmNset, False);	n++;
		}
		child = XtCreateManagedWidget(	current,
						xmToggleButtonWidgetClass,
						radioparent, wargs, n);

		XtAddCallback(	child, XmNvalueChangedCallback,
				radio_callback, prompt);

	}
/*
** Assume all child widgets are the same height.  Increase height by
** five times this, or the actual number of children, whichever is lesser.
*/

	GETSIZE (child);
	*pheight = (height * MIN(5, count)) + vpad; 

	return(radioparent);
}

MakeButtons(parent, pheight, pwidth, spec)
Widget		parent;
Dimension	*pheight;
Dimension	*pwidth;
EntryForm	*spec;
{
	BottomButton	*current;
	XmString	label;		/* compound string required */
	Arg		wargs[10];
	int		i, n;
	Dimension	newwidth, width = 25;
	Widget		newbutton;
	BottomButton	**buttons = spec->buttons;

	*pheight += vpad;

	n = 0;
	XtSetArg(wargs[n], XtNy, *pheight);			n++;
	XtSetArg(wargs[n], XtNx, 0);				n++;
	XtSetArg(wargs[n], XtNwidth, *pwidth);			n++;
	XtCreateManagedWidget(	"separator",
				xmSeparatorWidgetClass,
				parent, wargs, n);
	*pheight += vpad;

	for (	current=(*buttons); 
		current; 
		buttons++, current=(*buttons)) {

#ifdef	DEBUG
		printf ("Making a button labeled %s\n", current->label);
#endif
		label = XmStringCreate(	current->label, 
					XmSTRING_DEFAULT_CHARSET);
		n = 0;
		XtSetArg(wargs[n], XtNy, (*pheight));			n++;
		XtSetArg(wargs[n], XtNx, width);			n++;
		XtSetArg(wargs[n], XmNlabelString, label);		n++;

		newbutton = XtCreateManagedWidget(	current->label,
						xmPushButtonWidgetClass,
						parent, wargs, n);

		XtAddCallback(	newbutton, XmNactivateCallback,
				current->returnfunction, spec);
		n = 0;
		XtSetArg(wargs[n], XtNwidth, &newwidth);		n++;
		XtGetValues (newbutton, wargs, n);

		width += (newwidth + hpad);
	}

	(*pheight) += 100;
}

void
radio_callback(w, client_data, call_data)
Widget	w;
XmAnyCallbackStruct	*client_data;
XmAnyCallbackStruct	*call_data;
{
	Arg		wargs[10];
	int		n;
	Boolean		is_set;

	UserPrompt	*prompt = (UserPrompt *) client_data;

	n = 0;
	XtSetArg(wargs[n], XmNset, &is_set);	n++;
	XtGetValues (w, wargs, n);

	if (!is_set)
		return;

/*
** Since Motif insists on using !@#$% Compound Strings as the text for
** its label widgets, but doesn't provide a way of getting a char* back
** from a !@#$% Compound String, I can't retrieve the label of the button 
** that was hit. 
**
** Fortunately, I was smart enough to use the button label as the name 
** of the widget, and I can extract it via XtName().  Thanks, Motif!
*/
	if (prompt->returnvalue.stringvalue &&
			(strcmp(prompt->returnvalue.stringvalue, XtName(w)))) {
		strcpy(prompt->returnvalue.stringvalue, XtName(w));
	}

}

void
boolean_callback(w, client_data, call_data)
Widget	w;
XmAnyCallbackStruct	*client_data;
XmAnyCallbackStruct	*call_data;
{
	Arg		wargs[10];
	int		n;
	Boolean		is_set;
	UserPrompt	*current = (UserPrompt *)client_data;
	XmString	label;

	n = 0;
	XtSetArg(wargs[n], XmNset, &is_set);			n++;
	XtGetValues (w, wargs, n);

	current->returnvalue.booleanvalue = is_set;

	if (is_set)
		label = XmStringCreate(	"(True)", XmSTRING_DEFAULT_CHARSET);
	else
		label = XmStringCreate(	"(False)", XmSTRING_DEFAULT_CHARSET);
	n = 0;
	XtSetArg(wargs[n], XmNlabelString, label);		n++;
	XtSetValues (w, wargs, n);

#if DEBUG
	printf ("boolean_callback:  button %x is %s\n", 
			w, (is_set ? "True" : "False"));
#endif
}

void
menu_callback(w, client_data, call_data)
Widget	w;
XmAnyCallbackStruct	*client_data;
XmAnyCallbackStruct	*call_data;
{
	MenuItem	*itemhit = (MenuItem *) client_data;

/*	printf 	("menu_callback: item '%s', op %d and string '%s'\n", 
			itemhit->label, 
			itemhit->operation, 
			itemhit->form);
	XtManageChild(entryformwidget);	
*/
	MoiraMenuRequest(itemhit);
}


void
string_callback(w, client_data, call_data)
Widget	w;
XmAnyCallbackStruct	*client_data;
XmAnyCallbackStruct	*call_data;
{
	UserPrompt	*current = (UserPrompt *)client_data;
	char		*newvalue;

	newvalue = XmTextGetString(w);

	if (strcmp(current->returnvalue.stringvalue, newvalue)) {
/*		printf ("Replacing old value of selection, '%s', with '%s'\n",
				current->returnvalue.stringvalue,
				newvalue);
*/		strcpy(current->returnvalue.stringvalue, newvalue);
	}
	XtFree(newvalue);
}
Commit	Line	Data
7ee9b49f	1	#include <stdio.h>
	2	#include <X11/StringDefs.h>
	3	#include <X11/IntrinsicP.h>
	4	#include <X11/Shell.h>
	5	#include <X11/Core.h>
	6	#include <X11/CoreP.h>
	7	#include <Xm/Xm.h>
	8	#include <Xm/BulletinB.h>
	9	#include <Xm/Label.h>
	10	#include <Xm/Text.h>
	11	#include <Xm/PushB.h>
	12	#include <Xm/PushBG.h>
	13	#include <Xm/CascadeB.h>
	14	#include <Xm/ToggleB.h>
	15	#include <Xm/ToggleBG.h>
	16	#include <Xm/RowColumn.h>
	17	#include <Xm/Separator.h>
	18	#include "mmoira.h"
	19
892c98b2	20	static char rcsid[] = "$Header$";
892c98b2	21
7ee9b49f	22	#define MAX(a,b) ((a > b) ? a : b)
ecb7d146	23	#define MIN(a,b) ((a < b) ? a : b)
7ee9b49f	24
4fa286c6	25	int hpad = 10;
4fa286c6	26	int vpad = 5;
7ee9b49f	27
7ee9b49f	28	void manage_widget();
	29	Widget CreateForm();
	30	Widget CreateMenu();
	31	Widget BuildMenuTree();
ecb7d146	32	Widget MakeRadioField();
892c98b2	33	int button_callback();
ecb7d146	34	void radio_callback();
ecb7d146	35	void string_callback();
892c98b2	36	void boolean_callback();
7ee9b49f	37	void menu_callback();
7ee9b49f	38
4fa286c6	39	extern void UpdateForm();
892c98b2	40	extern int PopupErrorMessage();
	41	extern void PopupHelpWindow();
	42	extern int AppendToLog();
892c98b2	43	extern void MakeWatchCursor();
	44	extern void MakeNormalCursor();
	45	extern Widget SetupLogWidget();
7ee9b49f	46
892c98b2	47
	48	void
	49	manage_widget(w, widget, call_data)
	50	Widget w, widget;
	51	XmAnyCallbackStruct *call_data;
ecb7d146	52	{
892c98b2	53	XtManageChild(widget);
892c98b2	54	}
ecb7d146	55
892c98b2	56	int
b2d21e59	57	button_callback(w, client_data, call_data)
	58	Widget w;
	59	EntryForm *client_data;
892c98b2	60	XmAnyCallbackStruct *call_data;
	61	{
	62	char output[100];
4fa286c6	63	static int mode = 0;
4fa286c6	64
b2d21e59	65	/* sprintf (output, "Button %x was hit...\n", w);
	66	if (mode) {
	67	MakeWatchCursor(toplevel);
	68	MakeWatchCursor(entryformwidget);
	69	mode = 0;
	70	}
	71	else {
	72	MakeNormalCursor(toplevel);
	73	MakeNormalCursor(entryformwidget);
	74	mode = 1;
	75	}
	76	AppendToLog(output);
	77	PopupErrorMessage("Sorry, no functionality here!\nSecond line", "No further help is available");
	78	*/
	79	XtUnmanageChild(client_data->formpointer);
	80
892c98b2	81	}
	82
	83
	84	Widget
	85	BuildMenuTree(topW, spec)
	86	Widget topW;
	87	MenuItem *spec;
	88	{
	89	return (CreateMenu(topW, spec->submenu, XmHORIZONTAL));
ecb7d146	90	}
ecb7d146	91
7ee9b49f	92	/*
7ee9b49f	93	** Read the specification and put up a menu to match...
7ee9b49f	94	*/
	95
	96	Widget
	97	CreateMenu(parent, spec, orientation)
	98	Widget parent;
	99	MenuItem **spec;
	100	int orientation;
	101	{
	102	Widget menuparent;
	103	MenuItem *curmenuitem;
	104	Widget childbutton, childmenu;
	105	Arg wargs[10];
	106	int n;
	107	XmString label; /* !@#$%^ compound string required */
7ee9b49f	108
	109	label = XmStringCreate( "Complete junk", XmSTRING_DEFAULT_CHARSET);
	110
	111	n = 0;
7ee9b49f	112	XtSetArg(wargs[n], XmNlabelString, label); n++;
7ee9b49f	113
892c98b2	114	if (orientation == XmHORIZONTAL) {
	115	XtSetArg(wargs[n], XmNspacing, 5); n++;
	116	menuparent = XmCreateMenuBar( parent, "randommenu",
	117	wargs, n);
	118	XtManageChild(menuparent);
	119	}
ecb7d146	120	else
	121	menuparent = XmCreatePulldownMenu(parent, "randommenu",
	122	wargs, n);
	123
7ee9b49f	124	for ( curmenuitem = (*spec);
	125	curmenuitem;
	126	spec++, curmenuitem = (*spec)) {
	127
	128	#ifdef DEBUG
	129	printf ("Making entry: %s\n", curmenuitem->label);
	130	#endif
	131	label = XmStringCreate( curmenuitem->label,
	132	XmSTRING_DEFAULT_CHARSET);
7ee9b49f	133	n = 0;
	134	XtSetArg(wargs[n], XmNlabelString, label); n++;
	135
7ee9b49f	136	if (curmenuitem->submenu) {
	137	#ifdef DEBUG
	138	printf ("It has a submenu, which I'm recursing on...\n");
	139	#endif
ecb7d146	140	childmenu = CreateMenu( menuparent,
	141	curmenuitem->submenu,
	142	XmVERTICAL);
7ee9b49f	143	XtSetArg(wargs[n], XmNsubMenuId, childmenu); n++;
	144
	145	childbutton = XtCreateManagedWidget( "child",
	146	xmCascadeButtonWidgetClass,
	147	menuparent, wargs, n);
7ee9b49f	148
7ee9b49f	149	}
	150
	151	else {
ecb7d146	152	childbutton = XtCreateManagedWidget( "child",
	153	xmPushButtonGadgetClass,
	154	menuparent, wargs, n);
	155
7ee9b49f	156	XtAddCallback( childbutton,
	157	XmNactivateCallback,
	158	menu_callback, curmenuitem);
	159	}
	160	}
7ee9b49f	161
ecb7d146	162	return (menuparent);
7ee9b49f	163	}
7ee9b49f	164
7ee9b49f	165	/*
	166	** Read the specification and put up a form to match...
	167	*/
	168
	169	Widget
	170	CreateForm(parent, spec)
	171	Widget parent;
	172	EntryForm *spec;
	173	{
ecb7d146	174	Widget bb;
7ee9b49f	175	Arg wargs[10];
ecb7d146	176	int n;
7ee9b49f	177	XmString label; /* compound string required */
	178	Dimension height_so_far = 0, width_so_far = 0;
	179	Dimension height, width;
	180	Widget titleW, instructionW;
	181	Position x, y;
	182	Widget shellparent;
	183
ecb7d146	184	if (spec->formpointer) {
4fa286c6	185	UpdateForm(spec);
ecb7d146	186	return(spec->formpointer);
ecb7d146	187	}
7ee9b49f	188
b2d21e59	189	height_so_far = vpad;
b2d21e59	190
7ee9b49f	191	#define GETSIZE(foo) n = 0; \
	192	XtSetArg(wargs[n], XtNwidth, &width); n++; \
	193	XtSetArg(wargs[n], XtNheight, &height); n++; \
	194	XtGetValues (foo, wargs, n); \
	195
	196	#define STORESIZE if (width > width_so_far) width_so_far = width;\
4fa286c6	197	height_so_far += height + vpad;
7ee9b49f	198
	199
	200	n = 0;
4fa286c6	201	XtSetArg(wargs[n], XmNautoUnmanage, False); n++;
ecb7d146	202	bb = XmCreateBulletinBoardDialog(parent, "board", wargs, n);
ecb7d146	203
ecb7d146	204	spec->formpointer = bb;
7ee9b49f	205
4fa286c6	206	#ifdef FORMTITLES
7ee9b49f	207	label = XmStringCreate(spec->formname, XmSTRING_DEFAULT_CHARSET);
	208	n = 0;
	209	XtSetArg(wargs[n], XmNlabelString, label); n++;
	210	XtSetArg(wargs[n], XtNx, 0); n++;
	211	XtSetArg(wargs[n], XtNy, 0); n++;
	212	titleW = XtCreateManagedWidget( "title",
	213	xmLabelWidgetClass,
	214	bb, wargs, n);
	215	GETSIZE(titleW);
	216	STORESIZE;
4fa286c6	217	#endif
7ee9b49f	218
	219	label = XmStringCreate(spec->instructions, XmSTRING_DEFAULT_CHARSET);
	220	n = 0;
	221	XtSetArg(wargs[n], XmNlabelString, label); n++;
	222	XtSetArg(wargs[n], XtNx, 0); n++;
	223	XtSetArg(wargs[n], XtNy, height_so_far); n++;
b2d21e59	224	instructionW = XtCreateManagedWidget( "instructions",
7ee9b49f	225	xmLabelWidgetClass,
	226	bb, wargs, n);
	227	GETSIZE(instructionW);
	228	STORESIZE;
	229
	230	height = height_so_far;
	231	width = width_so_far;
ecb7d146	232	MakeInputLines(bb, &height, &width, spec);
7ee9b49f	233	STORESIZE;
	234
	235	height = height_so_far;
	236	width = width_so_far;
ecb7d146	237	MakeButtons(bb, &height, &width, spec);
7ee9b49f	238	STORESIZE;
	239
	240	/*
	241	** Center the title of the form
	242	*/
b2d21e59	243	#ifdef FORMTITLES
7ee9b49f	244	n = 0;
	245	XtSetArg(wargs[n], XtNwidth, &width); n++;
	246	XtGetValues (titleW, wargs, n);
	247
	248	x = (width_so_far - width) / 2;
	249
	250	n = 0;
	251	XtSetArg(wargs[n], XtNx, x); n++;
	252	XtSetValues (titleW, wargs, n);
4fa286c6	253	#endif
b2d21e59	254	n = 0;
	255	XtSetArg(wargs[n], XtNwidth, &width); n++;
	256	XtGetValues (instructionW, wargs, n);
	257
	258	x = (width_so_far - width) / 2;
	259
	260	n = 0;
	261	XtSetArg(wargs[n], XtNx, x); n++;
	262	XtSetValues (instructionW, wargs, n);
	263
7ee9b49f	264	return((Widget) bb);
	265	}
	266
	267	/*
	268	** Pheight and pwidth start with the values-to-date of the bboard so far.
	269	** Return your height and width in them when you're done.
	270	**
	271	** Positioning the widgets happens in two phases:
	272	** First, we set their y-positions as we create them.
	273	** After they're created, we go back and adjust the x-positions
	274	** according to the widest left side noted.
	275	*/
	276
ecb7d146	277	MakeInputLines(parent, pheight, pwidth, spec)
7ee9b49f	278	Widget parent;
	279	Dimension *pheight;
	280	Dimension *pwidth;
ecb7d146	281	EntryForm *spec;
7ee9b49f	282	{
	283	UserPrompt *current;
	284	XmString label; /* compound string required */
	285	Arg wargs[10];
	286	int i, n;
	287	Widget child;
	288	Dimension width, height, maxleftwidth = 0, maxrightwidth = 0;
	289	Dimension localy, leftheight = 0, rightheight = 0;
ecb7d146	290	UserPrompt **myinputlines = spec->inputlines;
7ee9b49f	291	int foo = 30;
	292	Widget children[20];
	293
	294	for ( current = (*myinputlines), localy = 0, i = 0;
	295	current;
	296	myinputlines++, current = (*myinputlines), i++) {
	297
	298
	299	#ifdef DEBUG
	300	printf ("Making entry %d: %s of type %d\n",
	301	i, current->prompt, current->type);
	302	#endif
	303	/*
	304	** First, make the prompt
	305	*/
	306	label = XmStringCreate( current->prompt,
	307	XmSTRING_DEFAULT_CHARSET);
	308	n = 0;
	309	XtSetArg(wargs[n], XmNlabelString, label); n++;
	310	XtSetArg(wargs[n], XtNy, localy + *pheight); n++;
	311	child = XtCreateManagedWidget( "prompt",
	312	xmLabelWidgetClass,
	313	parent, wargs, n);
	314
	315	GETSIZE(child);
	316	leftheight = height;
	317	if (width > maxleftwidth)
	318	maxleftwidth = width;
	319
	320	/*
	321	** Second, make the input widget
	322	*/
	323	n = 0;
	324	XtSetArg(wargs[n], XtNy, localy + *pheight); n++;
ecb7d146	325	XtSetArg(wargs[n], XmNtraversalOn, True); n++;
7ee9b49f	326	XtSetArg(wargs[n], XtNsensitive,
	327	!(current->insensitive)); n++;
	328	switch (current->type) {
	329	case FT_STRING:
b2d21e59	330	children[i] = XtCreateManagedWidget( "textwidget",
7ee9b49f	331	xmTextWidgetClass,
7ee9b49f	332	parent, wargs, n);
b2d21e59	333	XtAddCallback( children[i], XmNvalueChangedCallback,
ecb7d146	334	string_callback, current);
7ee9b49f	335	if (current->returnvalue.stringvalue) {
	336	XmTextSetString (children[i], current->returnvalue.stringvalue);
	337	}
	338	GETSIZE (children[i]);
	339	rightheight = height;
	340	if (width > maxrightwidth)
	341	maxrightwidth = width;
	342	break;
	343
	344	case FT_BOOLEAN:
b2d21e59	345	XtSetArg(wargs[n], XmNset,
b2d21e59	346	current->returnvalue.booleanvalue ? True : False); n++;
ecb7d146	347
	348	if (current->returnvalue.booleanvalue)
	349	label = XmStringCreate( "(True)", XmSTRING_DEFAULT_CHARSET);
	350	else
	351	label = XmStringCreate( "(False)", XmSTRING_DEFAULT_CHARSET);
7ee9b49f	352	XtSetArg(wargs[n], XmNlabelString, label); n++;
	353
	354	children[i] = XtCreateManagedWidget( "ignore this",
	355	xmToggleButtonWidgetClass,
	356	parent, wargs, n);
	357
	358	XtAddCallback( children[i], XmNvalueChangedCallback,
ecb7d146	359	boolean_callback, current);
7ee9b49f	360
	361	GETSIZE (children[i]);
	362	rightheight = height;
	363	if (width > maxrightwidth)
	364	maxrightwidth = width;
	365	break;
	366
	367	case FT_KEYWORD:
ecb7d146	368	children[i] =
	369	MakeRadioField(parent, current, &rightheight);
	370	XtManageChild(children[i]);
	371	XtSetValues(children[i], wargs, n);
7ee9b49f	372	GETSIZE (children[i]);
	373	if (width > maxrightwidth)
	374	maxrightwidth = width;
	375	break;
	376
	377	default:
	378	printf ("Sorry, don't recognize that type\n");
	379	break;
	380	}
ecb7d146	381	XmAddTabGroup(children[i]);
4fa286c6	382	current->mywidget = children[i];
7ee9b49f	383
4fa286c6	384	localy += MAX(rightheight, leftheight) + vpad;
7ee9b49f	385	}
	386
	387	/*
	388	** Now slide the input widgets right as far as the widest prompt.
	389	*/
	390	n = 0;
4fa286c6	391	XtSetArg(wargs[n], XtNx, maxleftwidth + hpad); n++;
7ee9b49f	392	for (; i; i--)
	393	XtSetValues (children[i - 1], wargs, n);
	394
4fa286c6	395	*pheight = localy - vpad;
4fa286c6	396	*pwidth = maxleftwidth + maxrightwidth + hpad;
7ee9b49f	397	}
	398
	399	/*
	400	** All the junk about keeping track of the sum of the children's heights
	401	** is because the !#$% RowColumn widget doesn't sum them for us, NOR
ecb7d146	402	** does it accept SetValues on its XtNHeight! Thanks, Motif!
7ee9b49f	403	*/
7ee9b49f	404
ecb7d146	405	Widget
ecb7d146	406	MakeRadioField(parent, prompt, pheight)
7ee9b49f	407	Widget parent;
	408	UserPrompt *prompt;
	409	Dimension *pheight;
	410	{
ecb7d146	411	Widget radioparent, child;
7ee9b49f	412	char *current;
7ee9b49f	413	Arg wargs[10];
ecb7d146	414	int count, n;
ecb7d146	415	XmString label; /* accursed compound string required */
7ee9b49f	416	Dimension height, width;
ecb7d146	417	char **keywords;
7ee9b49f	418
ecb7d146	419
4fa286c6	420	if (!prompt->keywords) {
7ee9b49f	421	fprintf (stderr, "Warning: No list of keywords for widget\n");
892c98b2	422	return;
7ee9b49f	423	}
ecb7d146	424	for ( count = 0, keywords = prompt->keywords;
	425	*keywords;
	426	keywords++, count++);
	427
	428	/*
	429	** Although the XmNnumColumns resource is documented as actually
	430	** representing the number of _rows_ when XmNorientation is set to XmVERTICAL,
	431	** it doesn't. So I need to count the items myself and manually set the
	432	** number of columns to get a maximum of five rows. There's no XmNnumRows
	433	** resource. Thanks, Motif!
	434	*/
	435
	436	n = 0;
892c98b2	437	XtSetArg(wargs[n], XmNspacing, 0); n++;
892c98b2	438
ecb7d146	439	if (count > 5) {
b2d21e59	440	XtSetArg(wargs[n], XmNnumColumns, 1 + (count-1) / 5); n++;
ecb7d146	441	XtSetArg(wargs[n], XmNorientation, XmVERTICAL); n++;
	442	XtSetArg(wargs[n], XmNpacking, XmPACK_COLUMN); n++;
	443	}
	444
	445	radioparent = XmCreateRadioBox(parent, "radio", wargs, n);
	446
	447	keywords = prompt->keywords;
7ee9b49f	448	for (current=(keywords); current; keywords++, current=(keywords)) {
	449	n = 0;
	450	label = XmStringCreate(current, XmSTRING_DEFAULT_CHARSET);
	451	XtSetArg(wargs[n], XmNlabelString, label); n++;
b2d21e59	452	if ((prompt->returnvalue.stringvalue) &&
b2d21e59	453	(!strcmp (current, prompt->returnvalue.stringvalue))) {
7ee9b49f	454	XtSetArg(wargs[n], XmNset, True); n++;
	455	}
	456	else {
	457	XtSetArg(wargs[n], XmNset, False); n++;
	458	}
	459	child = XtCreateManagedWidget( current,
892c98b2	460	xmToggleButtonWidgetClass,
ecb7d146	461	radioparent, wargs, n);
7ee9b49f	462
	463	XtAddCallback( child, XmNvalueChangedCallback,
	464	radio_callback, prompt);
	465
7ee9b49f	466	}
7ee9b49f	467	/*
ecb7d146	468	** Assume all child widgets are the same height. Increase height by
	469	** five times this, or the actual number of children, whichever is lesser.
	470	*/
	471
	472	GETSIZE (child);
b2d21e59	473	pheight = (height MIN(5, count)) + vpad;
ecb7d146	474
ecb7d146	475	return(radioparent);
7ee9b49f	476	}
7ee9b49f	477
ecb7d146	478	MakeButtons(parent, pheight, pwidth, spec)
7ee9b49f	479	Widget parent;
	480	Dimension *pheight;
	481	Dimension *pwidth;
ecb7d146	482	EntryForm *spec;
7ee9b49f	483	{
	484	BottomButton *current;
	485	XmString label; /* compound string required */
	486	Arg wargs[10];
	487	int i, n;
	488	Dimension newwidth, width = 25;
	489	Widget newbutton;
ecb7d146	490	BottomButton **buttons = spec->buttons;
7ee9b49f	491
4fa286c6	492	*pheight += vpad;
4fa286c6	493
7ee9b49f	494	n = 0;
	495	XtSetArg(wargs[n], XtNy, *pheight); n++;
	496	XtSetArg(wargs[n], XtNx, 0); n++;
	497	XtSetArg(wargs[n], XtNwidth, *pwidth); n++;
	498	XtCreateManagedWidget( "separator",
	499	xmSeparatorWidgetClass,
	500	parent, wargs, n);
4fa286c6	501	*pheight += vpad;
7ee9b49f	502
	503	for ( current=(*buttons);
	504	current;
	505	buttons++, current=(*buttons)) {
	506
	507	#ifdef DEBUG
	508	printf ("Making a button labeled %s\n", current->label);
	509	#endif
	510	label = XmStringCreate( current->label,
	511	XmSTRING_DEFAULT_CHARSET);
	512	n = 0;
	513	XtSetArg(wargs[n], XtNy, (*pheight)); n++;
	514	XtSetArg(wargs[n], XtNx, width); n++;
	515	XtSetArg(wargs[n], XmNlabelString, label); n++;
	516
	517	newbutton = XtCreateManagedWidget( current->label,
	518	xmPushButtonWidgetClass,
	519	parent, wargs, n);
	520
	521	XtAddCallback( newbutton, XmNactivateCallback,
ecb7d146	522	current->returnfunction, spec);
7ee9b49f	523	n = 0;
	524	XtSetArg(wargs[n], XtNwidth, &newwidth); n++;
	525	XtGetValues (newbutton, wargs, n);
	526
4fa286c6	527	width += (newwidth + hpad);
7ee9b49f	528	}
	529
	530	(*pheight) += 100;
	531	}
	532
ecb7d146	533	void
7ee9b49f	534	radio_callback(w, client_data, call_data)
	535	Widget w;
	536	XmAnyCallbackStruct *client_data;
	537	XmAnyCallbackStruct *call_data;
	538	{
	539	Arg wargs[10];
ecb7d146	540	int n;
ecb7d146	541	Boolean is_set;
7ee9b49f	542
	543	UserPrompt prompt = (UserPrompt ) client_data;
	544
7ee9b49f	545	n = 0;
ecb7d146	546	XtSetArg(wargs[n], XmNset, &is_set); n++;
7ee9b49f	547	XtGetValues (w, wargs, n);
7ee9b49f	548
ecb7d146	549	if (!is_set)
ecb7d146	550	return;
7ee9b49f	551
7ee9b49f	552	/*
ecb7d146	553	** Since Motif insists on using !@#$% Compound Strings as the text for
	554	** its label widgets, but doesn't provide a way of getting a char* back
	555	** from a !@#$% Compound String, I can't retrieve the label of the button
	556	** that was hit.
	557	**
	558	** Fortunately, I was smart enough to use the button label as the name
	559	** of the widget, and I can extract it via XtName(). Thanks, Motif!
	560	*/
b2d21e59	561	if (prompt->returnvalue.stringvalue &&
b2d21e59	562	(strcmp(prompt->returnvalue.stringvalue, XtName(w)))) {
892c98b2	563	strcpy(prompt->returnvalue.stringvalue, XtName(w));
892c98b2	564	}
7ee9b49f	565
ecb7d146	566	}
	567
	568	void
	569	boolean_callback(w, client_data, call_data)
	570	Widget w;
	571	XmAnyCallbackStruct *client_data;
	572	XmAnyCallbackStruct *call_data;
	573	{
	574	Arg wargs[10];
	575	int n;
	576	Boolean is_set;
	577	UserPrompt current = (UserPrompt )client_data;
	578	XmString label;
	579
	580	n = 0;
	581	XtSetArg(wargs[n], XmNset, &is_set); n++;
	582	XtGetValues (w, wargs, n);
	583
	584	current->returnvalue.booleanvalue = is_set;
7ee9b49f	585
ecb7d146	586	if (is_set)
	587	label = XmStringCreate( "(True)", XmSTRING_DEFAULT_CHARSET);
	588	else
	589	label = XmStringCreate( "(False)", XmSTRING_DEFAULT_CHARSET);
	590	n = 0;
	591	XtSetArg(wargs[n], XmNlabelString, label); n++;
	592	XtSetValues (w, wargs, n);
	593
	594	#if DEBUG
	595	printf ("boolean_callback: button %x is %s\n",
	596	w, (is_set ? "True" : "False"));
	597	#endif
7ee9b49f	598	}
	599
	600	void
	601	menu_callback(w, client_data, call_data)
	602	Widget w;
	603	XmAnyCallbackStruct *client_data;
	604	XmAnyCallbackStruct *call_data;
	605	{
	606	MenuItem itemhit = (MenuItem ) client_data;
	607
b2d21e59	608	/* printf ("menu_callback: item '%s', op %d and string '%s'\n",
	609	itemhit->label,
	610	itemhit->operation,
	611	itemhit->form);
	612	XtManageChild(entryformwidget);
	613	*/
7ee9b49f	614	MoiraMenuRequest(itemhit);
ecb7d146	615	}
7ee9b49f	616
892c98b2	617
ecb7d146	618	void
	619	string_callback(w, client_data, call_data)
	620	Widget w;
	621	XmAnyCallbackStruct *client_data;
	622	XmAnyCallbackStruct *call_data;
	623	{
	624	UserPrompt current = (UserPrompt )client_data;
	625	char *newvalue;
	626
	627	newvalue = XmTextGetString(w);
	628
892c98b2	629	if (strcmp(current->returnvalue.stringvalue, newvalue)) {
b2d21e59	630	/* printf ("Replacing old value of selection, '%s', with '%s'\n",
892c98b2	631	current->returnvalue.stringvalue,
892c98b2	632	newvalue);
b2d21e59	633	*/ strcpy(current->returnvalue.stringvalue, newvalue);
892c98b2	634	}
ecb7d146	635	XtFree(newvalue);
7ee9b49f	636	}