#ifdef _plan9_
#include <u.h>
#include <libc.h>
#else
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#endif
#include <config.h>
#include <filter.h>
#include <fractal.h>
#include <ui_helper.h>
#include <xerror.h>
#include <xldio.h>
#include <misc-f.h>
#include "config.h"
#include "xmenu.h"

#define HASHBITS 8
#define HASHSIZE (1<<HASHBITS)
#define HASHMASK (HASHSIZE-1)
#define HASH(c,len) (((len)*32+(c)[0]+(c)[(len)-1])&HASHMASK)

static struct queuelist
{
  struct queuelist *next;
  struct queuelist *previous;
  CONST menuitem *item;
  dialogparam *d;
}
 *firstqueue = NULL, *lastqueue = NULL;
static struct entry
{
  struct entry *next;
  struct entry *previous;
  struct entry *nextname;
  CONST menuitem *item;
}
 *firstitem = NULL, *lastitem = NULL;

struct entry *namehash[HASHSIZE];

static void
x_menu_insert (CONST menuitem * item, struct entry *iitem, int n)
{
  int i;
  int len;
  int hashpos;
  struct entry *list;
  for (i = 0; i < n; i++)
    {
      list = (struct entry *) calloc (1, sizeof (struct queuelist));
      if (list == NULL)
	{
	  x_error ("Warning:out of memory!");
	  return;
	}
      if (item->type != MENU_SEPARATOR)
	{
	  len = strlen (item->shortname);
	  hashpos = HASH (item->shortname, len);
	  list->nextname = namehash[hashpos];
#ifdef DEBUG
	  {
	    struct entry *e = list->nextname;
	    while (e != NULL)
	      {
		if (e->item->type != MENU_SUBMENU
		    && e->item->type != MENU_SEPARATOR
		    && item->type != MENU_SEPARATOR);
		if (!strcmp (e->item->shortname, item->shortname)
		    /*&& e->item->type != MENU_SUBMENU && item->type != MENU_SUBMENU */
		  )
		  {
		    x_error
		      ("Menu error:Name collision %s:'%s'(%s) and '%s'(%s)",
		       item->shortname, item->name, item->menuname,
		       e->item->name, e->item->menuname);
		  }
		e = e->nextname;
	      }
	  }
#endif
	  namehash[hashpos] = list;
	}
      list->item = item;
      if (iitem == NULL)
	{
	  /*printf("ahoj\n"); */
	  list->previous = lastitem;
	  list->next = NULL;
	  if (lastitem != NULL)
	    lastitem->next = list;
	  else
	    firstitem = list;
	  lastitem = list;
	}
      else
	{
	  list->next = iitem;
	  list->previous = iitem->previous;
	  if (iitem->previous)
	    iitem->previous->next = list;
	  else
	    firstitem = list;
	  iitem->previous = list;
	}
      item++;
    }
}
void
menu_add (CONST menuitem * item, int n)
{
  x_menu_insert (item, NULL, n);
}

void
menu_insert (CONST menuitem * item, CONST char *before, int n)
{
  struct entry *e = firstitem;
  while (e != NULL)
    {
      if (!strcmp (e->item->shortname, before))
	break;
      e = e->next;
    }
  x_menu_insert (item, e, n);
}

