/*	SCCS Id: @(#)winmenu.c	3.3	96/08/15	*/
/* Copyright (c) Dean Luick, 1992				  */
/* NetHack may be freely redistributed.  See license for details. */

/*
 * File for creating menus.
 *
 *	+ Global functions: start_menu, add_menu, end_menu, select_menu
 */
/*#define USE_FWF*/		/* use FWF's list widget */

#ifndef SYSV
#define PRESERVE_NO_SYSV	/* X11 include files may define SYSV */
#endif

#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Shell.h>
#include <X11/Xatom.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/Viewport.h>
#include <X11/Xaw/Cardinals.h>
#include <X11/Xaw/Box.h>
#ifdef USE_FWF
#include <X11/Xfwf/MultiList.h>
#else
#include <X11/Xaw/List.h>
#endif
#include <X11/Xos.h>

#ifdef PRESERVE_NO_SYSV
# ifdef SYSV
#  undef SYSV
# endif
# undef PRESERVE_NO_SYSV
#endif

#include "hack.h"
#include "winX.h"
#include <ctype.h>


static void FDECL(menu_select, (Widget, XtPointer, XtPointer));
static void FDECL(invert_line, (struct xwindow *,x11_menu_item *,int,long));
static void FDECL(menu_ok, (Widget, XtPointer, XtPointer));
static void FDECL(menu_cancel, (Widget, XtPointer, XtPointer));
static void FDECL(menu_all, (Widget, XtPointer, XtPointer));
static void FDECL(menu_none, (Widget, XtPointer, XtPointer));
static void FDECL(menu_invert, (Widget, XtPointer, XtPointer));
static void FDECL(menu_search, (Widget, XtPointer, XtPointer));
static void FDECL(select_all, (struct xwindow *));
static void FDECL(select_none, (struct xwindow *));
static void FDECL(select_match, (struct xwindow *, char*));
static void FDECL(invert_all, (struct xwindow *));
static void FDECL(invert_match, (struct xwindow *, char*));
static void FDECL(menu_popdown, (struct xwindow *));
#ifdef USE_FWF
static void FDECL(sync_selected, (struct menu_info_t *, int, int *));
#endif

static void FDECL(move_menu, (struct menu *, struct menu *));
static void FDECL(free_menu, (struct menu *));
static void FDECL(reset_menu_to_default, (struct menu *));
static void FDECL(clear_old_menu, (struct xwindow *));
static char *FDECL(copy_of, (const char *));

#define reset_menu_count(mi)	((mi)->counting = FALSE, (mi)->menu_count = 0L)


static const char menu_translations[] =
    "#override\n\
     <Key>Left: scroll(4)\n\
     <Key>Right: scroll(6)\n\
     <Key>Up: scroll(8)\n\
     <Key>Down: scroll(2)\n\
     <Key>: menu_key()";

/*
 * Menu callback.
 */
/* ARGSUSED */
static void
menu_select(w, client_data, call_data)
    Widget w;
    XtPointer client_data, call_data;
{
    struct xwindow *wp;
    struct menu_info_t *menu_info;
#ifdef USE_FWF
    XfwfMultiListReturnStruct *lrs = (XfwfMultiListReturnStruct *) call_data;
#else
    XawListReturnStruct *lrs = (XawListReturnStruct *) call_data;
    int i;
    x11_menu_item *curr;
#endif
    long how_many;

    wp = find_widget(w);
    menu_info  = wp->menu_information;
    how_many = menu_info->counting ? menu_info->menu_count : -1L;
    reset_menu_count(menu_info);

#ifdef USE_FWF
    /* if we've reached here, we've found our selected item */
    switch (lrs->action) {
	case XfwfMultiListActionNothing:
		pline("menu_select: nothing action?");
		break;
	case XfwfMultiListActionStatus:
		pline("menu_select: status action?");
		break;
	case XfwfMultiListActionHighlight:
	case XfwfMultiListActionUnhighlight:
		sync_selected(menu_info,lrs->num_selected,lrs->selected_items);
		break;
    }
#else
    for (i = 0, curr = menu_info->curr_menu.base; i < lrs->list_index; i++) {
	if (!curr) panic("menu_select: out of menu items!");
	curr = curr->next;
    }
    XawListUnhighlight(w);	/* unhilight item */

    /* if the menu is not active or don't have an identifier, try again */
    if (!menu_info->is_active || curr->identifier.a_void == 0) {
	X11_nhbell();
	return;
    }

    /* if we've reached here, we've found our selected item */
    curr->selected = !curr->selected;
    if (curr->selected) {
	curr->str[2] = (how_many != -1L) ? '#' : '+';
	curr->pick_count = how_many;
    } else {
	curr->str[2] = '-';
	curr->pick_count = -1L;
    }
    XawListChange(wp->w, menu_info->curr_menu.list_pointer, 0, 0, True);
#endif

    if (menu_info->how == PICK_ONE)
	menu_popdown(wp);
}

