[bpt/emacs.git] / src / xmenu.c

/* X Communication module for terminals which understand the X protocol.
   Copyright (C) 1986, 1988 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* X pop-up deck-of-cards menu facility for gnuemacs.
 *
 * Written by Jon Arnold and Roman Budzianowski
 * Mods and rewrite by Robert Krawitz
 *
 */

/* $Source: /u2/third_party/gnuemacs.chow/src/RCS/xmenu.c,v $
 * $Author: rlk $
 * $Locker:  $
 * $Header: xmenu.c,v 1.6 86/08/26 17:23:26 rlk Exp $
 *
 */

#ifndef lint
static char *rcsid_GXMenu_c = "$Header: xmenu.c,v 1.6 86/08/26 17:23:26 rlk Exp $";
#endif	lint
#ifdef XDEBUG
#include <stdio.h>
#endif

/* On 4.3 this loses if it comes after xterm.h.  */
#include <signal.h>
#include "config.h"
#include "lisp.h"
#include "screen.h"
#include "window.h"

/* This may include sys/types.h, and that somehow loses
   if this is not done before the other system files.  */
#include "xterm.h"

/* Load sys/types.h if not already loaded.
   In some systems loading it twice is suicidal.  */
#ifndef makedev
#include <sys/types.h>
#endif

#include "dispextern.h"

#ifdef HAVE_X11
#include "../oldXMenu/XMenu.h"
#else
#include <X/XMenu.h>
#endif

#define min(x,y) (((x) < (y)) ? (x) : (y))
#define max(x,y) (((x) > (y)) ? (x) : (y))

#define NUL 0

#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif TRUE

#ifdef HAVE_X11
extern Display *x_current_display;
#else
#define	ButtonReleaseMask ButtonReleased
#endif /* not HAVE_X11 */

Lisp_Object xmenu_show ();
extern int x_error_handler ();

/*************************************************************/

#if 0
/* Ignoring the args is easiest.  */
xmenu_quit ()
{
  error ("Unknown XMenu error");
}
#endif

DEFUN ("x-popup-menu",Fx_popup_menu, Sx_popup_menu, 1, 2, 0,
  "Pop up a deck-of-cards menu and return user's selection.\n\
ARG is a position specification: a list ((XOFFSET YOFFSET) WINDOW)\n\
where XOFFSET and YOFFSET are positions in characters from the top left\n\
corner of WINDOW's screen.  A mouse-event list will serve for this.\n\
This controls the position of the center of the first line\n\
in the first pane of the menu, not the top left of the menu as a whole.\n\
\n\
MENU is a specifier for a menu.  It is a list of the form\n\
\(TITLE PANE1 PANE2...), and each pane is a list of form\n\
\(TITLE (LINE ITEM)...).  Each line should be a string, and item should\n\
be the return value for that line (i.e. if it is selected.")
       (arg, menu)
     Lisp_Object arg, menu;
{
  int number_of_panes;
  Lisp_Object XMenu_return;
  int XMenu_xpos, XMenu_ypos;
  char **menus;
  char ***names;
  Lisp_Object **obj_list;
  int *items;
  char *title;
  char *error_name;
  Lisp_Object ltitle, selection;
  int i, j;
  SCREEN_PTR s;
  Lisp_Object x, y, window;

  window = Fcar (Fcdr (arg));
  x = Fcar (Fcar (arg));
  y = Fcar (Fcdr (Fcar (arg)));
  CHECK_WINDOW (window, 0);
  CHECK_NUMBER (x, 0);
  CHECK_NUMBER (y, 0);
  s = XSCREEN (WINDOW_SCREEN (XWINDOW (window)));

  XMenu_xpos = FONT_WIDTH (s->display.x->font) * XINT (x);
  XMenu_ypos = FONT_HEIGHT (s->display.x->font) * XINT (y);
  XMenu_xpos += s->display.x->left_pos;
  XMenu_ypos += s->display.x->top_pos;

  ltitle = Fcar (menu);
  CHECK_STRING (ltitle, 1);
  title = (char *) XSTRING (ltitle)->data;
  number_of_panes=list_of_panes (&obj_list, &menus, &names, &items, Fcdr (menu));
#ifdef XDEBUG
  fprintf (stderr, "Panes= %d\n", number_of_panes);
  for (i=0; i < number_of_panes; i++)
    {
      fprintf (stderr, "Pane %d lines %d title %s\n", i, items[i], menus[i]);
      for (j=0; j < items[i]; j++)
	{
	  fprintf (stderr, "    Item %d %s\n", j, names[i][j]);
	}
    }
#endif
  BLOCK_INPUT;
  selection = xmenu_show (ROOT_WINDOW, XMenu_xpos, XMenu_ypos, names, menus,
			  items, number_of_panes, obj_list, title, &error_name);
  UNBLOCK_INPUT;
  /** fprintf (stderr, "selection = %x\n", selection);  **/
  if (selection != NUL)
    {				/* selected something */
      XMenu_return = selection;
    }
  else
    {				/* nothing selected */
      XMenu_return = Qnil;
    }
  /* now free up the strings */
  for (i=0; i < number_of_panes; i++)
    {
      free (names[i]);
      free (obj_list[i]);
    }
  free (menus);
  free (obj_list);
  free (names);
  free (items);
  /*   free (title); */
  if (error_name) error (error_name);
  return XMenu_return;
}