void
menu_delete (CONST menuitem * items, int n)
{
  int d = 0, i;
  struct entry *item = firstitem;
  struct entry *pe;
  int hashpos;
  for (i = 0; i < n; i++)
    {
      if (items[i].type == MENU_SEPARATOR)
	{
	  struct entry *item = firstitem;
	  while (item && item->item != items + i)
	    item = item->next;
	  if (!item)
	    abort ();
	  if (item->previous != NULL)
	    item->previous->next = item->next;
	  else
	    firstitem = item->next;
	  if (item->next != NULL)
	    item->next->previous = item->previous;
	  else
	    lastitem = item->previous;
	  free (item);
	}
      else
	{
	  int len = strlen (items[i].shortname);
	  hashpos = HASH (items[i].shortname, len);
	  pe = NULL;
	  item = namehash[hashpos];
	  while (item != NULL)
	    {
	      if (items + i == item->item)
		{
		  d++;
		  if (pe == NULL)
		    namehash[hashpos] = item->nextname;
		  else
		    pe->nextname = item->nextname;
		  if (item->previous != NULL)
		    item->previous->next = item->next;
		  else
		    firstitem = item->next;
		  if (item->next != NULL)
		    item->next->previous = item->previous;
		  else
		    lastitem = item->previous;
		  free (item);
		  break;
		}		/*if */
	      pe = item;
	      item = item->nextname;
	    }			/*while */
	}
#ifdef DEBUG
      if (item == NULL)
	x_error ("Item %s not found!", items[i].shortname);
#endif
    }				/*for */
}
void
menu_addqueue (CONST menuitem * item, dialogparam * d)
{
  struct queuelist *list;
  list = (struct queuelist *) calloc (1, sizeof (struct queuelist));
  if (list == NULL)
    {
      x_error ("Warning:out of memory!");
      return;
    }
  list->previous = lastqueue;
  list->next = NULL;
  list->item = item;
  list->d = d;
  if (lastqueue != NULL)
    lastqueue->next = list;
  else
    firstqueue = list;
  lastqueue = list;
}
CONST menuitem *
menu_delqueue (dialogparam ** d)
{
  CONST struct menuitem *item;
  struct queuelist *list = firstqueue;
  if (firstqueue == NULL)
    return NULL;
  item = firstqueue->item;
  *d = firstqueue->d;
  firstqueue = list->next;
  if (list->next != NULL)
    list->next->previous = NULL;
  else
    lastqueue = NULL;
  free (list);
  return (item);
}
CONST static void *
menu_rfind (CONST void *(*function) (struct entry * item), CONST char *root)
{
  struct entry *item = firstitem;
  CONST void *r;
  while (item != NULL)
    {
      if (!strcmp (root, item->item->menuname))
	{
	  if ((r = function (item)) != NULL)
	    return r;
	  if (item->item->type == MENU_SUBMENU
	      && (r = menu_rfind (function, item->item->shortname)) != NULL)
	    return r;
	}
      item = item->next;
    }
  return NULL;
}
CONST static char *findkey;
CONST static void *
cmpfunction (struct entry *item)
{
  if (item->item->key == NULL)
    return NULL;
  if (!strcmp (findkey, item->item->key))
    return item->item;
  return NULL;
}
CONST menuitem *
menu_findkey (CONST char *key, CONST char *root)
{
  findkey = key;
  return ((CONST menuitem *) menu_rfind (cmpfunction, root));
}
static CONST menuitem *finditem;
CONST static void *
cmpfunction2 (struct entry *item)
{
  if (item->item == finditem)
    return item;
  return NULL;
}

int
menu_available (CONST menuitem * item, CONST char *root)
{
  finditem = item;
  return (menu_rfind (cmpfunction2, root) != NULL);
}
CONST char *
menu_fullname (CONST char *menu)
{
  struct entry *item = firstitem;
  while (item != NULL)
    {
      if (item->item->type == MENU_SUBMENU
	  && !strcmp (menu, item->item->shortname))
	{
	  return (item->item->name);
	}
      item = item->next;
    }
  return NULL;
}
CONST menuitem *
menu_item (CONST char *menu, int n)
{
  struct entry *item = firstitem;
  while (item != NULL)
    {
      if (!strcmp (menu, item->item->menuname))
	{
	  if (!(item->item->flags & MENUFLAG_NOMENU))
	    n--;
	  if (n < 0)
	    return (item->item);
	}
      item = item->next;
    }
  return NULL;
}
static CONST menuitem *
menu_item2 (CONST char *menu, int n)
{
  struct entry *item = firstitem;
  while (item != NULL)
    {
      if (!strcmp (menu, item->item->menuname))
	{
	  n--;
	  if (n < 0)
	    return (item->item);
	}
      item = item->next;
    }
  return NULL;
}

int
menu_havedialog (CONST menuitem * item, struct uih_context *c)
{
  if (item->type != MENU_DIALOG && item->type != MENU_CUSTOMDIALOG)
    return 0;
  if (!(item->type & MENUFLAG_RADIO) || c == NULL)
    return 1;
  if (item->flags & MENUFLAG_DIALOGATDISABLE)
    return (menu_enabled (item, c));
  return (!menu_enabled (item, c));
}
static void
menu_freeparam (dialogparam * d, CONST struct dialog *di)
{
  switch (di->type)
    {
    case DIALOG_STRING:
    case DIALOG_KEYSTRING:
    case DIALOG_IFILE:
    case DIALOG_OFILE:
      free (d->dstring);
    }
}
void
menu_destroydialog (CONST menuitem * item, dialogparam * d,
		    struct uih_context *uih)
{
  int i;
  CONST struct dialog *di = menu_getdialog (uih, item);
  for (i = 0; di[i].question; i++)
    {
      menu_freeparam (d + i, di + i);
    }
  free (d);

}

