Comment change.
[bpt/emacs.git] / src / xmenu.c
1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1999, 2000, 2001, 2003, 2004
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 /* X pop-up deck-of-cards menu facility for GNU Emacs.
23 *
24 * Written by Jon Arnold and Roman Budzianowski
25 * Mods and rewrite by Robert Krawitz
26 *
27 */
28
29 /* Modified by Fred Pierresteguy on December 93
30 to make the popup menus and menubar use the Xt. */
31
32 /* Rewritten for clarity and GC protection by rms in Feb 94. */
33
34 #include <config.h>
35
36 /* On 4.3 this loses if it comes after xterm.h. */
37 #include <signal.h>
38
39 #include <stdio.h>
40
41 #include "lisp.h"
42 #include "termhooks.h"
43 #include "keyboard.h"
44 #include "keymap.h"
45 #include "frame.h"
46 #include "window.h"
47 #include "blockinput.h"
48 #include "buffer.h"
49 #include "charset.h"
50 #include "coding.h"
51
52 #ifdef MSDOS
53 #include "msdos.h"
54 #endif
55
56 #ifdef HAVE_X_WINDOWS
57 /* This may include sys/types.h, and that somehow loses
58 if this is not done before the other system files. */
59 #include "xterm.h"
60 #endif
61
62 /* Load sys/types.h if not already loaded.
63 In some systems loading it twice is suicidal. */
64 #ifndef makedev
65 #include <sys/types.h>
66 #endif
67
68 #include "dispextern.h"
69
70 #ifdef HAVE_X_WINDOWS
71 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
72 code accepts the Emacs internal encoding. */
73 #undef HAVE_MULTILINGUAL_MENU
74 #ifdef USE_X_TOOLKIT
75 #include "widget.h"
76 #include <X11/Xlib.h>
77 #include <X11/IntrinsicP.h>
78 #include <X11/CoreP.h>
79 #include <X11/StringDefs.h>
80 #include <X11/Shell.h>
81 #ifdef USE_LUCID
82 #include <X11/Xaw/Paned.h>
83 #endif /* USE_LUCID */
84 #include "../lwlib/lwlib.h"
85 #else /* not USE_X_TOOLKIT */
86 #ifndef USE_GTK
87 #include "../oldXMenu/XMenu.h"
88 #endif
89 #endif /* not USE_X_TOOLKIT */
90 #endif /* HAVE_X_WINDOWS */
91
92 #ifndef TRUE
93 #define TRUE 1
94 #define FALSE 0
95 #endif /* no TRUE */
96
97 Lisp_Object Vmenu_updating_frame;
98
99 Lisp_Object Qdebug_on_next_call;
100
101 extern Lisp_Object Qmenu_bar;
102
103 extern Lisp_Object QCtoggle, QCradio;
104
105 extern Lisp_Object Voverriding_local_map;
106 extern Lisp_Object Voverriding_local_map_menu_flag;
107
108 extern Lisp_Object Qoverriding_local_map, Qoverriding_terminal_local_map;
109
110 extern Lisp_Object Qmenu_bar_update_hook;
111
112 #ifdef USE_X_TOOLKIT
113 extern void set_frame_menubar P_ ((FRAME_PTR, int, int));
114 extern XtAppContext Xt_app_con;
115
116 static Lisp_Object xdialog_show P_ ((FRAME_PTR, int, Lisp_Object, char **));
117 static void popup_get_selection P_ ((XEvent *, struct x_display_info *,
118 LWLIB_ID, int));
119
120 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
121
122 #define HAVE_BOXES 1
123 #endif /* USE_X_TOOLKIT */
124
125 #ifdef USE_GTK
126 #include "gtkutil.h"
127 #define HAVE_BOXES 1
128 extern void set_frame_menubar P_ ((FRAME_PTR, int, int));
129 static Lisp_Object xdialog_show P_ ((FRAME_PTR, int, Lisp_Object, char **));
130 #endif
131
132 /* This is how to deal with multibyte text if HAVE_MULTILINGUAL_MENU
133 isn't defined. The use of HAVE_MULTILINGUAL_MENU could probably be
134 confined to an extended version of this with sections of code below
135 using it unconditionally. */
136 #ifdef USE_GTK
137 /* gtk just uses utf-8. */
138 # define ENCODE_MENU_STRING(str) ENCODE_UTF_8 (str)
139 #else
140 /* I'm not convinced ENCODE_SYSTEM is defined correctly, or maybe
141 something else should be used here. Except under MS-Windows it
142 just converts to unibyte, but encoding with `locale-coding-system'
143 seems better -- X may actually display the result correctly, and
144 it's not necessarily equivalent to the unibyte text. -- fx */
145 # define ENCODE_MENU_STRING(str) ENCODE_SYSTEM (str)
146 #endif
147
148 static void push_menu_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
149 Lisp_Object, Lisp_Object, Lisp_Object,
150 Lisp_Object, Lisp_Object));
151 static int update_frame_menubar P_ ((struct frame *));
152 static Lisp_Object xmenu_show P_ ((struct frame *, int, int, int, int,
153 Lisp_Object, char **));
154 static void keymap_panes P_ ((Lisp_Object *, int, int));
155 static void single_keymap_panes P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
156 int, int));
157 static void list_of_panes P_ ((Lisp_Object));
158 static void list_of_items P_ ((Lisp_Object));
159
160 \f
161 /* This holds a Lisp vector that holds the results of decoding
162 the keymaps or alist-of-alists that specify a menu.
163
164 It describes the panes and items within the panes.
165
166 Each pane is described by 3 elements in the vector:
167 t, the pane name, the pane's prefix key.
168 Then follow the pane's items, with 5 elements per item:
169 the item string, the enable flag, the item's value,
170 the definition, and the equivalent keyboard key's description string.
171
172 In some cases, multiple levels of menus may be described.
173 A single vector slot containing nil indicates the start of a submenu.
174 A single vector slot containing lambda indicates the end of a submenu.
175 The submenu follows a menu item which is the way to reach the submenu.
176
177 A single vector slot containing quote indicates that the
178 following items should appear on the right of a dialog box.
179
180 Using a Lisp vector to hold this information while we decode it
181 takes care of protecting all the data from GC. */
182
183 #define MENU_ITEMS_PANE_NAME 1
184 #define MENU_ITEMS_PANE_PREFIX 2
185 #define MENU_ITEMS_PANE_LENGTH 3
186
187 enum menu_item_idx
188 {
189 MENU_ITEMS_ITEM_NAME = 0,
190 MENU_ITEMS_ITEM_ENABLE,
191 MENU_ITEMS_ITEM_VALUE,
192 MENU_ITEMS_ITEM_EQUIV_KEY,
193 MENU_ITEMS_ITEM_DEFINITION,
194 MENU_ITEMS_ITEM_TYPE,
195 MENU_ITEMS_ITEM_SELECTED,
196 MENU_ITEMS_ITEM_HELP,
197 MENU_ITEMS_ITEM_LENGTH
198 };
199
200 static Lisp_Object menu_items;
201
202 /* If non-nil, means that the global vars defined here are already in use.
203 Used to detect cases where we try to re-enter this non-reentrant code. */
204 static Lisp_Object menu_items_inuse;
205
206 /* Number of slots currently allocated in menu_items. */
207 static int menu_items_allocated;
208
209 /* This is the index in menu_items of the first empty slot. */
210 static int menu_items_used;
211
212 /* The number of panes currently recorded in menu_items,
213 excluding those within submenus. */
214 static int menu_items_n_panes;
215
216 /* Current depth within submenus. */
217 static int menu_items_submenu_depth;
218
219 /* Flag which when set indicates a dialog or menu has been posted by
220 Xt on behalf of one of the widget sets. */
221 static int popup_activated_flag;
222
223 static int next_menubar_widget_id;
224
225 /* This is set nonzero after the user activates the menu bar, and set
226 to zero again after the menu bars are redisplayed by prepare_menu_bar.
227 While it is nonzero, all calls to set_frame_menubar go deep.
228
229 I don't understand why this is needed, but it does seem to be
230 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
231
232 int pending_menu_activation;
233 \f
234 #ifdef USE_X_TOOLKIT
235
236 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
237
238 static struct frame *
239 menubar_id_to_frame (id)
240 LWLIB_ID id;
241 {
242 Lisp_Object tail, frame;
243 FRAME_PTR f;
244
245 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
246 {
247 frame = XCAR (tail);
248 if (!GC_FRAMEP (frame))
249 continue;
250 f = XFRAME (frame);
251 if (!FRAME_WINDOW_P (f))
252 continue;
253 if (f->output_data.x->id == id)
254 return f;
255 }
256 return 0;
257 }
258
259 #endif
260 \f
261 /* Initialize the menu_items structure if we haven't already done so.
262 Also mark it as currently empty. */
263
264 static void
265 init_menu_items ()
266 {
267 if (NILP (menu_items))
268 {
269 menu_items_allocated = 60;
270 menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
271 }
272
273 if (!NILP (menu_items_inuse))
274 error ("Trying to use a menu from within a menu-entry");
275 menu_items_inuse = Qt;
276 menu_items_used = 0;
277 menu_items_n_panes = 0;
278 menu_items_submenu_depth = 0;
279 }
280
281 /* Call at the end of generating the data in menu_items. */
282
283 static void
284 finish_menu_items ()
285 {
286 }
287
288 static Lisp_Object
289 unuse_menu_items (dummy)
290 int dummy;
291 {
292 return menu_items_inuse = Qnil;
293 }
294
295 /* Call when finished using the data for the current menu
296 in menu_items. */
297
298 static void
299 discard_menu_items ()
300 {
301 /* Free the structure if it is especially large.
302 Otherwise, hold on to it, to save time. */
303 if (menu_items_allocated > 200)
304 {
305 menu_items = Qnil;
306 menu_items_allocated = 0;
307 }
308 xassert (NILP (menu_items_inuse));
309 }
310
311 /* Make the menu_items vector twice as large. */
312
313 static void
314 grow_menu_items ()
315 {
316 Lisp_Object old;
317 int old_size = menu_items_allocated;
318 old = menu_items;
319
320 menu_items_allocated *= 2;
321 menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
322 bcopy (XVECTOR (old)->contents, XVECTOR (menu_items)->contents,
323 old_size * sizeof (Lisp_Object));
324 }
325
326 /* Begin a submenu. */
327
328 static void
329 push_submenu_start ()
330 {
331 if (menu_items_used + 1 > menu_items_allocated)
332 grow_menu_items ();
333
334 XVECTOR (menu_items)->contents[menu_items_used++] = Qnil;
335 menu_items_submenu_depth++;
336 }
337
338 /* End a submenu. */
339
340 static void
341 push_submenu_end ()
342 {
343 if (menu_items_used + 1 > menu_items_allocated)
344 grow_menu_items ();
345
346 XVECTOR (menu_items)->contents[menu_items_used++] = Qlambda;
347 menu_items_submenu_depth--;
348 }
349
350 /* Indicate boundary between left and right. */
351
352 static void
353 push_left_right_boundary ()
354 {
355 if (menu_items_used + 1 > menu_items_allocated)
356 grow_menu_items ();
357
358 XVECTOR (menu_items)->contents[menu_items_used++] = Qquote;
359 }
360
361 /* Start a new menu pane in menu_items.
362 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
363
364 static void
365 push_menu_pane (name, prefix_vec)
366 Lisp_Object name, prefix_vec;
367 {
368 if (menu_items_used + MENU_ITEMS_PANE_LENGTH > menu_items_allocated)
369 grow_menu_items ();
370
371 if (menu_items_submenu_depth == 0)
372 menu_items_n_panes++;
373 XVECTOR (menu_items)->contents[menu_items_used++] = Qt;
374 XVECTOR (menu_items)->contents[menu_items_used++] = name;
375 XVECTOR (menu_items)->contents[menu_items_used++] = prefix_vec;
376 }
377
378 /* Push one menu item into the current pane. NAME is the string to
379 display. ENABLE if non-nil means this item can be selected. KEY
380 is the key generated by choosing this item, or nil if this item
381 doesn't really have a definition. DEF is the definition of this
382 item. EQUIV is the textual description of the keyboard equivalent
383 for this item (or nil if none). TYPE is the type of this menu
384 item, one of nil, `toggle' or `radio'. */
385
386 static void
387 push_menu_item (name, enable, key, def, equiv, type, selected, help)
388 Lisp_Object name, enable, key, def, equiv, type, selected, help;
389 {
390 if (menu_items_used + MENU_ITEMS_ITEM_LENGTH > menu_items_allocated)
391 grow_menu_items ();
392
393 XVECTOR (menu_items)->contents[menu_items_used++] = name;
394 XVECTOR (menu_items)->contents[menu_items_used++] = enable;
395 XVECTOR (menu_items)->contents[menu_items_used++] = key;
396 XVECTOR (menu_items)->contents[menu_items_used++] = equiv;
397 XVECTOR (menu_items)->contents[menu_items_used++] = def;
398 XVECTOR (menu_items)->contents[menu_items_used++] = type;
399 XVECTOR (menu_items)->contents[menu_items_used++] = selected;
400 XVECTOR (menu_items)->contents[menu_items_used++] = help;
401 }
402 \f
403 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
404 and generate menu panes for them in menu_items.
405 If NOTREAL is nonzero,
406 don't bother really computing whether an item is enabled. */
407
408 static void
409 keymap_panes (keymaps, nmaps, notreal)
410 Lisp_Object *keymaps;
411 int nmaps;
412 int notreal;
413 {
414 int mapno;
415
416 init_menu_items ();
417
418 /* Loop over the given keymaps, making a pane for each map.
419 But don't make a pane that is empty--ignore that map instead.
420 P is the number of panes we have made so far. */
421 for (mapno = 0; mapno < nmaps; mapno++)
422 single_keymap_panes (keymaps[mapno],
423 Fkeymap_prompt (keymaps[mapno]), Qnil, notreal, 10);
424
425 finish_menu_items ();
426 }
427
428 /* Args passed between single_keymap_panes and single_menu_item. */
429 struct skp
430 {
431 Lisp_Object pending_maps;
432 int maxdepth, notreal;
433 int notbuttons;
434 };
435
436 static void single_menu_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
437 void *));
438
439 /* This is a recursive subroutine of keymap_panes.
440 It handles one keymap, KEYMAP.
441 The other arguments are passed along
442 or point to local variables of the previous function.
443 If NOTREAL is nonzero, only check for equivalent key bindings, don't
444 evaluate expressions in menu items and don't make any menu.
445
446 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
447
448 static void
449 single_keymap_panes (keymap, pane_name, prefix, notreal, maxdepth)
450 Lisp_Object keymap;
451 Lisp_Object pane_name;
452 Lisp_Object prefix;
453 int notreal;
454 int maxdepth;
455 {
456 struct skp skp;
457 struct gcpro gcpro1;
458
459 skp.pending_maps = Qnil;
460 skp.maxdepth = maxdepth;
461 skp.notreal = notreal;
462 skp.notbuttons = 0;
463
464 if (maxdepth <= 0)
465 return;
466
467 push_menu_pane (pane_name, prefix);
468
469 #ifndef HAVE_BOXES
470 /* Remember index for first item in this pane so we can go back and
471 add a prefix when (if) we see the first button. After that, notbuttons
472 is set to 0, to mark that we have seen a button and all non button
473 items need a prefix. */
474 skp.notbuttons = menu_items_used;
475 #endif
476
477 GCPRO1 (skp.pending_maps);
478 map_keymap (keymap, single_menu_item, Qnil, &skp, 1);
479 UNGCPRO;
480
481 /* Process now any submenus which want to be panes at this level. */
482 while (CONSP (skp.pending_maps))
483 {
484 Lisp_Object elt, eltcdr, string;
485 elt = XCAR (skp.pending_maps);
486 eltcdr = XCDR (elt);
487 string = XCAR (eltcdr);
488 /* We no longer discard the @ from the beginning of the string here.
489 Instead, we do this in xmenu_show. */
490 single_keymap_panes (Fcar (elt), string,
491 XCDR (eltcdr), notreal, maxdepth - 1);
492 skp.pending_maps = XCDR (skp.pending_maps);
493 }
494 }
495 \f
496 /* This is a subroutine of single_keymap_panes that handles one
497 keymap entry.
498 KEY is a key in a keymap and ITEM is its binding.
499 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
500 separate panes.
501 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
502 evaluate expressions in menu items and don't make any menu.
503 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
504 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
505 buttons. It keeps track of if we have seen a button in this menu or
506 not. */
507
508 static void
509 single_menu_item (key, item, dummy, skp_v)
510 Lisp_Object key, item, dummy;
511 void *skp_v;
512 {
513 Lisp_Object map, item_string, enabled;
514 struct gcpro gcpro1, gcpro2;
515 int res;
516 struct skp *skp = skp_v;
517
518 /* Parse the menu item and leave the result in item_properties. */
519 GCPRO2 (key, item);
520 res = parse_menu_item (item, skp->notreal, 0);
521 UNGCPRO;
522 if (!res)
523 return; /* Not a menu item. */
524
525 map = XVECTOR (item_properties)->contents[ITEM_PROPERTY_MAP];
526
527 if (skp->notreal)
528 {
529 /* We don't want to make a menu, just traverse the keymaps to
530 precompute equivalent key bindings. */
531 if (!NILP (map))
532 single_keymap_panes (map, Qnil, key, 1, skp->maxdepth - 1);
533 return;
534 }
535
536 enabled = XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE];
537 item_string = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
538
539 if (!NILP (map) && SREF (item_string, 0) == '@')
540 {
541 if (!NILP (enabled))
542 /* An enabled separate pane. Remember this to handle it later. */
543 skp->pending_maps = Fcons (Fcons (map, Fcons (item_string, key)),
544 skp->pending_maps);
545 return;
546 }
547
548 #ifndef HAVE_BOXES
549 /* Simulate radio buttons and toggle boxes by putting a prefix in
550 front of them. */
551 {
552 Lisp_Object prefix = Qnil;
553 Lisp_Object type = XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE];
554 if (!NILP (type))
555 {
556 Lisp_Object selected
557 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED];
558
559 if (skp->notbuttons)
560 /* The first button. Line up previous items in this menu. */
561 {
562 int index = skp->notbuttons; /* Index for first item this menu. */
563 int submenu = 0;
564 Lisp_Object tem;
565 while (index < menu_items_used)
566 {
567 tem
568 = XVECTOR (menu_items)->contents[index + MENU_ITEMS_ITEM_NAME];
569 if (NILP (tem))
570 {
571 index++;
572 submenu++; /* Skip sub menu. */
573 }
574 else if (EQ (tem, Qlambda))
575 {
576 index++;
577 submenu--; /* End sub menu. */
578 }
579 else if (EQ (tem, Qt))
580 index += 3; /* Skip new pane marker. */
581 else if (EQ (tem, Qquote))
582 index++; /* Skip a left, right divider. */
583 else
584 {
585 if (!submenu && SREF (tem, 0) != '\0'
586 && SREF (tem, 0) != '-')
587 XVECTOR (menu_items)->contents[index + MENU_ITEMS_ITEM_NAME]
588 = concat2 (build_string (" "), tem);
589 index += MENU_ITEMS_ITEM_LENGTH;
590 }
591 }
592 skp->notbuttons = 0;
593 }
594
595 /* Calculate prefix, if any, for this item. */
596 if (EQ (type, QCtoggle))
597 prefix = build_string (NILP (selected) ? "[ ] " : "[X] ");
598 else if (EQ (type, QCradio))
599 prefix = build_string (NILP (selected) ? "( ) " : "(*) ");
600 }
601 /* Not a button. If we have earlier buttons, then we need a prefix. */
602 else if (!skp->notbuttons && SREF (item_string, 0) != '\0'
603 && SREF (item_string, 0) != '-')
604 prefix = build_string (" ");
605
606 if (!NILP (prefix))
607 item_string = concat2 (prefix, item_string);
608 }
609 #endif /* not HAVE_BOXES */
610
611 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
612 if (!NILP (map))
613 /* Indicate visually that this is a submenu. */
614 item_string = concat2 (item_string, build_string (" >"));
615 #endif
616
617 push_menu_item (item_string, enabled, key,
618 XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF],
619 XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ],
620 XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE],
621 XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED],
622 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP]);
623
624 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
625 /* Display a submenu using the toolkit. */
626 if (! (NILP (map) || NILP (enabled)))
627 {
628 push_submenu_start ();
629 single_keymap_panes (map, Qnil, key, 0, skp->maxdepth - 1);
630 push_submenu_end ();
631 }
632 #endif
633 }
634 \f
635 /* Push all the panes and items of a menu described by the
636 alist-of-alists MENU.
637 This handles old-fashioned calls to x-popup-menu. */
638
639 static void
640 list_of_panes (menu)
641 Lisp_Object menu;
642 {
643 Lisp_Object tail;
644
645 init_menu_items ();
646
647 for (tail = menu; !NILP (tail); tail = Fcdr (tail))
648 {
649 Lisp_Object elt, pane_name, pane_data;
650 elt = Fcar (tail);
651 pane_name = Fcar (elt);
652 CHECK_STRING (pane_name);
653 push_menu_pane (ENCODE_MENU_STRING (pane_name), Qnil);
654 pane_data = Fcdr (elt);
655 CHECK_CONS (pane_data);
656 list_of_items (pane_data);
657 }
658
659 finish_menu_items ();
660 }
661
662 /* Push the items in a single pane defined by the alist PANE. */
663
664 static void
665 list_of_items (pane)
666 Lisp_Object pane;
667 {
668 Lisp_Object tail, item, item1;
669
670 for (tail = pane; !NILP (tail); tail = Fcdr (tail))
671 {
672 item = Fcar (tail);
673 if (STRINGP (item))
674 push_menu_item (ENCODE_MENU_STRING (item), Qnil, Qnil, Qt,
675 Qnil, Qnil, Qnil, Qnil);
676 else if (NILP (item))
677 push_left_right_boundary ();
678 else
679 {
680 CHECK_CONS (item);
681 item1 = Fcar (item);
682 CHECK_STRING (item1);
683 push_menu_item (ENCODE_MENU_STRING (item1), Qt, Fcdr (item),
684 Qt, Qnil, Qnil, Qnil, Qnil);
685 }
686 }
687 }
688 \f
689 #ifdef HAVE_X_WINDOWS
690 /* Return the mouse position in *X and *Y. The coordinates are window
691 relative for the edit window in frame F.
692 This is for Fx_popup_menu. The mouse_position_hook can not
693 be used for X, as it returns window relative coordinates
694 for the window where the mouse is in. This could be the menu bar,
695 the scroll bar or the edit window. Fx_popup_menu needs to be
696 sure it is the edit window. */
697 static void
698 mouse_position_for_popup (f, x, y)
699 FRAME_PTR f;
700 int *x;
701 int *y;
702 {
703 Window root, dummy_window;
704 int dummy;
705
706 BLOCK_INPUT;
707
708 XQueryPointer (FRAME_X_DISPLAY (f),
709 DefaultRootWindow (FRAME_X_DISPLAY (f)),
710
711 /* The root window which contains the pointer. */
712 &root,
713
714 /* Window pointer is on, not used */
715 &dummy_window,
716
717 /* The position on that root window. */
718 x, y,
719
720 /* x/y in dummy_window coordinates, not used. */
721 &dummy, &dummy,
722
723 /* Modifier keys and pointer buttons, about which
724 we don't care. */
725 (unsigned int *) &dummy);
726
727 UNBLOCK_INPUT;
728
729 /* xmenu_show expects window coordinates, not root window
730 coordinates. Translate. */
731 *x -= f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
732 *y -= f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
733 }
734
735 #endif /* HAVE_X_WINDOWS */
736
737 DEFUN ("x-popup-menu", Fx_popup_menu, Sx_popup_menu, 2, 2, 0,
738 doc: /* Pop up a deck-of-cards menu and return user's selection.
739 POSITION is a position specification. This is either a mouse button event
740 or a list ((XOFFSET YOFFSET) WINDOW)
741 where XOFFSET and YOFFSET are positions in pixels from the top left
742 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)
743 This controls the position of the center of the first line
744 in the first pane of the menu, not the top left of the menu as a whole.
745 If POSITION is t, it means to use the current mouse position.
746
747 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
748 The menu items come from key bindings that have a menu string as well as
749 a definition; actually, the "definition" in such a key binding looks like
750 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
751 the keymap as a top-level element.
752
753 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
754 Otherwise, REAL-DEFINITION should be a valid key binding definition.
755
756 You can also use a list of keymaps as MENU.
757 Then each keymap makes a separate pane.
758 When MENU is a keymap or a list of keymaps, the return value
759 is a list of events.
760
761 Alternatively, you can specify a menu of multiple panes
762 with a list of the form (TITLE PANE1 PANE2...),
763 where each pane is a list of form (TITLE ITEM1 ITEM2...).
764 Each ITEM is normally a cons cell (STRING . VALUE);
765 but a string can appear as an item--that makes a nonselectable line
766 in the menu.
767 With this form of menu, the return value is VALUE from the chosen item.
768
769 If POSITION is nil, don't display the menu at all, just precalculate the
770 cached information about equivalent key sequences. */)
771 (position, menu)
772 Lisp_Object position, menu;
773 {
774 Lisp_Object keymap, tem;
775 int xpos = 0, ypos = 0;
776 Lisp_Object title;
777 char *error_name;
778 Lisp_Object selection;
779 FRAME_PTR f = NULL;
780 Lisp_Object x, y, window;
781 int keymaps = 0;
782 int for_click = 0;
783 int specpdl_count = SPECPDL_INDEX ();
784 struct gcpro gcpro1;
785
786 #ifdef HAVE_MENUS
787 if (! NILP (position))
788 {
789 int get_current_pos_p = 0;
790 check_x ();
791
792 /* Decode the first argument: find the window and the coordinates. */
793 if (EQ (position, Qt)
794 || (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
795 || EQ (XCAR (position), Qtool_bar))))
796 {
797 get_current_pos_p = 1;
798 }
799 else
800 {
801 tem = Fcar (position);
802 if (CONSP (tem))
803 {
804 window = Fcar (Fcdr (position));
805 x = Fcar (tem);
806 y = Fcar (Fcdr (tem));
807 }
808 else
809 {
810 for_click = 1;
811 tem = Fcar (Fcdr (position)); /* EVENT_START (position) */
812 window = Fcar (tem); /* POSN_WINDOW (tem) */
813 tem = Fcar (Fcdr (Fcdr (tem))); /* POSN_WINDOW_POSN (tem) */
814 x = Fcar (tem);
815 y = Fcdr (tem);
816 }
817
818 /* If a click happens in an external tool bar or a detached
819 tool bar, x and y is NIL. In that case, use the current
820 mouse position. This happens for the help button in the
821 tool bar. Ideally popup-menu should pass NIL to
822 this function, but it doesn't. */
823 if (NILP (x) && NILP (y))
824 get_current_pos_p = 1;
825 }
826
827 if (get_current_pos_p)
828 {
829 /* Use the mouse's current position. */
830 FRAME_PTR new_f = SELECTED_FRAME ();
831 #ifdef HAVE_X_WINDOWS
832 /* Can't use mouse_position_hook for X since it returns
833 coordinates relative to the window the mouse is in,
834 we need coordinates relative to the edit widget always. */
835 if (new_f != 0)
836 {
837 int cur_x, cur_y;
838
839 mouse_position_for_popup (new_f, &cur_x, &cur_y);
840 /* cur_x/y may be negative, so use make_number. */
841 x = make_number (cur_x);
842 y = make_number (cur_y);
843 }
844
845 #else /* not HAVE_X_WINDOWS */
846 Lisp_Object bar_window;
847 enum scroll_bar_part part;
848 unsigned long time;
849
850 if (mouse_position_hook)
851 (*mouse_position_hook) (&new_f, 1, &bar_window,
852 &part, &x, &y, &time);
853 #endif /* not HAVE_X_WINDOWS */
854
855 if (new_f != 0)
856 XSETFRAME (window, new_f);
857 else
858 {
859 window = selected_window;
860 XSETFASTINT (x, 0);
861 XSETFASTINT (y, 0);
862 }
863 }
864
865 CHECK_NUMBER (x);
866 CHECK_NUMBER (y);
867
868 /* Decode where to put the menu. */
869
870 if (FRAMEP (window))
871 {
872 f = XFRAME (window);
873 xpos = 0;
874 ypos = 0;
875 }
876 else if (WINDOWP (window))
877 {
878 CHECK_LIVE_WINDOW (window);
879 f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
880
881 xpos = WINDOW_LEFT_EDGE_X (XWINDOW (window));
882 ypos = WINDOW_TOP_EDGE_Y (XWINDOW (window));
883 }
884 else
885 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
886 but I don't want to make one now. */
887 CHECK_WINDOW (window);
888
889 xpos += XINT (x);
890 ypos += XINT (y);
891 }
892 Vmenu_updating_frame = Qnil;
893 #endif /* HAVE_MENUS */
894
895 record_unwind_protect (unuse_menu_items, Qnil);
896 title = Qnil;
897 GCPRO1 (title);
898
899 /* Decode the menu items from what was specified. */
900
901 keymap = get_keymap (menu, 0, 0);
902 if (CONSP (keymap))
903 {
904 /* We were given a keymap. Extract menu info from the keymap. */
905 Lisp_Object prompt;
906
907 /* Extract the detailed info to make one pane. */
908 keymap_panes (&menu, 1, NILP (position));
909
910 /* Search for a string appearing directly as an element of the keymap.
911 That string is the title of the menu. */
912 prompt = Fkeymap_prompt (keymap);
913 if (NILP (title) && !NILP (prompt))
914 title = prompt;
915
916 /* Make that be the pane title of the first pane. */
917 if (!NILP (prompt) && menu_items_n_panes >= 0)
918 XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_NAME] = prompt;
919
920 keymaps = 1;
921 }
922 else if (CONSP (menu) && KEYMAPP (XCAR (menu)))
923 {
924 /* We were given a list of keymaps. */
925 int nmaps = XFASTINT (Flength (menu));
926 Lisp_Object *maps
927 = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
928 int i;
929
930 title = Qnil;
931
932 /* The first keymap that has a prompt string
933 supplies the menu title. */
934 for (tem = menu, i = 0; CONSP (tem); tem = Fcdr (tem))
935 {
936 Lisp_Object prompt;
937
938 maps[i++] = keymap = get_keymap (Fcar (tem), 1, 0);
939
940 prompt = Fkeymap_prompt (keymap);
941 if (NILP (title) && !NILP (prompt))
942 title = prompt;
943 }
944
945 /* Extract the detailed info to make one pane. */
946 keymap_panes (maps, nmaps, NILP (position));
947
948 /* Make the title be the pane title of the first pane. */
949 if (!NILP (title) && menu_items_n_panes >= 0)
950 XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_NAME] = title;
951
952 keymaps = 1;
953 }
954 else
955 {
956 /* We were given an old-fashioned menu. */
957 title = Fcar (menu);
958 CHECK_STRING (title);
959
960 list_of_panes (Fcdr (menu));
961
962 keymaps = 0;
963 }
964
965 unbind_to (specpdl_count, Qnil);
966
967 if (NILP (position))
968 {
969 discard_menu_items ();
970 UNGCPRO;
971 return Qnil;
972 }
973
974 #ifdef HAVE_MENUS
975 /* Display them in a menu. */
976 BLOCK_INPUT;
977
978 selection = xmenu_show (f, xpos, ypos, for_click,
979 keymaps, title, &error_name);
980 UNBLOCK_INPUT;
981
982 discard_menu_items ();
983
984 UNGCPRO;
985 #endif /* HAVE_MENUS */
986
987 if (error_name) error (error_name);
988 return selection;
989 }
990
991 #ifdef HAVE_MENUS
992
993 DEFUN ("x-popup-dialog", Fx_popup_dialog, Sx_popup_dialog, 2, 2, 0,
994 doc: /* Pop up a dialog box and return user's selection.
995 POSITION specifies which frame to use.
996 This is normally a mouse button event or a window or frame.
997 If POSITION is t, it means to use the frame the mouse is on.
998 The dialog box appears in the middle of the specified frame.
999
1000 CONTENTS specifies the alternatives to display in the dialog box.
1001 It is a list of the form (TITLE ITEM1 ITEM2...).
1002 Each ITEM is a cons cell (STRING . VALUE).
1003 The return value is VALUE from the chosen item.
1004
1005 An ITEM may also be just a string--that makes a nonselectable item.
1006 An ITEM may also be nil--that means to put all preceding items
1007 on the left of the dialog box and all following items on the right.
1008 \(By default, approximately half appear on each side.) */)
1009 (position, contents)
1010 Lisp_Object position, contents;
1011 {
1012 FRAME_PTR f = NULL;
1013 Lisp_Object window;
1014
1015 check_x ();
1016
1017 /* Decode the first argument: find the window or frame to use. */
1018 if (EQ (position, Qt)
1019 || (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
1020 || EQ (XCAR (position), Qtool_bar))))
1021 {
1022 #if 0 /* Using the frame the mouse is on may not be right. */
1023 /* Use the mouse's current position. */
1024 FRAME_PTR new_f = SELECTED_FRAME ();
1025 Lisp_Object bar_window;
1026 enum scroll_bar_part part;
1027 unsigned long time;
1028 Lisp_Object x, y;
1029
1030 (*mouse_position_hook) (&new_f, 1, &bar_window, &part, &x, &y, &time);
1031
1032 if (new_f != 0)
1033 XSETFRAME (window, new_f);
1034 else
1035 window = selected_window;
1036 #endif
1037 window = selected_window;
1038 }
1039 else if (CONSP (position))
1040 {
1041 Lisp_Object tem;
1042 tem = Fcar (position);
1043 if (CONSP (tem))
1044 window = Fcar (Fcdr (position));
1045 else
1046 {
1047 tem = Fcar (Fcdr (position)); /* EVENT_START (position) */
1048 window = Fcar (tem); /* POSN_WINDOW (tem) */
1049 }
1050 }
1051 else if (WINDOWP (position) || FRAMEP (position))
1052 window = position;
1053 else
1054 window = Qnil;
1055
1056 /* Decode where to put the menu. */
1057
1058 if (FRAMEP (window))
1059 f = XFRAME (window);
1060 else if (WINDOWP (window))
1061 {
1062 CHECK_LIVE_WINDOW (window);
1063 f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
1064 }
1065 else
1066 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1067 but I don't want to make one now. */
1068 CHECK_WINDOW (window);
1069
1070 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1071 /* Display a menu with these alternatives
1072 in the middle of frame F. */
1073 {
1074 Lisp_Object x, y, frame, newpos;
1075 XSETFRAME (frame, f);
1076 XSETINT (x, x_pixel_width (f) / 2);
1077 XSETINT (y, x_pixel_height (f) / 2);
1078 newpos = Fcons (Fcons (x, Fcons (y, Qnil)), Fcons (frame, Qnil));
1079
1080 return Fx_popup_menu (newpos,
1081 Fcons (Fcar (contents), Fcons (contents, Qnil)));
1082 }
1083 #else
1084 {
1085 Lisp_Object title;
1086 char *error_name;
1087 Lisp_Object selection;
1088 int specpdl_count = SPECPDL_INDEX ();
1089
1090 /* Decode the dialog items from what was specified. */
1091 title = Fcar (contents);
1092 CHECK_STRING (title);
1093 record_unwind_protect (unuse_menu_items, Qnil);
1094
1095 if (NILP (Fcar (Fcdr (contents))))
1096 /* No buttons specified, add an "Ok" button so users can pop down
1097 the dialog. Also, the lesstif/motif version crashes if there are
1098 no buttons. */
1099 contents = Fcons (title, Fcons (Fcons (build_string ("Ok"), Qt), Qnil));
1100
1101 list_of_panes (Fcons (contents, Qnil));
1102
1103 /* Display them in a dialog box. */
1104 BLOCK_INPUT;
1105 selection = xdialog_show (f, 0, title, &error_name);
1106 UNBLOCK_INPUT;
1107
1108 unbind_to (specpdl_count, Qnil);
1109 discard_menu_items ();
1110
1111 if (error_name) error (error_name);
1112 return selection;
1113 }
1114 #endif
1115 }
1116 \f
1117 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1118
1119 /* Loop in Xt until the menu pulldown or dialog popup has been
1120 popped down (deactivated). This is used for x-popup-menu
1121 and x-popup-dialog; it is not used for the menu bar.
1122
1123 If DOWN_ON_KEYPRESS is nonzero, pop down if a key is pressed.
1124
1125 This function used to have a DO_TIMERS argument which was
1126 1 in the dialog case, and caused it to run Lisp-level timers.
1127 That was unsafe so we removed it, but does anyone remember
1128 why menus and dialogs were treated differently?
1129
1130 NOTE: All calls to popup_get_selection should be protected
1131 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1132
1133 #ifdef USE_X_TOOLKIT
1134 static void
1135 popup_get_selection (initial_event, dpyinfo, id, down_on_keypress)
1136 XEvent *initial_event;
1137 struct x_display_info *dpyinfo;
1138 LWLIB_ID id;
1139 int down_on_keypress;
1140 {
1141 XEvent event;
1142
1143 while (popup_activated_flag)
1144 {
1145 if (initial_event)
1146 {
1147 event = *initial_event;
1148 initial_event = 0;
1149 }
1150 else
1151 XtAppNextEvent (Xt_app_con, &event);
1152
1153 /* Make sure we don't consider buttons grabbed after menu goes.
1154 And make sure to deactivate for any ButtonRelease,
1155 even if XtDispatchEvent doesn't do that. */
1156 if (event.type == ButtonRelease
1157 && dpyinfo->display == event.xbutton.display)
1158 {
1159 dpyinfo->grabbed &= ~(1 << event.xbutton.button);
1160 #ifdef USE_MOTIF /* Pretending that the event came from a
1161 Btn1Down seems the only way to convince Motif to
1162 activate its callbacks; setting the XmNmenuPost
1163 isn't working. --marcus@sysc.pdx.edu. */
1164 event.xbutton.button = 1;
1165 /* Motif only pops down menus when no Ctrl, Alt or Mod
1166 key is pressed and the button is released. So reset key state
1167 so Motif thinks this is the case. */
1168 event.xbutton.state = 0;
1169 #endif
1170 }
1171 /* If the user presses a key that doesn't go to the menu,
1172 deactivate the menu.
1173 The user is likely to do that if we get wedged.
1174 All toolkits now pop down menus on ESC.
1175 For dialogs however, the focus may not be on the dialog, so
1176 in that case, we pop down. */
1177 else if (event.type == KeyPress
1178 && down_on_keypress
1179 && dpyinfo->display == event.xbutton.display)
1180 {
1181 KeySym keysym = XLookupKeysym (&event.xkey, 0);
1182 if (!IsModifierKey (keysym)
1183 && x_any_window_to_frame (dpyinfo, event.xany.window) != NULL)
1184 popup_activated_flag = 0;
1185 }
1186
1187 x_dispatch_event (&event, event.xany.display);
1188 }
1189 }
1190
1191 #endif /* USE_X_TOOLKIT */
1192
1193 #ifdef USE_GTK
1194 /* Loop util popup_activated_flag is set to zero in a callback.
1195 Used for popup menus and dialogs. */
1196 static void
1197 popup_widget_loop ()
1198 {
1199 ++popup_activated_flag;
1200
1201 /* Process events in the Gtk event loop until done. */
1202 while (popup_activated_flag)
1203 {
1204 gtk_main_iteration ();
1205 }
1206 }
1207 #endif
1208
1209 /* Activate the menu bar of frame F.
1210 This is called from keyboard.c when it gets the
1211 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1212
1213 To activate the menu bar, we use the X button-press event
1214 that was saved in saved_menu_event.
1215 That makes the toolkit do its thing.
1216
1217 But first we recompute the menu bar contents (the whole tree).
1218
1219 The reason for saving the button event until here, instead of
1220 passing it to the toolkit right away, is that we can safely
1221 execute Lisp code. */
1222
1223 void
1224 x_activate_menubar (f)
1225 FRAME_PTR f;
1226 {
1227 if (!f->output_data.x->saved_menu_event->type)
1228 return;
1229
1230 #ifdef USE_GTK
1231 if (! xg_win_to_widget (FRAME_X_DISPLAY (f),
1232 f->output_data.x->saved_menu_event->xany.window))
1233 return;
1234 #endif
1235
1236 set_frame_menubar (f, 0, 1);
1237 BLOCK_INPUT;
1238 #ifdef USE_GTK
1239 XPutBackEvent (f->output_data.x->display_info->display,
1240 f->output_data.x->saved_menu_event);
1241 popup_activated_flag = 1;
1242 #else
1243 XtDispatchEvent (f->output_data.x->saved_menu_event);
1244 #endif
1245 UNBLOCK_INPUT;
1246 #ifdef USE_MOTIF
1247 if (f->output_data.x->saved_menu_event->type == ButtonRelease)
1248 pending_menu_activation = 1;
1249 #endif
1250
1251 /* Ignore this if we get it a second time. */
1252 f->output_data.x->saved_menu_event->type = 0;
1253 }
1254
1255 /* Detect if a dialog or menu has been posted. */
1256
1257 int
1258 popup_activated ()
1259 {
1260 return popup_activated_flag;
1261 }
1262
1263 /* This callback is invoked when the user selects a menubar cascade
1264 pushbutton, but before the pulldown menu is posted. */
1265
1266 #ifndef USE_GTK
1267 static void
1268 popup_activate_callback (widget, id, client_data)
1269 Widget widget;
1270 LWLIB_ID id;
1271 XtPointer client_data;
1272 {
1273 popup_activated_flag = 1;
1274 }
1275 #endif
1276
1277 /* This callback is invoked when a dialog or menu is finished being
1278 used and has been unposted. */
1279
1280 #ifdef USE_GTK
1281 static void
1282 popup_deactivate_callback (widget, client_data)
1283 GtkWidget *widget;
1284 gpointer client_data;
1285 {
1286 popup_activated_flag = 0;
1287 }
1288 #else
1289 static void
1290 popup_deactivate_callback (widget, id, client_data)
1291 Widget widget;
1292 LWLIB_ID id;
1293 XtPointer client_data;
1294 {
1295 popup_activated_flag = 0;
1296 }
1297 #endif
1298
1299
1300 /* Function that finds the frame for WIDGET and shows the HELP text
1301 for that widget.
1302 F is the frame if known, or NULL if not known. */
1303 static void
1304 show_help_event (f, widget, help)
1305 FRAME_PTR f;
1306 xt_or_gtk_widget widget;
1307 Lisp_Object help;
1308 {
1309 Lisp_Object frame;
1310
1311 if (f)
1312 {
1313 XSETFRAME (frame, f);
1314 kbd_buffer_store_help_event (frame, help);
1315 }
1316 else
1317 {
1318 #if 0 /* This code doesn't do anything useful. ++kfs */
1319 /* WIDGET is the popup menu. It's parent is the frame's
1320 widget. See which frame that is. */
1321 xt_or_gtk_widget frame_widget = XtParent (widget);
1322 Lisp_Object tail;
1323
1324 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
1325 {
1326 frame = XCAR (tail);
1327 if (GC_FRAMEP (frame)
1328 && (f = XFRAME (frame),
1329 FRAME_X_P (f) && f->output_data.x->widget == frame_widget))
1330 break;
1331 }
1332 #endif
1333 show_help_echo (help, Qnil, Qnil, Qnil, 1);
1334 }
1335 }
1336
1337 /* Callback called when menu items are highlighted/unhighlighted
1338 while moving the mouse over them. WIDGET is the menu bar or menu
1339 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1340 the data structure for the menu item, or null in case of
1341 unhighlighting. */
1342
1343 #ifdef USE_GTK
1344 void
1345 menu_highlight_callback (widget, call_data)
1346 GtkWidget *widget;
1347 gpointer call_data;
1348 {
1349 xg_menu_item_cb_data *cb_data;
1350 Lisp_Object help;
1351
1352 cb_data = (xg_menu_item_cb_data*) g_object_get_data (G_OBJECT (widget),
1353 XG_ITEM_DATA);
1354 if (! cb_data) return;
1355
1356 help = call_data ? cb_data->help : Qnil;
1357
1358 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1359 Don't show help for them, they won't appear before the
1360 popup is popped down. */
1361 if (popup_activated_flag <= 1)
1362 show_help_event (cb_data->cl_data->f, widget, help);
1363 }
1364 #else
1365 void
1366 menu_highlight_callback (widget, id, call_data)
1367 Widget widget;
1368 LWLIB_ID id;
1369 void *call_data;
1370 {
1371 struct frame *f;
1372 Lisp_Object help;
1373
1374 widget_value *wv = (widget_value *) call_data;
1375
1376 help = wv ? wv->help : Qnil;
1377
1378 /* Determine the frame for the help event. */
1379 f = menubar_id_to_frame (id);
1380
1381 show_help_event (f, widget, help);
1382 }
1383 #endif
1384
1385 /* Find the menu selection and store it in the keyboard buffer.
1386 F is the frame the menu is on.
1387 MENU_BAR_ITEMS_USED is the length of VECTOR.
1388 VECTOR is an array of menu events for the whole menu.
1389 */
1390 void
1391 find_and_call_menu_selection (f, menu_bar_items_used, vector, client_data)
1392 FRAME_PTR f;
1393 int menu_bar_items_used;
1394 Lisp_Object vector;
1395 void *client_data;
1396 {
1397 Lisp_Object prefix, entry;
1398 Lisp_Object *subprefix_stack;
1399 int submenu_depth = 0;
1400 int i;
1401
1402 entry = Qnil;
1403 subprefix_stack = (Lisp_Object *) alloca (menu_bar_items_used * sizeof (Lisp_Object));
1404 prefix = Qnil;
1405 i = 0;
1406
1407 while (i < menu_bar_items_used)
1408 {
1409 if (EQ (XVECTOR (vector)->contents[i], Qnil))
1410 {
1411 subprefix_stack[submenu_depth++] = prefix;
1412 prefix = entry;
1413 i++;
1414 }
1415 else if (EQ (XVECTOR (vector)->contents[i], Qlambda))
1416 {
1417 prefix = subprefix_stack[--submenu_depth];
1418 i++;
1419 }
1420 else if (EQ (XVECTOR (vector)->contents[i], Qt))
1421 {
1422 prefix = XVECTOR (vector)->contents[i + MENU_ITEMS_PANE_PREFIX];
1423 i += MENU_ITEMS_PANE_LENGTH;
1424 }
1425 else
1426 {
1427 entry = XVECTOR (vector)->contents[i + MENU_ITEMS_ITEM_VALUE];
1428 /* The EMACS_INT cast avoids a warning. There's no problem
1429 as long as pointers have enough bits to hold small integers. */
1430 if ((int) (EMACS_INT) client_data == i)
1431 {
1432 int j;
1433 struct input_event buf;
1434 Lisp_Object frame;
1435 EVENT_INIT (buf);
1436
1437 XSETFRAME (frame, f);
1438 buf.kind = MENU_BAR_EVENT;
1439 buf.frame_or_window = frame;
1440 buf.arg = frame;
1441 kbd_buffer_store_event (&buf);
1442
1443 for (j = 0; j < submenu_depth; j++)
1444 if (!NILP (subprefix_stack[j]))
1445 {
1446 buf.kind = MENU_BAR_EVENT;
1447 buf.frame_or_window = frame;
1448 buf.arg = subprefix_stack[j];
1449 kbd_buffer_store_event (&buf);
1450 }
1451
1452 if (!NILP (prefix))
1453 {
1454 buf.kind = MENU_BAR_EVENT;
1455 buf.frame_or_window = frame;
1456 buf.arg = prefix;
1457 kbd_buffer_store_event (&buf);
1458 }
1459
1460 buf.kind = MENU_BAR_EVENT;
1461 buf.frame_or_window = frame;
1462 buf.arg = entry;
1463 kbd_buffer_store_event (&buf);
1464
1465 return;
1466 }
1467 i += MENU_ITEMS_ITEM_LENGTH;
1468 }
1469 }
1470 }
1471
1472
1473 #ifdef USE_GTK
1474 /* Gtk calls callbacks just because we tell it what item should be
1475 selected in a radio group. If this variable is set to a non-zero
1476 value, we are creating menus and don't want callbacks right now.
1477 */
1478 static int xg_crazy_callback_abort;
1479
1480 /* This callback is called from the menu bar pulldown menu
1481 when the user makes a selection.
1482 Figure out what the user chose
1483 and put the appropriate events into the keyboard buffer. */
1484 static void
1485 menubar_selection_callback (widget, client_data)
1486 GtkWidget *widget;
1487 gpointer client_data;
1488 {
1489 xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
1490
1491 if (xg_crazy_callback_abort)
1492 return;
1493
1494 if (! cb_data || ! cb_data->cl_data || ! cb_data->cl_data->f)
1495 return;
1496
1497 find_and_call_menu_selection (cb_data->cl_data->f,
1498 cb_data->cl_data->menu_bar_items_used,
1499 cb_data->cl_data->menu_bar_vector,
1500 cb_data->call_data);
1501 }
1502
1503 #else /* not USE_GTK */
1504
1505 /* This callback is called from the menu bar pulldown menu
1506 when the user makes a selection.
1507 Figure out what the user chose
1508 and put the appropriate events into the keyboard buffer. */
1509 static void
1510 menubar_selection_callback (widget, id, client_data)
1511 Widget widget;
1512 LWLIB_ID id;
1513 XtPointer client_data;
1514 {
1515 FRAME_PTR f;
1516
1517 f = menubar_id_to_frame (id);
1518 if (!f)
1519 return;
1520 find_and_call_menu_selection (f, f->menu_bar_items_used,
1521 f->menu_bar_vector, client_data);
1522 }
1523 #endif /* not USE_GTK */
1524
1525 /* Allocate a widget_value, blocking input. */
1526
1527 widget_value *
1528 xmalloc_widget_value ()
1529 {
1530 widget_value *value;
1531
1532 BLOCK_INPUT;
1533 value = malloc_widget_value ();
1534 UNBLOCK_INPUT;
1535
1536 return value;
1537 }
1538
1539 /* This recursively calls free_widget_value on the tree of widgets.
1540 It must free all data that was malloc'ed for these widget_values.
1541 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1542 must be left alone. */
1543
1544 void
1545 free_menubar_widget_value_tree (wv)
1546 widget_value *wv;
1547 {
1548 if (! wv) return;
1549
1550 wv->name = wv->value = wv->key = (char *) 0xDEADBEEF;
1551
1552 if (wv->contents && (wv->contents != (widget_value*)1))
1553 {
1554 free_menubar_widget_value_tree (wv->contents);
1555 wv->contents = (widget_value *) 0xDEADBEEF;
1556 }
1557 if (wv->next)
1558 {
1559 free_menubar_widget_value_tree (wv->next);
1560 wv->next = (widget_value *) 0xDEADBEEF;
1561 }
1562 BLOCK_INPUT;
1563 free_widget_value (wv);
1564 UNBLOCK_INPUT;
1565 }
1566 \f
1567 /* Set up data in menu_items for a menu bar item
1568 whose event type is ITEM_KEY (with string ITEM_NAME)
1569 and whose contents come from the list of keymaps MAPS. */
1570
1571 static int
1572 parse_single_submenu (item_key, item_name, maps)
1573 Lisp_Object item_key, item_name, maps;
1574 {
1575 Lisp_Object length;
1576 int len;
1577 Lisp_Object *mapvec;
1578 int i;
1579 int top_level_items = 0;
1580
1581 length = Flength (maps);
1582 len = XINT (length);
1583
1584 /* Convert the list MAPS into a vector MAPVEC. */
1585 mapvec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
1586 for (i = 0; i < len; i++)
1587 {
1588 mapvec[i] = Fcar (maps);
1589 maps = Fcdr (maps);
1590 }
1591
1592 /* Loop over the given keymaps, making a pane for each map.
1593 But don't make a pane that is empty--ignore that map instead. */
1594 for (i = 0; i < len; i++)
1595 {
1596 if (!KEYMAPP (mapvec[i]))
1597 {
1598 /* Here we have a command at top level in the menu bar
1599 as opposed to a submenu. */
1600 top_level_items = 1;
1601 push_menu_pane (Qnil, Qnil);
1602 push_menu_item (item_name, Qt, item_key, mapvec[i],
1603 Qnil, Qnil, Qnil, Qnil);
1604 }
1605 else
1606 {
1607 Lisp_Object prompt;
1608 prompt = Fkeymap_prompt (mapvec[i]);
1609 single_keymap_panes (mapvec[i],
1610 !NILP (prompt) ? prompt : item_name,
1611 item_key, 0, 10);
1612 }
1613 }
1614
1615 return top_level_items;
1616 }
1617
1618 /* Create a tree of widget_value objects
1619 representing the panes and items
1620 in menu_items starting at index START, up to index END. */
1621
1622 static widget_value *
1623 digest_single_submenu (start, end, top_level_items)
1624 int start, end, top_level_items;
1625 {
1626 widget_value *wv, *prev_wv, *save_wv, *first_wv;
1627 int i;
1628 int submenu_depth = 0;
1629 widget_value **submenu_stack;
1630
1631 submenu_stack
1632 = (widget_value **) alloca (menu_items_used * sizeof (widget_value *));
1633 wv = xmalloc_widget_value ();
1634 wv->name = "menu";
1635 wv->value = 0;
1636 wv->enabled = 1;
1637 wv->button_type = BUTTON_TYPE_NONE;
1638 wv->help = Qnil;
1639 first_wv = wv;
1640 save_wv = 0;
1641 prev_wv = 0;
1642
1643 /* Loop over all panes and items made by the preceding call
1644 to parse_single_submenu and construct a tree of widget_value objects.
1645 Ignore the panes and items used by previous calls to
1646 digest_single_submenu, even though those are also in menu_items. */
1647 i = start;
1648 while (i < end)
1649 {
1650 if (EQ (XVECTOR (menu_items)->contents[i], Qnil))
1651 {
1652 submenu_stack[submenu_depth++] = save_wv;
1653 save_wv = prev_wv;
1654 prev_wv = 0;
1655 i++;
1656 }
1657 else if (EQ (XVECTOR (menu_items)->contents[i], Qlambda))
1658 {
1659 prev_wv = save_wv;
1660 save_wv = submenu_stack[--submenu_depth];
1661 i++;
1662 }
1663 else if (EQ (XVECTOR (menu_items)->contents[i], Qt)
1664 && submenu_depth != 0)
1665 i += MENU_ITEMS_PANE_LENGTH;
1666 /* Ignore a nil in the item list.
1667 It's meaningful only for dialog boxes. */
1668 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
1669 i += 1;
1670 else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
1671 {
1672 /* Create a new pane. */
1673 Lisp_Object pane_name, prefix;
1674 char *pane_string;
1675
1676 pane_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_NAME];
1677 prefix = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
1678
1679 #ifndef HAVE_MULTILINGUAL_MENU
1680 if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
1681 {
1682 pane_name = ENCODE_SYSTEM (pane_name);
1683 AREF (menu_items, i + MENU_ITEMS_PANE_NAME) = pane_name;
1684 }
1685 #endif
1686 pane_string = (NILP (pane_name)
1687 ? "" : (char *) SDATA (pane_name));
1688 /* If there is just one top-level pane, put all its items directly
1689 under the top-level menu. */
1690 if (menu_items_n_panes == 1)
1691 pane_string = "";
1692
1693 /* If the pane has a meaningful name,
1694 make the pane a top-level menu item
1695 with its items as a submenu beneath it. */
1696 if (strcmp (pane_string, ""))
1697 {
1698 wv = xmalloc_widget_value ();
1699 if (save_wv)
1700 save_wv->next = wv;
1701 else
1702 first_wv->contents = wv;
1703 wv->lname = pane_name;
1704 /* Set value to 1 so update_submenu_strings can handle '@' */
1705 wv->value = (char *)1;
1706 wv->enabled = 1;
1707 wv->button_type = BUTTON_TYPE_NONE;
1708 wv->help = Qnil;
1709 }
1710 save_wv = wv;
1711 prev_wv = 0;
1712 i += MENU_ITEMS_PANE_LENGTH;
1713 }
1714 else
1715 {
1716 /* Create a new item within current pane. */
1717 Lisp_Object item_name, enable, descrip, def, type, selected;
1718 Lisp_Object help;
1719
1720 item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
1721 enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
1722 descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
1723 def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);
1724 type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);
1725 selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
1726 help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
1727
1728 #ifndef HAVE_MULTILINGUAL_MENU
1729 if (STRING_MULTIBYTE (item_name))
1730 {
1731 item_name = ENCODE_MENU_STRING (item_name);
1732 AREF (menu_items, i + MENU_ITEMS_ITEM_NAME) = item_name;
1733 }
1734
1735 if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
1736 {
1737 descrip = ENCODE_MENU_STRING (descrip);
1738 AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY) = descrip;
1739 }
1740 #endif /* not HAVE_MULTILINGUAL_MENU */
1741
1742 wv = xmalloc_widget_value ();
1743 if (prev_wv)
1744 prev_wv->next = wv;
1745 else
1746 save_wv->contents = wv;
1747
1748 wv->lname = item_name;
1749 if (!NILP (descrip))
1750 wv->lkey = descrip;
1751 wv->value = 0;
1752 /* The EMACS_INT cast avoids a warning. There's no problem
1753 as long as pointers have enough bits to hold small integers. */
1754 wv->call_data = (!NILP (def) ? (void *) (EMACS_INT) i : 0);
1755 wv->enabled = !NILP (enable);
1756
1757 if (NILP (type))
1758 wv->button_type = BUTTON_TYPE_NONE;
1759 else if (EQ (type, QCradio))
1760 wv->button_type = BUTTON_TYPE_RADIO;
1761 else if (EQ (type, QCtoggle))
1762 wv->button_type = BUTTON_TYPE_TOGGLE;
1763 else
1764 abort ();
1765
1766 wv->selected = !NILP (selected);
1767 if (! STRINGP (help))
1768 help = Qnil;
1769
1770 wv->help = help;
1771
1772 prev_wv = wv;
1773
1774 i += MENU_ITEMS_ITEM_LENGTH;
1775 }
1776 }
1777
1778 /* If we have just one "menu item"
1779 that was originally a button, return it by itself. */
1780 if (top_level_items && first_wv->contents && first_wv->contents->next == 0)
1781 {
1782 wv = first_wv->contents;
1783 free_widget_value (first_wv);
1784 return wv;
1785 }
1786
1787 return first_wv;
1788 }
1789
1790 /* Walk through the widget_value tree starting at FIRST_WV and update
1791 the char * pointers from the corresponding lisp values.
1792 We do this after building the whole tree, since GC may happen while the
1793 tree is constructed, and small strings are relocated. So we must wait
1794 until no GC can happen before storing pointers into lisp values. */
1795 static void
1796 update_submenu_strings (first_wv)
1797 widget_value *first_wv;
1798 {
1799 widget_value *wv;
1800
1801 for (wv = first_wv; wv; wv = wv->next)
1802 {
1803 if (STRINGP (wv->lname))
1804 {
1805 wv->name = SDATA (wv->lname);
1806
1807 /* Ignore the @ that means "separate pane".
1808 This is a kludge, but this isn't worth more time. */
1809 if (wv->value == (char *)1)
1810 {
1811 if (wv->name[0] == '@')
1812 wv->name++;
1813 wv->value = 0;
1814 }
1815 }
1816
1817 if (STRINGP (wv->lkey))
1818 wv->key = SDATA (wv->lkey);
1819
1820 if (wv->contents)
1821 update_submenu_strings (wv->contents);
1822 }
1823 }
1824
1825 \f
1826 /* Recompute all the widgets of frame F, when the menu bar has been
1827 changed. Value is non-zero if widgets were updated. */
1828
1829 static int
1830 update_frame_menubar (f)
1831 FRAME_PTR f;
1832 {
1833 #ifdef USE_GTK
1834 return xg_update_frame_menubar (f);
1835 #else
1836 struct x_output *x = f->output_data.x;
1837 int columns, rows;
1838
1839 if (!x->menubar_widget || XtIsManaged (x->menubar_widget))
1840 return 0;
1841
1842 BLOCK_INPUT;
1843 /* Save the size of the frame because the pane widget doesn't accept
1844 to resize itself. So force it. */
1845 columns = FRAME_COLS (f);
1846 rows = FRAME_LINES (f);
1847
1848 /* Do the voodoo which means "I'm changing lots of things, don't try
1849 to refigure sizes until I'm done." */
1850 lw_refigure_widget (x->column_widget, False);
1851
1852 /* The order in which children are managed is the top to bottom
1853 order in which they are displayed in the paned window. First,
1854 remove the text-area widget. */
1855 XtUnmanageChild (x->edit_widget);
1856
1857 /* Remove the menubar that is there now, and put up the menubar that
1858 should be there. */
1859 XtManageChild (x->menubar_widget);
1860 XtMapWidget (x->menubar_widget);
1861 XtVaSetValues (x->menubar_widget, XtNmappedWhenManaged, 1, NULL);
1862
1863 /* Re-manage the text-area widget, and then thrash the sizes. */
1864 XtManageChild (x->edit_widget);
1865 lw_refigure_widget (x->column_widget, True);
1866
1867 /* Force the pane widget to resize itself with the right values. */
1868 EmacsFrameSetCharSize (x->edit_widget, columns, rows);
1869 UNBLOCK_INPUT;
1870 #endif
1871 return 1;
1872 }
1873
1874 /* Set the contents of the menubar widgets of frame F.
1875 The argument FIRST_TIME is currently ignored;
1876 it is set the first time this is called, from initialize_frame_menubar. */
1877
1878 void
1879 set_frame_menubar (f, first_time, deep_p)
1880 FRAME_PTR f;
1881 int first_time;
1882 int deep_p;
1883 {
1884 xt_or_gtk_widget menubar_widget = f->output_data.x->menubar_widget;
1885 #ifdef USE_X_TOOLKIT
1886 LWLIB_ID id;
1887 #endif
1888 Lisp_Object items;
1889 widget_value *wv, *first_wv, *prev_wv = 0;
1890 int i, last_i = 0;
1891 int *submenu_start, *submenu_end;
1892 int *submenu_top_level_items, *submenu_n_panes;
1893
1894
1895 XSETFRAME (Vmenu_updating_frame, f);
1896
1897 #ifdef USE_X_TOOLKIT
1898 if (f->output_data.x->id == 0)
1899 f->output_data.x->id = next_menubar_widget_id++;
1900 id = f->output_data.x->id;
1901 #endif
1902
1903 if (! menubar_widget)
1904 deep_p = 1;
1905 else if (pending_menu_activation && !deep_p)
1906 deep_p = 1;
1907 /* Make the first call for any given frame always go deep. */
1908 else if (!f->output_data.x->saved_menu_event && !deep_p)
1909 {
1910 deep_p = 1;
1911 f->output_data.x->saved_menu_event = (XEvent*)xmalloc (sizeof (XEvent));
1912 f->output_data.x->saved_menu_event->type = 0;
1913 }
1914
1915 #ifdef USE_GTK
1916 /* If we have detached menus, we must update deep so detached menus
1917 also gets updated. */
1918 deep_p = deep_p || xg_have_tear_offs ();
1919 #endif
1920
1921 if (deep_p)
1922 {
1923 /* Make a widget-value tree representing the entire menu trees. */
1924
1925 struct buffer *prev = current_buffer;
1926 Lisp_Object buffer;
1927 int specpdl_count = SPECPDL_INDEX ();
1928 int previous_menu_items_used = f->menu_bar_items_used;
1929 Lisp_Object *previous_items
1930 = (Lisp_Object *) alloca (previous_menu_items_used
1931 * sizeof (Lisp_Object));
1932
1933 /* If we are making a new widget, its contents are empty,
1934 do always reinitialize them. */
1935 if (! menubar_widget)
1936 previous_menu_items_used = 0;
1937
1938 buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer;
1939 specbind (Qinhibit_quit, Qt);
1940 /* Don't let the debugger step into this code
1941 because it is not reentrant. */
1942 specbind (Qdebug_on_next_call, Qnil);
1943
1944 record_unwind_protect (Fset_match_data, Fmatch_data (Qnil, Qnil));
1945 record_unwind_protect (unuse_menu_items, Qnil);
1946 if (NILP (Voverriding_local_map_menu_flag))
1947 {
1948 specbind (Qoverriding_terminal_local_map, Qnil);
1949 specbind (Qoverriding_local_map, Qnil);
1950 }
1951
1952 set_buffer_internal_1 (XBUFFER (buffer));
1953
1954 /* Run the Lucid hook. */
1955 safe_run_hooks (Qactivate_menubar_hook);
1956
1957 /* If it has changed current-menubar from previous value,
1958 really recompute the menubar from the value. */
1959 if (! NILP (Vlucid_menu_bar_dirty_flag))
1960 call0 (Qrecompute_lucid_menubar);
1961 safe_run_hooks (Qmenu_bar_update_hook);
1962 FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
1963
1964 items = FRAME_MENU_BAR_ITEMS (f);
1965
1966 /* Save the frame's previous menu bar contents data. */
1967 if (previous_menu_items_used)
1968 bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
1969 previous_menu_items_used * sizeof (Lisp_Object));
1970
1971 /* Fill in menu_items with the current menu bar contents.
1972 This can evaluate Lisp code. */
1973 menu_items = f->menu_bar_vector;
1974 menu_items_allocated = VECTORP (menu_items) ? ASIZE (menu_items) : 0;
1975 submenu_start = (int *) alloca (XVECTOR (items)->size * sizeof (int *));
1976 submenu_end = (int *) alloca (XVECTOR (items)->size * sizeof (int *));
1977 submenu_n_panes = (int *) alloca (XVECTOR (items)->size * sizeof (int));
1978 submenu_top_level_items
1979 = (int *) alloca (XVECTOR (items)->size * sizeof (int *));
1980 init_menu_items ();
1981 for (i = 0; i < XVECTOR (items)->size; i += 4)
1982 {
1983 Lisp_Object key, string, maps;
1984
1985 last_i = i;
1986
1987 key = XVECTOR (items)->contents[i];
1988 string = XVECTOR (items)->contents[i + 1];
1989 maps = XVECTOR (items)->contents[i + 2];
1990 if (NILP (string))
1991 break;
1992
1993 submenu_start[i] = menu_items_used;
1994
1995 menu_items_n_panes = 0;
1996 submenu_top_level_items[i]
1997 = parse_single_submenu (key, string, maps);
1998 submenu_n_panes[i] = menu_items_n_panes;
1999
2000 submenu_end[i] = menu_items_used;
2001 }
2002
2003 finish_menu_items ();
2004
2005 /* Convert menu_items into widget_value trees
2006 to display the menu. This cannot evaluate Lisp code. */
2007
2008 wv = xmalloc_widget_value ();
2009 wv->name = "menubar";
2010 wv->value = 0;
2011 wv->enabled = 1;
2012 wv->button_type = BUTTON_TYPE_NONE;
2013 wv->help = Qnil;
2014 first_wv = wv;
2015
2016 for (i = 0; i < last_i; i += 4)
2017 {
2018 menu_items_n_panes = submenu_n_panes[i];
2019 wv = digest_single_submenu (submenu_start[i], submenu_end[i],
2020 submenu_top_level_items[i]);
2021 if (prev_wv)
2022 prev_wv->next = wv;
2023 else
2024 first_wv->contents = wv;
2025 /* Don't set wv->name here; GC during the loop might relocate it. */
2026 wv->enabled = 1;
2027 wv->button_type = BUTTON_TYPE_NONE;
2028 prev_wv = wv;
2029 }
2030
2031 set_buffer_internal_1 (prev);
2032 unbind_to (specpdl_count, Qnil);
2033
2034 /* If there has been no change in the Lisp-level contents
2035 of the menu bar, skip redisplaying it. Just exit. */
2036
2037 for (i = 0; i < previous_menu_items_used; i++)
2038 if (menu_items_used == i
2039 || (!EQ (previous_items[i], XVECTOR (menu_items)->contents[i])))
2040 break;
2041 if (i == menu_items_used && i == previous_menu_items_used && i != 0)
2042 {
2043 free_menubar_widget_value_tree (first_wv);
2044 discard_menu_items ();
2045
2046 return;
2047 }
2048
2049 /* Now GC cannot happen during the lifetime of the widget_value,
2050 so it's safe to store data from a Lisp_String. */
2051 wv = first_wv->contents;
2052 for (i = 0; i < XVECTOR (items)->size; i += 4)
2053 {
2054 Lisp_Object string;
2055 string = XVECTOR (items)->contents[i + 1];
2056 if (NILP (string))
2057 break;
2058 wv->name = (char *) SDATA (string);
2059 update_submenu_strings (wv->contents);
2060 wv = wv->next;
2061 }
2062
2063 f->menu_bar_vector = menu_items;
2064 f->menu_bar_items_used = menu_items_used;
2065 discard_menu_items ();
2066 }
2067 else
2068 {
2069 /* Make a widget-value tree containing
2070 just the top level menu bar strings. */
2071
2072 wv = xmalloc_widget_value ();
2073 wv->name = "menubar";
2074 wv->value = 0;
2075 wv->enabled = 1;
2076 wv->button_type = BUTTON_TYPE_NONE;
2077 wv->help = Qnil;
2078 first_wv = wv;
2079
2080 items = FRAME_MENU_BAR_ITEMS (f);
2081 for (i = 0; i < XVECTOR (items)->size; i += 4)
2082 {
2083 Lisp_Object string;
2084
2085 string = XVECTOR (items)->contents[i + 1];
2086 if (NILP (string))
2087 break;
2088
2089 wv = xmalloc_widget_value ();
2090 wv->name = (char *) SDATA (string);
2091 wv->value = 0;
2092 wv->enabled = 1;
2093 wv->button_type = BUTTON_TYPE_NONE;
2094 wv->help = Qnil;
2095 /* This prevents lwlib from assuming this
2096 menu item is really supposed to be empty. */
2097 /* The EMACS_INT cast avoids a warning.
2098 This value just has to be different from small integers. */
2099 wv->call_data = (void *) (EMACS_INT) (-1);
2100
2101 if (prev_wv)
2102 prev_wv->next = wv;
2103 else
2104 first_wv->contents = wv;
2105 prev_wv = wv;
2106 }
2107
2108 /* Forget what we thought we knew about what is in the
2109 detailed contents of the menu bar menus.
2110 Changing the top level always destroys the contents. */
2111 f->menu_bar_items_used = 0;
2112 }
2113
2114 /* Create or update the menu bar widget. */
2115
2116 BLOCK_INPUT;
2117
2118 #ifdef USE_GTK
2119 xg_crazy_callback_abort = 1;
2120 if (menubar_widget)
2121 {
2122 /* The fourth arg is DEEP_P, which says to consider the entire
2123 menu trees we supply, rather than just the menu bar item names. */
2124 xg_modify_menubar_widgets (menubar_widget,
2125 f,
2126 first_wv,
2127 deep_p,
2128 G_CALLBACK (menubar_selection_callback),
2129 G_CALLBACK (popup_deactivate_callback),
2130 G_CALLBACK (menu_highlight_callback));
2131 }
2132 else
2133 {
2134 GtkWidget *wvbox = f->output_data.x->vbox_widget;
2135
2136 menubar_widget
2137 = xg_create_widget ("menubar", "menubar", f, first_wv,
2138 G_CALLBACK (menubar_selection_callback),
2139 G_CALLBACK (popup_deactivate_callback),
2140 G_CALLBACK (menu_highlight_callback));
2141
2142 f->output_data.x->menubar_widget = menubar_widget;
2143 }
2144
2145
2146 #else /* not USE_GTK */
2147 if (menubar_widget)
2148 {
2149 /* Disable resizing (done for Motif!) */
2150 lw_allow_resizing (f->output_data.x->widget, False);
2151
2152 /* The third arg is DEEP_P, which says to consider the entire
2153 menu trees we supply, rather than just the menu bar item names. */
2154 lw_modify_all_widgets (id, first_wv, deep_p);
2155
2156 /* Re-enable the edit widget to resize. */
2157 lw_allow_resizing (f->output_data.x->widget, True);
2158 }
2159 else
2160 {
2161 menubar_widget = lw_create_widget ("menubar", "menubar", id, first_wv,
2162 f->output_data.x->column_widget,
2163 0,
2164 popup_activate_callback,
2165 menubar_selection_callback,
2166 popup_deactivate_callback,
2167 menu_highlight_callback);
2168 f->output_data.x->menubar_widget = menubar_widget;
2169 }
2170
2171 {
2172 int menubar_size
2173 = (f->output_data.x->menubar_widget
2174 ? (f->output_data.x->menubar_widget->core.height
2175 + f->output_data.x->menubar_widget->core.border_width)
2176 : 0);
2177
2178 #if 0 /* Experimentally, we now get the right results
2179 for -geometry -0-0 without this. 24 Aug 96, rms. */
2180 #ifdef USE_LUCID
2181 if (FRAME_EXTERNAL_MENU_BAR (f))
2182 {
2183 Dimension ibw = 0;
2184 XtVaGetValues (f->output_data.x->column_widget,
2185 XtNinternalBorderWidth, &ibw, NULL);
2186 menubar_size += ibw;
2187 }
2188 #endif /* USE_LUCID */
2189 #endif /* 0 */
2190
2191 f->output_data.x->menubar_height = menubar_size;
2192 }
2193 #endif /* not USE_GTK */
2194
2195 free_menubar_widget_value_tree (first_wv);
2196 update_frame_menubar (f);
2197
2198 #ifdef USE_GTK
2199 xg_crazy_callback_abort = 0;
2200 #endif
2201
2202 UNBLOCK_INPUT;
2203 }
2204
2205 /* Called from Fx_create_frame to create the initial menubar of a frame
2206 before it is mapped, so that the window is mapped with the menubar already
2207 there instead of us tacking it on later and thrashing the window after it
2208 is visible. */
2209
2210 void
2211 initialize_frame_menubar (f)
2212 FRAME_PTR f;
2213 {
2214 /* This function is called before the first chance to redisplay
2215 the frame. It has to be, so the frame will have the right size. */
2216 FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
2217 set_frame_menubar (f, 1, 1);
2218 }
2219
2220
2221 /* Get rid of the menu bar of frame F, and free its storage.
2222 This is used when deleting a frame, and when turning off the menu bar.
2223 For GTK this function is in gtkutil.c. */
2224
2225 #ifndef USE_GTK
2226 void
2227 free_frame_menubar (f)
2228 FRAME_PTR f;
2229 {
2230 Widget menubar_widget;
2231
2232 menubar_widget = f->output_data.x->menubar_widget;
2233
2234 f->output_data.x->menubar_height = 0;
2235
2236 if (menubar_widget)
2237 {
2238 #ifdef USE_MOTIF
2239 /* Removing the menu bar magically changes the shell widget's x
2240 and y position of (0, 0) which, when the menu bar is turned
2241 on again, leads to pull-down menuss appearing in strange
2242 positions near the upper-left corner of the display. This
2243 happens only with some window managers like twm and ctwm,
2244 but not with other like Motif's mwm or kwm, because the
2245 latter generate ConfigureNotify events when the menu bar
2246 is switched off, which fixes the shell position. */
2247 Position x0, y0, x1, y1;
2248 #endif
2249
2250 BLOCK_INPUT;
2251
2252 #ifdef USE_MOTIF
2253 if (f->output_data.x->widget)
2254 XtVaGetValues (f->output_data.x->widget, XtNx, &x0, XtNy, &y0, NULL);
2255 #endif
2256
2257 lw_destroy_all_widgets ((LWLIB_ID) f->output_data.x->id);
2258 f->output_data.x->menubar_widget = NULL;
2259
2260 #ifdef USE_MOTIF
2261 if (f->output_data.x->widget)
2262 {
2263 XtVaGetValues (f->output_data.x->widget, XtNx, &x1, XtNy, &y1, NULL);
2264 if (x1 == 0 && y1 == 0)
2265 XtVaSetValues (f->output_data.x->widget, XtNx, x0, XtNy, y0, NULL);
2266 }
2267 #endif
2268
2269 UNBLOCK_INPUT;
2270 }
2271 }
2272 #endif /* not USE_GTK */
2273
2274 #endif /* USE_X_TOOLKIT || USE_GTK */
2275 \f
2276 /* xmenu_show actually displays a menu using the panes and items in menu_items
2277 and returns the value selected from it.
2278 There are two versions of xmenu_show, one for Xt and one for Xlib.
2279 Both assume input is blocked by the caller. */
2280
2281 /* F is the frame the menu is for.
2282 X and Y are the frame-relative specified position,
2283 relative to the inside upper left corner of the frame F.
2284 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2285 KEYMAPS is 1 if this menu was specified with keymaps;
2286 in that case, we return a list containing the chosen item's value
2287 and perhaps also the pane's prefix.
2288 TITLE is the specified menu title.
2289 ERROR is a place to store an error message string in case of failure.
2290 (We return nil on failure, but the value doesn't actually matter.) */
2291
2292 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2293
2294 /* The item selected in the popup menu. */
2295 static Lisp_Object *volatile menu_item_selection;
2296
2297 #ifdef USE_GTK
2298
2299 /* Used when position a popup menu. See menu_position_func and
2300 create_and_show_popup_menu below. */
2301 struct next_popup_x_y
2302 {
2303 FRAME_PTR f;
2304 int x;
2305 int y;
2306 };
2307
2308 /* The menu position function to use if we are not putting a popup
2309 menu where the pointer is.
2310 MENU is the menu to pop up.
2311 X and Y shall on exit contain x/y where the menu shall pop up.
2312 PUSH_IN is not documented in the GTK manual.
2313 USER_DATA is any data passed in when calling gtk_menu_popup.
2314 Here it points to a struct next_popup_x_y where the coordinates
2315 to store in *X and *Y are as well as the frame for the popup.
2316
2317 Here only X and Y are used. */
2318 static void
2319 menu_position_func (menu, x, y, push_in, user_data)
2320 GtkMenu *menu;
2321 gint *x;
2322 gint *y;
2323 gboolean *push_in;
2324 gpointer user_data;
2325 {
2326 struct next_popup_x_y* data = (struct next_popup_x_y*)user_data;
2327 GtkRequisition req;
2328 int disp_width = FRAME_X_DISPLAY_INFO (data->f)->width;
2329 int disp_height = FRAME_X_DISPLAY_INFO (data->f)->height;
2330
2331 *x = data->x;
2332 *y = data->y;
2333
2334 /* Check if there is room for the menu. If not, adjust x/y so that
2335 the menu is fully visible. */
2336 gtk_widget_size_request (GTK_WIDGET (menu), &req);
2337 if (data->x + req.width > disp_width)
2338 *x -= data->x + req.width - disp_width;
2339 if (data->y + req.height > disp_height)
2340 *y -= data->y + req.height - disp_height;
2341 }
2342
2343 static void
2344 popup_selection_callback (widget, client_data)
2345 GtkWidget *widget;
2346 gpointer client_data;
2347 {
2348 xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
2349
2350 if (xg_crazy_callback_abort) return;
2351 if (cb_data) menu_item_selection = (Lisp_Object *) cb_data->call_data;
2352 }
2353
2354 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2355 menu pops down.
2356 menu_item_selection will be set to the selection. */
2357 static void
2358 create_and_show_popup_menu (f, first_wv, x, y, for_click)
2359 FRAME_PTR f;
2360 widget_value *first_wv;
2361 int x;
2362 int y;
2363 int for_click;
2364 {
2365 int i;
2366 GtkWidget *menu;
2367 GtkMenuPositionFunc pos_func = 0; /* Pop up at pointer. */
2368 struct next_popup_x_y popup_x_y;
2369
2370 xg_crazy_callback_abort = 1;
2371 menu = xg_create_widget ("popup", first_wv->name, f, first_wv,
2372 G_CALLBACK (popup_selection_callback),
2373 G_CALLBACK (popup_deactivate_callback),
2374 G_CALLBACK (menu_highlight_callback));
2375 xg_crazy_callback_abort = 0;
2376
2377 for (i = 0; i < 5; i++)
2378 if (FRAME_X_DISPLAY_INFO (f)->grabbed & (1 << i))
2379 break;
2380
2381 if (! for_click)
2382 {
2383 /* Not invoked by a click. pop up at x/y. */
2384 pos_func = menu_position_func;
2385
2386 /* Adjust coordinates to be root-window-relative. */
2387 x += f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
2388 y += f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
2389
2390 popup_x_y.x = x;
2391 popup_x_y.y = y;
2392 popup_x_y.f = f;
2393 }
2394
2395 /* Display the menu. */
2396 gtk_widget_show_all (menu);
2397 gtk_menu_popup (GTK_MENU (menu), 0, 0, pos_func, &popup_x_y, i, 0);
2398
2399 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2400 two. show_help_echo uses this to detect popup menus. */
2401 popup_activated_flag = 1;
2402 /* Process events that apply to the menu. */
2403 popup_widget_loop ();
2404
2405 gtk_widget_destroy (menu);
2406
2407 /* Must reset this manually because the button release event is not passed
2408 to Emacs event loop. */
2409 FRAME_X_DISPLAY_INFO (f)->grabbed = 0;
2410 }
2411
2412 #else /* not USE_GTK */
2413
2414 /* We need a unique id for each widget handled by the Lucid Widget
2415 library.
2416
2417 For the main windows, and popup menus, we use this counter,
2418 which we increment each time after use. This starts from 1<<16.
2419
2420 For menu bars, we use numbers starting at 0, counted in
2421 next_menubar_widget_id. */
2422 LWLIB_ID widget_id_tick;
2423
2424 static void
2425 popup_selection_callback (widget, id, client_data)
2426 Widget widget;
2427 LWLIB_ID id;
2428 XtPointer client_data;
2429 {
2430 menu_item_selection = (Lisp_Object *) client_data;
2431 }
2432
2433 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2434 menu pops down.
2435 menu_item_selection will be set to the selection. */
2436 static void
2437 create_and_show_popup_menu (f, first_wv, x, y, for_click)
2438 FRAME_PTR f;
2439 widget_value *first_wv;
2440 int x;
2441 int y;
2442 int for_click;
2443 {
2444 int i;
2445 Arg av[2];
2446 int ac = 0;
2447 XButtonPressedEvent dummy;
2448 LWLIB_ID menu_id;
2449 Widget menu;
2450
2451 menu_id = widget_id_tick++;
2452 menu = lw_create_widget ("popup", first_wv->name, menu_id, first_wv,
2453 f->output_data.x->widget, 1, 0,
2454 popup_selection_callback,
2455 popup_deactivate_callback,
2456 menu_highlight_callback);
2457
2458 dummy.type = ButtonPress;
2459 dummy.serial = 0;
2460 dummy.send_event = 0;
2461 dummy.display = FRAME_X_DISPLAY (f);
2462 dummy.time = CurrentTime;
2463 dummy.root = FRAME_X_DISPLAY_INFO (f)->root_window;
2464 dummy.window = dummy.root;
2465 dummy.subwindow = dummy.root;
2466 dummy.x = x;
2467 dummy.y = y;
2468
2469 /* Adjust coordinates to be root-window-relative. */
2470 x += f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
2471 y += f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
2472
2473 dummy.x_root = x;
2474 dummy.y_root = y;
2475
2476 dummy.state = 0;
2477 dummy.button = 0;
2478 for (i = 0; i < 5; i++)
2479 if (FRAME_X_DISPLAY_INFO (f)->grabbed & (1 << i))
2480 dummy.button = i;
2481
2482 /* Don't allow any geometry request from the user. */
2483 XtSetArg (av[ac], XtNgeometry, 0); ac++;
2484 XtSetValues (menu, av, ac);
2485
2486 /* Display the menu. */
2487 lw_popup_menu (menu, (XEvent *) &dummy);
2488 popup_activated_flag = 1;
2489
2490 /* Process events that apply to the menu. */
2491 popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f), menu_id, 0);
2492
2493 /* fp turned off the following statement and wrote a comment
2494 that it is unnecessary--that the menu has already disappeared.
2495 Nowadays the menu disappears ok, all right, but
2496 we need to delete the widgets or multiple ones will pile up. */
2497 lw_destroy_all_widgets (menu_id);
2498 }
2499
2500 #endif /* not USE_GTK */
2501
2502 static Lisp_Object
2503 xmenu_show (f, x, y, for_click, keymaps, title, error)
2504 FRAME_PTR f;
2505 int x;
2506 int y;
2507 int for_click;
2508 int keymaps;
2509 Lisp_Object title;
2510 char **error;
2511 {
2512 int i;
2513 widget_value *wv, *save_wv = 0, *first_wv = 0, *prev_wv = 0;
2514 widget_value **submenu_stack
2515 = (widget_value **) alloca (menu_items_used * sizeof (widget_value *));
2516 Lisp_Object *subprefix_stack
2517 = (Lisp_Object *) alloca (menu_items_used * sizeof (Lisp_Object));
2518 int submenu_depth = 0;
2519
2520 int first_pane;
2521
2522 *error = NULL;
2523
2524 if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)
2525 {
2526 *error = "Empty menu";
2527 return Qnil;
2528 }
2529
2530 /* Create a tree of widget_value objects
2531 representing the panes and their items. */
2532 wv = xmalloc_widget_value ();
2533 wv->name = "menu";
2534 wv->value = 0;
2535 wv->enabled = 1;
2536 wv->button_type = BUTTON_TYPE_NONE;
2537 wv->help =Qnil;
2538 first_wv = wv;
2539 first_pane = 1;
2540
2541 /* Loop over all panes and items, filling in the tree. */
2542 i = 0;
2543 while (i < menu_items_used)
2544 {
2545 if (EQ (XVECTOR (menu_items)->contents[i], Qnil))
2546 {
2547 submenu_stack[submenu_depth++] = save_wv;
2548 save_wv = prev_wv;
2549 prev_wv = 0;
2550 first_pane = 1;
2551 i++;
2552 }
2553 else if (EQ (XVECTOR (menu_items)->contents[i], Qlambda))
2554 {
2555 prev_wv = save_wv;
2556 save_wv = submenu_stack[--submenu_depth];
2557 first_pane = 0;
2558 i++;
2559 }
2560 else if (EQ (XVECTOR (menu_items)->contents[i], Qt)
2561 && submenu_depth != 0)
2562 i += MENU_ITEMS_PANE_LENGTH;
2563 /* Ignore a nil in the item list.
2564 It's meaningful only for dialog boxes. */
2565 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
2566 i += 1;
2567 else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
2568 {
2569 /* Create a new pane. */
2570 Lisp_Object pane_name, prefix;
2571 char *pane_string;
2572
2573 pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
2574 prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
2575
2576 #ifndef HAVE_MULTILINGUAL_MENU
2577 if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
2578 {
2579 pane_name = ENCODE_SYSTEM (pane_name);
2580 AREF (menu_items, i + MENU_ITEMS_PANE_NAME) = pane_name;
2581 }
2582 #endif
2583 pane_string = (NILP (pane_name)
2584 ? "" : (char *) SDATA (pane_name));
2585 /* If there is just one top-level pane, put all its items directly
2586 under the top-level menu. */
2587 if (menu_items_n_panes == 1)
2588 pane_string = "";
2589
2590 /* If the pane has a meaningful name,
2591 make the pane a top-level menu item
2592 with its items as a submenu beneath it. */
2593 if (!keymaps && strcmp (pane_string, ""))
2594 {
2595 wv = xmalloc_widget_value ();
2596 if (save_wv)
2597 save_wv->next = wv;
2598 else
2599 first_wv->contents = wv;
2600 wv->name = pane_string;
2601 if (keymaps && !NILP (prefix))
2602 wv->name++;
2603 wv->value = 0;
2604 wv->enabled = 1;
2605 wv->button_type = BUTTON_TYPE_NONE;
2606 wv->help = Qnil;
2607 save_wv = wv;
2608 prev_wv = 0;
2609 }
2610 else if (first_pane)
2611 {
2612 save_wv = wv;
2613 prev_wv = 0;
2614 }
2615 first_pane = 0;
2616 i += MENU_ITEMS_PANE_LENGTH;
2617 }
2618 else
2619 {
2620 /* Create a new item within current pane. */
2621 Lisp_Object item_name, enable, descrip, def, type, selected, help;
2622 item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
2623 enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
2624 descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
2625 def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);
2626 type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);
2627 selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
2628 help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
2629
2630 #ifndef HAVE_MULTILINGUAL_MENU
2631 if (STRINGP (item_name) && STRING_MULTIBYTE (item_name))
2632 {
2633 item_name = ENCODE_MENU_STRING (item_name);
2634 AREF (menu_items, i + MENU_ITEMS_ITEM_NAME) = item_name;
2635 }
2636
2637 if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
2638 {
2639 descrip = ENCODE_MENU_STRING (descrip);
2640 AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY) = descrip;
2641 }
2642 #endif /* not HAVE_MULTILINGUAL_MENU */
2643
2644 wv = xmalloc_widget_value ();
2645 if (prev_wv)
2646 prev_wv->next = wv;
2647 else
2648 save_wv->contents = wv;
2649 wv->name = (char *) SDATA (item_name);
2650 if (!NILP (descrip))
2651 wv->key = (char *) SDATA (descrip);
2652 wv->value = 0;
2653 /* If this item has a null value,
2654 make the call_data null so that it won't display a box
2655 when the mouse is on it. */
2656 wv->call_data
2657 = (!NILP (def) ? (void *) &XVECTOR (menu_items)->contents[i] : 0);
2658 wv->enabled = !NILP (enable);
2659
2660 if (NILP (type))
2661 wv->button_type = BUTTON_TYPE_NONE;
2662 else if (EQ (type, QCtoggle))
2663 wv->button_type = BUTTON_TYPE_TOGGLE;
2664 else if (EQ (type, QCradio))
2665 wv->button_type = BUTTON_TYPE_RADIO;
2666 else
2667 abort ();
2668
2669 wv->selected = !NILP (selected);
2670
2671 if (! STRINGP (help))
2672 help = Qnil;
2673
2674 wv->help = help;
2675
2676 prev_wv = wv;
2677
2678 i += MENU_ITEMS_ITEM_LENGTH;
2679 }
2680 }
2681
2682 /* Deal with the title, if it is non-nil. */
2683 if (!NILP (title))
2684 {
2685 widget_value *wv_title = xmalloc_widget_value ();
2686 widget_value *wv_sep1 = xmalloc_widget_value ();
2687 widget_value *wv_sep2 = xmalloc_widget_value ();
2688
2689 wv_sep2->name = "--";
2690 wv_sep2->next = first_wv->contents;
2691 wv_sep2->help = Qnil;
2692
2693 wv_sep1->name = "--";
2694 wv_sep1->next = wv_sep2;
2695 wv_sep1->help = Qnil;
2696
2697 #ifndef HAVE_MULTILINGUAL_MENU
2698 if (STRING_MULTIBYTE (title))
2699 title = ENCODE_MENU_STRING (title);
2700 #endif
2701
2702 wv_title->name = (char *) SDATA (title);
2703 wv_title->enabled = TRUE;
2704 wv_title->button_type = BUTTON_TYPE_NONE;
2705 wv_title->next = wv_sep1;
2706 wv_title->help = Qnil;
2707 first_wv->contents = wv_title;
2708 }
2709
2710 /* No selection has been chosen yet. */
2711 menu_item_selection = 0;
2712
2713 /* Actually create and show the menu until popped down. */
2714 create_and_show_popup_menu (f, first_wv, x, y, for_click);
2715
2716 /* Free the widget_value objects we used to specify the contents. */
2717 free_menubar_widget_value_tree (first_wv);
2718
2719 /* Find the selected item, and its pane, to return
2720 the proper value. */
2721 if (menu_item_selection != 0)
2722 {
2723 Lisp_Object prefix, entry;
2724
2725 prefix = entry = Qnil;
2726 i = 0;
2727 while (i < menu_items_used)
2728 {
2729 if (EQ (XVECTOR (menu_items)->contents[i], Qnil))
2730 {
2731 subprefix_stack[submenu_depth++] = prefix;
2732 prefix = entry;
2733 i++;
2734 }
2735 else if (EQ (XVECTOR (menu_items)->contents[i], Qlambda))
2736 {
2737 prefix = subprefix_stack[--submenu_depth];
2738 i++;
2739 }
2740 else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
2741 {
2742 prefix
2743 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
2744 i += MENU_ITEMS_PANE_LENGTH;
2745 }
2746 /* Ignore a nil in the item list.
2747 It's meaningful only for dialog boxes. */
2748 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
2749 i += 1;
2750 else
2751 {
2752 entry
2753 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
2754 if (menu_item_selection == &XVECTOR (menu_items)->contents[i])
2755 {
2756 if (keymaps != 0)
2757 {
2758 int j;
2759
2760 entry = Fcons (entry, Qnil);
2761 if (!NILP (prefix))
2762 entry = Fcons (prefix, entry);
2763 for (j = submenu_depth - 1; j >= 0; j--)
2764 if (!NILP (subprefix_stack[j]))
2765 entry = Fcons (subprefix_stack[j], entry);
2766 }
2767 return entry;
2768 }
2769 i += MENU_ITEMS_ITEM_LENGTH;
2770 }
2771 }
2772 }
2773
2774 return Qnil;
2775 }
2776 \f
2777 #ifdef USE_GTK
2778 static void
2779 dialog_selection_callback (widget, client_data)
2780 GtkWidget *widget;
2781 gpointer client_data;
2782 {
2783 /* The EMACS_INT cast avoids a warning. There's no problem
2784 as long as pointers have enough bits to hold small integers. */
2785 if ((int) (EMACS_INT) client_data != -1)
2786 menu_item_selection = (Lisp_Object *) client_data;
2787
2788 popup_activated_flag = 0;
2789 }
2790
2791 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2792 dialog pops down.
2793 menu_item_selection will be set to the selection. */
2794 static void
2795 create_and_show_dialog (f, first_wv)
2796 FRAME_PTR f;
2797 widget_value *first_wv;
2798 {
2799 GtkWidget *menu;
2800
2801 menu = xg_create_widget ("dialog", first_wv->name, f, first_wv,
2802 G_CALLBACK (dialog_selection_callback),
2803 G_CALLBACK (popup_deactivate_callback),
2804 0);
2805
2806 if (menu)
2807 {
2808 /* Display the menu. */
2809 gtk_widget_show_all (menu);
2810
2811 /* Process events that apply to the menu. */
2812 popup_widget_loop ();
2813
2814 gtk_widget_destroy (menu);
2815 }
2816 }
2817
2818 #else /* not USE_GTK */
2819 static void
2820 dialog_selection_callback (widget, id, client_data)
2821 Widget widget;
2822 LWLIB_ID id;
2823 XtPointer client_data;
2824 {
2825 /* The EMACS_INT cast avoids a warning. There's no problem
2826 as long as pointers have enough bits to hold small integers. */
2827 if ((int) (EMACS_INT) client_data != -1)
2828 menu_item_selection = (Lisp_Object *) client_data;
2829
2830 BLOCK_INPUT;
2831 lw_destroy_all_widgets (id);
2832 UNBLOCK_INPUT;
2833 popup_activated_flag = 0;
2834 }
2835
2836
2837 /* ARG is the LWLIB ID of the dialog box, represented
2838 as a Lisp object as (HIGHPART . LOWPART). */
2839
2840 Lisp_Object
2841 xdialog_show_unwind (arg)
2842 Lisp_Object arg;
2843 {
2844 LWLIB_ID id = (XINT (XCAR (arg)) << 4 * sizeof (LWLIB_ID)
2845 | XINT (XCDR (arg)));
2846 BLOCK_INPUT;
2847 lw_destroy_all_widgets (id);
2848 UNBLOCK_INPUT;
2849 popup_activated_flag = 0;
2850 return Qnil;
2851 }
2852
2853
2854 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2855 dialog pops down.
2856 menu_item_selection will be set to the selection. */
2857 static void
2858 create_and_show_dialog (f, first_wv)
2859 FRAME_PTR f;
2860 widget_value *first_wv;
2861 {
2862 LWLIB_ID dialog_id;
2863
2864 dialog_id = widget_id_tick++;
2865 lw_create_widget (first_wv->name, "dialog", dialog_id, first_wv,
2866 f->output_data.x->widget, 1, 0,
2867 dialog_selection_callback, 0, 0);
2868 lw_modify_all_widgets (dialog_id, first_wv->contents, True);
2869
2870 /* Display the dialog box. */
2871 lw_pop_up_all_widgets (dialog_id);
2872 popup_activated_flag = 1;
2873
2874 /* Process events that apply to the dialog box.
2875 Also handle timers. */
2876 {
2877 int count = SPECPDL_INDEX ();
2878 int fact = 4 * sizeof (LWLIB_ID);
2879
2880 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2881 record_unwind_protect (xdialog_show_unwind,
2882 Fcons (make_number (dialog_id >> (fact)),
2883 make_number (dialog_id & ~(-1 << (fact)))));
2884
2885 popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f), dialog_id, 1);
2886
2887 unbind_to (count, Qnil);
2888 }
2889 }
2890
2891 #endif /* not USE_GTK */
2892
2893 static char * button_names [] = {
2894 "button1", "button2", "button3", "button4", "button5",
2895 "button6", "button7", "button8", "button9", "button10" };
2896
2897 static Lisp_Object
2898 xdialog_show (f, keymaps, title, error)
2899 FRAME_PTR f;
2900 int keymaps;
2901 Lisp_Object title;
2902 char **error;
2903 {
2904 int i, nb_buttons=0;
2905 char dialog_name[6];
2906
2907 widget_value *wv, *first_wv = 0, *prev_wv = 0;
2908
2909 /* Number of elements seen so far, before boundary. */
2910 int left_count = 0;
2911 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2912 int boundary_seen = 0;
2913
2914 *error = NULL;
2915
2916 if (menu_items_n_panes > 1)
2917 {
2918 *error = "Multiple panes in dialog box";
2919 return Qnil;
2920 }
2921
2922 /* Create a tree of widget_value objects
2923 representing the text label and buttons. */
2924 {
2925 Lisp_Object pane_name, prefix;
2926 char *pane_string;
2927 pane_name = XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_NAME];
2928 prefix = XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_PREFIX];
2929 pane_string = (NILP (pane_name)
2930 ? "" : (char *) SDATA (pane_name));
2931 prev_wv = xmalloc_widget_value ();
2932 prev_wv->value = pane_string;
2933 if (keymaps && !NILP (prefix))
2934 prev_wv->name++;
2935 prev_wv->enabled = 1;
2936 prev_wv->name = "message";
2937 prev_wv->help = Qnil;
2938 first_wv = prev_wv;
2939
2940 /* Loop over all panes and items, filling in the tree. */
2941 i = MENU_ITEMS_PANE_LENGTH;
2942 while (i < menu_items_used)
2943 {
2944
2945 /* Create a new item within current pane. */
2946 Lisp_Object item_name, enable, descrip;
2947 item_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_NAME];
2948 enable = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_ENABLE];
2949 descrip
2950 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_EQUIV_KEY];
2951
2952 if (NILP (item_name))
2953 {
2954 free_menubar_widget_value_tree (first_wv);
2955 *error = "Submenu in dialog items";
2956 return Qnil;
2957 }
2958 if (EQ (item_name, Qquote))
2959 {
2960 /* This is the boundary between left-side elts
2961 and right-side elts. Stop incrementing right_count. */
2962 boundary_seen = 1;
2963 i++;
2964 continue;
2965 }
2966 if (nb_buttons >= 9)
2967 {
2968 free_menubar_widget_value_tree (first_wv);
2969 *error = "Too many dialog items";
2970 return Qnil;
2971 }
2972
2973 wv = xmalloc_widget_value ();
2974 prev_wv->next = wv;
2975 wv->name = (char *) button_names[nb_buttons];
2976 if (!NILP (descrip))
2977 wv->key = (char *) SDATA (descrip);
2978 wv->value = (char *) SDATA (item_name);
2979 wv->call_data = (void *) &XVECTOR (menu_items)->contents[i];
2980 wv->enabled = !NILP (enable);
2981 wv->help = Qnil;
2982 prev_wv = wv;
2983
2984 if (! boundary_seen)
2985 left_count++;
2986
2987 nb_buttons++;
2988 i += MENU_ITEMS_ITEM_LENGTH;
2989 }
2990
2991 /* If the boundary was not specified,
2992 by default put half on the left and half on the right. */
2993 if (! boundary_seen)
2994 left_count = nb_buttons - nb_buttons / 2;
2995
2996 wv = xmalloc_widget_value ();
2997 wv->name = dialog_name;
2998 wv->help = Qnil;
2999 /* Dialog boxes use a really stupid name encoding
3000 which specifies how many buttons to use
3001 and how many buttons are on the right.
3002 The Q means something also. */
3003 dialog_name[0] = 'Q';
3004 dialog_name[1] = '0' + nb_buttons;
3005 dialog_name[2] = 'B';
3006 dialog_name[3] = 'R';
3007 /* Number of buttons to put on the right. */
3008 dialog_name[4] = '0' + nb_buttons - left_count;
3009 dialog_name[5] = 0;
3010 wv->contents = first_wv;
3011 first_wv = wv;
3012 }
3013
3014 /* No selection has been chosen yet. */
3015 menu_item_selection = 0;
3016
3017 /* Actually create and show the dialog. */
3018 create_and_show_dialog (f, first_wv);
3019
3020 /* Free the widget_value objects we used to specify the contents. */
3021 free_menubar_widget_value_tree (first_wv);
3022
3023 /* Find the selected item, and its pane, to return
3024 the proper value. */
3025 if (menu_item_selection != 0)
3026 {
3027 Lisp_Object prefix;
3028
3029 prefix = Qnil;
3030 i = 0;
3031 while (i < menu_items_used)
3032 {
3033 Lisp_Object entry;
3034
3035 if (EQ (XVECTOR (menu_items)->contents[i], Qt))
3036 {
3037 prefix
3038 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
3039 i += MENU_ITEMS_PANE_LENGTH;
3040 }
3041 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
3042 {
3043 /* This is the boundary between left-side elts and
3044 right-side elts. */
3045 ++i;
3046 }
3047 else
3048 {
3049 entry
3050 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
3051 if (menu_item_selection == &XVECTOR (menu_items)->contents[i])
3052 {
3053 if (keymaps != 0)
3054 {
3055 entry = Fcons (entry, Qnil);
3056 if (!NILP (prefix))
3057 entry = Fcons (prefix, entry);
3058 }
3059 return entry;
3060 }
3061 i += MENU_ITEMS_ITEM_LENGTH;
3062 }
3063 }
3064 }
3065
3066 return Qnil;
3067 }
3068
3069 #else /* not USE_X_TOOLKIT && not USE_GTK */
3070
3071 /* The frame of the last activated non-toolkit menu bar.
3072 Used to generate menu help events. */
3073
3074 static struct frame *menu_help_frame;
3075
3076
3077 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3078
3079 PANE is the pane number, and ITEM is the menu item number in
3080 the menu (currently not used).
3081
3082 This cannot be done with generating a HELP_EVENT because
3083 XMenuActivate contains a loop that doesn't let Emacs process
3084 keyboard events. */
3085
3086 static void
3087 menu_help_callback (help_string, pane, item)
3088 char *help_string;
3089 int pane, item;
3090 {
3091 extern Lisp_Object Qmenu_item;
3092 Lisp_Object *first_item;
3093 Lisp_Object pane_name;
3094 Lisp_Object menu_object;
3095
3096 first_item = XVECTOR (menu_items)->contents;
3097 if (EQ (first_item[0], Qt))
3098 pane_name = first_item[MENU_ITEMS_PANE_NAME];
3099 else if (EQ (first_item[0], Qquote))
3100 /* This shouldn't happen, see xmenu_show. */
3101 pane_name = empty_string;
3102 else
3103 pane_name = first_item[MENU_ITEMS_ITEM_NAME];
3104
3105 /* (menu-item MENU-NAME PANE-NUMBER) */
3106 menu_object = Fcons (Qmenu_item,
3107 Fcons (pane_name,
3108 Fcons (make_number (pane), Qnil)));
3109 show_help_echo (help_string ? build_string (help_string) : Qnil,
3110 Qnil, menu_object, make_number (item), 1);
3111 }
3112
3113
3114 static Lisp_Object
3115 xmenu_show (f, x, y, for_click, keymaps, title, error)
3116 FRAME_PTR f;
3117 int x, y;
3118 int for_click;
3119 int keymaps;
3120 Lisp_Object title;
3121 char **error;
3122 {
3123 Window root;
3124 XMenu *menu;
3125 int pane, selidx, lpane, status;
3126 Lisp_Object entry, pane_prefix;
3127 char *datap;
3128 int ulx, uly, width, height;
3129 int dispwidth, dispheight;
3130 int i, j;
3131 int maxwidth;
3132 int dummy_int;
3133 unsigned int dummy_uint;
3134
3135 *error = 0;
3136 if (menu_items_n_panes == 0)
3137 return Qnil;
3138
3139 if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)
3140 {
3141 *error = "Empty menu";
3142 return Qnil;
3143 }
3144
3145 /* Figure out which root window F is on. */
3146 XGetGeometry (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &root,
3147 &dummy_int, &dummy_int, &dummy_uint, &dummy_uint,
3148 &dummy_uint, &dummy_uint);
3149
3150 /* Make the menu on that window. */
3151 menu = XMenuCreate (FRAME_X_DISPLAY (f), root, "emacs");
3152 if (menu == NULL)
3153 {
3154 *error = "Can't create menu";
3155 return Qnil;
3156 }
3157
3158 #ifdef HAVE_X_WINDOWS
3159 /* Adjust coordinates to relative to the outer (window manager) window. */
3160 {
3161 Window child;
3162 int win_x = 0, win_y = 0;
3163
3164 /* Find the position of the outside upper-left corner of
3165 the inner window, with respect to the outer window. */
3166 if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
3167 {
3168 BLOCK_INPUT;
3169 XTranslateCoordinates (FRAME_X_DISPLAY (f),
3170
3171 /* From-window, to-window. */
3172 f->output_data.x->window_desc,
3173 f->output_data.x->parent_desc,
3174
3175 /* From-position, to-position. */
3176 0, 0, &win_x, &win_y,
3177
3178 /* Child of window. */
3179 &child);
3180 UNBLOCK_INPUT;
3181 x += win_x;
3182 y += win_y;
3183 }
3184 }
3185 #endif /* HAVE_X_WINDOWS */
3186
3187 /* Adjust coordinates to be root-window-relative. */
3188 x += f->left_pos;
3189 y += f->top_pos;
3190
3191 /* Create all the necessary panes and their items. */
3192 i = 0;
3193 while (i < menu_items_used)
3194 {
3195 if (EQ (XVECTOR (menu_items)->contents[i], Qt))
3196 {
3197 /* Create a new pane. */
3198 Lisp_Object pane_name, prefix;
3199 char *pane_string;
3200
3201 pane_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_NAME];
3202 prefix = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
3203 pane_string = (NILP (pane_name)
3204 ? "" : (char *) SDATA (pane_name));
3205 if (keymaps && !NILP (prefix))
3206 pane_string++;
3207
3208 lpane = XMenuAddPane (FRAME_X_DISPLAY (f), menu, pane_string, TRUE);
3209 if (lpane == XM_FAILURE)
3210 {
3211 XMenuDestroy (FRAME_X_DISPLAY (f), menu);
3212 *error = "Can't create pane";
3213 return Qnil;
3214 }
3215 i += MENU_ITEMS_PANE_LENGTH;
3216
3217 /* Find the width of the widest item in this pane. */
3218 maxwidth = 0;
3219 j = i;
3220 while (j < menu_items_used)
3221 {
3222 Lisp_Object item;
3223 item = XVECTOR (menu_items)->contents[j];
3224 if (EQ (item, Qt))
3225 break;
3226 if (NILP (item))
3227 {
3228 j++;
3229 continue;
3230 }
3231 width = SBYTES (item);
3232 if (width > maxwidth)
3233 maxwidth = width;
3234
3235 j += MENU_ITEMS_ITEM_LENGTH;
3236 }
3237 }
3238 /* Ignore a nil in the item list.
3239 It's meaningful only for dialog boxes. */
3240 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
3241 i += 1;
3242 else
3243 {
3244 /* Create a new item within current pane. */
3245 Lisp_Object item_name, enable, descrip, help;
3246 unsigned char *item_data;
3247 char *help_string;
3248
3249 item_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_NAME];
3250 enable = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_ENABLE];
3251 descrip
3252 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_EQUIV_KEY];
3253 help = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_HELP];
3254 help_string = STRINGP (help) ? SDATA (help) : NULL;
3255
3256 if (!NILP (descrip))
3257 {
3258 int gap = maxwidth - SBYTES (item_name);
3259 #ifdef C_ALLOCA
3260 Lisp_Object spacer;
3261 spacer = Fmake_string (make_number (gap), make_number (' '));
3262 item_name = concat2 (item_name, spacer);
3263 item_name = concat2 (item_name, descrip);
3264 item_data = SDATA (item_name);
3265 #else
3266 /* if alloca is fast, use that to make the space,
3267 to reduce gc needs. */
3268 item_data
3269 = (unsigned char *) alloca (maxwidth
3270 + SBYTES (descrip) + 1);
3271 bcopy (SDATA (item_name), item_data,
3272 SBYTES (item_name));
3273 for (j = SCHARS (item_name); j < maxwidth; j++)
3274 item_data[j] = ' ';
3275 bcopy (SDATA (descrip), item_data + j,
3276 SBYTES (descrip));
3277 item_data[j + SBYTES (descrip)] = 0;
3278 #endif
3279 }
3280 else
3281 item_data = SDATA (item_name);
3282
3283 if (XMenuAddSelection (FRAME_X_DISPLAY (f),
3284 menu, lpane, 0, item_data,
3285 !NILP (enable), help_string)
3286 == XM_FAILURE)
3287 {
3288 XMenuDestroy (FRAME_X_DISPLAY (f), menu);
3289 *error = "Can't add selection to menu";
3290 return Qnil;
3291 }
3292 i += MENU_ITEMS_ITEM_LENGTH;
3293 }
3294 }
3295
3296 /* All set and ready to fly. */
3297 XMenuRecompute (FRAME_X_DISPLAY (f), menu);
3298 dispwidth = DisplayWidth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
3299 dispheight = DisplayHeight (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
3300 x = min (x, dispwidth);
3301 y = min (y, dispheight);
3302 x = max (x, 1);
3303 y = max (y, 1);
3304 XMenuLocate (FRAME_X_DISPLAY (f), menu, 0, 0, x, y,
3305 &ulx, &uly, &width, &height);
3306 if (ulx+width > dispwidth)
3307 {
3308 x -= (ulx + width) - dispwidth;
3309 ulx = dispwidth - width;
3310 }
3311 if (uly+height > dispheight)
3312 {
3313 y -= (uly + height) - dispheight;
3314 uly = dispheight - height;
3315 }
3316 if (ulx < 0) x -= ulx;
3317 if (uly < 0) y -= uly;
3318
3319 XMenuSetAEQ (menu, TRUE);
3320 XMenuSetFreeze (menu, TRUE);
3321 pane = selidx = 0;
3322
3323 /* Help display under X won't work because XMenuActivate contains
3324 a loop that doesn't give Emacs a chance to process it. */
3325 menu_help_frame = f;
3326 status = XMenuActivate (FRAME_X_DISPLAY (f), menu, &pane, &selidx,
3327 x, y, ButtonReleaseMask, &datap,
3328 menu_help_callback);
3329
3330
3331 #ifdef HAVE_X_WINDOWS
3332 /* Assume the mouse has moved out of the X window.
3333 If it has actually moved in, we will get an EnterNotify. */
3334 x_mouse_leave (FRAME_X_DISPLAY_INFO (f));
3335 #endif
3336
3337 switch (status)
3338 {
3339 case XM_SUCCESS:
3340 #ifdef XDEBUG
3341 fprintf (stderr, "pane= %d line = %d\n", panes, selidx);
3342 #endif
3343
3344 /* Find the item number SELIDX in pane number PANE. */
3345 i = 0;
3346 while (i < menu_items_used)
3347 {
3348 if (EQ (XVECTOR (menu_items)->contents[i], Qt))
3349 {
3350 if (pane == 0)
3351 pane_prefix
3352 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
3353 pane--;
3354 i += MENU_ITEMS_PANE_LENGTH;
3355 }
3356 else
3357 {
3358 if (pane == -1)
3359 {
3360 if (selidx == 0)
3361 {
3362 entry
3363 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
3364 if (keymaps != 0)
3365 {
3366 entry = Fcons (entry, Qnil);
3367 if (!NILP (pane_prefix))
3368 entry = Fcons (pane_prefix, entry);
3369 }
3370 break;
3371 }
3372 selidx--;
3373 }
3374 i += MENU_ITEMS_ITEM_LENGTH;
3375 }
3376 }
3377 break;
3378
3379 case XM_FAILURE:
3380 *error = "Can't activate menu";
3381 case XM_IA_SELECT:
3382 case XM_NO_SELECT:
3383 entry = Qnil;
3384 break;
3385 }
3386 XMenuDestroy (FRAME_X_DISPLAY (f), menu);
3387
3388 #ifdef HAVE_X_WINDOWS
3389 /* State that no mouse buttons are now held.
3390 (The oldXMenu code doesn't track this info for us.)
3391 That is not necessarily true, but the fiction leads to reasonable
3392 results, and it is a pain to ask which are actually held now. */
3393 FRAME_X_DISPLAY_INFO (f)->grabbed = 0;
3394 #endif
3395
3396 return entry;
3397 }
3398
3399 #endif /* not USE_X_TOOLKIT */
3400
3401 #endif /* HAVE_MENUS */
3402 \f
3403 void
3404 syms_of_xmenu ()
3405 {
3406 staticpro (&menu_items);
3407 menu_items = Qnil;
3408 menu_items_inuse = Qnil;
3409
3410 Qdebug_on_next_call = intern ("debug-on-next-call");
3411 staticpro (&Qdebug_on_next_call);
3412
3413 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame,
3414 doc: /* Frame for which we are updating a menu.
3415 The enable predicate for a menu command should check this variable. */);
3416 Vmenu_updating_frame = Qnil;
3417
3418 #ifdef USE_X_TOOLKIT
3419 widget_id_tick = (1<<16);
3420 next_menubar_widget_id = 1;
3421 #endif
3422
3423 defsubr (&Sx_popup_menu);
3424 #ifdef HAVE_MENUS
3425 defsubr (&Sx_popup_dialog);
3426 #endif
3427 }
3428
3429 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3430 (do not change this comment) */