struct indices {
  int pane;
  int line;
};

Lisp_Object
xmenu_show (parent, startx, starty, line_list, pane_list, line_cnt,
		      pane_cnt, item_list, title, error)
     Window parent;		
     int startx, starty;	/* upper left corner position BROKEN */
     char **line_list[];   	/* list of strings for items */
     char *pane_list[];		/* list of pane titles */
     char *title;
     int pane_cnt;		/* total number of panes */
     Lisp_Object *item_list[];	/* All items */
     int line_cnt[];		/* Lines in each pane */
     char **error;		/* Error returned */
{
  XMenu *GXMenu;
  int last, panes, selidx, lpane, status;
  int lines, sofar;
  Lisp_Object entry;
  /* struct indices *datap, *datap_save; */
  char *datap;
  int ulx, uly, width, height;
  int dispwidth, dispheight;
  
  *error = (char *) 0;		/* Initialize error pointer to null */
  GXMenu = XMenuCreate (XDISPLAY parent, "emacs");
  if (GXMenu == NUL)
    {
      *error = "Can't create menu";
      return (0);
    }
  
  for (panes=0, lines=0; panes < pane_cnt; lines += line_cnt[panes], panes++)
    ;
  /* datap = (struct indices *) xmalloc (lines * sizeof (struct indices)); */
  /*datap = (char *) xmalloc (lines * sizeof (char));
    datap_save = datap;*/
  
  for (panes = 0, sofar=0;panes < pane_cnt;sofar +=line_cnt[panes], panes++)
    {
      /* create all the necessary panes */
      lpane = XMenuAddPane (XDISPLAY GXMenu, pane_list[panes], TRUE);
      if (lpane == XM_FAILURE)
	{
	  XMenuDestroy (XDISPLAY GXMenu);
	  *error = "Can't create pane";
	  return (0);
	}
      for (selidx = 0; selidx < line_cnt[panes] ; selidx++)
	{
	  /* add the selection stuff to the menus */
	  /* datap[selidx+sofar].pane = panes;
	     datap[selidx+sofar].line = selidx; */
	  if (XMenuAddSelection (XDISPLAY GXMenu, lpane, 0,
				 line_list[panes][selidx], TRUE)
	      == XM_FAILURE)
	    {
	      XMenuDestroy (XDISPLAY GXMenu);
	      /* free (datap); */
	      *error = "Can't add selection to menu";
	      /* error ("Can't add selection to menu"); */
	      return (0);
	    }
	}
    }
  /* all set and ready to fly */
  XMenuRecompute (XDISPLAY GXMenu);
  dispwidth = DisplayWidth (x_current_display, XDefaultScreen (x_current_display));
  dispheight = DisplayHeight (x_current_display, XDefaultScreen (x_current_display));
  startx = min (startx, dispwidth);
  starty = min (starty, dispheight);
  startx = max (startx, 1);
  starty = max (starty, 1);
  XMenuLocate (XDISPLAY GXMenu, 0, 0, startx, starty,
	       &ulx, &uly, &width, &height);
  if (ulx+width > dispwidth)
    {
      startx -= (ulx + width) - dispwidth;
      ulx = dispwidth - width;
    }
  if (uly+height > dispheight)
    {
      starty -= (uly + height) - dispheight;
      uly = dispheight - height;
    }
  if (ulx < 0) startx -= ulx;
  if (uly < 0) starty -= uly;
    
  XMenuSetFreeze (GXMenu, TRUE);
  panes = selidx = 0;
  
  status = XMenuActivate (XDISPLAY GXMenu, &panes, &selidx,
			  startx, starty, ButtonReleaseMask, &datap);
  switch (status)
    {
    case XM_SUCCESS:
#ifdef XDEBUG
      fprintf (stderr, "pane= %d line = %d\n", panes, selidx);
#endif
      entry = item_list[panes][selidx];
      break;
    case XM_FAILURE:
      /*free (datap_save); */
      XMenuDestroy (XDISPLAY GXMenu);
      *error = "Can't activate menu";
      /* error ("Can't activate menu"); */
    case XM_IA_SELECT:
    case XM_NO_SELECT:
      entry = Qnil;
      break;
    }
  XMenuDestroy (XDISPLAY GXMenu);
  /*free (datap_save);*/
  return (entry);
}