void
menu_activate (CONST menuitem * item, struct uih_context *c, dialogparam * d)
{
  if (c == NULL
      && (!(item->flags & MENUFLAG_ATSTARTUP) || firstqueue != NULL))
    {
      menu_addqueue (item, d);
      return;
    }
  else
    {
      if (c != NULL && c->incalculation && !(item->flags & MENUFLAG_INCALC))
	{
	  if (c->flags & MENUFLAG_INTERRUPT)
	    c->interrupt = 1;
	  menu_addqueue (item, d);
	  return;
	}
    }
  switch (item->type)
    {
    case MENU_SEPARATOR:
      x_error ("separator activated!");
      break;
    case MENU_SUBMENU:
      x_error ("submenu activated!");
      break;
    case MENU_NOPARAM:
      ((void (*)(struct uih_context *)) item->function) (c);
      break;
    case MENU_INT:
      ((void (*)(struct uih_context *, int)) item->function) (c,
							      item->iparam);
      break;
    case MENU_STRING:
      ((void (*)(struct uih_context *, CONST char *)) item->function) (c,
								       (CONST
									char
									*)
								       item->
								       pparam);
      break;
    case MENU_DIALOG:
    case MENU_CUSTOMDIALOG:
      if (!menu_havedialog (item, c))
	{
	  ((void (*)(struct uih_context * c, dialogparam *)) item->function)
	    (c, (dialogparam *) NULL);
	}
      else
	{
	  CONST menudialog *di = menu_getdialog (c, item);
	  if (di[0].question == NULL)
	    {
	      ((void (*)(struct uih_context * c, dialogparam *)) item->
	       function) (c, (dialogparam *) NULL);
	      break;
	    }
	  else if (di[1].question == NULL)
	    {
	      /*call function with right
	       *parameter. This avoids need to write wrappers*/
	      switch (di[0].type)
		{
		case DIALOG_INT:
		case DIALOG_CHOICE:
		case DIALOG_ONOFF:
		  ((void (*)(struct uih_context * c, int)) item->function) (c,
									    d
									    [0].
									    dint);
		  break;
		case DIALOG_FLOAT:
		  ((void (*)(struct uih_context * c, number_t)) item->
		   function) (c, d[0].number);
		  break;
		case DIALOG_COORD:
		  ((void (*)(struct uih_context * c, number_t, number_t))
		   item->function) (c, d[0].dcoord[0], d[0].dcoord[1]);
		  break;
		case DIALOG_STRING:
		case DIALOG_KEYSTRING:
		  ((void (*)(struct uih_context * c, char *)) item->function)
		    (c, d[0].dstring);
		  break;
		case DIALOG_IFILE:
		case DIALOG_OFILE:
		  ((void (*)(struct uih_context * c, xio_path)) item->
		   function) (c, d[0].dpath);
		  break;
		default:
		  x_error ("dialog:unknown type!");
		  break;
		}

	    }
	  else
	    ((void (*)(struct uih_context * c, dialogparam *)) item->function)
	      (c, d);
	}
      break;
    default:
      x_error ("Menu_activate: unknown type %i!", item->type);
      break;
    }
}
int
menu_enabled (CONST menuitem * item, struct uih_context *c)
{
  if (item->flags & (MENUFLAG_RADIO | MENUFLAG_CHECKBOX))
    switch (item->type)
      {
      case MENU_SEPARATOR:
	return 0;
      case MENU_SUBMENU:
      case MENU_DIALOG:
      case MENU_NOPARAM:
      case MENU_CUSTOMDIALOG:
	return (((int (*)(struct uih_context *)) item->control) (c));
      case MENU_INT:
	return (((int (*)(struct uih_context *, int)) item->control) (c,
								      item->
								      iparam));
      case MENU_STRING:
	return (((int (*)(struct uih_context *, CONST char *)) item->control)
		(c, (CONST char *) item->pparam));
      default:
	x_error ("Menu_enabled: unknown type!");
	break;
      }
  return 0;
}