/*
 * Called when menu window is deleted.
 */
/* ARGSUSED */
void
menu_delete(w, event, params, num_params)
    Widget w;
    XEvent *event;
    String *params;
    Cardinal *num_params;
{
    menu_cancel((Widget)None, (XtPointer) find_widget(w), (XtPointer) 0);
}

/*
 * Invert the count'th line (curr) in the given window.
 */
/*ARGSUSED*/
static void
invert_line(wp, curr, which, how_many)
    struct xwindow *wp;
    x11_menu_item *curr;
    int which;
    long how_many;
{
    reset_menu_count(wp->menu_information);
    curr->selected = !curr->selected;
    if (curr->selected) {
#ifdef USE_FWF
	XfwfMultiListHighlightItem((XfwfMultiListWidget)wp->w, which);
#else
	curr->str[2] = (how_many != -1) ? '#' : '+';
#endif
	curr->pick_count = how_many;
    } else {
#ifdef USE_FWF
	XfwfMultiListUnhighlightItem((XfwfMultiListWidget)wp->w, which);
#else
	curr->str[2] = '-';
#endif
	curr->pick_count = -1L;
    }
}

/*
 * Called when we get a key press event on a menu window.
 */
/* ARGSUSED */
void
menu_key(w, event, params, num_params)
    Widget w;
    XEvent *event;
    String *params;
    Cardinal *num_params;
{
    struct menu_info_t *menu_info;
    x11_menu_item *curr;
    struct xwindow *wp;
    char ch;
    int count;

    wp = find_widget(w);
    menu_info = wp->menu_information;

    ch = key_event_to_char((XKeyEvent *) event);

    if (ch == '\0') {	/* don't accept nul char/modifier event */
	/* don't beep */
	return;
    }

    if (menu_info->is_active) {		/* waiting for input */
	ch = map_menu_cmd(ch);
	if (ch == '\033') {		/* quit */
	    if (menu_info->counting) {
		/* when there's a count in progress, ESC discards it
		   rather than dismissing the whole menu */
		reset_menu_count(menu_info);
		return;
	    }
	    select_none(wp);
	} else if (ch == '\n' || ch == '\r') {
	    ;	/* accept */
	} else if (isdigit(ch)) {
	    /* special case: '0' is also the default ball class */
	    if (ch == '0' && !menu_info->counting &&
		    index(menu_info->curr_menu.gacc, ch))
		goto group_accel;
	    menu_info->menu_count *= 10L;
	    menu_info->menu_count += (long)(ch - '0');
	    if (menu_info->menu_count != 0L)	/* ignore leading zeros */
		menu_info->counting = TRUE;
	    return;
	} else if (ch == MENU_SEARCH) {		/* search */
	    if (menu_info->how == PICK_ANY || menu_info->how == PICK_ONE) {
		char buf[BUFSZ];
		X11_getlin("Search for:", buf);
		if (!*buf || *buf == '\033') return;
		if (menu_info->how == PICK_ANY) {
		    invert_match(wp, buf);
		    return;
		} else {
		    select_match(wp, buf);
		}
	    } else {
		X11_nhbell();
		return;
	    }
	} else if (ch == MENU_SELECT_ALL) {		/* select all */
	    if (menu_info->how == PICK_ANY)
		select_all(wp);
	    else
		X11_nhbell();
	    return;
	} else if (ch == MENU_UNSELECT_ALL) {		/* unselect all */
	    if (menu_info->how == PICK_ANY)
		select_none(wp);
	    else
		X11_nhbell();
	    return;
	} else if (ch == MENU_INVERT_ALL) {		/* invert all */
	    if (menu_info->how == PICK_ANY)
		invert_all(wp);
	    else
		X11_nhbell();
	    return;
	} else if (index(menu_info->curr_menu.gacc, ch)) {
 group_accel:
	    /* matched a group accelerator */
	    if (menu_info->how == PICK_ANY || menu_info->how == PICK_ONE) {
		for (count = 0, curr = menu_info->curr_menu.base; curr;
						curr = curr->next, count++) {
		    if (curr->identifier.a_void != 0 && curr->gselector == ch) {
			invert_line(wp, curr, count, -1L);
			/* for PICK_ONE, a group accelerator will
			   only be included in gacc[] if it matches
			   exactly one entry, so this must be it... */
			if (menu_info->how == PICK_ONE)
			    goto menu_done;	/* pop down */
		    }
		}
#ifndef USE_FWF
		XawListChange(wp->w, menu_info->curr_menu.list_pointer, 0, 0, True);
#endif
	    } else
		X11_nhbell();
	    return;
	} else {
	    boolean selected_something = FALSE;
	    for (count = 0, curr = menu_info->curr_menu.base; curr;
						    curr = curr->next, count++)
		if (curr->identifier.a_void != 0 && curr->selector == ch) break;

	    if (curr) {
		invert_line(wp, curr, count,
			    menu_info->counting ? menu_info->menu_count : -1L);
#ifndef USE_FWF
		XawListChange(wp->w, menu_info->curr_menu.list_pointer, 0, 0, True);
#endif
		selected_something = curr->selected;
	    } else {
		X11_nhbell();		/* no match */
	    }
	    if (!(selected_something && menu_info->how == PICK_ONE))
		return;		/* keep going */
	}
	/* pop down */
    } else {			/* permanent inventory window */
	if (ch != '\033') {
	    X11_nhbell();
	    return;
	}
	/* pop down on ESC */
    }

 menu_done:
    menu_popdown(wp);
}