syms_of_xmenu ()
{
  defsubr (&Sx_popup_menu);
}

list_of_panes (vector, panes, names, items, menu)
     Lisp_Object ***vector;	/* RETURN all menu objects */
     char ***panes;		/* RETURN pane names */
     char ****names;		/* RETURN all line names */
     int **items;		/* RETURN number of items per pane */
     Lisp_Object menu;
{
  Lisp_Object tail, item, item1;
  int i;
  
  if (XTYPE (menu) != Lisp_Cons) menu = wrong_type_argument (Qlistp, menu);

  i= XFASTINT (Flength (menu, 1));

  *vector = (Lisp_Object **) xmalloc (i * sizeof (Lisp_Object *));
  *panes = (char **) xmalloc (i * sizeof (char *));
  *items = (int *) xmalloc (i * sizeof (int));
  *names = (char ***) xmalloc (i * sizeof (char **));

  for (i=0, tail = menu; !NULL (tail); tail = Fcdr (tail), i++)
    {
       item = Fcdr (Fcar (tail));
       if (XTYPE (item) != Lisp_Cons) (void) wrong_type_argument (Qlistp, item);
#ifdef XDEBUG
       fprintf (stderr, "list_of_panes check tail, i=%d\n", i);
#endif
       item1 = Fcar (Fcar (tail));
       CHECK_STRING (item1, 1);
#ifdef XDEBUG
       fprintf (stderr, "list_of_panes check pane, i=%d%s\n", i,
		XSTRING (item1)->data);
#endif
       (*panes)[i] = (char *) XSTRING (item1)->data;
       (*items)[i] = list_of_items ((*vector)+i, (*names)+i, item);
       /* (*panes)[i] = (char *) xmalloc ((XSTRING (item1)->size)+1);
	  bcopy (XSTRING (item1)->data, (*panes)[i], XSTRING (item1)->size + 1)
	  ; */
    }
  return i;
}
     