void
menu_delnumbered (int n, CONST char *name)
{
  menuitem *items;
  int i;
  char s[256];
  sprintf (s, "%s%i", name, 0);
  items = (menuitem *) menu_findcommand (s);
  menu_delete (items, n);
  for (i = 0; i < n; i++)
    {
      if (items[i].key)
	free ((char *) items[i].key);
      free ((char *) items[i].shortname);
    }
  free (items);
}
CONST menuitem *
menu_genernumbered (int n, CONST char *menuname,
		    CONST char *CONST * CONST names, CONST char *keys,
		    int type, int flags,
		    void (*function) (struct uih_context * context, int),
		    int (*control) (struct uih_context * context, int),
		    CONST char *prefix)
{
  int l = keys != NULL ? (int) strlen (keys) : -1;
  int i;
  menuitem *item = (menuitem *) malloc (sizeof (menuitem) * n);
  if (item == NULL)
    return NULL;
  for (i = 0; i < n; i++)
    {
      item[i].menuname = menuname;
      if (i < l)
	{
	  char *key = malloc (2);
	  item[i].key = key;
	  key[0] = keys[i];
	  key[1] = 0;
	}
      else
	item[i].key = 0;
      item[i].type = type;
      item[i].flags = flags;
      item[i].iparam = i;
      item[i].name = names[i];
      item[i].shortname = names[i];
      if (prefix != NULL)
	{
	  char *shortname = (char *) malloc (strlen (prefix) + 4);
	  item[i].shortname = shortname;
	  sprintf (shortname, "%s%i", prefix, i);
	}
      item[i].function = (void (*)(void)) function;
      item[i].control = (int (*)(void)) control;
    }
  menu_add (item, n);
  return (item);
}