/* ARGSUSED */
static void
menu_ok(w, client_data, call_data)
    Widget w;
    XtPointer client_data, call_data;
{
    struct xwindow *wp = (struct xwindow *) client_data;

    menu_popdown(wp);
}

/* ARGSUSED */
static void
menu_cancel(w, client_data, call_data)
    Widget w;				/* don't use - may be None */
    XtPointer client_data, call_data;
{
    struct xwindow *wp = (struct xwindow *) client_data;

    if (wp->menu_information->is_active) {
	select_none(wp);
	wp->menu_information->cancelled = TRUE;
    }
    menu_popdown(wp);
}

/* ARGSUSED */
static void
menu_all(w, client_data, call_data)
    Widget w;
    XtPointer client_data, call_data;
{
    select_all((struct xwindow *) client_data);
}

/* ARGSUSED */
static void
menu_none(w, client_data, call_data)
    Widget w;
    XtPointer client_data, call_data;
{
    select_none((struct xwindow *) client_data);
}

/* ARGSUSED */
static void
menu_invert(w, client_data, call_data)
    Widget w;
    XtPointer client_data, call_data;
{
    invert_all((struct xwindow *) client_data);
}

/* ARGSUSED */
static void
menu_search(w, client_data, call_data)
    Widget w;
    XtPointer client_data, call_data;
{
    struct xwindow *wp = (struct xwindow *) client_data;
    struct menu_info_t *menu_info = wp->menu_information;

    char buf[BUFSZ];
    X11_getlin("Search for:", buf);
    if (!*buf || *buf == '\033') return;

    if (menu_info->how == PICK_ANY)
	invert_match(wp, buf);
    else
	select_match(wp, buf);

    if (menu_info->how == PICK_ONE)
	menu_popdown(wp);
}

static void
select_all(wp)
    struct xwindow *wp;
{
    x11_menu_item *curr;
    int count;
    boolean changed = FALSE;

    reset_menu_count(wp->menu_information);
    for (count = 0, curr = wp->menu_information->curr_menu.base; curr;
					curr = curr->next, count++)
	if (curr->identifier.a_void != 0)
	    if (!curr->selected) {
		invert_line(wp, curr, count, -1L);
		changed = TRUE;
	    }

#ifndef USE_FWF
    if (changed)
	XawListChange(wp->w, wp->menu_information->curr_menu.list_pointer,
		      0, 0, True);
#endif
}

static void
select_none(wp)
    struct xwindow *wp;
{
    x11_menu_item *curr;
    int count;
    boolean changed = FALSE;

    reset_menu_count(wp->menu_information);
    for (count = 0, curr = wp->menu_information->curr_menu.base; curr;
					curr = curr->next, count++)
	if (curr->identifier.a_void != 0)
	    if (curr->selected) {
		invert_line(wp, curr, count, -1L);
		changed = TRUE;
	    }

#ifndef USE_FWF
    if (changed)
	XawListChange(wp->w, wp->menu_information->curr_menu.list_pointer,
		      0, 0, True);
#endif
}

static void
invert_all(wp)
    struct xwindow *wp;
{
    x11_menu_item *curr;
    int count;

    reset_menu_count(wp->menu_information);
    for (count = 0, curr = wp->menu_information->curr_menu.base; curr;
					curr = curr->next, count++)
	if (curr->identifier.a_void != 0)
	    invert_line(wp, curr, count, -1L);

#ifndef USE_FWF
    XawListChange(wp->w, wp->menu_information->curr_menu.list_pointer,
		  0, 0, True);
#endif
}

static void
invert_match(wp, match)
    struct xwindow *wp;
    char *match;
{
    x11_menu_item *curr;
    int count;
    boolean changed = FALSE;

    reset_menu_count(wp->menu_information);
    for (count = 0, curr = wp->menu_information->curr_menu.base; curr;
						curr = curr->next, count++)
	if (curr->identifier.a_void != 0 && strstri(curr->str, match)) {
	    invert_line(wp, curr, count, -1L);
	    changed = TRUE;
	}

#ifndef USE_FWF
    if (changed)
	XawListChange(wp->w, wp->menu_information->curr_menu.list_pointer,
		      0, 0, True);
#endif
}