list_of_items (vector, names, pane)  /* get list from emacs and put to vector */
     Lisp_Object **vector;	/* RETURN menu "objects" */
     char ***names;		/* RETURN line names */
     Lisp_Object pane;
{
  Lisp_Object tail, item, item1;
  int i;

  if (XTYPE (pane) != Lisp_Cons) pane = wrong_type_argument (Qlistp, pane);

  i= XFASTINT (Flength (pane, 1));

  *vector = (Lisp_Object *) xmalloc (i * sizeof (Lisp_Object));
  *names = (char **) xmalloc (i * sizeof (char *));

  for (i=0, tail = pane; !NULL (tail); tail = Fcdr (tail), i++)
    {
       item = Fcar (tail);
       if (XTYPE (item) != Lisp_Cons) (void) wrong_type_argument (Qlistp, item);
#ifdef XDEBUG
       fprintf (stderr, "list_of_items check tail, i=%d\n", i);
#endif
       (*vector)[i] =  Fcdr (item);
       item1 = Fcar (item);
       CHECK_STRING (item1, 1);
#ifdef XDEBUG
       fprintf (stderr, "list_of_items check item, i=%d%s\n", i,
		XSTRING (item1)->data);
#endif
       (*names)[i] = (char *) XSTRING (item1)->data;
    }
  return i;
}
Commit	Line	Data
dcfdbac7 JB	1	/* X Communication module for terminals which understand the X protocol.
	2	Copyright (C) 1986, 1988 Free Software Foundation, Inc.
	3
	4	This file is part of GNU Emacs.
	5
	6	GNU Emacs is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 1, or (at your option)
	9	any later version.
	10
	11	GNU Emacs is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GNU Emacs; see the file COPYING. If not, write to
	18	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	/* X pop-up deck-of-cards menu facility for gnuemacs.
	21	*
	22	* Written by Jon Arnold and Roman Budzianowski
	23	* Mods and rewrite by Robert Krawitz
	24	*
	25	*/
	26
	27	/* $Source: /u2/third_party/gnuemacs.chow/src/RCS/xmenu.c,v $
	28	* $Author: rlk $
	29	* $Locker: $
	30	* $Header: xmenu.c,v 1.6 86/08/26 17:23:26 rlk Exp $
	31	*
	32	*/
	33
	34	#ifndef lint
	35	static char *rcsid_GXMenu_c = "$Header: xmenu.c,v 1.6 86/08/26 17:23:26 rlk Exp $";
	36	#endif lint
	37	#ifdef XDEBUG
	38	#include <stdio.h>
	39	#endif
	40
	41	/* On 4.3 this loses if it comes after xterm.h. */
	42	#include <signal.h>
	43	#include "config.h"
	44	#include "lisp.h"
	45	#include "screen.h"
	46	#include "window.h"
	47
	48	/* This may include sys/types.h, and that somehow loses
	49	if this is not done before the other system files. */
	50	#include "xterm.h"
	51
	52	/* Load sys/types.h if not already loaded.
	53	In some systems loading it twice is suicidal. */
	54	#ifndef makedev
	55	#include <sys/types.h>
	56	#endif
	57
	58	#include "dispextern.h"
	59
	60	#ifdef HAVE_X11
	61	#include "../oldXMenu/XMenu.h"
	62	#else
	63	#include <X/XMenu.h>
	64	#endif
