1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008 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 3, 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., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, 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 #if 0 /* Why was this included? And without syssignal.h? */
37 /* On 4.3 this loses if it comes after xterm.h. */
44 #include "termhooks.h"
49 #include "blockinput.h"
53 #include "sysselect.h"
60 /* This may include sys/types.h, and that somehow loses
61 if this is not done before the other system files. */
65 /* Load sys/types.h if not already loaded.
66 In some systems loading it twice is suicidal. */
68 #include <sys/types.h>
71 #include "dispextern.h"
74 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
75 code accepts the Emacs internal encoding. */
76 #undef HAVE_MULTILINGUAL_MENU
80 #include <X11/IntrinsicP.h>
81 #include <X11/CoreP.h>
82 #include <X11/StringDefs.h>
83 #include <X11/Shell.h>
85 #include <X11/Xaw/Paned.h>
86 #endif /* USE_LUCID */
87 #include "../lwlib/lwlib.h"
88 #else /* not USE_X_TOOLKIT */
90 #include "../oldXMenu/XMenu.h"
92 #endif /* not USE_X_TOOLKIT */
93 #endif /* HAVE_X_WINDOWS */
100 Lisp_Object Qdebug_on_next_call
;
102 extern Lisp_Object Vmenu_updating_frame
;
104 extern Lisp_Object Qmenu_bar
;
106 extern Lisp_Object QCtoggle
, QCradio
;
108 extern Lisp_Object Voverriding_local_map
;
109 extern Lisp_Object Voverriding_local_map_menu_flag
;
111 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
113 extern Lisp_Object Qmenu_bar_update_hook
;
116 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
117 extern XtAppContext Xt_app_con
;
119 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
121 static void popup_get_selection
P_ ((XEvent
*, struct x_display_info
*,
124 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
127 #endif /* USE_X_TOOLKIT */
132 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
133 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
137 /* This is how to deal with multibyte text if HAVE_MULTILINGUAL_MENU
138 isn't defined. The use of HAVE_MULTILINGUAL_MENU could probably be
139 confined to an extended version of this with sections of code below
140 using it unconditionally. */
142 /* gtk just uses utf-8. */
143 # define ENCODE_MENU_STRING(str) ENCODE_UTF_8 (str)
144 #elif defined HAVE_X_I18N
145 # define ENCODE_MENU_STRING(str) ENCODE_SYSTEM (str)
147 # define ENCODE_MENU_STRING(str) string_make_unibyte (str)
150 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
151 Lisp_Object
, Lisp_Object
, Lisp_Object
,
152 Lisp_Object
, Lisp_Object
));
153 static int update_frame_menubar
P_ ((struct frame
*));
154 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
155 Lisp_Object
, char **));
156 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
157 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
159 static void list_of_panes
P_ ((Lisp_Object
));
160 static void list_of_items
P_ ((Lisp_Object
));
163 /* This holds a Lisp vector that holds the results of decoding
164 the keymaps or alist-of-alists that specify a menu.
166 It describes the panes and items within the panes.
168 Each pane is described by 3 elements in the vector:
169 t, the pane name, the pane's prefix key.
170 Then follow the pane's items, with 5 elements per item:
171 the item string, the enable flag, the item's value,
172 the definition, and the equivalent keyboard key's description string.
174 In some cases, multiple levels of menus may be described.
175 A single vector slot containing nil indicates the start of a submenu.
176 A single vector slot containing lambda indicates the end of a submenu.
177 The submenu follows a menu item which is the way to reach the submenu.
179 A single vector slot containing quote indicates that the
180 following items should appear on the right of a dialog box.
182 Using a Lisp vector to hold this information while we decode it
183 takes care of protecting all the data from GC. */
185 #define MENU_ITEMS_PANE_NAME 1
186 #define MENU_ITEMS_PANE_PREFIX 2
187 #define MENU_ITEMS_PANE_LENGTH 3
191 MENU_ITEMS_ITEM_NAME
= 0,
192 MENU_ITEMS_ITEM_ENABLE
,
193 MENU_ITEMS_ITEM_VALUE
,
194 MENU_ITEMS_ITEM_EQUIV_KEY
,
195 MENU_ITEMS_ITEM_DEFINITION
,
196 MENU_ITEMS_ITEM_TYPE
,
197 MENU_ITEMS_ITEM_SELECTED
,
198 MENU_ITEMS_ITEM_HELP
,
199 MENU_ITEMS_ITEM_LENGTH
202 static Lisp_Object menu_items
;
204 /* If non-nil, means that the global vars defined here are already in use.
205 Used to detect cases where we try to re-enter this non-reentrant code. */
206 static Lisp_Object menu_items_inuse
;
208 /* Number of slots currently allocated in menu_items. */
209 static int menu_items_allocated
;
211 /* This is the index in menu_items of the first empty slot. */
212 static int menu_items_used
;
214 /* The number of panes currently recorded in menu_items,
215 excluding those within submenus. */
216 static int menu_items_n_panes
;
218 /* Current depth within submenus. */
219 static int menu_items_submenu_depth
;
221 /* Flag which when set indicates a dialog or menu has been posted by
222 Xt on behalf of one of the widget sets. */
223 static int popup_activated_flag
;
225 static int next_menubar_widget_id
;
227 /* This is set nonzero after the user activates the menu bar, and set
228 to zero again after the menu bars are redisplayed by prepare_menu_bar.
229 While it is nonzero, all calls to set_frame_menubar go deep.
231 I don't understand why this is needed, but it does seem to be
232 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
234 int pending_menu_activation
;
238 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
240 static struct frame
*
241 menubar_id_to_frame (id
)
244 Lisp_Object tail
, frame
;
247 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
250 if (!GC_FRAMEP (frame
))
253 if (!FRAME_WINDOW_P (f
))
255 if (f
->output_data
.x
->id
== id
)
263 /* Initialize the menu_items structure if we haven't already done so.
264 Also mark it as currently empty. */
269 if (!NILP (menu_items_inuse
))
270 error ("Trying to use a menu from within a menu-entry");
272 if (NILP (menu_items
))
274 menu_items_allocated
= 60;
275 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
278 menu_items_inuse
= Qt
;
280 menu_items_n_panes
= 0;
281 menu_items_submenu_depth
= 0;
284 /* Call at the end of generating the data in menu_items. */
292 unuse_menu_items (dummy
)
295 return menu_items_inuse
= Qnil
;
298 /* Call when finished using the data for the current menu
302 discard_menu_items ()
304 /* Free the structure if it is especially large.
305 Otherwise, hold on to it, to save time. */
306 if (menu_items_allocated
> 200)
309 menu_items_allocated
= 0;
311 xassert (NILP (menu_items_inuse
));
314 /* This undoes save_menu_items, and it is called by the specpdl unwind
318 restore_menu_items (saved
)
321 menu_items
= XCAR (saved
);
322 menu_items_inuse
= (! NILP (menu_items
) ? Qt
: Qnil
);
323 menu_items_allocated
= (VECTORP (menu_items
) ? ASIZE (menu_items
) : 0);
324 saved
= XCDR (saved
);
325 menu_items_used
= XINT (XCAR (saved
));
326 saved
= XCDR (saved
);
327 menu_items_n_panes
= XINT (XCAR (saved
));
328 saved
= XCDR (saved
);
329 menu_items_submenu_depth
= XINT (XCAR (saved
));
333 /* Push the whole state of menu_items processing onto the specpdl.
334 It will be restored when the specpdl is unwound. */
339 Lisp_Object saved
= list4 (!NILP (menu_items_inuse
) ? menu_items
: Qnil
,
340 make_number (menu_items_used
),
341 make_number (menu_items_n_panes
),
342 make_number (menu_items_submenu_depth
));
343 record_unwind_protect (restore_menu_items
, saved
);
344 menu_items_inuse
= Qnil
;
348 /* Make the menu_items vector twice as large. */
354 int old_size
= menu_items_allocated
;
357 menu_items_allocated
*= 2;
359 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
360 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
361 old_size
* sizeof (Lisp_Object
));
364 /* Begin a submenu. */
367 push_submenu_start ()
369 if (menu_items_used
+ 1 > menu_items_allocated
)
372 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
373 menu_items_submenu_depth
++;
381 if (menu_items_used
+ 1 > menu_items_allocated
)
384 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
385 menu_items_submenu_depth
--;
388 /* Indicate boundary between left and right. */
391 push_left_right_boundary ()
393 if (menu_items_used
+ 1 > menu_items_allocated
)
396 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
399 /* Start a new menu pane in menu_items.
400 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
403 push_menu_pane (name
, prefix_vec
)
404 Lisp_Object name
, prefix_vec
;
406 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
409 if (menu_items_submenu_depth
== 0)
410 menu_items_n_panes
++;
411 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
412 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
413 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
416 /* Push one menu item into the current pane. NAME is the string to
417 display. ENABLE if non-nil means this item can be selected. KEY
418 is the key generated by choosing this item, or nil if this item
419 doesn't really have a definition. DEF is the definition of this
420 item. EQUIV is the textual description of the keyboard equivalent
421 for this item (or nil if none). TYPE is the type of this menu
422 item, one of nil, `toggle' or `radio'. */
425 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
426 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
428 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
431 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
432 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
433 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
434 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
435 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
436 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
437 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
438 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
441 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
442 and generate menu panes for them in menu_items.
443 If NOTREAL is nonzero,
444 don't bother really computing whether an item is enabled. */
447 keymap_panes (keymaps
, nmaps
, notreal
)
448 Lisp_Object
*keymaps
;
456 /* Loop over the given keymaps, making a pane for each map.
457 But don't make a pane that is empty--ignore that map instead.
458 P is the number of panes we have made so far. */
459 for (mapno
= 0; mapno
< nmaps
; mapno
++)
460 single_keymap_panes (keymaps
[mapno
],
461 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
463 finish_menu_items ();
466 /* Args passed between single_keymap_panes and single_menu_item. */
469 Lisp_Object pending_maps
;
470 int maxdepth
, notreal
;
474 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
477 /* This is a recursive subroutine of keymap_panes.
478 It handles one keymap, KEYMAP.
479 The other arguments are passed along
480 or point to local variables of the previous function.
481 If NOTREAL is nonzero, only check for equivalent key bindings, don't
482 evaluate expressions in menu items and don't make any menu.
484 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
487 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
489 Lisp_Object pane_name
;
497 skp
.pending_maps
= Qnil
;
498 skp
.maxdepth
= maxdepth
;
499 skp
.notreal
= notreal
;
505 push_menu_pane (pane_name
, prefix
);
508 /* Remember index for first item in this pane so we can go back and
509 add a prefix when (if) we see the first button. After that, notbuttons
510 is set to 0, to mark that we have seen a button and all non button
511 items need a prefix. */
512 skp
.notbuttons
= menu_items_used
;
515 GCPRO1 (skp
.pending_maps
);
516 map_keymap (keymap
, single_menu_item
, Qnil
, &skp
, 1);
519 /* Process now any submenus which want to be panes at this level. */
520 while (CONSP (skp
.pending_maps
))
522 Lisp_Object elt
, eltcdr
, string
;
523 elt
= XCAR (skp
.pending_maps
);
525 string
= XCAR (eltcdr
);
526 /* We no longer discard the @ from the beginning of the string here.
527 Instead, we do this in xmenu_show. */
528 single_keymap_panes (Fcar (elt
), string
,
529 XCDR (eltcdr
), notreal
, maxdepth
- 1);
530 skp
.pending_maps
= XCDR (skp
.pending_maps
);
534 /* This is a subroutine of single_keymap_panes that handles one
536 KEY is a key in a keymap and ITEM is its binding.
537 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
539 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
540 evaluate expressions in menu items and don't make any menu.
541 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
542 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
543 buttons. It keeps track of if we have seen a button in this menu or
547 single_menu_item (key
, item
, dummy
, skp_v
)
548 Lisp_Object key
, item
, dummy
;
551 Lisp_Object map
, item_string
, enabled
;
552 struct gcpro gcpro1
, gcpro2
;
554 struct skp
*skp
= skp_v
;
556 /* Parse the menu item and leave the result in item_properties. */
558 res
= parse_menu_item (item
, skp
->notreal
, 0);
561 return; /* Not a menu item. */
563 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
567 /* We don't want to make a menu, just traverse the keymaps to
568 precompute equivalent key bindings. */
570 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
574 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
575 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
577 if (!NILP (map
) && SREF (item_string
, 0) == '@')
580 /* An enabled separate pane. Remember this to handle it later. */
581 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
587 /* Simulate radio buttons and toggle boxes by putting a prefix in
590 Lisp_Object prefix
= Qnil
;
591 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
595 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
598 /* The first button. Line up previous items in this menu. */
600 int index
= skp
->notbuttons
; /* Index for first item this menu. */
603 while (index
< menu_items_used
)
606 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
610 submenu
++; /* Skip sub menu. */
612 else if (EQ (tem
, Qlambda
))
615 submenu
--; /* End sub menu. */
617 else if (EQ (tem
, Qt
))
618 index
+= 3; /* Skip new pane marker. */
619 else if (EQ (tem
, Qquote
))
620 index
++; /* Skip a left, right divider. */
623 if (!submenu
&& SREF (tem
, 0) != '\0'
624 && SREF (tem
, 0) != '-')
625 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
626 = concat2 (build_string (" "), tem
);
627 index
+= MENU_ITEMS_ITEM_LENGTH
;
633 /* Calculate prefix, if any, for this item. */
634 if (EQ (type
, QCtoggle
))
635 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
636 else if (EQ (type
, QCradio
))
637 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
639 /* Not a button. If we have earlier buttons, then we need a prefix. */
640 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
641 && SREF (item_string
, 0) != '-')
642 prefix
= build_string (" ");
645 item_string
= concat2 (prefix
, item_string
);
647 #endif /* not HAVE_BOXES */
649 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
651 /* Indicate visually that this is a submenu. */
652 item_string
= concat2 (item_string
, build_string (" >"));
655 push_menu_item (item_string
, enabled
, key
,
656 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
657 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
658 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
659 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
660 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
662 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
663 /* Display a submenu using the toolkit. */
664 if (! (NILP (map
) || NILP (enabled
)))
666 push_submenu_start ();
667 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
673 /* Push all the panes and items of a menu described by the
674 alist-of-alists MENU.
675 This handles old-fashioned calls to x-popup-menu. */
685 for (tail
= menu
; CONSP (tail
); tail
= XCDR (tail
))
687 Lisp_Object elt
, pane_name
, pane_data
;
689 pane_name
= Fcar (elt
);
690 CHECK_STRING (pane_name
);
691 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
692 pane_data
= Fcdr (elt
);
693 CHECK_CONS (pane_data
);
694 list_of_items (pane_data
);
697 finish_menu_items ();
700 /* Push the items in a single pane defined by the alist PANE. */
706 Lisp_Object tail
, item
, item1
;
708 for (tail
= pane
; CONSP (tail
); tail
= XCDR (tail
))
712 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
713 Qnil
, Qnil
, Qnil
, Qnil
);
714 else if (CONSP (item
))
717 CHECK_STRING (item1
);
718 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, XCDR (item
),
719 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
722 push_left_right_boundary ();
727 #ifdef HAVE_X_WINDOWS
728 /* Return the mouse position in *X and *Y. The coordinates are window
729 relative for the edit window in frame F.
730 This is for Fx_popup_menu. The mouse_position_hook can not
731 be used for X, as it returns window relative coordinates
732 for the window where the mouse is in. This could be the menu bar,
733 the scroll bar or the edit window. Fx_popup_menu needs to be
734 sure it is the edit window. */
736 mouse_position_for_popup (f
, x
, y
)
741 Window root
, dummy_window
;
746 XQueryPointer (FRAME_X_DISPLAY (f
),
747 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
749 /* The root window which contains the pointer. */
752 /* Window pointer is on, not used */
755 /* The position on that root window. */
758 /* x/y in dummy_window coordinates, not used. */
761 /* Modifier keys and pointer buttons, about which
763 (unsigned int *) &dummy
);
767 /* xmenu_show expects window coordinates, not root window
768 coordinates. Translate. */
769 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
770 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
773 #endif /* HAVE_X_WINDOWS */
775 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
776 doc
: /* Pop up a deck-of-cards menu and return user's selection.
777 POSITION is a position specification. This is either a mouse button event
778 or a list ((XOFFSET YOFFSET) WINDOW)
779 where XOFFSET and YOFFSET are positions in pixels from the top left
780 corner of WINDOW. (WINDOW may be a window or a frame object.)
781 This controls the position of the top left of the menu as a whole.
782 If POSITION is t, it means to use the current mouse position.
784 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
785 The menu items come from key bindings that have a menu string as well as
786 a definition; actually, the "definition" in such a key binding looks like
787 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
788 the keymap as a top-level element.
790 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
791 Otherwise, REAL-DEFINITION should be a valid key binding definition.
793 You can also use a list of keymaps as MENU.
794 Then each keymap makes a separate pane.
796 When MENU is a keymap or a list of keymaps, the return value is the
797 list of events corresponding to the user's choice. Note that
798 `x-popup-menu' does not actually execute the command bound to that
801 Alternatively, you can specify a menu of multiple panes
802 with a list of the form (TITLE PANE1 PANE2...),
803 where each pane is a list of form (TITLE ITEM1 ITEM2...).
804 Each ITEM is normally a cons cell (STRING . VALUE);
805 but a string can appear as an item--that makes a nonselectable line
807 With this form of menu, the return value is VALUE from the chosen item.
809 If POSITION is nil, don't display the menu at all, just precalculate the
810 cached information about equivalent key sequences.
812 If the user gets rid of the menu without making a valid choice, for
813 instance by clicking the mouse away from a valid choice or by typing
814 keyboard input, then this normally results in a quit and
815 `x-popup-menu' does not return. But if POSITION is a mouse button
816 event (indicating that the user invoked the menu with the mouse) then
817 no quit occurs and `x-popup-menu' returns nil. */)
819 Lisp_Object position
, menu
;
821 Lisp_Object keymap
, tem
;
822 int xpos
= 0, ypos
= 0;
824 char *error_name
= NULL
;
825 Lisp_Object selection
= Qnil
;
827 Lisp_Object x
, y
, window
;
830 int specpdl_count
= SPECPDL_INDEX ();
834 if (! NILP (position
))
836 int get_current_pos_p
= 0;
839 /* Decode the first argument: find the window and the coordinates. */
840 if (EQ (position
, Qt
)
841 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
842 || EQ (XCAR (position
), Qtool_bar
))))
844 get_current_pos_p
= 1;
848 tem
= Fcar (position
);
851 window
= Fcar (Fcdr (position
));
853 y
= Fcar (XCDR (tem
));
858 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
859 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
860 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
865 /* If a click happens in an external tool bar or a detached
866 tool bar, x and y is NIL. In that case, use the current
867 mouse position. This happens for the help button in the
868 tool bar. Ideally popup-menu should pass NIL to
869 this function, but it doesn't. */
870 if (NILP (x
) && NILP (y
))
871 get_current_pos_p
= 1;
874 if (get_current_pos_p
)
876 /* Use the mouse's current position. */
877 FRAME_PTR new_f
= SELECTED_FRAME ();
878 #ifdef HAVE_X_WINDOWS
879 /* Can't use mouse_position_hook for X since it returns
880 coordinates relative to the window the mouse is in,
881 we need coordinates relative to the edit widget always. */
886 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
887 /* cur_x/y may be negative, so use make_number. */
888 x
= make_number (cur_x
);
889 y
= make_number (cur_y
);
892 #else /* not HAVE_X_WINDOWS */
893 Lisp_Object bar_window
;
894 enum scroll_bar_part part
;
897 if (mouse_position_hook
)
898 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
899 &part
, &x
, &y
, &time
);
900 #endif /* not HAVE_X_WINDOWS */
903 XSETFRAME (window
, new_f
);
906 window
= selected_window
;
915 /* Decode where to put the menu. */
923 else if (WINDOWP (window
))
925 CHECK_LIVE_WINDOW (window
);
926 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
928 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
929 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
932 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
933 but I don't want to make one now. */
934 CHECK_WINDOW (window
);
939 XSETFRAME (Vmenu_updating_frame
, f
);
942 Vmenu_updating_frame
= Qnil
;
943 #endif /* HAVE_MENUS */
945 record_unwind_protect (unuse_menu_items
, Qnil
);
949 /* Decode the menu items from what was specified. */
951 keymap
= get_keymap (menu
, 0, 0);
954 /* We were given a keymap. Extract menu info from the keymap. */
957 /* Extract the detailed info to make one pane. */
958 keymap_panes (&menu
, 1, NILP (position
));
960 /* Search for a string appearing directly as an element of the keymap.
961 That string is the title of the menu. */
962 prompt
= Fkeymap_prompt (keymap
);
963 if (NILP (title
) && !NILP (prompt
))
966 /* Make that be the pane title of the first pane. */
967 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
968 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
972 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
974 /* We were given a list of keymaps. */
975 int nmaps
= XFASTINT (Flength (menu
));
977 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
982 /* The first keymap that has a prompt string
983 supplies the menu title. */
984 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
988 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
990 prompt
= Fkeymap_prompt (keymap
);
991 if (NILP (title
) && !NILP (prompt
))
995 /* Extract the detailed info to make one pane. */
996 keymap_panes (maps
, nmaps
, NILP (position
));
998 /* Make the title be the pane title of the first pane. */
999 if (!NILP (title
) && menu_items_n_panes
>= 0)
1000 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
1006 /* We were given an old-fashioned menu. */
1007 title
= Fcar (menu
);
1008 CHECK_STRING (title
);
1010 list_of_panes (Fcdr (menu
));
1015 unbind_to (specpdl_count
, Qnil
);
1017 if (NILP (position
))
1019 discard_menu_items ();
1025 /* Display them in a menu. */
1028 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
1029 keymaps
, title
, &error_name
);
1032 discard_menu_items ();
1035 #endif /* HAVE_MENUS */
1037 if (error_name
) error (error_name
);
1043 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
1044 doc
: /* Pop up a dialog box and return user's selection.
1045 POSITION specifies which frame to use.
1046 This is normally a mouse button event or a window or frame.
1047 If POSITION is t, it means to use the frame the mouse is on.
1048 The dialog box appears in the middle of the specified frame.
1050 CONTENTS specifies the alternatives to display in the dialog box.
1051 It is a list of the form (DIALOG ITEM1 ITEM2...).
1052 Each ITEM is a cons cell (STRING . VALUE).
1053 The return value is VALUE from the chosen item.
1055 An ITEM may also be just a string--that makes a nonselectable item.
1056 An ITEM may also be nil--that means to put all preceding items
1057 on the left of the dialog box and all following items on the right.
1058 \(By default, approximately half appear on each side.)
1060 If HEADER is non-nil, the frame title for the box is "Information",
1061 otherwise it is "Question".
1063 If the user gets rid of the dialog box without making a valid choice,
1064 for instance using the window manager, then this produces a quit and
1065 `x-popup-dialog' does not return. */)
1066 (position
, contents
, header
)
1067 Lisp_Object position
, contents
, header
;
1074 /* Decode the first argument: find the window or frame to use. */
1075 if (EQ (position
, Qt
)
1076 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1077 || EQ (XCAR (position
), Qtool_bar
))))
1079 #if 0 /* Using the frame the mouse is on may not be right. */
1080 /* Use the mouse's current position. */
1081 FRAME_PTR new_f
= SELECTED_FRAME ();
1082 Lisp_Object bar_window
;
1083 enum scroll_bar_part part
;
1087 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1090 XSETFRAME (window
, new_f
);
1092 window
= selected_window
;
1094 window
= selected_window
;
1096 else if (CONSP (position
))
1099 tem
= Fcar (position
);
1101 window
= Fcar (Fcdr (position
));
1104 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1105 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1108 else if (WINDOWP (position
) || FRAMEP (position
))
1113 /* Decode where to put the menu. */
1115 if (FRAMEP (window
))
1116 f
= XFRAME (window
);
1117 else if (WINDOWP (window
))
1119 CHECK_LIVE_WINDOW (window
);
1120 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1123 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1124 but I don't want to make one now. */
1125 CHECK_WINDOW (window
);
1127 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1128 /* Display a menu with these alternatives
1129 in the middle of frame F. */
1131 Lisp_Object x
, y
, frame
, newpos
;
1132 XSETFRAME (frame
, f
);
1133 XSETINT (x
, x_pixel_width (f
) / 2);
1134 XSETINT (y
, x_pixel_height (f
) / 2);
1135 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1137 return Fx_popup_menu (newpos
,
1138 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1144 Lisp_Object selection
;
1145 int specpdl_count
= SPECPDL_INDEX ();
1147 /* Decode the dialog items from what was specified. */
1148 title
= Fcar (contents
);
1149 CHECK_STRING (title
);
1150 record_unwind_protect (unuse_menu_items
, Qnil
);
1152 if (NILP (Fcar (Fcdr (contents
))))
1153 /* No buttons specified, add an "Ok" button so users can pop down
1154 the dialog. Also, the lesstif/motif version crashes if there are
1156 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1158 list_of_panes (Fcons (contents
, Qnil
));
1160 /* Display them in a dialog box. */
1162 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
1165 unbind_to (specpdl_count
, Qnil
);
1166 discard_menu_items ();
1168 if (error_name
) error (error_name
);
1177 /* Set menu_items_inuse so no other popup menu or dialog is created. */
1180 x_menu_set_in_use (in_use
)
1183 menu_items_inuse
= in_use
? Qt
: Qnil
;
1184 popup_activated_flag
= in_use
;
1185 #ifdef USE_X_TOOLKIT
1186 if (popup_activated_flag
)
1187 x_activate_timeout_atimer ();
1191 /* Wait for an X event to arrive or for a timer to expire. */
1194 x_menu_wait_for_event (void *data
)
1196 extern EMACS_TIME timer_check
P_ ((int));
1198 /* Another way to do this is to register a timer callback, that can be
1199 done in GTK and Xt. But we have to do it like this when using only X
1200 anyway, and with callbacks we would have three variants for timer handling
1201 instead of the small ifdefs below. */
1204 #ifdef USE_X_TOOLKIT
1205 ! XtAppPending (Xt_app_con
)
1206 #elif defined USE_GTK
1207 ! gtk_events_pending ()
1209 ! XPending ((Display
*) data
)
1213 EMACS_TIME next_time
= timer_check (1);
1214 long secs
= EMACS_SECS (next_time
);
1215 long usecs
= EMACS_USECS (next_time
);
1216 SELECT_TYPE read_fds
;
1217 struct x_display_info
*dpyinfo
;
1220 FD_ZERO (&read_fds
);
1221 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1223 int fd
= ConnectionNumber (dpyinfo
->display
);
1224 FD_SET (fd
, &read_fds
);
1228 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1230 /* Sometimes timer_check returns -1 (no timers) even if there are
1231 timers. So do a timeout anyway. */
1232 EMACS_SET_SECS (next_time
, 1);
1233 EMACS_SET_USECS (next_time
, 0);
1236 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1239 #endif /* ! MSDOS */
1242 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1244 #ifdef USE_X_TOOLKIT
1246 /* Loop in Xt until the menu pulldown or dialog popup has been
1247 popped down (deactivated). This is used for x-popup-menu
1248 and x-popup-dialog; it is not used for the menu bar.
1250 NOTE: All calls to popup_get_selection should be protected
1251 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1254 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1255 XEvent
*initial_event
;
1256 struct x_display_info
*dpyinfo
;
1262 while (popup_activated_flag
)
1266 event
= *initial_event
;
1271 if (do_timers
) x_menu_wait_for_event (0);
1272 XtAppNextEvent (Xt_app_con
, &event
);
1275 /* Make sure we don't consider buttons grabbed after menu goes.
1276 And make sure to deactivate for any ButtonRelease,
1277 even if XtDispatchEvent doesn't do that. */
1278 if (event
.type
== ButtonRelease
1279 && dpyinfo
->display
== event
.xbutton
.display
)
1281 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1282 #ifdef USE_MOTIF /* Pretending that the event came from a
1283 Btn1Down seems the only way to convince Motif to
1284 activate its callbacks; setting the XmNmenuPost
1285 isn't working. --marcus@sysc.pdx.edu. */
1286 event
.xbutton
.button
= 1;
1287 /* Motif only pops down menus when no Ctrl, Alt or Mod
1288 key is pressed and the button is released. So reset key state
1289 so Motif thinks this is the case. */
1290 event
.xbutton
.state
= 0;
1293 /* Pop down on C-g and Escape. */
1294 else if (event
.type
== KeyPress
1295 && dpyinfo
->display
== event
.xbutton
.display
)
1297 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1299 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
1300 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
1301 popup_activated_flag
= 0;
1304 x_dispatch_event (&event
, event
.xany
.display
);
1308 DEFUN ("menu-bar-open", Fmenu_bar_open
, Smenu_bar_open
, 0, 1, "i",
1309 doc
: /* Start key navigation of the menu bar in FRAME.
1310 This initially opens the first menu bar item and you can then navigate with the
1311 arrow keys, select a menu entry with the return key or cancel with the
1312 escape key. If FRAME has no menu bar this function does nothing.
1314 If FRAME is nil or not given, use the selected frame. */)
1319 FRAME_PTR f
= check_x_frame (frame
);
1323 if (FRAME_EXTERNAL_MENU_BAR (f
))
1324 set_frame_menubar (f
, 0, 1);
1326 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
1332 x_catch_errors (FRAME_X_DISPLAY (f
));
1333 memset (&ev
, 0, sizeof ev
);
1334 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
1335 ev
.xbutton
.window
= XtWindow (menubar
);
1336 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1337 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
1338 ev
.xbutton
.button
= Button1
;
1339 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
1340 ev
.xbutton
.same_screen
= True
;
1347 XtSetArg (al
[0], XtNchildren
, &list
);
1348 XtSetArg (al
[1], XtNnumChildren
, &nr
);
1349 XtGetValues (menubar
, al
, 2);
1350 ev
.xbutton
.window
= XtWindow (list
[0]);
1354 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
1355 /* From-window, to-window. */
1356 ev
.xbutton
.window
, ev
.xbutton
.root
,
1358 /* From-position, to-position. */
1359 ev
.xbutton
.x
, ev
.xbutton
.y
,
1360 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
1364 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
1365 x_uncatch_errors ();
1369 ev
.type
= ButtonPress
;
1370 ev
.xbutton
.state
= 0;
1372 XtDispatchEvent (&ev
);
1373 ev
.xbutton
.type
= ButtonRelease
;
1374 ev
.xbutton
.state
= Button1Mask
;
1375 XtDispatchEvent (&ev
);
1383 #endif /* USE_X_TOOLKIT */
1387 DEFUN ("menu-bar-open", Fmenu_bar_open
, Smenu_bar_open
, 0, 1, "i",
1388 doc
: /* Start key navigation of the menu bar in FRAME.
1389 This initially opens the first menu bar item and you can then navigate with the
1390 arrow keys, select a menu entry with the return key or cancel with the
1391 escape key. If FRAME has no menu bar this function does nothing.
1393 If FRAME is nil or not given, use the selected frame. */)
1400 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
1404 f
= check_x_frame (frame
);
1406 if (FRAME_EXTERNAL_MENU_BAR (f
))
1407 set_frame_menubar (f
, 0, 1);
1409 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
1412 /* Activate the first menu. */
1413 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
1417 g_signal_emit_by_name (children
->data
, "activate_item");
1418 popup_activated_flag
= 1;
1419 g_list_free (children
);
1427 /* Loop util popup_activated_flag is set to zero in a callback.
1428 Used for popup menus and dialogs. */
1431 popup_widget_loop (do_timers
, widget
)
1435 ++popup_activated_flag
;
1437 /* Process events in the Gtk event loop until done. */
1438 while (popup_activated_flag
)
1440 if (do_timers
) x_menu_wait_for_event (0);
1441 gtk_main_iteration ();
1446 /* Activate the menu bar of frame F.
1447 This is called from keyboard.c when it gets the
1448 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1450 To activate the menu bar, we use the X button-press event
1451 that was saved in saved_menu_event.
1452 That makes the toolkit do its thing.
1454 But first we recompute the menu bar contents (the whole tree).
1456 The reason for saving the button event until here, instead of
1457 passing it to the toolkit right away, is that we can safely
1458 execute Lisp code. */
1461 x_activate_menubar (f
)
1464 if (!f
->output_data
.x
->saved_menu_event
->type
)
1468 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1469 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1473 set_frame_menubar (f
, 0, 1);
1476 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1477 f
->output_data
.x
->saved_menu_event
);
1478 popup_activated_flag
= 1;
1480 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1484 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1485 pending_menu_activation
= 1;
1488 /* Ignore this if we get it a second time. */
1489 f
->output_data
.x
->saved_menu_event
->type
= 0;
1492 /* This callback is invoked when the user selects a menubar cascade
1493 pushbutton, but before the pulldown menu is posted. */
1497 popup_activate_callback (widget
, id
, client_data
)
1500 XtPointer client_data
;
1502 popup_activated_flag
= 1;
1503 #ifdef USE_X_TOOLKIT
1504 x_activate_timeout_atimer ();
1509 /* This callback is invoked when a dialog or menu is finished being
1510 used and has been unposted. */
1514 popup_deactivate_callback (widget
, client_data
)
1516 gpointer client_data
;
1518 popup_activated_flag
= 0;
1522 popup_deactivate_callback (widget
, id
, client_data
)
1525 XtPointer client_data
;
1527 popup_activated_flag
= 0;
1532 /* Function that finds the frame for WIDGET and shows the HELP text
1534 F is the frame if known, or NULL if not known. */
1536 show_help_event (f
, widget
, help
)
1538 xt_or_gtk_widget widget
;
1545 XSETFRAME (frame
, f
);
1546 kbd_buffer_store_help_event (frame
, help
);
1550 #if 0 /* This code doesn't do anything useful. ++kfs */
1551 /* WIDGET is the popup menu. It's parent is the frame's
1552 widget. See which frame that is. */
1553 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1556 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1558 frame
= XCAR (tail
);
1559 if (GC_FRAMEP (frame
)
1560 && (f
= XFRAME (frame
),
1561 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1565 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1569 /* Callback called when menu items are highlighted/unhighlighted
1570 while moving the mouse over them. WIDGET is the menu bar or menu
1571 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1572 the data structure for the menu item, or null in case of
1577 menu_highlight_callback (widget
, call_data
)
1581 xg_menu_item_cb_data
*cb_data
;
1584 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1586 if (! cb_data
) return;
1588 help
= call_data
? cb_data
->help
: Qnil
;
1590 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1591 Don't show help for them, they won't appear before the
1592 popup is popped down. */
1593 if (popup_activated_flag
<= 1)
1594 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1598 menu_highlight_callback (widget
, id
, call_data
)
1606 widget_value
*wv
= (widget_value
*) call_data
;
1608 help
= wv
? wv
->help
: Qnil
;
1610 /* Determine the frame for the help event. */
1611 f
= menubar_id_to_frame (id
);
1613 show_help_event (f
, widget
, help
);
1617 /* Find the menu selection and store it in the keyboard buffer.
1618 F is the frame the menu is on.
1619 MENU_BAR_ITEMS_USED is the length of VECTOR.
1620 VECTOR is an array of menu events for the whole menu. */
1623 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1625 int menu_bar_items_used
;
1629 Lisp_Object prefix
, entry
;
1630 Lisp_Object
*subprefix_stack
;
1631 int submenu_depth
= 0;
1635 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1639 while (i
< menu_bar_items_used
)
1641 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1643 subprefix_stack
[submenu_depth
++] = prefix
;
1647 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1649 prefix
= subprefix_stack
[--submenu_depth
];
1652 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1654 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1655 i
+= MENU_ITEMS_PANE_LENGTH
;
1659 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1660 /* The EMACS_INT cast avoids a warning. There's no problem
1661 as long as pointers have enough bits to hold small integers. */
1662 if ((int) (EMACS_INT
) client_data
== i
)
1665 struct input_event buf
;
1669 XSETFRAME (frame
, f
);
1670 buf
.kind
= MENU_BAR_EVENT
;
1671 buf
.frame_or_window
= frame
;
1673 kbd_buffer_store_event (&buf
);
1675 for (j
= 0; j
< submenu_depth
; j
++)
1676 if (!NILP (subprefix_stack
[j
]))
1678 buf
.kind
= MENU_BAR_EVENT
;
1679 buf
.frame_or_window
= frame
;
1680 buf
.arg
= subprefix_stack
[j
];
1681 kbd_buffer_store_event (&buf
);
1686 buf
.kind
= MENU_BAR_EVENT
;
1687 buf
.frame_or_window
= frame
;
1689 kbd_buffer_store_event (&buf
);
1692 buf
.kind
= MENU_BAR_EVENT
;
1693 buf
.frame_or_window
= frame
;
1695 kbd_buffer_store_event (&buf
);
1699 i
+= MENU_ITEMS_ITEM_LENGTH
;
1706 /* Gtk calls callbacks just because we tell it what item should be
1707 selected in a radio group. If this variable is set to a non-zero
1708 value, we are creating menus and don't want callbacks right now.
1710 static int xg_crazy_callback_abort
;
1712 /* This callback is called from the menu bar pulldown menu
1713 when the user makes a selection.
1714 Figure out what the user chose
1715 and put the appropriate events into the keyboard buffer. */
1717 menubar_selection_callback (widget
, client_data
)
1719 gpointer client_data
;
1721 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1723 if (xg_crazy_callback_abort
)
1726 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1729 /* For a group of radio buttons, GTK calls the selection callback first
1730 for the item that was active before the selection and then for the one that
1731 is active after the selection. For C-h k this means we get the help on
1732 the deselected item and then the selected item is executed. Prevent that
1733 by ignoring the non-active item. */
1734 if (GTK_IS_RADIO_MENU_ITEM (widget
)
1735 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
1738 /* When a menu is popped down, X generates a focus event (i.e. focus
1739 goes back to the frame below the menu). Since GTK buffers events,
1740 we force it out here before the menu selection event. Otherwise
1741 sit-for will exit at once if the focus event follows the menu selection
1745 while (gtk_events_pending ())
1746 gtk_main_iteration ();
1749 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1750 cb_data
->cl_data
->menu_bar_items_used
,
1751 cb_data
->cl_data
->menu_bar_vector
,
1752 cb_data
->call_data
);
1755 #else /* not USE_GTK */
1757 /* This callback is called from the menu bar pulldown menu
1758 when the user makes a selection.
1759 Figure out what the user chose
1760 and put the appropriate events into the keyboard buffer. */
1762 menubar_selection_callback (widget
, id
, client_data
)
1765 XtPointer client_data
;
1769 f
= menubar_id_to_frame (id
);
1772 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1773 f
->menu_bar_vector
, client_data
);
1775 #endif /* not USE_GTK */
1777 /* Allocate a widget_value, blocking input. */
1780 xmalloc_widget_value ()
1782 widget_value
*value
;
1785 value
= malloc_widget_value ();
1791 /* This recursively calls free_widget_value on the tree of widgets.
1792 It must free all data that was malloc'ed for these widget_values.
1793 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1794 must be left alone. */
1797 free_menubar_widget_value_tree (wv
)
1802 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1804 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1806 free_menubar_widget_value_tree (wv
->contents
);
1807 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1811 free_menubar_widget_value_tree (wv
->next
);
1812 wv
->next
= (widget_value
*) 0xDEADBEEF;
1815 free_widget_value (wv
);
1819 /* Set up data in menu_items for a menu bar item
1820 whose event type is ITEM_KEY (with string ITEM_NAME)
1821 and whose contents come from the list of keymaps MAPS. */
1824 parse_single_submenu (item_key
, item_name
, maps
)
1825 Lisp_Object item_key
, item_name
, maps
;
1829 Lisp_Object
*mapvec
;
1831 int top_level_items
= 0;
1833 length
= Flength (maps
);
1834 len
= XINT (length
);
1836 /* Convert the list MAPS into a vector MAPVEC. */
1837 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1838 for (i
= 0; i
< len
; i
++)
1840 mapvec
[i
] = Fcar (maps
);
1844 /* Loop over the given keymaps, making a pane for each map.
1845 But don't make a pane that is empty--ignore that map instead. */
1846 for (i
= 0; i
< len
; i
++)
1848 if (!KEYMAPP (mapvec
[i
]))
1850 /* Here we have a command at top level in the menu bar
1851 as opposed to a submenu. */
1852 top_level_items
= 1;
1853 push_menu_pane (Qnil
, Qnil
);
1854 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1855 Qnil
, Qnil
, Qnil
, Qnil
);
1860 prompt
= Fkeymap_prompt (mapvec
[i
]);
1861 single_keymap_panes (mapvec
[i
],
1862 !NILP (prompt
) ? prompt
: item_name
,
1867 return top_level_items
;
1870 /* Create a tree of widget_value objects
1871 representing the panes and items
1872 in menu_items starting at index START, up to index END. */
1874 static widget_value
*
1875 digest_single_submenu (start
, end
, top_level_items
)
1876 int start
, end
, top_level_items
;
1878 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1880 int submenu_depth
= 0;
1881 widget_value
**submenu_stack
;
1885 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1886 wv
= xmalloc_widget_value ();
1890 wv
->button_type
= BUTTON_TYPE_NONE
;
1896 /* Loop over all panes and items made by the preceding call
1897 to parse_single_submenu and construct a tree of widget_value objects.
1898 Ignore the panes and items used by previous calls to
1899 digest_single_submenu, even though those are also in menu_items. */
1903 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1905 submenu_stack
[submenu_depth
++] = save_wv
;
1910 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1913 save_wv
= submenu_stack
[--submenu_depth
];
1916 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1917 && submenu_depth
!= 0)
1918 i
+= MENU_ITEMS_PANE_LENGTH
;
1919 /* Ignore a nil in the item list.
1920 It's meaningful only for dialog boxes. */
1921 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1923 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1925 /* Create a new pane. */
1926 Lisp_Object pane_name
, prefix
;
1931 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1932 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1934 #ifndef HAVE_MULTILINGUAL_MENU
1935 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1937 pane_name
= ENCODE_MENU_STRING (pane_name
);
1938 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1941 pane_string
= (NILP (pane_name
)
1942 ? "" : (char *) SDATA (pane_name
));
1943 /* If there is just one top-level pane, put all its items directly
1944 under the top-level menu. */
1945 if (menu_items_n_panes
== 1)
1948 /* If the pane has a meaningful name,
1949 make the pane a top-level menu item
1950 with its items as a submenu beneath it. */
1951 if (strcmp (pane_string
, ""))
1953 wv
= xmalloc_widget_value ();
1957 first_wv
->contents
= wv
;
1958 wv
->lname
= pane_name
;
1959 /* Set value to 1 so update_submenu_strings can handle '@' */
1960 wv
->value
= (char *)1;
1962 wv
->button_type
= BUTTON_TYPE_NONE
;
1970 i
+= MENU_ITEMS_PANE_LENGTH
;
1974 /* Create a new item within current pane. */
1975 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1978 /* All items should be contained in panes. */
1979 if (panes_seen
== 0)
1982 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1983 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1984 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1985 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1986 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1987 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1988 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1990 #ifndef HAVE_MULTILINGUAL_MENU
1991 if (STRING_MULTIBYTE (item_name
))
1993 item_name
= ENCODE_MENU_STRING (item_name
);
1994 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1997 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1999 descrip
= ENCODE_MENU_STRING (descrip
);
2000 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2002 #endif /* not HAVE_MULTILINGUAL_MENU */
2004 wv
= xmalloc_widget_value ();
2008 save_wv
->contents
= wv
;
2010 wv
->lname
= item_name
;
2011 if (!NILP (descrip
))
2014 /* The EMACS_INT cast avoids a warning. There's no problem
2015 as long as pointers have enough bits to hold small integers. */
2016 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
2017 wv
->enabled
= !NILP (enable
);
2020 wv
->button_type
= BUTTON_TYPE_NONE
;
2021 else if (EQ (type
, QCradio
))
2022 wv
->button_type
= BUTTON_TYPE_RADIO
;
2023 else if (EQ (type
, QCtoggle
))
2024 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2028 wv
->selected
= !NILP (selected
);
2029 if (! STRINGP (help
))
2036 i
+= MENU_ITEMS_ITEM_LENGTH
;
2040 /* If we have just one "menu item"
2041 that was originally a button, return it by itself. */
2042 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
2044 wv
= first_wv
->contents
;
2045 free_widget_value (first_wv
);
2052 /* Walk through the widget_value tree starting at FIRST_WV and update
2053 the char * pointers from the corresponding lisp values.
2054 We do this after building the whole tree, since GC may happen while the
2055 tree is constructed, and small strings are relocated. So we must wait
2056 until no GC can happen before storing pointers into lisp values. */
2058 update_submenu_strings (first_wv
)
2059 widget_value
*first_wv
;
2063 for (wv
= first_wv
; wv
; wv
= wv
->next
)
2065 if (STRINGP (wv
->lname
))
2067 wv
->name
= (char *) SDATA (wv
->lname
);
2069 /* Ignore the @ that means "separate pane".
2070 This is a kludge, but this isn't worth more time. */
2071 if (wv
->value
== (char *)1)
2073 if (wv
->name
[0] == '@')
2079 if (STRINGP (wv
->lkey
))
2080 wv
->key
= (char *) SDATA (wv
->lkey
);
2083 update_submenu_strings (wv
->contents
);
2088 /* Recompute all the widgets of frame F, when the menu bar has been
2089 changed. Value is non-zero if widgets were updated. */
2092 update_frame_menubar (f
)
2096 return xg_update_frame_menubar (f
);
2098 struct x_output
*x
= f
->output_data
.x
;
2101 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
2105 /* Save the size of the frame because the pane widget doesn't accept
2106 to resize itself. So force it. */
2107 columns
= FRAME_COLS (f
);
2108 rows
= FRAME_LINES (f
);
2110 /* Do the voodoo which means "I'm changing lots of things, don't try
2111 to refigure sizes until I'm done." */
2112 lw_refigure_widget (x
->column_widget
, False
);
2114 /* The order in which children are managed is the top to bottom
2115 order in which they are displayed in the paned window. First,
2116 remove the text-area widget. */
2117 XtUnmanageChild (x
->edit_widget
);
2119 /* Remove the menubar that is there now, and put up the menubar that
2121 XtManageChild (x
->menubar_widget
);
2122 XtMapWidget (x
->menubar_widget
);
2123 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
2125 /* Re-manage the text-area widget, and then thrash the sizes. */
2126 XtManageChild (x
->edit_widget
);
2127 lw_refigure_widget (x
->column_widget
, True
);
2129 /* Force the pane widget to resize itself with the right values. */
2130 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
2136 /* Set the contents of the menubar widgets of frame F.
2137 The argument FIRST_TIME is currently ignored;
2138 it is set the first time this is called, from initialize_frame_menubar. */
2141 set_frame_menubar (f
, first_time
, deep_p
)
2146 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
2147 #ifdef USE_X_TOOLKIT
2151 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
2153 int *submenu_start
, *submenu_end
;
2154 int *submenu_top_level_items
, *submenu_n_panes
;
2157 XSETFRAME (Vmenu_updating_frame
, f
);
2159 #ifdef USE_X_TOOLKIT
2160 if (f
->output_data
.x
->id
== 0)
2161 f
->output_data
.x
->id
= next_menubar_widget_id
++;
2162 id
= f
->output_data
.x
->id
;
2165 if (! menubar_widget
)
2167 else if (pending_menu_activation
&& !deep_p
)
2169 /* Make the first call for any given frame always go deep. */
2170 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
2173 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
2174 f
->output_data
.x
->saved_menu_event
->type
= 0;
2178 /* If we have detached menus, we must update deep so detached menus
2179 also gets updated. */
2180 deep_p
= deep_p
|| xg_have_tear_offs ();
2185 /* Make a widget-value tree representing the entire menu trees. */
2187 struct buffer
*prev
= current_buffer
;
2189 int specpdl_count
= SPECPDL_INDEX ();
2190 int previous_menu_items_used
= f
->menu_bar_items_used
;
2191 Lisp_Object
*previous_items
2192 = (Lisp_Object
*) alloca (previous_menu_items_used
2193 * sizeof (Lisp_Object
));
2195 /* If we are making a new widget, its contents are empty,
2196 do always reinitialize them. */
2197 if (! menubar_widget
)
2198 previous_menu_items_used
= 0;
2200 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
2201 specbind (Qinhibit_quit
, Qt
);
2202 /* Don't let the debugger step into this code
2203 because it is not reentrant. */
2204 specbind (Qdebug_on_next_call
, Qnil
);
2206 record_unwind_save_match_data ();
2207 if (NILP (Voverriding_local_map_menu_flag
))
2209 specbind (Qoverriding_terminal_local_map
, Qnil
);
2210 specbind (Qoverriding_local_map
, Qnil
);
2213 set_buffer_internal_1 (XBUFFER (buffer
));
2215 /* Run the Lucid hook. */
2216 safe_run_hooks (Qactivate_menubar_hook
);
2218 /* If it has changed current-menubar from previous value,
2219 really recompute the menubar from the value. */
2220 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2221 call0 (Qrecompute_lucid_menubar
);
2222 safe_run_hooks (Qmenu_bar_update_hook
);
2223 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2225 items
= FRAME_MENU_BAR_ITEMS (f
);
2227 /* Save the frame's previous menu bar contents data. */
2228 if (previous_menu_items_used
)
2229 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2230 previous_menu_items_used
* sizeof (Lisp_Object
));
2232 /* Fill in menu_items with the current menu bar contents.
2233 This can evaluate Lisp code. */
2236 menu_items
= f
->menu_bar_vector
;
2237 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2238 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2239 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2240 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2241 submenu_top_level_items
2242 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2244 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2246 Lisp_Object key
, string
, maps
;
2250 key
= XVECTOR (items
)->contents
[i
];
2251 string
= XVECTOR (items
)->contents
[i
+ 1];
2252 maps
= XVECTOR (items
)->contents
[i
+ 2];
2256 submenu_start
[i
] = menu_items_used
;
2258 menu_items_n_panes
= 0;
2259 submenu_top_level_items
[i
]
2260 = parse_single_submenu (key
, string
, maps
);
2261 submenu_n_panes
[i
] = menu_items_n_panes
;
2263 submenu_end
[i
] = menu_items_used
;
2266 finish_menu_items ();
2268 /* Convert menu_items into widget_value trees
2269 to display the menu. This cannot evaluate Lisp code. */
2271 wv
= xmalloc_widget_value ();
2272 wv
->name
= "menubar";
2275 wv
->button_type
= BUTTON_TYPE_NONE
;
2279 for (i
= 0; i
< last_i
; i
+= 4)
2281 menu_items_n_panes
= submenu_n_panes
[i
];
2282 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2283 submenu_top_level_items
[i
]);
2287 first_wv
->contents
= wv
;
2288 /* Don't set wv->name here; GC during the loop might relocate it. */
2290 wv
->button_type
= BUTTON_TYPE_NONE
;
2294 set_buffer_internal_1 (prev
);
2296 /* If there has been no change in the Lisp-level contents
2297 of the menu bar, skip redisplaying it. Just exit. */
2299 /* Compare the new menu items with the ones computed last time. */
2300 for (i
= 0; i
< previous_menu_items_used
; i
++)
2301 if (menu_items_used
== i
2302 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2304 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2306 /* The menu items have not changed. Don't bother updating
2307 the menus in any form, since it would be a no-op. */
2308 free_menubar_widget_value_tree (first_wv
);
2309 discard_menu_items ();
2310 unbind_to (specpdl_count
, Qnil
);
2314 /* The menu items are different, so store them in the frame. */
2315 f
->menu_bar_vector
= menu_items
;
2316 f
->menu_bar_items_used
= menu_items_used
;
2318 /* This calls restore_menu_items to restore menu_items, etc.,
2319 as they were outside. */
2320 unbind_to (specpdl_count
, Qnil
);
2322 /* Now GC cannot happen during the lifetime of the widget_value,
2323 so it's safe to store data from a Lisp_String. */
2324 wv
= first_wv
->contents
;
2325 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2328 string
= XVECTOR (items
)->contents
[i
+ 1];
2331 wv
->name
= (char *) SDATA (string
);
2332 update_submenu_strings (wv
->contents
);
2339 /* Make a widget-value tree containing
2340 just the top level menu bar strings. */
2342 wv
= xmalloc_widget_value ();
2343 wv
->name
= "menubar";
2346 wv
->button_type
= BUTTON_TYPE_NONE
;
2350 items
= FRAME_MENU_BAR_ITEMS (f
);
2351 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2355 string
= XVECTOR (items
)->contents
[i
+ 1];
2359 wv
= xmalloc_widget_value ();
2360 wv
->name
= (char *) SDATA (string
);
2363 wv
->button_type
= BUTTON_TYPE_NONE
;
2365 /* This prevents lwlib from assuming this
2366 menu item is really supposed to be empty. */
2367 /* The EMACS_INT cast avoids a warning.
2368 This value just has to be different from small integers. */
2369 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2374 first_wv
->contents
= wv
;
2378 /* Forget what we thought we knew about what is in the
2379 detailed contents of the menu bar menus.
2380 Changing the top level always destroys the contents. */
2381 f
->menu_bar_items_used
= 0;
2384 /* Create or update the menu bar widget. */
2389 xg_crazy_callback_abort
= 1;
2392 /* The fourth arg is DEEP_P, which says to consider the entire
2393 menu trees we supply, rather than just the menu bar item names. */
2394 xg_modify_menubar_widgets (menubar_widget
,
2398 G_CALLBACK (menubar_selection_callback
),
2399 G_CALLBACK (popup_deactivate_callback
),
2400 G_CALLBACK (menu_highlight_callback
));
2404 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2407 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2408 G_CALLBACK (menubar_selection_callback
),
2409 G_CALLBACK (popup_deactivate_callback
),
2410 G_CALLBACK (menu_highlight_callback
));
2412 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2416 #else /* not USE_GTK */
2419 /* Disable resizing (done for Motif!) */
2420 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2422 /* The third arg is DEEP_P, which says to consider the entire
2423 menu trees we supply, rather than just the menu bar item names. */
2424 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2426 /* Re-enable the edit widget to resize. */
2427 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2431 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
2432 XtTranslations override
= XtParseTranslationTable (menuOverride
);
2434 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2435 f
->output_data
.x
->column_widget
,
2437 popup_activate_callback
,
2438 menubar_selection_callback
,
2439 popup_deactivate_callback
,
2440 menu_highlight_callback
);
2441 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2443 /* Make menu pop down on C-g. */
2444 XtOverrideTranslations (menubar_widget
, override
);
2449 = (f
->output_data
.x
->menubar_widget
2450 ? (f
->output_data
.x
->menubar_widget
->core
.height
2451 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2454 #if 0 /* Experimentally, we now get the right results
2455 for -geometry -0-0 without this. 24 Aug 96, rms. */
2457 if (FRAME_EXTERNAL_MENU_BAR (f
))
2460 XtVaGetValues (f
->output_data
.x
->column_widget
,
2461 XtNinternalBorderWidth
, &ibw
, NULL
);
2462 menubar_size
+= ibw
;
2464 #endif /* USE_LUCID */
2467 f
->output_data
.x
->menubar_height
= menubar_size
;
2469 #endif /* not USE_GTK */
2471 free_menubar_widget_value_tree (first_wv
);
2472 update_frame_menubar (f
);
2475 xg_crazy_callback_abort
= 0;
2481 /* Called from Fx_create_frame to create the initial menubar of a frame
2482 before it is mapped, so that the window is mapped with the menubar already
2483 there instead of us tacking it on later and thrashing the window after it
2487 initialize_frame_menubar (f
)
2490 /* This function is called before the first chance to redisplay
2491 the frame. It has to be, so the frame will have the right size. */
2492 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2493 set_frame_menubar (f
, 1, 1);
2497 /* Get rid of the menu bar of frame F, and free its storage.
2498 This is used when deleting a frame, and when turning off the menu bar.
2499 For GTK this function is in gtkutil.c. */
2503 free_frame_menubar (f
)
2506 Widget menubar_widget
;
2508 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2510 f
->output_data
.x
->menubar_height
= 0;
2515 /* Removing the menu bar magically changes the shell widget's x
2516 and y position of (0, 0) which, when the menu bar is turned
2517 on again, leads to pull-down menuss appearing in strange
2518 positions near the upper-left corner of the display. This
2519 happens only with some window managers like twm and ctwm,
2520 but not with other like Motif's mwm or kwm, because the
2521 latter generate ConfigureNotify events when the menu bar
2522 is switched off, which fixes the shell position. */
2523 Position x0
, y0
, x1
, y1
;
2529 if (f
->output_data
.x
->widget
)
2530 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2533 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2534 f
->output_data
.x
->menubar_widget
= NULL
;
2537 if (f
->output_data
.x
->widget
)
2539 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2540 if (x1
== 0 && y1
== 0)
2541 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2548 #endif /* not USE_GTK */
2550 #endif /* USE_X_TOOLKIT || USE_GTK */
2552 /* xmenu_show actually displays a menu using the panes and items in menu_items
2553 and returns the value selected from it.
2554 There are two versions of xmenu_show, one for Xt and one for Xlib.
2555 Both assume input is blocked by the caller. */
2557 /* F is the frame the menu is for.
2558 X and Y are the frame-relative specified position,
2559 relative to the inside upper left corner of the frame F.
2560 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2561 KEYMAPS is 1 if this menu was specified with keymaps;
2562 in that case, we return a list containing the chosen item's value
2563 and perhaps also the pane's prefix.
2564 TITLE is the specified menu title.
2565 ERROR is a place to store an error message string in case of failure.
2566 (We return nil on failure, but the value doesn't actually matter.) */
2568 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2570 /* The item selected in the popup menu. */
2571 static Lisp_Object
*volatile menu_item_selection
;
2575 /* Used when position a popup menu. See menu_position_func and
2576 create_and_show_popup_menu below. */
2577 struct next_popup_x_y
2584 /* The menu position function to use if we are not putting a popup
2585 menu where the pointer is.
2586 MENU is the menu to pop up.
2587 X and Y shall on exit contain x/y where the menu shall pop up.
2588 PUSH_IN is not documented in the GTK manual.
2589 USER_DATA is any data passed in when calling gtk_menu_popup.
2590 Here it points to a struct next_popup_x_y where the coordinates
2591 to store in *X and *Y are as well as the frame for the popup.
2593 Here only X and Y are used. */
2595 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2602 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2604 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2605 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2610 /* Check if there is room for the menu. If not, adjust x/y so that
2611 the menu is fully visible. */
2612 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2613 if (data
->x
+ req
.width
> disp_width
)
2614 *x
-= data
->x
+ req
.width
- disp_width
;
2615 if (data
->y
+ req
.height
> disp_height
)
2616 *y
-= data
->y
+ req
.height
- disp_height
;
2620 popup_selection_callback (widget
, client_data
)
2622 gpointer client_data
;
2624 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2626 if (xg_crazy_callback_abort
) return;
2627 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2634 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
2636 popup_activated_flag
= 0;
2638 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
2643 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2645 menu_item_selection will be set to the selection. */
2647 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2649 widget_value
*first_wv
;
2656 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2657 struct next_popup_x_y popup_x_y
;
2658 int specpdl_count
= SPECPDL_INDEX ();
2660 xg_crazy_callback_abort
= 1;
2661 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2662 G_CALLBACK (popup_selection_callback
),
2663 G_CALLBACK (popup_deactivate_callback
),
2664 G_CALLBACK (menu_highlight_callback
));
2665 xg_crazy_callback_abort
= 0;
2669 /* Not invoked by a click. pop up at x/y. */
2670 pos_func
= menu_position_func
;
2672 /* Adjust coordinates to be root-window-relative. */
2673 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2674 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2680 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
2684 for (i
= 0; i
< 5; i
++)
2685 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2689 /* Display the menu. */
2690 gtk_widget_show_all (menu
);
2691 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2693 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2695 if (GTK_WIDGET_MAPPED (menu
))
2697 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2698 two. show_help_echo uses this to detect popup menus. */
2699 popup_activated_flag
= 1;
2700 /* Process events that apply to the menu. */
2701 popup_widget_loop (1, menu
);
2704 unbind_to (specpdl_count
, Qnil
);
2706 /* Must reset this manually because the button release event is not passed
2707 to Emacs event loop. */
2708 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2711 #else /* not USE_GTK */
2713 /* We need a unique id for each widget handled by the Lucid Widget
2716 For the main windows, and popup menus, we use this counter,
2717 which we increment each time after use. This starts from 1<<16.
2719 For menu bars, we use numbers starting at 0, counted in
2720 next_menubar_widget_id. */
2721 LWLIB_ID widget_id_tick
;
2724 popup_selection_callback (widget
, id
, client_data
)
2727 XtPointer client_data
;
2729 menu_item_selection
= (Lisp_Object
*) client_data
;
2732 /* ARG is the LWLIB ID of the dialog box, represented
2733 as a Lisp object as (HIGHPART . LOWPART). */
2739 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2740 | XINT (XCDR (arg
)));
2743 lw_destroy_all_widgets (id
);
2745 popup_activated_flag
= 0;
2750 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2752 menu_item_selection will be set to the selection. */
2754 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2756 widget_value
*first_wv
;
2764 XButtonPressedEvent dummy
;
2768 menu_id
= widget_id_tick
++;
2769 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2770 f
->output_data
.x
->widget
, 1, 0,
2771 popup_selection_callback
,
2772 popup_deactivate_callback
,
2773 menu_highlight_callback
);
2775 dummy
.type
= ButtonPress
;
2777 dummy
.send_event
= 0;
2778 dummy
.display
= FRAME_X_DISPLAY (f
);
2779 dummy
.time
= CurrentTime
;
2780 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2781 dummy
.window
= dummy
.root
;
2782 dummy
.subwindow
= dummy
.root
;
2786 /* Adjust coordinates to be root-window-relative. */
2787 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2788 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2795 for (i
= 0; i
< 5; i
++)
2796 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2799 /* Don't allow any geometry request from the user. */
2800 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2801 XtSetValues (menu
, av
, ac
);
2803 /* Display the menu. */
2804 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2805 popup_activated_flag
= 1;
2806 x_activate_timeout_atimer ();
2809 int fact
= 4 * sizeof (LWLIB_ID
);
2810 int specpdl_count
= SPECPDL_INDEX ();
2811 record_unwind_protect (pop_down_menu
,
2812 Fcons (make_number (menu_id
>> (fact
)),
2813 make_number (menu_id
& ~(-1 << (fact
)))));
2815 /* Process events that apply to the menu. */
2816 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
2818 unbind_to (specpdl_count
, Qnil
);
2822 #endif /* not USE_GTK */
2825 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2835 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2836 widget_value
**submenu_stack
2837 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2838 Lisp_Object
*subprefix_stack
2839 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2840 int submenu_depth
= 0;
2846 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2848 *error
= "Empty menu";
2852 /* Create a tree of widget_value objects
2853 representing the panes and their items. */
2854 wv
= xmalloc_widget_value ();
2858 wv
->button_type
= BUTTON_TYPE_NONE
;
2863 /* Loop over all panes and items, filling in the tree. */
2865 while (i
< menu_items_used
)
2867 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2869 submenu_stack
[submenu_depth
++] = save_wv
;
2875 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2878 save_wv
= submenu_stack
[--submenu_depth
];
2882 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2883 && submenu_depth
!= 0)
2884 i
+= MENU_ITEMS_PANE_LENGTH
;
2885 /* Ignore a nil in the item list.
2886 It's meaningful only for dialog boxes. */
2887 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2889 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2891 /* Create a new pane. */
2892 Lisp_Object pane_name
, prefix
;
2895 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2896 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2898 #ifndef HAVE_MULTILINGUAL_MENU
2899 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2901 pane_name
= ENCODE_MENU_STRING (pane_name
);
2902 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2905 pane_string
= (NILP (pane_name
)
2906 ? "" : (char *) SDATA (pane_name
));
2907 /* If there is just one top-level pane, put all its items directly
2908 under the top-level menu. */
2909 if (menu_items_n_panes
== 1)
2912 /* If the pane has a meaningful name,
2913 make the pane a top-level menu item
2914 with its items as a submenu beneath it. */
2915 if (!keymaps
&& strcmp (pane_string
, ""))
2917 wv
= xmalloc_widget_value ();
2921 first_wv
->contents
= wv
;
2922 wv
->name
= pane_string
;
2923 if (keymaps
&& !NILP (prefix
))
2927 wv
->button_type
= BUTTON_TYPE_NONE
;
2932 else if (first_pane
)
2938 i
+= MENU_ITEMS_PANE_LENGTH
;
2942 /* Create a new item within current pane. */
2943 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2944 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2945 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2946 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2947 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2948 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2949 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2950 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2952 #ifndef HAVE_MULTILINGUAL_MENU
2953 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2955 item_name
= ENCODE_MENU_STRING (item_name
);
2956 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2959 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2961 descrip
= ENCODE_MENU_STRING (descrip
);
2962 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2964 #endif /* not HAVE_MULTILINGUAL_MENU */
2966 wv
= xmalloc_widget_value ();
2970 save_wv
->contents
= wv
;
2971 wv
->name
= (char *) SDATA (item_name
);
2972 if (!NILP (descrip
))
2973 wv
->key
= (char *) SDATA (descrip
);
2975 /* If this item has a null value,
2976 make the call_data null so that it won't display a box
2977 when the mouse is on it. */
2979 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2980 wv
->enabled
= !NILP (enable
);
2983 wv
->button_type
= BUTTON_TYPE_NONE
;
2984 else if (EQ (type
, QCtoggle
))
2985 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2986 else if (EQ (type
, QCradio
))
2987 wv
->button_type
= BUTTON_TYPE_RADIO
;
2991 wv
->selected
= !NILP (selected
);
2993 if (! STRINGP (help
))
3000 i
+= MENU_ITEMS_ITEM_LENGTH
;
3004 /* Deal with the title, if it is non-nil. */
3007 widget_value
*wv_title
= xmalloc_widget_value ();
3008 widget_value
*wv_sep1
= xmalloc_widget_value ();
3009 widget_value
*wv_sep2
= xmalloc_widget_value ();
3011 wv_sep2
->name
= "--";
3012 wv_sep2
->next
= first_wv
->contents
;
3013 wv_sep2
->help
= Qnil
;
3015 wv_sep1
->name
= "--";
3016 wv_sep1
->next
= wv_sep2
;
3017 wv_sep1
->help
= Qnil
;
3019 #ifndef HAVE_MULTILINGUAL_MENU
3020 if (STRING_MULTIBYTE (title
))
3021 title
= ENCODE_MENU_STRING (title
);
3024 wv_title
->name
= (char *) SDATA (title
);
3025 wv_title
->enabled
= TRUE
;
3026 wv_title
->button_type
= BUTTON_TYPE_NONE
;
3027 wv_title
->next
= wv_sep1
;
3028 wv_title
->help
= Qnil
;
3029 first_wv
->contents
= wv_title
;
3032 /* No selection has been chosen yet. */
3033 menu_item_selection
= 0;
3035 /* Actually create and show the menu until popped down. */
3036 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
3038 /* Free the widget_value objects we used to specify the contents. */
3039 free_menubar_widget_value_tree (first_wv
);
3041 /* Find the selected item, and its pane, to return
3042 the proper value. */
3043 if (menu_item_selection
!= 0)
3045 Lisp_Object prefix
, entry
;
3047 prefix
= entry
= Qnil
;
3049 while (i
< menu_items_used
)
3051 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
3053 subprefix_stack
[submenu_depth
++] = prefix
;
3057 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
3059 prefix
= subprefix_stack
[--submenu_depth
];
3062 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3065 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3066 i
+= MENU_ITEMS_PANE_LENGTH
;
3068 /* Ignore a nil in the item list.
3069 It's meaningful only for dialog boxes. */
3070 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3075 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3076 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3082 entry
= Fcons (entry
, Qnil
);
3084 entry
= Fcons (prefix
, entry
);
3085 for (j
= submenu_depth
- 1; j
>= 0; j
--)
3086 if (!NILP (subprefix_stack
[j
]))
3087 entry
= Fcons (subprefix_stack
[j
], entry
);
3091 i
+= MENU_ITEMS_ITEM_LENGTH
;
3095 else if (!for_click
)
3096 /* Make "Cancel" equivalent to C-g. */
3097 Fsignal (Qquit
, Qnil
);
3104 dialog_selection_callback (widget
, client_data
)
3106 gpointer client_data
;
3108 /* The EMACS_INT cast avoids a warning. There's no problem
3109 as long as pointers have enough bits to hold small integers. */
3110 if ((int) (EMACS_INT
) client_data
!= -1)
3111 menu_item_selection
= (Lisp_Object
*) client_data
;
3113 popup_activated_flag
= 0;
3116 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
3118 menu_item_selection will be set to the selection. */
3120 create_and_show_dialog (f
, first_wv
)
3122 widget_value
*first_wv
;
3126 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
3127 G_CALLBACK (dialog_selection_callback
),
3128 G_CALLBACK (popup_deactivate_callback
),
3133 int specpdl_count
= SPECPDL_INDEX ();
3134 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
3136 /* Display the menu. */
3137 gtk_widget_show_all (menu
);
3139 /* Process events that apply to the menu. */
3140 popup_widget_loop (1, menu
);
3142 unbind_to (specpdl_count
, Qnil
);
3146 #else /* not USE_GTK */
3148 dialog_selection_callback (widget
, id
, client_data
)
3151 XtPointer client_data
;
3153 /* The EMACS_INT cast avoids a warning. There's no problem
3154 as long as pointers have enough bits to hold small integers. */
3155 if ((int) (EMACS_INT
) client_data
!= -1)
3156 menu_item_selection
= (Lisp_Object
*) client_data
;
3159 lw_destroy_all_widgets (id
);
3161 popup_activated_flag
= 0;
3165 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
3167 menu_item_selection will be set to the selection. */
3169 create_and_show_dialog (f
, first_wv
)
3171 widget_value
*first_wv
;
3175 dialog_id
= widget_id_tick
++;
3176 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
3177 f
->output_data
.x
->widget
, 1, 0,
3178 dialog_selection_callback
, 0, 0);
3179 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
3181 /* Display the dialog box. */
3182 lw_pop_up_all_widgets (dialog_id
);
3183 popup_activated_flag
= 1;
3184 x_activate_timeout_atimer ();
3186 /* Process events that apply to the dialog box.
3187 Also handle timers. */
3189 int count
= SPECPDL_INDEX ();
3190 int fact
= 4 * sizeof (LWLIB_ID
);
3192 /* xdialog_show_unwind is responsible for popping the dialog box down. */
3193 record_unwind_protect (pop_down_menu
,
3194 Fcons (make_number (dialog_id
>> (fact
)),
3195 make_number (dialog_id
& ~(-1 << (fact
)))));
3197 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
3200 unbind_to (count
, Qnil
);
3204 #endif /* not USE_GTK */
3206 static char * button_names
[] = {
3207 "button1", "button2", "button3", "button4", "button5",
3208 "button6", "button7", "button8", "button9", "button10" };
3211 xdialog_show (f
, keymaps
, title
, header
, error_name
)
3214 Lisp_Object title
, header
;
3217 int i
, nb_buttons
=0;
3218 char dialog_name
[6];
3220 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
3222 /* Number of elements seen so far, before boundary. */
3224 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
3225 int boundary_seen
= 0;
3229 if (menu_items_n_panes
> 1)
3231 *error_name
= "Multiple panes in dialog box";
3235 /* Create a tree of widget_value objects
3236 representing the text label and buttons. */
3238 Lisp_Object pane_name
, prefix
;
3240 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
3241 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
3242 pane_string
= (NILP (pane_name
)
3243 ? "" : (char *) SDATA (pane_name
));
3244 prev_wv
= xmalloc_widget_value ();
3245 prev_wv
->value
= pane_string
;
3246 if (keymaps
&& !NILP (prefix
))
3248 prev_wv
->enabled
= 1;
3249 prev_wv
->name
= "message";
3250 prev_wv
->help
= Qnil
;
3253 /* Loop over all panes and items, filling in the tree. */
3254 i
= MENU_ITEMS_PANE_LENGTH
;
3255 while (i
< menu_items_used
)
3258 /* Create a new item within current pane. */
3259 Lisp_Object item_name
, enable
, descrip
;
3260 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3261 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3263 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3265 if (NILP (item_name
))
3267 free_menubar_widget_value_tree (first_wv
);
3268 *error_name
= "Submenu in dialog items";
3271 if (EQ (item_name
, Qquote
))
3273 /* This is the boundary between left-side elts
3274 and right-side elts. Stop incrementing right_count. */
3279 if (nb_buttons
>= 9)
3281 free_menubar_widget_value_tree (first_wv
);
3282 *error_name
= "Too many dialog items";
3286 wv
= xmalloc_widget_value ();
3288 wv
->name
= (char *) button_names
[nb_buttons
];
3289 if (!NILP (descrip
))
3290 wv
->key
= (char *) SDATA (descrip
);
3291 wv
->value
= (char *) SDATA (item_name
);
3292 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3293 wv
->enabled
= !NILP (enable
);
3297 if (! boundary_seen
)
3301 i
+= MENU_ITEMS_ITEM_LENGTH
;
3304 /* If the boundary was not specified,
3305 by default put half on the left and half on the right. */
3306 if (! boundary_seen
)
3307 left_count
= nb_buttons
- nb_buttons
/ 2;
3309 wv
= xmalloc_widget_value ();
3310 wv
->name
= dialog_name
;
3313 /* Frame title: 'Q' = Question, 'I' = Information.
3314 Can also have 'E' = Error if, one day, we want
3315 a popup for errors. */
3317 dialog_name
[0] = 'Q';
3319 dialog_name
[0] = 'I';
3321 /* Dialog boxes use a really stupid name encoding
3322 which specifies how many buttons to use
3323 and how many buttons are on the right. */
3324 dialog_name
[1] = '0' + nb_buttons
;
3325 dialog_name
[2] = 'B';
3326 dialog_name
[3] = 'R';
3327 /* Number of buttons to put on the right. */
3328 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3330 wv
->contents
= first_wv
;
3334 /* No selection has been chosen yet. */
3335 menu_item_selection
= 0;
3337 /* Force a redisplay before showing the dialog. If a frame is created
3338 just before showing the dialog, its contents may not have been fully
3339 drawn, as this depends on timing of events from the X server. Redisplay
3340 is not done when a dialog is shown. If redisplay could be done in the
3341 X event loop (i.e. the X event loop does not run in a signal handler)
3342 this would not be needed. */
3345 /* Actually create and show the dialog. */
3346 create_and_show_dialog (f
, first_wv
);
3348 /* Free the widget_value objects we used to specify the contents. */
3349 free_menubar_widget_value_tree (first_wv
);
3351 /* Find the selected item, and its pane, to return
3352 the proper value. */
3353 if (menu_item_selection
!= 0)
3359 while (i
< menu_items_used
)
3363 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3366 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3367 i
+= MENU_ITEMS_PANE_LENGTH
;
3369 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3371 /* This is the boundary between left-side elts and
3378 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3379 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3383 entry
= Fcons (entry
, Qnil
);
3385 entry
= Fcons (prefix
, entry
);
3389 i
+= MENU_ITEMS_ITEM_LENGTH
;
3394 /* Make "Cancel" equivalent to C-g. */
3395 Fsignal (Qquit
, Qnil
);
3400 #else /* not USE_X_TOOLKIT && not USE_GTK */
3402 /* The frame of the last activated non-toolkit menu bar.
3403 Used to generate menu help events. */
3405 static struct frame
*menu_help_frame
;
3408 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3410 PANE is the pane number, and ITEM is the menu item number in
3411 the menu (currently not used).
3413 This cannot be done with generating a HELP_EVENT because
3414 XMenuActivate contains a loop that doesn't let Emacs process
3418 menu_help_callback (help_string
, pane
, item
)
3422 extern Lisp_Object Qmenu_item
;
3423 Lisp_Object
*first_item
;
3424 Lisp_Object pane_name
;
3425 Lisp_Object menu_object
;
3427 first_item
= XVECTOR (menu_items
)->contents
;
3428 if (EQ (first_item
[0], Qt
))
3429 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3430 else if (EQ (first_item
[0], Qquote
))
3431 /* This shouldn't happen, see xmenu_show. */
3432 pane_name
= empty_string
;
3434 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3436 /* (menu-item MENU-NAME PANE-NUMBER) */
3437 menu_object
= Fcons (Qmenu_item
,
3439 Fcons (make_number (pane
), Qnil
)));
3440 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3441 Qnil
, menu_object
, make_number (item
), 1);
3448 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
3449 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
3451 FRAME_PTR f
= p1
->pointer
;
3452 XMenu
*menu
= p2
->pointer
;
3456 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
3457 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
3459 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3461 #ifdef HAVE_X_WINDOWS
3462 /* Assume the mouse has moved out of the X window.
3463 If it has actually moved in, we will get an EnterNotify. */
3464 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3466 /* State that no mouse buttons are now held.
3467 (The oldXMenu code doesn't track this info for us.)
3468 That is not necessarily true, but the fiction leads to reasonable
3469 results, and it is a pain to ask which are actually held now. */
3470 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3472 #endif /* HAVE_X_WINDOWS */
3481 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3491 int pane
, selidx
, lpane
, status
;
3492 Lisp_Object entry
, pane_prefix
;
3494 int ulx
, uly
, width
, height
;
3495 int dispwidth
, dispheight
;
3496 int i
, j
, lines
, maxlines
;
3499 unsigned int dummy_uint
;
3500 int specpdl_count
= SPECPDL_INDEX ();
3503 if (menu_items_n_panes
== 0)
3506 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3508 *error
= "Empty menu";
3512 /* Figure out which root window F is on. */
3513 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3514 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3515 &dummy_uint
, &dummy_uint
);
3517 /* Make the menu on that window. */
3518 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3521 *error
= "Can't create menu";
3525 /* Don't GC while we prepare and show the menu,
3526 because we give the oldxmenu library pointers to the
3527 contents of strings. */
3528 inhibit_garbage_collection ();
3530 #ifdef HAVE_X_WINDOWS
3531 /* Adjust coordinates to relative to the outer (window manager) window. */
3532 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
3533 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
3534 #endif /* HAVE_X_WINDOWS */
3536 /* Adjust coordinates to be root-window-relative. */
3540 /* Create all the necessary panes and their items. */
3541 maxlines
= lines
= i
= 0;
3542 while (i
< menu_items_used
)
3544 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3546 /* Create a new pane. */
3547 Lisp_Object pane_name
, prefix
;
3550 maxlines
= max (maxlines
, lines
);
3552 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3553 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3554 pane_string
= (NILP (pane_name
)
3555 ? "" : (char *) SDATA (pane_name
));
3556 if (keymaps
&& !NILP (prefix
))
3559 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3560 if (lpane
== XM_FAILURE
)
3562 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3563 *error
= "Can't create pane";
3566 i
+= MENU_ITEMS_PANE_LENGTH
;
3568 /* Find the width of the widest item in this pane. */
3571 while (j
< menu_items_used
)
3574 item
= XVECTOR (menu_items
)->contents
[j
];
3582 width
= SBYTES (item
);
3583 if (width
> maxwidth
)
3586 j
+= MENU_ITEMS_ITEM_LENGTH
;
3589 /* Ignore a nil in the item list.
3590 It's meaningful only for dialog boxes. */
3591 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3595 /* Create a new item within current pane. */
3596 Lisp_Object item_name
, enable
, descrip
, help
;
3597 unsigned char *item_data
;
3600 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3601 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3603 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3604 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3605 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3607 if (!NILP (descrip
))
3609 int gap
= maxwidth
- SBYTES (item_name
);
3612 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3613 item_name
= concat2 (item_name
, spacer
);
3614 item_name
= concat2 (item_name
, descrip
);
3615 item_data
= SDATA (item_name
);
3617 /* if alloca is fast, use that to make the space,
3618 to reduce gc needs. */
3620 = (unsigned char *) alloca (maxwidth
3621 + SBYTES (descrip
) + 1);
3622 bcopy (SDATA (item_name
), item_data
,
3623 SBYTES (item_name
));
3624 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3626 bcopy (SDATA (descrip
), item_data
+ j
,
3628 item_data
[j
+ SBYTES (descrip
)] = 0;
3632 item_data
= SDATA (item_name
);
3634 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3635 menu
, lpane
, 0, item_data
,
3636 !NILP (enable
), help_string
)
3639 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3640 *error
= "Can't add selection to menu";
3643 i
+= MENU_ITEMS_ITEM_LENGTH
;
3648 maxlines
= max (maxlines
, lines
);
3650 /* All set and ready to fly. */
3651 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3652 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3653 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3654 x
= min (x
, dispwidth
);
3655 y
= min (y
, dispheight
);
3658 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3659 &ulx
, &uly
, &width
, &height
);
3660 if (ulx
+width
> dispwidth
)
3662 x
-= (ulx
+ width
) - dispwidth
;
3663 ulx
= dispwidth
- width
;
3665 if (uly
+height
> dispheight
)
3667 y
-= (uly
+ height
) - dispheight
;
3668 uly
= dispheight
- height
;
3670 if (ulx
< 0) x
-= ulx
;
3671 if (uly
< 0) y
-= uly
;
3675 /* If position was not given by a mouse click, adjust so upper left
3676 corner of the menu as a whole ends up at given coordinates. This
3677 is what x-popup-menu says in its documentation. */
3679 y
+= 1.5*height
/(maxlines
+2);
3682 XMenuSetAEQ (menu
, TRUE
);
3683 XMenuSetFreeze (menu
, TRUE
);
3687 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3690 record_unwind_protect (pop_down_menu
,
3691 Fcons (make_save_value (f
, 0),
3692 make_save_value (menu
, 0)));
3694 /* Help display under X won't work because XMenuActivate contains
3695 a loop that doesn't give Emacs a chance to process it. */
3696 menu_help_frame
= f
;
3697 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3698 x
, y
, ButtonReleaseMask
, &datap
,
3699 menu_help_callback
);
3705 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3708 /* Find the item number SELIDX in pane number PANE. */
3710 while (i
< menu_items_used
)
3712 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3716 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3718 i
+= MENU_ITEMS_PANE_LENGTH
;
3727 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3730 entry
= Fcons (entry
, Qnil
);
3731 if (!NILP (pane_prefix
))
3732 entry
= Fcons (pane_prefix
, entry
);
3738 i
+= MENU_ITEMS_ITEM_LENGTH
;
3744 *error
= "Can't activate menu";
3749 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3750 the menu was invoked with a mouse event as POSITION). */
3752 Fsignal (Qquit
, Qnil
);
3757 unbind_to (specpdl_count
, Qnil
);
3762 #endif /* not USE_X_TOOLKIT */
3764 #endif /* HAVE_MENUS */
3766 /* Detect if a dialog or menu has been posted. */
3771 return popup_activated_flag
;
3774 /* The following is used by delayed window autoselection. */
3776 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
3777 doc
: /* Return t if a menu or popup dialog is active. */)
3781 return (popup_activated ()) ? Qt
: Qnil
;
3784 #endif /* HAVE_MENUS */
3790 staticpro (&menu_items
);
3792 menu_items_inuse
= Qnil
;
3794 Qdebug_on_next_call
= intern ("debug-on-next-call");
3795 staticpro (&Qdebug_on_next_call
);
3797 #ifdef USE_X_TOOLKIT
3798 widget_id_tick
= (1<<16);
3799 next_menubar_widget_id
= 1;
3802 defsubr (&Sx_popup_menu
);
3803 defsubr (&Smenu_or_popup_active_p
);
3805 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
3806 defsubr (&Smenu_bar_open
);
3807 Ffset (intern ("accelerate-menu"), intern (Smenu_bar_open
.symbol_name
));
3811 defsubr (&Sx_popup_dialog
);
3815 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3816 (do not change this comment) */