static void
select_match(wp, match)
    struct xwindow *wp;
    char *match;
{
    x11_menu_item *curr;
    int count;

    reset_menu_count(wp->menu_information);
    for (count = 0, curr = wp->menu_information->curr_menu.base; curr;
						curr = curr->next, count++)
	if (curr->identifier.a_void != 0 && strstri(curr->str, match)) {
	    if (!curr->selected) {
		invert_line(wp, curr, count, -1L);
#ifndef USE_FWF
		XawListChange(wp->w, wp->menu_information->curr_menu.list_pointer,
			      0, 0, True);
#endif
	    }
	    return;
	}

    /* no match */
    X11_nhbell();
}

static void
menu_popdown(wp)
    struct xwindow *wp;
{
    nh_XtPopdown(wp->popup);			/* remove the event grab */
    if (wp->menu_information->is_active)
	exit_x_event = TRUE;			/* exit our event handler */
    wp->menu_information->is_up = FALSE;	/* menu is down */
}

#ifdef USE_FWF
/*
 * Make sure our idea of selected matches the FWF Multilist's idea of what
 * is currently selected.  The MultiList's selected list can change without
 * notifying us if one or more items are selected and then another is
 * selected (not toggled).  Then the items that were selected are deselected
 * but we are not notified.
 */
static void
sync_selected(menu_info, num_selected, items)
    struct menu_info_t *menu_info;
    int num_selected;
    int *items;
{
    int i, j, *ip;
    x11_menu_item *curr;
    Boolean found;

    for (i=0, curr = menu_info->curr_menu.base; curr; i++, curr = curr->next) {
	found = False;
	for (j = 0, ip = items; j < num_selected; j++, ip++)
	    if (*ip == i) {
		found = True;
		break;
	    }
#if 0
	if (curr->selected && !found)
	    printf("sync: deselecting %s\n", curr->str);
	else if (!curr->selected && found)
	    printf("sync: selecting %s\n", curr->str);
#endif
	curr->selected = found ? TRUE : FALSE;
    }
}
#endif /* USE_FWF */


/* Global functions ======================================================== */

void
X11_start_menu(window)
    winid window;
{
    struct xwindow *wp;
    check_winid(window);

    wp = &window_list[window];

    if (wp->menu_information->is_menu) {
	/* make sure we'ere starting with a clean slate */
	free_menu(&wp->menu_information->new_menu);
    } else {
	wp->menu_information->is_menu = TRUE;
    }
}

/*ARGSUSED*/
void
X11_add_menu(window, glyph, identifier, ch, gch, attr, str, preselected)
    winid window;
    int glyph;			/* unused (for now) */
    const anything *identifier;
    char ch;
    char gch;			/* group accelerator (0 = no group) */
    int attr;
    const char *str;
    boolean preselected;
{
    x11_menu_item *item;
    struct menu_info_t *menu_info;

    check_winid(window);
    menu_info = window_list[window].menu_information;
    if (!menu_info->is_menu) {
	impossible("add_menu:  called before start_menu");
	return;
    }

    item = (x11_menu_item *) alloc((unsigned)sizeof(x11_menu_item));
    item->next = (x11_menu_item *) 0;
    item->identifier = *identifier;
    item->attr = attr;
/*    item->selected = preselected; */
    item->selected = FALSE;
    item->pick_count = -1L;

    if (identifier->a_void) {
	char buf[4+BUFSZ];
	int len = strlen(str);

	if (!ch) {
	    /* Supply a keyboard accelerator.  Only the first 52 get one. */

	    if (menu_info->new_menu.curr_selector) {
		ch = menu_info->new_menu.curr_selector++;
		if (ch == 'z')
		    menu_info->new_menu.curr_selector = 'A';
		else if (ch == 'Z')
		    menu_info->new_menu.curr_selector = 0;	/* out */
	    }
	}

	if (len >= BUFSZ) {
	    /* We *think* everything's coming in off at most BUFSZ bufs... */
	    impossible("Menu item too long (%d).", len);
	    len = BUFSZ - 1;
	}
	Sprintf(buf, "%c - ", ch ? ch : ' ');
	(void) strncpy(buf+4, str, len);
	buf[4+len] = '\0';
	item->str = copy_of(buf);
    } else {
	/* no keyboard accelerator */
	item->str = copy_of(str);
	ch = 0;
    }

    item->selector = ch;
    item->gselector = gch;

    if (menu_info->new_menu.last) {
	menu_info->new_menu.last->next = item;
    } else {
	menu_info->new_menu.base = item;
    }
    menu_info->new_menu.last = item;
    menu_info->new_menu.count++;
}

void
X11_end_menu(window, query)
    winid window;
    const char *query;
{
    struct menu_info_t *menu_info;

    check_winid(window);
    menu_info = window_list[window].menu_information;
    if (!menu_info->is_menu) {
	impossible("end_menu:  called before start_menu");
	return;
    }
    menu_info->new_menu.query = copy_of(query);
}

