1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 88, 93, 94, 96, 99, 2000, 2001, 2003
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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)
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.
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. */
22 /* X pop-up deck-of-cards menu facility for GNU Emacs.
24 * Written by Jon Arnold and Roman Budzianowski
25 * Mods and rewrite by Robert Krawitz
29 /* Modified by Fred Pierresteguy on December 93
30 to make the popup menus and menubar use the Xt. */
32 /* Rewritten for clarity and GC protection by rms in Feb 94. */
36 /* On 4.3 this loses if it comes after xterm.h. */
42 #include "termhooks.h"
47 #include "blockinput.h"
57 /* This may include sys/types.h, and that somehow loses
58 if this is not done before the other system files. */
62 /* Load sys/types.h if not already loaded.
63 In some systems loading it twice is suicidal. */
65 #include <sys/types.h>
68 #include "dispextern.h"
71 #undef HAVE_MULTILINGUAL_MENU
75 #include <X11/IntrinsicP.h>
76 #include <X11/CoreP.h>
77 #include <X11/StringDefs.h>
78 #include <X11/Shell.h>
80 #include <X11/Xaw/Paned.h>
81 #endif /* USE_LUCID */
82 #include "../lwlib/lwlib.h"
83 #else /* not USE_X_TOOLKIT */
85 #include "../oldXMenu/XMenu.h"
87 #endif /* not USE_X_TOOLKIT */
88 #endif /* HAVE_X_WINDOWS */
95 Lisp_Object Vmenu_updating_frame
;
97 Lisp_Object Qdebug_on_next_call
;
99 extern Lisp_Object Qmenu_bar
;
100 extern Lisp_Object Qmouse_click
, Qevent_kind
;
102 extern Lisp_Object QCtoggle
, QCradio
;
104 extern Lisp_Object Voverriding_local_map
;
105 extern Lisp_Object Voverriding_local_map_menu_flag
;
107 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
109 extern Lisp_Object Qmenu_bar_update_hook
;
112 extern void set_frame_menubar ();
113 extern XtAppContext Xt_app_con
;
115 static Lisp_Object
xdialog_show ();
116 static void popup_get_selection ();
118 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
121 #endif /* USE_X_TOOLKIT */
126 extern void set_frame_menubar ();
127 static Lisp_Object
xdialog_show ();
130 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
131 Lisp_Object
, Lisp_Object
, Lisp_Object
,
132 Lisp_Object
, Lisp_Object
));
133 static int update_frame_menubar
P_ ((struct frame
*));
134 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
135 Lisp_Object
, char **));
136 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
137 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
139 static void list_of_panes
P_ ((Lisp_Object
));
140 static void list_of_items
P_ ((Lisp_Object
));
142 extern EMACS_TIME timer_check
P_ ((int));
144 /* This holds a Lisp vector that holds the results of decoding
145 the keymaps or alist-of-alists that specify a menu.
147 It describes the panes and items within the panes.
149 Each pane is described by 3 elements in the vector:
150 t, the pane name, the pane's prefix key.
151 Then follow the pane's items, with 5 elements per item:
152 the item string, the enable flag, the item's value,
153 the definition, and the equivalent keyboard key's description string.
155 In some cases, multiple levels of menus may be described.
156 A single vector slot containing nil indicates the start of a submenu.
157 A single vector slot containing lambda indicates the end of a submenu.
158 The submenu follows a menu item which is the way to reach the submenu.
160 A single vector slot containing quote indicates that the
161 following items should appear on the right of a dialog box.
163 Using a Lisp vector to hold this information while we decode it
164 takes care of protecting all the data from GC. */
166 #define MENU_ITEMS_PANE_NAME 1
167 #define MENU_ITEMS_PANE_PREFIX 2
168 #define MENU_ITEMS_PANE_LENGTH 3
172 MENU_ITEMS_ITEM_NAME
= 0,
173 MENU_ITEMS_ITEM_ENABLE
,
174 MENU_ITEMS_ITEM_VALUE
,
175 MENU_ITEMS_ITEM_EQUIV_KEY
,
176 MENU_ITEMS_ITEM_DEFINITION
,
177 MENU_ITEMS_ITEM_TYPE
,
178 MENU_ITEMS_ITEM_SELECTED
,
179 MENU_ITEMS_ITEM_HELP
,
180 MENU_ITEMS_ITEM_LENGTH
183 static Lisp_Object menu_items
;
185 /* If non-nil, means that the global vars defined here are already in use.
186 Used to detect cases where we try to re-enter this non-reentrant code. */
187 static Lisp_Object menu_items_inuse
;
189 /* Number of slots currently allocated in menu_items. */
190 static int menu_items_allocated
;
192 /* This is the index in menu_items of the first empty slot. */
193 static int menu_items_used
;
195 /* The number of panes currently recorded in menu_items,
196 excluding those within submenus. */
197 static int menu_items_n_panes
;
199 /* Current depth within submenus. */
200 static int menu_items_submenu_depth
;
202 /* Flag which when set indicates a dialog or menu has been posted by
203 Xt on behalf of one of the widget sets. */
204 static int popup_activated_flag
;
206 static int next_menubar_widget_id
;
208 /* This is set nonzero after the user activates the menu bar, and set
209 to zero again after the menu bars are redisplayed by prepare_menu_bar.
210 While it is nonzero, all calls to set_frame_menubar go deep.
212 I don't understand why this is needed, but it does seem to be
213 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
215 int pending_menu_activation
;
219 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
221 static struct frame
*
222 menubar_id_to_frame (id
)
225 Lisp_Object tail
, frame
;
228 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
231 if (!GC_FRAMEP (frame
))
234 if (!FRAME_WINDOW_P (f
))
236 if (f
->output_data
.x
->id
== id
)
244 /* Initialize the menu_items structure if we haven't already done so.
245 Also mark it as currently empty. */
250 if (NILP (menu_items
))
252 menu_items_allocated
= 60;
253 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
256 if (!NILP (menu_items_inuse
))
257 error ("Trying to use a menu from within a menu-entry");
258 menu_items_inuse
= Qt
;
260 menu_items_n_panes
= 0;
261 menu_items_submenu_depth
= 0;
264 /* Call at the end of generating the data in menu_items. */
272 unuse_menu_items (dummy
)
275 return menu_items_inuse
= Qnil
;
278 /* Call when finished using the data for the current menu
282 discard_menu_items ()
284 /* Free the structure if it is especially large.
285 Otherwise, hold on to it, to save time. */
286 if (menu_items_allocated
> 200)
289 menu_items_allocated
= 0;
291 xassert (NILP (menu_items_inuse
));
294 /* Make the menu_items vector twice as large. */
300 int old_size
= menu_items_allocated
;
303 menu_items_allocated
*= 2;
304 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
305 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
306 old_size
* sizeof (Lisp_Object
));
309 /* Begin a submenu. */
312 push_submenu_start ()
314 if (menu_items_used
+ 1 > menu_items_allocated
)
317 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
318 menu_items_submenu_depth
++;
326 if (menu_items_used
+ 1 > menu_items_allocated
)
329 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
330 menu_items_submenu_depth
--;
333 /* Indicate boundary between left and right. */
336 push_left_right_boundary ()
338 if (menu_items_used
+ 1 > menu_items_allocated
)
341 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
344 /* Start a new menu pane in menu_items.
345 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
348 push_menu_pane (name
, prefix_vec
)
349 Lisp_Object name
, prefix_vec
;
351 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
354 if (menu_items_submenu_depth
== 0)
355 menu_items_n_panes
++;
356 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
357 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
358 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
361 /* Push one menu item into the current pane. NAME is the string to
362 display. ENABLE if non-nil means this item can be selected. KEY
363 is the key generated by choosing this item, or nil if this item
364 doesn't really have a definition. DEF is the definition of this
365 item. EQUIV is the textual description of the keyboard equivalent
366 for this item (or nil if none). TYPE is the type of this menu
367 item, one of nil, `toggle' or `radio'. */
370 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
371 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
373 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
376 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
377 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
378 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
379 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
380 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
381 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
382 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
383 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
386 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
387 and generate menu panes for them in menu_items.
388 If NOTREAL is nonzero,
389 don't bother really computing whether an item is enabled. */
392 keymap_panes (keymaps
, nmaps
, notreal
)
393 Lisp_Object
*keymaps
;
401 /* Loop over the given keymaps, making a pane for each map.
402 But don't make a pane that is empty--ignore that map instead.
403 P is the number of panes we have made so far. */
404 for (mapno
= 0; mapno
< nmaps
; mapno
++)
405 single_keymap_panes (keymaps
[mapno
],
406 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
408 finish_menu_items ();
411 /* Args passed between single_keymap_panes and single_menu_item. */
414 Lisp_Object pending_maps
;
415 int maxdepth
, notreal
;
419 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
422 /* This is a recursive subroutine of keymap_panes.
423 It handles one keymap, KEYMAP.
424 The other arguments are passed along
425 or point to local variables of the previous function.
426 If NOTREAL is nonzero, only check for equivalent key bindings, don't
427 evaluate expressions in menu items and don't make any menu.
429 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
432 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
434 Lisp_Object pane_name
;
442 skp
.pending_maps
= Qnil
;
443 skp
.maxdepth
= maxdepth
;
444 skp
.notreal
= notreal
;
450 push_menu_pane (pane_name
, prefix
);
453 /* Remember index for first item in this pane so we can go back and
454 add a prefix when (if) we see the first button. After that, notbuttons
455 is set to 0, to mark that we have seen a button and all non button
456 items need a prefix. */
457 skp
.notbuttons
= menu_items_used
;
460 GCPRO1 (skp
.pending_maps
);
461 map_keymap (keymap
, single_menu_item
, Qnil
, &skp
, 1);
464 /* Process now any submenus which want to be panes at this level. */
465 while (CONSP (skp
.pending_maps
))
467 Lisp_Object elt
, eltcdr
, string
;
468 elt
= XCAR (skp
.pending_maps
);
470 string
= XCAR (eltcdr
);
471 /* We no longer discard the @ from the beginning of the string here.
472 Instead, we do this in xmenu_show. */
473 single_keymap_panes (Fcar (elt
), string
,
474 XCDR (eltcdr
), notreal
, maxdepth
- 1);
475 skp
.pending_maps
= XCDR (skp
.pending_maps
);
479 /* This is a subroutine of single_keymap_panes that handles one
481 KEY is a key in a keymap and ITEM is its binding.
482 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
484 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
485 evaluate expressions in menu items and don't make any menu.
486 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
487 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
488 buttons. It keeps track of if we have seen a button in this menu or
492 single_menu_item (key
, item
, dummy
, skp_v
)
493 Lisp_Object key
, item
, dummy
;
496 Lisp_Object map
, item_string
, enabled
;
497 struct gcpro gcpro1
, gcpro2
;
499 struct skp
*skp
= skp_v
;
501 /* Parse the menu item and leave the result in item_properties. */
503 res
= parse_menu_item (item
, skp
->notreal
, 0);
506 return; /* Not a menu item. */
508 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
512 /* We don't want to make a menu, just traverse the keymaps to
513 precompute equivalent key bindings. */
515 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
519 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
520 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
522 if (!NILP (map
) && SREF (item_string
, 0) == '@')
525 /* An enabled separate pane. Remember this to handle it later. */
526 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
532 /* Simulate radio buttons and toggle boxes by putting a prefix in
535 Lisp_Object prefix
= Qnil
;
536 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
540 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
543 /* The first button. Line up previous items in this menu. */
545 int index
= skp
->notbuttons
; /* Index for first item this menu. */
548 while (index
< menu_items_used
)
551 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
555 submenu
++; /* Skip sub menu. */
557 else if (EQ (tem
, Qlambda
))
560 submenu
--; /* End sub menu. */
562 else if (EQ (tem
, Qt
))
563 index
+= 3; /* Skip new pane marker. */
564 else if (EQ (tem
, Qquote
))
565 index
++; /* Skip a left, right divider. */
568 if (!submenu
&& SREF (tem
, 0) != '\0'
569 && SREF (tem
, 0) != '-')
570 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
571 = concat2 (build_string (" "), tem
);
572 index
+= MENU_ITEMS_ITEM_LENGTH
;
578 /* Calculate prefix, if any, for this item. */
579 if (EQ (type
, QCtoggle
))
580 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
581 else if (EQ (type
, QCradio
))
582 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
584 /* Not a button. If we have earlier buttons, then we need a prefix. */
585 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
586 && SREF (item_string
, 0) != '-')
587 prefix
= build_string (" ");
590 item_string
= concat2 (prefix
, item_string
);
592 #endif /* not HAVE_BOXES */
594 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
596 /* Indicate visually that this is a submenu. */
597 item_string
= concat2 (item_string
, build_string (" >"));
600 push_menu_item (item_string
, enabled
, key
,
601 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
602 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
603 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
604 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
605 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
607 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
608 /* Display a submenu using the toolkit. */
609 if (! (NILP (map
) || NILP (enabled
)))
611 push_submenu_start ();
612 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
618 /* Push all the panes and items of a menu described by the
619 alist-of-alists MENU.
620 This handles old-fashioned calls to x-popup-menu. */
630 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
632 Lisp_Object elt
, pane_name
, pane_data
;
634 pane_name
= Fcar (elt
);
635 CHECK_STRING (pane_name
);
636 push_menu_pane (pane_name
, Qnil
);
637 pane_data
= Fcdr (elt
);
638 CHECK_CONS (pane_data
);
639 list_of_items (pane_data
);
642 finish_menu_items ();
645 /* Push the items in a single pane defined by the alist PANE. */
651 Lisp_Object tail
, item
, item1
;
653 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
657 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
658 else if (NILP (item
))
659 push_left_right_boundary ();
664 CHECK_STRING (item1
);
665 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
670 #ifdef HAVE_X_WINDOWS
671 /* Return the mouse position in *X and *Y. The coordinates are window
672 relative for the edit window in frame F.
673 This is for Fx_popup_menu. The mouse_position_hook can not
674 be used for X, as it returns window relative coordinates
675 for the window where the mouse is in. This could be the menu bar,
676 the scroll bar or the edit window. Fx_popup_menu needs to be
677 sure it is the edit window. */
679 mouse_position_for_popup(f
, x
, y
)
684 Window root
, dummy_window
;
689 XQueryPointer (FRAME_X_DISPLAY (f
),
690 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
692 /* The root window which contains the pointer. */
695 /* Window pointer is on, not used */
698 /* The position on that root window. */
701 /* x/y in dummy_window coordinates, not used. */
704 /* Modifier keys and pointer buttons, about which
706 (unsigned int *) &dummy
);
710 /* xmenu_show expects window coordinates, not root window
711 coordinates. Translate. */
712 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
713 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
716 #endif /* HAVE_X_WINDOWS */
718 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
719 doc
: /* Pop up a deck-of-cards menu and return user's selection.
720 POSITION is a position specification. This is either a mouse button event
721 or a list ((XOFFSET YOFFSET) WINDOW)
722 where XOFFSET and YOFFSET are positions in pixels from the top left
723 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)
724 This controls the position of the center of the first line
725 in the first pane of the menu, not the top left of the menu as a whole.
726 If POSITION is t, it means to use the current mouse position.
728 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
729 The menu items come from key bindings that have a menu string as well as
730 a definition; actually, the "definition" in such a key binding looks like
731 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
732 the keymap as a top-level element.
734 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
735 Otherwise, REAL-DEFINITION should be a valid key binding definition.
737 You can also use a list of keymaps as MENU.
738 Then each keymap makes a separate pane.
739 When MENU is a keymap or a list of keymaps, the return value
742 Alternatively, you can specify a menu of multiple panes
743 with a list of the form (TITLE PANE1 PANE2...),
744 where each pane is a list of form (TITLE ITEM1 ITEM2...).
745 Each ITEM is normally a cons cell (STRING . VALUE);
746 but a string can appear as an item--that makes a nonselectable line
748 With this form of menu, the return value is VALUE from the chosen item.
750 If POSITION is nil, don't display the menu at all, just precalculate the
751 cached information about equivalent key sequences. */)
753 Lisp_Object position
, menu
;
755 Lisp_Object keymap
, tem
;
756 int xpos
= 0, ypos
= 0;
759 Lisp_Object selection
;
761 Lisp_Object x
, y
, window
;
764 int specpdl_count
= SPECPDL_INDEX ();
768 if (! NILP (position
))
770 int get_current_pos_p
= 0;
773 /* Decode the first argument: find the window and the coordinates. */
774 if (EQ (position
, Qt
)
775 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
776 || EQ (XCAR (position
), Qtool_bar
))))
778 get_current_pos_p
= 1;
782 tem
= Fcar (position
);
785 window
= Fcar (Fcdr (position
));
787 y
= Fcar (Fcdr (tem
));
792 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
793 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
794 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
799 /* If a click happens in an external tool bar or a detached
800 tool bar, x and y is NIL. In that case, use the current
801 mouse position. This happens for the help button in the
802 tool bar. Ideally popup-menu should pass NIL to
803 this function, but it doesn't. */
804 if (NILP (x
) && NILP (y
))
805 get_current_pos_p
= 1;
808 if (get_current_pos_p
)
810 /* Use the mouse's current position. */
811 FRAME_PTR new_f
= SELECTED_FRAME ();
812 #ifdef HAVE_X_WINDOWS
813 /* Can't use mouse_position_hook for X since it returns
814 coordinates relative to the window the mouse is in,
815 we need coordinates relative to the edit widget always. */
820 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
821 /* cur_x/y may be negative, so use make_number. */
822 x
= make_number (cur_x
);
823 y
= make_number (cur_y
);
826 #else /* not HAVE_X_WINDOWS */
827 Lisp_Object bar_window
;
828 enum scroll_bar_part part
;
831 if (mouse_position_hook
)
832 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
833 &part
, &x
, &y
, &time
);
834 #endif /* not HAVE_X_WINDOWS */
837 XSETFRAME (window
, new_f
);
840 window
= selected_window
;
849 /* Decode where to put the menu. */
857 else if (WINDOWP (window
))
859 CHECK_LIVE_WINDOW (window
);
860 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
862 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
863 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
866 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
867 but I don't want to make one now. */
868 CHECK_WINDOW (window
);
873 Vmenu_updating_frame
= Qnil
;
874 #endif /* HAVE_MENUS */
876 record_unwind_protect (unuse_menu_items
, Qnil
);
880 /* Decode the menu items from what was specified. */
882 keymap
= get_keymap (menu
, 0, 0);
885 /* We were given a keymap. Extract menu info from the keymap. */
888 /* Extract the detailed info to make one pane. */
889 keymap_panes (&menu
, 1, NILP (position
));
891 /* Search for a string appearing directly as an element of the keymap.
892 That string is the title of the menu. */
893 prompt
= Fkeymap_prompt (keymap
);
894 if (NILP (title
) && !NILP (prompt
))
897 /* Make that be the pane title of the first pane. */
898 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
899 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
903 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
905 /* We were given a list of keymaps. */
906 int nmaps
= XFASTINT (Flength (menu
));
908 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
913 /* The first keymap that has a prompt string
914 supplies the menu title. */
915 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
919 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
921 prompt
= Fkeymap_prompt (keymap
);
922 if (NILP (title
) && !NILP (prompt
))
926 /* Extract the detailed info to make one pane. */
927 keymap_panes (maps
, nmaps
, NILP (position
));
929 /* Make the title be the pane title of the first pane. */
930 if (!NILP (title
) && menu_items_n_panes
>= 0)
931 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
937 /* We were given an old-fashioned menu. */
939 CHECK_STRING (title
);
941 list_of_panes (Fcdr (menu
));
946 unbind_to (specpdl_count
, Qnil
);
950 discard_menu_items ();
956 /* Display them in a menu. */
959 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
960 keymaps
, title
, &error_name
);
963 discard_menu_items ();
966 #endif /* HAVE_MENUS */
968 if (error_name
) error (error_name
);
974 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
975 doc
: /* Pop up a dialog box and return user's selection.
976 POSITION specifies which frame to use.
977 This is normally a mouse button event or a window or frame.
978 If POSITION is t, it means to use the frame the mouse is on.
979 The dialog box appears in the middle of the specified frame.
981 CONTENTS specifies the alternatives to display in the dialog box.
982 It is a list of the form (TITLE ITEM1 ITEM2...).
983 Each ITEM is a cons cell (STRING . VALUE).
984 The return value is VALUE from the chosen item.
986 An ITEM may also be just a string--that makes a nonselectable item.
987 An ITEM may also be nil--that means to put all preceding items
988 on the left of the dialog box and all following items on the right.
989 \(By default, approximately half appear on each side.) */)
991 Lisp_Object position
, contents
;
998 /* Decode the first argument: find the window or frame to use. */
999 if (EQ (position
, Qt
)
1000 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1001 || EQ (XCAR (position
), Qtool_bar
))))
1003 #if 0 /* Using the frame the mouse is on may not be right. */
1004 /* Use the mouse's current position. */
1005 FRAME_PTR new_f
= SELECTED_FRAME ();
1006 Lisp_Object bar_window
;
1007 enum scroll_bar_part part
;
1011 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1014 XSETFRAME (window
, new_f
);
1016 window
= selected_window
;
1018 window
= selected_window
;
1020 else if (CONSP (position
))
1023 tem
= Fcar (position
);
1025 window
= Fcar (Fcdr (position
));
1028 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1029 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1032 else if (WINDOWP (position
) || FRAMEP (position
))
1037 /* Decode where to put the menu. */
1039 if (FRAMEP (window
))
1040 f
= XFRAME (window
);
1041 else if (WINDOWP (window
))
1043 CHECK_LIVE_WINDOW (window
);
1044 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1047 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1048 but I don't want to make one now. */
1049 CHECK_WINDOW (window
);
1051 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1052 /* Display a menu with these alternatives
1053 in the middle of frame F. */
1055 Lisp_Object x
, y
, frame
, newpos
;
1056 XSETFRAME (frame
, f
);
1057 XSETINT (x
, x_pixel_width (f
) / 2);
1058 XSETINT (y
, x_pixel_height (f
) / 2);
1059 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1061 return Fx_popup_menu (newpos
,
1062 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1068 Lisp_Object selection
;
1069 int specpdl_count
= SPECPDL_INDEX ();
1071 /* Decode the dialog items from what was specified. */
1072 title
= Fcar (contents
);
1073 CHECK_STRING (title
);
1074 record_unwind_protect (unuse_menu_items
, Qnil
);
1076 list_of_panes (Fcons (contents
, Qnil
));
1078 /* Display them in a dialog box. */
1080 selection
= xdialog_show (f
, 0, title
, &error_name
);
1083 unbind_to (specpdl_count
, Qnil
);
1084 discard_menu_items ();
1086 if (error_name
) error (error_name
);
1092 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1094 /* Loop in Xt until the menu pulldown or dialog popup has been
1095 popped down (deactivated). This is used for x-popup-menu
1096 and x-popup-dialog; it is not used for the menu bar.
1098 If DO_TIMERS is nonzero, run timers.
1100 NOTE: All calls to popup_get_selection should be protected
1101 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1103 #ifdef USE_X_TOOLKIT
1105 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1106 XEvent
*initial_event
;
1107 struct x_display_info
*dpyinfo
;
1113 while (popup_activated_flag
)
1115 /* If we have no events to run, consider timers. */
1116 if (do_timers
&& !XtAppPending (Xt_app_con
))
1121 event
= *initial_event
;
1125 XtAppNextEvent (Xt_app_con
, &event
);
1127 /* Make sure we don't consider buttons grabbed after menu goes.
1128 And make sure to deactivate for any ButtonRelease,
1129 even if XtDispatchEvent doesn't do that. */
1130 if (event
.type
== ButtonRelease
1131 && dpyinfo
->display
== event
.xbutton
.display
)
1133 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1134 #ifdef USE_MOTIF /* Pretending that the event came from a
1135 Btn1Down seems the only way to convince Motif to
1136 activate its callbacks; setting the XmNmenuPost
1137 isn't working. --marcus@sysc.pdx.edu. */
1138 event
.xbutton
.button
= 1;
1139 /* Motif only pops down menus when no Ctrl, Alt or Mod
1140 key is pressed and the button is released. So reset key state
1141 so Motif thinks this is the case. */
1142 event
.xbutton
.state
= 0;
1145 /* If the user presses a key, deactivate the menu.
1146 The user is likely to do that if we get wedged.
1147 This is mostly for Lucid, Motif pops down the menu on ESC. */
1148 else if (event
.type
== KeyPress
1149 && dpyinfo
->display
== event
.xbutton
.display
)
1151 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1152 if (!IsModifierKey (keysym
))
1153 popup_activated_flag
= 0;
1156 x_dispatch_event (&event
, event
.xany
.display
);
1160 #endif /* USE_X_TOOLKIT */
1163 /* Loop util popup_activated_flag is set to zero in a callback.
1164 Used for popup menus and dialogs. */
1166 popup_widget_loop ()
1168 ++popup_activated_flag
;
1170 /* Process events in the Gtk event loop until done. */
1171 while (popup_activated_flag
)
1173 gtk_main_iteration ();
1178 /* Activate the menu bar of frame F.
1179 This is called from keyboard.c when it gets the
1180 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1182 To activate the menu bar, we use the X button-press event
1183 that was saved in saved_menu_event.
1184 That makes the toolkit do its thing.
1186 But first we recompute the menu bar contents (the whole tree).
1188 The reason for saving the button event until here, instead of
1189 passing it to the toolkit right away, is that we can safely
1190 execute Lisp code. */
1193 x_activate_menubar (f
)
1196 if (!f
->output_data
.x
->saved_menu_event
->type
)
1200 if (! xg_win_to_widget (f
->output_data
.x
->saved_menu_event
->xany
.window
))
1204 set_frame_menubar (f
, 0, 1);
1207 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1208 f
->output_data
.x
->saved_menu_event
);
1209 popup_activated_flag
= 1;
1211 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1215 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1216 pending_menu_activation
= 1;
1219 /* Ignore this if we get it a second time. */
1220 f
->output_data
.x
->saved_menu_event
->type
= 0;
1223 /* Detect if a dialog or menu has been posted. */
1228 return popup_activated_flag
;
1231 /* This callback is invoked when the user selects a menubar cascade
1232 pushbutton, but before the pulldown menu is posted. */
1236 popup_activate_callback (widget
, id
, client_data
)
1239 XtPointer client_data
;
1241 popup_activated_flag
= 1;
1245 /* This callback is invoked when a dialog or menu is finished being
1246 used and has been unposted. */
1250 popup_deactivate_callback (widget
, client_data
)
1252 gpointer client_data
;
1254 popup_activated_flag
= 0;
1258 popup_deactivate_callback (widget
, id
, client_data
)
1261 XtPointer client_data
;
1263 popup_activated_flag
= 0;
1268 /* Function that finds the frame for WIDGET and shows the HELP text
1270 F is the frame if known, or NULL if not known. */
1272 show_help_event (f
, widget
, help
)
1274 xt_or_gtk_widget widget
;
1281 XSETFRAME (frame
, f
);
1282 kbd_buffer_store_help_event (frame
, help
);
1286 /* WIDGET is the popup menu. It's parent is the frame's
1287 widget. See which frame that is. */
1288 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1291 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1293 frame
= XCAR (tail
);
1294 if (GC_FRAMEP (frame
)
1295 && (f
= XFRAME (frame
),
1296 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1300 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1304 /* Callback called when menu items are highlighted/unhighlighted
1305 while moving the mouse over them. WIDGET is the menu bar or menu
1306 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1307 the data structure for the menu item, or null in case of
1312 menu_highlight_callback (widget
, call_data
)
1316 xg_menu_item_cb_data
*cb_data
;
1319 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1321 if (! cb_data
) return;
1323 help
= call_data
? cb_data
->help
: Qnil
;
1325 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1326 Don't show help for them, they won't appear before the
1327 popup is popped down. */
1328 if (popup_activated_flag
<= 1)
1329 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1333 menu_highlight_callback (widget
, id
, call_data
)
1341 widget_value
*wv
= (widget_value
*) call_data
;
1343 help
= wv
? wv
->help
: Qnil
;
1345 /* Determine the frame for the help event. */
1346 f
= menubar_id_to_frame (id
);
1348 show_help_event (f
, widget
, help
);
1352 /* Find the menu selection and store it in the keyboard buffer.
1353 F is the frame the menu is on.
1354 MENU_BAR_ITEMS_USED is the length of VECTOR.
1355 VECTOR is an array of menu events for the whole menu.
1358 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1360 int menu_bar_items_used
;
1364 Lisp_Object prefix
, entry
;
1365 Lisp_Object
*subprefix_stack
;
1366 int submenu_depth
= 0;
1370 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1374 while (i
< menu_bar_items_used
)
1376 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1378 subprefix_stack
[submenu_depth
++] = prefix
;
1382 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1384 prefix
= subprefix_stack
[--submenu_depth
];
1387 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1389 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1390 i
+= MENU_ITEMS_PANE_LENGTH
;
1394 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1395 /* The EMACS_INT cast avoids a warning. There's no problem
1396 as long as pointers have enough bits to hold small integers. */
1397 if ((int) (EMACS_INT
) client_data
== i
)
1400 struct input_event buf
;
1403 XSETFRAME (frame
, f
);
1404 buf
.kind
= MENU_BAR_EVENT
;
1405 buf
.frame_or_window
= frame
;
1407 kbd_buffer_store_event (&buf
);
1409 for (j
= 0; j
< submenu_depth
; j
++)
1410 if (!NILP (subprefix_stack
[j
]))
1412 buf
.kind
= MENU_BAR_EVENT
;
1413 buf
.frame_or_window
= frame
;
1414 buf
.arg
= subprefix_stack
[j
];
1415 kbd_buffer_store_event (&buf
);
1420 buf
.kind
= MENU_BAR_EVENT
;
1421 buf
.frame_or_window
= frame
;
1423 kbd_buffer_store_event (&buf
);
1426 buf
.kind
= MENU_BAR_EVENT
;
1427 buf
.frame_or_window
= frame
;
1429 kbd_buffer_store_event (&buf
);
1433 i
+= MENU_ITEMS_ITEM_LENGTH
;
1440 /* Gtk calls callbacks just because we tell it what item should be
1441 selected in a radio group. If this variable is set to a non-zero
1442 value, we are creating menus and don't want callbacks right now.
1444 static int xg_crazy_callback_abort
;
1446 /* This callback is called from the menu bar pulldown menu
1447 when the user makes a selection.
1448 Figure out what the user chose
1449 and put the appropriate events into the keyboard buffer. */
1451 menubar_selection_callback (widget
, client_data
)
1453 gpointer client_data
;
1455 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1457 if (xg_crazy_callback_abort
)
1460 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1463 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1464 cb_data
->cl_data
->menu_bar_items_used
,
1465 cb_data
->cl_data
->menu_bar_vector
,
1466 cb_data
->call_data
);
1469 #else /* not USE_GTK */
1471 /* This callback is called from the menu bar pulldown menu
1472 when the user makes a selection.
1473 Figure out what the user chose
1474 and put the appropriate events into the keyboard buffer. */
1476 menubar_selection_callback (widget
, id
, client_data
)
1479 XtPointer client_data
;
1483 f
= menubar_id_to_frame (id
);
1486 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1487 f
->menu_bar_vector
, client_data
);
1489 #endif /* not USE_GTK */
1491 /* Allocate a widget_value, blocking input. */
1494 xmalloc_widget_value ()
1496 widget_value
*value
;
1499 value
= malloc_widget_value ();
1505 /* This recursively calls free_widget_value on the tree of widgets.
1506 It must free all data that was malloc'ed for these widget_values.
1507 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1508 must be left alone. */
1511 free_menubar_widget_value_tree (wv
)
1516 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1518 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1520 free_menubar_widget_value_tree (wv
->contents
);
1521 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1525 free_menubar_widget_value_tree (wv
->next
);
1526 wv
->next
= (widget_value
*) 0xDEADBEEF;
1529 free_widget_value (wv
);
1533 /* Set up data in menu_items for a menu bar item
1534 whose event type is ITEM_KEY (with string ITEM_NAME)
1535 and whose contents come from the list of keymaps MAPS. */
1538 parse_single_submenu (item_key
, item_name
, maps
)
1539 Lisp_Object item_key
, item_name
, maps
;
1543 Lisp_Object
*mapvec
;
1545 int top_level_items
= 0;
1547 length
= Flength (maps
);
1548 len
= XINT (length
);
1550 /* Convert the list MAPS into a vector MAPVEC. */
1551 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1552 for (i
= 0; i
< len
; i
++)
1554 mapvec
[i
] = Fcar (maps
);
1558 /* Loop over the given keymaps, making a pane for each map.
1559 But don't make a pane that is empty--ignore that map instead. */
1560 for (i
= 0; i
< len
; i
++)
1562 if (!KEYMAPP (mapvec
[i
]))
1564 /* Here we have a command at top level in the menu bar
1565 as opposed to a submenu. */
1566 top_level_items
= 1;
1567 push_menu_pane (Qnil
, Qnil
);
1568 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1569 Qnil
, Qnil
, Qnil
, Qnil
);
1574 prompt
= Fkeymap_prompt (mapvec
[i
]);
1575 single_keymap_panes (mapvec
[i
],
1576 !NILP (prompt
) ? prompt
: item_name
,
1581 return top_level_items
;
1584 /* Create a tree of widget_value objects
1585 representing the panes and items
1586 in menu_items starting at index START, up to index END. */
1588 static widget_value
*
1589 digest_single_submenu (start
, end
, top_level_items
)
1590 int start
, end
, top_level_items
;
1592 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1594 int submenu_depth
= 0;
1595 widget_value
**submenu_stack
;
1598 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1599 wv
= xmalloc_widget_value ();
1603 wv
->button_type
= BUTTON_TYPE_NONE
;
1609 /* Loop over all panes and items made by the preceding call
1610 to parse_single_submenu and construct a tree of widget_value objects.
1611 Ignore the panes and items used by previous calls to
1612 digest_single_submenu, even though those are also in menu_items. */
1616 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1618 submenu_stack
[submenu_depth
++] = save_wv
;
1623 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1626 save_wv
= submenu_stack
[--submenu_depth
];
1629 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1630 && submenu_depth
!= 0)
1631 i
+= MENU_ITEMS_PANE_LENGTH
;
1632 /* Ignore a nil in the item list.
1633 It's meaningful only for dialog boxes. */
1634 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1636 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1638 /* Create a new pane. */
1639 Lisp_Object pane_name
, prefix
;
1642 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1643 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1645 #ifndef HAVE_MULTILINGUAL_MENU
1646 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1648 pane_name
= ENCODE_SYSTEM (pane_name
);
1649 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1652 pane_string
= (NILP (pane_name
)
1653 ? "" : (char *) SDATA (pane_name
));
1654 /* If there is just one top-level pane, put all its items directly
1655 under the top-level menu. */
1656 if (menu_items_n_panes
== 1)
1659 /* If the pane has a meaningful name,
1660 make the pane a top-level menu item
1661 with its items as a submenu beneath it. */
1662 if (strcmp (pane_string
, ""))
1664 wv
= xmalloc_widget_value ();
1668 first_wv
->contents
= wv
;
1669 wv
->name
= pane_string
;
1670 /* Ignore the @ that means "separate pane".
1671 This is a kludge, but this isn't worth more time. */
1672 if (!NILP (prefix
) && wv
->name
[0] == '@')
1676 wv
->button_type
= BUTTON_TYPE_NONE
;
1681 i
+= MENU_ITEMS_PANE_LENGTH
;
1685 /* Create a new item within current pane. */
1686 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1689 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1690 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1691 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1692 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1693 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1694 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1695 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1697 #ifndef HAVE_MULTILINGUAL_MENU
1698 if (STRING_MULTIBYTE (item_name
))
1700 item_name
= ENCODE_SYSTEM (item_name
);
1701 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1704 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1706 descrip
= ENCODE_SYSTEM (descrip
);
1707 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1709 #endif /* not HAVE_MULTILINGUAL_MENU */
1711 wv
= xmalloc_widget_value ();
1715 save_wv
->contents
= wv
;
1717 wv
->name
= (char *) SDATA (item_name
);
1718 if (!NILP (descrip
))
1719 wv
->key
= (char *) SDATA (descrip
);
1721 /* The EMACS_INT cast avoids a warning. There's no problem
1722 as long as pointers have enough bits to hold small integers. */
1723 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1724 wv
->enabled
= !NILP (enable
);
1727 wv
->button_type
= BUTTON_TYPE_NONE
;
1728 else if (EQ (type
, QCradio
))
1729 wv
->button_type
= BUTTON_TYPE_RADIO
;
1730 else if (EQ (type
, QCtoggle
))
1731 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1735 wv
->selected
= !NILP (selected
);
1736 if (! STRINGP (help
))
1743 i
+= MENU_ITEMS_ITEM_LENGTH
;
1747 /* If we have just one "menu item"
1748 that was originally a button, return it by itself. */
1749 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1751 wv
= first_wv
->contents
;
1752 free_widget_value (first_wv
);
1759 /* Recompute all the widgets of frame F, when the menu bar has been
1760 changed. Value is non-zero if widgets were updated. */
1763 update_frame_menubar (f
)
1767 return xg_update_frame_menubar (f
);
1769 struct x_output
*x
= f
->output_data
.x
;
1772 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1776 /* Save the size of the frame because the pane widget doesn't accept
1777 to resize itself. So force it. */
1778 columns
= FRAME_COLS (f
);
1779 rows
= FRAME_LINES (f
);
1781 /* Do the voodoo which means "I'm changing lots of things, don't try
1782 to refigure sizes until I'm done." */
1783 lw_refigure_widget (x
->column_widget
, False
);
1785 /* The order in which children are managed is the top to bottom
1786 order in which they are displayed in the paned window. First,
1787 remove the text-area widget. */
1788 XtUnmanageChild (x
->edit_widget
);
1790 /* Remove the menubar that is there now, and put up the menubar that
1792 XtManageChild (x
->menubar_widget
);
1793 XtMapWidget (x
->menubar_widget
);
1794 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1796 /* Re-manage the text-area widget, and then thrash the sizes. */
1797 XtManageChild (x
->edit_widget
);
1798 lw_refigure_widget (x
->column_widget
, True
);
1800 /* Force the pane widget to resize itself with the right values. */
1801 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1807 /* Set the contents of the menubar widgets of frame F.
1808 The argument FIRST_TIME is currently ignored;
1809 it is set the first time this is called, from initialize_frame_menubar. */
1812 set_frame_menubar (f
, first_time
, deep_p
)
1817 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1818 #ifdef USE_X_TOOLKIT
1822 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1824 int *submenu_start
, *submenu_end
;
1825 int *submenu_top_level_items
, *submenu_n_panes
;
1828 XSETFRAME (Vmenu_updating_frame
, f
);
1830 #ifdef USE_X_TOOLKIT
1831 if (f
->output_data
.x
->id
== 0)
1832 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1833 id
= f
->output_data
.x
->id
;
1836 if (! menubar_widget
)
1838 else if (pending_menu_activation
&& !deep_p
)
1840 /* Make the first call for any given frame always go deep. */
1841 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1844 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1845 f
->output_data
.x
->saved_menu_event
->type
= 0;
1850 /* Make a widget-value tree representing the entire menu trees. */
1852 struct buffer
*prev
= current_buffer
;
1854 int specpdl_count
= SPECPDL_INDEX ();
1855 int previous_menu_items_used
= f
->menu_bar_items_used
;
1856 Lisp_Object
*previous_items
1857 = (Lisp_Object
*) alloca (previous_menu_items_used
1858 * sizeof (Lisp_Object
));
1860 /* If we are making a new widget, its contents are empty,
1861 do always reinitialize them. */
1862 if (! menubar_widget
)
1863 previous_menu_items_used
= 0;
1865 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1866 specbind (Qinhibit_quit
, Qt
);
1867 /* Don't let the debugger step into this code
1868 because it is not reentrant. */
1869 specbind (Qdebug_on_next_call
, Qnil
);
1871 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1872 record_unwind_protect (unuse_menu_items
, Qnil
);
1873 if (NILP (Voverriding_local_map_menu_flag
))
1875 specbind (Qoverriding_terminal_local_map
, Qnil
);
1876 specbind (Qoverriding_local_map
, Qnil
);
1879 set_buffer_internal_1 (XBUFFER (buffer
));
1881 /* Run the Lucid hook. */
1882 safe_run_hooks (Qactivate_menubar_hook
);
1884 /* If it has changed current-menubar from previous value,
1885 really recompute the menubar from the value. */
1886 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1887 call0 (Qrecompute_lucid_menubar
);
1888 safe_run_hooks (Qmenu_bar_update_hook
);
1889 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1891 items
= FRAME_MENU_BAR_ITEMS (f
);
1893 /* Save the frame's previous menu bar contents data. */
1894 if (previous_menu_items_used
)
1895 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1896 previous_menu_items_used
* sizeof (Lisp_Object
));
1898 /* Fill in menu_items with the current menu bar contents.
1899 This can evaluate Lisp code. */
1900 menu_items
= f
->menu_bar_vector
;
1901 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1902 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1903 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1904 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1905 submenu_top_level_items
1906 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1908 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1910 Lisp_Object key
, string
, maps
;
1914 key
= XVECTOR (items
)->contents
[i
];
1915 string
= XVECTOR (items
)->contents
[i
+ 1];
1916 maps
= XVECTOR (items
)->contents
[i
+ 2];
1920 submenu_start
[i
] = menu_items_used
;
1922 menu_items_n_panes
= 0;
1923 submenu_top_level_items
[i
]
1924 = parse_single_submenu (key
, string
, maps
);
1925 submenu_n_panes
[i
] = menu_items_n_panes
;
1927 submenu_end
[i
] = menu_items_used
;
1930 finish_menu_items ();
1932 /* Convert menu_items into widget_value trees
1933 to display the menu. This cannot evaluate Lisp code. */
1935 wv
= xmalloc_widget_value ();
1936 wv
->name
= "menubar";
1939 wv
->button_type
= BUTTON_TYPE_NONE
;
1943 for (i
= 0; i
< last_i
; i
+= 4)
1945 menu_items_n_panes
= submenu_n_panes
[i
];
1946 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1947 submenu_top_level_items
[i
]);
1951 first_wv
->contents
= wv
;
1952 /* Don't set wv->name here; GC during the loop might relocate it. */
1954 wv
->button_type
= BUTTON_TYPE_NONE
;
1958 set_buffer_internal_1 (prev
);
1959 unbind_to (specpdl_count
, Qnil
);
1961 /* If there has been no change in the Lisp-level contents
1962 of the menu bar, skip redisplaying it. Just exit. */
1964 for (i
= 0; i
< previous_menu_items_used
; i
++)
1965 if (menu_items_used
== i
1966 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1968 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1970 free_menubar_widget_value_tree (first_wv
);
1971 discard_menu_items ();
1976 /* Now GC cannot happen during the lifetime of the widget_value,
1977 so it's safe to store data from a Lisp_String. */
1978 wv
= first_wv
->contents
;
1979 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1982 string
= XVECTOR (items
)->contents
[i
+ 1];
1985 wv
->name
= (char *) SDATA (string
);
1989 f
->menu_bar_vector
= menu_items
;
1990 f
->menu_bar_items_used
= menu_items_used
;
1991 discard_menu_items ();
1995 /* Make a widget-value tree containing
1996 just the top level menu bar strings. */
1998 wv
= xmalloc_widget_value ();
1999 wv
->name
= "menubar";
2002 wv
->button_type
= BUTTON_TYPE_NONE
;
2006 items
= FRAME_MENU_BAR_ITEMS (f
);
2007 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2011 string
= XVECTOR (items
)->contents
[i
+ 1];
2015 wv
= xmalloc_widget_value ();
2016 wv
->name
= (char *) SDATA (string
);
2019 wv
->button_type
= BUTTON_TYPE_NONE
;
2021 /* This prevents lwlib from assuming this
2022 menu item is really supposed to be empty. */
2023 /* The EMACS_INT cast avoids a warning.
2024 This value just has to be different from small integers. */
2025 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2030 first_wv
->contents
= wv
;
2034 /* Forget what we thought we knew about what is in the
2035 detailed contents of the menu bar menus.
2036 Changing the top level always destroys the contents. */
2037 f
->menu_bar_items_used
= 0;
2040 /* Create or update the menu bar widget. */
2045 xg_crazy_callback_abort
= 1;
2048 /* The third arg is DEEP_P, which says to consider the entire
2049 menu trees we supply, rather than just the menu bar item names. */
2050 xg_modify_menubar_widgets (menubar_widget
,
2054 G_CALLBACK (menubar_selection_callback
),
2055 G_CALLBACK (popup_deactivate_callback
),
2056 G_CALLBACK (menu_highlight_callback
));
2060 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2063 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2064 G_CALLBACK (menubar_selection_callback
),
2065 G_CALLBACK (popup_deactivate_callback
),
2066 G_CALLBACK (menu_highlight_callback
));
2068 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2072 #else /* not USE_GTK */
2075 /* Disable resizing (done for Motif!) */
2076 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2078 /* The third arg is DEEP_P, which says to consider the entire
2079 menu trees we supply, rather than just the menu bar item names. */
2080 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2082 /* Re-enable the edit widget to resize. */
2083 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2087 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2088 f
->output_data
.x
->column_widget
,
2090 popup_activate_callback
,
2091 menubar_selection_callback
,
2092 popup_deactivate_callback
,
2093 menu_highlight_callback
);
2094 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2099 = (f
->output_data
.x
->menubar_widget
2100 ? (f
->output_data
.x
->menubar_widget
->core
.height
2101 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2104 #if 0 /* Experimentally, we now get the right results
2105 for -geometry -0-0 without this. 24 Aug 96, rms. */
2107 if (FRAME_EXTERNAL_MENU_BAR (f
))
2110 XtVaGetValues (f
->output_data
.x
->column_widget
,
2111 XtNinternalBorderWidth
, &ibw
, NULL
);
2112 menubar_size
+= ibw
;
2114 #endif /* USE_LUCID */
2117 f
->output_data
.x
->menubar_height
= menubar_size
;
2119 #endif /* not USE_GTK */
2121 free_menubar_widget_value_tree (first_wv
);
2122 update_frame_menubar (f
);
2125 xg_crazy_callback_abort
= 0;
2131 /* Called from Fx_create_frame to create the initial menubar of a frame
2132 before it is mapped, so that the window is mapped with the menubar already
2133 there instead of us tacking it on later and thrashing the window after it
2137 initialize_frame_menubar (f
)
2140 /* This function is called before the first chance to redisplay
2141 the frame. It has to be, so the frame will have the right size. */
2142 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2143 set_frame_menubar (f
, 1, 1);
2147 /* Get rid of the menu bar of frame F, and free its storage.
2148 This is used when deleting a frame, and when turning off the menu bar.
2149 For GTK this function is in gtkutil.c. */
2153 free_frame_menubar (f
)
2156 Widget menubar_widget
;
2158 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2160 f
->output_data
.x
->menubar_height
= 0;
2165 /* Removing the menu bar magically changes the shell widget's x
2166 and y position of (0, 0) which, when the menu bar is turned
2167 on again, leads to pull-down menuss appearing in strange
2168 positions near the upper-left corner of the display. This
2169 happens only with some window managers like twm and ctwm,
2170 but not with other like Motif's mwm or kwm, because the
2171 latter generate ConfigureNotify events when the menu bar
2172 is switched off, which fixes the shell position. */
2173 Position x0
, y0
, x1
, y1
;
2179 if (f
->output_data
.x
->widget
)
2180 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2183 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2184 f
->output_data
.x
->menubar_widget
= NULL
;
2187 if (f
->output_data
.x
->widget
)
2189 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2190 if (x1
== 0 && y1
== 0)
2191 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2198 #endif /* not USE_GTK */
2200 #endif /* USE_X_TOOLKIT || USE_GTK */
2202 /* xmenu_show actually displays a menu using the panes and items in menu_items
2203 and returns the value selected from it.
2204 There are two versions of xmenu_show, one for Xt and one for Xlib.
2205 Both assume input is blocked by the caller. */
2207 /* F is the frame the menu is for.
2208 X and Y are the frame-relative specified position,
2209 relative to the inside upper left corner of the frame F.
2210 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2211 KEYMAPS is 1 if this menu was specified with keymaps;
2212 in that case, we return a list containing the chosen item's value
2213 and perhaps also the pane's prefix.
2214 TITLE is the specified menu title.
2215 ERROR is a place to store an error message string in case of failure.
2216 (We return nil on failure, but the value doesn't actually matter.) */
2218 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2220 /* The item selected in the popup menu. */
2221 static Lisp_Object
*volatile menu_item_selection
;
2225 /* Used when position a popup menu. See menu_position_func and
2226 create_and_show_popup_menu below. */
2227 struct next_popup_x_y
2234 /* The menu position function to use if we are not putting a popup
2235 menu where the pointer is.
2236 MENU is the menu to pop up.
2237 X and Y shall on exit contain x/y where the menu shall pop up.
2238 PUSH_IN is not documented in the GTK manual.
2239 USER_DATA is any data passed in when calling gtk_menu_popup.
2240 Here it points to a struct next_popup_x_y where the coordinates
2241 to store in *X and *Y are as well as the frame for the popup.
2243 Here only X and Y are used. */
2245 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2252 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2254 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2255 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2260 /* Check if there is room for the menu. If not, adjust x/y so that
2261 the menu is fully visible. */
2262 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2263 if (data
->x
+ req
.width
> disp_width
)
2264 *x
-= data
->x
+ req
.width
- disp_width
;
2265 if (data
->y
+ req
.height
> disp_height
)
2266 *y
-= data
->y
+ req
.height
- disp_height
;
2270 popup_selection_callback (widget
, client_data
)
2272 gpointer client_data
;
2274 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2276 if (xg_crazy_callback_abort
) return;
2277 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2280 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2282 menu_item_selection will be set to the selection. */
2284 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2286 widget_value
*first_wv
;
2293 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2294 struct next_popup_x_y popup_x_y
;
2296 xg_crazy_callback_abort
= 1;
2297 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2298 G_CALLBACK (popup_selection_callback
),
2299 G_CALLBACK (popup_deactivate_callback
),
2300 G_CALLBACK (menu_highlight_callback
));
2301 xg_crazy_callback_abort
= 0;
2303 for (i
= 0; i
< 5; i
++)
2304 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2309 /* Not invoked by a click. pop up at x/y. */
2310 pos_func
= menu_position_func
;
2312 /* Adjust coordinates to be root-window-relative. */
2313 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2314 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2321 /* Display the menu. */
2322 gtk_widget_show_all (menu
);
2323 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2326 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2327 two. show_help_echo uses this to detect popup menus. */
2328 popup_activated_flag
= 1;
2329 /* Process events that apply to the menu. */
2330 popup_widget_loop ();
2333 xg_keep_popup (menu
, xg_did_tearoff
);
2335 gtk_widget_destroy (menu
);
2337 /* Must reset this manually because the button release event is not passed
2338 to Emacs event loop. */
2339 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2342 #else /* not USE_GTK */
2344 /* We need a unique id for each widget handled by the Lucid Widget
2347 For the main windows, and popup menus, we use this counter,
2348 which we increment each time after use. This starts from 1<<16.
2350 For menu bars, we use numbers starting at 0, counted in
2351 next_menubar_widget_id. */
2352 LWLIB_ID widget_id_tick
;
2355 popup_selection_callback (widget
, id
, client_data
)
2358 XtPointer client_data
;
2360 menu_item_selection
= (Lisp_Object
*) client_data
;
2363 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2365 menu_item_selection will be set to the selection. */
2367 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2369 widget_value
*first_wv
;
2377 XButtonPressedEvent dummy
;
2382 menu_id
= widget_id_tick
++;
2383 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2384 f
->output_data
.x
->widget
, 1, 0,
2385 popup_selection_callback
,
2386 popup_deactivate_callback
,
2387 menu_highlight_callback
);
2389 dummy
.type
= ButtonPress
;
2391 dummy
.send_event
= 0;
2392 dummy
.display
= FRAME_X_DISPLAY (f
);
2393 dummy
.time
= CurrentTime
;
2394 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2395 dummy
.window
= dummy
.root
;
2396 dummy
.subwindow
= dummy
.root
;
2400 /* Adjust coordinates to be root-window-relative. */
2401 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2402 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2409 for (i
= 0; i
< 5; i
++)
2410 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2413 /* Don't allow any geometry request from the user. */
2414 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2415 XtSetValues (menu
, av
, ac
);
2417 /* Display the menu. */
2418 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2419 popup_activated_flag
= 1;
2421 /* Process events that apply to the menu. */
2422 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 0);
2424 /* fp turned off the following statement and wrote a comment
2425 that it is unnecessary--that the menu has already disappeared.
2426 Nowadays the menu disappears ok, all right, but
2427 we need to delete the widgets or multiple ones will pile up. */
2428 lw_destroy_all_widgets (menu_id
);
2431 #endif /* not USE_GTK */
2434 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2444 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2445 widget_value
**submenu_stack
2446 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2447 Lisp_Object
*subprefix_stack
2448 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2449 int submenu_depth
= 0;
2455 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2457 *error
= "Empty menu";
2461 /* Create a tree of widget_value objects
2462 representing the panes and their items. */
2463 wv
= xmalloc_widget_value ();
2467 wv
->button_type
= BUTTON_TYPE_NONE
;
2472 /* Loop over all panes and items, filling in the tree. */
2474 while (i
< menu_items_used
)
2476 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2478 submenu_stack
[submenu_depth
++] = save_wv
;
2484 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2487 save_wv
= submenu_stack
[--submenu_depth
];
2491 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2492 && submenu_depth
!= 0)
2493 i
+= MENU_ITEMS_PANE_LENGTH
;
2494 /* Ignore a nil in the item list.
2495 It's meaningful only for dialog boxes. */
2496 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2498 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2500 /* Create a new pane. */
2501 Lisp_Object pane_name
, prefix
;
2504 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2505 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2507 #ifndef HAVE_MULTILINGUAL_MENU
2508 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2510 pane_name
= ENCODE_SYSTEM (pane_name
);
2511 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2514 pane_string
= (NILP (pane_name
)
2515 ? "" : (char *) SDATA (pane_name
));
2516 /* If there is just one top-level pane, put all its items directly
2517 under the top-level menu. */
2518 if (menu_items_n_panes
== 1)
2521 /* If the pane has a meaningful name,
2522 make the pane a top-level menu item
2523 with its items as a submenu beneath it. */
2524 if (!keymaps
&& strcmp (pane_string
, ""))
2526 wv
= xmalloc_widget_value ();
2530 first_wv
->contents
= wv
;
2531 wv
->name
= pane_string
;
2532 if (keymaps
&& !NILP (prefix
))
2536 wv
->button_type
= BUTTON_TYPE_NONE
;
2541 else if (first_pane
)
2547 i
+= MENU_ITEMS_PANE_LENGTH
;
2551 /* Create a new item within current pane. */
2552 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2553 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2554 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2555 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2556 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2557 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2558 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2559 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2561 #ifndef HAVE_MULTILINGUAL_MENU
2562 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2564 item_name
= ENCODE_SYSTEM (item_name
);
2565 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2568 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2570 descrip
= ENCODE_SYSTEM (descrip
);
2571 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2573 #endif /* not HAVE_MULTILINGUAL_MENU */
2575 wv
= xmalloc_widget_value ();
2579 save_wv
->contents
= wv
;
2580 wv
->name
= (char *) SDATA (item_name
);
2581 if (!NILP (descrip
))
2582 wv
->key
= (char *) SDATA (descrip
);
2584 /* If this item has a null value,
2585 make the call_data null so that it won't display a box
2586 when the mouse is on it. */
2588 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2589 wv
->enabled
= !NILP (enable
);
2592 wv
->button_type
= BUTTON_TYPE_NONE
;
2593 else if (EQ (type
, QCtoggle
))
2594 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2595 else if (EQ (type
, QCradio
))
2596 wv
->button_type
= BUTTON_TYPE_RADIO
;
2600 wv
->selected
= !NILP (selected
);
2602 if (! STRINGP (help
))
2609 i
+= MENU_ITEMS_ITEM_LENGTH
;
2613 /* Deal with the title, if it is non-nil. */
2616 widget_value
*wv_title
= xmalloc_widget_value ();
2617 widget_value
*wv_sep1
= xmalloc_widget_value ();
2618 widget_value
*wv_sep2
= xmalloc_widget_value ();
2620 wv_sep2
->name
= "--";
2621 wv_sep2
->next
= first_wv
->contents
;
2622 wv_sep2
->help
= Qnil
;
2624 wv_sep1
->name
= "--";
2625 wv_sep1
->next
= wv_sep2
;
2626 wv_sep1
->help
= Qnil
;
2628 #ifndef HAVE_MULTILINGUAL_MENU
2629 if (STRING_MULTIBYTE (title
))
2630 title
= ENCODE_SYSTEM (title
);
2633 wv_title
->name
= (char *) SDATA (title
);
2634 wv_title
->enabled
= TRUE
;
2635 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2636 wv_title
->next
= wv_sep1
;
2637 wv_title
->help
= Qnil
;
2638 first_wv
->contents
= wv_title
;
2641 /* No selection has been chosen yet. */
2642 menu_item_selection
= 0;
2644 /* Actually create and show the menu until popped down. */
2645 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2647 /* Free the widget_value objects we used to specify the contents. */
2648 free_menubar_widget_value_tree (first_wv
);
2650 /* Find the selected item, and its pane, to return
2651 the proper value. */
2652 if (menu_item_selection
!= 0)
2654 Lisp_Object prefix
, entry
;
2656 prefix
= entry
= Qnil
;
2658 while (i
< menu_items_used
)
2660 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2662 subprefix_stack
[submenu_depth
++] = prefix
;
2666 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2668 prefix
= subprefix_stack
[--submenu_depth
];
2671 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2674 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2675 i
+= MENU_ITEMS_PANE_LENGTH
;
2677 /* Ignore a nil in the item list.
2678 It's meaningful only for dialog boxes. */
2679 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2684 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2685 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2691 entry
= Fcons (entry
, Qnil
);
2693 entry
= Fcons (prefix
, entry
);
2694 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2695 if (!NILP (subprefix_stack
[j
]))
2696 entry
= Fcons (subprefix_stack
[j
], entry
);
2700 i
+= MENU_ITEMS_ITEM_LENGTH
;
2710 dialog_selection_callback (widget
, client_data
)
2712 gpointer client_data
;
2714 /* The EMACS_INT cast avoids a warning. There's no problem
2715 as long as pointers have enough bits to hold small integers. */
2716 if ((int) (EMACS_INT
) client_data
!= -1)
2717 menu_item_selection
= (Lisp_Object
*) client_data
;
2719 popup_activated_flag
= 0;
2722 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2724 menu_item_selection will be set to the selection. */
2726 create_and_show_dialog (f
, first_wv
)
2728 widget_value
*first_wv
;
2732 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2733 G_CALLBACK (dialog_selection_callback
),
2734 G_CALLBACK (popup_deactivate_callback
),
2739 /* Display the menu. */
2740 gtk_widget_show_all (menu
);
2742 /* Process events that apply to the menu. */
2743 popup_widget_loop ();
2745 gtk_widget_destroy (menu
);
2749 #else /* not USE_GTK */
2751 dialog_selection_callback (widget
, id
, client_data
)
2754 XtPointer client_data
;
2756 /* The EMACS_INT cast avoids a warning. There's no problem
2757 as long as pointers have enough bits to hold small integers. */
2758 if ((int) (EMACS_INT
) client_data
!= -1)
2759 menu_item_selection
= (Lisp_Object
*) client_data
;
2762 lw_destroy_all_widgets (id
);
2764 popup_activated_flag
= 0;
2768 /* ARG is the LWLIB ID of the dialog box, represented
2769 as a Lisp object as (HIGHPART . LOWPART). */
2772 xdialog_show_unwind (arg
)
2775 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2776 | XINT (XCDR (arg
)));
2778 lw_destroy_all_widgets (id
);
2780 popup_activated_flag
= 0;
2785 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2787 menu_item_selection will be set to the selection. */
2789 create_and_show_dialog (f
, first_wv
)
2791 widget_value
*first_wv
;
2795 dialog_id
= widget_id_tick
++;
2796 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2797 f
->output_data
.x
->widget
, 1, 0,
2798 dialog_selection_callback
, 0, 0);
2799 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2801 /* Display the dialog box. */
2802 lw_pop_up_all_widgets (dialog_id
);
2803 popup_activated_flag
= 1;
2805 /* Process events that apply to the dialog box.
2806 Also handle timers. */
2808 int count
= SPECPDL_INDEX ();
2809 int fact
= 4 * sizeof (LWLIB_ID
);
2811 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2812 record_unwind_protect (xdialog_show_unwind
,
2813 Fcons (make_number (dialog_id
>> (fact
)),
2814 make_number (dialog_id
& ~(-1 << (fact
)))));
2816 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
, 1);
2818 unbind_to (count
, Qnil
);
2822 #endif /* not USE_GTK */
2824 static char * button_names
[] = {
2825 "button1", "button2", "button3", "button4", "button5",
2826 "button6", "button7", "button8", "button9", "button10" };
2829 xdialog_show (f
, keymaps
, title
, error
)
2835 int i
, nb_buttons
=0;
2836 char dialog_name
[6];
2838 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2840 /* Number of elements seen so far, before boundary. */
2842 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2843 int boundary_seen
= 0;
2847 if (menu_items_n_panes
> 1)
2849 *error
= "Multiple panes in dialog box";
2853 /* Create a tree of widget_value objects
2854 representing the text label and buttons. */
2856 Lisp_Object pane_name
, prefix
;
2858 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2859 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2860 pane_string
= (NILP (pane_name
)
2861 ? "" : (char *) SDATA (pane_name
));
2862 prev_wv
= xmalloc_widget_value ();
2863 prev_wv
->value
= pane_string
;
2864 if (keymaps
&& !NILP (prefix
))
2866 prev_wv
->enabled
= 1;
2867 prev_wv
->name
= "message";
2868 prev_wv
->help
= Qnil
;
2871 /* Loop over all panes and items, filling in the tree. */
2872 i
= MENU_ITEMS_PANE_LENGTH
;
2873 while (i
< menu_items_used
)
2876 /* Create a new item within current pane. */
2877 Lisp_Object item_name
, enable
, descrip
;
2878 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2879 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2881 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2883 if (NILP (item_name
))
2885 free_menubar_widget_value_tree (first_wv
);
2886 *error
= "Submenu in dialog items";
2889 if (EQ (item_name
, Qquote
))
2891 /* This is the boundary between left-side elts
2892 and right-side elts. Stop incrementing right_count. */
2897 if (nb_buttons
>= 9)
2899 free_menubar_widget_value_tree (first_wv
);
2900 *error
= "Too many dialog items";
2904 wv
= xmalloc_widget_value ();
2906 wv
->name
= (char *) button_names
[nb_buttons
];
2907 if (!NILP (descrip
))
2908 wv
->key
= (char *) SDATA (descrip
);
2909 wv
->value
= (char *) SDATA (item_name
);
2910 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2911 wv
->enabled
= !NILP (enable
);
2915 if (! boundary_seen
)
2919 i
+= MENU_ITEMS_ITEM_LENGTH
;
2922 /* If the boundary was not specified,
2923 by default put half on the left and half on the right. */
2924 if (! boundary_seen
)
2925 left_count
= nb_buttons
- nb_buttons
/ 2;
2927 wv
= xmalloc_widget_value ();
2928 wv
->name
= dialog_name
;
2930 /* Dialog boxes use a really stupid name encoding
2931 which specifies how many buttons to use
2932 and how many buttons are on the right.
2933 The Q means something also. */
2934 dialog_name
[0] = 'Q';
2935 dialog_name
[1] = '0' + nb_buttons
;
2936 dialog_name
[2] = 'B';
2937 dialog_name
[3] = 'R';
2938 /* Number of buttons to put on the right. */
2939 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2941 wv
->contents
= first_wv
;
2945 /* No selection has been chosen yet. */
2946 menu_item_selection
= 0;
2948 /* Actually create and show the dialog. */
2949 create_and_show_dialog (f
, first_wv
);
2951 /* Free the widget_value objects we used to specify the contents. */
2952 free_menubar_widget_value_tree (first_wv
);
2954 /* Find the selected item, and its pane, to return
2955 the proper value. */
2956 if (menu_item_selection
!= 0)
2962 while (i
< menu_items_used
)
2966 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2969 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2970 i
+= MENU_ITEMS_PANE_LENGTH
;
2972 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2974 /* This is the boundary between left-side elts and
2981 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2982 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2986 entry
= Fcons (entry
, Qnil
);
2988 entry
= Fcons (prefix
, entry
);
2992 i
+= MENU_ITEMS_ITEM_LENGTH
;
3000 #else /* not USE_X_TOOLKIT && not USE_GTK */
3002 /* The frame of the last activated non-toolkit menu bar.
3003 Used to generate menu help events. */
3005 static struct frame
*menu_help_frame
;
3008 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3010 PANE is the pane number, and ITEM is the menu item number in
3011 the menu (currently not used).
3013 This cannot be done with generating a HELP_EVENT because
3014 XMenuActivate contains a loop that doesn't let Emacs process
3018 menu_help_callback (help_string
, pane
, item
)
3022 extern Lisp_Object Qmenu_item
;
3023 Lisp_Object
*first_item
;
3024 Lisp_Object pane_name
;
3025 Lisp_Object menu_object
;
3027 first_item
= XVECTOR (menu_items
)->contents
;
3028 if (EQ (first_item
[0], Qt
))
3029 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3030 else if (EQ (first_item
[0], Qquote
))
3031 /* This shouldn't happen, see xmenu_show. */
3032 pane_name
= empty_string
;
3034 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3036 /* (menu-item MENU-NAME PANE-NUMBER) */
3037 menu_object
= Fcons (Qmenu_item
,
3039 Fcons (make_number (pane
), Qnil
)));
3040 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3041 Qnil
, menu_object
, make_number (item
), 1);
3046 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3056 int pane
, selidx
, lpane
, status
;
3057 Lisp_Object entry
, pane_prefix
;
3059 int ulx
, uly
, width
, height
;
3060 int dispwidth
, dispheight
;
3064 unsigned int dummy_uint
;
3067 if (menu_items_n_panes
== 0)
3070 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3072 *error
= "Empty menu";
3076 /* Figure out which root window F is on. */
3077 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3078 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3079 &dummy_uint
, &dummy_uint
);
3081 /* Make the menu on that window. */
3082 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3085 *error
= "Can't create menu";
3089 #ifdef HAVE_X_WINDOWS
3090 /* Adjust coordinates to relative to the outer (window manager) window. */
3093 int win_x
= 0, win_y
= 0;
3095 /* Find the position of the outside upper-left corner of
3096 the inner window, with respect to the outer window. */
3097 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
3100 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3102 /* From-window, to-window. */
3103 f
->output_data
.x
->window_desc
,
3104 f
->output_data
.x
->parent_desc
,
3106 /* From-position, to-position. */
3107 0, 0, &win_x
, &win_y
,
3109 /* Child of window. */
3116 #endif /* HAVE_X_WINDOWS */
3118 /* Adjust coordinates to be root-window-relative. */
3122 /* Create all the necessary panes and their items. */
3124 while (i
< menu_items_used
)
3126 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3128 /* Create a new pane. */
3129 Lisp_Object pane_name
, prefix
;
3132 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3133 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3134 pane_string
= (NILP (pane_name
)
3135 ? "" : (char *) SDATA (pane_name
));
3136 if (keymaps
&& !NILP (prefix
))
3139 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3140 if (lpane
== XM_FAILURE
)
3142 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3143 *error
= "Can't create pane";
3146 i
+= MENU_ITEMS_PANE_LENGTH
;
3148 /* Find the width of the widest item in this pane. */
3151 while (j
< menu_items_used
)
3154 item
= XVECTOR (menu_items
)->contents
[j
];
3162 width
= SBYTES (item
);
3163 if (width
> maxwidth
)
3166 j
+= MENU_ITEMS_ITEM_LENGTH
;
3169 /* Ignore a nil in the item list.
3170 It's meaningful only for dialog boxes. */
3171 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3175 /* Create a new item within current pane. */
3176 Lisp_Object item_name
, enable
, descrip
, help
;
3177 unsigned char *item_data
;
3180 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3181 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3183 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3184 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3185 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3187 if (!NILP (descrip
))
3189 int gap
= maxwidth
- SBYTES (item_name
);
3192 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3193 item_name
= concat2 (item_name
, spacer
);
3194 item_name
= concat2 (item_name
, descrip
);
3195 item_data
= SDATA (item_name
);
3197 /* if alloca is fast, use that to make the space,
3198 to reduce gc needs. */
3200 = (unsigned char *) alloca (maxwidth
3201 + SBYTES (descrip
) + 1);
3202 bcopy (SDATA (item_name
), item_data
,
3203 SBYTES (item_name
));
3204 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3206 bcopy (SDATA (descrip
), item_data
+ j
,
3208 item_data
[j
+ SBYTES (descrip
)] = 0;
3212 item_data
= SDATA (item_name
);
3214 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3215 menu
, lpane
, 0, item_data
,
3216 !NILP (enable
), help_string
)
3219 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3220 *error
= "Can't add selection to menu";
3223 i
+= MENU_ITEMS_ITEM_LENGTH
;
3227 /* All set and ready to fly. */
3228 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3229 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3230 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3231 x
= min (x
, dispwidth
);
3232 y
= min (y
, dispheight
);
3235 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3236 &ulx
, &uly
, &width
, &height
);
3237 if (ulx
+width
> dispwidth
)
3239 x
-= (ulx
+ width
) - dispwidth
;
3240 ulx
= dispwidth
- width
;
3242 if (uly
+height
> dispheight
)
3244 y
-= (uly
+ height
) - dispheight
;
3245 uly
= dispheight
- height
;
3247 if (ulx
< 0) x
-= ulx
;
3248 if (uly
< 0) y
-= uly
;
3250 XMenuSetAEQ (menu
, TRUE
);
3251 XMenuSetFreeze (menu
, TRUE
);
3254 /* Help display under X won't work because XMenuActivate contains
3255 a loop that doesn't give Emacs a chance to process it. */
3256 menu_help_frame
= f
;
3257 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3258 x
, y
, ButtonReleaseMask
, &datap
,
3259 menu_help_callback
);
3262 #ifdef HAVE_X_WINDOWS
3263 /* Assume the mouse has moved out of the X window.
3264 If it has actually moved in, we will get an EnterNotify. */
3265 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3272 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3275 /* Find the item number SELIDX in pane number PANE. */
3277 while (i
< menu_items_used
)
3279 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3283 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3285 i
+= MENU_ITEMS_PANE_LENGTH
;
3294 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3297 entry
= Fcons (entry
, Qnil
);
3298 if (!NILP (pane_prefix
))
3299 entry
= Fcons (pane_prefix
, entry
);
3305 i
+= MENU_ITEMS_ITEM_LENGTH
;
3311 *error
= "Can't activate menu";
3317 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3319 #ifdef HAVE_X_WINDOWS
3320 /* State that no mouse buttons are now held.
3321 (The oldXMenu code doesn't track this info for us.)
3322 That is not necessarily true, but the fiction leads to reasonable
3323 results, and it is a pain to ask which are actually held now. */
3324 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3330 #endif /* not USE_X_TOOLKIT */
3332 #endif /* HAVE_MENUS */
3337 staticpro (&menu_items
);
3339 menu_items_inuse
= Qnil
;
3341 Qdebug_on_next_call
= intern ("debug-on-next-call");
3342 staticpro (&Qdebug_on_next_call
);
3344 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3345 doc
: /* Frame for which we are updating a menu.
3346 The enable predicate for a menu command should check this variable. */);
3347 Vmenu_updating_frame
= Qnil
;
3349 #ifdef USE_X_TOOLKIT
3350 widget_id_tick
= (1<<16);
3351 next_menubar_widget_id
= 1;
3354 defsubr (&Sx_popup_menu
);
3356 defsubr (&Sx_popup_dialog
);