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 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 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. */
47 #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
;
749 XQueryPointer (FRAME_X_DISPLAY (f
),
750 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
752 /* The root window which contains the pointer. */
755 /* Window pointer is on, not used */
758 /* The position on that root window. */
761 /* x/y in dummy_window coordinates, not used. */
764 /* Modifier keys and pointer buttons, about which
766 (unsigned int *) &dummy
);
770 /* xmenu_show expects window coordinates, not root window
771 coordinates. Translate. */
772 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
773 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
776 #endif /* HAVE_X_WINDOWS */
778 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
779 doc
: /* Pop up a deck-of-cards menu and return user's selection.
780 POSITION is a position specification. This is either a mouse button event
781 or a list ((XOFFSET YOFFSET) WINDOW)
782 where XOFFSET and YOFFSET are positions in pixels from the top left
783 corner of WINDOW. (WINDOW may be a window or a frame object.)
784 This controls the position of the top left of the menu as a whole.
785 If POSITION is t, it means to use the current mouse position.
787 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
788 The menu items come from key bindings that have a menu string as well as
789 a definition; actually, the "definition" in such a key binding looks like
790 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
791 the keymap as a top-level element.
793 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
794 Otherwise, REAL-DEFINITION should be a valid key binding definition.
796 You can also use a list of keymaps as MENU.
797 Then each keymap makes a separate pane.
799 When MENU is a keymap or a list of keymaps, the return value is the
800 list of events corresponding to the user's choice. Note that
801 `x-popup-menu' does not actually execute the command bound to that
804 Alternatively, you can specify a menu of multiple panes
805 with a list of the form (TITLE PANE1 PANE2...),
806 where each pane is a list of form (TITLE ITEM1 ITEM2...).
807 Each ITEM is normally a cons cell (STRING . VALUE);
808 but a string can appear as an item--that makes a nonselectable line
810 With this form of menu, the return value is VALUE from the chosen item.
812 If POSITION is nil, don't display the menu at all, just precalculate the
813 cached information about equivalent key sequences.
815 If the user gets rid of the menu without making a valid choice, for
816 instance by clicking the mouse away from a valid choice or by typing
817 keyboard input, then this normally results in a quit and
818 `x-popup-menu' does not return. But if POSITION is a mouse button
819 event (indicating that the user invoked the menu with the mouse) then
820 no quit occurs and `x-popup-menu' returns nil. */)
822 Lisp_Object position
, menu
;
824 Lisp_Object keymap
, tem
;
825 int xpos
= 0, ypos
= 0;
827 char *error_name
= NULL
;
828 Lisp_Object selection
= Qnil
;
830 Lisp_Object x
, y
, window
;
833 int specpdl_count
= SPECPDL_INDEX ();
837 if (! NILP (position
))
839 int get_current_pos_p
= 0;
842 /* Decode the first argument: find the window and the coordinates. */
843 if (EQ (position
, Qt
)
844 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
845 || EQ (XCAR (position
), Qtool_bar
))))
847 get_current_pos_p
= 1;
851 tem
= Fcar (position
);
854 window
= Fcar (Fcdr (position
));
856 y
= Fcar (XCDR (tem
));
861 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
862 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
863 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
868 /* If a click happens in an external tool bar or a detached
869 tool bar, x and y is NIL. In that case, use the current
870 mouse position. This happens for the help button in the
871 tool bar. Ideally popup-menu should pass NIL to
872 this function, but it doesn't. */
873 if (NILP (x
) && NILP (y
))
874 get_current_pos_p
= 1;
877 if (get_current_pos_p
)
879 /* Use the mouse's current position. */
880 FRAME_PTR new_f
= SELECTED_FRAME ();
881 #ifdef HAVE_X_WINDOWS
882 /* Can't use mouse_position_hook for X since it returns
883 coordinates relative to the window the mouse is in,
884 we need coordinates relative to the edit widget always. */
889 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
890 /* cur_x/y may be negative, so use make_number. */
891 x
= make_number (cur_x
);
892 y
= make_number (cur_y
);
895 #else /* not HAVE_X_WINDOWS */
896 Lisp_Object bar_window
;
897 enum scroll_bar_part part
;
900 if (mouse_position_hook
)
901 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
902 &part
, &x
, &y
, &time
);
903 #endif /* not HAVE_X_WINDOWS */
906 XSETFRAME (window
, new_f
);
909 window
= selected_window
;
918 /* Decode where to put the menu. */
926 else if (WINDOWP (window
))
928 CHECK_LIVE_WINDOW (window
);
929 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
931 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
932 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
935 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
936 but I don't want to make one now. */
937 CHECK_WINDOW (window
);
943 error ("Can not put X menu on non-X terminal");
945 XSETFRAME (Vmenu_updating_frame
, f
);
948 Vmenu_updating_frame
= Qnil
;
949 #endif /* HAVE_MENUS */
951 record_unwind_protect (unuse_menu_items
, Qnil
);
955 /* Decode the menu items from what was specified. */
957 keymap
= get_keymap (menu
, 0, 0);
960 /* We were given a keymap. Extract menu info from the keymap. */
963 /* Extract the detailed info to make one pane. */
964 keymap_panes (&menu
, 1, NILP (position
));
966 /* Search for a string appearing directly as an element of the keymap.
967 That string is the title of the menu. */
968 prompt
= Fkeymap_prompt (keymap
);
969 if (NILP (title
) && !NILP (prompt
))
972 /* Make that be the pane title of the first pane. */
973 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
974 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
978 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
980 /* We were given a list of keymaps. */
981 int nmaps
= XFASTINT (Flength (menu
));
983 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
988 /* The first keymap that has a prompt string
989 supplies the menu title. */
990 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
994 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
996 prompt
= Fkeymap_prompt (keymap
);
997 if (NILP (title
) && !NILP (prompt
))
1001 /* Extract the detailed info to make one pane. */
1002 keymap_panes (maps
, nmaps
, NILP (position
));
1004 /* Make the title be the pane title of the first pane. */
1005 if (!NILP (title
) && menu_items_n_panes
>= 0)
1006 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
1012 /* We were given an old-fashioned menu. */
1013 title
= Fcar (menu
);
1014 CHECK_STRING (title
);
1016 list_of_panes (Fcdr (menu
));
1021 unbind_to (specpdl_count
, Qnil
);
1023 if (NILP (position
))
1025 discard_menu_items ();
1031 /* Display them in a menu. */
1034 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
1035 keymaps
, title
, &error_name
);
1038 discard_menu_items ();
1041 #endif /* HAVE_MENUS */
1043 if (error_name
) error (error_name
);
1049 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
1050 doc
: /* Pop up a dialog box and return user's selection.
1051 POSITION specifies which frame to use.
1052 This is normally a mouse button event or a window or frame.
1053 If POSITION is t, it means to use the frame the mouse is on.
1054 The dialog box appears in the middle of the specified frame.
1056 CONTENTS specifies the alternatives to display in the dialog box.
1057 It is a list of the form (DIALOG ITEM1 ITEM2...).
1058 Each ITEM is a cons cell (STRING . VALUE).
1059 The return value is VALUE from the chosen item.
1061 An ITEM may also be just a string--that makes a nonselectable item.
1062 An ITEM may also be nil--that means to put all preceding items
1063 on the left of the dialog box and all following items on the right.
1064 \(By default, approximately half appear on each side.)
1066 If HEADER is non-nil, the frame title for the box is "Information",
1067 otherwise it is "Question".
1069 If the user gets rid of the dialog box without making a valid choice,
1070 for instance using the window manager, then this produces a quit and
1071 `x-popup-dialog' does not return. */)
1072 (position
, contents
, header
)
1073 Lisp_Object position
, contents
, header
;
1080 /* Decode the first argument: find the window or frame to use. */
1081 if (EQ (position
, Qt
)
1082 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1083 || EQ (XCAR (position
), Qtool_bar
))))
1085 #if 0 /* Using the frame the mouse is on may not be right. */
1086 /* Use the mouse's current position. */
1087 FRAME_PTR new_f
= SELECTED_FRAME ();
1088 Lisp_Object bar_window
;
1089 enum scroll_bar_part part
;
1093 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1096 XSETFRAME (window
, new_f
);
1098 window
= selected_window
;
1100 window
= selected_window
;
1102 else if (CONSP (position
))
1105 tem
= Fcar (position
);
1107 window
= Fcar (Fcdr (position
));
1110 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1111 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1114 else if (WINDOWP (position
) || FRAMEP (position
))
1119 /* Decode where to put the menu. */
1121 if (FRAMEP (window
))
1122 f
= XFRAME (window
);
1123 else if (WINDOWP (window
))
1125 CHECK_LIVE_WINDOW (window
);
1126 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1129 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1130 but I don't want to make one now. */
1131 CHECK_WINDOW (window
);
1133 if (! FRAME_X_P (f
))
1134 error ("Can not put X dialog on non-X terminal");
1136 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1137 /* Display a menu with these alternatives
1138 in the middle of frame F. */
1140 Lisp_Object x
, y
, frame
, newpos
;
1141 XSETFRAME (frame
, f
);
1142 XSETINT (x
, x_pixel_width (f
) / 2);
1143 XSETINT (y
, x_pixel_height (f
) / 2);
1144 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1146 return Fx_popup_menu (newpos
,
1147 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1153 Lisp_Object selection
;
1154 int specpdl_count
= SPECPDL_INDEX ();
1156 /* Decode the dialog items from what was specified. */
1157 title
= Fcar (contents
);
1158 CHECK_STRING (title
);
1159 record_unwind_protect (unuse_menu_items
, Qnil
);
1161 if (NILP (Fcar (Fcdr (contents
))))
1162 /* No buttons specified, add an "Ok" button so users can pop down
1163 the dialog. Also, the lesstif/motif version crashes if there are
1165 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1167 list_of_panes (Fcons (contents
, Qnil
));
1169 /* Display them in a dialog box. */
1171 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
1174 unbind_to (specpdl_count
, Qnil
);
1175 discard_menu_items ();
1177 if (error_name
) error (error_name
);
1186 /* Set menu_items_inuse so no other popup menu or dialog is created. */
1189 x_menu_set_in_use (in_use
)
1192 menu_items_inuse
= in_use
? Qt
: Qnil
;
1193 popup_activated_flag
= in_use
;
1194 #ifdef USE_X_TOOLKIT
1195 if (popup_activated_flag
)
1196 x_activate_timeout_atimer ();
1200 /* Wait for an X event to arrive or for a timer to expire. */
1203 x_menu_wait_for_event (void *data
)
1205 extern EMACS_TIME timer_check
P_ ((int));
1207 /* Another way to do this is to register a timer callback, that can be
1208 done in GTK and Xt. But we have to do it like this when using only X
1209 anyway, and with callbacks we would have three variants for timer handling
1210 instead of the small ifdefs below. */
1213 #ifdef USE_X_TOOLKIT
1214 ! XtAppPending (Xt_app_con
)
1215 #elif defined USE_GTK
1216 ! gtk_events_pending ()
1218 ! XPending ((Display
*) data
)
1222 EMACS_TIME next_time
= timer_check (1);
1223 long secs
= EMACS_SECS (next_time
);
1224 long usecs
= EMACS_USECS (next_time
);
1225 SELECT_TYPE read_fds
;
1226 struct x_display_info
*dpyinfo
;
1229 FD_ZERO (&read_fds
);
1230 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1232 int fd
= ConnectionNumber (dpyinfo
->display
);
1233 FD_SET (fd
, &read_fds
);
1237 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1239 /* Sometimes timer_check returns -1 (no timers) even if there are
1240 timers. So do a timeout anyway. */
1241 EMACS_SET_SECS (next_time
, 1);
1242 EMACS_SET_USECS (next_time
, 0);
1245 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1248 #endif /* ! MSDOS */
1251 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1253 #ifdef USE_X_TOOLKIT
1255 /* Loop in Xt until the menu pulldown or dialog popup has been
1256 popped down (deactivated). This is used for x-popup-menu
1257 and x-popup-dialog; it is not used for the menu bar.
1259 NOTE: All calls to popup_get_selection should be protected
1260 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1263 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1264 XEvent
*initial_event
;
1265 struct x_display_info
*dpyinfo
;
1271 while (popup_activated_flag
)
1275 event
= *initial_event
;
1280 if (do_timers
) x_menu_wait_for_event (0);
1281 XtAppNextEvent (Xt_app_con
, &event
);
1284 /* Make sure we don't consider buttons grabbed after menu goes.
1285 And make sure to deactivate for any ButtonRelease,
1286 even if XtDispatchEvent doesn't do that. */
1287 if (event
.type
== ButtonRelease
1288 && dpyinfo
->display
== event
.xbutton
.display
)
1290 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1291 #ifdef USE_MOTIF /* Pretending that the event came from a
1292 Btn1Down seems the only way to convince Motif to
1293 activate its callbacks; setting the XmNmenuPost
1294 isn't working. --marcus@sysc.pdx.edu. */
1295 event
.xbutton
.button
= 1;
1296 /* Motif only pops down menus when no Ctrl, Alt or Mod
1297 key is pressed and the button is released. So reset key state
1298 so Motif thinks this is the case. */
1299 event
.xbutton
.state
= 0;
1302 /* Pop down on C-g and Escape. */
1303 else if (event
.type
== KeyPress
1304 && dpyinfo
->display
== event
.xbutton
.display
)
1306 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1308 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
1309 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
1310 popup_activated_flag
= 0;
1313 x_dispatch_event (&event
, event
.xany
.display
);
1317 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
1318 doc
: /* Start key navigation of the menu bar in FRAME.
1319 This initially opens the first menu bar item and you can then navigate with the
1320 arrow keys, select a menu entry with the return key or cancel with the
1321 escape key. If FRAME has no menu bar this function does nothing.
1323 If FRAME is nil or not given, use the selected frame. */)
1328 FRAME_PTR f
= check_x_frame (frame
);
1332 if (FRAME_EXTERNAL_MENU_BAR (f
))
1333 set_frame_menubar (f
, 0, 1);
1335 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
1341 x_catch_errors (FRAME_X_DISPLAY (f
));
1342 memset (&ev
, 0, sizeof ev
);
1343 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
1344 ev
.xbutton
.window
= XtWindow (menubar
);
1345 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1346 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
1347 ev
.xbutton
.button
= Button1
;
1348 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
1349 ev
.xbutton
.same_screen
= True
;
1356 XtSetArg (al
[0], XtNchildren
, &list
);
1357 XtSetArg (al
[1], XtNnumChildren
, &nr
);
1358 XtGetValues (menubar
, al
, 2);
1359 ev
.xbutton
.window
= XtWindow (list
[0]);
1363 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
1364 /* From-window, to-window. */
1365 ev
.xbutton
.window
, ev
.xbutton
.root
,
1367 /* From-position, to-position. */
1368 ev
.xbutton
.x
, ev
.xbutton
.y
,
1369 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
1373 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
1374 x_uncatch_errors ();
1378 ev
.type
= ButtonPress
;
1379 ev
.xbutton
.state
= 0;
1381 XtDispatchEvent (&ev
);
1382 ev
.xbutton
.type
= ButtonRelease
;
1383 ev
.xbutton
.state
= Button1Mask
;
1384 XtDispatchEvent (&ev
);
1392 #endif /* USE_X_TOOLKIT */
1396 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
1397 doc
: /* Start key navigation of the menu bar in FRAME.
1398 This initially opens the first menu bar item and you can then navigate with the
1399 arrow keys, select a menu entry with the return key or cancel with the
1400 escape key. If FRAME has no menu bar this function does nothing.
1402 If FRAME is nil or not given, use the selected frame. */)
1409 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
1413 f
= check_x_frame (frame
);
1415 if (FRAME_EXTERNAL_MENU_BAR (f
))
1416 set_frame_menubar (f
, 0, 1);
1418 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
1421 /* Activate the first menu. */
1422 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
1424 gtk_menu_shell_select_item (GTK_MENU_SHELL (menubar
),
1425 GTK_WIDGET (children
->data
));
1427 popup_activated_flag
= 1;
1428 g_list_free (children
);
1435 /* Loop util popup_activated_flag is set to zero in a callback.
1436 Used for popup menus and dialogs. */
1439 popup_widget_loop (do_timers
, widget
)
1443 ++popup_activated_flag
;
1445 /* Process events in the Gtk event loop until done. */
1446 while (popup_activated_flag
)
1448 if (do_timers
) x_menu_wait_for_event (0);
1449 gtk_main_iteration ();
1454 /* Activate the menu bar of frame F.
1455 This is called from keyboard.c when it gets the
1456 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1458 To activate the menu bar, we use the X button-press event
1459 that was saved in saved_menu_event.
1460 That makes the toolkit do its thing.
1462 But first we recompute the menu bar contents (the whole tree).
1464 The reason for saving the button event until here, instead of
1465 passing it to the toolkit right away, is that we can safely
1466 execute Lisp code. */
1469 x_activate_menubar (f
)
1472 if (! FRAME_X_P (f
))
1475 if (!f
->output_data
.x
->saved_menu_event
->type
)
1479 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1480 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1484 set_frame_menubar (f
, 0, 1);
1487 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1488 f
->output_data
.x
->saved_menu_event
);
1489 popup_activated_flag
= 1;
1491 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1495 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1496 pending_menu_activation
= 1;
1499 /* Ignore this if we get it a second time. */
1500 f
->output_data
.x
->saved_menu_event
->type
= 0;
1503 /* This callback is invoked when the user selects a menubar cascade
1504 pushbutton, but before the pulldown menu is posted. */
1508 popup_activate_callback (widget
, id
, client_data
)
1511 XtPointer client_data
;
1513 popup_activated_flag
= 1;
1514 #ifdef USE_X_TOOLKIT
1515 x_activate_timeout_atimer ();
1520 /* This callback is invoked when a dialog or menu is finished being
1521 used and has been unposted. */
1525 popup_deactivate_callback (widget
, client_data
)
1527 gpointer client_data
;
1529 popup_activated_flag
= 0;
1533 popup_deactivate_callback (widget
, id
, client_data
)
1536 XtPointer client_data
;
1538 popup_activated_flag
= 0;
1543 /* Function that finds the frame for WIDGET and shows the HELP text
1545 F is the frame if known, or NULL if not known. */
1547 show_help_event (f
, widget
, help
)
1549 xt_or_gtk_widget widget
;
1556 XSETFRAME (frame
, f
);
1557 kbd_buffer_store_help_event (frame
, help
);
1561 #if 0 /* This code doesn't do anything useful. ++kfs */
1562 /* WIDGET is the popup menu. It's parent is the frame's
1563 widget. See which frame that is. */
1564 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1567 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1569 frame
= XCAR (tail
);
1570 if (GC_FRAMEP (frame
)
1571 && (f
= XFRAME (frame
),
1572 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1576 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1580 /* Callback called when menu items are highlighted/unhighlighted
1581 while moving the mouse over them. WIDGET is the menu bar or menu
1582 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1583 the data structure for the menu item, or null in case of
1588 menu_highlight_callback (widget
, call_data
)
1592 xg_menu_item_cb_data
*cb_data
;
1595 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1597 if (! cb_data
) return;
1599 help
= call_data
? cb_data
->help
: Qnil
;
1601 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1602 Don't show help for them, they won't appear before the
1603 popup is popped down. */
1604 if (popup_activated_flag
<= 1)
1605 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1609 menu_highlight_callback (widget
, id
, call_data
)
1617 widget_value
*wv
= (widget_value
*) call_data
;
1619 help
= wv
? wv
->help
: Qnil
;
1621 /* Determine the frame for the help event. */
1622 f
= menubar_id_to_frame (id
);
1624 show_help_event (f
, widget
, help
);
1628 /* Find the menu selection and store it in the keyboard buffer.
1629 F is the frame the menu is on.
1630 MENU_BAR_ITEMS_USED is the length of VECTOR.
1631 VECTOR is an array of menu events for the whole menu. */
1634 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1636 int menu_bar_items_used
;
1640 Lisp_Object prefix
, entry
;
1641 Lisp_Object
*subprefix_stack
;
1642 int submenu_depth
= 0;
1646 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1650 while (i
< menu_bar_items_used
)
1652 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1654 subprefix_stack
[submenu_depth
++] = prefix
;
1658 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1660 prefix
= subprefix_stack
[--submenu_depth
];
1663 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1665 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1666 i
+= MENU_ITEMS_PANE_LENGTH
;
1670 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1671 /* The EMACS_INT cast avoids a warning. There's no problem
1672 as long as pointers have enough bits to hold small integers. */
1673 if ((int) (EMACS_INT
) client_data
== i
)
1676 struct input_event buf
;
1680 XSETFRAME (frame
, f
);
1681 buf
.kind
= MENU_BAR_EVENT
;
1682 buf
.frame_or_window
= frame
;
1684 kbd_buffer_store_event (&buf
);
1686 for (j
= 0; j
< submenu_depth
; j
++)
1687 if (!NILP (subprefix_stack
[j
]))
1689 buf
.kind
= MENU_BAR_EVENT
;
1690 buf
.frame_or_window
= frame
;
1691 buf
.arg
= subprefix_stack
[j
];
1692 kbd_buffer_store_event (&buf
);
1697 buf
.kind
= MENU_BAR_EVENT
;
1698 buf
.frame_or_window
= frame
;
1700 kbd_buffer_store_event (&buf
);
1703 buf
.kind
= MENU_BAR_EVENT
;
1704 buf
.frame_or_window
= frame
;
1706 kbd_buffer_store_event (&buf
);
1710 i
+= MENU_ITEMS_ITEM_LENGTH
;
1717 /* Gtk calls callbacks just because we tell it what item should be
1718 selected in a radio group. If this variable is set to a non-zero
1719 value, we are creating menus and don't want callbacks right now.
1721 static int xg_crazy_callback_abort
;
1723 /* This callback is called from the menu bar pulldown menu
1724 when the user makes a selection.
1725 Figure out what the user chose
1726 and put the appropriate events into the keyboard buffer. */
1728 menubar_selection_callback (widget
, client_data
)
1730 gpointer client_data
;
1732 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1734 if (xg_crazy_callback_abort
)
1737 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1740 /* For a group of radio buttons, GTK calls the selection callback first
1741 for the item that was active before the selection and then for the one that
1742 is active after the selection. For C-h k this means we get the help on
1743 the deselected item and then the selected item is executed. Prevent that
1744 by ignoring the non-active item. */
1745 if (GTK_IS_RADIO_MENU_ITEM (widget
)
1746 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
1749 /* When a menu is popped down, X generates a focus event (i.e. focus
1750 goes back to the frame below the menu). Since GTK buffers events,
1751 we force it out here before the menu selection event. Otherwise
1752 sit-for will exit at once if the focus event follows the menu selection
1756 while (gtk_events_pending ())
1757 gtk_main_iteration ();
1760 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1761 cb_data
->cl_data
->menu_bar_items_used
,
1762 cb_data
->cl_data
->menu_bar_vector
,
1763 cb_data
->call_data
);
1766 #else /* not USE_GTK */
1768 /* This callback is called from the menu bar pulldown menu
1769 when the user makes a selection.
1770 Figure out what the user chose
1771 and put the appropriate events into the keyboard buffer. */
1773 menubar_selection_callback (widget
, id
, client_data
)
1776 XtPointer client_data
;
1780 f
= menubar_id_to_frame (id
);
1783 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1784 f
->menu_bar_vector
, client_data
);
1786 #endif /* not USE_GTK */
1788 /* Allocate a widget_value, blocking input. */
1791 xmalloc_widget_value ()
1793 widget_value
*value
;
1796 value
= malloc_widget_value ();
1802 /* This recursively calls free_widget_value on the tree of widgets.
1803 It must free all data that was malloc'ed for these widget_values.
1804 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1805 must be left alone. */
1808 free_menubar_widget_value_tree (wv
)
1813 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1815 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1817 free_menubar_widget_value_tree (wv
->contents
);
1818 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1822 free_menubar_widget_value_tree (wv
->next
);
1823 wv
->next
= (widget_value
*) 0xDEADBEEF;
1826 free_widget_value (wv
);
1830 /* Set up data in menu_items for a menu bar item
1831 whose event type is ITEM_KEY (with string ITEM_NAME)
1832 and whose contents come from the list of keymaps MAPS. */
1835 parse_single_submenu (item_key
, item_name
, maps
)
1836 Lisp_Object item_key
, item_name
, maps
;
1840 Lisp_Object
*mapvec
;
1842 int top_level_items
= 0;
1844 length
= Flength (maps
);
1845 len
= XINT (length
);
1847 /* Convert the list MAPS into a vector MAPVEC. */
1848 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1849 for (i
= 0; i
< len
; i
++)
1851 mapvec
[i
] = Fcar (maps
);
1855 /* Loop over the given keymaps, making a pane for each map.
1856 But don't make a pane that is empty--ignore that map instead. */
1857 for (i
= 0; i
< len
; i
++)
1859 if (!KEYMAPP (mapvec
[i
]))
1861 /* Here we have a command at top level in the menu bar
1862 as opposed to a submenu. */
1863 top_level_items
= 1;
1864 push_menu_pane (Qnil
, Qnil
);
1865 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1866 Qnil
, Qnil
, Qnil
, Qnil
);
1871 prompt
= Fkeymap_prompt (mapvec
[i
]);
1872 single_keymap_panes (mapvec
[i
],
1873 !NILP (prompt
) ? prompt
: item_name
,
1878 return top_level_items
;
1881 /* Create a tree of widget_value objects
1882 representing the panes and items
1883 in menu_items starting at index START, up to index END. */
1885 static widget_value
*
1886 digest_single_submenu (start
, end
, top_level_items
)
1887 int start
, end
, top_level_items
;
1889 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1891 int submenu_depth
= 0;
1892 widget_value
**submenu_stack
;
1896 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1897 wv
= xmalloc_widget_value ();
1901 wv
->button_type
= BUTTON_TYPE_NONE
;
1907 /* Loop over all panes and items made by the preceding call
1908 to parse_single_submenu and construct a tree of widget_value objects.
1909 Ignore the panes and items used by previous calls to
1910 digest_single_submenu, even though those are also in menu_items. */
1914 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1916 submenu_stack
[submenu_depth
++] = save_wv
;
1921 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1924 save_wv
= submenu_stack
[--submenu_depth
];
1927 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1928 && submenu_depth
!= 0)
1929 i
+= MENU_ITEMS_PANE_LENGTH
;
1930 /* Ignore a nil in the item list.
1931 It's meaningful only for dialog boxes. */
1932 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1934 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1936 /* Create a new pane. */
1937 Lisp_Object pane_name
, prefix
;
1942 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1943 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1945 #ifndef HAVE_MULTILINGUAL_MENU
1946 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1948 pane_name
= ENCODE_MENU_STRING (pane_name
);
1949 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1952 pane_string
= (NILP (pane_name
)
1953 ? "" : (char *) SDATA (pane_name
));
1954 /* If there is just one top-level pane, put all its items directly
1955 under the top-level menu. */
1956 if (menu_items_n_panes
== 1)
1959 /* If the pane has a meaningful name,
1960 make the pane a top-level menu item
1961 with its items as a submenu beneath it. */
1962 if (strcmp (pane_string
, ""))
1964 wv
= xmalloc_widget_value ();
1968 first_wv
->contents
= wv
;
1969 wv
->lname
= pane_name
;
1970 /* Set value to 1 so update_submenu_strings can handle '@' */
1971 wv
->value
= (char *)1;
1973 wv
->button_type
= BUTTON_TYPE_NONE
;
1981 i
+= MENU_ITEMS_PANE_LENGTH
;
1985 /* Create a new item within current pane. */
1986 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1989 /* All items should be contained in panes. */
1990 if (panes_seen
== 0)
1993 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1994 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1995 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1996 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1997 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1998 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1999 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2001 #ifndef HAVE_MULTILINGUAL_MENU
2002 if (STRING_MULTIBYTE (item_name
))
2004 item_name
= ENCODE_MENU_STRING (item_name
);
2005 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2008 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2010 descrip
= ENCODE_MENU_STRING (descrip
);
2011 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2013 #endif /* not HAVE_MULTILINGUAL_MENU */
2015 wv
= xmalloc_widget_value ();
2019 save_wv
->contents
= wv
;
2021 wv
->lname
= item_name
;
2022 if (!NILP (descrip
))
2025 /* The EMACS_INT cast avoids a warning. There's no problem
2026 as long as pointers have enough bits to hold small integers. */
2027 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
2028 wv
->enabled
= !NILP (enable
);
2031 wv
->button_type
= BUTTON_TYPE_NONE
;
2032 else if (EQ (type
, QCradio
))
2033 wv
->button_type
= BUTTON_TYPE_RADIO
;
2034 else if (EQ (type
, QCtoggle
))
2035 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2039 wv
->selected
= !NILP (selected
);
2040 if (! STRINGP (help
))
2047 i
+= MENU_ITEMS_ITEM_LENGTH
;
2051 /* If we have just one "menu item"
2052 that was originally a button, return it by itself. */
2053 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
2055 wv
= first_wv
->contents
;
2056 free_widget_value (first_wv
);
2063 /* Walk through the widget_value tree starting at FIRST_WV and update
2064 the char * pointers from the corresponding lisp values.
2065 We do this after building the whole tree, since GC may happen while the
2066 tree is constructed, and small strings are relocated. So we must wait
2067 until no GC can happen before storing pointers into lisp values. */
2069 update_submenu_strings (first_wv
)
2070 widget_value
*first_wv
;
2074 for (wv
= first_wv
; wv
; wv
= wv
->next
)
2076 if (STRINGP (wv
->lname
))
2078 wv
->name
= (char *) SDATA (wv
->lname
);
2080 /* Ignore the @ that means "separate pane".
2081 This is a kludge, but this isn't worth more time. */
2082 if (wv
->value
== (char *)1)
2084 if (wv
->name
[0] == '@')
2090 if (STRINGP (wv
->lkey
))
2091 wv
->key
= (char *) SDATA (wv
->lkey
);
2094 update_submenu_strings (wv
->contents
);
2099 /* Recompute all the widgets of frame F, when the menu bar has been
2100 changed. Value is non-zero if widgets were updated. */
2103 update_frame_menubar (f
)
2107 return xg_update_frame_menubar (f
);
2112 if (! FRAME_X_P (f
))
2115 x
= f
->output_data
.x
;
2117 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
2121 /* Save the size of the frame because the pane widget doesn't accept
2122 to resize itself. So force it. */
2123 columns
= FRAME_COLS (f
);
2124 rows
= FRAME_LINES (f
);
2126 /* Do the voodoo which means "I'm changing lots of things, don't try
2127 to refigure sizes until I'm done." */
2128 lw_refigure_widget (x
->column_widget
, False
);
2130 /* The order in which children are managed is the top to bottom
2131 order in which they are displayed in the paned window. First,
2132 remove the text-area widget. */
2133 XtUnmanageChild (x
->edit_widget
);
2135 /* Remove the menubar that is there now, and put up the menubar that
2137 XtManageChild (x
->menubar_widget
);
2138 XtMapWidget (x
->menubar_widget
);
2139 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
2141 /* Re-manage the text-area widget, and then thrash the sizes. */
2142 XtManageChild (x
->edit_widget
);
2143 lw_refigure_widget (x
->column_widget
, True
);
2145 /* Force the pane widget to resize itself with the right values. */
2146 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
2152 /* Set the contents of the menubar widgets of frame F.
2153 The argument FIRST_TIME is currently ignored;
2154 it is set the first time this is called, from initialize_frame_menubar. */
2157 set_frame_menubar (f
, first_time
, deep_p
)
2162 xt_or_gtk_widget menubar_widget
;
2163 #ifdef USE_X_TOOLKIT
2167 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
2169 int *submenu_start
, *submenu_end
;
2170 int *submenu_top_level_items
, *submenu_n_panes
;
2172 if (! FRAME_X_P (f
))
2175 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2177 XSETFRAME (Vmenu_updating_frame
, f
);
2179 #ifdef USE_X_TOOLKIT
2180 if (f
->output_data
.x
->id
== 0)
2181 f
->output_data
.x
->id
= next_menubar_widget_id
++;
2182 id
= f
->output_data
.x
->id
;
2185 if (! menubar_widget
)
2187 else if (pending_menu_activation
&& !deep_p
)
2189 /* Make the first call for any given frame always go deep. */
2190 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
2193 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
2194 f
->output_data
.x
->saved_menu_event
->type
= 0;
2198 /* If we have detached menus, we must update deep so detached menus
2199 also gets updated. */
2200 deep_p
= deep_p
|| xg_have_tear_offs ();
2205 /* Make a widget-value tree representing the entire menu trees. */
2207 struct buffer
*prev
= current_buffer
;
2209 int specpdl_count
= SPECPDL_INDEX ();
2210 int previous_menu_items_used
= f
->menu_bar_items_used
;
2211 Lisp_Object
*previous_items
2212 = (Lisp_Object
*) alloca (previous_menu_items_used
2213 * sizeof (Lisp_Object
));
2215 /* If we are making a new widget, its contents are empty,
2216 do always reinitialize them. */
2217 if (! menubar_widget
)
2218 previous_menu_items_used
= 0;
2220 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
2221 specbind (Qinhibit_quit
, Qt
);
2222 /* Don't let the debugger step into this code
2223 because it is not reentrant. */
2224 specbind (Qdebug_on_next_call
, Qnil
);
2226 record_unwind_save_match_data ();
2227 if (NILP (Voverriding_local_map_menu_flag
))
2229 specbind (Qoverriding_terminal_local_map
, Qnil
);
2230 specbind (Qoverriding_local_map
, Qnil
);
2233 set_buffer_internal_1 (XBUFFER (buffer
));
2235 /* Run the Lucid hook. */
2236 safe_run_hooks (Qactivate_menubar_hook
);
2238 /* If it has changed current-menubar from previous value,
2239 really recompute the menubar from the value. */
2240 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2241 call0 (Qrecompute_lucid_menubar
);
2242 safe_run_hooks (Qmenu_bar_update_hook
);
2243 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2245 items
= FRAME_MENU_BAR_ITEMS (f
);
2247 /* Save the frame's previous menu bar contents data. */
2248 if (previous_menu_items_used
)
2249 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2250 previous_menu_items_used
* sizeof (Lisp_Object
));
2252 /* Fill in menu_items with the current menu bar contents.
2253 This can evaluate Lisp code. */
2256 menu_items
= f
->menu_bar_vector
;
2257 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2258 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2259 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2260 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2261 submenu_top_level_items
2262 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2264 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2266 Lisp_Object key
, string
, maps
;
2270 key
= XVECTOR (items
)->contents
[i
];
2271 string
= XVECTOR (items
)->contents
[i
+ 1];
2272 maps
= XVECTOR (items
)->contents
[i
+ 2];
2276 submenu_start
[i
] = menu_items_used
;
2278 menu_items_n_panes
= 0;
2279 submenu_top_level_items
[i
]
2280 = parse_single_submenu (key
, string
, maps
);
2281 submenu_n_panes
[i
] = menu_items_n_panes
;
2283 submenu_end
[i
] = menu_items_used
;
2286 finish_menu_items ();
2288 /* Convert menu_items into widget_value trees
2289 to display the menu. This cannot evaluate Lisp code. */
2291 wv
= xmalloc_widget_value ();
2292 wv
->name
= "menubar";
2295 wv
->button_type
= BUTTON_TYPE_NONE
;
2299 for (i
= 0; i
< last_i
; i
+= 4)
2301 menu_items_n_panes
= submenu_n_panes
[i
];
2302 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2303 submenu_top_level_items
[i
]);
2307 first_wv
->contents
= wv
;
2308 /* Don't set wv->name here; GC during the loop might relocate it. */
2310 wv
->button_type
= BUTTON_TYPE_NONE
;
2314 set_buffer_internal_1 (prev
);
2316 /* If there has been no change in the Lisp-level contents
2317 of the menu bar, skip redisplaying it. Just exit. */
2319 /* Compare the new menu items with the ones computed last time. */
2320 for (i
= 0; i
< previous_menu_items_used
; i
++)
2321 if (menu_items_used
== i
2322 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2324 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2326 /* The menu items have not changed. Don't bother updating
2327 the menus in any form, since it would be a no-op. */
2328 free_menubar_widget_value_tree (first_wv
);
2329 discard_menu_items ();
2330 unbind_to (specpdl_count
, Qnil
);
2334 /* The menu items are different, so store them in the frame. */
2335 f
->menu_bar_vector
= menu_items
;
2336 f
->menu_bar_items_used
= menu_items_used
;
2338 /* This calls restore_menu_items to restore menu_items, etc.,
2339 as they were outside. */
2340 unbind_to (specpdl_count
, Qnil
);
2342 /* Now GC cannot happen during the lifetime of the widget_value,
2343 so it's safe to store data from a Lisp_String. */
2344 wv
= first_wv
->contents
;
2345 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2348 string
= XVECTOR (items
)->contents
[i
+ 1];
2351 wv
->name
= (char *) SDATA (string
);
2352 update_submenu_strings (wv
->contents
);
2359 /* Make a widget-value tree containing
2360 just the top level menu bar strings. */
2362 wv
= xmalloc_widget_value ();
2363 wv
->name
= "menubar";
2366 wv
->button_type
= BUTTON_TYPE_NONE
;
2370 items
= FRAME_MENU_BAR_ITEMS (f
);
2371 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2375 string
= XVECTOR (items
)->contents
[i
+ 1];
2379 wv
= xmalloc_widget_value ();
2380 wv
->name
= (char *) SDATA (string
);
2383 wv
->button_type
= BUTTON_TYPE_NONE
;
2385 /* This prevents lwlib from assuming this
2386 menu item is really supposed to be empty. */
2387 /* The EMACS_INT cast avoids a warning.
2388 This value just has to be different from small integers. */
2389 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2394 first_wv
->contents
= wv
;
2398 /* Forget what we thought we knew about what is in the
2399 detailed contents of the menu bar menus.
2400 Changing the top level always destroys the contents. */
2401 f
->menu_bar_items_used
= 0;
2404 /* Create or update the menu bar widget. */
2409 xg_crazy_callback_abort
= 1;
2412 /* The fourth arg is DEEP_P, which says to consider the entire
2413 menu trees we supply, rather than just the menu bar item names. */
2414 xg_modify_menubar_widgets (menubar_widget
,
2418 G_CALLBACK (menubar_selection_callback
),
2419 G_CALLBACK (popup_deactivate_callback
),
2420 G_CALLBACK (menu_highlight_callback
));
2424 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2427 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2428 G_CALLBACK (menubar_selection_callback
),
2429 G_CALLBACK (popup_deactivate_callback
),
2430 G_CALLBACK (menu_highlight_callback
));
2432 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2436 #else /* not USE_GTK */
2439 /* Disable resizing (done for Motif!) */
2440 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2442 /* The third arg is DEEP_P, which says to consider the entire
2443 menu trees we supply, rather than just the menu bar item names. */
2444 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2446 /* Re-enable the edit widget to resize. */
2447 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2451 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
2452 XtTranslations override
= XtParseTranslationTable (menuOverride
);
2454 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2455 f
->output_data
.x
->column_widget
,
2457 popup_activate_callback
,
2458 menubar_selection_callback
,
2459 popup_deactivate_callback
,
2460 menu_highlight_callback
);
2461 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2463 /* Make menu pop down on C-g. */
2464 XtOverrideTranslations (menubar_widget
, override
);
2469 = (f
->output_data
.x
->menubar_widget
2470 ? (f
->output_data
.x
->menubar_widget
->core
.height
2471 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2474 #if 0 /* Experimentally, we now get the right results
2475 for -geometry -0-0 without this. 24 Aug 96, rms. */
2477 if (FRAME_EXTERNAL_MENU_BAR (f
))
2480 XtVaGetValues (f
->output_data
.x
->column_widget
,
2481 XtNinternalBorderWidth
, &ibw
, NULL
);
2482 menubar_size
+= ibw
;
2484 #endif /* USE_LUCID */
2487 f
->output_data
.x
->menubar_height
= menubar_size
;
2489 #endif /* not USE_GTK */
2491 free_menubar_widget_value_tree (first_wv
);
2492 update_frame_menubar (f
);
2495 xg_crazy_callback_abort
= 0;
2501 /* Called from Fx_create_frame to create the initial menubar of a frame
2502 before it is mapped, so that the window is mapped with the menubar already
2503 there instead of us tacking it on later and thrashing the window after it
2507 initialize_frame_menubar (f
)
2510 /* This function is called before the first chance to redisplay
2511 the frame. It has to be, so the frame will have the right size. */
2512 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2513 set_frame_menubar (f
, 1, 1);
2517 /* Get rid of the menu bar of frame F, and free its storage.
2518 This is used when deleting a frame, and when turning off the menu bar.
2519 For GTK this function is in gtkutil.c. */
2523 free_frame_menubar (f
)
2526 Widget menubar_widget
;
2528 if (! FRAME_X_P (f
))
2531 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2533 f
->output_data
.x
->menubar_height
= 0;
2538 /* Removing the menu bar magically changes the shell widget's x
2539 and y position of (0, 0) which, when the menu bar is turned
2540 on again, leads to pull-down menuss appearing in strange
2541 positions near the upper-left corner of the display. This
2542 happens only with some window managers like twm and ctwm,
2543 but not with other like Motif's mwm or kwm, because the
2544 latter generate ConfigureNotify events when the menu bar
2545 is switched off, which fixes the shell position. */
2546 Position x0
, y0
, x1
, y1
;
2552 if (f
->output_data
.x
->widget
)
2553 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2556 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2557 f
->output_data
.x
->menubar_widget
= NULL
;
2560 if (f
->output_data
.x
->widget
)
2562 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2563 if (x1
== 0 && y1
== 0)
2564 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2571 #endif /* not USE_GTK */
2573 #endif /* USE_X_TOOLKIT || USE_GTK */
2575 /* xmenu_show actually displays a menu using the panes and items in menu_items
2576 and returns the value selected from it.
2577 There are two versions of xmenu_show, one for Xt and one for Xlib.
2578 Both assume input is blocked by the caller. */
2580 /* F is the frame the menu is for.
2581 X and Y are the frame-relative specified position,
2582 relative to the inside upper left corner of the frame F.
2583 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2584 KEYMAPS is 1 if this menu was specified with keymaps;
2585 in that case, we return a list containing the chosen item's value
2586 and perhaps also the pane's prefix.
2587 TITLE is the specified menu title.
2588 ERROR is a place to store an error message string in case of failure.
2589 (We return nil on failure, but the value doesn't actually matter.) */
2591 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2593 /* The item selected in the popup menu. */
2594 static Lisp_Object
*volatile menu_item_selection
;
2598 /* Used when position a popup menu. See menu_position_func and
2599 create_and_show_popup_menu below. */
2600 struct next_popup_x_y
2607 /* The menu position function to use if we are not putting a popup
2608 menu where the pointer is.
2609 MENU is the menu to pop up.
2610 X and Y shall on exit contain x/y where the menu shall pop up.
2611 PUSH_IN is not documented in the GTK manual.
2612 USER_DATA is any data passed in when calling gtk_menu_popup.
2613 Here it points to a struct next_popup_x_y where the coordinates
2614 to store in *X and *Y are as well as the frame for the popup.
2616 Here only X and Y are used. */
2618 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2625 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2627 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2628 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2633 /* Check if there is room for the menu. If not, adjust x/y so that
2634 the menu is fully visible. */
2635 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2636 if (data
->x
+ req
.width
> disp_width
)
2637 *x
-= data
->x
+ req
.width
- disp_width
;
2638 if (data
->y
+ req
.height
> disp_height
)
2639 *y
-= data
->y
+ req
.height
- disp_height
;
2643 popup_selection_callback (widget
, client_data
)
2645 gpointer client_data
;
2647 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2649 if (xg_crazy_callback_abort
) return;
2650 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2657 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
2659 popup_activated_flag
= 0;
2661 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
2666 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2668 menu_item_selection will be set to the selection. */
2670 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2672 widget_value
*first_wv
;
2679 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2680 struct next_popup_x_y popup_x_y
;
2681 int specpdl_count
= SPECPDL_INDEX ();
2683 if (! FRAME_X_P (f
))
2686 xg_crazy_callback_abort
= 1;
2687 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2688 G_CALLBACK (popup_selection_callback
),
2689 G_CALLBACK (popup_deactivate_callback
),
2690 G_CALLBACK (menu_highlight_callback
));
2691 xg_crazy_callback_abort
= 0;
2695 /* Not invoked by a click. pop up at x/y. */
2696 pos_func
= menu_position_func
;
2698 /* Adjust coordinates to be root-window-relative. */
2699 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2700 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2706 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
2710 for (i
= 0; i
< 5; i
++)
2711 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2715 /* Display the menu. */
2716 gtk_widget_show_all (menu
);
2717 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2719 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2721 if (GTK_WIDGET_MAPPED (menu
))
2723 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2724 two. show_help_echo uses this to detect popup menus. */
2725 popup_activated_flag
= 1;
2726 /* Process events that apply to the menu. */
2727 popup_widget_loop (1, menu
);
2730 unbind_to (specpdl_count
, Qnil
);
2732 /* Must reset this manually because the button release event is not passed
2733 to Emacs event loop. */
2734 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2737 #else /* not USE_GTK */
2739 /* We need a unique id for each widget handled by the Lucid Widget
2742 For the main windows, and popup menus, we use this counter,
2743 which we increment each time after use. This starts from 1<<16.
2745 For menu bars, we use numbers starting at 0, counted in
2746 next_menubar_widget_id. */
2747 LWLIB_ID widget_id_tick
;
2750 popup_selection_callback (widget
, id
, client_data
)
2753 XtPointer client_data
;
2755 menu_item_selection
= (Lisp_Object
*) client_data
;
2758 /* ARG is the LWLIB ID of the dialog box, represented
2759 as a Lisp object as (HIGHPART . LOWPART). */
2765 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2766 | XINT (XCDR (arg
)));
2769 lw_destroy_all_widgets (id
);
2771 popup_activated_flag
= 0;
2776 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2778 menu_item_selection will be set to the selection. */
2780 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2782 widget_value
*first_wv
;
2790 XButtonPressedEvent dummy
;
2794 if (! FRAME_X_P (f
))
2797 menu_id
= widget_id_tick
++;
2798 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2799 f
->output_data
.x
->widget
, 1, 0,
2800 popup_selection_callback
,
2801 popup_deactivate_callback
,
2802 menu_highlight_callback
);
2804 dummy
.type
= ButtonPress
;
2806 dummy
.send_event
= 0;
2807 dummy
.display
= FRAME_X_DISPLAY (f
);
2808 dummy
.time
= CurrentTime
;
2809 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2810 dummy
.window
= dummy
.root
;
2811 dummy
.subwindow
= dummy
.root
;
2815 /* Adjust coordinates to be root-window-relative. */
2816 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2817 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2824 for (i
= 0; i
< 5; i
++)
2825 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2828 /* Don't allow any geometry request from the user. */
2829 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2830 XtSetValues (menu
, av
, ac
);
2832 /* Display the menu. */
2833 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2834 popup_activated_flag
= 1;
2835 x_activate_timeout_atimer ();
2838 int fact
= 4 * sizeof (LWLIB_ID
);
2839 int specpdl_count
= SPECPDL_INDEX ();
2840 record_unwind_protect (pop_down_menu
,
2841 Fcons (make_number (menu_id
>> (fact
)),
2842 make_number (menu_id
& ~(-1 << (fact
)))));
2844 /* Process events that apply to the menu. */
2845 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
2847 unbind_to (specpdl_count
, Qnil
);
2851 #endif /* not USE_GTK */
2854 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2864 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2865 widget_value
**submenu_stack
2866 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2867 Lisp_Object
*subprefix_stack
2868 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2869 int submenu_depth
= 0;
2873 if (! FRAME_X_P (f
))
2878 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2880 *error
= "Empty menu";
2884 /* Create a tree of widget_value objects
2885 representing the panes and their items. */
2886 wv
= xmalloc_widget_value ();
2890 wv
->button_type
= BUTTON_TYPE_NONE
;
2895 /* Loop over all panes and items, filling in the tree. */
2897 while (i
< menu_items_used
)
2899 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2901 submenu_stack
[submenu_depth
++] = save_wv
;
2907 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2910 save_wv
= submenu_stack
[--submenu_depth
];
2914 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2915 && submenu_depth
!= 0)
2916 i
+= MENU_ITEMS_PANE_LENGTH
;
2917 /* Ignore a nil in the item list.
2918 It's meaningful only for dialog boxes. */
2919 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2921 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2923 /* Create a new pane. */
2924 Lisp_Object pane_name
, prefix
;
2927 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2928 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2930 #ifndef HAVE_MULTILINGUAL_MENU
2931 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2933 pane_name
= ENCODE_MENU_STRING (pane_name
);
2934 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2937 pane_string
= (NILP (pane_name
)
2938 ? "" : (char *) SDATA (pane_name
));
2939 /* If there is just one top-level pane, put all its items directly
2940 under the top-level menu. */
2941 if (menu_items_n_panes
== 1)
2944 /* If the pane has a meaningful name,
2945 make the pane a top-level menu item
2946 with its items as a submenu beneath it. */
2947 if (!keymaps
&& strcmp (pane_string
, ""))
2949 wv
= xmalloc_widget_value ();
2953 first_wv
->contents
= wv
;
2954 wv
->name
= pane_string
;
2955 if (keymaps
&& !NILP (prefix
))
2959 wv
->button_type
= BUTTON_TYPE_NONE
;
2964 else if (first_pane
)
2970 i
+= MENU_ITEMS_PANE_LENGTH
;
2974 /* Create a new item within current pane. */
2975 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2976 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2977 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2978 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2979 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2980 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2981 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2982 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2984 #ifndef HAVE_MULTILINGUAL_MENU
2985 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2987 item_name
= ENCODE_MENU_STRING (item_name
);
2988 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2991 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2993 descrip
= ENCODE_MENU_STRING (descrip
);
2994 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2996 #endif /* not HAVE_MULTILINGUAL_MENU */
2998 wv
= xmalloc_widget_value ();
3002 save_wv
->contents
= wv
;
3003 wv
->name
= (char *) SDATA (item_name
);
3004 if (!NILP (descrip
))
3005 wv
->key
= (char *) SDATA (descrip
);
3007 /* If this item has a null value,
3008 make the call_data null so that it won't display a box
3009 when the mouse is on it. */
3011 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
3012 wv
->enabled
= !NILP (enable
);
3015 wv
->button_type
= BUTTON_TYPE_NONE
;
3016 else if (EQ (type
, QCtoggle
))
3017 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
3018 else if (EQ (type
, QCradio
))
3019 wv
->button_type
= BUTTON_TYPE_RADIO
;
3023 wv
->selected
= !NILP (selected
);
3025 if (! STRINGP (help
))
3032 i
+= MENU_ITEMS_ITEM_LENGTH
;
3036 /* Deal with the title, if it is non-nil. */
3039 widget_value
*wv_title
= xmalloc_widget_value ();
3040 widget_value
*wv_sep1
= xmalloc_widget_value ();
3041 widget_value
*wv_sep2
= xmalloc_widget_value ();
3043 wv_sep2
->name
= "--";
3044 wv_sep2
->next
= first_wv
->contents
;
3045 wv_sep2
->help
= Qnil
;
3047 wv_sep1
->name
= "--";
3048 wv_sep1
->next
= wv_sep2
;
3049 wv_sep1
->help
= Qnil
;
3051 #ifndef HAVE_MULTILINGUAL_MENU
3052 if (STRING_MULTIBYTE (title
))
3053 title
= ENCODE_MENU_STRING (title
);
3056 wv_title
->name
= (char *) SDATA (title
);
3057 wv_title
->enabled
= TRUE
;
3058 wv_title
->button_type
= BUTTON_TYPE_NONE
;
3059 wv_title
->next
= wv_sep1
;
3060 wv_title
->help
= Qnil
;
3061 first_wv
->contents
= wv_title
;
3064 /* No selection has been chosen yet. */
3065 menu_item_selection
= 0;
3067 /* Actually create and show the menu until popped down. */
3068 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
3070 /* Free the widget_value objects we used to specify the contents. */
3071 free_menubar_widget_value_tree (first_wv
);
3073 /* Find the selected item, and its pane, to return
3074 the proper value. */
3075 if (menu_item_selection
!= 0)
3077 Lisp_Object prefix
, entry
;
3079 prefix
= entry
= Qnil
;
3081 while (i
< menu_items_used
)
3083 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
3085 subprefix_stack
[submenu_depth
++] = prefix
;
3089 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
3091 prefix
= subprefix_stack
[--submenu_depth
];
3094 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3097 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3098 i
+= MENU_ITEMS_PANE_LENGTH
;
3100 /* Ignore a nil in the item list.
3101 It's meaningful only for dialog boxes. */
3102 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3107 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3108 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3114 entry
= Fcons (entry
, Qnil
);
3116 entry
= Fcons (prefix
, entry
);
3117 for (j
= submenu_depth
- 1; j
>= 0; j
--)
3118 if (!NILP (subprefix_stack
[j
]))
3119 entry
= Fcons (subprefix_stack
[j
], entry
);
3123 i
+= MENU_ITEMS_ITEM_LENGTH
;
3127 else if (!for_click
)
3128 /* Make "Cancel" equivalent to C-g. */
3129 Fsignal (Qquit
, Qnil
);
3136 dialog_selection_callback (widget
, client_data
)
3138 gpointer client_data
;
3140 /* The EMACS_INT cast avoids a warning. There's no problem
3141 as long as pointers have enough bits to hold small integers. */
3142 if ((int) (EMACS_INT
) client_data
!= -1)
3143 menu_item_selection
= (Lisp_Object
*) client_data
;
3145 popup_activated_flag
= 0;
3148 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
3150 menu_item_selection will be set to the selection. */
3152 create_and_show_dialog (f
, first_wv
)
3154 widget_value
*first_wv
;
3158 if (! FRAME_X_P (f
))
3161 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
3162 G_CALLBACK (dialog_selection_callback
),
3163 G_CALLBACK (popup_deactivate_callback
),
3168 int specpdl_count
= SPECPDL_INDEX ();
3169 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
3171 /* Display the menu. */
3172 gtk_widget_show_all (menu
);
3174 /* Process events that apply to the menu. */
3175 popup_widget_loop (1, menu
);
3177 unbind_to (specpdl_count
, Qnil
);
3181 #else /* not USE_GTK */
3183 dialog_selection_callback (widget
, id
, client_data
)
3186 XtPointer client_data
;
3188 /* The EMACS_INT cast avoids a warning. There's no problem
3189 as long as pointers have enough bits to hold small integers. */
3190 if ((int) (EMACS_INT
) client_data
!= -1)
3191 menu_item_selection
= (Lisp_Object
*) client_data
;
3194 lw_destroy_all_widgets (id
);
3196 popup_activated_flag
= 0;
3200 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
3202 menu_item_selection will be set to the selection. */
3204 create_and_show_dialog (f
, first_wv
)
3206 widget_value
*first_wv
;
3213 dialog_id
= widget_id_tick
++;
3214 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
3215 f
->output_data
.x
->widget
, 1, 0,
3216 dialog_selection_callback
, 0, 0);
3217 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
3219 /* Display the dialog box. */
3220 lw_pop_up_all_widgets (dialog_id
);
3221 popup_activated_flag
= 1;
3222 x_activate_timeout_atimer ();
3224 /* Process events that apply to the dialog box.
3225 Also handle timers. */
3227 int count
= SPECPDL_INDEX ();
3228 int fact
= 4 * sizeof (LWLIB_ID
);
3230 /* xdialog_show_unwind is responsible for popping the dialog box down. */
3231 record_unwind_protect (pop_down_menu
,
3232 Fcons (make_number (dialog_id
>> (fact
)),
3233 make_number (dialog_id
& ~(-1 << (fact
)))));
3235 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
3238 unbind_to (count
, Qnil
);
3242 #endif /* not USE_GTK */
3244 static char * button_names
[] = {
3245 "button1", "button2", "button3", "button4", "button5",
3246 "button6", "button7", "button8", "button9", "button10" };
3249 xdialog_show (f
, keymaps
, title
, header
, error_name
)
3252 Lisp_Object title
, header
;
3255 int i
, nb_buttons
=0;
3256 char dialog_name
[6];
3258 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
3260 /* Number of elements seen so far, before boundary. */
3262 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
3263 int boundary_seen
= 0;
3265 if (! FRAME_X_P (f
))
3270 if (menu_items_n_panes
> 1)
3272 *error_name
= "Multiple panes in dialog box";
3276 /* Create a tree of widget_value objects
3277 representing the text label and buttons. */
3279 Lisp_Object pane_name
, prefix
;
3281 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
3282 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
3283 pane_string
= (NILP (pane_name
)
3284 ? "" : (char *) SDATA (pane_name
));
3285 prev_wv
= xmalloc_widget_value ();
3286 prev_wv
->value
= pane_string
;
3287 if (keymaps
&& !NILP (prefix
))
3289 prev_wv
->enabled
= 1;
3290 prev_wv
->name
= "message";
3291 prev_wv
->help
= Qnil
;
3294 /* Loop over all panes and items, filling in the tree. */
3295 i
= MENU_ITEMS_PANE_LENGTH
;
3296 while (i
< menu_items_used
)
3299 /* Create a new item within current pane. */
3300 Lisp_Object item_name
, enable
, descrip
;
3301 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3302 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3304 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3306 if (NILP (item_name
))
3308 free_menubar_widget_value_tree (first_wv
);
3309 *error_name
= "Submenu in dialog items";
3312 if (EQ (item_name
, Qquote
))
3314 /* This is the boundary between left-side elts
3315 and right-side elts. Stop incrementing right_count. */
3320 if (nb_buttons
>= 9)
3322 free_menubar_widget_value_tree (first_wv
);
3323 *error_name
= "Too many dialog items";
3327 wv
= xmalloc_widget_value ();
3329 wv
->name
= (char *) button_names
[nb_buttons
];
3330 if (!NILP (descrip
))
3331 wv
->key
= (char *) SDATA (descrip
);
3332 wv
->value
= (char *) SDATA (item_name
);
3333 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3334 wv
->enabled
= !NILP (enable
);
3338 if (! boundary_seen
)
3342 i
+= MENU_ITEMS_ITEM_LENGTH
;
3345 /* If the boundary was not specified,
3346 by default put half on the left and half on the right. */
3347 if (! boundary_seen
)
3348 left_count
= nb_buttons
- nb_buttons
/ 2;
3350 wv
= xmalloc_widget_value ();
3351 wv
->name
= dialog_name
;
3354 /* Frame title: 'Q' = Question, 'I' = Information.
3355 Can also have 'E' = Error if, one day, we want
3356 a popup for errors. */
3358 dialog_name
[0] = 'Q';
3360 dialog_name
[0] = 'I';
3362 /* Dialog boxes use a really stupid name encoding
3363 which specifies how many buttons to use
3364 and how many buttons are on the right. */
3365 dialog_name
[1] = '0' + nb_buttons
;
3366 dialog_name
[2] = 'B';
3367 dialog_name
[3] = 'R';
3368 /* Number of buttons to put on the right. */
3369 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3371 wv
->contents
= first_wv
;
3375 /* No selection has been chosen yet. */
3376 menu_item_selection
= 0;
3378 /* Actually create and show the dialog. */
3379 create_and_show_dialog (f
, first_wv
);
3381 /* Free the widget_value objects we used to specify the contents. */
3382 free_menubar_widget_value_tree (first_wv
);
3384 /* Find the selected item, and its pane, to return
3385 the proper value. */
3386 if (menu_item_selection
!= 0)
3392 while (i
< menu_items_used
)
3396 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3399 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3400 i
+= MENU_ITEMS_PANE_LENGTH
;
3402 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3404 /* This is the boundary between left-side elts and
3411 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3412 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3416 entry
= Fcons (entry
, Qnil
);
3418 entry
= Fcons (prefix
, entry
);
3422 i
+= MENU_ITEMS_ITEM_LENGTH
;
3427 /* Make "Cancel" equivalent to C-g. */
3428 Fsignal (Qquit
, Qnil
);
3433 #else /* not USE_X_TOOLKIT && not USE_GTK */
3435 /* The frame of the last activated non-toolkit menu bar.
3436 Used to generate menu help events. */
3438 static struct frame
*menu_help_frame
;
3441 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3443 PANE is the pane number, and ITEM is the menu item number in
3444 the menu (currently not used).
3446 This cannot be done with generating a HELP_EVENT because
3447 XMenuActivate contains a loop that doesn't let Emacs process
3451 menu_help_callback (help_string
, pane
, item
)
3455 extern Lisp_Object Qmenu_item
;
3456 Lisp_Object
*first_item
;
3457 Lisp_Object pane_name
;
3458 Lisp_Object menu_object
;
3460 first_item
= XVECTOR (menu_items
)->contents
;
3461 if (EQ (first_item
[0], Qt
))
3462 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3463 else if (EQ (first_item
[0], Qquote
))
3464 /* This shouldn't happen, see xmenu_show. */
3465 pane_name
= empty_string
;
3467 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3469 /* (menu-item MENU-NAME PANE-NUMBER) */
3470 menu_object
= Fcons (Qmenu_item
,
3472 Fcons (make_number (pane
), Qnil
)));
3473 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3474 Qnil
, menu_object
, make_number (item
), 1);
3481 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
3482 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
3484 FRAME_PTR f
= p1
->pointer
;
3485 XMenu
*menu
= p2
->pointer
;
3489 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
3490 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
3492 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3494 #ifdef HAVE_X_WINDOWS
3495 /* Assume the mouse has moved out of the X window.
3496 If it has actually moved in, we will get an EnterNotify. */
3497 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3499 /* State that no mouse buttons are now held.
3500 (The oldXMenu code doesn't track this info for us.)
3501 That is not necessarily true, but the fiction leads to reasonable
3502 results, and it is a pain to ask which are actually held now. */
3503 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3505 #endif /* HAVE_X_WINDOWS */
3514 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3524 int pane
, selidx
, lpane
, status
;
3525 Lisp_Object entry
, pane_prefix
;
3527 int ulx
, uly
, width
, height
;
3528 int dispwidth
, dispheight
;
3529 int i
, j
, lines
, maxlines
;
3532 unsigned int dummy_uint
;
3533 int specpdl_count
= SPECPDL_INDEX ();
3535 if (! FRAME_X_P (f
))
3539 if (menu_items_n_panes
== 0)
3542 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3544 *error
= "Empty menu";
3548 /* Figure out which root window F is on. */
3549 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3550 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3551 &dummy_uint
, &dummy_uint
);
3553 /* Make the menu on that window. */
3554 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3557 *error
= "Can't create menu";
3561 /* Don't GC while we prepare and show the menu,
3562 because we give the oldxmenu library pointers to the
3563 contents of strings. */
3564 inhibit_garbage_collection ();
3566 #ifdef HAVE_X_WINDOWS
3567 /* Adjust coordinates to relative to the outer (window manager) window. */
3568 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
3569 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
3570 #endif /* HAVE_X_WINDOWS */
3572 /* Adjust coordinates to be root-window-relative. */
3576 /* Create all the necessary panes and their items. */
3577 maxlines
= lines
= i
= 0;
3578 while (i
< menu_items_used
)
3580 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3582 /* Create a new pane. */
3583 Lisp_Object pane_name
, prefix
;
3586 maxlines
= max (maxlines
, lines
);
3588 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3589 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3590 pane_string
= (NILP (pane_name
)
3591 ? "" : (char *) SDATA (pane_name
));
3592 if (keymaps
&& !NILP (prefix
))
3595 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3596 if (lpane
== XM_FAILURE
)
3598 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3599 *error
= "Can't create pane";
3602 i
+= MENU_ITEMS_PANE_LENGTH
;
3604 /* Find the width of the widest item in this pane. */
3607 while (j
< menu_items_used
)
3610 item
= XVECTOR (menu_items
)->contents
[j
];
3618 width
= SBYTES (item
);
3619 if (width
> maxwidth
)
3622 j
+= MENU_ITEMS_ITEM_LENGTH
;
3625 /* Ignore a nil in the item list.
3626 It's meaningful only for dialog boxes. */
3627 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3631 /* Create a new item within current pane. */
3632 Lisp_Object item_name
, enable
, descrip
, help
;
3633 unsigned char *item_data
;
3636 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3637 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3639 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3640 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3641 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3643 if (!NILP (descrip
))
3645 int gap
= maxwidth
- SBYTES (item_name
);
3648 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3649 item_name
= concat2 (item_name
, spacer
);
3650 item_name
= concat2 (item_name
, descrip
);
3651 item_data
= SDATA (item_name
);
3653 /* if alloca is fast, use that to make the space,
3654 to reduce gc needs. */
3656 = (unsigned char *) alloca (maxwidth
3657 + SBYTES (descrip
) + 1);
3658 bcopy (SDATA (item_name
), item_data
,
3659 SBYTES (item_name
));
3660 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3662 bcopy (SDATA (descrip
), item_data
+ j
,
3664 item_data
[j
+ SBYTES (descrip
)] = 0;
3668 item_data
= SDATA (item_name
);
3670 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3671 menu
, lpane
, 0, item_data
,
3672 !NILP (enable
), help_string
)
3675 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3676 *error
= "Can't add selection to menu";
3679 i
+= MENU_ITEMS_ITEM_LENGTH
;
3684 maxlines
= max (maxlines
, lines
);
3686 /* All set and ready to fly. */
3687 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3688 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3689 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3690 x
= min (x
, dispwidth
);
3691 y
= min (y
, dispheight
);
3694 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3695 &ulx
, &uly
, &width
, &height
);
3696 if (ulx
+width
> dispwidth
)
3698 x
-= (ulx
+ width
) - dispwidth
;
3699 ulx
= dispwidth
- width
;
3701 if (uly
+height
> dispheight
)
3703 y
-= (uly
+ height
) - dispheight
;
3704 uly
= dispheight
- height
;
3706 if (ulx
< 0) x
-= ulx
;
3707 if (uly
< 0) y
-= uly
;
3711 /* If position was not given by a mouse click, adjust so upper left
3712 corner of the menu as a whole ends up at given coordinates. This
3713 is what x-popup-menu says in its documentation. */
3715 y
+= 1.5*height
/(maxlines
+2);
3718 XMenuSetAEQ (menu
, TRUE
);
3719 XMenuSetFreeze (menu
, TRUE
);
3723 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3726 record_unwind_protect (pop_down_menu
,
3727 Fcons (make_save_value (f
, 0),
3728 make_save_value (menu
, 0)));
3730 /* Help display under X won't work because XMenuActivate contains
3731 a loop that doesn't give Emacs a chance to process it. */
3732 menu_help_frame
= f
;
3733 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3734 x
, y
, ButtonReleaseMask
, &datap
,
3735 menu_help_callback
);
3741 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3744 /* Find the item number SELIDX in pane number PANE. */
3746 while (i
< menu_items_used
)
3748 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3752 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3754 i
+= MENU_ITEMS_PANE_LENGTH
;
3763 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3766 entry
= Fcons (entry
, Qnil
);
3767 if (!NILP (pane_prefix
))
3768 entry
= Fcons (pane_prefix
, entry
);
3774 i
+= MENU_ITEMS_ITEM_LENGTH
;
3780 *error
= "Can't activate menu";
3785 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3786 the menu was invoked with a mouse event as POSITION). */
3788 Fsignal (Qquit
, Qnil
);
3793 unbind_to (specpdl_count
, Qnil
);
3798 #endif /* not USE_X_TOOLKIT */
3800 #endif /* HAVE_MENUS */
3802 /* Detect if a dialog or menu has been posted. */
3807 return popup_activated_flag
;
3810 /* The following is used by delayed window autoselection. */
3812 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
3813 doc
: /* Return t if a menu or popup dialog is active. */)
3817 return (popup_activated ()) ? Qt
: Qnil
;
3820 #endif /* HAVE_MENUS */
3826 staticpro (&menu_items
);
3828 menu_items_inuse
= Qnil
;
3830 Qdebug_on_next_call
= intern ("debug-on-next-call");
3831 staticpro (&Qdebug_on_next_call
);
3833 #ifdef USE_X_TOOLKIT
3834 widget_id_tick
= (1<<16);
3835 next_menubar_widget_id
= 1;
3838 defsubr (&Sx_popup_menu
);
3839 defsubr (&Smenu_or_popup_active_p
);
3841 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
3842 defsubr (&Sx_menu_bar_open_internal
);
3843 Ffset (intern ("accelerate-menu"),
3844 intern (Sx_menu_bar_open_internal
.symbol_name
));
3848 defsubr (&Sx_popup_dialog
);
3852 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3853 (do not change this comment) */