int
X11_select_menu(window, how, menu_list)
    winid window;
    int how;
    menu_item **menu_list;
{
    x11_menu_item *curr;
    struct xwindow *wp;
    struct menu_info_t *menu_info;
    Arg args[10];
    Cardinal num_args;
    String *ptr;
    int retval;
    Dimension v_pixel_width, v_pixel_height;
    boolean labeled;
    Widget viewport_widget, form, label, ok, cancel, all, none, invert, search;
    Boolean sens;
#ifdef USE_FWF
    Boolean *boolp;
#endif
    char gacc[QBUFSZ], *ap;

    *menu_list = (menu_item *) 0;
    check_winid(window);
    wp = &window_list[window];
    menu_info = wp->menu_information;
    if (!menu_info->is_menu) {
	impossible("select_menu:  called before start_menu");
	return 0;
    }

    menu_info->how = (short) how;

    /* collect group accelerators; for PICK_NONE, they're ignored;
       for PICK_ONE, only those which match exactly one entry will be
       accepted; for PICK_ANY, those which match any entry are okay */
    gacc[0] = '\0';
    if (menu_info->how != PICK_NONE) {
	int i, n, gcnt[128];
#define GSELIDX(c) ((c) & 127)	/* guard against `signed char' */

	for (i = 0; i < SIZE(gcnt); i++) gcnt[i] = 0;
	for (n = 0, curr = menu_info->new_menu.base; curr; curr = curr->next)
	    if (curr->gselector) ++n,  ++gcnt[GSELIDX(curr->gselector)];

	if (n > 0)	/* at least one group accelerator found */
	    for (ap = gacc, curr = menu_info->new_menu.base;
		    curr; curr = curr->next)
		if (curr->gselector && !index(gacc, curr->gselector) &&
			(menu_info->how == PICK_ANY ||
			    gcnt[GSELIDX(curr->gselector)] == 1)) {
		    *ap++ = curr->gselector;
		    *ap = '\0'; /* re-terminate for index() */
		}
    }
    menu_info->new_menu.gacc = copy_of(gacc);
    reset_menu_count(menu_info);

    /*
     * Create a string and sensitive list for the new menu.
     */
    menu_info->new_menu.list_pointer = ptr = (String *)
	    alloc((unsigned) (sizeof(String) * (menu_info->new_menu.count+1)));
    for (curr = menu_info->new_menu.base; curr; ptr++, curr = curr->next)
	*ptr = (String) curr->str;
    *ptr = 0;		/* terminate list with null */

#ifdef USE_FWF
    menu_info->new_menu.sensitive = boolp = (Boolean *)
	    alloc((unsigned) (sizeof(Boolean) * (menu_info->new_menu.count)));
    for (curr = menu_info->new_menu.base; curr; boolp++, curr = curr->next)
	*boolp = (curr->identifier.a_void != 0);
#else
    menu_info->new_menu.sensitive = (Boolean *) 0;
#endif
    labeled = (menu_info->new_menu.query && *(menu_info->new_menu.query))
	? TRUE : FALSE;

    /*
     * Menus don't appear to size components correctly, except
     * when first created.  For 3.2.0 release, just recreate
     * each time.
     */
    if (menu_info->valid_widgets
			&& (window != WIN_INVEN || !flags.perm_invent)) {
	XtDestroyWidget(wp->popup);
	menu_info->valid_widgets = FALSE;
	menu_info->is_up = FALSE;
    }

    if (!menu_info->valid_widgets) {
	Dimension row_spacing;

	num_args = 0;
	XtSetArg(args[num_args], XtNallowShellResize, True); num_args++;
	wp->popup = XtCreatePopupShell(
			window == WIN_INVEN ? "inventory" : "menu",
			how == PICK_NONE ? topLevelShellWidgetClass:
					transientShellWidgetClass,
			toplevel, args, num_args);
	XtOverrideTranslations(wp->popup,
	    XtParseTranslationTable("<Message>WM_PROTOCOLS: menu_delete()"));


	num_args = 0;
	XtSetArg(args[num_args], XtNtranslations,
		XtParseTranslationTable(menu_translations));	num_args++;
	form = XtCreateManagedWidget("mform",
				    formWidgetClass,
				    wp->popup,
				    args, num_args);

	num_args = 0;
	XtSetArg(args[num_args], XtNborderWidth, 0);		num_args++;
	XtSetArg(args[num_args], XtNtop, XtChainTop);		num_args++;
	XtSetArg(args[num_args], XtNbottom, XtChainTop);	num_args++;
	XtSetArg(args[num_args], XtNleft, XtChainLeft);		num_args++;
	XtSetArg(args[num_args], XtNright, XtChainLeft);	num_args++;

	if (labeled)
	    label = XtCreateManagedWidget(menu_info->new_menu.query,
				    labelWidgetClass,
				    form,
				    args, num_args);
	else label = NULL;

	/*
	 * Create ok, cancel, all, none, invert, and search buttons..
	 */
	num_args = 0;
	XtSetArg(args[num_args], XtNfromVert, label);		num_args++;
	XtSetArg(args[num_args], XtNtop, XtChainTop);		num_args++;
	XtSetArg(args[num_args], XtNbottom, XtChainTop);	num_args++;
	XtSetArg(args[num_args], XtNleft, XtChainLeft);		num_args++;
	XtSetArg(args[num_args], XtNright, XtChainLeft);	num_args++;
	ok = XtCreateManagedWidget("OK",
			commandWidgetClass,
			form,
			args, num_args);
	XtAddCallback(ok, XtNcallback, menu_ok, (XtPointer) wp);

	num_args = 0;
	XtSetArg(args[num_args], XtNfromVert, label);		num_args++;
	XtSetArg(args[num_args], XtNfromHoriz, ok);		num_args++;
	XtSetArg(args[num_args], XtNsensitive, how!=PICK_NONE);	num_args++;
	XtSetArg(args[num_args], XtNtop, XtChainTop);		num_args++;
	XtSetArg(args[num_args], XtNbottom, XtChainTop);	num_args++;
	XtSetArg(args[num_args], XtNleft, XtChainLeft);		num_args++;
	XtSetArg(args[num_args], XtNright, XtChainLeft);	num_args++;
	cancel = XtCreateManagedWidget("cancel",
			commandWidgetClass,
			form,
			args, num_args);
	XtAddCallback(cancel, XtNcallback, menu_cancel, (XtPointer) wp);

	sens = (how == PICK_ANY);
	num_args = 0;
	XtSetArg(args[num_args], XtNfromVert, label);		num_args++;
	XtSetArg(args[num_args], XtNfromHoriz, cancel);		num_args++;
	XtSetArg(args[num_args], XtNsensitive, sens);		num_args++;
	XtSetArg(args[num_args], XtNtop, XtChainTop);		num_args++;
	XtSetArg(args[num_args], XtNbottom, XtChainTop);	num_args++;
	XtSetArg(args[num_args], XtNleft, XtChainLeft);		num_args++;
	XtSetArg(args[num_args], XtNright, XtChainLeft);	num_args++;
	all = XtCreateManagedWidget("all",
			commandWidgetClass,
			form,
			args, num_args);
	XtAddCallback(all, XtNcallback, menu_all, (XtPointer) wp);

	num_args = 0;
	XtSetArg(args[num_args], XtNfromVert, label);		num_args++;
	XtSetArg(args[num_args], XtNfromHoriz, all);		num_args++;
	XtSetArg(args[num_args], XtNsensitive, sens);		num_args++;
	XtSetArg(args[num_args], XtNtop, XtChainTop);		num_args++;
	XtSetArg(args[num_args], XtNbottom, XtChainTop);	num_args++;
	XtSetArg(args[num_args], XtNleft, XtChainLeft);		num_args++;
	XtSetArg(args[num_args], XtNright, XtChainLeft);	num_args++;
	none = XtCreateManagedWidget("none",
			commandWidgetClass,
			form,
			args, num_args);
	XtAddCallback(none, XtNcallback, menu_none, (XtPointer) wp);

	num_args = 0;
	XtSetArg(args[num_args], XtNfromVert, label);		num_args++;
	XtSetArg(args[num_args], XtNfromHoriz, none);		num_args++;
	XtSetArg(args[num_args], XtNsensitive, sens);		num_args++;
	XtSetArg(args[num_args], XtNtop, XtChainTop);		num_args++;
	XtSetArg(args[num_args], XtNbottom, XtChainTop);	num_args++;
	XtSetArg(args[num_args], XtNleft, XtChainLeft);		num_args++;
	XtSetArg(args[num_args], XtNright, XtChainLeft);	num_args++;
	invert = XtCreateManagedWidget("invert",
			commandWidgetClass,
			form,
			args, num_args);
	XtAddCallback(invert, XtNcallback, menu_invert, (XtPointer) wp);

	num_args = 0;
	XtSetArg(args[num_args], XtNfromVert, label);		num_args++;
	XtSetArg(args[num_args], XtNfromHoriz, invert);		num_args++;
	XtSetArg(args[num_args], XtNsensitive, how!=PICK_NONE);	num_args++;
	XtSetArg(args[num_args], XtNtop, XtChainTop);		num_args++;
	XtSetArg(args[num_args], XtNbottom, XtChainTop);	num_args++;
	XtSetArg(args[num_args], XtNleft, XtChainLeft);		num_args++;
	XtSetArg(args[num_args], XtNright, XtChainLeft);	num_args++;
	search = XtCreateManagedWidget("search",
			commandWidgetClass,
			form,
			args, num_args);
	XtAddCallback(search, XtNcallback, menu_search, (XtPointer) wp);

	num_args = 0;
	XtSetArg(args[num_args], XtNallowVert,  True);		num_args++;
	XtSetArg(args[num_args], XtNallowHoriz, False);		num_args++;
	XtSetArg(args[num_args], XtNuseBottom, True);		num_args++;
	XtSetArg(args[num_args], XtNuseRight, True);		num_args++;
/*
	XtSetArg(args[num_args], XtNforceBars, True);		num_args++;
*/
	XtSetArg(args[num_args], XtNfromVert, all);		num_args++;
	XtSetArg(args[num_args], XtNtop, XtChainTop);		num_args++;
	XtSetArg(args[num_args], XtNbottom, XtChainBottom);	num_args++;
	XtSetArg(args[num_args], XtNleft, XtChainLeft);		num_args++;
	XtSetArg(args[num_args], XtNright, XtChainRight);	num_args++;
	viewport_widget = XtCreateManagedWidget(
		    "menu_viewport",	/* name */
		    viewportWidgetClass,
		    form,		/* parent widget */
		    args, num_args);	/* values, and number of values */

	/* make new menu the current menu */
	move_menu(&menu_info->new_menu, &menu_info->curr_menu);

	num_args = 0;
	XtSetArg(args[num_args], XtNforceColumns, True);	num_args++;
	XtSetArg(args[num_args], XtNcolumnSpacing, 1);		num_args++;
	XtSetArg(args[num_args], XtNdefaultColumns, 1);		num_args++;
	XtSetArg(args[num_args], XtNlist,
			menu_info->curr_menu.list_pointer);	num_args++;
#ifdef USE_FWF
	XtSetArg(args[num_args], XtNsensitiveArray,
			menu_info->curr_menu.sensitive);	num_args++;
	XtSetArg(args[num_args], XtNmaxSelectable,
			menu_info->curr_menu.count);		num_args++;
#endif
	wp->w = XtCreateManagedWidget(
		    "menu_list",		/* name */
#ifdef USE_FWF
		    xfwfMultiListWidgetClass,
#else
		    listWidgetClass,
#endif
		    viewport_widget,		/* parent widget */
		    args,			/* set some values */
		    num_args);			/* number of values to set */

	XtAddCallback(wp->w, XtNcallback, menu_select, (XtPointer) 0);

	/* Get the font and margin information. */
	num_args = 0;
	XtSetArg(args[num_args], XtNfont, &menu_info->fs);	num_args++;
	XtSetArg(args[num_args], XtNinternalHeight,
				&menu_info->internal_height);	num_args++;
	XtSetArg(args[num_args], XtNinternalWidth,
				&menu_info->internal_width);	num_args++;
	XtSetArg(args[num_args], XtNrowSpacing, &row_spacing);	num_args++;
	XtGetValues(wp->w, args, num_args);

	/* font height is ascent + descent */
	menu_info->line_height =
		menu_info->fs->max_bounds.ascent +
		menu_info->fs->max_bounds.descent + row_spacing;

	menu_info->valid_widgets = TRUE;

	num_args = 0;
	XtSetArg(args[num_args], XtNwidth, &v_pixel_width);	num_args++;
	XtSetArg(args[num_args], XtNheight, &v_pixel_height);	num_args++;
	XtGetValues(wp->w, args, num_args);
    } else {
	Dimension len;

	viewport_widget = XtParent(wp->w);

	/* get the longest string on new menu */
	v_pixel_width = 0;
	for (ptr = menu_info->new_menu.list_pointer; *ptr; ptr++) {
	    len = XTextWidth(menu_info->fs, *ptr, strlen(*ptr));
	    if (len > v_pixel_width) v_pixel_width = len;
	}

	/* add viewport internal border */
	v_pixel_width += 2 * menu_info->internal_width;
	v_pixel_height = (2 * menu_info->internal_height) +
	    (menu_info->new_menu.count * menu_info->line_height);

	/* make new menu the current menu */
	move_menu(&menu_info->new_menu, &menu_info->curr_menu);
#ifdef USE_FWF
	XfwfMultiListSetNewData((XfwfMultiListWidget)wp->w,
		menu_info->curr_menu.list_pointer, 0, 0, TRUE,
		menu_info->curr_menu.sensitive);
#else
	XawListChange(wp->w, menu_info->curr_menu.list_pointer, 0, 0, TRUE);
#endif
    }

    /* if viewport will be bigger than the screen, limit its height */
    num_args = 0;
    XtSetArg(args[num_args], XtNwidth, &v_pixel_width);	num_args++;
    XtSetArg(args[num_args], XtNheight, &v_pixel_height);	num_args++;
    XtGetValues(wp->w, args, num_args);
    if ((Dimension) XtScreen(wp->w)->height * 5 / 6 < v_pixel_height) {
	/* scrollbar is 14 pixels wide.  Widen the form to accommodate it. */
	v_pixel_width += 14;

	/* shrink to fit vertically */
	v_pixel_height = XtScreen(wp->w)->height * 5 / 6;

	num_args = 0;
	XtSetArg(args[num_args], XtNwidth, v_pixel_width); num_args++;
	XtSetArg(args[num_args], XtNheight, v_pixel_height); num_args++;
	XtSetValues(wp->w, args, num_args);
    }
    XtRealizeWidget(wp->popup);	/* need to realize before we position */

    /* if menu is not up, position it */
    if (!menu_info->is_up) positionpopup(wp->popup, FALSE);

    menu_info->is_up = TRUE;
    if (window == WIN_INVEN && how == PICK_NONE) {
	/* cant use nh_XtPopup() because it may try to grab the focus */
	XtPopup(wp->popup, (int)XtGrabNone);
	if (!updated_inventory)
	    XMapRaised(XtDisplay(wp->popup), XtWindow(wp->popup));
	XSetWMProtocols(XtDisplay(wp->popup), XtWindow(wp->popup),
							&wm_delete_window, 1);
	retval = 0;
    } else {
	menu_info->is_active = TRUE;	/* waiting for user response */
	menu_info->cancelled = FALSE;
	nh_XtPopup(wp->popup, (int)XtGrabExclusive, wp->w);
	(void) x_event(EXIT_ON_EXIT);
	menu_info->is_active = FALSE;
	if (menu_info->cancelled)
	    return -1;

	retval = 0;
	for (curr = menu_info->curr_menu.base; curr; curr = curr->next)
	    if (curr->selected) retval++;

	if (retval) {
	    menu_item *mi;

	    *menu_list = mi = (menu_item *) alloc(retval * sizeof(menu_item));
	    for (curr = menu_info->curr_menu.base; curr; curr = curr->next)
		if (curr->selected) {
		    mi->item = curr->identifier;
		    mi->count = curr->pick_count;
		    mi++;
		}
	}
    }

    return retval;
}