65
66	#define min(x,y) (((x) < (y)) ? (x) : (y))
67	#define max(x,y) (((x) > (y)) ? (x) : (y))
68
69	#define NUL 0
70
71	#ifndef TRUE
72	#define TRUE 1
73	#define FALSE 0
74	#endif TRUE
75
76	#ifdef HAVE_X11
77	extern Display *x_current_display;
78	#else
79	#define ButtonReleaseMask ButtonReleased
80	#endif /* not HAVE_X11 */
81
82	Lisp_Object xmenu_show ();
83	extern int x_error_handler ();
84
85	/*************************************************************/
86
87	#if 0
88	/* Ignoring the args is easiest. */
89	xmenu_quit ()
90	{
91	error ("Unknown XMenu error");
92	}
93	#endif
94
95	DEFUN ("x-popup-menu",Fx_popup_menu, Sx_popup_menu, 1, 2, 0,
96	"Pop up a deck-of-cards menu and return user's selection.\n\
97	ARG is a position specification: a list ((XOFFSET YOFFSET) WINDOW)\n\
98	where XOFFSET and YOFFSET are positions in characters from the top left\n\
99	corner of WINDOW's screen. A mouse-event list will serve for this.\n\
100	This controls the position of the center of the first line\n\
101	in the first pane of the menu, not the top left of the menu as a whole.\n\
102	\n\
103	MENU is a specifier for a menu. It is a list of the form\n\
104	\(TITLE PANE1 PANE2...), and each pane is a list of form\n\
105	\(TITLE (LINE ITEM)...). Each line should be a string, and item should\n\
106	be the return value for that line (i.e. if it is selected.")
107	(arg, menu)
108	Lisp_Object arg, menu;
109	{
110	int number_of_panes;
111	Lisp_Object XMenu_return;
112	int XMenu_xpos, XMenu_ypos;
113	char **menus;
114	char ***names;
115	Lisp_Object **obj_list;
116	int *items;
117	char *title;
118	char *error_name;
119	Lisp_Object ltitle, selection;
120	int i, j;
121	SCREEN_PTR s;
122	Lisp_Object x, y, window;
123
124	window = Fcar (Fcdr (arg));
125	x = Fcar (Fcar (arg));
126	y = Fcar (Fcdr (Fcar (arg)));
127	CHECK_WINDOW (window, 0);
128	CHECK_NUMBER (x, 0);
129	CHECK_NUMBER (y, 0);
130	s = XSCREEN (WINDOW_SCREEN (XWINDOW (window)));
131
132	XMenu_xpos = FONT_WIDTH (s->display.x->font) * XINT (x);
133	XMenu_ypos = FONT_HEIGHT (s->display.x->font) * XINT (y);
134	XMenu_xpos += s->display.x->left_pos;
135	XMenu_ypos += s->display.x->top_pos;
136
137	ltitle = Fcar (menu);
138	CHECK_STRING (ltitle, 1);
139	title = (char *) XSTRING (ltitle)->data;
140	number_of_panes=list_of_panes (&obj_list, &menus, &names, &items, Fcdr (menu));
141	#ifdef XDEBUG
142	fprintf (stderr, "Panes= %d\n", number_of_panes);
143	for (i=0; i < number_of_panes; i++)
144	{
145	fprintf (stderr, "Pane %d lines %d title %s\n", i, items[i], menus[i]);
146	for (j=0; j < items[i]; j++)
147	{
148	fprintf (stderr, " Item %d %s\n", j, names[i][j]);
149	}
150	}
151	#endif
152	BLOCK_INPUT;
153	selection = xmenu_show (ROOT_WINDOW, XMenu_xpos, XMenu_ypos, names, menus,
154	items, number_of_panes, obj_list, title, &error_name);
155	UNBLOCK_INPUT;
156	/ fprintf (stderr, "selection = %x\n", selection); /
157	if (selection != NUL)
158	{ /* selected something */
159	XMenu_return = selection;
160	}
161	else
162	{ /* nothing selected */
163	XMenu_return = Qnil;
164	}
165	/* now free up the strings */
166	for (i=0; i < number_of_panes; i++)
167	{
168	free (names[i]);
169	free (obj_list[i]);
170	}
171	free (menus);
172	free (obj_list);
173	free (names);
174	free (items);
175	/* free (title); */
176	if (error_name) error (error_name);
177	return XMenu_return;
178	}
179
180	struct indices {
181	int pane;
182	int line;
183	};
184
185	Lisp_Object
186	xmenu_show (parent, startx, starty, line_list, pane_list, line_cnt,
187	pane_cnt, item_list, title, error)
188	Window parent;
189	int startx, starty; /* upper left corner position BROKEN */
190	char *line_list[]; / list of strings for items */
191	char pane_list[]; / list of pane titles */
192	char *title;
193	int pane_cnt; /* total number of panes */
194	Lisp_Object item_list[]; / All items */
195	int line_cnt[]; /* Lines in each pane */
196	char *error; / Error returned */
197	{
198	XMenu *GXMenu;
199	int last, panes, selidx, lpane, status;
200	int lines, sofar;
201	Lisp_Object entry;
202	/* struct indices datap, datap_save; */
203	char *datap;
204	int ulx, uly, width, height;
205	int dispwidth, dispheight;
206
207	error = (char ) 0; /* Initialize error pointer to null */
208	GXMenu = XMenuCreate (XDISPLAY parent, "emacs");
209	if (GXMenu == NUL)
210	{
211	*error = "Can't create menu";
212	return (0);
213	}
214
215	for (panes=0, lines=0; panes < pane_cnt; lines += line_cnt[panes], panes++)
216	;
217	/* datap = (struct indices ) xmalloc (lines sizeof (struct indices)); */
218	/datap = (char ) xmalloc (lines * sizeof (char));
219	datap_save = datap;*/
220
221	for (panes = 0, sofar=0;panes < pane_cnt;sofar +=line_cnt[panes], panes++)
222	{
223	/* create all the necessary panes */
224	lpane = XMenuAddPane (XDISPLAY GXMenu, pane_list[panes], TRUE);
225	if (lpane == XM_FAILURE)
226	{
227	XMenuDestroy (XDISPLAY GXMenu);
228	*error = "Can't create pane";
229	return (0);
230	}
231	for (selidx = 0; selidx < line_cnt[panes] ; selidx++)
232	{
233	/* add the selection stuff to the menus */
234	/* datap[selidx+sofar].pane = panes;
235	datap[selidx+sofar].line = selidx; */
236	if (XMenuAddSelection (XDISPLAY GXMenu, lpane, 0,
237	line_list[panes][selidx], TRUE)
238	== XM_FAILURE)
239	{
240	XMenuDestroy (XDISPLAY GXMenu);
241	/* free (datap); */
242	*error = "Can't add selection to menu";
243	/* error ("Can't add selection to menu"); */
244	return (0);
245	}
246	}
247	}
248	/* all set and ready to fly */
249	XMenuRecompute (XDISPLAY GXMenu);
250	dispwidth = DisplayWidth (x_current_display, XDefaultScreen (x_current_display));
251	dispheight = DisplayHeight (x_current_display, XDefaultScreen (x_current_display));
252	startx = min (startx, dispwidth);
253	starty = min (starty, dispheight);
254	startx = max (startx, 1);
255	starty = max (starty, 1);
256	XMenuLocate (XDISPLAY GXMenu, 0, 0, startx, starty,
257	&ulx, &uly, &width, &height);
258	if (ulx+width > dispwidth)
259	{
260	startx -= (ulx + width) - dispwidth;
261	ulx = dispwidth - width;
262	}
263	if (uly+height > dispheight)
264	{
265	starty -= (uly + height) - dispheight;
266	uly = dispheight - height;
267	}
268	if (ulx < 0) startx -= ulx;
269	if (uly < 0) starty -= uly;
270
271	XMenuSetFreeze (GXMenu, TRUE);
272	panes = selidx = 0;
273
274	status = XMenuActivate (XDISPLAY GXMenu, &panes, &selidx,
275	startx, starty, ButtonReleaseMask, &datap);
276	switch (status)
277	{
278	case XM_SUCCESS:
279	#ifdef XDEBUG
280	fprintf (stderr, "pane= %d line = %d\n", panes, selidx);
281	#endif
282	entry = item_list[panes][selidx];
283	break;
284	case XM_FAILURE:
285	/free (datap_save); /
286	XMenuDestroy (XDISPLAY GXMenu);
287	*error = "Can't activate menu";
288	/* error ("Can't activate menu"); */
289	case XM_IA_SELECT:
290	case XM_NO_SELECT:
291	entry = Qnil;
292	break;
293	}
294	XMenuDestroy (XDISPLAY GXMenu);
295	/free (datap_save);/
296	return (entry);
297	}
298
299	syms_of_xmenu ()
300	{
301	defsubr (&Sx_popup_menu);
302	}
303
304	list_of_panes (vector, panes, names, items, menu)
305	Lisp_Object **vector; / RETURN all menu objects */
306	char **panes; / RETURN pane names */
307	char ***names; / RETURN all line names */
308	int *items; / RETURN number of items per pane */
309	Lisp_Object menu;
310	{
311	Lisp_Object tail, item, item1;
312	int i;
313
314	if (XTYPE (menu) != Lisp_Cons) menu = wrong_type_argument (Qlistp, menu);
315
316	i= XFASTINT (Flength (menu, 1));
317
318	vector = (Lisp_Object ) xmalloc (i sizeof (Lisp_Object *));
319	panes = (char ) xmalloc (i sizeof (char *));
320	items = (int ) xmalloc (i * sizeof (int));
321	names = (char *) xmalloc (i sizeof (char **));
322
323	for (i=0, tail = menu; !NULL (tail); tail = Fcdr (tail), i++)
324	{
325	item = Fcdr (Fcar (tail));
326	if (XTYPE (item) != Lisp_Cons) (void) wrong_type_argument (Qlistp, item);
327	#ifdef XDEBUG
328	fprintf (stderr, "list_of_panes check tail, i=%d\n", i);
329	#endif
330	item1 = Fcar (Fcar (tail));
331	CHECK_STRING (item1, 1);
332	#ifdef XDEBUG
333	fprintf (stderr, "list_of_panes check pane, i=%d%s\n", i,
334	XSTRING (item1)->data);
335	#endif
336	(panes)[i] = (char ) XSTRING (item1)->data;
337	(items)[i] = list_of_items ((vector)+i, (*names)+i, item);
338	/* (panes)[i] = (char ) xmalloc ((XSTRING (item1)->size)+1);
339	bcopy (XSTRING (item1)->data, (*panes)[i], XSTRING (item1)->size + 1)
340	; */
341	}
342	return i;
343	}
344
345
346	list_of_items (vector, names, pane) /* get list from emacs and put to vector */
347	Lisp_Object *vector; / RETURN menu "objects" */
348	char **names; / RETURN line names */
349	Lisp_Object pane;
350	{
351	Lisp_Object tail, item, item1;
352	int i;
353
354	if (XTYPE (pane) != Lisp_Cons) pane = wrong_type_argument (Qlistp, pane);
355
356	i= XFASTINT (Flength (pane, 1));
357
358	vector = (Lisp_Object ) xmalloc (i * sizeof (Lisp_Object));
359	names = (char ) xmalloc (i sizeof (char *));
360
361	for (i=0, tail = pane; !NULL (tail); tail = Fcdr (tail), i++)
362	{
363	item = Fcar (tail);
364	if (XTYPE (item) != Lisp_Cons) (void) wrong_type_argument (Qlistp, item);
365	#ifdef XDEBUG
366	fprintf (stderr, "list_of_items check tail, i=%d\n", i);
367	#endif
368	(*vector)[i] = Fcdr (item);
369	item1 = Fcar (item);
370	CHECK_STRING (item1, 1);
371	#ifdef XDEBUG
372	fprintf (stderr, "list_of_items check item, i=%d%s\n", i,
373	XSTRING (item1)->data);
374	#endif
375	(names)[i] = (char ) XSTRING (item1)->data;
376	}
377	return i;
378	}