1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 88, 93, 94, 96, 99, 2000, 2001
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
)
493 Lisp_Object key
, item
, dummy
;
496 Lisp_Object map
, item_string
, enabled
;
497 struct gcpro gcpro1
, gcpro2
;
500 /* Parse the menu item and leave the result in item_properties. */
502 res
= parse_menu_item (item
, skp
->notreal
, 0);
505 return; /* Not a menu item. */
507 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
511 /* We don't want to make a menu, just traverse the keymaps to
512 precompute equivalent key bindings. */
514 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
518 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
519 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
521 if (!NILP (map
) && SREF (item_string
, 0) == '@')
524 /* An enabled separate pane. Remember this to handle it later. */
525 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
531 /* Simulate radio buttons and toggle boxes by putting a prefix in
534 Lisp_Object prefix
= Qnil
;
535 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
539 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
542 /* The first button. Line up previous items in this menu. */
544 int index
= skp
->notbuttons
; /* Index for first item this menu. */
547 while (index
< menu_items_used
)
550 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
554 submenu
++; /* Skip sub menu. */
556 else if (EQ (tem
, Qlambda
))
559 submenu
--; /* End sub menu. */
561 else if (EQ (tem
, Qt
))
562 index
+= 3; /* Skip new pane marker. */
563 else if (EQ (tem
, Qquote
))
564 index
++; /* Skip a left, right divider. */
567 if (!submenu
&& SREF (tem
, 0) != '\0'
568 && SREF (tem
, 0) != '-')
569 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
570 = concat2 (build_string (" "), tem
);
571 index
+= MENU_ITEMS_ITEM_LENGTH
;
577 /* Calculate prefix, if any, for this item. */
578 if (EQ (type
, QCtoggle
))
579 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
580 else if (EQ (type
, QCradio
))
581 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
583 /* Not a button. If we have earlier buttons, then we need a prefix. */
584 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
585 && SREF (item_string
, 0) != '-')
586 prefix
= build_string (" ");
589 item_string
= concat2 (prefix
, item_string
);
591 #endif /* not HAVE_BOXES */
593 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
595 /* Indicate visually that this is a submenu. */
596 item_string
= concat2 (item_string
, build_string (" >"));
599 push_menu_item (item_string
, enabled
, key
,
600 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
601 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
602 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
603 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
604 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
606 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
607 /* Display a submenu using the toolkit. */
608 if (! (NILP (map
) || NILP (enabled
)))
610 push_submenu_start ();
611 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
617 /* Push all the panes and items of a menu described by the
618 alist-of-alists MENU.
619 This handles old-fashioned calls to x-popup-menu. */
629 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
631 Lisp_Object elt
, pane_name
, pane_data
;
633 pane_name
= Fcar (elt
);
634 CHECK_STRING (pane_name
);
635 push_menu_pane (pane_name
, Qnil
);
636 pane_data
= Fcdr (elt
);
637 CHECK_CONS (pane_data
);
638 list_of_items (pane_data
);
641 finish_menu_items ();
644 /* Push the items in a single pane defined by the alist PANE. */
650 Lisp_Object tail
, item
, item1
;
652 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
656 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
657 else if (NILP (item
))
658 push_left_right_boundary ();
663 CHECK_STRING (item1
);
664 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
669 #ifdef HAVE_X_WINDOWS
670 /* Return the mouse position in *X and *Y. The coordinates are window
671 relative for the edit window in frame F.
672 This is for Fx_popup_menu. The mouse_position_hook can not
673 be used for X, as it returns window relative coordinates
674 for the window where the mouse is in. This could be the menu bar,
675 the scroll bar or the edit window. Fx_popup_menu needs to be
676 sure it is the edit window. */
678 mouse_position_for_popup(f
, x
, y
)
683 Window root
, dummy_window
;
688 XQueryPointer (FRAME_X_DISPLAY (f
),
689 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
691 /* The root window which contains the pointer. */
694 /* Window pointer is on, not used */
697 /* The position on that root window. */
700 /* x/y in dummy_window coordinates, not used. */
703 /* Modifier keys and pointer buttons, about which
705 (unsigned int *) &dummy
);
709 /* xmenu_show expects window coordinates, not root window
710 coordinates. Translate. */
711 *x
-= f
->output_data
.x
->left_pos
712 + FRAME_OUTER_TO_INNER_DIFF_X (f
);
713 *y
-= f
->output_data
.x
->top_pos
714 + FRAME_OUTER_TO_INNER_DIFF_Y (f
);
717 #endif /* HAVE_X_WINDOWS */
719 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
720 doc
: /* Pop up a deck-of-cards menu and return user's selection.
721 POSITION is a position specification. This is either a mouse button event
722 or a list ((XOFFSET YOFFSET) WINDOW)
723 where XOFFSET and YOFFSET are positions in pixels from the top left
724 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)
725 This controls the position of the center of the first line
726 in the first pane of the menu, not the top left of the menu as a whole.
727 If POSITION is t, it means to use the current mouse position.
729 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
730 The menu items come from key bindings that have a menu string as well as
731 a definition; actually, the "definition" in such a key binding looks like
732 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
733 the keymap as a top-level element.
735 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
736 Otherwise, REAL-DEFINITION should be a valid key binding definition.
738 You can also use a list of keymaps as MENU.
739 Then each keymap makes a separate pane.
740 When MENU is a keymap or a list of keymaps, the return value
743 Alternatively, you can specify a menu of multiple panes
744 with a list of the form (TITLE PANE1 PANE2...),
745 where each pane is a list of form (TITLE ITEM1 ITEM2...).
746 Each ITEM is normally a cons cell (STRING . VALUE);
747 but a string can appear as an item--that makes a nonselectable line
749 With this form of menu, the return value is VALUE from the chosen item.
751 If POSITION is nil, don't display the menu at all, just precalculate the
752 cached information about equivalent key sequences. */)
754 Lisp_Object position
, menu
;
756 Lisp_Object keymap
, tem
;
757 int xpos
= 0, ypos
= 0;
760 Lisp_Object selection
;
762 Lisp_Object x
, y
, window
;
765 int specpdl_count
= SPECPDL_INDEX ();
769 if (! NILP (position
))
771 int get_current_pos_p
= 0;
774 /* Decode the first argument: find the window and the coordinates. */
775 if (EQ (position
, Qt
)
776 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
777 || EQ (XCAR (position
), Qtool_bar
))))
779 get_current_pos_p
= 1;
783 tem
= Fcar (position
);
786 window
= Fcar (Fcdr (position
));
788 y
= Fcar (Fcdr (tem
));
793 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
794 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
795 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
800 /* If a click happens in an external tool bar or a detached
801 tool bar, x and y is NIL. In that case, use the current
802 mouse position. This happens for the help button in the
803 tool bar. Ideally popup-menu should pass NIL to
804 this function, but it doesn't. */
805 if (NILP (x
) && NILP (y
))
806 get_current_pos_p
= 1;
809 if (get_current_pos_p
)
811 /* Use the mouse's current position. */
812 FRAME_PTR new_f
= SELECTED_FRAME ();
813 #ifdef HAVE_X_WINDOWS
814 /* Can't use mouse_position_hook for X since it returns
815 coordinates relative to the window the mouse is in,
816 we need coordinates relative to the edit widget always. */
821 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
822 /* cur_x/y may be negative, so use make_number. */
823 x
= make_number (cur_x
);
824 y
= make_number (cur_y
);
827 #else /* not HAVE_X_WINDOWS */
828 Lisp_Object bar_window
;
829 enum scroll_bar_part part
;
832 if (mouse_position_hook
)
833 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
834 &part
, &x
, &y
, &time
);
835 #endif /* not HAVE_X_WINDOWS */
838 XSETFRAME (window
, new_f
);
841 window
= selected_window
;
850 /* Decode where to put the menu. */
858 else if (WINDOWP (window
))
860 CHECK_LIVE_WINDOW (window
);
861 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
863 xpos
= (FONT_WIDTH (FRAME_FONT (f
))
864 * XFASTINT (XWINDOW (window
)->left
));
865 ypos
= (FRAME_LINE_HEIGHT (f
)
866 * XFASTINT (XWINDOW (window
)->top
));
869 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
870 but I don't want to make one now. */
871 CHECK_WINDOW (window
);
876 Vmenu_updating_frame
= Qnil
;
877 #endif /* HAVE_MENUS */
879 record_unwind_protect (unuse_menu_items
, Qnil
);
883 /* Decode the menu items from what was specified. */
885 keymap
= get_keymap (menu
, 0, 0);
888 /* We were given a keymap. Extract menu info from the keymap. */
891 /* Extract the detailed info to make one pane. */
892 keymap_panes (&menu
, 1, NILP (position
));
894 /* Search for a string appearing directly as an element of the keymap.
895 That string is the title of the menu. */
896 prompt
= Fkeymap_prompt (keymap
);
897 if (NILP (title
) && !NILP (prompt
))
900 /* Make that be the pane title of the first pane. */
901 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
902 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
906 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
908 /* We were given a list of keymaps. */
909 int nmaps
= XFASTINT (Flength (menu
));
911 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
916 /* The first keymap that has a prompt string
917 supplies the menu title. */
918 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
922 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
924 prompt
= Fkeymap_prompt (keymap
);
925 if (NILP (title
) && !NILP (prompt
))
929 /* Extract the detailed info to make one pane. */
930 keymap_panes (maps
, nmaps
, NILP (position
));
932 /* Make the title be the pane title of the first pane. */
933 if (!NILP (title
) && menu_items_n_panes
>= 0)
934 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
940 /* We were given an old-fashioned menu. */
942 CHECK_STRING (title
);
944 list_of_panes (Fcdr (menu
));
949 unbind_to (specpdl_count
, Qnil
);
953 discard_menu_items ();
959 /* Display them in a menu. */
962 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
963 keymaps
, title
, &error_name
);
966 discard_menu_items ();
969 #endif /* HAVE_MENUS */
971 if (error_name
) error (error_name
);
977 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
978 doc
: /* Pop up a dialog box and return user's selection.
979 POSITION specifies which frame to use.
980 This is normally a mouse button event or a window or frame.
981 If POSITION is t, it means to use the frame the mouse is on.
982 The dialog box appears in the middle of the specified frame.
984 CONTENTS specifies the alternatives to display in the dialog box.
985 It is a list of the form (TITLE ITEM1 ITEM2...).
986 Each ITEM is a cons cell (STRING . VALUE).
987 The return value is VALUE from the chosen item.
989 An ITEM may also be just a string--that makes a nonselectable item.
990 An ITEM may also be nil--that means to put all preceding items
991 on the left of the dialog box and all following items on the right.
992 \(By default, approximately half appear on each side.) */)
994 Lisp_Object position
, contents
;
1001 /* Decode the first argument: find the window or frame to use. */
1002 if (EQ (position
, Qt
)
1003 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1004 || EQ (XCAR (position
), Qtool_bar
))))
1006 #if 0 /* Using the frame the mouse is on may not be right. */
1007 /* Use the mouse's current position. */
1008 FRAME_PTR new_f
= SELECTED_FRAME ();
1009 Lisp_Object bar_window
;
1010 enum scroll_bar_part part
;
1014 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1017 XSETFRAME (window
, new_f
);
1019 window
= selected_window
;
1021 window
= selected_window
;
1023 else if (CONSP (position
))
1026 tem
= Fcar (position
);
1028 window
= Fcar (Fcdr (position
));
1031 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1032 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1035 else if (WINDOWP (position
) || FRAMEP (position
))
1040 /* Decode where to put the menu. */
1042 if (FRAMEP (window
))
1043 f
= XFRAME (window
);
1044 else if (WINDOWP (window
))
1046 CHECK_LIVE_WINDOW (window
);
1047 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1050 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1051 but I don't want to make one now. */
1052 CHECK_WINDOW (window
);
1054 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1055 /* Display a menu with these alternatives
1056 in the middle of frame F. */
1058 Lisp_Object x
, y
, frame
, newpos
;
1059 XSETFRAME (frame
, f
);
1060 XSETINT (x
, x_pixel_width (f
) / 2);
1061 XSETINT (y
, x_pixel_height (f
) / 2);
1062 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1064 return Fx_popup_menu (newpos
,
1065 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1071 Lisp_Object selection
;
1072 int specpdl_count
= SPECPDL_INDEX ();
1074 /* Decode the dialog items from what was specified. */
1075 title
= Fcar (contents
);
1076 CHECK_STRING (title
);
1077 record_unwind_protect (unuse_menu_items
, Qnil
);
1079 list_of_panes (Fcons (contents
, Qnil
));
1081 /* Display them in a dialog box. */
1083 selection
= xdialog_show (f
, 0, title
, &error_name
);
1086 unbind_to (specpdl_count
, Qnil
);
1087 discard_menu_items ();
1089 if (error_name
) error (error_name
);
1095 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1097 /* Loop in Xt until the menu pulldown or dialog popup has been
1098 popped down (deactivated). This is used for x-popup-menu
1099 and x-popup-dialog; it is not used for the menu bar.
1101 If DO_TIMERS is nonzero, run timers.
1103 NOTE: All calls to popup_get_selection should be protected
1104 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1106 #ifdef USE_X_TOOLKIT
1108 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1109 XEvent
*initial_event
;
1110 struct x_display_info
*dpyinfo
;
1116 while (popup_activated_flag
)
1118 /* If we have no events to run, consider timers. */
1119 if (do_timers
&& !XtAppPending (Xt_app_con
))
1124 event
= *initial_event
;
1128 XtAppNextEvent (Xt_app_con
, &event
);
1130 /* Make sure we don't consider buttons grabbed after menu goes.
1131 And make sure to deactivate for any ButtonRelease,
1132 even if XtDispatchEvent doesn't do that. */
1133 if (event
.type
== ButtonRelease
1134 && dpyinfo
->display
== event
.xbutton
.display
)
1136 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1137 #ifdef USE_MOTIF /* Pretending that the event came from a
1138 Btn1Down seems the only way to convince Motif to
1139 activate its callbacks; setting the XmNmenuPost
1140 isn't working. --marcus@sysc.pdx.edu. */
1141 event
.xbutton
.button
= 1;
1142 /* Motif only pops down menus when no Ctrl, Alt or Mod
1143 key is pressed and the button is released. So reset key state
1144 so Motif thinks this is the case. */
1145 event
.xbutton
.state
= 0;
1148 /* If the user presses a key, deactivate the menu.
1149 The user is likely to do that if we get wedged.
1150 This is mostly for Lucid, Motif pops down the menu on ESC. */
1151 else if (event
.type
== KeyPress
1152 && dpyinfo
->display
== event
.xbutton
.display
)
1154 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1155 if (!IsModifierKey (keysym
))
1156 popup_activated_flag
= 0;
1159 x_dispatch_event (&event
, event
.xany
.display
);
1163 #endif /* USE_X_TOOLKIT */
1166 /* Loop util popup_activated_flag is set to zero in a callback.
1167 Used for popup menus and dialogs. */
1169 popup_widget_loop ()
1171 ++popup_activated_flag
;
1173 /* Process events in the Gtk event loop until done. */
1174 while (popup_activated_flag
)
1176 gtk_main_iteration ();
1181 /* Activate the menu bar of frame F.
1182 This is called from keyboard.c when it gets the
1183 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1185 To activate the menu bar, we use the X button-press event
1186 that was saved in saved_menu_event.
1187 That makes the toolkit do its thing.
1189 But first we recompute the menu bar contents (the whole tree).
1191 The reason for saving the button event until here, instead of
1192 passing it to the toolkit right away, is that we can safely
1193 execute Lisp code. */
1196 x_activate_menubar (f
)
1199 if (!f
->output_data
.x
->saved_menu_event
->type
)
1203 if (! xg_win_to_widget (f
->output_data
.x
->saved_menu_event
->xany
.window
))
1207 set_frame_menubar (f
, 0, 1);
1210 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1211 f
->output_data
.x
->saved_menu_event
);
1212 popup_activated_flag
= 1;
1214 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1218 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1219 pending_menu_activation
= 1;
1222 /* Ignore this if we get it a second time. */
1223 f
->output_data
.x
->saved_menu_event
->type
= 0;
1226 /* Detect if a dialog or menu has been posted. */
1231 return popup_activated_flag
;
1234 /* This callback is invoked when the user selects a menubar cascade
1235 pushbutton, but before the pulldown menu is posted. */
1239 popup_activate_callback (widget
, id
, client_data
)
1242 XtPointer client_data
;
1244 popup_activated_flag
= 1;
1248 /* This callback is invoked when a dialog or menu is finished being
1249 used and has been unposted. */
1253 popup_deactivate_callback (widget
, client_data
)
1255 gpointer client_data
;
1257 popup_activated_flag
= 0;
1261 popup_deactivate_callback (widget
, id
, client_data
)
1264 XtPointer client_data
;
1266 popup_activated_flag
= 0;
1271 /* Function that finds the frame for WIDGET and shows the HELP text
1273 F is the frame if known, or NULL if not known. */
1275 show_help_event (f
, widget
, help
)
1277 xt_or_gtk_widget widget
;
1284 XSETFRAME (frame
, f
);
1285 kbd_buffer_store_help_event (frame
, help
);
1289 /* WIDGET is the popup menu. It's parent is the frame's
1290 widget. See which frame that is. */
1291 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1294 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1296 frame
= XCAR (tail
);
1297 if (GC_FRAMEP (frame
)
1298 && (f
= XFRAME (frame
),
1299 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1303 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1307 /* Callback called when menu items are highlighted/unhighlighted
1308 while moving the mouse over them. WIDGET is the menu bar or menu
1309 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1310 the data structure for the menu item, or null in case of
1315 menu_highlight_callback (widget
, call_data
)
1319 xg_menu_item_cb_data
*cb_data
;
1322 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1324 if (! cb_data
) return;
1326 help
= call_data
? cb_data
->help
: Qnil
;
1328 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1329 Don't show help for them, they won't appear before the
1330 popup is popped down. */
1331 if (popup_activated_flag
<= 1)
1332 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1336 menu_highlight_callback (widget
, id
, call_data
)
1344 widget_value
*wv
= (widget_value
*) call_data
;
1346 help
= wv
? wv
->help
: Qnil
;
1348 /* Determine the frame for the help event. */
1349 f
= menubar_id_to_frame (id
);
1351 show_help_event (f
, widget
, help
);
1355 /* Find the menu selection and store it in the keyboard buffer.
1356 F is the frame the menu is on.
1357 MENU_BAR_ITEMS_USED is the length of VECTOR.
1358 VECTOR is an array of menu events for the whole menu.
1361 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1363 int menu_bar_items_used
;
1367 Lisp_Object prefix
, entry
;
1368 Lisp_Object
*subprefix_stack
;
1369 int submenu_depth
= 0;
1373 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1377 while (i
< menu_bar_items_used
)
1379 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1381 subprefix_stack
[submenu_depth
++] = prefix
;
1385 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1387 prefix
= subprefix_stack
[--submenu_depth
];
1390 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1392 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1393 i
+= MENU_ITEMS_PANE_LENGTH
;
1397 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1398 /* The EMACS_INT cast avoids a warning. There's no problem
1399 as long as pointers have enough bits to hold small integers. */
1400 if ((int) (EMACS_INT
) client_data
== i
)
1403 struct input_event buf
;
1406 XSETFRAME (frame
, f
);
1407 buf
.kind
= MENU_BAR_EVENT
;
1408 buf
.frame_or_window
= frame
;
1410 kbd_buffer_store_event (&buf
);
1412 for (j
= 0; j
< submenu_depth
; j
++)
1413 if (!NILP (subprefix_stack
[j
]))
1415 buf
.kind
= MENU_BAR_EVENT
;
1416 buf
.frame_or_window
= frame
;
1417 buf
.arg
= subprefix_stack
[j
];
1418 kbd_buffer_store_event (&buf
);
1423 buf
.kind
= MENU_BAR_EVENT
;
1424 buf
.frame_or_window
= frame
;
1426 kbd_buffer_store_event (&buf
);
1429 buf
.kind
= MENU_BAR_EVENT
;
1430 buf
.frame_or_window
= frame
;
1432 kbd_buffer_store_event (&buf
);
1436 i
+= MENU_ITEMS_ITEM_LENGTH
;
1443 /* Gtk calls callbacks just because we tell it what item should be
1444 selected in a radio group. If this variable is set to a non-zero
1445 value, we are creating menus and don't want callbacks right now.
1447 static int xg_crazy_callback_abort
;
1449 /* This callback is called from the menu bar pulldown menu
1450 when the user makes a selection.
1451 Figure out what the user chose
1452 and put the appropriate events into the keyboard buffer. */
1454 menubar_selection_callback (widget
, client_data
)
1456 gpointer client_data
;
1458 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1460 if (xg_crazy_callback_abort
)
1463 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1466 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1467 cb_data
->cl_data
->menu_bar_items_used
,
1468 cb_data
->cl_data
->menu_bar_vector
,
1469 cb_data
->call_data
);
1472 #else /* not USE_GTK */
1474 /* This callback is called from the menu bar pulldown menu
1475 when the user makes a selection.
1476 Figure out what the user chose
1477 and put the appropriate events into the keyboard buffer. */
1479 menubar_selection_callback (widget
, id
, client_data
)
1482 XtPointer client_data
;
1486 f
= menubar_id_to_frame (id
);
1489 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1490 f
->menu_bar_vector
, client_data
);
1492 #endif /* not USE_GTK */
1494 /* Allocate a widget_value, blocking input. */
1497 xmalloc_widget_value ()
1499 widget_value
*value
;
1502 value
= malloc_widget_value ();
1508 /* This recursively calls free_widget_value on the tree of widgets.
1509 It must free all data that was malloc'ed for these widget_values.
1510 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1511 must be left alone. */
1514 free_menubar_widget_value_tree (wv
)
1519 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1521 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1523 free_menubar_widget_value_tree (wv
->contents
);
1524 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1528 free_menubar_widget_value_tree (wv
->next
);
1529 wv
->next
= (widget_value
*) 0xDEADBEEF;
1532 free_widget_value (wv
);
1536 /* Set up data in menu_items for a menu bar item
1537 whose event type is ITEM_KEY (with string ITEM_NAME)
1538 and whose contents come from the list of keymaps MAPS. */
1541 parse_single_submenu (item_key
, item_name
, maps
)
1542 Lisp_Object item_key
, item_name
, maps
;
1546 Lisp_Object
*mapvec
;
1548 int top_level_items
= 0;
1550 length
= Flength (maps
);
1551 len
= XINT (length
);
1553 /* Convert the list MAPS into a vector MAPVEC. */
1554 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1555 for (i
= 0; i
< len
; i
++)
1557 mapvec
[i
] = Fcar (maps
);
1561 /* Loop over the given keymaps, making a pane for each map.
1562 But don't make a pane that is empty--ignore that map instead. */
1563 for (i
= 0; i
< len
; i
++)
1565 if (!KEYMAPP (mapvec
[i
]))
1567 /* Here we have a command at top level in the menu bar
1568 as opposed to a submenu. */
1569 top_level_items
= 1;
1570 push_menu_pane (Qnil
, Qnil
);
1571 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1572 Qnil
, Qnil
, Qnil
, Qnil
);
1577 prompt
= Fkeymap_prompt (mapvec
[i
]);
1578 single_keymap_panes (mapvec
[i
],
1579 !NILP (prompt
) ? prompt
: item_name
,
1584 return top_level_items
;
1587 /* Create a tree of widget_value objects
1588 representing the panes and items
1589 in menu_items starting at index START, up to index END. */
1591 static widget_value
*
1592 digest_single_submenu (start
, end
, top_level_items
)
1593 int start
, end
, top_level_items
;
1595 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1597 int submenu_depth
= 0;
1598 widget_value
**submenu_stack
;
1601 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1602 wv
= xmalloc_widget_value ();
1606 wv
->button_type
= BUTTON_TYPE_NONE
;
1612 /* Loop over all panes and items made by the preceding call
1613 to parse_single_submenu and construct a tree of widget_value objects.
1614 Ignore the panes and items used by previous calls to
1615 digest_single_submenu, even though those are also in menu_items. */
1619 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1621 submenu_stack
[submenu_depth
++] = save_wv
;
1626 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1629 save_wv
= submenu_stack
[--submenu_depth
];
1632 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1633 && submenu_depth
!= 0)
1634 i
+= MENU_ITEMS_PANE_LENGTH
;
1635 /* Ignore a nil in the item list.
1636 It's meaningful only for dialog boxes. */
1637 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1639 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1641 /* Create a new pane. */
1642 Lisp_Object pane_name
, prefix
;
1645 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1646 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1648 #ifndef HAVE_MULTILINGUAL_MENU
1649 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1651 pane_name
= ENCODE_SYSTEM (pane_name
);
1652 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1655 pane_string
= (NILP (pane_name
)
1656 ? "" : (char *) SDATA (pane_name
));
1657 /* If there is just one top-level pane, put all its items directly
1658 under the top-level menu. */
1659 if (menu_items_n_panes
== 1)
1662 /* If the pane has a meaningful name,
1663 make the pane a top-level menu item
1664 with its items as a submenu beneath it. */
1665 if (strcmp (pane_string
, ""))
1667 wv
= xmalloc_widget_value ();
1671 first_wv
->contents
= wv
;
1672 wv
->name
= pane_string
;
1673 /* Ignore the @ that means "separate pane".
1674 This is a kludge, but this isn't worth more time. */
1675 if (!NILP (prefix
) && wv
->name
[0] == '@')
1679 wv
->button_type
= BUTTON_TYPE_NONE
;
1684 i
+= MENU_ITEMS_PANE_LENGTH
;
1688 /* Create a new item within current pane. */
1689 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1692 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1693 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1694 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1695 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1696 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1697 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1698 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1700 #ifndef HAVE_MULTILINGUAL_MENU
1701 if (STRING_MULTIBYTE (item_name
))
1703 item_name
= ENCODE_SYSTEM (item_name
);
1704 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1707 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1709 descrip
= ENCODE_SYSTEM (descrip
);
1710 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1712 #endif /* not HAVE_MULTILINGUAL_MENU */
1714 wv
= xmalloc_widget_value ();
1718 save_wv
->contents
= wv
;
1720 wv
->name
= (char *) SDATA (item_name
);
1721 if (!NILP (descrip
))
1722 wv
->key
= (char *) SDATA (descrip
);
1724 /* The EMACS_INT cast avoids a warning. There's no problem
1725 as long as pointers have enough bits to hold small integers. */
1726 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1727 wv
->enabled
= !NILP (enable
);
1730 wv
->button_type
= BUTTON_TYPE_NONE
;
1731 else if (EQ (type
, QCradio
))
1732 wv
->button_type
= BUTTON_TYPE_RADIO
;
1733 else if (EQ (type
, QCtoggle
))
1734 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1738 wv
->selected
= !NILP (selected
);
1739 if (! STRINGP (help
))
1746 i
+= MENU_ITEMS_ITEM_LENGTH
;
1750 /* If we have just one "menu item"
1751 that was originally a button, return it by itself. */
1752 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1754 wv
= first_wv
->contents
;
1755 free_widget_value (first_wv
);
1762 /* Recompute all the widgets of frame F, when the menu bar has been
1763 changed. Value is non-zero if widgets were updated. */
1766 update_frame_menubar (f
)
1770 return xg_update_frame_menubar (f
);
1772 struct x_output
*x
= f
->output_data
.x
;
1775 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1779 /* Save the size of the frame because the pane widget doesn't accept
1780 to resize itself. So force it. */
1784 /* Do the voodoo which means "I'm changing lots of things, don't try
1785 to refigure sizes until I'm done." */
1786 lw_refigure_widget (x
->column_widget
, False
);
1788 /* The order in which children are managed is the top to bottom
1789 order in which they are displayed in the paned window. First,
1790 remove the text-area widget. */
1791 XtUnmanageChild (x
->edit_widget
);
1793 /* Remove the menubar that is there now, and put up the menubar that
1795 XtManageChild (x
->menubar_widget
);
1796 XtMapWidget (x
->menubar_widget
);
1797 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1799 /* Re-manage the text-area widget, and then thrash the sizes. */
1800 XtManageChild (x
->edit_widget
);
1801 lw_refigure_widget (x
->column_widget
, True
);
1803 /* Force the pane widget to resize itself with the right values. */
1804 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1810 /* Set the contents of the menubar widgets of frame F.
1811 The argument FIRST_TIME is currently ignored;
1812 it is set the first time this is called, from initialize_frame_menubar. */
1815 set_frame_menubar (f
, first_time
, deep_p
)
1820 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1821 #ifdef USE_X_TOOLKIT
1825 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1827 int *submenu_start
, *submenu_end
;
1828 int *submenu_top_level_items
, *submenu_n_panes
;
1831 XSETFRAME (Vmenu_updating_frame
, f
);
1833 #ifdef USE_X_TOOLKIT
1834 if (f
->output_data
.x
->id
== 0)
1835 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1836 id
= f
->output_data
.x
->id
;
1839 if (! menubar_widget
)
1841 else if (pending_menu_activation
&& !deep_p
)
1843 /* Make the first call for any given frame always go deep. */
1844 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1847 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1848 f
->output_data
.x
->saved_menu_event
->type
= 0;
1853 /* Make a widget-value tree representing the entire menu trees. */
1855 struct buffer
*prev
= current_buffer
;
1857 int specpdl_count
= SPECPDL_INDEX ();
1858 int previous_menu_items_used
= f
->menu_bar_items_used
;
1859 Lisp_Object
*previous_items
1860 = (Lisp_Object
*) alloca (previous_menu_items_used
1861 * sizeof (Lisp_Object
));
1863 /* If we are making a new widget, its contents are empty,
1864 do always reinitialize them. */
1865 if (! menubar_widget
)
1866 previous_menu_items_used
= 0;
1868 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1869 specbind (Qinhibit_quit
, Qt
);
1870 /* Don't let the debugger step into this code
1871 because it is not reentrant. */
1872 specbind (Qdebug_on_next_call
, Qnil
);
1874 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1875 record_unwind_protect (unuse_menu_items
, Qnil
);
1876 if (NILP (Voverriding_local_map_menu_flag
))
1878 specbind (Qoverriding_terminal_local_map
, Qnil
);
1879 specbind (Qoverriding_local_map
, Qnil
);
1882 set_buffer_internal_1 (XBUFFER (buffer
));
1884 /* Run the Lucid hook. */
1885 safe_run_hooks (Qactivate_menubar_hook
);
1887 /* If it has changed current-menubar from previous value,
1888 really recompute the menubar from the value. */
1889 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1890 call0 (Qrecompute_lucid_menubar
);
1891 safe_run_hooks (Qmenu_bar_update_hook
);
1892 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1894 items
= FRAME_MENU_BAR_ITEMS (f
);
1896 /* Save the frame's previous menu bar contents data. */
1897 if (previous_menu_items_used
)
1898 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1899 previous_menu_items_used
* sizeof (Lisp_Object
));
1901 /* Fill in menu_items with the current menu bar contents.
1902 This can evaluate Lisp code. */
1903 menu_items
= f
->menu_bar_vector
;
1904 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1905 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1906 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1907 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1908 submenu_top_level_items
1909 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1911 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1913 Lisp_Object key
, string
, maps
;
1917 key
= XVECTOR (items
)->contents
[i
];
1918 string
= XVECTOR (items
)->contents
[i
+ 1];
1919 maps
= XVECTOR (items
)->contents
[i
+ 2];
1923 submenu_start
[i
] = menu_items_used
;
1925 menu_items_n_panes
= 0;
1926 submenu_top_level_items
[i
]
1927 = parse_single_submenu (key
, string
, maps
);
1928 submenu_n_panes
[i
] = menu_items_n_panes
;
1930 submenu_end
[i
] = menu_items_used
;
1933 finish_menu_items ();
1935 /* Convert menu_items into widget_value trees
1936 to display the menu. This cannot evaluate Lisp code. */
1938 wv
= xmalloc_widget_value ();
1939 wv
->name
= "menubar";
1942 wv
->button_type
= BUTTON_TYPE_NONE
;
1946 for (i
= 0; i
< last_i
; i
+= 4)
1948 menu_items_n_panes
= submenu_n_panes
[i
];
1949 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1950 submenu_top_level_items
[i
]);
1954 first_wv
->contents
= wv
;
1955 /* Don't set wv->name here; GC during the loop might relocate it. */
1957 wv
->button_type
= BUTTON_TYPE_NONE
;
1961 set_buffer_internal_1 (prev
);
1962 unbind_to (specpdl_count
, Qnil
);
1964 /* If there has been no change in the Lisp-level contents
1965 of the menu bar, skip redisplaying it. Just exit. */
1967 for (i
= 0; i
< previous_menu_items_used
; i
++)
1968 if (menu_items_used
== i
1969 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1971 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1973 free_menubar_widget_value_tree (first_wv
);
1974 discard_menu_items ();
1979 /* Now GC cannot happen during the lifetime of the widget_value,
1980 so it's safe to store data from a Lisp_String. */
1981 wv
= first_wv
->contents
;
1982 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1985 string
= XVECTOR (items
)->contents
[i
+ 1];
1988 wv
->name
= (char *) SDATA (string
);
1992 f
->menu_bar_vector
= menu_items
;
1993 f
->menu_bar_items_used
= menu_items_used
;
1994 discard_menu_items ();
1998 /* Make a widget-value tree containing
1999 just the top level menu bar strings. */
2001 wv
= xmalloc_widget_value ();
2002 wv
->name
= "menubar";
2005 wv
->button_type
= BUTTON_TYPE_NONE
;
2009 items
= FRAME_MENU_BAR_ITEMS (f
);
2010 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2014 string
= XVECTOR (items
)->contents
[i
+ 1];
2018 wv
= xmalloc_widget_value ();
2019 wv
->name
= (char *) SDATA (string
);
2022 wv
->button_type
= BUTTON_TYPE_NONE
;
2024 /* This prevents lwlib from assuming this
2025 menu item is really supposed to be empty. */
2026 /* The EMACS_INT cast avoids a warning.
2027 This value just has to be different from small integers. */
2028 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2033 first_wv
->contents
= wv
;
2037 /* Forget what we thought we knew about what is in the
2038 detailed contents of the menu bar menus.
2039 Changing the top level always destroys the contents. */
2040 f
->menu_bar_items_used
= 0;
2043 /* Create or update the menu bar widget. */
2048 xg_crazy_callback_abort
= 1;
2051 /* The third arg is DEEP_P, which says to consider the entire
2052 menu trees we supply, rather than just the menu bar item names. */
2053 xg_modify_menubar_widgets (menubar_widget
,
2057 G_CALLBACK (menubar_selection_callback
),
2058 G_CALLBACK (popup_deactivate_callback
),
2059 G_CALLBACK (menu_highlight_callback
));
2063 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2066 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2067 G_CALLBACK (menubar_selection_callback
),
2068 G_CALLBACK (popup_deactivate_callback
),
2069 G_CALLBACK (menu_highlight_callback
));
2071 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2075 #else /* not USE_GTK */
2078 /* Disable resizing (done for Motif!) */
2079 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2081 /* The third arg is DEEP_P, which says to consider the entire
2082 menu trees we supply, rather than just the menu bar item names. */
2083 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2085 /* Re-enable the edit widget to resize. */
2086 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2090 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2091 f
->output_data
.x
->column_widget
,
2093 popup_activate_callback
,
2094 menubar_selection_callback
,
2095 popup_deactivate_callback
,
2096 menu_highlight_callback
);
2097 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2102 = (f
->output_data
.x
->menubar_widget
2103 ? (f
->output_data
.x
->menubar_widget
->core
.height
2104 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2107 #if 0 /* Experimentally, we now get the right results
2108 for -geometry -0-0 without this. 24 Aug 96, rms. */
2110 if (FRAME_EXTERNAL_MENU_BAR (f
))
2113 XtVaGetValues (f
->output_data
.x
->column_widget
,
2114 XtNinternalBorderWidth
, &ibw
, NULL
);
2115 menubar_size
+= ibw
;
2117 #endif /* USE_LUCID */
2120 f
->output_data
.x
->menubar_height
= menubar_size
;
2122 #endif /* not USE_GTK */
2124 free_menubar_widget_value_tree (first_wv
);
2125 update_frame_menubar (f
);
2128 xg_crazy_callback_abort
= 0;
2134 /* Called from Fx_create_frame to create the initial menubar of a frame
2135 before it is mapped, so that the window is mapped with the menubar already
2136 there instead of us tacking it on later and thrashing the window after it
2140 initialize_frame_menubar (f
)
2143 /* This function is called before the first chance to redisplay
2144 the frame. It has to be, so the frame will have the right size. */
2145 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2146 set_frame_menubar (f
, 1, 1);
2150 /* Get rid of the menu bar of frame F, and free its storage.
2151 This is used when deleting a frame, and when turning off the menu bar.
2152 For GTK this function is in gtkutil.c. */
2156 free_frame_menubar (f
)
2159 Widget menubar_widget
;
2161 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2163 f
->output_data
.x
->menubar_height
= 0;
2168 /* Removing the menu bar magically changes the shell widget's x
2169 and y position of (0, 0) which, when the menu bar is turned
2170 on again, leads to pull-down menuss appearing in strange
2171 positions near the upper-left corner of the display. This
2172 happens only with some window managers like twm and ctwm,
2173 but not with other like Motif's mwm or kwm, because the
2174 latter generate ConfigureNotify events when the menu bar
2175 is switched off, which fixes the shell position. */
2176 Position x0
, y0
, x1
, y1
;
2182 if (f
->output_data
.x
->widget
)
2183 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2186 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2187 f
->output_data
.x
->menubar_widget
= NULL
;
2190 if (f
->output_data
.x
->widget
)
2192 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2193 if (x1
== 0 && y1
== 0)
2194 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2201 #endif /* not USE_GTK */
2203 #endif /* USE_X_TOOLKIT || USE_GTK */
2205 /* xmenu_show actually displays a menu using the panes and items in menu_items
2206 and returns the value selected from it.
2207 There are two versions of xmenu_show, one for Xt and one for Xlib.
2208 Both assume input is blocked by the caller. */
2210 /* F is the frame the menu is for.
2211 X and Y are the frame-relative specified position,
2212 relative to the inside upper left corner of the frame F.
2213 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2214 KEYMAPS is 1 if this menu was specified with keymaps;
2215 in that case, we return a list containing the chosen item's value
2216 and perhaps also the pane's prefix.
2217 TITLE is the specified menu title.
2218 ERROR is a place to store an error message string in case of failure.
2219 (We return nil on failure, but the value doesn't actually matter.) */
2221 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2223 /* The item selected in the popup menu. */
2224 static Lisp_Object
*volatile menu_item_selection
;
2228 /* Used when position a popup menu. See menu_position_func and
2229 create_and_show_popup_menu below. */
2230 struct next_popup_x_y
2237 /* The menu position function to use if we are not putting a popup
2238 menu where the pointer is.
2239 MENU is the menu to pop up.
2240 X and Y shall on exit contain x/y where the menu shall pop up.
2241 PUSH_IN is not documented in the GTK manual.
2242 USER_DATA is any data passed in when calling gtk_menu_popup.
2243 Here it points to a struct next_popup_x_y where the coordinates
2244 to store in *X and *Y are as well as the frame for the popup.
2246 Here only X and Y are used. */
2248 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2255 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2257 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2258 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2263 /* Check if there is room for the menu. If not, adjust x/y so that
2264 the menu is fully visible. */
2265 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2266 if (data
->x
+ req
.width
> disp_width
)
2267 *x
-= data
->x
+ req
.width
- disp_width
;
2268 if (data
->y
+ req
.height
> disp_height
)
2269 *y
-= data
->y
+ req
.height
- disp_height
;
2273 popup_selection_callback (widget
, client_data
)
2275 gpointer client_data
;
2277 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2279 if (xg_crazy_callback_abort
) return;
2280 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2283 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2285 menu_item_selection will be set to the selection. */
2287 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2289 widget_value
*first_wv
;
2296 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2297 struct next_popup_x_y popup_x_y
;
2299 xg_crazy_callback_abort
= 1;
2300 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2301 G_CALLBACK (popup_selection_callback
),
2302 G_CALLBACK (popup_deactivate_callback
),
2303 G_CALLBACK (menu_highlight_callback
));
2304 xg_crazy_callback_abort
= 0;
2306 for (i
= 0; i
< 5; i
++)
2307 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2312 /* Not invoked by a click. pop up at x/y. */
2313 pos_func
= menu_position_func
;
2315 /* Adjust coordinates to be root-window-relative. */
2316 x
+= f
->output_data
.x
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2317 y
+= f
->output_data
.x
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2324 /* Display the menu. */
2325 gtk_widget_show_all (menu
);
2326 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2329 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2330 two. show_help_echo uses this to detect popup menus. */
2331 popup_activated_flag
= 1;
2332 /* Process events that apply to the menu. */
2333 popup_widget_loop ();
2336 xg_keep_popup (menu
, xg_did_tearoff
);
2338 gtk_widget_destroy (menu
);
2340 /* Must reset this manually because the button release event is not passed
2341 to Emacs event loop. */
2342 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2345 #else /* not USE_GTK */
2347 /* We need a unique id for each widget handled by the Lucid Widget
2350 For the main windows, and popup menus, we use this counter,
2351 which we increment each time after use. This starts from 1<<16.
2353 For menu bars, we use numbers starting at 0, counted in
2354 next_menubar_widget_id. */
2355 LWLIB_ID widget_id_tick
;
2358 popup_selection_callback (widget
, id
, client_data
)
2361 XtPointer client_data
;
2363 menu_item_selection
= (Lisp_Object
*) client_data
;
2366 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2368 menu_item_selection will be set to the selection. */
2370 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2372 widget_value
*first_wv
;
2380 XButtonPressedEvent dummy
;
2385 menu_id
= widget_id_tick
++;
2386 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2387 f
->output_data
.x
->widget
, 1, 0,
2388 popup_selection_callback
,
2389 popup_deactivate_callback
,
2390 menu_highlight_callback
);
2392 dummy
.type
= ButtonPress
;
2394 dummy
.send_event
= 0;
2395 dummy
.display
= FRAME_X_DISPLAY (f
);
2396 dummy
.time
= CurrentTime
;
2397 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2398 dummy
.window
= dummy
.root
;
2399 dummy
.subwindow
= dummy
.root
;
2403 /* Adjust coordinates to be root-window-relative. */
2404 x
+= f
->output_data
.x
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2405 y
+= f
->output_data
.x
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2412 for (i
= 0; i
< 5; i
++)
2413 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2416 /* Don't allow any geometry request from the user. */
2417 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2418 XtSetValues (menu
, av
, ac
);
2420 /* Display the menu. */
2421 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2422 popup_activated_flag
= 1;
2424 /* Process events that apply to the menu. */
2425 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 0);
2427 /* fp turned off the following statement and wrote a comment
2428 that it is unnecessary--that the menu has already disappeared.
2429 Nowadays the menu disappears ok, all right, but
2430 we need to delete the widgets or multiple ones will pile up. */
2431 lw_destroy_all_widgets (menu_id
);
2434 #endif /* not USE_GTK */
2437 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2447 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2448 widget_value
**submenu_stack
2449 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2450 Lisp_Object
*subprefix_stack
2451 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2452 int submenu_depth
= 0;
2458 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2460 *error
= "Empty menu";
2464 /* Create a tree of widget_value objects
2465 representing the panes and their items. */
2466 wv
= xmalloc_widget_value ();
2470 wv
->button_type
= BUTTON_TYPE_NONE
;
2475 /* Loop over all panes and items, filling in the tree. */
2477 while (i
< menu_items_used
)
2479 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2481 submenu_stack
[submenu_depth
++] = save_wv
;
2487 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2490 save_wv
= submenu_stack
[--submenu_depth
];
2494 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2495 && submenu_depth
!= 0)
2496 i
+= MENU_ITEMS_PANE_LENGTH
;
2497 /* Ignore a nil in the item list.
2498 It's meaningful only for dialog boxes. */
2499 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2501 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2503 /* Create a new pane. */
2504 Lisp_Object pane_name
, prefix
;
2507 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2508 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2510 #ifndef HAVE_MULTILINGUAL_MENU
2511 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2513 pane_name
= ENCODE_SYSTEM (pane_name
);
2514 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2517 pane_string
= (NILP (pane_name
)
2518 ? "" : (char *) SDATA (pane_name
));
2519 /* If there is just one top-level pane, put all its items directly
2520 under the top-level menu. */
2521 if (menu_items_n_panes
== 1)
2524 /* If the pane has a meaningful name,
2525 make the pane a top-level menu item
2526 with its items as a submenu beneath it. */
2527 if (!keymaps
&& strcmp (pane_string
, ""))
2529 wv
= xmalloc_widget_value ();
2533 first_wv
->contents
= wv
;
2534 wv
->name
= pane_string
;
2535 if (keymaps
&& !NILP (prefix
))
2539 wv
->button_type
= BUTTON_TYPE_NONE
;
2544 else if (first_pane
)
2550 i
+= MENU_ITEMS_PANE_LENGTH
;
2554 /* Create a new item within current pane. */
2555 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2556 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2557 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2558 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2559 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2560 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2561 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2562 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2564 #ifndef HAVE_MULTILINGUAL_MENU
2565 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2567 item_name
= ENCODE_SYSTEM (item_name
);
2568 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2571 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2573 descrip
= ENCODE_SYSTEM (descrip
);
2574 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2576 #endif /* not HAVE_MULTILINGUAL_MENU */
2578 wv
= xmalloc_widget_value ();
2582 save_wv
->contents
= wv
;
2583 wv
->name
= (char *) SDATA (item_name
);
2584 if (!NILP (descrip
))
2585 wv
->key
= (char *) SDATA (descrip
);
2587 /* If this item has a null value,
2588 make the call_data null so that it won't display a box
2589 when the mouse is on it. */
2591 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2592 wv
->enabled
= !NILP (enable
);
2595 wv
->button_type
= BUTTON_TYPE_NONE
;
2596 else if (EQ (type
, QCtoggle
))
2597 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2598 else if (EQ (type
, QCradio
))
2599 wv
->button_type
= BUTTON_TYPE_RADIO
;
2603 wv
->selected
= !NILP (selected
);
2605 if (! STRINGP (help
))
2612 i
+= MENU_ITEMS_ITEM_LENGTH
;
2616 /* Deal with the title, if it is non-nil. */
2619 widget_value
*wv_title
= xmalloc_widget_value ();
2620 widget_value
*wv_sep1
= xmalloc_widget_value ();
2621 widget_value
*wv_sep2
= xmalloc_widget_value ();
2623 wv_sep2
->name
= "--";
2624 wv_sep2
->next
= first_wv
->contents
;
2625 wv_sep2
->help
= Qnil
;
2627 wv_sep1
->name
= "--";
2628 wv_sep1
->next
= wv_sep2
;
2629 wv_sep1
->help
= Qnil
;
2631 #ifndef HAVE_MULTILINGUAL_MENU
2632 if (STRING_MULTIBYTE (title
))
2633 title
= ENCODE_SYSTEM (title
);
2636 wv_title
->name
= (char *) SDATA (title
);
2637 wv_title
->enabled
= TRUE
;
2638 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2639 wv_title
->next
= wv_sep1
;
2640 wv_title
->help
= Qnil
;
2641 first_wv
->contents
= wv_title
;
2644 /* No selection has been chosen yet. */
2645 menu_item_selection
= 0;
2647 /* Actually create and show the menu until popped down. */
2648 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2650 /* Free the widget_value objects we used to specify the contents. */
2651 free_menubar_widget_value_tree (first_wv
);
2653 /* Find the selected item, and its pane, to return
2654 the proper value. */
2655 if (menu_item_selection
!= 0)
2657 Lisp_Object prefix
, entry
;
2659 prefix
= entry
= Qnil
;
2661 while (i
< menu_items_used
)
2663 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2665 subprefix_stack
[submenu_depth
++] = prefix
;
2669 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2671 prefix
= subprefix_stack
[--submenu_depth
];
2674 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2677 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2678 i
+= MENU_ITEMS_PANE_LENGTH
;
2680 /* Ignore a nil in the item list.
2681 It's meaningful only for dialog boxes. */
2682 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2687 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2688 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2694 entry
= Fcons (entry
, Qnil
);
2696 entry
= Fcons (prefix
, entry
);
2697 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2698 if (!NILP (subprefix_stack
[j
]))
2699 entry
= Fcons (subprefix_stack
[j
], entry
);
2703 i
+= MENU_ITEMS_ITEM_LENGTH
;
2713 dialog_selection_callback (widget
, client_data
)
2715 gpointer client_data
;
2717 /* The EMACS_INT cast avoids a warning. There's no problem
2718 as long as pointers have enough bits to hold small integers. */
2719 if ((int) (EMACS_INT
) client_data
!= -1)
2720 menu_item_selection
= (Lisp_Object
*) client_data
;
2722 popup_activated_flag
= 0;
2725 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2727 menu_item_selection will be set to the selection. */
2729 create_and_show_dialog (f
, first_wv
)
2731 widget_value
*first_wv
;
2735 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2736 G_CALLBACK (dialog_selection_callback
),
2737 G_CALLBACK (popup_deactivate_callback
),
2742 /* Display the menu. */
2743 gtk_widget_show_all (menu
);
2745 /* Process events that apply to the menu. */
2746 popup_widget_loop ();
2748 gtk_widget_destroy (menu
);
2752 #else /* not USE_GTK */
2754 dialog_selection_callback (widget
, id
, client_data
)
2757 XtPointer client_data
;
2759 /* The EMACS_INT cast avoids a warning. There's no problem
2760 as long as pointers have enough bits to hold small integers. */
2761 if ((int) (EMACS_INT
) client_data
!= -1)
2762 menu_item_selection
= (Lisp_Object
*) client_data
;
2765 lw_destroy_all_widgets (id
);
2767 popup_activated_flag
= 0;
2771 /* ARG is the LWLIB ID of the dialog box, represented
2772 as a Lisp object as (HIGHPART . LOWPART). */
2775 xdialog_show_unwind (arg
)
2778 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2779 | XINT (XCDR (arg
)));
2781 lw_destroy_all_widgets (id
);
2783 popup_activated_flag
= 0;
2788 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2790 menu_item_selection will be set to the selection. */
2792 create_and_show_dialog (f
, first_wv
)
2794 widget_value
*first_wv
;
2798 dialog_id
= widget_id_tick
++;
2799 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2800 f
->output_data
.x
->widget
, 1, 0,
2801 dialog_selection_callback
, 0, 0);
2802 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2804 /* Display the dialog box. */
2805 lw_pop_up_all_widgets (dialog_id
);
2806 popup_activated_flag
= 1;
2808 /* Process events that apply to the dialog box.
2809 Also handle timers. */
2811 int count
= SPECPDL_INDEX ();
2812 int fact
= 4 * sizeof (LWLIB_ID
);
2814 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2815 record_unwind_protect (xdialog_show_unwind
,
2816 Fcons (make_number (dialog_id
>> (fact
)),
2817 make_number (dialog_id
& ~(-1 << (fact
)))));
2819 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
, 1);
2821 unbind_to (count
, Qnil
);
2825 #endif /* not USE_GTK */
2827 static char * button_names
[] = {
2828 "button1", "button2", "button3", "button4", "button5",
2829 "button6", "button7", "button8", "button9", "button10" };
2832 xdialog_show (f
, keymaps
, title
, error
)
2838 int i
, nb_buttons
=0;
2839 char dialog_name
[6];
2841 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2843 /* Number of elements seen so far, before boundary. */
2845 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2846 int boundary_seen
= 0;
2850 if (menu_items_n_panes
> 1)
2852 *error
= "Multiple panes in dialog box";
2856 /* Create a tree of widget_value objects
2857 representing the text label and buttons. */
2859 Lisp_Object pane_name
, prefix
;
2861 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2862 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2863 pane_string
= (NILP (pane_name
)
2864 ? "" : (char *) SDATA (pane_name
));
2865 prev_wv
= xmalloc_widget_value ();
2866 prev_wv
->value
= pane_string
;
2867 if (keymaps
&& !NILP (prefix
))
2869 prev_wv
->enabled
= 1;
2870 prev_wv
->name
= "message";
2871 prev_wv
->help
= Qnil
;
2874 /* Loop over all panes and items, filling in the tree. */
2875 i
= MENU_ITEMS_PANE_LENGTH
;
2876 while (i
< menu_items_used
)
2879 /* Create a new item within current pane. */
2880 Lisp_Object item_name
, enable
, descrip
;
2881 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2882 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2884 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2886 if (NILP (item_name
))
2888 free_menubar_widget_value_tree (first_wv
);
2889 *error
= "Submenu in dialog items";
2892 if (EQ (item_name
, Qquote
))
2894 /* This is the boundary between left-side elts
2895 and right-side elts. Stop incrementing right_count. */
2900 if (nb_buttons
>= 9)
2902 free_menubar_widget_value_tree (first_wv
);
2903 *error
= "Too many dialog items";
2907 wv
= xmalloc_widget_value ();
2909 wv
->name
= (char *) button_names
[nb_buttons
];
2910 if (!NILP (descrip
))
2911 wv
->key
= (char *) SDATA (descrip
);
2912 wv
->value
= (char *) SDATA (item_name
);
2913 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2914 wv
->enabled
= !NILP (enable
);
2918 if (! boundary_seen
)
2922 i
+= MENU_ITEMS_ITEM_LENGTH
;
2925 /* If the boundary was not specified,
2926 by default put half on the left and half on the right. */
2927 if (! boundary_seen
)
2928 left_count
= nb_buttons
- nb_buttons
/ 2;
2930 wv
= xmalloc_widget_value ();
2931 wv
->name
= dialog_name
;
2933 /* Dialog boxes use a really stupid name encoding
2934 which specifies how many buttons to use
2935 and how many buttons are on the right.
2936 The Q means something also. */
2937 dialog_name
[0] = 'Q';
2938 dialog_name
[1] = '0' + nb_buttons
;
2939 dialog_name
[2] = 'B';
2940 dialog_name
[3] = 'R';
2941 /* Number of buttons to put on the right. */
2942 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2944 wv
->contents
= first_wv
;
2948 /* No selection has been chosen yet. */
2949 menu_item_selection
= 0;
2951 /* Actually create and show the dialog. */
2952 create_and_show_dialog (f
, first_wv
);
2954 /* Free the widget_value objects we used to specify the contents. */
2955 free_menubar_widget_value_tree (first_wv
);
2957 /* Find the selected item, and its pane, to return
2958 the proper value. */
2959 if (menu_item_selection
!= 0)
2965 while (i
< menu_items_used
)
2969 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2972 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2973 i
+= MENU_ITEMS_PANE_LENGTH
;
2975 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2977 /* This is the boundary between left-side elts and
2984 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2985 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2989 entry
= Fcons (entry
, Qnil
);
2991 entry
= Fcons (prefix
, entry
);
2995 i
+= MENU_ITEMS_ITEM_LENGTH
;
3003 #else /* not USE_X_TOOLKIT && not USE_GTK */
3005 /* The frame of the last activated non-toolkit menu bar.
3006 Used to generate menu help events. */
3008 static struct frame
*menu_help_frame
;
3011 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3013 PANE is the pane number, and ITEM is the menu item number in
3014 the menu (currently not used).
3016 This cannot be done with generating a HELP_EVENT because
3017 XMenuActivate contains a loop that doesn't let Emacs process
3021 menu_help_callback (help_string
, pane
, item
)
3025 extern Lisp_Object Qmenu_item
;
3026 Lisp_Object
*first_item
;
3027 Lisp_Object pane_name
;
3028 Lisp_Object menu_object
;
3030 first_item
= XVECTOR (menu_items
)->contents
;
3031 if (EQ (first_item
[0], Qt
))
3032 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3033 else if (EQ (first_item
[0], Qquote
))
3034 /* This shouldn't happen, see xmenu_show. */
3035 pane_name
= empty_string
;
3037 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3039 /* (menu-item MENU-NAME PANE-NUMBER) */
3040 menu_object
= Fcons (Qmenu_item
,
3042 Fcons (make_number (pane
), Qnil
)));
3043 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3044 Qnil
, menu_object
, make_number (item
), 1);
3049 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3059 int pane
, selidx
, lpane
, status
;
3060 Lisp_Object entry
, pane_prefix
;
3062 int ulx
, uly
, width
, height
;
3063 int dispwidth
, dispheight
;
3067 unsigned int dummy_uint
;
3070 if (menu_items_n_panes
== 0)
3073 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3075 *error
= "Empty menu";
3079 /* Figure out which root window F is on. */
3080 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3081 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3082 &dummy_uint
, &dummy_uint
);
3084 /* Make the menu on that window. */
3085 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3088 *error
= "Can't create menu";
3092 #ifdef HAVE_X_WINDOWS
3093 /* Adjust coordinates to relative to the outer (window manager) window. */
3096 int win_x
= 0, win_y
= 0;
3098 /* Find the position of the outside upper-left corner of
3099 the inner window, with respect to the outer window. */
3100 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
3103 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3105 /* From-window, to-window. */
3106 f
->output_data
.x
->window_desc
,
3107 f
->output_data
.x
->parent_desc
,
3109 /* From-position, to-position. */
3110 0, 0, &win_x
, &win_y
,
3112 /* Child of window. */
3119 #endif /* HAVE_X_WINDOWS */
3121 /* Adjust coordinates to be root-window-relative. */
3122 x
+= f
->output_data
.x
->left_pos
;
3123 y
+= f
->output_data
.x
->top_pos
;
3125 /* Create all the necessary panes and their items. */
3127 while (i
< menu_items_used
)
3129 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3131 /* Create a new pane. */
3132 Lisp_Object pane_name
, prefix
;
3135 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3136 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3137 pane_string
= (NILP (pane_name
)
3138 ? "" : (char *) SDATA (pane_name
));
3139 if (keymaps
&& !NILP (prefix
))
3142 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3143 if (lpane
== XM_FAILURE
)
3145 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3146 *error
= "Can't create pane";
3149 i
+= MENU_ITEMS_PANE_LENGTH
;
3151 /* Find the width of the widest item in this pane. */
3154 while (j
< menu_items_used
)
3157 item
= XVECTOR (menu_items
)->contents
[j
];
3165 width
= SBYTES (item
);
3166 if (width
> maxwidth
)
3169 j
+= MENU_ITEMS_ITEM_LENGTH
;
3172 /* Ignore a nil in the item list.
3173 It's meaningful only for dialog boxes. */
3174 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3178 /* Create a new item within current pane. */
3179 Lisp_Object item_name
, enable
, descrip
, help
;
3180 unsigned char *item_data
;
3183 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3184 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3186 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3187 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3188 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3190 if (!NILP (descrip
))
3192 int gap
= maxwidth
- SBYTES (item_name
);
3195 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3196 item_name
= concat2 (item_name
, spacer
);
3197 item_name
= concat2 (item_name
, descrip
);
3198 item_data
= SDATA (item_name
);
3200 /* if alloca is fast, use that to make the space,
3201 to reduce gc needs. */
3203 = (unsigned char *) alloca (maxwidth
3204 + SBYTES (descrip
) + 1);
3205 bcopy (SDATA (item_name
), item_data
,
3206 SBYTES (item_name
));
3207 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3209 bcopy (SDATA (descrip
), item_data
+ j
,
3211 item_data
[j
+ SBYTES (descrip
)] = 0;
3215 item_data
= SDATA (item_name
);
3217 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3218 menu
, lpane
, 0, item_data
,
3219 !NILP (enable
), help_string
)
3222 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3223 *error
= "Can't add selection to menu";
3226 i
+= MENU_ITEMS_ITEM_LENGTH
;
3230 /* All set and ready to fly. */
3231 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3232 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3233 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3234 x
= min (x
, dispwidth
);
3235 y
= min (y
, dispheight
);
3238 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3239 &ulx
, &uly
, &width
, &height
);
3240 if (ulx
+width
> dispwidth
)
3242 x
-= (ulx
+ width
) - dispwidth
;
3243 ulx
= dispwidth
- width
;
3245 if (uly
+height
> dispheight
)
3247 y
-= (uly
+ height
) - dispheight
;
3248 uly
= dispheight
- height
;
3250 if (ulx
< 0) x
-= ulx
;
3251 if (uly
< 0) y
-= uly
;
3253 XMenuSetAEQ (menu
, TRUE
);
3254 XMenuSetFreeze (menu
, TRUE
);
3257 /* Help display under X won't work because XMenuActivate contains
3258 a loop that doesn't give Emacs a chance to process it. */
3259 menu_help_frame
= f
;
3260 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3261 x
, y
, ButtonReleaseMask
, &datap
,
3262 menu_help_callback
);
3265 #ifdef HAVE_X_WINDOWS
3266 /* Assume the mouse has moved out of the X window.
3267 If it has actually moved in, we will get an EnterNotify. */
3268 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3275 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3278 /* Find the item number SELIDX in pane number PANE. */
3280 while (i
< menu_items_used
)
3282 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3286 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3288 i
+= MENU_ITEMS_PANE_LENGTH
;
3297 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3300 entry
= Fcons (entry
, Qnil
);
3301 if (!NILP (pane_prefix
))
3302 entry
= Fcons (pane_prefix
, entry
);
3308 i
+= MENU_ITEMS_ITEM_LENGTH
;
3314 *error
= "Can't activate menu";
3320 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3322 #ifdef HAVE_X_WINDOWS
3323 /* State that no mouse buttons are now held.
3324 (The oldXMenu code doesn't track this info for us.)
3325 That is not necessarily true, but the fiction leads to reasonable
3326 results, and it is a pain to ask which are actually held now. */
3327 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3333 #endif /* not USE_X_TOOLKIT */
3335 #endif /* HAVE_MENUS */
3340 staticpro (&menu_items
);
3342 menu_items_inuse
= Qnil
;
3344 Qdebug_on_next_call
= intern ("debug-on-next-call");
3345 staticpro (&Qdebug_on_next_call
);
3347 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3348 doc
: /* Frame for which we are updating a menu.
3349 The enable predicate for a menu command should check this variable. */);
3350 Vmenu_updating_frame
= Qnil
;
3352 #ifdef USE_X_TOOLKIT
3353 widget_id_tick
= (1<<16);
3354 next_menubar_widget_id
= 1;
3357 defsubr (&Sx_popup_menu
);
3359 defsubr (&Sx_popup_dialog
);