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's frame. (WINDOW may be a frame object instead of a window.)
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.
755 When MENU is a keymap or a list of keymaps, the return value
758 Alternatively, you can specify a menu of multiple panes
759 with a list of the form (TITLE PANE1 PANE2...),
760 where each pane is a list of form (TITLE ITEM1 ITEM2...).
761 Each ITEM is normally a cons cell (STRING . VALUE);
762 but a string can appear as an item--that makes a nonselectable line
764 With this form of menu, the return value is VALUE from the chosen item.
766 If POSITION is nil, don't display the menu at all, just precalculate the
767 cached information about equivalent key sequences. */)
769 Lisp_Object position
, menu
;
771 Lisp_Object keymap
, tem
;
772 int xpos
= 0, ypos
= 0;
774 char *error_name
= NULL
;
775 Lisp_Object selection
;
777 Lisp_Object x
, y
, window
;
780 int specpdl_count
= SPECPDL_INDEX ();
784 if (! NILP (position
))
786 int get_current_pos_p
= 0;
789 /* Decode the first argument: find the window and the coordinates. */
790 if (EQ (position
, Qt
)
791 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
792 || EQ (XCAR (position
), Qtool_bar
))))
794 get_current_pos_p
= 1;
798 tem
= Fcar (position
);
801 window
= Fcar (Fcdr (position
));
803 y
= Fcar (XCDR (tem
));
808 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
809 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
810 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
815 /* If a click happens in an external tool bar or a detached
816 tool bar, x and y is NIL. In that case, use the current
817 mouse position. This happens for the help button in the
818 tool bar. Ideally popup-menu should pass NIL to
819 this function, but it doesn't. */
820 if (NILP (x
) && NILP (y
))
821 get_current_pos_p
= 1;
824 if (get_current_pos_p
)
826 /* Use the mouse's current position. */
827 FRAME_PTR new_f
= SELECTED_FRAME ();
828 #ifdef HAVE_X_WINDOWS
829 /* Can't use mouse_position_hook for X since it returns
830 coordinates relative to the window the mouse is in,
831 we need coordinates relative to the edit widget always. */
836 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
837 /* cur_x/y may be negative, so use make_number. */
838 x
= make_number (cur_x
);
839 y
= make_number (cur_y
);
842 #else /* not HAVE_X_WINDOWS */
843 Lisp_Object bar_window
;
844 enum scroll_bar_part part
;
847 if (mouse_position_hook
)
848 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
849 &part
, &x
, &y
, &time
);
850 #endif /* not HAVE_X_WINDOWS */
853 XSETFRAME (window
, new_f
);
856 window
= selected_window
;
865 /* Decode where to put the menu. */
873 else if (WINDOWP (window
))
875 CHECK_LIVE_WINDOW (window
);
876 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
878 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
879 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
882 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
883 but I don't want to make one now. */
884 CHECK_WINDOW (window
);
889 Vmenu_updating_frame
= Qnil
;
890 #endif /* HAVE_MENUS */
892 record_unwind_protect (unuse_menu_items
, Qnil
);
896 /* Decode the menu items from what was specified. */
898 keymap
= get_keymap (menu
, 0, 0);
901 /* We were given a keymap. Extract menu info from the keymap. */
904 /* Extract the detailed info to make one pane. */
905 keymap_panes (&menu
, 1, NILP (position
));
907 /* Search for a string appearing directly as an element of the keymap.
908 That string is the title of the menu. */
909 prompt
= Fkeymap_prompt (keymap
);
910 if (NILP (title
) && !NILP (prompt
))
913 /* Make that be the pane title of the first pane. */
914 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
915 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
919 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
921 /* We were given a list of keymaps. */
922 int nmaps
= XFASTINT (Flength (menu
));
924 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
929 /* The first keymap that has a prompt string
930 supplies the menu title. */
931 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
935 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
937 prompt
= Fkeymap_prompt (keymap
);
938 if (NILP (title
) && !NILP (prompt
))
942 /* Extract the detailed info to make one pane. */
943 keymap_panes (maps
, nmaps
, NILP (position
));
945 /* Make the title be the pane title of the first pane. */
946 if (!NILP (title
) && menu_items_n_panes
>= 0)
947 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
953 /* We were given an old-fashioned menu. */
955 CHECK_STRING (title
);
957 list_of_panes (Fcdr (menu
));
962 unbind_to (specpdl_count
, Qnil
);
966 discard_menu_items ();
972 /* Display them in a menu. */
975 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
976 keymaps
, title
, &error_name
);
979 discard_menu_items ();
982 #endif /* HAVE_MENUS */
984 if (error_name
) error (error_name
);
990 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
991 doc
: /* Pop up a dialog box and return user's selection.
992 POSITION specifies which frame to use.
993 This is normally a mouse button event or a window or frame.
994 If POSITION is t, it means to use the frame the mouse is on.
995 The dialog box appears in the middle of the specified frame.
997 CONTENTS specifies the alternatives to display in the dialog box.
998 It is a list of the form (TITLE ITEM1 ITEM2...).
999 Each ITEM is a cons cell (STRING . VALUE).
1000 The return value is VALUE from the chosen item.
1002 An ITEM may also be just a string--that makes a nonselectable item.
1003 An ITEM may also be nil--that means to put all preceding items
1004 on the left of the dialog box and all following items on the right.
1005 \(By default, approximately half appear on each side.) */)
1006 (position
, contents
)
1007 Lisp_Object position
, contents
;
1014 /* Decode the first argument: find the window or frame to use. */
1015 if (EQ (position
, Qt
)
1016 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1017 || EQ (XCAR (position
), Qtool_bar
))))
1019 #if 0 /* Using the frame the mouse is on may not be right. */
1020 /* Use the mouse's current position. */
1021 FRAME_PTR new_f
= SELECTED_FRAME ();
1022 Lisp_Object bar_window
;
1023 enum scroll_bar_part part
;
1027 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1030 XSETFRAME (window
, new_f
);
1032 window
= selected_window
;
1034 window
= selected_window
;
1036 else if (CONSP (position
))
1039 tem
= Fcar (position
);
1041 window
= Fcar (Fcdr (position
));
1044 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1045 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1048 else if (WINDOWP (position
) || FRAMEP (position
))
1053 /* Decode where to put the menu. */
1055 if (FRAMEP (window
))
1056 f
= XFRAME (window
);
1057 else if (WINDOWP (window
))
1059 CHECK_LIVE_WINDOW (window
);
1060 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1063 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1064 but I don't want to make one now. */
1065 CHECK_WINDOW (window
);
1067 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1068 /* Display a menu with these alternatives
1069 in the middle of frame F. */
1071 Lisp_Object x
, y
, frame
, newpos
;
1072 XSETFRAME (frame
, f
);
1073 XSETINT (x
, x_pixel_width (f
) / 2);
1074 XSETINT (y
, x_pixel_height (f
) / 2);
1075 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1077 return Fx_popup_menu (newpos
,
1078 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1084 Lisp_Object selection
;
1085 int specpdl_count
= SPECPDL_INDEX ();
1087 /* Decode the dialog items from what was specified. */
1088 title
= Fcar (contents
);
1089 CHECK_STRING (title
);
1090 record_unwind_protect (unuse_menu_items
, Qnil
);
1092 if (NILP (Fcar (Fcdr (contents
))))
1093 /* No buttons specified, add an "Ok" button so users can pop down
1094 the dialog. Also, the lesstif/motif version crashes if there are
1096 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1098 list_of_panes (Fcons (contents
, Qnil
));
1100 /* Display them in a dialog box. */
1102 selection
= xdialog_show (f
, 0, title
, &error_name
);
1105 unbind_to (specpdl_count
, Qnil
);
1106 discard_menu_items ();
1108 if (error_name
) error (error_name
);
1117 /* Set menu_items_inuse so no other popup menu or dialog is created. */
1120 x_menu_set_in_use (in_use
)
1123 menu_items_inuse
= in_use
? Qt
: Qnil
;
1124 popup_activated_flag
= in_use
;
1127 /* Wait for an X event to arrive or for a timer to expire. */
1130 x_menu_wait_for_event (void *data
)
1132 extern EMACS_TIME timer_check
P_ ((int));
1134 /* Another way to do this is to register a timer callback, that can be
1135 done in GTK and Xt. But we have to do it like this when using only X
1136 anyway, and with callbacks we would have three variants for timer handling
1137 instead of the small ifdefs below. */
1140 #ifdef USE_X_TOOLKIT
1141 ! XtAppPending (Xt_app_con
)
1142 #elif defined USE_GTK
1143 ! gtk_events_pending ()
1145 ! XPending ((Display
*) data
)
1149 EMACS_TIME next_time
= timer_check (1);
1150 long secs
= EMACS_SECS (next_time
);
1151 long usecs
= EMACS_USECS (next_time
);
1152 SELECT_TYPE read_fds
;
1153 struct x_display_info
*dpyinfo
;
1156 FD_ZERO (&read_fds
);
1157 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1159 int fd
= ConnectionNumber (dpyinfo
->display
);
1160 FD_SET (fd
, &read_fds
);
1164 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1166 /* Sometimes timer_check returns -1 (no timers) even if there are
1167 timers. So do a timeout anyway. */
1168 EMACS_SET_SECS (next_time
, 1);
1169 EMACS_SET_USECS (next_time
, 0);
1172 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1175 #endif /* ! MSDOS */
1178 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1180 #ifdef USE_X_TOOLKIT
1182 /* Loop in Xt until the menu pulldown or dialog popup has been
1183 popped down (deactivated). This is used for x-popup-menu
1184 and x-popup-dialog; it is not used for the menu bar.
1186 NOTE: All calls to popup_get_selection should be protected
1187 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1190 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1191 XEvent
*initial_event
;
1192 struct x_display_info
*dpyinfo
;
1198 while (popup_activated_flag
)
1202 event
= *initial_event
;
1207 if (do_timers
) x_menu_wait_for_event (0);
1208 XtAppNextEvent (Xt_app_con
, &event
);
1211 /* Make sure we don't consider buttons grabbed after menu goes.
1212 And make sure to deactivate for any ButtonRelease,
1213 even if XtDispatchEvent doesn't do that. */
1214 if (event
.type
== ButtonRelease
1215 && dpyinfo
->display
== event
.xbutton
.display
)
1217 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1218 #ifdef USE_MOTIF /* Pretending that the event came from a
1219 Btn1Down seems the only way to convince Motif to
1220 activate its callbacks; setting the XmNmenuPost
1221 isn't working. --marcus@sysc.pdx.edu. */
1222 event
.xbutton
.button
= 1;
1223 /* Motif only pops down menus when no Ctrl, Alt or Mod
1224 key is pressed and the button is released. So reset key state
1225 so Motif thinks this is the case. */
1226 event
.xbutton
.state
= 0;
1229 /* Pop down on C-g and Escape. */
1230 else if (event
.type
== KeyPress
1231 && dpyinfo
->display
== event
.xbutton
.display
)
1233 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1235 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
1236 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
1237 popup_activated_flag
= 0;
1240 x_dispatch_event (&event
, event
.xany
.display
);
1244 #endif /* USE_X_TOOLKIT */
1247 /* Loop util popup_activated_flag is set to zero in a callback.
1248 Used for popup menus and dialogs. */
1251 popup_widget_loop (do_timers
, widget
)
1255 ++popup_activated_flag
;
1257 /* Process events in the Gtk event loop until done. */
1258 while (popup_activated_flag
)
1260 if (do_timers
) x_menu_wait_for_event (0);
1261 gtk_main_iteration ();
1266 /* Activate the menu bar of frame F.
1267 This is called from keyboard.c when it gets the
1268 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1270 To activate the menu bar, we use the X button-press event
1271 that was saved in saved_menu_event.
1272 That makes the toolkit do its thing.
1274 But first we recompute the menu bar contents (the whole tree).
1276 The reason for saving the button event until here, instead of
1277 passing it to the toolkit right away, is that we can safely
1278 execute Lisp code. */
1281 x_activate_menubar (f
)
1284 if (!f
->output_data
.x
->saved_menu_event
->type
)
1288 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1289 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1293 set_frame_menubar (f
, 0, 1);
1296 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1297 f
->output_data
.x
->saved_menu_event
);
1298 popup_activated_flag
= 1;
1300 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1304 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1305 pending_menu_activation
= 1;
1308 /* Ignore this if we get it a second time. */
1309 f
->output_data
.x
->saved_menu_event
->type
= 0;
1312 /* Detect if a dialog or menu has been posted. */
1317 return popup_activated_flag
;
1320 /* This callback is invoked when the user selects a menubar cascade
1321 pushbutton, but before the pulldown menu is posted. */
1325 popup_activate_callback (widget
, id
, client_data
)
1328 XtPointer client_data
;
1330 popup_activated_flag
= 1;
1334 /* This callback is invoked when a dialog or menu is finished being
1335 used and has been unposted. */
1339 popup_deactivate_callback (widget
, client_data
)
1341 gpointer client_data
;
1343 popup_activated_flag
= 0;
1347 popup_deactivate_callback (widget
, id
, client_data
)
1350 XtPointer client_data
;
1352 popup_activated_flag
= 0;
1357 /* Function that finds the frame for WIDGET and shows the HELP text
1359 F is the frame if known, or NULL if not known. */
1361 show_help_event (f
, widget
, help
)
1363 xt_or_gtk_widget widget
;
1370 XSETFRAME (frame
, f
);
1371 kbd_buffer_store_help_event (frame
, help
);
1375 #if 0 /* This code doesn't do anything useful. ++kfs */
1376 /* WIDGET is the popup menu. It's parent is the frame's
1377 widget. See which frame that is. */
1378 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1381 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1383 frame
= XCAR (tail
);
1384 if (GC_FRAMEP (frame
)
1385 && (f
= XFRAME (frame
),
1386 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1390 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1394 /* Callback called when menu items are highlighted/unhighlighted
1395 while moving the mouse over them. WIDGET is the menu bar or menu
1396 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1397 the data structure for the menu item, or null in case of
1402 menu_highlight_callback (widget
, call_data
)
1406 xg_menu_item_cb_data
*cb_data
;
1409 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1411 if (! cb_data
) return;
1413 help
= call_data
? cb_data
->help
: Qnil
;
1415 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1416 Don't show help for them, they won't appear before the
1417 popup is popped down. */
1418 if (popup_activated_flag
<= 1)
1419 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1423 menu_highlight_callback (widget
, id
, call_data
)
1431 widget_value
*wv
= (widget_value
*) call_data
;
1433 help
= wv
? wv
->help
: Qnil
;
1435 /* Determine the frame for the help event. */
1436 f
= menubar_id_to_frame (id
);
1438 show_help_event (f
, widget
, help
);
1442 /* Find the menu selection and store it in the keyboard buffer.
1443 F is the frame the menu is on.
1444 MENU_BAR_ITEMS_USED is the length of VECTOR.
1445 VECTOR is an array of menu events for the whole menu. */
1448 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1450 int menu_bar_items_used
;
1454 Lisp_Object prefix
, entry
;
1455 Lisp_Object
*subprefix_stack
;
1456 int submenu_depth
= 0;
1460 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1464 while (i
< menu_bar_items_used
)
1466 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1468 subprefix_stack
[submenu_depth
++] = prefix
;
1472 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1474 prefix
= subprefix_stack
[--submenu_depth
];
1477 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1479 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1480 i
+= MENU_ITEMS_PANE_LENGTH
;
1484 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1485 /* The EMACS_INT cast avoids a warning. There's no problem
1486 as long as pointers have enough bits to hold small integers. */
1487 if ((int) (EMACS_INT
) client_data
== i
)
1490 struct input_event buf
;
1494 XSETFRAME (frame
, f
);
1495 buf
.kind
= MENU_BAR_EVENT
;
1496 buf
.frame_or_window
= frame
;
1498 kbd_buffer_store_event (&buf
);
1500 for (j
= 0; j
< submenu_depth
; j
++)
1501 if (!NILP (subprefix_stack
[j
]))
1503 buf
.kind
= MENU_BAR_EVENT
;
1504 buf
.frame_or_window
= frame
;
1505 buf
.arg
= subprefix_stack
[j
];
1506 kbd_buffer_store_event (&buf
);
1511 buf
.kind
= MENU_BAR_EVENT
;
1512 buf
.frame_or_window
= frame
;
1514 kbd_buffer_store_event (&buf
);
1517 buf
.kind
= MENU_BAR_EVENT
;
1518 buf
.frame_or_window
= frame
;
1520 kbd_buffer_store_event (&buf
);
1524 i
+= MENU_ITEMS_ITEM_LENGTH
;
1531 /* Gtk calls callbacks just because we tell it what item should be
1532 selected in a radio group. If this variable is set to a non-zero
1533 value, we are creating menus and don't want callbacks right now.
1535 static int xg_crazy_callback_abort
;
1537 /* This callback is called from the menu bar pulldown menu
1538 when the user makes a selection.
1539 Figure out what the user chose
1540 and put the appropriate events into the keyboard buffer. */
1542 menubar_selection_callback (widget
, client_data
)
1544 gpointer client_data
;
1546 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1548 if (xg_crazy_callback_abort
)
1551 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1554 /* When a menu is popped down, X generates a focus event (i.e. focus
1555 goes back to the frame below the menu). Since GTK buffers events,
1556 we force it out here before the menu selection event. Otherwise
1557 sit-for will exit at once if the focus event follows the menu selection
1561 while (gtk_events_pending ())
1562 gtk_main_iteration ();
1565 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1566 cb_data
->cl_data
->menu_bar_items_used
,
1567 cb_data
->cl_data
->menu_bar_vector
,
1568 cb_data
->call_data
);
1571 #else /* not USE_GTK */
1573 /* This callback is called from the menu bar pulldown menu
1574 when the user makes a selection.
1575 Figure out what the user chose
1576 and put the appropriate events into the keyboard buffer. */
1578 menubar_selection_callback (widget
, id
, client_data
)
1581 XtPointer client_data
;
1585 f
= menubar_id_to_frame (id
);
1588 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1589 f
->menu_bar_vector
, client_data
);
1591 #endif /* not USE_GTK */
1593 /* Allocate a widget_value, blocking input. */
1596 xmalloc_widget_value ()
1598 widget_value
*value
;
1601 value
= malloc_widget_value ();
1607 /* This recursively calls free_widget_value on the tree of widgets.
1608 It must free all data that was malloc'ed for these widget_values.
1609 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1610 must be left alone. */
1613 free_menubar_widget_value_tree (wv
)
1618 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1620 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1622 free_menubar_widget_value_tree (wv
->contents
);
1623 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1627 free_menubar_widget_value_tree (wv
->next
);
1628 wv
->next
= (widget_value
*) 0xDEADBEEF;
1631 free_widget_value (wv
);
1635 /* Set up data in menu_items for a menu bar item
1636 whose event type is ITEM_KEY (with string ITEM_NAME)
1637 and whose contents come from the list of keymaps MAPS. */
1640 parse_single_submenu (item_key
, item_name
, maps
)
1641 Lisp_Object item_key
, item_name
, maps
;
1645 Lisp_Object
*mapvec
;
1647 int top_level_items
= 0;
1649 length
= Flength (maps
);
1650 len
= XINT (length
);
1652 /* Convert the list MAPS into a vector MAPVEC. */
1653 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1654 for (i
= 0; i
< len
; i
++)
1656 mapvec
[i
] = Fcar (maps
);
1660 /* Loop over the given keymaps, making a pane for each map.
1661 But don't make a pane that is empty--ignore that map instead. */
1662 for (i
= 0; i
< len
; i
++)
1664 if (!KEYMAPP (mapvec
[i
]))
1666 /* Here we have a command at top level in the menu bar
1667 as opposed to a submenu. */
1668 top_level_items
= 1;
1669 push_menu_pane (Qnil
, Qnil
);
1670 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1671 Qnil
, Qnil
, Qnil
, Qnil
);
1676 prompt
= Fkeymap_prompt (mapvec
[i
]);
1677 single_keymap_panes (mapvec
[i
],
1678 !NILP (prompt
) ? prompt
: item_name
,
1683 return top_level_items
;
1686 /* Create a tree of widget_value objects
1687 representing the panes and items
1688 in menu_items starting at index START, up to index END. */
1690 static widget_value
*
1691 digest_single_submenu (start
, end
, top_level_items
)
1692 int start
, end
, top_level_items
;
1694 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1696 int submenu_depth
= 0;
1697 widget_value
**submenu_stack
;
1700 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1701 wv
= xmalloc_widget_value ();
1705 wv
->button_type
= BUTTON_TYPE_NONE
;
1711 /* Loop over all panes and items made by the preceding call
1712 to parse_single_submenu and construct a tree of widget_value objects.
1713 Ignore the panes and items used by previous calls to
1714 digest_single_submenu, even though those are also in menu_items. */
1718 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1720 submenu_stack
[submenu_depth
++] = save_wv
;
1725 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1728 save_wv
= submenu_stack
[--submenu_depth
];
1731 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1732 && submenu_depth
!= 0)
1733 i
+= MENU_ITEMS_PANE_LENGTH
;
1734 /* Ignore a nil in the item list.
1735 It's meaningful only for dialog boxes. */
1736 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1738 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1740 /* Create a new pane. */
1741 Lisp_Object pane_name
, prefix
;
1744 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1745 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1747 #ifndef HAVE_MULTILINGUAL_MENU
1748 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1750 pane_name
= ENCODE_MENU_STRING (pane_name
);
1751 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1754 pane_string
= (NILP (pane_name
)
1755 ? "" : (char *) SDATA (pane_name
));
1756 /* If there is just one top-level pane, put all its items directly
1757 under the top-level menu. */
1758 if (menu_items_n_panes
== 1)
1761 /* If the pane has a meaningful name,
1762 make the pane a top-level menu item
1763 with its items as a submenu beneath it. */
1764 if (strcmp (pane_string
, ""))
1766 wv
= xmalloc_widget_value ();
1770 first_wv
->contents
= wv
;
1771 wv
->lname
= pane_name
;
1772 /* Set value to 1 so update_submenu_strings can handle '@' */
1773 wv
->value
= (char *)1;
1775 wv
->button_type
= BUTTON_TYPE_NONE
;
1780 i
+= MENU_ITEMS_PANE_LENGTH
;
1784 /* Create a new item within current pane. */
1785 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1788 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1789 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1790 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1791 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1792 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1793 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1794 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1796 #ifndef HAVE_MULTILINGUAL_MENU
1797 if (STRING_MULTIBYTE (item_name
))
1799 item_name
= ENCODE_MENU_STRING (item_name
);
1800 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1803 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1805 descrip
= ENCODE_MENU_STRING (descrip
);
1806 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1808 #endif /* not HAVE_MULTILINGUAL_MENU */
1810 wv
= xmalloc_widget_value ();
1814 save_wv
->contents
= wv
;
1816 wv
->lname
= item_name
;
1817 if (!NILP (descrip
))
1820 /* The EMACS_INT cast avoids a warning. There's no problem
1821 as long as pointers have enough bits to hold small integers. */
1822 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1823 wv
->enabled
= !NILP (enable
);
1826 wv
->button_type
= BUTTON_TYPE_NONE
;
1827 else if (EQ (type
, QCradio
))
1828 wv
->button_type
= BUTTON_TYPE_RADIO
;
1829 else if (EQ (type
, QCtoggle
))
1830 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1834 wv
->selected
= !NILP (selected
);
1835 if (! STRINGP (help
))
1842 i
+= MENU_ITEMS_ITEM_LENGTH
;
1846 /* If we have just one "menu item"
1847 that was originally a button, return it by itself. */
1848 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1850 wv
= first_wv
->contents
;
1851 free_widget_value (first_wv
);
1858 /* Walk through the widget_value tree starting at FIRST_WV and update
1859 the char * pointers from the corresponding lisp values.
1860 We do this after building the whole tree, since GC may happen while the
1861 tree is constructed, and small strings are relocated. So we must wait
1862 until no GC can happen before storing pointers into lisp values. */
1864 update_submenu_strings (first_wv
)
1865 widget_value
*first_wv
;
1869 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1871 if (STRINGP (wv
->lname
))
1873 wv
->name
= SDATA (wv
->lname
);
1875 /* Ignore the @ that means "separate pane".
1876 This is a kludge, but this isn't worth more time. */
1877 if (wv
->value
== (char *)1)
1879 if (wv
->name
[0] == '@')
1885 if (STRINGP (wv
->lkey
))
1886 wv
->key
= SDATA (wv
->lkey
);
1889 update_submenu_strings (wv
->contents
);
1894 /* Recompute all the widgets of frame F, when the menu bar has been
1895 changed. Value is non-zero if widgets were updated. */
1898 update_frame_menubar (f
)
1902 return xg_update_frame_menubar (f
);
1904 struct x_output
*x
= f
->output_data
.x
;
1907 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1911 /* Save the size of the frame because the pane widget doesn't accept
1912 to resize itself. So force it. */
1913 columns
= FRAME_COLS (f
);
1914 rows
= FRAME_LINES (f
);
1916 /* Do the voodoo which means "I'm changing lots of things, don't try
1917 to refigure sizes until I'm done." */
1918 lw_refigure_widget (x
->column_widget
, False
);
1920 /* The order in which children are managed is the top to bottom
1921 order in which they are displayed in the paned window. First,
1922 remove the text-area widget. */
1923 XtUnmanageChild (x
->edit_widget
);
1925 /* Remove the menubar that is there now, and put up the menubar that
1927 XtManageChild (x
->menubar_widget
);
1928 XtMapWidget (x
->menubar_widget
);
1929 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1931 /* Re-manage the text-area widget, and then thrash the sizes. */
1932 XtManageChild (x
->edit_widget
);
1933 lw_refigure_widget (x
->column_widget
, True
);
1935 /* Force the pane widget to resize itself with the right values. */
1936 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1942 /* Set the contents of the menubar widgets of frame F.
1943 The argument FIRST_TIME is currently ignored;
1944 it is set the first time this is called, from initialize_frame_menubar. */
1947 set_frame_menubar (f
, first_time
, deep_p
)
1952 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1953 #ifdef USE_X_TOOLKIT
1957 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1959 int *submenu_start
, *submenu_end
;
1960 int *submenu_top_level_items
, *submenu_n_panes
;
1963 XSETFRAME (Vmenu_updating_frame
, f
);
1965 #ifdef USE_X_TOOLKIT
1966 if (f
->output_data
.x
->id
== 0)
1967 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1968 id
= f
->output_data
.x
->id
;
1971 if (! menubar_widget
)
1973 else if (pending_menu_activation
&& !deep_p
)
1975 /* Make the first call for any given frame always go deep. */
1976 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1979 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1980 f
->output_data
.x
->saved_menu_event
->type
= 0;
1984 /* If we have detached menus, we must update deep so detached menus
1985 also gets updated. */
1986 deep_p
= deep_p
|| xg_have_tear_offs ();
1991 /* Make a widget-value tree representing the entire menu trees. */
1993 struct buffer
*prev
= current_buffer
;
1995 int specpdl_count
= SPECPDL_INDEX ();
1996 int previous_menu_items_used
= f
->menu_bar_items_used
;
1997 Lisp_Object
*previous_items
1998 = (Lisp_Object
*) alloca (previous_menu_items_used
1999 * sizeof (Lisp_Object
));
2001 /* If we are making a new widget, its contents are empty,
2002 do always reinitialize them. */
2003 if (! menubar_widget
)
2004 previous_menu_items_used
= 0;
2006 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
2007 specbind (Qinhibit_quit
, Qt
);
2008 /* Don't let the debugger step into this code
2009 because it is not reentrant. */
2010 specbind (Qdebug_on_next_call
, Qnil
);
2012 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
2013 record_unwind_protect (unuse_menu_items
, Qnil
);
2014 if (NILP (Voverriding_local_map_menu_flag
))
2016 specbind (Qoverriding_terminal_local_map
, Qnil
);
2017 specbind (Qoverriding_local_map
, Qnil
);
2020 set_buffer_internal_1 (XBUFFER (buffer
));
2022 /* Run the Lucid hook. */
2023 safe_run_hooks (Qactivate_menubar_hook
);
2025 /* If it has changed current-menubar from previous value,
2026 really recompute the menubar from the value. */
2027 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2028 call0 (Qrecompute_lucid_menubar
);
2029 safe_run_hooks (Qmenu_bar_update_hook
);
2030 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2032 items
= FRAME_MENU_BAR_ITEMS (f
);
2034 /* Save the frame's previous menu bar contents data. */
2035 if (previous_menu_items_used
)
2036 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2037 previous_menu_items_used
* sizeof (Lisp_Object
));
2039 /* Fill in menu_items with the current menu bar contents.
2040 This can evaluate Lisp code. */
2041 menu_items
= f
->menu_bar_vector
;
2042 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2043 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2044 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2045 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2046 submenu_top_level_items
2047 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2049 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2051 Lisp_Object key
, string
, maps
;
2055 key
= XVECTOR (items
)->contents
[i
];
2056 string
= XVECTOR (items
)->contents
[i
+ 1];
2057 maps
= XVECTOR (items
)->contents
[i
+ 2];
2061 submenu_start
[i
] = menu_items_used
;
2063 menu_items_n_panes
= 0;
2064 submenu_top_level_items
[i
]
2065 = parse_single_submenu (key
, string
, maps
);
2066 submenu_n_panes
[i
] = menu_items_n_panes
;
2068 submenu_end
[i
] = menu_items_used
;
2071 finish_menu_items ();
2073 /* Convert menu_items into widget_value trees
2074 to display the menu. This cannot evaluate Lisp code. */
2076 wv
= xmalloc_widget_value ();
2077 wv
->name
= "menubar";
2080 wv
->button_type
= BUTTON_TYPE_NONE
;
2084 for (i
= 0; i
< last_i
; i
+= 4)
2086 menu_items_n_panes
= submenu_n_panes
[i
];
2087 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2088 submenu_top_level_items
[i
]);
2092 first_wv
->contents
= wv
;
2093 /* Don't set wv->name here; GC during the loop might relocate it. */
2095 wv
->button_type
= BUTTON_TYPE_NONE
;
2099 set_buffer_internal_1 (prev
);
2100 unbind_to (specpdl_count
, Qnil
);
2102 /* If there has been no change in the Lisp-level contents
2103 of the menu bar, skip redisplaying it. Just exit. */
2105 for (i
= 0; i
< previous_menu_items_used
; i
++)
2106 if (menu_items_used
== i
2107 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2109 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2111 free_menubar_widget_value_tree (first_wv
);
2112 discard_menu_items ();
2117 /* Now GC cannot happen during the lifetime of the widget_value,
2118 so it's safe to store data from a Lisp_String. */
2119 wv
= first_wv
->contents
;
2120 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2123 string
= XVECTOR (items
)->contents
[i
+ 1];
2126 wv
->name
= (char *) SDATA (string
);
2127 update_submenu_strings (wv
->contents
);
2131 f
->menu_bar_vector
= menu_items
;
2132 f
->menu_bar_items_used
= menu_items_used
;
2133 discard_menu_items ();
2137 /* Make a widget-value tree containing
2138 just the top level menu bar strings. */
2140 wv
= xmalloc_widget_value ();
2141 wv
->name
= "menubar";
2144 wv
->button_type
= BUTTON_TYPE_NONE
;
2148 items
= FRAME_MENU_BAR_ITEMS (f
);
2149 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2153 string
= XVECTOR (items
)->contents
[i
+ 1];
2157 wv
= xmalloc_widget_value ();
2158 wv
->name
= (char *) SDATA (string
);
2161 wv
->button_type
= BUTTON_TYPE_NONE
;
2163 /* This prevents lwlib from assuming this
2164 menu item is really supposed to be empty. */
2165 /* The EMACS_INT cast avoids a warning.
2166 This value just has to be different from small integers. */
2167 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2172 first_wv
->contents
= wv
;
2176 /* Forget what we thought we knew about what is in the
2177 detailed contents of the menu bar menus.
2178 Changing the top level always destroys the contents. */
2179 f
->menu_bar_items_used
= 0;
2182 /* Create or update the menu bar widget. */
2187 xg_crazy_callback_abort
= 1;
2190 /* The fourth arg is DEEP_P, which says to consider the entire
2191 menu trees we supply, rather than just the menu bar item names. */
2192 xg_modify_menubar_widgets (menubar_widget
,
2196 G_CALLBACK (menubar_selection_callback
),
2197 G_CALLBACK (popup_deactivate_callback
),
2198 G_CALLBACK (menu_highlight_callback
));
2202 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2205 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2206 G_CALLBACK (menubar_selection_callback
),
2207 G_CALLBACK (popup_deactivate_callback
),
2208 G_CALLBACK (menu_highlight_callback
));
2210 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2214 #else /* not USE_GTK */
2217 /* Disable resizing (done for Motif!) */
2218 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2220 /* The third arg is DEEP_P, which says to consider the entire
2221 menu trees we supply, rather than just the menu bar item names. */
2222 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2224 /* Re-enable the edit widget to resize. */
2225 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2229 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
2230 XtTranslations override
= XtParseTranslationTable (menuOverride
);
2232 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2233 f
->output_data
.x
->column_widget
,
2235 popup_activate_callback
,
2236 menubar_selection_callback
,
2237 popup_deactivate_callback
,
2238 menu_highlight_callback
);
2239 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2241 /* Make menu pop down on C-g. */
2242 XtOverrideTranslations (menubar_widget
, override
);
2247 = (f
->output_data
.x
->menubar_widget
2248 ? (f
->output_data
.x
->menubar_widget
->core
.height
2249 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2252 #if 0 /* Experimentally, we now get the right results
2253 for -geometry -0-0 without this. 24 Aug 96, rms. */
2255 if (FRAME_EXTERNAL_MENU_BAR (f
))
2258 XtVaGetValues (f
->output_data
.x
->column_widget
,
2259 XtNinternalBorderWidth
, &ibw
, NULL
);
2260 menubar_size
+= ibw
;
2262 #endif /* USE_LUCID */
2265 f
->output_data
.x
->menubar_height
= menubar_size
;
2267 #endif /* not USE_GTK */
2269 free_menubar_widget_value_tree (first_wv
);
2270 update_frame_menubar (f
);
2273 xg_crazy_callback_abort
= 0;
2279 /* Called from Fx_create_frame to create the initial menubar of a frame
2280 before it is mapped, so that the window is mapped with the menubar already
2281 there instead of us tacking it on later and thrashing the window after it
2285 initialize_frame_menubar (f
)
2288 /* This function is called before the first chance to redisplay
2289 the frame. It has to be, so the frame will have the right size. */
2290 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2291 set_frame_menubar (f
, 1, 1);
2295 /* Get rid of the menu bar of frame F, and free its storage.
2296 This is used when deleting a frame, and when turning off the menu bar.
2297 For GTK this function is in gtkutil.c. */
2301 free_frame_menubar (f
)
2304 Widget menubar_widget
;
2306 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2308 f
->output_data
.x
->menubar_height
= 0;
2313 /* Removing the menu bar magically changes the shell widget's x
2314 and y position of (0, 0) which, when the menu bar is turned
2315 on again, leads to pull-down menuss appearing in strange
2316 positions near the upper-left corner of the display. This
2317 happens only with some window managers like twm and ctwm,
2318 but not with other like Motif's mwm or kwm, because the
2319 latter generate ConfigureNotify events when the menu bar
2320 is switched off, which fixes the shell position. */
2321 Position x0
, y0
, x1
, y1
;
2327 if (f
->output_data
.x
->widget
)
2328 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2331 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2332 f
->output_data
.x
->menubar_widget
= NULL
;
2335 if (f
->output_data
.x
->widget
)
2337 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2338 if (x1
== 0 && y1
== 0)
2339 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2346 #endif /* not USE_GTK */
2348 #endif /* USE_X_TOOLKIT || USE_GTK */
2350 /* xmenu_show actually displays a menu using the panes and items in menu_items
2351 and returns the value selected from it.
2352 There are two versions of xmenu_show, one for Xt and one for Xlib.
2353 Both assume input is blocked by the caller. */
2355 /* F is the frame the menu is for.
2356 X and Y are the frame-relative specified position,
2357 relative to the inside upper left corner of the frame F.
2358 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2359 KEYMAPS is 1 if this menu was specified with keymaps;
2360 in that case, we return a list containing the chosen item's value
2361 and perhaps also the pane's prefix.
2362 TITLE is the specified menu title.
2363 ERROR is a place to store an error message string in case of failure.
2364 (We return nil on failure, but the value doesn't actually matter.) */
2366 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2368 /* The item selected in the popup menu. */
2369 static Lisp_Object
*volatile menu_item_selection
;
2373 /* Used when position a popup menu. See menu_position_func and
2374 create_and_show_popup_menu below. */
2375 struct next_popup_x_y
2382 /* The menu position function to use if we are not putting a popup
2383 menu where the pointer is.
2384 MENU is the menu to pop up.
2385 X and Y shall on exit contain x/y where the menu shall pop up.
2386 PUSH_IN is not documented in the GTK manual.
2387 USER_DATA is any data passed in when calling gtk_menu_popup.
2388 Here it points to a struct next_popup_x_y where the coordinates
2389 to store in *X and *Y are as well as the frame for the popup.
2391 Here only X and Y are used. */
2393 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2400 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2402 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2403 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2408 /* Check if there is room for the menu. If not, adjust x/y so that
2409 the menu is fully visible. */
2410 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2411 if (data
->x
+ req
.width
> disp_width
)
2412 *x
-= data
->x
+ req
.width
- disp_width
;
2413 if (data
->y
+ req
.height
> disp_height
)
2414 *y
-= data
->y
+ req
.height
- disp_height
;
2418 popup_selection_callback (widget
, client_data
)
2420 gpointer client_data
;
2422 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2424 if (xg_crazy_callback_abort
) return;
2425 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2432 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
2434 popup_activated_flag
= 0;
2436 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
2441 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2443 menu_item_selection will be set to the selection. */
2445 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2447 widget_value
*first_wv
;
2454 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2455 struct next_popup_x_y popup_x_y
;
2456 int specpdl_count
= SPECPDL_INDEX ();
2458 xg_crazy_callback_abort
= 1;
2459 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2460 G_CALLBACK (popup_selection_callback
),
2461 G_CALLBACK (popup_deactivate_callback
),
2462 G_CALLBACK (menu_highlight_callback
));
2463 xg_crazy_callback_abort
= 0;
2467 /* Not invoked by a click. pop up at x/y. */
2468 pos_func
= menu_position_func
;
2470 /* Adjust coordinates to be root-window-relative. */
2471 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2472 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2478 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
2482 for (i
= 0; i
< 5; i
++)
2483 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2487 /* Display the menu. */
2488 gtk_widget_show_all (menu
);
2489 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2491 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2493 if (GTK_WIDGET_MAPPED (menu
))
2495 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2496 two. show_help_echo uses this to detect popup menus. */
2497 popup_activated_flag
= 1;
2498 /* Process events that apply to the menu. */
2499 popup_widget_loop (1, menu
);
2502 unbind_to (specpdl_count
, Qnil
);
2504 /* Must reset this manually because the button release event is not passed
2505 to Emacs event loop. */
2506 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2509 #else /* not USE_GTK */
2511 /* We need a unique id for each widget handled by the Lucid Widget
2514 For the main windows, and popup menus, we use this counter,
2515 which we increment each time after use. This starts from 1<<16.
2517 For menu bars, we use numbers starting at 0, counted in
2518 next_menubar_widget_id. */
2519 LWLIB_ID widget_id_tick
;
2522 popup_selection_callback (widget
, id
, client_data
)
2525 XtPointer client_data
;
2527 menu_item_selection
= (Lisp_Object
*) client_data
;
2530 /* ARG is the LWLIB ID of the dialog box, represented
2531 as a Lisp object as (HIGHPART . LOWPART). */
2537 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2538 | XINT (XCDR (arg
)));
2541 lw_destroy_all_widgets (id
);
2543 popup_activated_flag
= 0;
2548 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2550 menu_item_selection will be set to the selection. */
2552 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2554 widget_value
*first_wv
;
2562 XButtonPressedEvent dummy
;
2566 menu_id
= widget_id_tick
++;
2567 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2568 f
->output_data
.x
->widget
, 1, 0,
2569 popup_selection_callback
,
2570 popup_deactivate_callback
,
2571 menu_highlight_callback
);
2573 dummy
.type
= ButtonPress
;
2575 dummy
.send_event
= 0;
2576 dummy
.display
= FRAME_X_DISPLAY (f
);
2577 dummy
.time
= CurrentTime
;
2578 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2579 dummy
.window
= dummy
.root
;
2580 dummy
.subwindow
= dummy
.root
;
2584 /* Adjust coordinates to be root-window-relative. */
2585 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2586 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2593 for (i
= 0; i
< 5; i
++)
2594 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2597 /* Don't allow any geometry request from the user. */
2598 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2599 XtSetValues (menu
, av
, ac
);
2601 /* Display the menu. */
2602 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2603 popup_activated_flag
= 1;
2606 int fact
= 4 * sizeof (LWLIB_ID
);
2607 int specpdl_count
= SPECPDL_INDEX ();
2608 record_unwind_protect (pop_down_menu
,
2609 Fcons (make_number (menu_id
>> (fact
)),
2610 make_number (menu_id
& ~(-1 << (fact
)))));
2612 /* Process events that apply to the menu. */
2613 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
2615 unbind_to (specpdl_count
, Qnil
);
2619 #endif /* not USE_GTK */
2622 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2632 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2633 widget_value
**submenu_stack
2634 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2635 Lisp_Object
*subprefix_stack
2636 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2637 int submenu_depth
= 0;
2643 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2645 *error
= "Empty menu";
2649 /* Create a tree of widget_value objects
2650 representing the panes and their items. */
2651 wv
= xmalloc_widget_value ();
2655 wv
->button_type
= BUTTON_TYPE_NONE
;
2660 /* Loop over all panes and items, filling in the tree. */
2662 while (i
< menu_items_used
)
2664 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2666 submenu_stack
[submenu_depth
++] = save_wv
;
2672 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2675 save_wv
= submenu_stack
[--submenu_depth
];
2679 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2680 && submenu_depth
!= 0)
2681 i
+= MENU_ITEMS_PANE_LENGTH
;
2682 /* Ignore a nil in the item list.
2683 It's meaningful only for dialog boxes. */
2684 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2686 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2688 /* Create a new pane. */
2689 Lisp_Object pane_name
, prefix
;
2692 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2693 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2695 #ifndef HAVE_MULTILINGUAL_MENU
2696 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2698 pane_name
= ENCODE_MENU_STRING (pane_name
);
2699 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2702 pane_string
= (NILP (pane_name
)
2703 ? "" : (char *) SDATA (pane_name
));
2704 /* If there is just one top-level pane, put all its items directly
2705 under the top-level menu. */
2706 if (menu_items_n_panes
== 1)
2709 /* If the pane has a meaningful name,
2710 make the pane a top-level menu item
2711 with its items as a submenu beneath it. */
2712 if (!keymaps
&& strcmp (pane_string
, ""))
2714 wv
= xmalloc_widget_value ();
2718 first_wv
->contents
= wv
;
2719 wv
->name
= pane_string
;
2720 if (keymaps
&& !NILP (prefix
))
2724 wv
->button_type
= BUTTON_TYPE_NONE
;
2729 else if (first_pane
)
2735 i
+= MENU_ITEMS_PANE_LENGTH
;
2739 /* Create a new item within current pane. */
2740 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2741 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2742 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2743 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2744 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2745 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2746 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2747 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2749 #ifndef HAVE_MULTILINGUAL_MENU
2750 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2752 item_name
= ENCODE_MENU_STRING (item_name
);
2753 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2756 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2758 descrip
= ENCODE_MENU_STRING (descrip
);
2759 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2761 #endif /* not HAVE_MULTILINGUAL_MENU */
2763 wv
= xmalloc_widget_value ();
2767 save_wv
->contents
= wv
;
2768 wv
->name
= (char *) SDATA (item_name
);
2769 if (!NILP (descrip
))
2770 wv
->key
= (char *) SDATA (descrip
);
2772 /* If this item has a null value,
2773 make the call_data null so that it won't display a box
2774 when the mouse is on it. */
2776 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2777 wv
->enabled
= !NILP (enable
);
2780 wv
->button_type
= BUTTON_TYPE_NONE
;
2781 else if (EQ (type
, QCtoggle
))
2782 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2783 else if (EQ (type
, QCradio
))
2784 wv
->button_type
= BUTTON_TYPE_RADIO
;
2788 wv
->selected
= !NILP (selected
);
2790 if (! STRINGP (help
))
2797 i
+= MENU_ITEMS_ITEM_LENGTH
;
2801 /* Deal with the title, if it is non-nil. */
2804 widget_value
*wv_title
= xmalloc_widget_value ();
2805 widget_value
*wv_sep1
= xmalloc_widget_value ();
2806 widget_value
*wv_sep2
= xmalloc_widget_value ();
2808 wv_sep2
->name
= "--";
2809 wv_sep2
->next
= first_wv
->contents
;
2810 wv_sep2
->help
= Qnil
;
2812 wv_sep1
->name
= "--";
2813 wv_sep1
->next
= wv_sep2
;
2814 wv_sep1
->help
= Qnil
;
2816 #ifndef HAVE_MULTILINGUAL_MENU
2817 if (STRING_MULTIBYTE (title
))
2818 title
= ENCODE_MENU_STRING (title
);
2821 wv_title
->name
= (char *) SDATA (title
);
2822 wv_title
->enabled
= TRUE
;
2823 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2824 wv_title
->next
= wv_sep1
;
2825 wv_title
->help
= Qnil
;
2826 first_wv
->contents
= wv_title
;
2829 /* No selection has been chosen yet. */
2830 menu_item_selection
= 0;
2832 /* Actually create and show the menu until popped down. */
2833 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2835 /* Free the widget_value objects we used to specify the contents. */
2836 free_menubar_widget_value_tree (first_wv
);
2838 /* Find the selected item, and its pane, to return
2839 the proper value. */
2840 if (menu_item_selection
!= 0)
2842 Lisp_Object prefix
, entry
;
2844 prefix
= entry
= Qnil
;
2846 while (i
< menu_items_used
)
2848 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2850 subprefix_stack
[submenu_depth
++] = prefix
;
2854 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2856 prefix
= subprefix_stack
[--submenu_depth
];
2859 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2862 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2863 i
+= MENU_ITEMS_PANE_LENGTH
;
2865 /* Ignore a nil in the item list.
2866 It's meaningful only for dialog boxes. */
2867 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2872 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2873 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2879 entry
= Fcons (entry
, Qnil
);
2881 entry
= Fcons (prefix
, entry
);
2882 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2883 if (!NILP (subprefix_stack
[j
]))
2884 entry
= Fcons (subprefix_stack
[j
], entry
);
2888 i
+= MENU_ITEMS_ITEM_LENGTH
;
2898 dialog_selection_callback (widget
, client_data
)
2900 gpointer client_data
;
2902 /* The EMACS_INT cast avoids a warning. There's no problem
2903 as long as pointers have enough bits to hold small integers. */
2904 if ((int) (EMACS_INT
) client_data
!= -1)
2905 menu_item_selection
= (Lisp_Object
*) client_data
;
2907 popup_activated_flag
= 0;
2910 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2912 menu_item_selection will be set to the selection. */
2914 create_and_show_dialog (f
, first_wv
)
2916 widget_value
*first_wv
;
2920 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2921 G_CALLBACK (dialog_selection_callback
),
2922 G_CALLBACK (popup_deactivate_callback
),
2927 int specpdl_count
= SPECPDL_INDEX ();
2928 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2930 /* Display the menu. */
2931 gtk_widget_show_all (menu
);
2933 /* Process events that apply to the menu. */
2934 popup_widget_loop (1, menu
);
2936 unbind_to (specpdl_count
, Qnil
);
2940 #else /* not USE_GTK */
2942 dialog_selection_callback (widget
, id
, client_data
)
2945 XtPointer client_data
;
2947 /* The EMACS_INT cast avoids a warning. There's no problem
2948 as long as pointers have enough bits to hold small integers. */
2949 if ((int) (EMACS_INT
) client_data
!= -1)
2950 menu_item_selection
= (Lisp_Object
*) client_data
;
2953 lw_destroy_all_widgets (id
);
2955 popup_activated_flag
= 0;
2959 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2961 menu_item_selection will be set to the selection. */
2963 create_and_show_dialog (f
, first_wv
)
2965 widget_value
*first_wv
;
2969 dialog_id
= widget_id_tick
++;
2970 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2971 f
->output_data
.x
->widget
, 1, 0,
2972 dialog_selection_callback
, 0, 0);
2973 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2975 /* Display the dialog box. */
2976 lw_pop_up_all_widgets (dialog_id
);
2977 popup_activated_flag
= 1;
2979 /* Process events that apply to the dialog box.
2980 Also handle timers. */
2982 int count
= SPECPDL_INDEX ();
2983 int fact
= 4 * sizeof (LWLIB_ID
);
2985 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2986 record_unwind_protect (pop_down_menu
,
2987 Fcons (make_number (dialog_id
>> (fact
)),
2988 make_number (dialog_id
& ~(-1 << (fact
)))));
2990 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
2993 unbind_to (count
, Qnil
);
2997 #endif /* not USE_GTK */
2999 static char * button_names
[] = {
3000 "button1", "button2", "button3", "button4", "button5",
3001 "button6", "button7", "button8", "button9", "button10" };
3004 xdialog_show (f
, keymaps
, title
, error
)
3010 int i
, nb_buttons
=0;
3011 char dialog_name
[6];
3013 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
3015 /* Number of elements seen so far, before boundary. */
3017 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
3018 int boundary_seen
= 0;
3022 if (menu_items_n_panes
> 1)
3024 *error
= "Multiple panes in dialog box";
3028 /* Create a tree of widget_value objects
3029 representing the text label and buttons. */
3031 Lisp_Object pane_name
, prefix
;
3033 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
3034 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
3035 pane_string
= (NILP (pane_name
)
3036 ? "" : (char *) SDATA (pane_name
));
3037 prev_wv
= xmalloc_widget_value ();
3038 prev_wv
->value
= pane_string
;
3039 if (keymaps
&& !NILP (prefix
))
3041 prev_wv
->enabled
= 1;
3042 prev_wv
->name
= "message";
3043 prev_wv
->help
= Qnil
;
3046 /* Loop over all panes and items, filling in the tree. */
3047 i
= MENU_ITEMS_PANE_LENGTH
;
3048 while (i
< menu_items_used
)
3051 /* Create a new item within current pane. */
3052 Lisp_Object item_name
, enable
, descrip
;
3053 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3054 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3056 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3058 if (NILP (item_name
))
3060 free_menubar_widget_value_tree (first_wv
);
3061 *error
= "Submenu in dialog items";
3064 if (EQ (item_name
, Qquote
))
3066 /* This is the boundary between left-side elts
3067 and right-side elts. Stop incrementing right_count. */
3072 if (nb_buttons
>= 9)
3074 free_menubar_widget_value_tree (first_wv
);
3075 *error
= "Too many dialog items";
3079 wv
= xmalloc_widget_value ();
3081 wv
->name
= (char *) button_names
[nb_buttons
];
3082 if (!NILP (descrip
))
3083 wv
->key
= (char *) SDATA (descrip
);
3084 wv
->value
= (char *) SDATA (item_name
);
3085 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3086 wv
->enabled
= !NILP (enable
);
3090 if (! boundary_seen
)
3094 i
+= MENU_ITEMS_ITEM_LENGTH
;
3097 /* If the boundary was not specified,
3098 by default put half on the left and half on the right. */
3099 if (! boundary_seen
)
3100 left_count
= nb_buttons
- nb_buttons
/ 2;
3102 wv
= xmalloc_widget_value ();
3103 wv
->name
= dialog_name
;
3105 /* Dialog boxes use a really stupid name encoding
3106 which specifies how many buttons to use
3107 and how many buttons are on the right.
3108 The Q means something also. */
3109 dialog_name
[0] = 'Q';
3110 dialog_name
[1] = '0' + nb_buttons
;
3111 dialog_name
[2] = 'B';
3112 dialog_name
[3] = 'R';
3113 /* Number of buttons to put on the right. */
3114 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3116 wv
->contents
= first_wv
;
3120 /* No selection has been chosen yet. */
3121 menu_item_selection
= 0;
3123 /* Actually create and show the dialog. */
3124 create_and_show_dialog (f
, first_wv
);
3126 /* Free the widget_value objects we used to specify the contents. */
3127 free_menubar_widget_value_tree (first_wv
);
3129 /* Find the selected item, and its pane, to return
3130 the proper value. */
3131 if (menu_item_selection
!= 0)
3137 while (i
< menu_items_used
)
3141 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3144 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3145 i
+= MENU_ITEMS_PANE_LENGTH
;
3147 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3149 /* This is the boundary between left-side elts and
3156 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3157 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3161 entry
= Fcons (entry
, Qnil
);
3163 entry
= Fcons (prefix
, entry
);
3167 i
+= MENU_ITEMS_ITEM_LENGTH
;
3172 /* Make "Cancel" equivalent to C-g. */
3173 Fsignal (Qquit
, Qnil
);
3178 #else /* not USE_X_TOOLKIT && not USE_GTK */
3180 /* The frame of the last activated non-toolkit menu bar.
3181 Used to generate menu help events. */
3183 static struct frame
*menu_help_frame
;
3186 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3188 PANE is the pane number, and ITEM is the menu item number in
3189 the menu (currently not used).
3191 This cannot be done with generating a HELP_EVENT because
3192 XMenuActivate contains a loop that doesn't let Emacs process
3196 menu_help_callback (help_string
, pane
, item
)
3200 extern Lisp_Object Qmenu_item
;
3201 Lisp_Object
*first_item
;
3202 Lisp_Object pane_name
;
3203 Lisp_Object menu_object
;
3205 first_item
= XVECTOR (menu_items
)->contents
;
3206 if (EQ (first_item
[0], Qt
))
3207 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3208 else if (EQ (first_item
[0], Qquote
))
3209 /* This shouldn't happen, see xmenu_show. */
3210 pane_name
= empty_string
;
3212 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3214 /* (menu-item MENU-NAME PANE-NUMBER) */
3215 menu_object
= Fcons (Qmenu_item
,
3217 Fcons (make_number (pane
), Qnil
)));
3218 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3219 Qnil
, menu_object
, make_number (item
), 1);
3226 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
3227 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
3229 FRAME_PTR f
= p1
->pointer
;
3230 XMenu
*menu
= p2
->pointer
;
3234 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
3235 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
3237 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3239 #ifdef HAVE_X_WINDOWS
3240 /* Assume the mouse has moved out of the X window.
3241 If it has actually moved in, we will get an EnterNotify. */
3242 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3244 /* State that no mouse buttons are now held.
3245 (The oldXMenu code doesn't track this info for us.)
3246 That is not necessarily true, but the fiction leads to reasonable
3247 results, and it is a pain to ask which are actually held now. */
3248 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3250 #endif /* HAVE_X_WINDOWS */
3259 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3269 int pane
, selidx
, lpane
, status
;
3270 Lisp_Object entry
, pane_prefix
;
3272 int ulx
, uly
, width
, height
;
3273 int dispwidth
, dispheight
;
3274 int i
, j
, lines
, maxlines
;
3277 unsigned int dummy_uint
;
3278 int specpdl_count
= SPECPDL_INDEX ();
3281 if (menu_items_n_panes
== 0)
3284 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3286 *error
= "Empty menu";
3290 /* Figure out which root window F is on. */
3291 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3292 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3293 &dummy_uint
, &dummy_uint
);
3295 /* Make the menu on that window. */
3296 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3299 *error
= "Can't create menu";
3303 #ifdef HAVE_X_WINDOWS
3304 /* Adjust coordinates to relative to the outer (window manager) window. */
3305 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
3306 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
3307 #endif /* HAVE_X_WINDOWS */
3309 /* Adjust coordinates to be root-window-relative. */
3313 /* Create all the necessary panes and their items. */
3314 maxlines
= lines
= i
= 0;
3315 while (i
< menu_items_used
)
3317 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3319 /* Create a new pane. */
3320 Lisp_Object pane_name
, prefix
;
3323 maxlines
= max (maxlines
, lines
);
3325 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3326 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3327 pane_string
= (NILP (pane_name
)
3328 ? "" : (char *) SDATA (pane_name
));
3329 if (keymaps
&& !NILP (prefix
))
3332 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3333 if (lpane
== XM_FAILURE
)
3335 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3336 *error
= "Can't create pane";
3339 i
+= MENU_ITEMS_PANE_LENGTH
;
3341 /* Find the width of the widest item in this pane. */
3344 while (j
< menu_items_used
)
3347 item
= XVECTOR (menu_items
)->contents
[j
];
3355 width
= SBYTES (item
);
3356 if (width
> maxwidth
)
3359 j
+= MENU_ITEMS_ITEM_LENGTH
;
3362 /* Ignore a nil in the item list.
3363 It's meaningful only for dialog boxes. */
3364 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3368 /* Create a new item within current pane. */
3369 Lisp_Object item_name
, enable
, descrip
, help
;
3370 unsigned char *item_data
;
3373 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3374 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3376 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3377 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3378 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3380 if (!NILP (descrip
))
3382 int gap
= maxwidth
- SBYTES (item_name
);
3385 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3386 item_name
= concat2 (item_name
, spacer
);
3387 item_name
= concat2 (item_name
, descrip
);
3388 item_data
= SDATA (item_name
);
3390 /* if alloca is fast, use that to make the space,
3391 to reduce gc needs. */
3393 = (unsigned char *) alloca (maxwidth
3394 + SBYTES (descrip
) + 1);
3395 bcopy (SDATA (item_name
), item_data
,
3396 SBYTES (item_name
));
3397 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3399 bcopy (SDATA (descrip
), item_data
+ j
,
3401 item_data
[j
+ SBYTES (descrip
)] = 0;
3405 item_data
= SDATA (item_name
);
3407 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3408 menu
, lpane
, 0, item_data
,
3409 !NILP (enable
), help_string
)
3412 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3413 *error
= "Can't add selection to menu";
3416 i
+= MENU_ITEMS_ITEM_LENGTH
;
3421 maxlines
= max (maxlines
, lines
);
3423 /* All set and ready to fly. */
3424 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3425 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3426 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3427 x
= min (x
, dispwidth
);
3428 y
= min (y
, dispheight
);
3431 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3432 &ulx
, &uly
, &width
, &height
);
3433 if (ulx
+width
> dispwidth
)
3435 x
-= (ulx
+ width
) - dispwidth
;
3436 ulx
= dispwidth
- width
;
3438 if (uly
+height
> dispheight
)
3440 y
-= (uly
+ height
) - dispheight
;
3441 uly
= dispheight
- height
;
3443 if (ulx
< 0) x
-= ulx
;
3444 if (uly
< 0) y
-= uly
;
3448 /* If position was not given by a mouse click, adjust so upper left
3449 corner of the menu as a whole ends up at given coordinates. This
3450 is what x-popup-menu says in its documentation. */
3452 y
+= 1.5*height
/(maxlines
+2);
3455 XMenuSetAEQ (menu
, TRUE
);
3456 XMenuSetFreeze (menu
, TRUE
);
3460 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3463 record_unwind_protect (pop_down_menu
,
3464 Fcons (make_save_value (f
, 0),
3465 make_save_value (menu
, 0)));
3467 /* Help display under X won't work because XMenuActivate contains
3468 a loop that doesn't give Emacs a chance to process it. */
3469 menu_help_frame
= f
;
3470 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3471 x
, y
, ButtonReleaseMask
, &datap
,
3472 menu_help_callback
);
3478 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3481 /* Find the item number SELIDX in pane number PANE. */
3483 while (i
< menu_items_used
)
3485 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3489 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3491 i
+= MENU_ITEMS_PANE_LENGTH
;
3500 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3503 entry
= Fcons (entry
, Qnil
);
3504 if (!NILP (pane_prefix
))
3505 entry
= Fcons (pane_prefix
, entry
);
3511 i
+= MENU_ITEMS_ITEM_LENGTH
;
3517 *error
= "Can't activate menu";
3522 /* Make "Cancel" equivalent to C-g unless this menu was popped up by
3525 Fsignal (Qquit
, Qnil
);
3530 unbind_to (specpdl_count
, Qnil
);
3535 #endif /* not USE_X_TOOLKIT */
3537 #endif /* HAVE_MENUS */
3542 staticpro (&menu_items
);
3544 menu_items_inuse
= Qnil
;
3546 Qdebug_on_next_call
= intern ("debug-on-next-call");
3547 staticpro (&Qdebug_on_next_call
);
3549 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3550 doc
: /* Frame for which we are updating a menu.
3551 The enable predicate for a menu command should check this variable. */);
3552 Vmenu_updating_frame
= Qnil
;
3554 #ifdef USE_X_TOOLKIT
3555 widget_id_tick
= (1<<16);
3556 next_menubar_widget_id
= 1;
3559 defsubr (&Sx_popup_menu
);
3561 defsubr (&Sx_popup_dialog
);
3565 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3566 (do not change this comment) */