/* End global functions ==================================================== */

/*
 * Allocate a copy of the given string.  If null, return a string of
 * zero length.
 *
 * This is an exact duplicate of copy_of() in tty/wintty.c.
 */
static char *
copy_of(s)
    const char *s;
{
    if (!s) s = "";
    return strcpy((char *) alloc((unsigned) (strlen(s) + 1)), s);
}


static void
move_menu(src_menu, dest_menu)
    struct menu *src_menu, *dest_menu;
{
    free_menu(dest_menu);	/* toss old menu */
    *dest_menu = *src_menu;	/* make new menu current */
				/* leave no dangling ptrs */
    reset_menu_to_default(src_menu);
}


static void
free_menu(mp)
    struct menu *mp;
{
    while (mp->base) {
	mp->last = mp->base;
	mp->base = mp->base->next;

	free((genericptr_t)mp->last->str);
	free((genericptr_t)mp->last);
    }
    if (mp->query) free((genericptr_t) mp->query);
    if (mp->gacc) free((genericptr_t) mp->gacc);
    if (mp->list_pointer) free((genericptr_t) mp->list_pointer);
    if (mp->sensitive) free((genericptr_t) mp->sensitive);
    reset_menu_to_default(mp);
}

static void
reset_menu_to_default(mp)
    struct menu *mp;
{
    mp->base = mp->last = (x11_menu_item *)0;
    mp->query = (const char *)0;
    mp->gacc = (const char *)0;
    mp->count = 0;
    mp->list_pointer = (String *)0;
    mp->sensitive = (Boolean *)0;
    mp->curr_selector = 'a';	/* first accelerator */
}