number_t
menu_getfloat (CONST char *s, CONST char **error)
{
#ifdef HAVE_LONG_DOUBLE
  long double param = 0;
#else
  double param = 0;
#endif
#ifdef HAVE_LONG_DOUBLE
#ifndef USE_ATOLD
#ifdef USE_XLDIO
  param = x_strtold (s, NULL);
  if (0)
#else
  if (sscanf (s, "%LG", &param) == 0)
#endif
#else
  param = _atold (s);
  if (0)
#endif
    {
#else
  if (sscanf (s, "%lG", &param) == 0)
    {
#endif
      *error = "Floating point number expected";
      return 0;
    }
  return (param);
}

int menuparse_scheme = 0;
CONST char *
menu_fillparam (struct uih_context *uih, tokenfunc f, CONST menudialog * d,
		dialogparam * p)
{
  char *c = f (uih);
  CONST char *error = NULL;
  if (c == NULL)
    return "Parameter expected";
  switch (d->type)
    {
    case DIALOG_INT:
      if (sscanf (c, "%i", &p->dint) != 1)
	{
	  return "Integer parameter expected";
	}
      break;
    case DIALOG_FLOAT:
      p->number = menu_getfloat (c, &error);
      if (error != NULL)
	return (error);
      break;
    case DIALOG_COORD:
      p->dcoord[0] = menu_getfloat (c, &error);
      if (error != NULL)
	return (error);
      c = f (uih);
      if (c == NULL)
	return "Imaginary part expected";
      p->dcoord[1] = menu_getfloat (c, &error);
      if (error != NULL)
	return (error);
      break;
    case DIALOG_KEYSTRING:
      if (menuparse_scheme)
	{
	  if (c[0] != '\'')
	    return "Key string parameter expected";
	  p->dstring = mystrdup (c + 1);
	}
      else
	p->dstring = mystrdup (c);
      break;
    case DIALOG_STRING:
      if (menuparse_scheme)
	{
	  int l = strlen (c);
	  if (l < 2 || c[0] != '"' || c[l - 1] != '"')
	    return "String parameter expected";
	  p->dstring = mystrdup (c + 1);
	  p->dstring[l - 2] = 0;
	}
      else
	p->dstring = mystrdup (c);
      break;
    case DIALOG_IFILE:
    case DIALOG_OFILE:
      if (menuparse_scheme)
	{
	  int l = strlen (c);
	  if (l < 2 || c[0] != '"' || c[l - 1] != '"')
	    return "String parameter expected";
	  p->dstring = mystrdup (c + 1);
	  p->dstring[l - 2] = 0;
	}
      else
	p->dstring = mystrdup (c);
      break;
    case DIALOG_CHOICE:
      if (menuparse_scheme)
	{
	  if (c[0] != '\'')
	    return "Key string parameter expected";
	  c++;
	}
      {
	int i;
	CONST char **keys = (CONST char **) d->defstr;
	for (i = 0;; i++)
	  {
	    if (keys[i] == NULL)
	      return "Unknown parameter";
	    if (!strcmp (c, keys[i]))
	      {
		p->dint = i;
		return NULL;
	      }
	  }
      }
    case DIALOG_ONOFF:
      if (menuparse_scheme)
	{
	  if (!strcmp ("#t", c))
	    {
	      p->dint = 1;
	      return NULL;
	    }
	  if (!strcmp ("#f", c))
	    {
	      p->dint = 0;
	      return NULL;
	    }
	}
      else
	{
	  if (!strcmp ("on", c))
	    {
	      p->dint = 1;
	      return NULL;
	    }
	  if (!strcmp ("off", c))
	    {
	      p->dint = 0;
	      return NULL;
	    }
	}
    default:
      x_error ("Unknown dialog parameter type!");
    }				/*switch */
  return NULL;
}
static char errorstr[256];
CONST menuitem *
menu_findcommand (CONST char *name)
{
  struct entry *entry;
  CONST menuitem *item;
  int len;
  len = strlen (name);
  if (len > 100)
    return NULL;
  entry = namehash[HASH (name, len)];
  while (entry != NULL)
    {
      if (!strcmp (entry->item->shortname, name))
	break;
      entry = entry->nextname;
    }
  if (entry == NULL)
    {
      return NULL;
    }
  item = entry->item;
  return (item);
}
CONST char *
menu_processcommand (struct uih_context *uih, tokenfunc f, int scheme,
		     int mask, CONST char *root)
{
  char *c = f (uih);
  CONST menuitem *item;
  menuparse_scheme = scheme;
  if (c == NULL)
    {
      if (!menuparse_scheme)
	return "Command name expected";
      return NULL;
    }
  item = menu_findcommand (c);
  if (item == NULL)
    {
      sprintf (errorstr, "%s:unknown function", c);
      return errorstr;
    }
  if (item->flags & mask)
    {
      sprintf (errorstr,
	       "function '%s' not available in this context (%i, %i)", c,
	       mask, item->flags);
      return errorstr;
    }
  if ((item->flags & MENUFLAG_NOPLAY) && uih != NULL)
    {
      if (root != NULL && !menu_available (item, root))
	{
	  sprintf (errorstr, "function '%s' is disabled", c);
	  return errorstr;
	}
    }

  if ((item->flags & MENUFLAG_CHECKBOX) && scheme)
    {
      int w;
      c = f (uih);
      if (c == NULL)
	{
	  return ("Boolean parameter expected");
	}

      if (!strcmp ("#t", c))
	{
	  w = 1;
	}
      else if (!strcmp ("#f", c))
	{
	  w = 0;
	}
      else
	return "Boolean parameter expected";
      if (w == menu_enabled (item, uih))
	{
	  if (((w != 0) ^ ((item->flags & MENUFLAG_DIALOGATDISABLE) != 0))
	      || (item->type != MENU_DIALOG
		  && item->type != MENU_CUSTOMDIALOG))
	    {
	      return NULL;
	    }
	  else
	    menu_activate (item, uih, NULL);	/*disable it... */
	}
    }
  if (item->type != MENU_DIALOG && item->type != MENU_CUSTOMDIALOG)
    {
      menu_activate (item, uih, NULL);
      return NULL;
    }
  /*So we have some parameters */

  {
    dialogparam *param;
    CONST menudialog *d = menu_getdialog (uih, item);
    int i, n;
    for (n = 0; d[n].question != NULL; n++);
    param = (dialogparam *) malloc (n * sizeof (dialogparam));
    for (i = 0; i < n; i++)
      {
	CONST char *error;
	error = menu_fillparam (uih, f, d + i, param + i);
	if (error != NULL)
	  {
	    sprintf (errorstr, "Function '%s' parameter %i:%s",
		     item->shortname, i, error);
	    for (n = 0; n < i; n++)
	      {
		menu_freeparam (param + i, d + i);
	      }
	    free (param);
	    return errorstr;
	  }
      }
    menu_activate (item, uih, param);
    if (uih != NULL)
      menu_destroydialog (item, param, uih);
  }
  return NULL;
}

static int argpos, margc;
static char **margv;
static int argposs;
static char *
gettoken (struct uih_context *c)
{
  if (argpos == margc)
    return NULL;
  if (argpos == argposs)
    {
      if (!margv[argpos])
	return NULL;
      return (margv[argpos++] + 1);
    }
  else
    return (margv[argpos++]);
}

int
menu_processargs (int n, int argc, char **argv)
{
  CONST char *error;
  argpos = n;
  argposs = n;
  margc = argc;
  margv = argv;
  error = menu_processcommand (NULL, gettoken, 0, MENUFLAG_NOOPTION, "root");
  if (error)
    {
      x_error ("%s", error);
      return -1;
    }
  return (argpos - 2);

}

void
menu_printhelp (void)
{
  struct entry *e = firstitem;
  while (e)
    {
      if (e->item->type == MENU_SEPARATOR)
	{
	  e = e->next;
	  continue;
	}
      if (e->item->type == MENU_SUBMENU
	  && !(e->item->flags & MENUFLAG_NOOPTION))
	{
	  struct entry *e1 = firstitem;
	  int n = 1;
	  while (e1)
	    {
	      /*if (e->item->type == MENU_SEPARATOR) {printf ("\n"); e1=e1->next;continue;} */
	      if (e1->item->type != MENU_SUBMENU
		  && e1->item->type != MENU_SEPARATOR
		  && !(e1->item->flags & MENUFLAG_NOOPTION)
		  && !strcmp (e1->item->menuname, e->item->shortname))
		{
		  if (n)
		    {
		      printf ("\n%s\n\n", e->item->name);
		      n = 0;
		    }
		  printf (" -%-15s", e1->item->shortname);
		  if (menu_havedialog (e1->item, NULL))
		    {
		      CONST menudialog *d = menu_getdialog (NULL, e1->item);
		      while (d->question != NULL)
			{
			  switch (d->type)
			    {
			    case DIALOG_INT:
			      printf ("integer ");
			      break;
			    case DIALOG_FLOAT:
			      printf ("real_number ");
			      break;
			    case DIALOG_COORD:
			      printf ("real_number  real_number ");
			      break;
			    case DIALOG_KEYSTRING:
			    case DIALOG_STRING:
			      printf ("string ");
			      break;
			    case DIALOG_IFILE:
			      printf ("input_file ");
			      break;
			    case DIALOG_OFILE:
			      printf ("output_file ");
			      break;
			    case DIALOG_CHOICE:
			      {
				int i;
				CONST char **keys = (CONST char **) d->defstr;
				for (i = 0;; i++)
				  {
				    if (keys[i] == NULL)
				      break;
				    if (i != 0)
				      putc ('|', stdout);
				    printf ("%s", keys[i]);
				  }
				putc (' ', stdout);
			      }
			      break;
			    case DIALOG_ONOFF:
			      printf ("on|off ");
			    }
			  d++;
			}
		      printf ("\n%14s   ", "");
		    }
		  printf (" %s\n", e1->item->name);
		}
	      e1 = e1->next;
	    }
	}
      e = e->next;
    }
}

void
uih_xshlprintmenu (struct uih_context *c, CONST char *name)
{
  int i = 0;
  int nexti;
  CONST menuitem *item, *nextitem, *lastitem;
  int comma;
  printf ("%%%s\n\n", name);
  printf ("<menuhead><head>%s</head></menuhead>\n", menu_fullname (name));
  printf ("<menuitems><center>\n");
  for (i = 0; (item = menu_item2 (name, i)) != NULL; i++)
    {
      if (item->type == MENU_SEPARATOR)
	printf ("<p>\n");
      else if (item->type == MENU_SUBMENU)
	printf ("<p><submenu><a %s>%s</a>\n", item->shortname, item->name);
      else
	printf ("<p><a %s>%s</a>\n", item->shortname, item->name);
    }
  printf ("</center></menuitems>\n");
  lastitem = NULL;
  for (i = 0; (item = menu_item2 (name, i)) != NULL; i++)
    {
      if (item->type == MENU_SEPARATOR)
	continue;
      if (item->type != MENU_SUBMENU)
	{
	  for (nexti = i + 1;
	       (nextitem = menu_item2 (name, nexti)) != NULL
	       && nextitem->type == MENU_SUBMENU; nexti++);
	  printf ("<node %s, %s, %s, %s>\n", item->shortname,
		  (lastitem != NULL ? lastitem->shortname : ""),
		  nextitem != NULL ? nextitem->shortname : "", name);
	  printf ("%%%s\n", item->shortname);
	  printf ("<head>%s</head>\n", item->name);
	  if (!(item->flags & MENUFLAG_NOPLAY))
	    {
	      printf ("<p><emph>Syntax</emph>:(%s", item->shortname);
	      if (item->flags & MENUFLAG_CHECKBOX)
		printf (" bool");
	      if (item->type == MENU_DIALOG
		  || item->type == MENU_CUSTOMDIALOG)
		{
		  int y;
		  CONST menudialog *di;
		  di = menu_getdialog (c, item);
		  if (item->flags & MENUFLAG_CHECKBOX)
		    printf (" [");
		  for (y = 0; di[y].question != NULL; y++)
		    {
		      switch (di[y].type)
			{
			case DIALOG_INT:
			  printf (" integer");
			  break;
			case DIALOG_FLOAT:
			  printf (" float");
			  break;
			case DIALOG_STRING:
			  printf (" string");
			case DIALOG_KEYSTRING:
			  printf (" keyword");
			  break;
			case DIALOG_IFILE:
			  printf (" file");
			  break;
			case DIALOG_OFILE:
			  printf (" file");
			  break;
			case DIALOG_ONOFF:
			  printf (" bool");
			  break;
			case DIALOG_COORD:
			  printf (" complex");
			  break;
			case DIALOG_CHOICE:
			  printf (" keyword");
			  break;
			}
		    }
		  if (item->flags & MENUFLAG_CHECKBOX)
		    printf (" ]");
		}
	      printf (")\n");
	    }
	  printf ("<p>\n<emph>Available as</emph>: ");
	  comma = 0;
	  if (!(item->flags & MENUFLAG_NOMENU))
	    printf ("menu item"), comma = 1;
	  if (!(item->flags & MENUFLAG_NOOPTION))
	    printf ("%scommand line option", comma ? ", " : ""), comma = 1;
	  if (!(item->flags & MENUFLAG_NOPLAY))
	    printf ("%scommand", comma ? ", " : ""), comma = 1;
	  printf ("\n");
	  printf ("\n");
	  lastitem = item;
	}
    }
}
void
uih_xshlprintmenus (struct uih_context *c)
{
  struct entry *e = firstitem;
  struct entry *nexte;
  struct entry *laste;
  printf ("%%menus\n");
  printf ("<main><head>Menus</head></main>\n");
  printf ("<menuitems><center>\n");
  while (e != NULL)
    {
      if (e->item->type == MENU_SUBMENU)
	printf ("<p><submenu><a %s>%s</a>\n", e->item->shortname,
		e->item->name);
      e = e->next;
    }
  printf ("</center></menuitems>\n");
  e = firstitem;
  laste = NULL;
  while (e != NULL)
    {
      if (e->item->type == MENU_SUBMENU)
	{
	  nexte = e->next;
	  while (nexte != NULL && nexte->item->type != MENU_SUBMENU)
	    nexte = nexte->next;
	  printf ("<node %s, %s, %s, %s>\n", e->item->shortname,
		  (laste != NULL ? laste->item->shortname : ""),
		  nexte != NULL ? nexte->item->shortname : "", "menus");
	  uih_xshlprintmenu (c, e->item->shortname);
	  laste = e;
	}
      e = e->next;
    }
  printf ("%%endmenus");
}

void
menu_forall (struct uih_context *c,
	     void (*callback) (struct uih_context * c, CONST menuitem * item))
{
  struct entry *e = firstitem;
  while (e != NULL)
    {
      callback (c, e->item);
      e = e->next;
    }
}
