1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1999, 2000, 2001, 2003, 2004,
3 2005 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* X pop-up deck-of-cards menu facility for GNU Emacs.
24 * Written by Jon Arnold and Roman Budzianowski
25 * Mods and rewrite by Robert Krawitz
29 /* Modified by Fred Pierresteguy on December 93
30 to make the popup menus and menubar use the Xt. */
32 /* Rewritten for clarity and GC protection by rms in Feb 94. */
36 /* On 4.3 this loses if it comes after xterm.h. */
42 #include "termhooks.h"
47 #include "blockinput.h"
51 #include "sysselect.h"
58 /* This may include sys/types.h, and that somehow loses
59 if this is not done before the other system files. */
63 /* Load sys/types.h if not already loaded.
64 In some systems loading it twice is suicidal. */
66 #include <sys/types.h>
69 #include "dispextern.h"
72 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
73 code accepts the Emacs internal encoding. */
74 #undef HAVE_MULTILINGUAL_MENU
78 #include <X11/IntrinsicP.h>
79 #include <X11/CoreP.h>
80 #include <X11/StringDefs.h>
81 #include <X11/Shell.h>
83 #include <X11/Xaw/Paned.h>
84 #endif /* USE_LUCID */
85 #include "../lwlib/lwlib.h"
86 #else /* not USE_X_TOOLKIT */
88 #include "../oldXMenu/XMenu.h"
90 #endif /* not USE_X_TOOLKIT */
91 #endif /* HAVE_X_WINDOWS */
98 Lisp_Object Vmenu_updating_frame
;
100 Lisp_Object Qdebug_on_next_call
;
102 extern Lisp_Object Qmenu_bar
;
104 extern Lisp_Object QCtoggle
, QCradio
;
106 extern Lisp_Object Voverriding_local_map
;
107 extern Lisp_Object Voverriding_local_map_menu_flag
;
109 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
111 extern Lisp_Object Qmenu_bar_update_hook
;
114 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
115 extern XtAppContext Xt_app_con
;
117 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, char **));
118 static void popup_get_selection
P_ ((XEvent
*, struct x_display_info
*,
121 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
124 #endif /* USE_X_TOOLKIT */
129 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
130 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, char **));
133 /* This is how to deal with multibyte text if HAVE_MULTILINGUAL_MENU
134 isn't defined. The use of HAVE_MULTILINGUAL_MENU could probably be
135 confined to an extended version of this with sections of code below
136 using it unconditionally. */
138 /* gtk just uses utf-8. */
139 # define ENCODE_MENU_STRING(str) ENCODE_UTF_8 (str)
140 #elif defined HAVE_X_I18N
141 # define ENCODE_MENU_STRING(str) ENCODE_SYSTEM (str)
143 # define ENCODE_MENU_STRING(str) string_make_unibyte (str)
146 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
147 Lisp_Object
, Lisp_Object
, Lisp_Object
,
148 Lisp_Object
, Lisp_Object
));
149 static int update_frame_menubar
P_ ((struct frame
*));
150 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
151 Lisp_Object
, char **));
152 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
153 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
155 static void list_of_panes
P_ ((Lisp_Object
));
156 static void list_of_items
P_ ((Lisp_Object
));
159 /* This holds a Lisp vector that holds the results of decoding
160 the keymaps or alist-of-alists that specify a menu.
162 It describes the panes and items within the panes.
164 Each pane is described by 3 elements in the vector:
165 t, the pane name, the pane's prefix key.
166 Then follow the pane's items, with 5 elements per item:
167 the item string, the enable flag, the item's value,
168 the definition, and the equivalent keyboard key's description string.
170 In some cases, multiple levels of menus may be described.
171 A single vector slot containing nil indicates the start of a submenu.
172 A single vector slot containing lambda indicates the end of a submenu.
173 The submenu follows a menu item which is the way to reach the submenu.
175 A single vector slot containing quote indicates that the
176 following items should appear on the right of a dialog box.
178 Using a Lisp vector to hold this information while we decode it
179 takes care of protecting all the data from GC. */
181 #define MENU_ITEMS_PANE_NAME 1
182 #define MENU_ITEMS_PANE_PREFIX 2
183 #define MENU_ITEMS_PANE_LENGTH 3
187 MENU_ITEMS_ITEM_NAME
= 0,
188 MENU_ITEMS_ITEM_ENABLE
,
189 MENU_ITEMS_ITEM_VALUE
,
190 MENU_ITEMS_ITEM_EQUIV_KEY
,
191 MENU_ITEMS_ITEM_DEFINITION
,
192 MENU_ITEMS_ITEM_TYPE
,
193 MENU_ITEMS_ITEM_SELECTED
,
194 MENU_ITEMS_ITEM_HELP
,
195 MENU_ITEMS_ITEM_LENGTH
198 static Lisp_Object menu_items
;
200 /* If non-nil, means that the global vars defined here are already in use.
201 Used to detect cases where we try to re-enter this non-reentrant code. */
202 static Lisp_Object menu_items_inuse
;
204 /* Number of slots currently allocated in menu_items. */
205 static int menu_items_allocated
;
207 /* This is the index in menu_items of the first empty slot. */
208 static int menu_items_used
;
210 /* The number of panes currently recorded in menu_items,
211 excluding those within submenus. */
212 static int menu_items_n_panes
;
214 /* Current depth within submenus. */
215 static int menu_items_submenu_depth
;
217 /* Flag which when set indicates a dialog or menu has been posted by
218 Xt on behalf of one of the widget sets. */
219 static int popup_activated_flag
;
221 static int next_menubar_widget_id
;
223 /* This is set nonzero after the user activates the menu bar, and set
224 to zero again after the menu bars are redisplayed by prepare_menu_bar.
225 While it is nonzero, all calls to set_frame_menubar go deep.
227 I don't understand why this is needed, but it does seem to be
228 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
230 int pending_menu_activation
;
234 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
236 static struct frame
*
237 menubar_id_to_frame (id
)
240 Lisp_Object tail
, frame
;
243 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
246 if (!GC_FRAMEP (frame
))
249 if (!FRAME_WINDOW_P (f
))
251 if (f
->output_data
.x
->id
== id
)
259 /* Initialize the menu_items structure if we haven't already done so.
260 Also mark it as currently empty. */
265 if (NILP (menu_items
))
267 menu_items_allocated
= 60;
268 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
271 if (!NILP (menu_items_inuse
))
272 error ("Trying to use a menu from within a menu-entry");
273 menu_items_inuse
= Qt
;
275 menu_items_n_panes
= 0;
276 menu_items_submenu_depth
= 0;
279 /* Call at the end of generating the data in menu_items. */
287 unuse_menu_items (dummy
)
290 return menu_items_inuse
= Qnil
;
293 /* Call when finished using the data for the current menu
297 discard_menu_items ()
299 /* Free the structure if it is especially large.
300 Otherwise, hold on to it, to save time. */
301 if (menu_items_allocated
> 200)
304 menu_items_allocated
= 0;
306 xassert (NILP (menu_items_inuse
));
309 /* Make the menu_items vector twice as large. */
315 int old_size
= menu_items_allocated
;
318 menu_items_allocated
*= 2;
319 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
320 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
321 old_size
* sizeof (Lisp_Object
));
324 /* Begin a submenu. */
327 push_submenu_start ()
329 if (menu_items_used
+ 1 > menu_items_allocated
)
332 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
333 menu_items_submenu_depth
++;
341 if (menu_items_used
+ 1 > menu_items_allocated
)
344 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
345 menu_items_submenu_depth
--;
348 /* Indicate boundary between left and right. */
351 push_left_right_boundary ()
353 if (menu_items_used
+ 1 > menu_items_allocated
)
356 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
359 /* Start a new menu pane in menu_items.
360 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
363 push_menu_pane (name
, prefix_vec
)
364 Lisp_Object name
, prefix_vec
;
366 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
369 if (menu_items_submenu_depth
== 0)
370 menu_items_n_panes
++;
371 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
372 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
373 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
376 /* Push one menu item into the current pane. NAME is the string to
377 display. ENABLE if non-nil means this item can be selected. KEY
378 is the key generated by choosing this item, or nil if this item
379 doesn't really have a definition. DEF is the definition of this
380 item. EQUIV is the textual description of the keyboard equivalent
381 for this item (or nil if none). TYPE is the type of this menu
382 item, one of nil, `toggle' or `radio'. */
385 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
386 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
388 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
391 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
392 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
393 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
394 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
395 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
396 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
397 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
398 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
401 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
402 and generate menu panes for them in menu_items.
403 If NOTREAL is nonzero,
404 don't bother really computing whether an item is enabled. */
407 keymap_panes (keymaps
, nmaps
, notreal
)
408 Lisp_Object
*keymaps
;
416 /* Loop over the given keymaps, making a pane for each map.
417 But don't make a pane that is empty--ignore that map instead.
418 P is the number of panes we have made so far. */
419 for (mapno
= 0; mapno
< nmaps
; mapno
++)
420 single_keymap_panes (keymaps
[mapno
],
421 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
423 finish_menu_items ();
426 /* Args passed between single_keymap_panes and single_menu_item. */
429 Lisp_Object pending_maps
;
430 int maxdepth
, notreal
;
434 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
437 /* This is a recursive subroutine of keymap_panes.
438 It handles one keymap, KEYMAP.
439 The other arguments are passed along
440 or point to local variables of the previous function.
441 If NOTREAL is nonzero, only check for equivalent key bindings, don't
442 evaluate expressions in menu items and don't make any menu.
444 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
447 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
449 Lisp_Object pane_name
;
457 skp
.pending_maps
= Qnil
;
458 skp
.maxdepth
= maxdepth
;
459 skp
.notreal
= notreal
;
465 push_menu_pane (pane_name
, prefix
);
468 /* Remember index for first item in this pane so we can go back and
469 add a prefix when (if) we see the first button. After that, notbuttons
470 is set to 0, to mark that we have seen a button and all non button
471 items need a prefix. */
472 skp
.notbuttons
= menu_items_used
;
475 GCPRO1 (skp
.pending_maps
);
476 map_keymap (keymap
, single_menu_item
, Qnil
, &skp
, 1);
479 /* Process now any submenus which want to be panes at this level. */
480 while (CONSP (skp
.pending_maps
))
482 Lisp_Object elt
, eltcdr
, string
;
483 elt
= XCAR (skp
.pending_maps
);
485 string
= XCAR (eltcdr
);
486 /* We no longer discard the @ from the beginning of the string here.
487 Instead, we do this in xmenu_show. */
488 single_keymap_panes (Fcar (elt
), string
,
489 XCDR (eltcdr
), notreal
, maxdepth
- 1);
490 skp
.pending_maps
= XCDR (skp
.pending_maps
);
494 /* This is a subroutine of single_keymap_panes that handles one
496 KEY is a key in a keymap and ITEM is its binding.
497 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
499 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
500 evaluate expressions in menu items and don't make any menu.
501 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
502 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
503 buttons. It keeps track of if we have seen a button in this menu or
507 single_menu_item (key
, item
, dummy
, skp_v
)
508 Lisp_Object key
, item
, dummy
;
511 Lisp_Object map
, item_string
, enabled
;
512 struct gcpro gcpro1
, gcpro2
;
514 struct skp
*skp
= skp_v
;
516 /* Parse the menu item and leave the result in item_properties. */
518 res
= parse_menu_item (item
, skp
->notreal
, 0);
521 return; /* Not a menu item. */
523 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
527 /* We don't want to make a menu, just traverse the keymaps to
528 precompute equivalent key bindings. */
530 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
534 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
535 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
537 if (!NILP (map
) && SREF (item_string
, 0) == '@')
540 /* An enabled separate pane. Remember this to handle it later. */
541 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
547 /* Simulate radio buttons and toggle boxes by putting a prefix in
550 Lisp_Object prefix
= Qnil
;
551 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
555 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
558 /* The first button. Line up previous items in this menu. */
560 int index
= skp
->notbuttons
; /* Index for first item this menu. */
563 while (index
< menu_items_used
)
566 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
570 submenu
++; /* Skip sub menu. */
572 else if (EQ (tem
, Qlambda
))
575 submenu
--; /* End sub menu. */
577 else if (EQ (tem
, Qt
))
578 index
+= 3; /* Skip new pane marker. */
579 else if (EQ (tem
, Qquote
))
580 index
++; /* Skip a left, right divider. */
583 if (!submenu
&& SREF (tem
, 0) != '\0'
584 && SREF (tem
, 0) != '-')
585 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
586 = concat2 (build_string (" "), tem
);
587 index
+= MENU_ITEMS_ITEM_LENGTH
;
593 /* Calculate prefix, if any, for this item. */
594 if (EQ (type
, QCtoggle
))
595 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
596 else if (EQ (type
, QCradio
))
597 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
599 /* Not a button. If we have earlier buttons, then we need a prefix. */
600 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
601 && SREF (item_string
, 0) != '-')
602 prefix
= build_string (" ");
605 item_string
= concat2 (prefix
, item_string
);
607 #endif /* not HAVE_BOXES */
609 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
611 /* Indicate visually that this is a submenu. */
612 item_string
= concat2 (item_string
, build_string (" >"));
615 push_menu_item (item_string
, enabled
, key
,
616 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
617 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
618 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
619 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
620 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
622 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
623 /* Display a submenu using the toolkit. */
624 if (! (NILP (map
) || NILP (enabled
)))
626 push_submenu_start ();
627 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
633 /* Push all the panes and items of a menu described by the
634 alist-of-alists MENU.
635 This handles old-fashioned calls to x-popup-menu. */
645 for (tail
= menu
; CONSP (tail
); tail
= XCDR (tail
))
647 Lisp_Object elt
, pane_name
, pane_data
;
649 pane_name
= Fcar (elt
);
650 CHECK_STRING (pane_name
);
651 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
652 pane_data
= Fcdr (elt
);
653 CHECK_CONS (pane_data
);
654 list_of_items (pane_data
);
657 finish_menu_items ();
660 /* Push the items in a single pane defined by the alist PANE. */
666 Lisp_Object tail
, item
, item1
;
668 for (tail
= pane
; CONSP (tail
); tail
= XCDR (tail
))
672 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
673 Qnil
, Qnil
, Qnil
, Qnil
);
674 else if (CONSP (item
))
677 CHECK_STRING (item1
);
678 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, XCDR (item
),
679 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
682 push_left_right_boundary ();
687 #ifdef HAVE_X_WINDOWS
688 /* Return the mouse position in *X and *Y. The coordinates are window
689 relative for the edit window in frame F.
690 This is for Fx_popup_menu. The mouse_position_hook can not
691 be used for X, as it returns window relative coordinates
692 for the window where the mouse is in. This could be the menu bar,
693 the scroll bar or the edit window. Fx_popup_menu needs to be
694 sure it is the edit window. */
696 mouse_position_for_popup (f
, x
, y
)
701 Window root
, dummy_window
;
706 XQueryPointer (FRAME_X_DISPLAY (f
),
707 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
709 /* The root window which contains the pointer. */
712 /* Window pointer is on, not used */
715 /* The position on that root window. */
718 /* x/y in dummy_window coordinates, not used. */
721 /* Modifier keys and pointer buttons, about which
723 (unsigned int *) &dummy
);
727 /* xmenu_show expects window coordinates, not root window
728 coordinates. Translate. */
729 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
730 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
733 #endif /* HAVE_X_WINDOWS */
735 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
736 doc
: /* Pop up a deck-of-cards menu and return user's selection.
737 POSITION is a position specification. This is either a mouse button event
738 or a list ((XOFFSET YOFFSET) WINDOW)
739 where XOFFSET and YOFFSET are positions in pixels from the top left
740 corner of WINDOW. (WINDOW may be a window or a frame object.)
741 This controls the position of the top left of the menu as a whole.
742 If POSITION is t, it means to use the current mouse position.
744 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
745 The menu items come from key bindings that have a menu string as well as
746 a definition; actually, the "definition" in such a key binding looks like
747 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
748 the keymap as a top-level element.
750 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
751 Otherwise, REAL-DEFINITION should be a valid key binding definition.
753 You can also use a list of keymaps as MENU.
754 Then each keymap makes a separate pane.
756 When MENU is a keymap or a list of keymaps, the return value is the
757 list of events corresponding to the user's choice. Note that
758 `x-popup-menu' does not actually execute the command bound to that
761 Alternatively, you can specify a menu of multiple panes
762 with a list of the form (TITLE PANE1 PANE2...),
763 where each pane is a list of form (TITLE ITEM1 ITEM2...).
764 Each ITEM is normally a cons cell (STRING . VALUE);
765 but a string can appear as an item--that makes a nonselectable line
767 With this form of menu, the return value is VALUE from the chosen item.
769 If POSITION is nil, don't display the menu at all, just precalculate the
770 cached information about equivalent key sequences. */)
772 Lisp_Object position
, menu
;
774 Lisp_Object keymap
, tem
;
775 int xpos
= 0, ypos
= 0;
777 char *error_name
= NULL
;
778 Lisp_Object selection
;
780 Lisp_Object x
, y
, window
;
783 int specpdl_count
= SPECPDL_INDEX ();
787 if (! NILP (position
))
789 int get_current_pos_p
= 0;
792 /* Decode the first argument: find the window and the coordinates. */
793 if (EQ (position
, Qt
)
794 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
795 || EQ (XCAR (position
), Qtool_bar
))))
797 get_current_pos_p
= 1;
801 tem
= Fcar (position
);
804 window
= Fcar (Fcdr (position
));
806 y
= Fcar (XCDR (tem
));
811 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
812 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
813 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
818 /* If a click happens in an external tool bar or a detached
819 tool bar, x and y is NIL. In that case, use the current
820 mouse position. This happens for the help button in the
821 tool bar. Ideally popup-menu should pass NIL to
822 this function, but it doesn't. */
823 if (NILP (x
) && NILP (y
))
824 get_current_pos_p
= 1;
827 if (get_current_pos_p
)
829 /* Use the mouse's current position. */
830 FRAME_PTR new_f
= SELECTED_FRAME ();
831 #ifdef HAVE_X_WINDOWS
832 /* Can't use mouse_position_hook for X since it returns
833 coordinates relative to the window the mouse is in,
834 we need coordinates relative to the edit widget always. */
839 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
840 /* cur_x/y may be negative, so use make_number. */
841 x
= make_number (cur_x
);
842 y
= make_number (cur_y
);
845 #else /* not HAVE_X_WINDOWS */
846 Lisp_Object bar_window
;
847 enum scroll_bar_part part
;
850 if (mouse_position_hook
)
851 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
852 &part
, &x
, &y
, &time
);
853 #endif /* not HAVE_X_WINDOWS */
856 XSETFRAME (window
, new_f
);
859 window
= selected_window
;
868 /* Decode where to put the menu. */
876 else if (WINDOWP (window
))
878 CHECK_LIVE_WINDOW (window
);
879 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
881 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
882 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
885 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
886 but I don't want to make one now. */
887 CHECK_WINDOW (window
);
892 Vmenu_updating_frame
= Qnil
;
893 #endif /* HAVE_MENUS */
895 record_unwind_protect (unuse_menu_items
, Qnil
);
899 /* Decode the menu items from what was specified. */
901 keymap
= get_keymap (menu
, 0, 0);
904 /* We were given a keymap. Extract menu info from the keymap. */
907 /* Extract the detailed info to make one pane. */
908 keymap_panes (&menu
, 1, NILP (position
));
910 /* Search for a string appearing directly as an element of the keymap.
911 That string is the title of the menu. */
912 prompt
= Fkeymap_prompt (keymap
);
913 if (NILP (title
) && !NILP (prompt
))
916 /* Make that be the pane title of the first pane. */
917 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
918 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
922 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
924 /* We were given a list of keymaps. */
925 int nmaps
= XFASTINT (Flength (menu
));
927 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
932 /* The first keymap that has a prompt string
933 supplies the menu title. */
934 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
938 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
940 prompt
= Fkeymap_prompt (keymap
);
941 if (NILP (title
) && !NILP (prompt
))
945 /* Extract the detailed info to make one pane. */
946 keymap_panes (maps
, nmaps
, NILP (position
));
948 /* Make the title be the pane title of the first pane. */
949 if (!NILP (title
) && menu_items_n_panes
>= 0)
950 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
956 /* We were given an old-fashioned menu. */
958 CHECK_STRING (title
);
960 list_of_panes (Fcdr (menu
));
965 unbind_to (specpdl_count
, Qnil
);
969 discard_menu_items ();
975 /* Display them in a menu. */
978 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
979 keymaps
, title
, &error_name
);
982 discard_menu_items ();
985 #endif /* HAVE_MENUS */
987 if (error_name
) error (error_name
);
993 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
994 doc
: /* Pop up a dialog box and return user's selection.
995 POSITION specifies which frame to use.
996 This is normally a mouse button event or a window or frame.
997 If POSITION is t, it means to use the frame the mouse is on.
998 The dialog box appears in the middle of the specified frame.
1000 CONTENTS specifies the alternatives to display in the dialog box.
1001 It is a list of the form (TITLE ITEM1 ITEM2...).
1002 Each ITEM is a cons cell (STRING . VALUE).
1003 The return value is VALUE from the chosen item.
1005 An ITEM may also be just a string--that makes a nonselectable item.
1006 An ITEM may also be nil--that means to put all preceding items
1007 on the left of the dialog box and all following items on the right.
1008 \(By default, approximately half appear on each side.) */)
1009 (position
, contents
)
1010 Lisp_Object position
, contents
;
1017 /* Decode the first argument: find the window or frame to use. */
1018 if (EQ (position
, Qt
)
1019 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1020 || EQ (XCAR (position
), Qtool_bar
))))
1022 #if 0 /* Using the frame the mouse is on may not be right. */
1023 /* Use the mouse's current position. */
1024 FRAME_PTR new_f
= SELECTED_FRAME ();
1025 Lisp_Object bar_window
;
1026 enum scroll_bar_part part
;
1030 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1033 XSETFRAME (window
, new_f
);
1035 window
= selected_window
;
1037 window
= selected_window
;
1039 else if (CONSP (position
))
1042 tem
= Fcar (position
);
1044 window
= Fcar (Fcdr (position
));
1047 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1048 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1051 else if (WINDOWP (position
) || FRAMEP (position
))
1056 /* Decode where to put the menu. */
1058 if (FRAMEP (window
))
1059 f
= XFRAME (window
);
1060 else if (WINDOWP (window
))
1062 CHECK_LIVE_WINDOW (window
);
1063 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1066 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1067 but I don't want to make one now. */
1068 CHECK_WINDOW (window
);
1070 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1071 /* Display a menu with these alternatives
1072 in the middle of frame F. */
1074 Lisp_Object x
, y
, frame
, newpos
;
1075 XSETFRAME (frame
, f
);
1076 XSETINT (x
, x_pixel_width (f
) / 2);
1077 XSETINT (y
, x_pixel_height (f
) / 2);
1078 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1080 return Fx_popup_menu (newpos
,
1081 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1087 Lisp_Object selection
;
1088 int specpdl_count
= SPECPDL_INDEX ();
1090 /* Decode the dialog items from what was specified. */
1091 title
= Fcar (contents
);
1092 CHECK_STRING (title
);
1093 record_unwind_protect (unuse_menu_items
, Qnil
);
1095 if (NILP (Fcar (Fcdr (contents
))))
1096 /* No buttons specified, add an "Ok" button so users can pop down
1097 the dialog. Also, the lesstif/motif version crashes if there are
1099 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1101 list_of_panes (Fcons (contents
, Qnil
));
1103 /* Display them in a dialog box. */
1105 selection
= xdialog_show (f
, 0, title
, &error_name
);
1108 unbind_to (specpdl_count
, Qnil
);
1109 discard_menu_items ();
1111 if (error_name
) error (error_name
);
1120 /* Set menu_items_inuse so no other popup menu or dialog is created. */
1123 x_menu_set_in_use (in_use
)
1126 menu_items_inuse
= in_use
? Qt
: Qnil
;
1127 popup_activated_flag
= in_use
;
1130 /* Wait for an X event to arrive or for a timer to expire. */
1133 x_menu_wait_for_event (void *data
)
1135 extern EMACS_TIME timer_check
P_ ((int));
1137 /* Another way to do this is to register a timer callback, that can be
1138 done in GTK and Xt. But we have to do it like this when using only X
1139 anyway, and with callbacks we would have three variants for timer handling
1140 instead of the small ifdefs below. */
1143 #ifdef USE_X_TOOLKIT
1144 ! XtAppPending (Xt_app_con
)
1145 #elif defined USE_GTK
1146 ! gtk_events_pending ()
1148 ! XPending ((Display
*) data
)
1152 EMACS_TIME next_time
= timer_check (1);
1153 long secs
= EMACS_SECS (next_time
);
1154 long usecs
= EMACS_USECS (next_time
);
1155 SELECT_TYPE read_fds
;
1156 struct x_display_info
*dpyinfo
;
1159 FD_ZERO (&read_fds
);
1160 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1162 int fd
= ConnectionNumber (dpyinfo
->display
);
1163 FD_SET (fd
, &read_fds
);
1167 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1169 /* Sometimes timer_check returns -1 (no timers) even if there are
1170 timers. So do a timeout anyway. */
1171 EMACS_SET_SECS (next_time
, 1);
1172 EMACS_SET_USECS (next_time
, 0);
1175 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1178 #endif /* ! MSDOS */
1181 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1183 #ifdef USE_X_TOOLKIT
1185 /* Loop in Xt until the menu pulldown or dialog popup has been
1186 popped down (deactivated). This is used for x-popup-menu
1187 and x-popup-dialog; it is not used for the menu bar.
1189 NOTE: All calls to popup_get_selection should be protected
1190 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1193 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1194 XEvent
*initial_event
;
1195 struct x_display_info
*dpyinfo
;
1201 while (popup_activated_flag
)
1205 event
= *initial_event
;
1210 if (do_timers
) x_menu_wait_for_event (0);
1211 XtAppNextEvent (Xt_app_con
, &event
);
1214 /* Make sure we don't consider buttons grabbed after menu goes.
1215 And make sure to deactivate for any ButtonRelease,
1216 even if XtDispatchEvent doesn't do that. */
1217 if (event
.type
== ButtonRelease
1218 && dpyinfo
->display
== event
.xbutton
.display
)
1220 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1221 #ifdef USE_MOTIF /* Pretending that the event came from a
1222 Btn1Down seems the only way to convince Motif to
1223 activate its callbacks; setting the XmNmenuPost
1224 isn't working. --marcus@sysc.pdx.edu. */
1225 event
.xbutton
.button
= 1;
1226 /* Motif only pops down menus when no Ctrl, Alt or Mod
1227 key is pressed and the button is released. So reset key state
1228 so Motif thinks this is the case. */
1229 event
.xbutton
.state
= 0;
1232 /* Pop down on C-g and Escape. */
1233 else if (event
.type
== KeyPress
1234 && dpyinfo
->display
== event
.xbutton
.display
)
1236 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1238 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
1239 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
1240 popup_activated_flag
= 0;
1243 x_dispatch_event (&event
, event
.xany
.display
);
1247 #endif /* USE_X_TOOLKIT */
1250 /* Loop util popup_activated_flag is set to zero in a callback.
1251 Used for popup menus and dialogs. */
1254 popup_widget_loop (do_timers
, widget
)
1258 ++popup_activated_flag
;
1260 /* Process events in the Gtk event loop until done. */
1261 while (popup_activated_flag
)
1263 if (do_timers
) x_menu_wait_for_event (0);
1264 gtk_main_iteration ();
1269 /* Activate the menu bar of frame F.
1270 This is called from keyboard.c when it gets the
1271 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1273 To activate the menu bar, we use the X button-press event
1274 that was saved in saved_menu_event.
1275 That makes the toolkit do its thing.
1277 But first we recompute the menu bar contents (the whole tree).
1279 The reason for saving the button event until here, instead of
1280 passing it to the toolkit right away, is that we can safely
1281 execute Lisp code. */
1284 x_activate_menubar (f
)
1287 if (!f
->output_data
.x
->saved_menu_event
->type
)
1291 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1292 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1296 set_frame_menubar (f
, 0, 1);
1299 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1300 f
->output_data
.x
->saved_menu_event
);
1301 popup_activated_flag
= 1;
1303 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1307 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1308 pending_menu_activation
= 1;
1311 /* Ignore this if we get it a second time. */
1312 f
->output_data
.x
->saved_menu_event
->type
= 0;
1315 /* Detect if a dialog or menu has been posted. */
1320 return popup_activated_flag
;
1323 /* This callback is invoked when the user selects a menubar cascade
1324 pushbutton, but before the pulldown menu is posted. */
1328 popup_activate_callback (widget
, id
, client_data
)
1331 XtPointer client_data
;
1333 popup_activated_flag
= 1;
1337 /* This callback is invoked when a dialog or menu is finished being
1338 used and has been unposted. */
1342 popup_deactivate_callback (widget
, client_data
)
1344 gpointer client_data
;
1346 popup_activated_flag
= 0;
1350 popup_deactivate_callback (widget
, id
, client_data
)
1353 XtPointer client_data
;
1355 popup_activated_flag
= 0;
1360 /* Function that finds the frame for WIDGET and shows the HELP text
1362 F is the frame if known, or NULL if not known. */
1364 show_help_event (f
, widget
, help
)
1366 xt_or_gtk_widget widget
;
1373 XSETFRAME (frame
, f
);
1374 kbd_buffer_store_help_event (frame
, help
);
1378 #if 0 /* This code doesn't do anything useful. ++kfs */
1379 /* WIDGET is the popup menu. It's parent is the frame's
1380 widget. See which frame that is. */
1381 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1384 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1386 frame
= XCAR (tail
);
1387 if (GC_FRAMEP (frame
)
1388 && (f
= XFRAME (frame
),
1389 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1393 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1397 /* Callback called when menu items are highlighted/unhighlighted
1398 while moving the mouse over them. WIDGET is the menu bar or menu
1399 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1400 the data structure for the menu item, or null in case of
1405 menu_highlight_callback (widget
, call_data
)
1409 xg_menu_item_cb_data
*cb_data
;
1412 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1414 if (! cb_data
) return;
1416 help
= call_data
? cb_data
->help
: Qnil
;
1418 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1419 Don't show help for them, they won't appear before the
1420 popup is popped down. */
1421 if (popup_activated_flag
<= 1)
1422 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1426 menu_highlight_callback (widget
, id
, call_data
)
1434 widget_value
*wv
= (widget_value
*) call_data
;
1436 help
= wv
? wv
->help
: Qnil
;
1438 /* Determine the frame for the help event. */
1439 f
= menubar_id_to_frame (id
);
1441 show_help_event (f
, widget
, help
);
1445 /* Find the menu selection and store it in the keyboard buffer.
1446 F is the frame the menu is on.
1447 MENU_BAR_ITEMS_USED is the length of VECTOR.
1448 VECTOR is an array of menu events for the whole menu. */
1451 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1453 int menu_bar_items_used
;
1457 Lisp_Object prefix
, entry
;
1458 Lisp_Object
*subprefix_stack
;
1459 int submenu_depth
= 0;
1463 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1467 while (i
< menu_bar_items_used
)
1469 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1471 subprefix_stack
[submenu_depth
++] = prefix
;
1475 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1477 prefix
= subprefix_stack
[--submenu_depth
];
1480 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1482 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1483 i
+= MENU_ITEMS_PANE_LENGTH
;
1487 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1488 /* The EMACS_INT cast avoids a warning. There's no problem
1489 as long as pointers have enough bits to hold small integers. */
1490 if ((int) (EMACS_INT
) client_data
== i
)
1493 struct input_event buf
;
1497 XSETFRAME (frame
, f
);
1498 buf
.kind
= MENU_BAR_EVENT
;
1499 buf
.frame_or_window
= frame
;
1501 kbd_buffer_store_event (&buf
);
1503 for (j
= 0; j
< submenu_depth
; j
++)
1504 if (!NILP (subprefix_stack
[j
]))
1506 buf
.kind
= MENU_BAR_EVENT
;
1507 buf
.frame_or_window
= frame
;
1508 buf
.arg
= subprefix_stack
[j
];
1509 kbd_buffer_store_event (&buf
);
1514 buf
.kind
= MENU_BAR_EVENT
;
1515 buf
.frame_or_window
= frame
;
1517 kbd_buffer_store_event (&buf
);
1520 buf
.kind
= MENU_BAR_EVENT
;
1521 buf
.frame_or_window
= frame
;
1523 kbd_buffer_store_event (&buf
);
1527 i
+= MENU_ITEMS_ITEM_LENGTH
;
1534 /* Gtk calls callbacks just because we tell it what item should be
1535 selected in a radio group. If this variable is set to a non-zero
1536 value, we are creating menus and don't want callbacks right now.
1538 static int xg_crazy_callback_abort
;
1540 /* This callback is called from the menu bar pulldown menu
1541 when the user makes a selection.
1542 Figure out what the user chose
1543 and put the appropriate events into the keyboard buffer. */
1545 menubar_selection_callback (widget
, client_data
)
1547 gpointer client_data
;
1549 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1551 if (xg_crazy_callback_abort
)
1554 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1557 /* When a menu is popped down, X generates a focus event (i.e. focus
1558 goes back to the frame below the menu). Since GTK buffers events,
1559 we force it out here before the menu selection event. Otherwise
1560 sit-for will exit at once if the focus event follows the menu selection
1564 while (gtk_events_pending ())
1565 gtk_main_iteration ();
1568 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1569 cb_data
->cl_data
->menu_bar_items_used
,
1570 cb_data
->cl_data
->menu_bar_vector
,
1571 cb_data
->call_data
);
1574 #else /* not USE_GTK */
1576 /* This callback is called from the menu bar pulldown menu
1577 when the user makes a selection.
1578 Figure out what the user chose
1579 and put the appropriate events into the keyboard buffer. */
1581 menubar_selection_callback (widget
, id
, client_data
)
1584 XtPointer client_data
;
1588 f
= menubar_id_to_frame (id
);
1591 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1592 f
->menu_bar_vector
, client_data
);
1594 #endif /* not USE_GTK */
1596 /* Allocate a widget_value, blocking input. */
1599 xmalloc_widget_value ()
1601 widget_value
*value
;
1604 value
= malloc_widget_value ();
1610 /* This recursively calls free_widget_value on the tree of widgets.
1611 It must free all data that was malloc'ed for these widget_values.
1612 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1613 must be left alone. */
1616 free_menubar_widget_value_tree (wv
)
1621 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1623 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1625 free_menubar_widget_value_tree (wv
->contents
);
1626 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1630 free_menubar_widget_value_tree (wv
->next
);
1631 wv
->next
= (widget_value
*) 0xDEADBEEF;
1634 free_widget_value (wv
);
1638 /* Set up data in menu_items for a menu bar item
1639 whose event type is ITEM_KEY (with string ITEM_NAME)
1640 and whose contents come from the list of keymaps MAPS. */
1643 parse_single_submenu (item_key
, item_name
, maps
)
1644 Lisp_Object item_key
, item_name
, maps
;
1648 Lisp_Object
*mapvec
;
1650 int top_level_items
= 0;
1652 length
= Flength (maps
);
1653 len
= XINT (length
);
1655 /* Convert the list MAPS into a vector MAPVEC. */
1656 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1657 for (i
= 0; i
< len
; i
++)
1659 mapvec
[i
] = Fcar (maps
);
1663 /* Loop over the given keymaps, making a pane for each map.
1664 But don't make a pane that is empty--ignore that map instead. */
1665 for (i
= 0; i
< len
; i
++)
1667 if (!KEYMAPP (mapvec
[i
]))
1669 /* Here we have a command at top level in the menu bar
1670 as opposed to a submenu. */
1671 top_level_items
= 1;
1672 push_menu_pane (Qnil
, Qnil
);
1673 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1674 Qnil
, Qnil
, Qnil
, Qnil
);
1679 prompt
= Fkeymap_prompt (mapvec
[i
]);
1680 single_keymap_panes (mapvec
[i
],
1681 !NILP (prompt
) ? prompt
: item_name
,
1686 return top_level_items
;
1689 /* Create a tree of widget_value objects
1690 representing the panes and items
1691 in menu_items starting at index START, up to index END. */
1693 static widget_value
*
1694 digest_single_submenu (start
, end
, top_level_items
)
1695 int start
, end
, top_level_items
;
1697 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1699 int submenu_depth
= 0;
1700 widget_value
**submenu_stack
;
1703 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1704 wv
= xmalloc_widget_value ();
1708 wv
->button_type
= BUTTON_TYPE_NONE
;
1714 /* Loop over all panes and items made by the preceding call
1715 to parse_single_submenu and construct a tree of widget_value objects.
1716 Ignore the panes and items used by previous calls to
1717 digest_single_submenu, even though those are also in menu_items. */
1721 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1723 submenu_stack
[submenu_depth
++] = save_wv
;
1728 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1731 save_wv
= submenu_stack
[--submenu_depth
];
1734 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1735 && submenu_depth
!= 0)
1736 i
+= MENU_ITEMS_PANE_LENGTH
;
1737 /* Ignore a nil in the item list.
1738 It's meaningful only for dialog boxes. */
1739 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1741 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1743 /* Create a new pane. */
1744 Lisp_Object pane_name
, prefix
;
1747 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1748 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1750 #ifndef HAVE_MULTILINGUAL_MENU
1751 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1753 pane_name
= ENCODE_MENU_STRING (pane_name
);
1754 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1757 pane_string
= (NILP (pane_name
)
1758 ? "" : (char *) SDATA (pane_name
));
1759 /* If there is just one top-level pane, put all its items directly
1760 under the top-level menu. */
1761 if (menu_items_n_panes
== 1)
1764 /* If the pane has a meaningful name,
1765 make the pane a top-level menu item
1766 with its items as a submenu beneath it. */
1767 if (strcmp (pane_string
, ""))
1769 wv
= xmalloc_widget_value ();
1773 first_wv
->contents
= wv
;
1774 wv
->lname
= pane_name
;
1775 /* Set value to 1 so update_submenu_strings can handle '@' */
1776 wv
->value
= (char *)1;
1778 wv
->button_type
= BUTTON_TYPE_NONE
;
1783 i
+= MENU_ITEMS_PANE_LENGTH
;
1787 /* Create a new item within current pane. */
1788 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1791 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1792 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1793 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1794 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1795 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1796 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1797 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1799 #ifndef HAVE_MULTILINGUAL_MENU
1800 if (STRING_MULTIBYTE (item_name
))
1802 item_name
= ENCODE_MENU_STRING (item_name
);
1803 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1806 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1808 descrip
= ENCODE_MENU_STRING (descrip
);
1809 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1811 #endif /* not HAVE_MULTILINGUAL_MENU */
1813 wv
= xmalloc_widget_value ();
1817 save_wv
->contents
= wv
;
1819 wv
->lname
= item_name
;
1820 if (!NILP (descrip
))
1823 /* The EMACS_INT cast avoids a warning. There's no problem
1824 as long as pointers have enough bits to hold small integers. */
1825 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1826 wv
->enabled
= !NILP (enable
);
1829 wv
->button_type
= BUTTON_TYPE_NONE
;
1830 else if (EQ (type
, QCradio
))
1831 wv
->button_type
= BUTTON_TYPE_RADIO
;
1832 else if (EQ (type
, QCtoggle
))
1833 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1837 wv
->selected
= !NILP (selected
);
1838 if (! STRINGP (help
))
1845 i
+= MENU_ITEMS_ITEM_LENGTH
;
1849 /* If we have just one "menu item"
1850 that was originally a button, return it by itself. */
1851 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1853 wv
= first_wv
->contents
;
1854 free_widget_value (first_wv
);
1861 /* Walk through the widget_value tree starting at FIRST_WV and update
1862 the char * pointers from the corresponding lisp values.
1863 We do this after building the whole tree, since GC may happen while the
1864 tree is constructed, and small strings are relocated. So we must wait
1865 until no GC can happen before storing pointers into lisp values. */
1867 update_submenu_strings (first_wv
)
1868 widget_value
*first_wv
;
1872 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1874 if (STRINGP (wv
->lname
))
1876 wv
->name
= SDATA (wv
->lname
);
1878 /* Ignore the @ that means "separate pane".
1879 This is a kludge, but this isn't worth more time. */
1880 if (wv
->value
== (char *)1)
1882 if (wv
->name
[0] == '@')
1888 if (STRINGP (wv
->lkey
))
1889 wv
->key
= SDATA (wv
->lkey
);
1892 update_submenu_strings (wv
->contents
);
1897 /* Recompute all the widgets of frame F, when the menu bar has been
1898 changed. Value is non-zero if widgets were updated. */
1901 update_frame_menubar (f
)
1905 return xg_update_frame_menubar (f
);
1907 struct x_output
*x
= f
->output_data
.x
;
1910 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1914 /* Save the size of the frame because the pane widget doesn't accept
1915 to resize itself. So force it. */
1916 columns
= FRAME_COLS (f
);
1917 rows
= FRAME_LINES (f
);
1919 /* Do the voodoo which means "I'm changing lots of things, don't try
1920 to refigure sizes until I'm done." */
1921 lw_refigure_widget (x
->column_widget
, False
);
1923 /* The order in which children are managed is the top to bottom
1924 order in which they are displayed in the paned window. First,
1925 remove the text-area widget. */
1926 XtUnmanageChild (x
->edit_widget
);
1928 /* Remove the menubar that is there now, and put up the menubar that
1930 XtManageChild (x
->menubar_widget
);
1931 XtMapWidget (x
->menubar_widget
);
1932 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1934 /* Re-manage the text-area widget, and then thrash the sizes. */
1935 XtManageChild (x
->edit_widget
);
1936 lw_refigure_widget (x
->column_widget
, True
);
1938 /* Force the pane widget to resize itself with the right values. */
1939 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1945 /* Set the contents of the menubar widgets of frame F.
1946 The argument FIRST_TIME is currently ignored;
1947 it is set the first time this is called, from initialize_frame_menubar. */
1950 set_frame_menubar (f
, first_time
, deep_p
)
1955 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1956 #ifdef USE_X_TOOLKIT
1960 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1962 int *submenu_start
, *submenu_end
;
1963 int *submenu_top_level_items
, *submenu_n_panes
;
1966 XSETFRAME (Vmenu_updating_frame
, f
);
1968 #ifdef USE_X_TOOLKIT
1969 if (f
->output_data
.x
->id
== 0)
1970 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1971 id
= f
->output_data
.x
->id
;
1974 if (! menubar_widget
)
1976 else if (pending_menu_activation
&& !deep_p
)
1978 /* Make the first call for any given frame always go deep. */
1979 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1982 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1983 f
->output_data
.x
->saved_menu_event
->type
= 0;
1987 /* If we have detached menus, we must update deep so detached menus
1988 also gets updated. */
1989 deep_p
= deep_p
|| xg_have_tear_offs ();
1994 /* Make a widget-value tree representing the entire menu trees. */
1996 struct buffer
*prev
= current_buffer
;
1998 int specpdl_count
= SPECPDL_INDEX ();
1999 int previous_menu_items_used
= f
->menu_bar_items_used
;
2000 Lisp_Object
*previous_items
2001 = (Lisp_Object
*) alloca (previous_menu_items_used
2002 * sizeof (Lisp_Object
));
2004 /* If we are making a new widget, its contents are empty,
2005 do always reinitialize them. */
2006 if (! menubar_widget
)
2007 previous_menu_items_used
= 0;
2009 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
2010 specbind (Qinhibit_quit
, Qt
);
2011 /* Don't let the debugger step into this code
2012 because it is not reentrant. */
2013 specbind (Qdebug_on_next_call
, Qnil
);
2015 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
2016 record_unwind_protect (unuse_menu_items
, Qnil
);
2017 if (NILP (Voverriding_local_map_menu_flag
))
2019 specbind (Qoverriding_terminal_local_map
, Qnil
);
2020 specbind (Qoverriding_local_map
, Qnil
);
2023 set_buffer_internal_1 (XBUFFER (buffer
));
2025 /* Run the Lucid hook. */
2026 safe_run_hooks (Qactivate_menubar_hook
);
2028 /* If it has changed current-menubar from previous value,
2029 really recompute the menubar from the value. */
2030 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2031 call0 (Qrecompute_lucid_menubar
);
2032 safe_run_hooks (Qmenu_bar_update_hook
);
2033 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2035 items
= FRAME_MENU_BAR_ITEMS (f
);
2037 /* Save the frame's previous menu bar contents data. */
2038 if (previous_menu_items_used
)
2039 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2040 previous_menu_items_used
* sizeof (Lisp_Object
));
2042 /* Fill in menu_items with the current menu bar contents.
2043 This can evaluate Lisp code. */
2044 menu_items
= f
->menu_bar_vector
;
2045 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2046 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2047 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2048 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2049 submenu_top_level_items
2050 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2052 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2054 Lisp_Object key
, string
, maps
;
2058 key
= XVECTOR (items
)->contents
[i
];
2059 string
= XVECTOR (items
)->contents
[i
+ 1];
2060 maps
= XVECTOR (items
)->contents
[i
+ 2];
2064 submenu_start
[i
] = menu_items_used
;
2066 menu_items_n_panes
= 0;
2067 submenu_top_level_items
[i
]
2068 = parse_single_submenu (key
, string
, maps
);
2069 submenu_n_panes
[i
] = menu_items_n_panes
;
2071 submenu_end
[i
] = menu_items_used
;
2074 finish_menu_items ();
2076 /* Convert menu_items into widget_value trees
2077 to display the menu. This cannot evaluate Lisp code. */
2079 wv
= xmalloc_widget_value ();
2080 wv
->name
= "menubar";
2083 wv
->button_type
= BUTTON_TYPE_NONE
;
2087 for (i
= 0; i
< last_i
; i
+= 4)
2089 menu_items_n_panes
= submenu_n_panes
[i
];
2090 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2091 submenu_top_level_items
[i
]);
2095 first_wv
->contents
= wv
;
2096 /* Don't set wv->name here; GC during the loop might relocate it. */
2098 wv
->button_type
= BUTTON_TYPE_NONE
;
2102 set_buffer_internal_1 (prev
);
2103 unbind_to (specpdl_count
, Qnil
);
2105 /* If there has been no change in the Lisp-level contents
2106 of the menu bar, skip redisplaying it. Just exit. */
2108 for (i
= 0; i
< previous_menu_items_used
; i
++)
2109 if (menu_items_used
== i
2110 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2112 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2114 free_menubar_widget_value_tree (first_wv
);
2115 discard_menu_items ();
2120 /* Now GC cannot happen during the lifetime of the widget_value,
2121 so it's safe to store data from a Lisp_String. */
2122 wv
= first_wv
->contents
;
2123 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2126 string
= XVECTOR (items
)->contents
[i
+ 1];
2129 wv
->name
= (char *) SDATA (string
);
2130 update_submenu_strings (wv
->contents
);
2134 f
->menu_bar_vector
= menu_items
;
2135 f
->menu_bar_items_used
= menu_items_used
;
2136 discard_menu_items ();
2140 /* Make a widget-value tree containing
2141 just the top level menu bar strings. */
2143 wv
= xmalloc_widget_value ();
2144 wv
->name
= "menubar";
2147 wv
->button_type
= BUTTON_TYPE_NONE
;
2151 items
= FRAME_MENU_BAR_ITEMS (f
);
2152 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2156 string
= XVECTOR (items
)->contents
[i
+ 1];
2160 wv
= xmalloc_widget_value ();
2161 wv
->name
= (char *) SDATA (string
);
2164 wv
->button_type
= BUTTON_TYPE_NONE
;
2166 /* This prevents lwlib from assuming this
2167 menu item is really supposed to be empty. */
2168 /* The EMACS_INT cast avoids a warning.
2169 This value just has to be different from small integers. */
2170 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2175 first_wv
->contents
= wv
;
2179 /* Forget what we thought we knew about what is in the
2180 detailed contents of the menu bar menus.
2181 Changing the top level always destroys the contents. */
2182 f
->menu_bar_items_used
= 0;
2185 /* Create or update the menu bar widget. */
2190 xg_crazy_callback_abort
= 1;
2193 /* The fourth arg is DEEP_P, which says to consider the entire
2194 menu trees we supply, rather than just the menu bar item names. */
2195 xg_modify_menubar_widgets (menubar_widget
,
2199 G_CALLBACK (menubar_selection_callback
),
2200 G_CALLBACK (popup_deactivate_callback
),
2201 G_CALLBACK (menu_highlight_callback
));
2205 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2208 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2209 G_CALLBACK (menubar_selection_callback
),
2210 G_CALLBACK (popup_deactivate_callback
),
2211 G_CALLBACK (menu_highlight_callback
));
2213 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2217 #else /* not USE_GTK */
2220 /* Disable resizing (done for Motif!) */
2221 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2223 /* The third arg is DEEP_P, which says to consider the entire
2224 menu trees we supply, rather than just the menu bar item names. */
2225 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2227 /* Re-enable the edit widget to resize. */
2228 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2232 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
2233 XtTranslations override
= XtParseTranslationTable (menuOverride
);
2235 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2236 f
->output_data
.x
->column_widget
,
2238 popup_activate_callback
,
2239 menubar_selection_callback
,
2240 popup_deactivate_callback
,
2241 menu_highlight_callback
);
2242 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2244 /* Make menu pop down on C-g. */
2245 XtOverrideTranslations (menubar_widget
, override
);
2250 = (f
->output_data
.x
->menubar_widget
2251 ? (f
->output_data
.x
->menubar_widget
->core
.height
2252 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2255 #if 0 /* Experimentally, we now get the right results
2256 for -geometry -0-0 without this. 24 Aug 96, rms. */
2258 if (FRAME_EXTERNAL_MENU_BAR (f
))
2261 XtVaGetValues (f
->output_data
.x
->column_widget
,
2262 XtNinternalBorderWidth
, &ibw
, NULL
);
2263 menubar_size
+= ibw
;
2265 #endif /* USE_LUCID */
2268 f
->output_data
.x
->menubar_height
= menubar_size
;
2270 #endif /* not USE_GTK */
2272 free_menubar_widget_value_tree (first_wv
);
2273 update_frame_menubar (f
);
2276 xg_crazy_callback_abort
= 0;
2282 /* Called from Fx_create_frame to create the initial menubar of a frame
2283 before it is mapped, so that the window is mapped with the menubar already
2284 there instead of us tacking it on later and thrashing the window after it
2288 initialize_frame_menubar (f
)
2291 /* This function is called before the first chance to redisplay
2292 the frame. It has to be, so the frame will have the right size. */
2293 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2294 set_frame_menubar (f
, 1, 1);
2298 /* Get rid of the menu bar of frame F, and free its storage.
2299 This is used when deleting a frame, and when turning off the menu bar.
2300 For GTK this function is in gtkutil.c. */
2304 free_frame_menubar (f
)
2307 Widget menubar_widget
;
2309 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2311 f
->output_data
.x
->menubar_height
= 0;
2316 /* Removing the menu bar magically changes the shell widget's x
2317 and y position of (0, 0) which, when the menu bar is turned
2318 on again, leads to pull-down menuss appearing in strange
2319 positions near the upper-left corner of the display. This
2320 happens only with some window managers like twm and ctwm,
2321 but not with other like Motif's mwm or kwm, because the
2322 latter generate ConfigureNotify events when the menu bar
2323 is switched off, which fixes the shell position. */
2324 Position x0
, y0
, x1
, y1
;
2330 if (f
->output_data
.x
->widget
)
2331 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2334 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2335 f
->output_data
.x
->menubar_widget
= NULL
;
2338 if (f
->output_data
.x
->widget
)
2340 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2341 if (x1
== 0 && y1
== 0)
2342 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2349 #endif /* not USE_GTK */
2351 #endif /* USE_X_TOOLKIT || USE_GTK */
2353 /* xmenu_show actually displays a menu using the panes and items in menu_items
2354 and returns the value selected from it.
2355 There are two versions of xmenu_show, one for Xt and one for Xlib.
2356 Both assume input is blocked by the caller. */
2358 /* F is the frame the menu is for.
2359 X and Y are the frame-relative specified position,
2360 relative to the inside upper left corner of the frame F.
2361 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2362 KEYMAPS is 1 if this menu was specified with keymaps;
2363 in that case, we return a list containing the chosen item's value
2364 and perhaps also the pane's prefix.
2365 TITLE is the specified menu title.
2366 ERROR is a place to store an error message string in case of failure.
2367 (We return nil on failure, but the value doesn't actually matter.) */
2369 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2371 /* The item selected in the popup menu. */
2372 static Lisp_Object
*volatile menu_item_selection
;
2376 /* Used when position a popup menu. See menu_position_func and
2377 create_and_show_popup_menu below. */
2378 struct next_popup_x_y
2385 /* The menu position function to use if we are not putting a popup
2386 menu where the pointer is.
2387 MENU is the menu to pop up.
2388 X and Y shall on exit contain x/y where the menu shall pop up.
2389 PUSH_IN is not documented in the GTK manual.
2390 USER_DATA is any data passed in when calling gtk_menu_popup.
2391 Here it points to a struct next_popup_x_y where the coordinates
2392 to store in *X and *Y are as well as the frame for the popup.
2394 Here only X and Y are used. */
2396 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2403 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2405 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2406 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2411 /* Check if there is room for the menu. If not, adjust x/y so that
2412 the menu is fully visible. */
2413 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2414 if (data
->x
+ req
.width
> disp_width
)
2415 *x
-= data
->x
+ req
.width
- disp_width
;
2416 if (data
->y
+ req
.height
> disp_height
)
2417 *y
-= data
->y
+ req
.height
- disp_height
;
2421 popup_selection_callback (widget
, client_data
)
2423 gpointer client_data
;
2425 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2427 if (xg_crazy_callback_abort
) return;
2428 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2435 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
2437 popup_activated_flag
= 0;
2439 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
2444 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2446 menu_item_selection will be set to the selection. */
2448 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2450 widget_value
*first_wv
;
2457 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2458 struct next_popup_x_y popup_x_y
;
2459 int specpdl_count
= SPECPDL_INDEX ();
2461 xg_crazy_callback_abort
= 1;
2462 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2463 G_CALLBACK (popup_selection_callback
),
2464 G_CALLBACK (popup_deactivate_callback
),
2465 G_CALLBACK (menu_highlight_callback
));
2466 xg_crazy_callback_abort
= 0;
2470 /* Not invoked by a click. pop up at x/y. */
2471 pos_func
= menu_position_func
;
2473 /* Adjust coordinates to be root-window-relative. */
2474 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2475 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2481 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
2485 for (i
= 0; i
< 5; i
++)
2486 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2490 /* Display the menu. */
2491 gtk_widget_show_all (menu
);
2492 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2494 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2496 if (GTK_WIDGET_MAPPED (menu
))
2498 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2499 two. show_help_echo uses this to detect popup menus. */
2500 popup_activated_flag
= 1;
2501 /* Process events that apply to the menu. */
2502 popup_widget_loop (1, menu
);
2505 unbind_to (specpdl_count
, Qnil
);
2507 /* Must reset this manually because the button release event is not passed
2508 to Emacs event loop. */
2509 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2512 #else /* not USE_GTK */
2514 /* We need a unique id for each widget handled by the Lucid Widget
2517 For the main windows, and popup menus, we use this counter,
2518 which we increment each time after use. This starts from 1<<16.
2520 For menu bars, we use numbers starting at 0, counted in
2521 next_menubar_widget_id. */
2522 LWLIB_ID widget_id_tick
;
2525 popup_selection_callback (widget
, id
, client_data
)
2528 XtPointer client_data
;
2530 menu_item_selection
= (Lisp_Object
*) client_data
;
2533 /* ARG is the LWLIB ID of the dialog box, represented
2534 as a Lisp object as (HIGHPART . LOWPART). */
2540 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2541 | XINT (XCDR (arg
)));
2544 lw_destroy_all_widgets (id
);
2546 popup_activated_flag
= 0;
2551 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2553 menu_item_selection will be set to the selection. */
2555 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2557 widget_value
*first_wv
;
2565 XButtonPressedEvent dummy
;
2569 menu_id
= widget_id_tick
++;
2570 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2571 f
->output_data
.x
->widget
, 1, 0,
2572 popup_selection_callback
,
2573 popup_deactivate_callback
,
2574 menu_highlight_callback
);
2576 dummy
.type
= ButtonPress
;
2578 dummy
.send_event
= 0;
2579 dummy
.display
= FRAME_X_DISPLAY (f
);
2580 dummy
.time
= CurrentTime
;
2581 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2582 dummy
.window
= dummy
.root
;
2583 dummy
.subwindow
= dummy
.root
;
2587 /* Adjust coordinates to be root-window-relative. */
2588 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2589 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2596 for (i
= 0; i
< 5; i
++)
2597 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2600 /* Don't allow any geometry request from the user. */
2601 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2602 XtSetValues (menu
, av
, ac
);
2604 /* Display the menu. */
2605 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2606 popup_activated_flag
= 1;
2609 int fact
= 4 * sizeof (LWLIB_ID
);
2610 int specpdl_count
= SPECPDL_INDEX ();
2611 record_unwind_protect (pop_down_menu
,
2612 Fcons (make_number (menu_id
>> (fact
)),
2613 make_number (menu_id
& ~(-1 << (fact
)))));
2615 /* Process events that apply to the menu. */
2616 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
2618 unbind_to (specpdl_count
, Qnil
);
2622 #endif /* not USE_GTK */
2625 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2635 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2636 widget_value
**submenu_stack
2637 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2638 Lisp_Object
*subprefix_stack
2639 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2640 int submenu_depth
= 0;
2646 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2648 *error
= "Empty menu";
2652 /* Create a tree of widget_value objects
2653 representing the panes and their items. */
2654 wv
= xmalloc_widget_value ();
2658 wv
->button_type
= BUTTON_TYPE_NONE
;
2663 /* Loop over all panes and items, filling in the tree. */
2665 while (i
< menu_items_used
)
2667 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2669 submenu_stack
[submenu_depth
++] = save_wv
;
2675 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2678 save_wv
= submenu_stack
[--submenu_depth
];
2682 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2683 && submenu_depth
!= 0)
2684 i
+= MENU_ITEMS_PANE_LENGTH
;
2685 /* Ignore a nil in the item list.
2686 It's meaningful only for dialog boxes. */
2687 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2689 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2691 /* Create a new pane. */
2692 Lisp_Object pane_name
, prefix
;
2695 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2696 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2698 #ifndef HAVE_MULTILINGUAL_MENU
2699 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2701 pane_name
= ENCODE_MENU_STRING (pane_name
);
2702 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2705 pane_string
= (NILP (pane_name
)
2706 ? "" : (char *) SDATA (pane_name
));
2707 /* If there is just one top-level pane, put all its items directly
2708 under the top-level menu. */
2709 if (menu_items_n_panes
== 1)
2712 /* If the pane has a meaningful name,
2713 make the pane a top-level menu item
2714 with its items as a submenu beneath it. */
2715 if (!keymaps
&& strcmp (pane_string
, ""))
2717 wv
= xmalloc_widget_value ();
2721 first_wv
->contents
= wv
;
2722 wv
->name
= pane_string
;
2723 if (keymaps
&& !NILP (prefix
))
2727 wv
->button_type
= BUTTON_TYPE_NONE
;
2732 else if (first_pane
)
2738 i
+= MENU_ITEMS_PANE_LENGTH
;
2742 /* Create a new item within current pane. */
2743 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2744 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2745 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2746 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2747 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2748 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2749 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2750 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2752 #ifndef HAVE_MULTILINGUAL_MENU
2753 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2755 item_name
= ENCODE_MENU_STRING (item_name
);
2756 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2759 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2761 descrip
= ENCODE_MENU_STRING (descrip
);
2762 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2764 #endif /* not HAVE_MULTILINGUAL_MENU */
2766 wv
= xmalloc_widget_value ();
2770 save_wv
->contents
= wv
;
2771 wv
->name
= (char *) SDATA (item_name
);
2772 if (!NILP (descrip
))
2773 wv
->key
= (char *) SDATA (descrip
);
2775 /* If this item has a null value,
2776 make the call_data null so that it won't display a box
2777 when the mouse is on it. */
2779 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2780 wv
->enabled
= !NILP (enable
);
2783 wv
->button_type
= BUTTON_TYPE_NONE
;
2784 else if (EQ (type
, QCtoggle
))
2785 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2786 else if (EQ (type
, QCradio
))
2787 wv
->button_type
= BUTTON_TYPE_RADIO
;
2791 wv
->selected
= !NILP (selected
);
2793 if (! STRINGP (help
))
2800 i
+= MENU_ITEMS_ITEM_LENGTH
;
2804 /* Deal with the title, if it is non-nil. */
2807 widget_value
*wv_title
= xmalloc_widget_value ();
2808 widget_value
*wv_sep1
= xmalloc_widget_value ();
2809 widget_value
*wv_sep2
= xmalloc_widget_value ();
2811 wv_sep2
->name
= "--";
2812 wv_sep2
->next
= first_wv
->contents
;
2813 wv_sep2
->help
= Qnil
;
2815 wv_sep1
->name
= "--";
2816 wv_sep1
->next
= wv_sep2
;
2817 wv_sep1
->help
= Qnil
;
2819 #ifndef HAVE_MULTILINGUAL_MENU
2820 if (STRING_MULTIBYTE (title
))
2821 title
= ENCODE_MENU_STRING (title
);
2824 wv_title
->name
= (char *) SDATA (title
);
2825 wv_title
->enabled
= TRUE
;
2826 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2827 wv_title
->next
= wv_sep1
;
2828 wv_title
->help
= Qnil
;
2829 first_wv
->contents
= wv_title
;
2832 /* No selection has been chosen yet. */
2833 menu_item_selection
= 0;
2835 /* Actually create and show the menu until popped down. */
2836 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2838 /* Free the widget_value objects we used to specify the contents. */
2839 free_menubar_widget_value_tree (first_wv
);
2841 /* Find the selected item, and its pane, to return
2842 the proper value. */
2843 if (menu_item_selection
!= 0)
2845 Lisp_Object prefix
, entry
;
2847 prefix
= entry
= Qnil
;
2849 while (i
< menu_items_used
)
2851 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2853 subprefix_stack
[submenu_depth
++] = prefix
;
2857 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2859 prefix
= subprefix_stack
[--submenu_depth
];
2862 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2865 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2866 i
+= MENU_ITEMS_PANE_LENGTH
;
2868 /* Ignore a nil in the item list.
2869 It's meaningful only for dialog boxes. */
2870 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2875 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2876 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2882 entry
= Fcons (entry
, Qnil
);
2884 entry
= Fcons (prefix
, entry
);
2885 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2886 if (!NILP (subprefix_stack
[j
]))
2887 entry
= Fcons (subprefix_stack
[j
], entry
);
2891 i
+= MENU_ITEMS_ITEM_LENGTH
;
2895 else if (!for_click
)
2896 /* Make "Cancel" equivalent to C-g. */
2897 Fsignal (Qquit
, Qnil
);
2904 dialog_selection_callback (widget
, client_data
)
2906 gpointer client_data
;
2908 /* The EMACS_INT cast avoids a warning. There's no problem
2909 as long as pointers have enough bits to hold small integers. */
2910 if ((int) (EMACS_INT
) client_data
!= -1)
2911 menu_item_selection
= (Lisp_Object
*) client_data
;
2913 popup_activated_flag
= 0;
2916 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2918 menu_item_selection will be set to the selection. */
2920 create_and_show_dialog (f
, first_wv
)
2922 widget_value
*first_wv
;
2926 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2927 G_CALLBACK (dialog_selection_callback
),
2928 G_CALLBACK (popup_deactivate_callback
),
2933 int specpdl_count
= SPECPDL_INDEX ();
2934 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2936 /* Display the menu. */
2937 gtk_widget_show_all (menu
);
2939 /* Process events that apply to the menu. */
2940 popup_widget_loop (1, menu
);
2942 unbind_to (specpdl_count
, Qnil
);
2946 #else /* not USE_GTK */
2948 dialog_selection_callback (widget
, id
, client_data
)
2951 XtPointer client_data
;
2953 /* The EMACS_INT cast avoids a warning. There's no problem
2954 as long as pointers have enough bits to hold small integers. */
2955 if ((int) (EMACS_INT
) client_data
!= -1)
2956 menu_item_selection
= (Lisp_Object
*) client_data
;
2959 lw_destroy_all_widgets (id
);
2961 popup_activated_flag
= 0;
2965 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2967 menu_item_selection will be set to the selection. */
2969 create_and_show_dialog (f
, first_wv
)
2971 widget_value
*first_wv
;
2975 dialog_id
= widget_id_tick
++;
2976 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2977 f
->output_data
.x
->widget
, 1, 0,
2978 dialog_selection_callback
, 0, 0);
2979 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2981 /* Display the dialog box. */
2982 lw_pop_up_all_widgets (dialog_id
);
2983 popup_activated_flag
= 1;
2985 /* Process events that apply to the dialog box.
2986 Also handle timers. */
2988 int count
= SPECPDL_INDEX ();
2989 int fact
= 4 * sizeof (LWLIB_ID
);
2991 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2992 record_unwind_protect (pop_down_menu
,
2993 Fcons (make_number (dialog_id
>> (fact
)),
2994 make_number (dialog_id
& ~(-1 << (fact
)))));
2996 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
2999 unbind_to (count
, Qnil
);
3003 #endif /* not USE_GTK */
3005 static char * button_names
[] = {
3006 "button1", "button2", "button3", "button4", "button5",
3007 "button6", "button7", "button8", "button9", "button10" };
3010 xdialog_show (f
, keymaps
, title
, error
)
3016 int i
, nb_buttons
=0;
3017 char dialog_name
[6];
3019 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
3021 /* Number of elements seen so far, before boundary. */
3023 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
3024 int boundary_seen
= 0;
3028 if (menu_items_n_panes
> 1)
3030 *error
= "Multiple panes in dialog box";
3034 /* Create a tree of widget_value objects
3035 representing the text label and buttons. */
3037 Lisp_Object pane_name
, prefix
;
3039 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
3040 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
3041 pane_string
= (NILP (pane_name
)
3042 ? "" : (char *) SDATA (pane_name
));
3043 prev_wv
= xmalloc_widget_value ();
3044 prev_wv
->value
= pane_string
;
3045 if (keymaps
&& !NILP (prefix
))
3047 prev_wv
->enabled
= 1;
3048 prev_wv
->name
= "message";
3049 prev_wv
->help
= Qnil
;
3052 /* Loop over all panes and items, filling in the tree. */
3053 i
= MENU_ITEMS_PANE_LENGTH
;
3054 while (i
< menu_items_used
)
3057 /* Create a new item within current pane. */
3058 Lisp_Object item_name
, enable
, descrip
;
3059 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3060 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3062 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3064 if (NILP (item_name
))
3066 free_menubar_widget_value_tree (first_wv
);
3067 *error
= "Submenu in dialog items";
3070 if (EQ (item_name
, Qquote
))
3072 /* This is the boundary between left-side elts
3073 and right-side elts. Stop incrementing right_count. */
3078 if (nb_buttons
>= 9)
3080 free_menubar_widget_value_tree (first_wv
);
3081 *error
= "Too many dialog items";
3085 wv
= xmalloc_widget_value ();
3087 wv
->name
= (char *) button_names
[nb_buttons
];
3088 if (!NILP (descrip
))
3089 wv
->key
= (char *) SDATA (descrip
);
3090 wv
->value
= (char *) SDATA (item_name
);
3091 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3092 wv
->enabled
= !NILP (enable
);
3096 if (! boundary_seen
)
3100 i
+= MENU_ITEMS_ITEM_LENGTH
;
3103 /* If the boundary was not specified,
3104 by default put half on the left and half on the right. */
3105 if (! boundary_seen
)
3106 left_count
= nb_buttons
- nb_buttons
/ 2;
3108 wv
= xmalloc_widget_value ();
3109 wv
->name
= dialog_name
;
3111 /* Dialog boxes use a really stupid name encoding
3112 which specifies how many buttons to use
3113 and how many buttons are on the right.
3114 The Q means something also. */
3115 dialog_name
[0] = 'Q';
3116 dialog_name
[1] = '0' + nb_buttons
;
3117 dialog_name
[2] = 'B';
3118 dialog_name
[3] = 'R';
3119 /* Number of buttons to put on the right. */
3120 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3122 wv
->contents
= first_wv
;
3126 /* No selection has been chosen yet. */
3127 menu_item_selection
= 0;
3129 /* Actually create and show the dialog. */
3130 create_and_show_dialog (f
, first_wv
);
3132 /* Free the widget_value objects we used to specify the contents. */
3133 free_menubar_widget_value_tree (first_wv
);
3135 /* Find the selected item, and its pane, to return
3136 the proper value. */
3137 if (menu_item_selection
!= 0)
3143 while (i
< menu_items_used
)
3147 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3150 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3151 i
+= MENU_ITEMS_PANE_LENGTH
;
3153 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3155 /* This is the boundary between left-side elts and
3162 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3163 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3167 entry
= Fcons (entry
, Qnil
);
3169 entry
= Fcons (prefix
, entry
);
3173 i
+= MENU_ITEMS_ITEM_LENGTH
;
3178 /* Make "Cancel" equivalent to C-g. */
3179 Fsignal (Qquit
, Qnil
);
3184 #else /* not USE_X_TOOLKIT && not USE_GTK */
3186 /* The frame of the last activated non-toolkit menu bar.
3187 Used to generate menu help events. */
3189 static struct frame
*menu_help_frame
;
3192 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3194 PANE is the pane number, and ITEM is the menu item number in
3195 the menu (currently not used).
3197 This cannot be done with generating a HELP_EVENT because
3198 XMenuActivate contains a loop that doesn't let Emacs process
3202 menu_help_callback (help_string
, pane
, item
)
3206 extern Lisp_Object Qmenu_item
;
3207 Lisp_Object
*first_item
;
3208 Lisp_Object pane_name
;
3209 Lisp_Object menu_object
;
3211 first_item
= XVECTOR (menu_items
)->contents
;
3212 if (EQ (first_item
[0], Qt
))
3213 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3214 else if (EQ (first_item
[0], Qquote
))
3215 /* This shouldn't happen, see xmenu_show. */
3216 pane_name
= empty_string
;
3218 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3220 /* (menu-item MENU-NAME PANE-NUMBER) */
3221 menu_object
= Fcons (Qmenu_item
,
3223 Fcons (make_number (pane
), Qnil
)));
3224 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3225 Qnil
, menu_object
, make_number (item
), 1);
3232 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
3233 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
3235 FRAME_PTR f
= p1
->pointer
;
3236 XMenu
*menu
= p2
->pointer
;
3240 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
3241 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
3243 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3245 #ifdef HAVE_X_WINDOWS
3246 /* Assume the mouse has moved out of the X window.
3247 If it has actually moved in, we will get an EnterNotify. */
3248 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3250 /* State that no mouse buttons are now held.
3251 (The oldXMenu code doesn't track this info for us.)
3252 That is not necessarily true, but the fiction leads to reasonable
3253 results, and it is a pain to ask which are actually held now. */
3254 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3256 #endif /* HAVE_X_WINDOWS */
3265 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3275 int pane
, selidx
, lpane
, status
;
3276 Lisp_Object entry
, pane_prefix
;
3278 int ulx
, uly
, width
, height
;
3279 int dispwidth
, dispheight
;
3280 int i
, j
, lines
, maxlines
;
3283 unsigned int dummy_uint
;
3284 int specpdl_count
= SPECPDL_INDEX ();
3287 if (menu_items_n_panes
== 0)
3290 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3292 *error
= "Empty menu";
3296 /* Figure out which root window F is on. */
3297 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3298 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3299 &dummy_uint
, &dummy_uint
);
3301 /* Make the menu on that window. */
3302 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3305 *error
= "Can't create menu";
3309 #ifdef HAVE_X_WINDOWS
3310 /* Adjust coordinates to relative to the outer (window manager) window. */
3311 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
3312 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
3313 #endif /* HAVE_X_WINDOWS */
3315 /* Adjust coordinates to be root-window-relative. */
3319 /* Create all the necessary panes and their items. */
3320 maxlines
= lines
= i
= 0;
3321 while (i
< menu_items_used
)
3323 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3325 /* Create a new pane. */
3326 Lisp_Object pane_name
, prefix
;
3329 maxlines
= max (maxlines
, lines
);
3331 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3332 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3333 pane_string
= (NILP (pane_name
)
3334 ? "" : (char *) SDATA (pane_name
));
3335 if (keymaps
&& !NILP (prefix
))
3338 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3339 if (lpane
== XM_FAILURE
)
3341 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3342 *error
= "Can't create pane";
3345 i
+= MENU_ITEMS_PANE_LENGTH
;
3347 /* Find the width of the widest item in this pane. */
3350 while (j
< menu_items_used
)
3353 item
= XVECTOR (menu_items
)->contents
[j
];
3361 width
= SBYTES (item
);
3362 if (width
> maxwidth
)
3365 j
+= MENU_ITEMS_ITEM_LENGTH
;
3368 /* Ignore a nil in the item list.
3369 It's meaningful only for dialog boxes. */
3370 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3374 /* Create a new item within current pane. */
3375 Lisp_Object item_name
, enable
, descrip
, help
;
3376 unsigned char *item_data
;
3379 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3380 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3382 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3383 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3384 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3386 if (!NILP (descrip
))
3388 int gap
= maxwidth
- SBYTES (item_name
);
3391 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3392 item_name
= concat2 (item_name
, spacer
);
3393 item_name
= concat2 (item_name
, descrip
);
3394 item_data
= SDATA (item_name
);
3396 /* if alloca is fast, use that to make the space,
3397 to reduce gc needs. */
3399 = (unsigned char *) alloca (maxwidth
3400 + SBYTES (descrip
) + 1);
3401 bcopy (SDATA (item_name
), item_data
,
3402 SBYTES (item_name
));
3403 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3405 bcopy (SDATA (descrip
), item_data
+ j
,
3407 item_data
[j
+ SBYTES (descrip
)] = 0;
3411 item_data
= SDATA (item_name
);
3413 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3414 menu
, lpane
, 0, item_data
,
3415 !NILP (enable
), help_string
)
3418 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3419 *error
= "Can't add selection to menu";
3422 i
+= MENU_ITEMS_ITEM_LENGTH
;
3427 maxlines
= max (maxlines
, lines
);
3429 /* All set and ready to fly. */
3430 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3431 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3432 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3433 x
= min (x
, dispwidth
);
3434 y
= min (y
, dispheight
);
3437 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3438 &ulx
, &uly
, &width
, &height
);
3439 if (ulx
+width
> dispwidth
)
3441 x
-= (ulx
+ width
) - dispwidth
;
3442 ulx
= dispwidth
- width
;
3444 if (uly
+height
> dispheight
)
3446 y
-= (uly
+ height
) - dispheight
;
3447 uly
= dispheight
- height
;
3449 if (ulx
< 0) x
-= ulx
;
3450 if (uly
< 0) y
-= uly
;
3454 /* If position was not given by a mouse click, adjust so upper left
3455 corner of the menu as a whole ends up at given coordinates. This
3456 is what x-popup-menu says in its documentation. */
3458 y
+= 1.5*height
/(maxlines
+2);
3461 XMenuSetAEQ (menu
, TRUE
);
3462 XMenuSetFreeze (menu
, TRUE
);
3466 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3469 record_unwind_protect (pop_down_menu
,
3470 Fcons (make_save_value (f
, 0),
3471 make_save_value (menu
, 0)));
3473 /* Help display under X won't work because XMenuActivate contains
3474 a loop that doesn't give Emacs a chance to process it. */
3475 menu_help_frame
= f
;
3476 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3477 x
, y
, ButtonReleaseMask
, &datap
,
3478 menu_help_callback
);
3484 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3487 /* Find the item number SELIDX in pane number PANE. */
3489 while (i
< menu_items_used
)
3491 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3495 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3497 i
+= MENU_ITEMS_PANE_LENGTH
;
3506 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3509 entry
= Fcons (entry
, Qnil
);
3510 if (!NILP (pane_prefix
))
3511 entry
= Fcons (pane_prefix
, entry
);
3517 i
+= MENU_ITEMS_ITEM_LENGTH
;
3523 *error
= "Can't activate menu";
3528 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3529 the menu was invoked with a mouse event as POSITION). */
3531 Fsignal (Qquit
, Qnil
);
3536 unbind_to (specpdl_count
, Qnil
);
3541 #endif /* not USE_X_TOOLKIT */
3543 #endif /* HAVE_MENUS */
3548 staticpro (&menu_items
);
3550 menu_items_inuse
= Qnil
;
3552 Qdebug_on_next_call
= intern ("debug-on-next-call");
3553 staticpro (&Qdebug_on_next_call
);
3555 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3556 doc
: /* Frame for which we are updating a menu.
3557 The enable predicate for a menu command should check this variable. */);
3558 Vmenu_updating_frame
= Qnil
;
3560 #ifdef USE_X_TOOLKIT
3561 widget_id_tick
= (1<<16);
3562 next_menubar_widget_id
= 1;
3565 defsubr (&Sx_popup_menu
);
3567 defsubr (&Sx_popup_dialog
);
3571 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3572 (do not change this comment) */