static void
clear_old_menu(wp)
    struct xwindow *wp;
{
    struct menu_info_t *menu_info = wp->menu_information;

    free_menu(&menu_info->curr_menu);
    free_menu(&menu_info->new_menu);

    if (menu_info->valid_widgets) {
	nh_XtPopdown(wp->popup);
	menu_info->is_up = FALSE;
	XtDestroyWidget(wp->popup);
	menu_info->valid_widgets = FALSE;
	wp->w = wp->popup = (Widget) 0;
    }
}

void
create_menu_window(wp)
    struct xwindow *wp;
{
    wp->type = NHW_MENU;
    wp->menu_information =
		(struct menu_info_t *) alloc(sizeof(struct menu_info_t));
    (void) memset((genericptr_t) wp->menu_information, '\0',
						sizeof(struct menu_info_t));
    reset_menu_to_default(&wp->menu_information->curr_menu);
    reset_menu_to_default(&wp->menu_information->new_menu);
    reset_menu_count(wp->menu_information);
    wp->w = wp->popup = (Widget) 0;
}

void
destroy_menu_window(wp)
    struct xwindow *wp;
{
    clear_old_menu(wp);		/* this will also destroy the widgets */
    free((genericptr_t) wp->menu_information);
    wp->menu_information = (struct menu_info_t *) 0;
    wp->type = NHW_NONE;	/* allow re-use */
}

/*winmenu.c*/