1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* X pop-up deck-of-cards menu facility for GNU Emacs.
24 * Written by Jon Arnold and Roman Budzianowski
25 * Mods and rewrite by Robert Krawitz
29 /* Modified by Fred Pierresteguy on December 93
30 to make the popup menus and menubar use the Xt. */
32 /* Rewritten for clarity and GC protection by rms in Feb 94. */
36 #if 0 /* Why was this included? And without syssignal.h? */
37 /* On 4.3 this loses if it comes after xterm.h. */
47 #include "termhooks.h"
49 #include "blockinput.h"
53 #include "sysselect.h"
60 /* This may include sys/types.h, and that somehow loses
61 if this is not done before the other system files. */
65 /* Load sys/types.h if not already loaded.
66 In some systems loading it twice is suicidal. */
68 #include <sys/types.h>
71 #include "dispextern.h"
74 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
75 code accepts the Emacs internal encoding. */
76 #undef HAVE_MULTILINGUAL_MENU
80 #include <X11/IntrinsicP.h>
81 #include <X11/CoreP.h>
82 #include <X11/StringDefs.h>
83 #include <X11/Shell.h>
85 #include <X11/Xaw/Paned.h>
86 #endif /* USE_LUCID */
87 #include "../lwlib/lwlib.h"
88 #else /* not USE_X_TOOLKIT */
90 #include "../oldXMenu/XMenu.h"
92 #endif /* not USE_X_TOOLKIT */
93 #endif /* HAVE_X_WINDOWS */
100 Lisp_Object Vmenu_updating_frame
;
102 Lisp_Object Qdebug_on_next_call
;
104 extern Lisp_Object Qmenu_bar
;
106 extern Lisp_Object QCtoggle
, QCradio
;
108 extern Lisp_Object Voverriding_local_map
;
109 extern Lisp_Object Voverriding_local_map_menu_flag
;
111 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
113 extern Lisp_Object Qmenu_bar_update_hook
;
116 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
117 extern XtAppContext Xt_app_con
;
119 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
121 static void popup_get_selection
P_ ((XEvent
*, struct x_display_info
*,
124 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
127 #endif /* USE_X_TOOLKIT */
132 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
133 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
137 /* This is how to deal with multibyte text if HAVE_MULTILINGUAL_MENU
138 isn't defined. The use of HAVE_MULTILINGUAL_MENU could probably be
139 confined to an extended version of this with sections of code below
140 using it unconditionally. */
142 /* gtk just uses utf-8. */
143 # define ENCODE_MENU_STRING(str) ENCODE_UTF_8 (str)
144 #elif defined HAVE_X_I18N
145 # define ENCODE_MENU_STRING(str) ENCODE_SYSTEM (str)
147 # define ENCODE_MENU_STRING(str) string_make_unibyte (str)
150 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
151 Lisp_Object
, Lisp_Object
, Lisp_Object
,
152 Lisp_Object
, Lisp_Object
));
153 static int update_frame_menubar
P_ ((struct frame
*));
154 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
155 Lisp_Object
, char **));
156 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
157 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
159 static void list_of_panes
P_ ((Lisp_Object
));
160 static void list_of_items
P_ ((Lisp_Object
));
163 /* This holds a Lisp vector that holds the results of decoding
164 the keymaps or alist-of-alists that specify a menu.
166 It describes the panes and items within the panes.
168 Each pane is described by 3 elements in the vector:
169 t, the pane name, the pane's prefix key.
170 Then follow the pane's items, with 5 elements per item:
171 the item string, the enable flag, the item's value,
172 the definition, and the equivalent keyboard key's description string.
174 In some cases, multiple levels of menus may be described.
175 A single vector slot containing nil indicates the start of a submenu.
176 A single vector slot containing lambda indicates the end of a submenu.
177 The submenu follows a menu item which is the way to reach the submenu.
179 A single vector slot containing quote indicates that the
180 following items should appear on the right of a dialog box.
182 Using a Lisp vector to hold this information while we decode it
183 takes care of protecting all the data from GC. */
185 #define MENU_ITEMS_PANE_NAME 1
186 #define MENU_ITEMS_PANE_PREFIX 2
187 #define MENU_ITEMS_PANE_LENGTH 3
191 MENU_ITEMS_ITEM_NAME
= 0,
192 MENU_ITEMS_ITEM_ENABLE
,
193 MENU_ITEMS_ITEM_VALUE
,
194 MENU_ITEMS_ITEM_EQUIV_KEY
,
195 MENU_ITEMS_ITEM_DEFINITION
,
196 MENU_ITEMS_ITEM_TYPE
,
197 MENU_ITEMS_ITEM_SELECTED
,
198 MENU_ITEMS_ITEM_HELP
,
199 MENU_ITEMS_ITEM_LENGTH
202 static Lisp_Object menu_items
;
204 /* If non-nil, means that the global vars defined here are already in use.
205 Used to detect cases where we try to re-enter this non-reentrant code. */
206 static Lisp_Object menu_items_inuse
;
208 /* Number of slots currently allocated in menu_items. */
209 static int menu_items_allocated
;
211 /* This is the index in menu_items of the first empty slot. */
212 static int menu_items_used
;
214 /* The number of panes currently recorded in menu_items,
215 excluding those within submenus. */
216 static int menu_items_n_panes
;
218 /* Current depth within submenus. */
219 static int menu_items_submenu_depth
;
221 /* Flag which when set indicates a dialog or menu has been posted by
222 Xt on behalf of one of the widget sets. */
223 static int popup_activated_flag
;
225 static int next_menubar_widget_id
;
227 /* This is set nonzero after the user activates the menu bar, and set
228 to zero again after the menu bars are redisplayed by prepare_menu_bar.
229 While it is nonzero, all calls to set_frame_menubar go deep.
231 I don't understand why this is needed, but it does seem to be
232 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
234 int pending_menu_activation
;
238 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
240 static struct frame
*
241 menubar_id_to_frame (id
)
244 Lisp_Object tail
, frame
;
247 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
250 if (!GC_FRAMEP (frame
))
253 if (!FRAME_WINDOW_P (f
))
255 if (f
->output_data
.x
->id
== id
)
263 /* Initialize the menu_items structure if we haven't already done so.
264 Also mark it as currently empty. */
269 if (NILP (menu_items
))
271 menu_items_allocated
= 60;
272 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
275 if (!NILP (menu_items_inuse
))
276 error ("Trying to use a menu from within a menu-entry");
277 menu_items_inuse
= Qt
;
279 menu_items_n_panes
= 0;
280 menu_items_submenu_depth
= 0;
283 /* Call at the end of generating the data in menu_items. */
291 unuse_menu_items (dummy
)
294 return menu_items_inuse
= Qnil
;
297 /* Call when finished using the data for the current menu
301 discard_menu_items ()
303 /* Free the structure if it is especially large.
304 Otherwise, hold on to it, to save time. */
305 if (menu_items_allocated
> 200)
308 menu_items_allocated
= 0;
310 xassert (NILP (menu_items_inuse
));
313 /* Make the menu_items vector twice as large. */
319 int old_size
= menu_items_allocated
;
322 menu_items_allocated
*= 2;
323 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
324 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
325 old_size
* sizeof (Lisp_Object
));
328 /* Begin a submenu. */
331 push_submenu_start ()
333 if (menu_items_used
+ 1 > menu_items_allocated
)
336 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
337 menu_items_submenu_depth
++;
345 if (menu_items_used
+ 1 > menu_items_allocated
)
348 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
349 menu_items_submenu_depth
--;
352 /* Indicate boundary between left and right. */
355 push_left_right_boundary ()
357 if (menu_items_used
+ 1 > menu_items_allocated
)
360 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
363 /* Start a new menu pane in menu_items.
364 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
367 push_menu_pane (name
, prefix_vec
)
368 Lisp_Object name
, prefix_vec
;
370 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
373 if (menu_items_submenu_depth
== 0)
374 menu_items_n_panes
++;
375 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
376 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
377 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
380 /* Push one menu item into the current pane. NAME is the string to
381 display. ENABLE if non-nil means this item can be selected. KEY
382 is the key generated by choosing this item, or nil if this item
383 doesn't really have a definition. DEF is the definition of this
384 item. EQUIV is the textual description of the keyboard equivalent
385 for this item (or nil if none). TYPE is the type of this menu
386 item, one of nil, `toggle' or `radio'. */
389 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
390 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
392 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
395 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
396 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
397 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
398 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
399 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
400 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
401 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
402 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
405 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
406 and generate menu panes for them in menu_items.
407 If NOTREAL is nonzero,
408 don't bother really computing whether an item is enabled. */
411 keymap_panes (keymaps
, nmaps
, notreal
)
412 Lisp_Object
*keymaps
;
420 /* Loop over the given keymaps, making a pane for each map.
421 But don't make a pane that is empty--ignore that map instead.
422 P is the number of panes we have made so far. */
423 for (mapno
= 0; mapno
< nmaps
; mapno
++)
424 single_keymap_panes (keymaps
[mapno
],
425 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
427 finish_menu_items ();
430 /* Args passed between single_keymap_panes and single_menu_item. */
433 Lisp_Object pending_maps
;
434 int maxdepth
, notreal
;
438 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
441 /* This is a recursive subroutine of keymap_panes.
442 It handles one keymap, KEYMAP.
443 The other arguments are passed along
444 or point to local variables of the previous function.
445 If NOTREAL is nonzero, only check for equivalent key bindings, don't
446 evaluate expressions in menu items and don't make any menu.
448 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
451 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
453 Lisp_Object pane_name
;
461 skp
.pending_maps
= Qnil
;
462 skp
.maxdepth
= maxdepth
;
463 skp
.notreal
= notreal
;
469 push_menu_pane (pane_name
, prefix
);
472 /* Remember index for first item in this pane so we can go back and
473 add a prefix when (if) we see the first button. After that, notbuttons
474 is set to 0, to mark that we have seen a button and all non button
475 items need a prefix. */
476 skp
.notbuttons
= menu_items_used
;
479 GCPRO1 (skp
.pending_maps
);
480 map_keymap (keymap
, single_menu_item
, Qnil
, &skp
, 1);
483 /* Process now any submenus which want to be panes at this level. */
484 while (CONSP (skp
.pending_maps
))
486 Lisp_Object elt
, eltcdr
, string
;
487 elt
= XCAR (skp
.pending_maps
);
489 string
= XCAR (eltcdr
);
490 /* We no longer discard the @ from the beginning of the string here.
491 Instead, we do this in xmenu_show. */
492 single_keymap_panes (Fcar (elt
), string
,
493 XCDR (eltcdr
), notreal
, maxdepth
- 1);
494 skp
.pending_maps
= XCDR (skp
.pending_maps
);
498 /* This is a subroutine of single_keymap_panes that handles one
500 KEY is a key in a keymap and ITEM is its binding.
501 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
503 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
504 evaluate expressions in menu items and don't make any menu.
505 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
506 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
507 buttons. It keeps track of if we have seen a button in this menu or
511 single_menu_item (key
, item
, dummy
, skp_v
)
512 Lisp_Object key
, item
, dummy
;
515 Lisp_Object map
, item_string
, enabled
;
516 struct gcpro gcpro1
, gcpro2
;
518 struct skp
*skp
= skp_v
;
520 /* Parse the menu item and leave the result in item_properties. */
522 res
= parse_menu_item (item
, skp
->notreal
, 0);
525 return; /* Not a menu item. */
527 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
531 /* We don't want to make a menu, just traverse the keymaps to
532 precompute equivalent key bindings. */
534 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
538 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
539 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
541 if (!NILP (map
) && SREF (item_string
, 0) == '@')
544 /* An enabled separate pane. Remember this to handle it later. */
545 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
551 /* Simulate radio buttons and toggle boxes by putting a prefix in
554 Lisp_Object prefix
= Qnil
;
555 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
559 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
562 /* The first button. Line up previous items in this menu. */
564 int index
= skp
->notbuttons
; /* Index for first item this menu. */
567 while (index
< menu_items_used
)
570 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
574 submenu
++; /* Skip sub menu. */
576 else if (EQ (tem
, Qlambda
))
579 submenu
--; /* End sub menu. */
581 else if (EQ (tem
, Qt
))
582 index
+= 3; /* Skip new pane marker. */
583 else if (EQ (tem
, Qquote
))
584 index
++; /* Skip a left, right divider. */
587 if (!submenu
&& SREF (tem
, 0) != '\0'
588 && SREF (tem
, 0) != '-')
589 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
590 = concat2 (build_string (" "), tem
);
591 index
+= MENU_ITEMS_ITEM_LENGTH
;
597 /* Calculate prefix, if any, for this item. */
598 if (EQ (type
, QCtoggle
))
599 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
600 else if (EQ (type
, QCradio
))
601 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
603 /* Not a button. If we have earlier buttons, then we need a prefix. */
604 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
605 && SREF (item_string
, 0) != '-')
606 prefix
= build_string (" ");
609 item_string
= concat2 (prefix
, item_string
);
611 #endif /* not HAVE_BOXES */
613 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
615 /* Indicate visually that this is a submenu. */
616 item_string
= concat2 (item_string
, build_string (" >"));
619 push_menu_item (item_string
, enabled
, key
,
620 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
621 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
622 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
623 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
624 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
626 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
627 /* Display a submenu using the toolkit. */
628 if (! (NILP (map
) || NILP (enabled
)))
630 push_submenu_start ();
631 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
637 /* Push all the panes and items of a menu described by the
638 alist-of-alists MENU.
639 This handles old-fashioned calls to x-popup-menu. */
649 for (tail
= menu
; CONSP (tail
); tail
= XCDR (tail
))
651 Lisp_Object elt
, pane_name
, pane_data
;
653 pane_name
= Fcar (elt
);
654 CHECK_STRING (pane_name
);
655 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
656 pane_data
= Fcdr (elt
);
657 CHECK_CONS (pane_data
);
658 list_of_items (pane_data
);
661 finish_menu_items ();
664 /* Push the items in a single pane defined by the alist PANE. */
670 Lisp_Object tail
, item
, item1
;
672 for (tail
= pane
; CONSP (tail
); tail
= XCDR (tail
))
676 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
677 Qnil
, Qnil
, Qnil
, Qnil
);
678 else if (CONSP (item
))
681 CHECK_STRING (item1
);
682 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, XCDR (item
),
683 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
686 push_left_right_boundary ();
691 #ifdef HAVE_X_WINDOWS
692 /* Return the mouse position in *X and *Y. The coordinates are window
693 relative for the edit window in frame F.
694 This is for Fx_popup_menu. The mouse_position_hook can not
695 be used for X, as it returns window relative coordinates
696 for the window where the mouse is in. This could be the menu bar,
697 the scroll bar or the edit window. Fx_popup_menu needs to be
698 sure it is the edit window. */
700 mouse_position_for_popup (f
, x
, y
)
705 Window root
, dummy_window
;
713 XQueryPointer (FRAME_X_DISPLAY (f
),
714 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
716 /* The root window which contains the pointer. */
719 /* Window pointer is on, not used */
722 /* The position on that root window. */
725 /* x/y in dummy_window coordinates, not used. */
728 /* Modifier keys and pointer buttons, about which
730 (unsigned int *) &dummy
);
734 /* xmenu_show expects window coordinates, not root window
735 coordinates. Translate. */
736 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
737 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
740 #endif /* HAVE_X_WINDOWS */
742 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
743 doc
: /* Pop up a deck-of-cards menu and return user's selection.
744 POSITION is a position specification. This is either a mouse button event
745 or a list ((XOFFSET YOFFSET) WINDOW)
746 where XOFFSET and YOFFSET are positions in pixels from the top left
747 corner of WINDOW. (WINDOW may be a window or a frame object.)
748 This controls the position of the top left of the menu as a whole.
749 If POSITION is t, it means to use the current mouse position.
751 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
752 The menu items come from key bindings that have a menu string as well as
753 a definition; actually, the "definition" in such a key binding looks like
754 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
755 the keymap as a top-level element.
757 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
758 Otherwise, REAL-DEFINITION should be a valid key binding definition.
760 You can also use a list of keymaps as MENU.
761 Then each keymap makes a separate pane.
763 When MENU is a keymap or a list of keymaps, the return value is the
764 list of events corresponding to the user's choice. Note that
765 `x-popup-menu' does not actually execute the command bound to that
768 Alternatively, you can specify a menu of multiple panes
769 with a list of the form (TITLE PANE1 PANE2...),
770 where each pane is a list of form (TITLE ITEM1 ITEM2...).
771 Each ITEM is normally a cons cell (STRING . VALUE);
772 but a string can appear as an item--that makes a nonselectable line
774 With this form of menu, the return value is VALUE from the chosen item.
776 If POSITION is nil, don't display the menu at all, just precalculate the
777 cached information about equivalent key sequences.
779 If the user gets rid of the menu without making a valid choice, for
780 instance by clicking the mouse away from a valid choice or by typing
781 keyboard input, then this normally results in a quit and
782 `x-popup-menu' does not return. But if POSITION is a mouse button
783 event (indicating that the user invoked the menu with the mouse) then
784 no quit occurs and `x-popup-menu' returns nil. */)
786 Lisp_Object position
, menu
;
788 Lisp_Object keymap
, tem
;
789 int xpos
= 0, ypos
= 0;
791 char *error_name
= NULL
;
792 Lisp_Object selection
;
794 Lisp_Object x
, y
, window
;
797 int specpdl_count
= SPECPDL_INDEX ();
801 if (! NILP (position
))
803 int get_current_pos_p
= 0;
806 /* Decode the first argument: find the window and the coordinates. */
807 if (EQ (position
, Qt
)
808 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
809 || EQ (XCAR (position
), Qtool_bar
))))
811 get_current_pos_p
= 1;
815 tem
= Fcar (position
);
818 window
= Fcar (Fcdr (position
));
820 y
= Fcar (XCDR (tem
));
825 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
826 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
827 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
832 /* If a click happens in an external tool bar or a detached
833 tool bar, x and y is NIL. In that case, use the current
834 mouse position. This happens for the help button in the
835 tool bar. Ideally popup-menu should pass NIL to
836 this function, but it doesn't. */
837 if (NILP (x
) && NILP (y
))
838 get_current_pos_p
= 1;
841 if (get_current_pos_p
)
843 /* Use the mouse's current position. */
844 FRAME_PTR new_f
= SELECTED_FRAME ();
845 #ifdef HAVE_X_WINDOWS
846 /* Can't use mouse_position_hook for X since it returns
847 coordinates relative to the window the mouse is in,
848 we need coordinates relative to the edit widget always. */
853 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
854 /* cur_x/y may be negative, so use make_number. */
855 x
= make_number (cur_x
);
856 y
= make_number (cur_y
);
859 #else /* not HAVE_X_WINDOWS */
860 Lisp_Object bar_window
;
861 enum scroll_bar_part part
;
864 if (mouse_position_hook
)
865 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
866 &part
, &x
, &y
, &time
);
867 #endif /* not HAVE_X_WINDOWS */
870 XSETFRAME (window
, new_f
);
873 window
= selected_window
;
882 /* Decode where to put the menu. */
890 else if (WINDOWP (window
))
892 CHECK_LIVE_WINDOW (window
);
893 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
895 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
896 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
899 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
900 but I don't want to make one now. */
901 CHECK_WINDOW (window
);
907 error ("Can not put X menu on non-X terminal");
909 XSETFRAME (Vmenu_updating_frame
, f
);
912 Vmenu_updating_frame
= Qnil
;
913 #endif /* HAVE_MENUS */
915 record_unwind_protect (unuse_menu_items
, Qnil
);
919 /* Decode the menu items from what was specified. */
921 keymap
= get_keymap (menu
, 0, 0);
924 /* We were given a keymap. Extract menu info from the keymap. */
927 /* Extract the detailed info to make one pane. */
928 keymap_panes (&menu
, 1, NILP (position
));
930 /* Search for a string appearing directly as an element of the keymap.
931 That string is the title of the menu. */
932 prompt
= Fkeymap_prompt (keymap
);
933 if (NILP (title
) && !NILP (prompt
))
936 /* Make that be the pane title of the first pane. */
937 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
938 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
942 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
944 /* We were given a list of keymaps. */
945 int nmaps
= XFASTINT (Flength (menu
));
947 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
952 /* The first keymap that has a prompt string
953 supplies the menu title. */
954 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
958 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
960 prompt
= Fkeymap_prompt (keymap
);
961 if (NILP (title
) && !NILP (prompt
))
965 /* Extract the detailed info to make one pane. */
966 keymap_panes (maps
, nmaps
, NILP (position
));
968 /* Make the title be the pane title of the first pane. */
969 if (!NILP (title
) && menu_items_n_panes
>= 0)
970 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
976 /* We were given an old-fashioned menu. */
978 CHECK_STRING (title
);
980 list_of_panes (Fcdr (menu
));
985 unbind_to (specpdl_count
, Qnil
);
989 discard_menu_items ();
995 /* Display them in a menu. */
998 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
999 keymaps
, title
, &error_name
);
1002 discard_menu_items ();
1005 #endif /* HAVE_MENUS */
1007 if (error_name
) error (error_name
);
1013 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
1014 doc
: /* Pop up a dialog box and return user's selection.
1015 POSITION specifies which frame to use.
1016 This is normally a mouse button event or a window or frame.
1017 If POSITION is t, it means to use the frame the mouse is on.
1018 The dialog box appears in the middle of the specified frame.
1020 CONTENTS specifies the alternatives to display in the dialog box.
1021 It is a list of the form (DIALOG ITEM1 ITEM2...).
1022 Each ITEM is a cons cell (STRING . VALUE).
1023 The return value is VALUE from the chosen item.
1025 An ITEM may also be just a string--that makes a nonselectable item.
1026 An ITEM may also be nil--that means to put all preceding items
1027 on the left of the dialog box and all following items on the right.
1028 \(By default, approximately half appear on each side.)
1030 If HEADER is non-nil, the frame title for the box is "Information",
1031 otherwise it is "Question".
1033 If the user gets rid of the dialog box without making a valid choice,
1034 for instance using the window manager, then this produces a quit and
1035 `x-popup-dialog' does not return. */)
1036 (position
, contents
, header
)
1037 Lisp_Object position
, contents
, header
;
1044 /* Decode the first argument: find the window or frame to use. */
1045 if (EQ (position
, Qt
)
1046 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1047 || EQ (XCAR (position
), Qtool_bar
))))
1049 #if 0 /* Using the frame the mouse is on may not be right. */
1050 /* Use the mouse's current position. */
1051 FRAME_PTR new_f
= SELECTED_FRAME ();
1052 Lisp_Object bar_window
;
1053 enum scroll_bar_part part
;
1057 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1060 XSETFRAME (window
, new_f
);
1062 window
= selected_window
;
1064 window
= selected_window
;
1066 else if (CONSP (position
))
1069 tem
= Fcar (position
);
1071 window
= Fcar (Fcdr (position
));
1074 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1075 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1078 else if (WINDOWP (position
) || FRAMEP (position
))
1083 /* Decode where to put the menu. */
1085 if (FRAMEP (window
))
1086 f
= XFRAME (window
);
1087 else if (WINDOWP (window
))
1089 CHECK_LIVE_WINDOW (window
);
1090 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1093 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1094 but I don't want to make one now. */
1095 CHECK_WINDOW (window
);
1097 if (! FRAME_X_P (f
))
1098 error ("Can not put X dialog on non-X terminal");
1100 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1101 /* Display a menu with these alternatives
1102 in the middle of frame F. */
1104 Lisp_Object x
, y
, frame
, newpos
;
1105 XSETFRAME (frame
, f
);
1106 XSETINT (x
, x_pixel_width (f
) / 2);
1107 XSETINT (y
, x_pixel_height (f
) / 2);
1108 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1110 return Fx_popup_menu (newpos
,
1111 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1117 Lisp_Object selection
;
1118 int specpdl_count
= SPECPDL_INDEX ();
1120 /* Decode the dialog items from what was specified. */
1121 title
= Fcar (contents
);
1122 CHECK_STRING (title
);
1123 record_unwind_protect (unuse_menu_items
, Qnil
);
1125 if (NILP (Fcar (Fcdr (contents
))))
1126 /* No buttons specified, add an "Ok" button so users can pop down
1127 the dialog. Also, the lesstif/motif version crashes if there are
1129 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1131 list_of_panes (Fcons (contents
, Qnil
));
1133 /* Display them in a dialog box. */
1135 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
1138 unbind_to (specpdl_count
, Qnil
);
1139 discard_menu_items ();
1141 if (error_name
) error (error_name
);
1150 /* Set menu_items_inuse so no other popup menu or dialog is created. */
1153 x_menu_set_in_use (in_use
)
1156 menu_items_inuse
= in_use
? Qt
: Qnil
;
1157 popup_activated_flag
= in_use
;
1160 /* Wait for an X event to arrive or for a timer to expire. */
1163 x_menu_wait_for_event (void *data
)
1165 extern EMACS_TIME timer_check
P_ ((int));
1167 /* Another way to do this is to register a timer callback, that can be
1168 done in GTK and Xt. But we have to do it like this when using only X
1169 anyway, and with callbacks we would have three variants for timer handling
1170 instead of the small ifdefs below. */
1173 #ifdef USE_X_TOOLKIT
1174 ! XtAppPending (Xt_app_con
)
1175 #elif defined USE_GTK
1176 ! gtk_events_pending ()
1178 ! XPending ((Display
*) data
)
1182 EMACS_TIME next_time
= timer_check (1);
1183 long secs
= EMACS_SECS (next_time
);
1184 long usecs
= EMACS_USECS (next_time
);
1185 SELECT_TYPE read_fds
;
1186 struct x_display_info
*dpyinfo
;
1189 FD_ZERO (&read_fds
);
1190 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1192 int fd
= ConnectionNumber (dpyinfo
->display
);
1193 FD_SET (fd
, &read_fds
);
1197 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1199 /* Sometimes timer_check returns -1 (no timers) even if there are
1200 timers. So do a timeout anyway. */
1201 EMACS_SET_SECS (next_time
, 1);
1202 EMACS_SET_USECS (next_time
, 0);
1205 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1208 #endif /* ! MSDOS */
1211 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1213 #ifdef USE_X_TOOLKIT
1215 /* Loop in Xt until the menu pulldown or dialog popup has been
1216 popped down (deactivated). This is used for x-popup-menu
1217 and x-popup-dialog; it is not used for the menu bar.
1219 NOTE: All calls to popup_get_selection should be protected
1220 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1223 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1224 XEvent
*initial_event
;
1225 struct x_display_info
*dpyinfo
;
1231 while (popup_activated_flag
)
1235 event
= *initial_event
;
1240 if (do_timers
) x_menu_wait_for_event (0);
1241 XtAppNextEvent (Xt_app_con
, &event
);
1244 /* Make sure we don't consider buttons grabbed after menu goes.
1245 And make sure to deactivate for any ButtonRelease,
1246 even if XtDispatchEvent doesn't do that. */
1247 if (event
.type
== ButtonRelease
1248 && dpyinfo
->display
== event
.xbutton
.display
)
1250 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1251 #ifdef USE_MOTIF /* Pretending that the event came from a
1252 Btn1Down seems the only way to convince Motif to
1253 activate its callbacks; setting the XmNmenuPost
1254 isn't working. --marcus@sysc.pdx.edu. */
1255 event
.xbutton
.button
= 1;
1256 /* Motif only pops down menus when no Ctrl, Alt or Mod
1257 key is pressed and the button is released. So reset key state
1258 so Motif thinks this is the case. */
1259 event
.xbutton
.state
= 0;
1262 /* Pop down on C-g and Escape. */
1263 else if (event
.type
== KeyPress
1264 && dpyinfo
->display
== event
.xbutton
.display
)
1266 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1268 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
1269 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
1270 popup_activated_flag
= 0;
1273 x_dispatch_event (&event
, event
.xany
.display
);
1277 #endif /* USE_X_TOOLKIT */
1280 /* Loop util popup_activated_flag is set to zero in a callback.
1281 Used for popup menus and dialogs. */
1284 popup_widget_loop (do_timers
, widget
)
1288 ++popup_activated_flag
;
1290 /* Process events in the Gtk event loop until done. */
1291 while (popup_activated_flag
)
1293 if (do_timers
) x_menu_wait_for_event (0);
1294 gtk_main_iteration ();
1299 /* Activate the menu bar of frame F.
1300 This is called from keyboard.c when it gets the
1301 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1303 To activate the menu bar, we use the X button-press event
1304 that was saved in saved_menu_event.
1305 That makes the toolkit do its thing.
1307 But first we recompute the menu bar contents (the whole tree).
1309 The reason for saving the button event until here, instead of
1310 passing it to the toolkit right away, is that we can safely
1311 execute Lisp code. */
1314 x_activate_menubar (f
)
1317 if (! FRAME_X_P (f
))
1320 if (!f
->output_data
.x
->saved_menu_event
->type
)
1324 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1325 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1329 set_frame_menubar (f
, 0, 1);
1332 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1333 f
->output_data
.x
->saved_menu_event
);
1334 popup_activated_flag
= 1;
1336 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1340 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1341 pending_menu_activation
= 1;
1344 /* Ignore this if we get it a second time. */
1345 f
->output_data
.x
->saved_menu_event
->type
= 0;
1348 /* Detect if a dialog or menu has been posted. */
1353 return popup_activated_flag
;
1356 /* This callback is invoked when the user selects a menubar cascade
1357 pushbutton, but before the pulldown menu is posted. */
1361 popup_activate_callback (widget
, id
, client_data
)
1364 XtPointer client_data
;
1366 popup_activated_flag
= 1;
1370 /* This callback is invoked when a dialog or menu is finished being
1371 used and has been unposted. */
1375 popup_deactivate_callback (widget
, client_data
)
1377 gpointer client_data
;
1379 popup_activated_flag
= 0;
1383 popup_deactivate_callback (widget
, id
, client_data
)
1386 XtPointer client_data
;
1388 popup_activated_flag
= 0;
1393 /* Function that finds the frame for WIDGET and shows the HELP text
1395 F is the frame if known, or NULL if not known. */
1397 show_help_event (f
, widget
, help
)
1399 xt_or_gtk_widget widget
;
1406 XSETFRAME (frame
, f
);
1407 kbd_buffer_store_help_event (frame
, help
);
1411 #if 0 /* This code doesn't do anything useful. ++kfs */
1412 /* WIDGET is the popup menu. It's parent is the frame's
1413 widget. See which frame that is. */
1414 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1417 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1419 frame
= XCAR (tail
);
1420 if (GC_FRAMEP (frame
)
1421 && (f
= XFRAME (frame
),
1422 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1426 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1430 /* Callback called when menu items are highlighted/unhighlighted
1431 while moving the mouse over them. WIDGET is the menu bar or menu
1432 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1433 the data structure for the menu item, or null in case of
1438 menu_highlight_callback (widget
, call_data
)
1442 xg_menu_item_cb_data
*cb_data
;
1445 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1447 if (! cb_data
) return;
1449 help
= call_data
? cb_data
->help
: Qnil
;
1451 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1452 Don't show help for them, they won't appear before the
1453 popup is popped down. */
1454 if (popup_activated_flag
<= 1)
1455 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1459 menu_highlight_callback (widget
, id
, call_data
)
1467 widget_value
*wv
= (widget_value
*) call_data
;
1469 help
= wv
? wv
->help
: Qnil
;
1471 /* Determine the frame for the help event. */
1472 f
= menubar_id_to_frame (id
);
1474 show_help_event (f
, widget
, help
);
1478 /* Find the menu selection and store it in the keyboard buffer.
1479 F is the frame the menu is on.
1480 MENU_BAR_ITEMS_USED is the length of VECTOR.
1481 VECTOR is an array of menu events for the whole menu. */
1484 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1486 int menu_bar_items_used
;
1490 Lisp_Object prefix
, entry
;
1491 Lisp_Object
*subprefix_stack
;
1492 int submenu_depth
= 0;
1496 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1500 while (i
< menu_bar_items_used
)
1502 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1504 subprefix_stack
[submenu_depth
++] = prefix
;
1508 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1510 prefix
= subprefix_stack
[--submenu_depth
];
1513 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1515 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1516 i
+= MENU_ITEMS_PANE_LENGTH
;
1520 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1521 /* The EMACS_INT cast avoids a warning. There's no problem
1522 as long as pointers have enough bits to hold small integers. */
1523 if ((int) (EMACS_INT
) client_data
== i
)
1526 struct input_event buf
;
1530 XSETFRAME (frame
, f
);
1531 buf
.kind
= MENU_BAR_EVENT
;
1532 buf
.frame_or_window
= frame
;
1534 kbd_buffer_store_event (&buf
);
1536 for (j
= 0; j
< submenu_depth
; j
++)
1537 if (!NILP (subprefix_stack
[j
]))
1539 buf
.kind
= MENU_BAR_EVENT
;
1540 buf
.frame_or_window
= frame
;
1541 buf
.arg
= subprefix_stack
[j
];
1542 kbd_buffer_store_event (&buf
);
1547 buf
.kind
= MENU_BAR_EVENT
;
1548 buf
.frame_or_window
= frame
;
1550 kbd_buffer_store_event (&buf
);
1553 buf
.kind
= MENU_BAR_EVENT
;
1554 buf
.frame_or_window
= frame
;
1556 kbd_buffer_store_event (&buf
);
1560 i
+= MENU_ITEMS_ITEM_LENGTH
;
1567 /* Gtk calls callbacks just because we tell it what item should be
1568 selected in a radio group. If this variable is set to a non-zero
1569 value, we are creating menus and don't want callbacks right now.
1571 static int xg_crazy_callback_abort
;
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
, client_data
)
1580 gpointer client_data
;
1582 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1584 if (xg_crazy_callback_abort
)
1587 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1590 /* For a group of radio buttons, GTK calls the selection callback first
1591 for the item that was active before the selection and then for the one that
1592 is active after the selection. For C-h k this means we get the help on
1593 the deselected item and then the selected item is executed. Prevent that
1594 by ignoring the non-active item. */
1595 if (GTK_IS_RADIO_MENU_ITEM (widget
)
1596 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
1599 /* When a menu is popped down, X generates a focus event (i.e. focus
1600 goes back to the frame below the menu). Since GTK buffers events,
1601 we force it out here before the menu selection event. Otherwise
1602 sit-for will exit at once if the focus event follows the menu selection
1606 while (gtk_events_pending ())
1607 gtk_main_iteration ();
1610 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1611 cb_data
->cl_data
->menu_bar_items_used
,
1612 cb_data
->cl_data
->menu_bar_vector
,
1613 cb_data
->call_data
);
1616 #else /* not USE_GTK */
1618 /* This callback is called from the menu bar pulldown menu
1619 when the user makes a selection.
1620 Figure out what the user chose
1621 and put the appropriate events into the keyboard buffer. */
1623 menubar_selection_callback (widget
, id
, client_data
)
1626 XtPointer client_data
;
1630 f
= menubar_id_to_frame (id
);
1633 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1634 f
->menu_bar_vector
, client_data
);
1636 #endif /* not USE_GTK */
1638 /* Allocate a widget_value, blocking input. */
1641 xmalloc_widget_value ()
1643 widget_value
*value
;
1646 value
= malloc_widget_value ();
1652 /* This recursively calls free_widget_value on the tree of widgets.
1653 It must free all data that was malloc'ed for these widget_values.
1654 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1655 must be left alone. */
1658 free_menubar_widget_value_tree (wv
)
1663 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1665 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1667 free_menubar_widget_value_tree (wv
->contents
);
1668 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1672 free_menubar_widget_value_tree (wv
->next
);
1673 wv
->next
= (widget_value
*) 0xDEADBEEF;
1676 free_widget_value (wv
);
1680 /* Set up data in menu_items for a menu bar item
1681 whose event type is ITEM_KEY (with string ITEM_NAME)
1682 and whose contents come from the list of keymaps MAPS. */
1685 parse_single_submenu (item_key
, item_name
, maps
)
1686 Lisp_Object item_key
, item_name
, maps
;
1690 Lisp_Object
*mapvec
;
1692 int top_level_items
= 0;
1694 length
= Flength (maps
);
1695 len
= XINT (length
);
1697 /* Convert the list MAPS into a vector MAPVEC. */
1698 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1699 for (i
= 0; i
< len
; i
++)
1701 mapvec
[i
] = Fcar (maps
);
1705 /* Loop over the given keymaps, making a pane for each map.
1706 But don't make a pane that is empty--ignore that map instead. */
1707 for (i
= 0; i
< len
; i
++)
1709 if (!KEYMAPP (mapvec
[i
]))
1711 /* Here we have a command at top level in the menu bar
1712 as opposed to a submenu. */
1713 top_level_items
= 1;
1714 push_menu_pane (Qnil
, Qnil
);
1715 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1716 Qnil
, Qnil
, Qnil
, Qnil
);
1721 prompt
= Fkeymap_prompt (mapvec
[i
]);
1722 single_keymap_panes (mapvec
[i
],
1723 !NILP (prompt
) ? prompt
: item_name
,
1728 return top_level_items
;
1731 /* Create a tree of widget_value objects
1732 representing the panes and items
1733 in menu_items starting at index START, up to index END. */
1735 static widget_value
*
1736 digest_single_submenu (start
, end
, top_level_items
)
1737 int start
, end
, top_level_items
;
1739 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1741 int submenu_depth
= 0;
1742 widget_value
**submenu_stack
;
1745 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1746 wv
= xmalloc_widget_value ();
1750 wv
->button_type
= BUTTON_TYPE_NONE
;
1756 /* Loop over all panes and items made by the preceding call
1757 to parse_single_submenu and construct a tree of widget_value objects.
1758 Ignore the panes and items used by previous calls to
1759 digest_single_submenu, even though those are also in menu_items. */
1763 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1765 submenu_stack
[submenu_depth
++] = save_wv
;
1770 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1773 save_wv
= submenu_stack
[--submenu_depth
];
1776 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1777 && submenu_depth
!= 0)
1778 i
+= MENU_ITEMS_PANE_LENGTH
;
1779 /* Ignore a nil in the item list.
1780 It's meaningful only for dialog boxes. */
1781 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1783 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1785 /* Create a new pane. */
1786 Lisp_Object pane_name
, prefix
;
1789 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1790 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1792 #ifndef HAVE_MULTILINGUAL_MENU
1793 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1795 pane_name
= ENCODE_MENU_STRING (pane_name
);
1796 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1799 pane_string
= (NILP (pane_name
)
1800 ? "" : (char *) SDATA (pane_name
));
1801 /* If there is just one top-level pane, put all its items directly
1802 under the top-level menu. */
1803 if (menu_items_n_panes
== 1)
1806 /* If the pane has a meaningful name,
1807 make the pane a top-level menu item
1808 with its items as a submenu beneath it. */
1809 if (strcmp (pane_string
, ""))
1811 wv
= xmalloc_widget_value ();
1815 first_wv
->contents
= wv
;
1816 wv
->lname
= pane_name
;
1817 /* Set value to 1 so update_submenu_strings can handle '@' */
1818 wv
->value
= (char *)1;
1820 wv
->button_type
= BUTTON_TYPE_NONE
;
1828 i
+= MENU_ITEMS_PANE_LENGTH
;
1832 /* Create a new item within current pane. */
1833 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1836 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1837 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1838 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1839 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1840 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1841 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1842 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1844 #ifndef HAVE_MULTILINGUAL_MENU
1845 if (STRING_MULTIBYTE (item_name
))
1847 item_name
= ENCODE_MENU_STRING (item_name
);
1848 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1851 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1853 descrip
= ENCODE_MENU_STRING (descrip
);
1854 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1856 #endif /* not HAVE_MULTILINGUAL_MENU */
1858 wv
= xmalloc_widget_value ();
1862 save_wv
->contents
= wv
;
1864 wv
->lname
= item_name
;
1865 if (!NILP (descrip
))
1868 /* The EMACS_INT cast avoids a warning. There's no problem
1869 as long as pointers have enough bits to hold small integers. */
1870 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1871 wv
->enabled
= !NILP (enable
);
1874 wv
->button_type
= BUTTON_TYPE_NONE
;
1875 else if (EQ (type
, QCradio
))
1876 wv
->button_type
= BUTTON_TYPE_RADIO
;
1877 else if (EQ (type
, QCtoggle
))
1878 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1882 wv
->selected
= !NILP (selected
);
1883 if (! STRINGP (help
))
1890 i
+= MENU_ITEMS_ITEM_LENGTH
;
1894 /* If we have just one "menu item"
1895 that was originally a button, return it by itself. */
1896 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1898 wv
= first_wv
->contents
;
1899 free_widget_value (first_wv
);
1906 /* Walk through the widget_value tree starting at FIRST_WV and update
1907 the char * pointers from the corresponding lisp values.
1908 We do this after building the whole tree, since GC may happen while the
1909 tree is constructed, and small strings are relocated. So we must wait
1910 until no GC can happen before storing pointers into lisp values. */
1912 update_submenu_strings (first_wv
)
1913 widget_value
*first_wv
;
1917 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1919 if (STRINGP (wv
->lname
))
1921 wv
->name
= (char *) SDATA (wv
->lname
);
1923 /* Ignore the @ that means "separate pane".
1924 This is a kludge, but this isn't worth more time. */
1925 if (wv
->value
== (char *)1)
1927 if (wv
->name
[0] == '@')
1933 if (STRINGP (wv
->lkey
))
1934 wv
->key
= (char *) SDATA (wv
->lkey
);
1937 update_submenu_strings (wv
->contents
);
1942 /* Recompute all the widgets of frame F, when the menu bar has been
1943 changed. Value is non-zero if widgets were updated. */
1946 update_frame_menubar (f
)
1950 return xg_update_frame_menubar (f
);
1955 if (! FRAME_X_P (f
))
1958 x
= f
->output_data
.x
;
1960 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1964 /* Save the size of the frame because the pane widget doesn't accept
1965 to resize itself. So force it. */
1966 columns
= FRAME_COLS (f
);
1967 rows
= FRAME_LINES (f
);
1969 /* Do the voodoo which means "I'm changing lots of things, don't try
1970 to refigure sizes until I'm done." */
1971 lw_refigure_widget (x
->column_widget
, False
);
1973 /* The order in which children are managed is the top to bottom
1974 order in which they are displayed in the paned window. First,
1975 remove the text-area widget. */
1976 XtUnmanageChild (x
->edit_widget
);
1978 /* Remove the menubar that is there now, and put up the menubar that
1980 XtManageChild (x
->menubar_widget
);
1981 XtMapWidget (x
->menubar_widget
);
1982 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1984 /* Re-manage the text-area widget, and then thrash the sizes. */
1985 XtManageChild (x
->edit_widget
);
1986 lw_refigure_widget (x
->column_widget
, True
);
1988 /* Force the pane widget to resize itself with the right values. */
1989 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1995 /* Set the contents of the menubar widgets of frame F.
1996 The argument FIRST_TIME is currently ignored;
1997 it is set the first time this is called, from initialize_frame_menubar. */
2000 set_frame_menubar (f
, first_time
, deep_p
)
2005 xt_or_gtk_widget menubar_widget
;
2006 #ifdef USE_X_TOOLKIT
2010 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
2012 int *submenu_start
, *submenu_end
;
2013 int *submenu_top_level_items
, *submenu_n_panes
;
2015 if (! FRAME_X_P (f
))
2018 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2020 XSETFRAME (Vmenu_updating_frame
, f
);
2022 #ifdef USE_X_TOOLKIT
2023 if (f
->output_data
.x
->id
== 0)
2024 f
->output_data
.x
->id
= next_menubar_widget_id
++;
2025 id
= f
->output_data
.x
->id
;
2028 if (! menubar_widget
)
2030 else if (pending_menu_activation
&& !deep_p
)
2032 /* Make the first call for any given frame always go deep. */
2033 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
2036 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
2037 f
->output_data
.x
->saved_menu_event
->type
= 0;
2041 /* If we have detached menus, we must update deep so detached menus
2042 also gets updated. */
2043 deep_p
= deep_p
|| xg_have_tear_offs ();
2048 /* Make a widget-value tree representing the entire menu trees. */
2050 struct buffer
*prev
= current_buffer
;
2052 int specpdl_count
= SPECPDL_INDEX ();
2053 int previous_menu_items_used
= f
->menu_bar_items_used
;
2054 Lisp_Object
*previous_items
2055 = (Lisp_Object
*) alloca (previous_menu_items_used
2056 * sizeof (Lisp_Object
));
2058 /* If we are making a new widget, its contents are empty,
2059 do always reinitialize them. */
2060 if (! menubar_widget
)
2061 previous_menu_items_used
= 0;
2063 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
2064 specbind (Qinhibit_quit
, Qt
);
2065 /* Don't let the debugger step into this code
2066 because it is not reentrant. */
2067 specbind (Qdebug_on_next_call
, Qnil
);
2069 record_unwind_save_match_data ();
2070 record_unwind_protect (unuse_menu_items
, Qnil
);
2071 if (NILP (Voverriding_local_map_menu_flag
))
2073 specbind (Qoverriding_terminal_local_map
, Qnil
);
2074 specbind (Qoverriding_local_map
, Qnil
);
2077 set_buffer_internal_1 (XBUFFER (buffer
));
2079 /* Run the Lucid hook. */
2080 safe_run_hooks (Qactivate_menubar_hook
);
2082 /* If it has changed current-menubar from previous value,
2083 really recompute the menubar from the value. */
2084 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2085 call0 (Qrecompute_lucid_menubar
);
2086 safe_run_hooks (Qmenu_bar_update_hook
);
2087 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2089 items
= FRAME_MENU_BAR_ITEMS (f
);
2091 /* Save the frame's previous menu bar contents data. */
2092 if (previous_menu_items_used
)
2093 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2094 previous_menu_items_used
* sizeof (Lisp_Object
));
2096 /* Fill in menu_items with the current menu bar contents.
2097 This can evaluate Lisp code. */
2098 menu_items
= f
->menu_bar_vector
;
2099 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2100 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2101 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2102 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2103 submenu_top_level_items
2104 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2106 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2108 Lisp_Object key
, string
, maps
;
2112 key
= XVECTOR (items
)->contents
[i
];
2113 string
= XVECTOR (items
)->contents
[i
+ 1];
2114 maps
= XVECTOR (items
)->contents
[i
+ 2];
2118 submenu_start
[i
] = menu_items_used
;
2120 menu_items_n_panes
= 0;
2121 submenu_top_level_items
[i
]
2122 = parse_single_submenu (key
, string
, maps
);
2123 submenu_n_panes
[i
] = menu_items_n_panes
;
2125 submenu_end
[i
] = menu_items_used
;
2128 finish_menu_items ();
2130 /* Convert menu_items into widget_value trees
2131 to display the menu. This cannot evaluate Lisp code. */
2133 wv
= xmalloc_widget_value ();
2134 wv
->name
= "menubar";
2137 wv
->button_type
= BUTTON_TYPE_NONE
;
2141 for (i
= 0; i
< last_i
; i
+= 4)
2143 menu_items_n_panes
= submenu_n_panes
[i
];
2144 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2145 submenu_top_level_items
[i
]);
2149 first_wv
->contents
= wv
;
2150 /* Don't set wv->name here; GC during the loop might relocate it. */
2152 wv
->button_type
= BUTTON_TYPE_NONE
;
2156 set_buffer_internal_1 (prev
);
2157 unbind_to (specpdl_count
, Qnil
);
2159 /* If there has been no change in the Lisp-level contents
2160 of the menu bar, skip redisplaying it. Just exit. */
2162 for (i
= 0; i
< previous_menu_items_used
; i
++)
2163 if (menu_items_used
== i
2164 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2166 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2168 free_menubar_widget_value_tree (first_wv
);
2169 discard_menu_items ();
2174 /* Now GC cannot happen during the lifetime of the widget_value,
2175 so it's safe to store data from a Lisp_String. */
2176 wv
= first_wv
->contents
;
2177 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2180 string
= XVECTOR (items
)->contents
[i
+ 1];
2183 wv
->name
= (char *) SDATA (string
);
2184 update_submenu_strings (wv
->contents
);
2188 f
->menu_bar_vector
= menu_items
;
2189 f
->menu_bar_items_used
= menu_items_used
;
2190 discard_menu_items ();
2194 /* Make a widget-value tree containing
2195 just the top level menu bar strings. */
2197 wv
= xmalloc_widget_value ();
2198 wv
->name
= "menubar";
2201 wv
->button_type
= BUTTON_TYPE_NONE
;
2205 items
= FRAME_MENU_BAR_ITEMS (f
);
2206 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2210 string
= XVECTOR (items
)->contents
[i
+ 1];
2214 wv
= xmalloc_widget_value ();
2215 wv
->name
= (char *) SDATA (string
);
2218 wv
->button_type
= BUTTON_TYPE_NONE
;
2220 /* This prevents lwlib from assuming this
2221 menu item is really supposed to be empty. */
2222 /* The EMACS_INT cast avoids a warning.
2223 This value just has to be different from small integers. */
2224 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2229 first_wv
->contents
= wv
;
2233 /* Forget what we thought we knew about what is in the
2234 detailed contents of the menu bar menus.
2235 Changing the top level always destroys the contents. */
2236 f
->menu_bar_items_used
= 0;
2239 /* Create or update the menu bar widget. */
2244 xg_crazy_callback_abort
= 1;
2247 /* The fourth arg is DEEP_P, which says to consider the entire
2248 menu trees we supply, rather than just the menu bar item names. */
2249 xg_modify_menubar_widgets (menubar_widget
,
2253 G_CALLBACK (menubar_selection_callback
),
2254 G_CALLBACK (popup_deactivate_callback
),
2255 G_CALLBACK (menu_highlight_callback
));
2259 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2262 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2263 G_CALLBACK (menubar_selection_callback
),
2264 G_CALLBACK (popup_deactivate_callback
),
2265 G_CALLBACK (menu_highlight_callback
));
2267 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2271 #else /* not USE_GTK */
2274 /* Disable resizing (done for Motif!) */
2275 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2277 /* The third arg is DEEP_P, which says to consider the entire
2278 menu trees we supply, rather than just the menu bar item names. */
2279 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2281 /* Re-enable the edit widget to resize. */
2282 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2286 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
2287 XtTranslations override
= XtParseTranslationTable (menuOverride
);
2289 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2290 f
->output_data
.x
->column_widget
,
2292 popup_activate_callback
,
2293 menubar_selection_callback
,
2294 popup_deactivate_callback
,
2295 menu_highlight_callback
);
2296 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2298 /* Make menu pop down on C-g. */
2299 XtOverrideTranslations (menubar_widget
, override
);
2304 = (f
->output_data
.x
->menubar_widget
2305 ? (f
->output_data
.x
->menubar_widget
->core
.height
2306 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2309 #if 0 /* Experimentally, we now get the right results
2310 for -geometry -0-0 without this. 24 Aug 96, rms. */
2312 if (FRAME_EXTERNAL_MENU_BAR (f
))
2315 XtVaGetValues (f
->output_data
.x
->column_widget
,
2316 XtNinternalBorderWidth
, &ibw
, NULL
);
2317 menubar_size
+= ibw
;
2319 #endif /* USE_LUCID */
2322 f
->output_data
.x
->menubar_height
= menubar_size
;
2324 #endif /* not USE_GTK */
2326 free_menubar_widget_value_tree (first_wv
);
2327 update_frame_menubar (f
);
2330 xg_crazy_callback_abort
= 0;
2336 /* Called from Fx_create_frame to create the initial menubar of a frame
2337 before it is mapped, so that the window is mapped with the menubar already
2338 there instead of us tacking it on later and thrashing the window after it
2342 initialize_frame_menubar (f
)
2345 /* This function is called before the first chance to redisplay
2346 the frame. It has to be, so the frame will have the right size. */
2347 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2348 set_frame_menubar (f
, 1, 1);
2352 /* Get rid of the menu bar of frame F, and free its storage.
2353 This is used when deleting a frame, and when turning off the menu bar.
2354 For GTK this function is in gtkutil.c. */
2358 free_frame_menubar (f
)
2361 Widget menubar_widget
;
2363 if (! FRAME_X_P (f
))
2366 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2368 f
->output_data
.x
->menubar_height
= 0;
2373 /* Removing the menu bar magically changes the shell widget's x
2374 and y position of (0, 0) which, when the menu bar is turned
2375 on again, leads to pull-down menuss appearing in strange
2376 positions near the upper-left corner of the display. This
2377 happens only with some window managers like twm and ctwm,
2378 but not with other like Motif's mwm or kwm, because the
2379 latter generate ConfigureNotify events when the menu bar
2380 is switched off, which fixes the shell position. */
2381 Position x0
, y0
, x1
, y1
;
2387 if (f
->output_data
.x
->widget
)
2388 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2391 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2392 f
->output_data
.x
->menubar_widget
= NULL
;
2395 if (f
->output_data
.x
->widget
)
2397 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2398 if (x1
== 0 && y1
== 0)
2399 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2406 #endif /* not USE_GTK */
2408 #endif /* USE_X_TOOLKIT || USE_GTK */
2410 /* xmenu_show actually displays a menu using the panes and items in menu_items
2411 and returns the value selected from it.
2412 There are two versions of xmenu_show, one for Xt and one for Xlib.
2413 Both assume input is blocked by the caller. */
2415 /* F is the frame the menu is for.
2416 X and Y are the frame-relative specified position,
2417 relative to the inside upper left corner of the frame F.
2418 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2419 KEYMAPS is 1 if this menu was specified with keymaps;
2420 in that case, we return a list containing the chosen item's value
2421 and perhaps also the pane's prefix.
2422 TITLE is the specified menu title.
2423 ERROR is a place to store an error message string in case of failure.
2424 (We return nil on failure, but the value doesn't actually matter.) */
2426 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2428 /* The item selected in the popup menu. */
2429 static Lisp_Object
*volatile menu_item_selection
;
2433 /* Used when position a popup menu. See menu_position_func and
2434 create_and_show_popup_menu below. */
2435 struct next_popup_x_y
2442 /* The menu position function to use if we are not putting a popup
2443 menu where the pointer is.
2444 MENU is the menu to pop up.
2445 X and Y shall on exit contain x/y where the menu shall pop up.
2446 PUSH_IN is not documented in the GTK manual.
2447 USER_DATA is any data passed in when calling gtk_menu_popup.
2448 Here it points to a struct next_popup_x_y where the coordinates
2449 to store in *X and *Y are as well as the frame for the popup.
2451 Here only X and Y are used. */
2453 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2460 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2462 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2463 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2468 /* Check if there is room for the menu. If not, adjust x/y so that
2469 the menu is fully visible. */
2470 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2471 if (data
->x
+ req
.width
> disp_width
)
2472 *x
-= data
->x
+ req
.width
- disp_width
;
2473 if (data
->y
+ req
.height
> disp_height
)
2474 *y
-= data
->y
+ req
.height
- disp_height
;
2478 popup_selection_callback (widget
, client_data
)
2480 gpointer client_data
;
2482 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2484 if (xg_crazy_callback_abort
) return;
2485 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2492 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
2494 popup_activated_flag
= 0;
2496 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
2501 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2503 menu_item_selection will be set to the selection. */
2505 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2507 widget_value
*first_wv
;
2514 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2515 struct next_popup_x_y popup_x_y
;
2516 int specpdl_count
= SPECPDL_INDEX ();
2518 if (! FRAME_X_P (f
))
2521 xg_crazy_callback_abort
= 1;
2522 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2523 G_CALLBACK (popup_selection_callback
),
2524 G_CALLBACK (popup_deactivate_callback
),
2525 G_CALLBACK (menu_highlight_callback
));
2526 xg_crazy_callback_abort
= 0;
2530 /* Not invoked by a click. pop up at x/y. */
2531 pos_func
= menu_position_func
;
2533 /* Adjust coordinates to be root-window-relative. */
2534 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2535 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2541 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
2545 for (i
= 0; i
< 5; i
++)
2546 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2550 /* Display the menu. */
2551 gtk_widget_show_all (menu
);
2552 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2554 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2556 if (GTK_WIDGET_MAPPED (menu
))
2558 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2559 two. show_help_echo uses this to detect popup menus. */
2560 popup_activated_flag
= 1;
2561 /* Process events that apply to the menu. */
2562 popup_widget_loop (1, menu
);
2565 unbind_to (specpdl_count
, Qnil
);
2567 /* Must reset this manually because the button release event is not passed
2568 to Emacs event loop. */
2569 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2572 #else /* not USE_GTK */
2574 /* We need a unique id for each widget handled by the Lucid Widget
2577 For the main windows, and popup menus, we use this counter,
2578 which we increment each time after use. This starts from 1<<16.
2580 For menu bars, we use numbers starting at 0, counted in
2581 next_menubar_widget_id. */
2582 LWLIB_ID widget_id_tick
;
2585 popup_selection_callback (widget
, id
, client_data
)
2588 XtPointer client_data
;
2590 menu_item_selection
= (Lisp_Object
*) client_data
;
2593 /* ARG is the LWLIB ID of the dialog box, represented
2594 as a Lisp object as (HIGHPART . LOWPART). */
2600 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2601 | XINT (XCDR (arg
)));
2604 lw_destroy_all_widgets (id
);
2606 popup_activated_flag
= 0;
2611 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2613 menu_item_selection will be set to the selection. */
2615 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2617 widget_value
*first_wv
;
2625 XButtonPressedEvent dummy
;
2629 if (! FRAME_X_P (f
))
2632 menu_id
= widget_id_tick
++;
2633 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2634 f
->output_data
.x
->widget
, 1, 0,
2635 popup_selection_callback
,
2636 popup_deactivate_callback
,
2637 menu_highlight_callback
);
2639 dummy
.type
= ButtonPress
;
2641 dummy
.send_event
= 0;
2642 dummy
.display
= FRAME_X_DISPLAY (f
);
2643 dummy
.time
= CurrentTime
;
2644 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2645 dummy
.window
= dummy
.root
;
2646 dummy
.subwindow
= dummy
.root
;
2650 /* Adjust coordinates to be root-window-relative. */
2651 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2652 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2659 for (i
= 0; i
< 5; i
++)
2660 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2663 /* Don't allow any geometry request from the user. */
2664 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2665 XtSetValues (menu
, av
, ac
);
2667 /* Display the menu. */
2668 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2669 popup_activated_flag
= 1;
2672 int fact
= 4 * sizeof (LWLIB_ID
);
2673 int specpdl_count
= SPECPDL_INDEX ();
2674 record_unwind_protect (pop_down_menu
,
2675 Fcons (make_number (menu_id
>> (fact
)),
2676 make_number (menu_id
& ~(-1 << (fact
)))));
2678 /* Process events that apply to the menu. */
2679 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
2681 unbind_to (specpdl_count
, Qnil
);
2685 #endif /* not USE_GTK */
2688 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2698 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2699 widget_value
**submenu_stack
2700 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2701 Lisp_Object
*subprefix_stack
2702 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2703 int submenu_depth
= 0;
2707 if (! FRAME_X_P (f
))
2712 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2714 *error
= "Empty menu";
2718 /* Create a tree of widget_value objects
2719 representing the panes and their items. */
2720 wv
= xmalloc_widget_value ();
2724 wv
->button_type
= BUTTON_TYPE_NONE
;
2729 /* Loop over all panes and items, filling in the tree. */
2731 while (i
< menu_items_used
)
2733 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2735 submenu_stack
[submenu_depth
++] = save_wv
;
2741 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2744 save_wv
= submenu_stack
[--submenu_depth
];
2748 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2749 && submenu_depth
!= 0)
2750 i
+= MENU_ITEMS_PANE_LENGTH
;
2751 /* Ignore a nil in the item list.
2752 It's meaningful only for dialog boxes. */
2753 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2755 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2757 /* Create a new pane. */
2758 Lisp_Object pane_name
, prefix
;
2761 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2762 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2764 #ifndef HAVE_MULTILINGUAL_MENU
2765 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2767 pane_name
= ENCODE_MENU_STRING (pane_name
);
2768 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2771 pane_string
= (NILP (pane_name
)
2772 ? "" : (char *) SDATA (pane_name
));
2773 /* If there is just one top-level pane, put all its items directly
2774 under the top-level menu. */
2775 if (menu_items_n_panes
== 1)
2778 /* If the pane has a meaningful name,
2779 make the pane a top-level menu item
2780 with its items as a submenu beneath it. */
2781 if (!keymaps
&& strcmp (pane_string
, ""))
2783 wv
= xmalloc_widget_value ();
2787 first_wv
->contents
= wv
;
2788 wv
->name
= pane_string
;
2789 if (keymaps
&& !NILP (prefix
))
2793 wv
->button_type
= BUTTON_TYPE_NONE
;
2798 else if (first_pane
)
2804 i
+= MENU_ITEMS_PANE_LENGTH
;
2808 /* Create a new item within current pane. */
2809 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2810 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2811 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2812 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2813 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2814 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2815 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2816 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2818 #ifndef HAVE_MULTILINGUAL_MENU
2819 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2821 item_name
= ENCODE_MENU_STRING (item_name
);
2822 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2825 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2827 descrip
= ENCODE_MENU_STRING (descrip
);
2828 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2830 #endif /* not HAVE_MULTILINGUAL_MENU */
2832 wv
= xmalloc_widget_value ();
2836 save_wv
->contents
= wv
;
2837 wv
->name
= (char *) SDATA (item_name
);
2838 if (!NILP (descrip
))
2839 wv
->key
= (char *) SDATA (descrip
);
2841 /* If this item has a null value,
2842 make the call_data null so that it won't display a box
2843 when the mouse is on it. */
2845 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2846 wv
->enabled
= !NILP (enable
);
2849 wv
->button_type
= BUTTON_TYPE_NONE
;
2850 else if (EQ (type
, QCtoggle
))
2851 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2852 else if (EQ (type
, QCradio
))
2853 wv
->button_type
= BUTTON_TYPE_RADIO
;
2857 wv
->selected
= !NILP (selected
);
2859 if (! STRINGP (help
))
2866 i
+= MENU_ITEMS_ITEM_LENGTH
;
2870 /* Deal with the title, if it is non-nil. */
2873 widget_value
*wv_title
= xmalloc_widget_value ();
2874 widget_value
*wv_sep1
= xmalloc_widget_value ();
2875 widget_value
*wv_sep2
= xmalloc_widget_value ();
2877 wv_sep2
->name
= "--";
2878 wv_sep2
->next
= first_wv
->contents
;
2879 wv_sep2
->help
= Qnil
;
2881 wv_sep1
->name
= "--";
2882 wv_sep1
->next
= wv_sep2
;
2883 wv_sep1
->help
= Qnil
;
2885 #ifndef HAVE_MULTILINGUAL_MENU
2886 if (STRING_MULTIBYTE (title
))
2887 title
= ENCODE_MENU_STRING (title
);
2890 wv_title
->name
= (char *) SDATA (title
);
2891 wv_title
->enabled
= TRUE
;
2892 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2893 wv_title
->next
= wv_sep1
;
2894 wv_title
->help
= Qnil
;
2895 first_wv
->contents
= wv_title
;
2898 /* No selection has been chosen yet. */
2899 menu_item_selection
= 0;
2901 /* Actually create and show the menu until popped down. */
2902 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2904 /* Free the widget_value objects we used to specify the contents. */
2905 free_menubar_widget_value_tree (first_wv
);
2907 /* Find the selected item, and its pane, to return
2908 the proper value. */
2909 if (menu_item_selection
!= 0)
2911 Lisp_Object prefix
, entry
;
2913 prefix
= entry
= Qnil
;
2915 while (i
< menu_items_used
)
2917 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2919 subprefix_stack
[submenu_depth
++] = prefix
;
2923 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2925 prefix
= subprefix_stack
[--submenu_depth
];
2928 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2931 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2932 i
+= MENU_ITEMS_PANE_LENGTH
;
2934 /* Ignore a nil in the item list.
2935 It's meaningful only for dialog boxes. */
2936 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2941 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2942 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2948 entry
= Fcons (entry
, Qnil
);
2950 entry
= Fcons (prefix
, entry
);
2951 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2952 if (!NILP (subprefix_stack
[j
]))
2953 entry
= Fcons (subprefix_stack
[j
], entry
);
2957 i
+= MENU_ITEMS_ITEM_LENGTH
;
2961 else if (!for_click
)
2962 /* Make "Cancel" equivalent to C-g. */
2963 Fsignal (Qquit
, Qnil
);
2970 dialog_selection_callback (widget
, client_data
)
2972 gpointer client_data
;
2974 /* The EMACS_INT cast avoids a warning. There's no problem
2975 as long as pointers have enough bits to hold small integers. */
2976 if ((int) (EMACS_INT
) client_data
!= -1)
2977 menu_item_selection
= (Lisp_Object
*) client_data
;
2979 popup_activated_flag
= 0;
2982 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2984 menu_item_selection will be set to the selection. */
2986 create_and_show_dialog (f
, first_wv
)
2988 widget_value
*first_wv
;
2992 if (! FRAME_X_P (f
))
2995 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2996 G_CALLBACK (dialog_selection_callback
),
2997 G_CALLBACK (popup_deactivate_callback
),
3002 int specpdl_count
= SPECPDL_INDEX ();
3003 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
3005 /* Display the menu. */
3006 gtk_widget_show_all (menu
);
3008 /* Process events that apply to the menu. */
3009 popup_widget_loop (1, menu
);
3011 unbind_to (specpdl_count
, Qnil
);
3015 #else /* not USE_GTK */
3017 dialog_selection_callback (widget
, id
, client_data
)
3020 XtPointer client_data
;
3022 /* The EMACS_INT cast avoids a warning. There's no problem
3023 as long as pointers have enough bits to hold small integers. */
3024 if ((int) (EMACS_INT
) client_data
!= -1)
3025 menu_item_selection
= (Lisp_Object
*) client_data
;
3028 lw_destroy_all_widgets (id
);
3030 popup_activated_flag
= 0;
3034 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
3036 menu_item_selection will be set to the selection. */
3038 create_and_show_dialog (f
, first_wv
)
3040 widget_value
*first_wv
;
3047 dialog_id
= widget_id_tick
++;
3048 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
3049 f
->output_data
.x
->widget
, 1, 0,
3050 dialog_selection_callback
, 0, 0);
3051 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
3053 /* Display the dialog box. */
3054 lw_pop_up_all_widgets (dialog_id
);
3055 popup_activated_flag
= 1;
3057 /* Process events that apply to the dialog box.
3058 Also handle timers. */
3060 int count
= SPECPDL_INDEX ();
3061 int fact
= 4 * sizeof (LWLIB_ID
);
3063 /* xdialog_show_unwind is responsible for popping the dialog box down. */
3064 record_unwind_protect (pop_down_menu
,
3065 Fcons (make_number (dialog_id
>> (fact
)),
3066 make_number (dialog_id
& ~(-1 << (fact
)))));
3068 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
3071 unbind_to (count
, Qnil
);
3075 #endif /* not USE_GTK */
3077 static char * button_names
[] = {
3078 "button1", "button2", "button3", "button4", "button5",
3079 "button6", "button7", "button8", "button9", "button10" };
3082 xdialog_show (f
, keymaps
, title
, header
, error_name
)
3085 Lisp_Object title
, header
;
3088 int i
, nb_buttons
=0;
3089 char dialog_name
[6];
3091 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
3093 /* Number of elements seen so far, before boundary. */
3095 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
3096 int boundary_seen
= 0;
3098 if (! FRAME_X_P (f
))
3103 if (menu_items_n_panes
> 1)
3105 *error_name
= "Multiple panes in dialog box";
3109 /* Create a tree of widget_value objects
3110 representing the text label and buttons. */
3112 Lisp_Object pane_name
, prefix
;
3114 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
3115 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
3116 pane_string
= (NILP (pane_name
)
3117 ? "" : (char *) SDATA (pane_name
));
3118 prev_wv
= xmalloc_widget_value ();
3119 prev_wv
->value
= pane_string
;
3120 if (keymaps
&& !NILP (prefix
))
3122 prev_wv
->enabled
= 1;
3123 prev_wv
->name
= "message";
3124 prev_wv
->help
= Qnil
;
3127 /* Loop over all panes and items, filling in the tree. */
3128 i
= MENU_ITEMS_PANE_LENGTH
;
3129 while (i
< menu_items_used
)
3132 /* Create a new item within current pane. */
3133 Lisp_Object item_name
, enable
, descrip
;
3134 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3135 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3137 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3139 if (NILP (item_name
))
3141 free_menubar_widget_value_tree (first_wv
);
3142 *error_name
= "Submenu in dialog items";
3145 if (EQ (item_name
, Qquote
))
3147 /* This is the boundary between left-side elts
3148 and right-side elts. Stop incrementing right_count. */
3153 if (nb_buttons
>= 9)
3155 free_menubar_widget_value_tree (first_wv
);
3156 *error_name
= "Too many dialog items";
3160 wv
= xmalloc_widget_value ();
3162 wv
->name
= (char *) button_names
[nb_buttons
];
3163 if (!NILP (descrip
))
3164 wv
->key
= (char *) SDATA (descrip
);
3165 wv
->value
= (char *) SDATA (item_name
);
3166 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3167 wv
->enabled
= !NILP (enable
);
3171 if (! boundary_seen
)
3175 i
+= MENU_ITEMS_ITEM_LENGTH
;
3178 /* If the boundary was not specified,
3179 by default put half on the left and half on the right. */
3180 if (! boundary_seen
)
3181 left_count
= nb_buttons
- nb_buttons
/ 2;
3183 wv
= xmalloc_widget_value ();
3184 wv
->name
= dialog_name
;
3187 /* Frame title: 'Q' = Question, 'I' = Information.
3188 Can also have 'E' = Error if, one day, we want
3189 a popup for errors. */
3191 dialog_name
[0] = 'Q';
3193 dialog_name
[0] = 'I';
3195 /* Dialog boxes use a really stupid name encoding
3196 which specifies how many buttons to use
3197 and how many buttons are on the right. */
3198 dialog_name
[1] = '0' + nb_buttons
;
3199 dialog_name
[2] = 'B';
3200 dialog_name
[3] = 'R';
3201 /* Number of buttons to put on the right. */
3202 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3204 wv
->contents
= first_wv
;
3208 /* No selection has been chosen yet. */
3209 menu_item_selection
= 0;
3211 /* Actually create and show the dialog. */
3212 create_and_show_dialog (f
, first_wv
);
3214 /* Free the widget_value objects we used to specify the contents. */
3215 free_menubar_widget_value_tree (first_wv
);
3217 /* Find the selected item, and its pane, to return
3218 the proper value. */
3219 if (menu_item_selection
!= 0)
3225 while (i
< menu_items_used
)
3229 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3232 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3233 i
+= MENU_ITEMS_PANE_LENGTH
;
3235 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3237 /* This is the boundary between left-side elts and
3244 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3245 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3249 entry
= Fcons (entry
, Qnil
);
3251 entry
= Fcons (prefix
, entry
);
3255 i
+= MENU_ITEMS_ITEM_LENGTH
;
3260 /* Make "Cancel" equivalent to C-g. */
3261 Fsignal (Qquit
, Qnil
);
3266 #else /* not USE_X_TOOLKIT && not USE_GTK */
3268 /* The frame of the last activated non-toolkit menu bar.
3269 Used to generate menu help events. */
3271 static struct frame
*menu_help_frame
;
3274 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3276 PANE is the pane number, and ITEM is the menu item number in
3277 the menu (currently not used).
3279 This cannot be done with generating a HELP_EVENT because
3280 XMenuActivate contains a loop that doesn't let Emacs process
3284 menu_help_callback (help_string
, pane
, item
)
3288 extern Lisp_Object Qmenu_item
;
3289 Lisp_Object
*first_item
;
3290 Lisp_Object pane_name
;
3291 Lisp_Object menu_object
;
3293 first_item
= XVECTOR (menu_items
)->contents
;
3294 if (EQ (first_item
[0], Qt
))
3295 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3296 else if (EQ (first_item
[0], Qquote
))
3297 /* This shouldn't happen, see xmenu_show. */
3298 pane_name
= empty_string
;
3300 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3302 /* (menu-item MENU-NAME PANE-NUMBER) */
3303 menu_object
= Fcons (Qmenu_item
,
3305 Fcons (make_number (pane
), Qnil
)));
3306 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3307 Qnil
, menu_object
, make_number (item
), 1);
3314 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
3315 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
3317 FRAME_PTR f
= p1
->pointer
;
3318 XMenu
*menu
= p2
->pointer
;
3322 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
3323 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
3325 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3327 #ifdef HAVE_X_WINDOWS
3328 /* Assume the mouse has moved out of the X window.
3329 If it has actually moved in, we will get an EnterNotify. */
3330 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3332 /* State that no mouse buttons are now held.
3333 (The oldXMenu code doesn't track this info for us.)
3334 That is not necessarily true, but the fiction leads to reasonable
3335 results, and it is a pain to ask which are actually held now. */
3336 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3338 #endif /* HAVE_X_WINDOWS */
3347 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3357 int pane
, selidx
, lpane
, status
;
3358 Lisp_Object entry
, pane_prefix
;
3360 int ulx
, uly
, width
, height
;
3361 int dispwidth
, dispheight
;
3362 int i
, j
, lines
, maxlines
;
3365 unsigned int dummy_uint
;
3366 int specpdl_count
= SPECPDL_INDEX ();
3368 if (! FRAME_X_P (f
))
3372 if (menu_items_n_panes
== 0)
3375 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3377 *error
= "Empty menu";
3381 /* Figure out which root window F is on. */
3382 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3383 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3384 &dummy_uint
, &dummy_uint
);
3386 /* Make the menu on that window. */
3387 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3390 *error
= "Can't create menu";
3394 /* Don't GC while we prepare and show the menu,
3395 because we give the oldxmenu library pointers to the
3396 contents of strings. */
3397 inhibit_garbage_collection ();
3399 #ifdef HAVE_X_WINDOWS
3400 /* Adjust coordinates to relative to the outer (window manager) window. */
3401 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
3402 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
3403 #endif /* HAVE_X_WINDOWS */
3405 /* Adjust coordinates to be root-window-relative. */
3409 /* Create all the necessary panes and their items. */
3410 maxlines
= lines
= i
= 0;
3411 while (i
< menu_items_used
)
3413 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3415 /* Create a new pane. */
3416 Lisp_Object pane_name
, prefix
;
3419 maxlines
= max (maxlines
, lines
);
3421 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3422 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3423 pane_string
= (NILP (pane_name
)
3424 ? "" : (char *) SDATA (pane_name
));
3425 if (keymaps
&& !NILP (prefix
))
3428 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3429 if (lpane
== XM_FAILURE
)
3431 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3432 *error
= "Can't create pane";
3435 i
+= MENU_ITEMS_PANE_LENGTH
;
3437 /* Find the width of the widest item in this pane. */
3440 while (j
< menu_items_used
)
3443 item
= XVECTOR (menu_items
)->contents
[j
];
3451 width
= SBYTES (item
);
3452 if (width
> maxwidth
)
3455 j
+= MENU_ITEMS_ITEM_LENGTH
;
3458 /* Ignore a nil in the item list.
3459 It's meaningful only for dialog boxes. */
3460 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3464 /* Create a new item within current pane. */
3465 Lisp_Object item_name
, enable
, descrip
, help
;
3466 unsigned char *item_data
;
3469 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3470 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3472 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3473 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3474 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3476 if (!NILP (descrip
))
3478 int gap
= maxwidth
- SBYTES (item_name
);
3481 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3482 item_name
= concat2 (item_name
, spacer
);
3483 item_name
= concat2 (item_name
, descrip
);
3484 item_data
= SDATA (item_name
);
3486 /* if alloca is fast, use that to make the space,
3487 to reduce gc needs. */
3489 = (unsigned char *) alloca (maxwidth
3490 + SBYTES (descrip
) + 1);
3491 bcopy (SDATA (item_name
), item_data
,
3492 SBYTES (item_name
));
3493 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3495 bcopy (SDATA (descrip
), item_data
+ j
,
3497 item_data
[j
+ SBYTES (descrip
)] = 0;
3501 item_data
= SDATA (item_name
);
3503 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3504 menu
, lpane
, 0, item_data
,
3505 !NILP (enable
), help_string
)
3508 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3509 *error
= "Can't add selection to menu";
3512 i
+= MENU_ITEMS_ITEM_LENGTH
;
3517 maxlines
= max (maxlines
, lines
);
3519 /* All set and ready to fly. */
3520 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3521 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3522 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3523 x
= min (x
, dispwidth
);
3524 y
= min (y
, dispheight
);
3527 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3528 &ulx
, &uly
, &width
, &height
);
3529 if (ulx
+width
> dispwidth
)
3531 x
-= (ulx
+ width
) - dispwidth
;
3532 ulx
= dispwidth
- width
;
3534 if (uly
+height
> dispheight
)
3536 y
-= (uly
+ height
) - dispheight
;
3537 uly
= dispheight
- height
;
3539 if (ulx
< 0) x
-= ulx
;
3540 if (uly
< 0) y
-= uly
;
3544 /* If position was not given by a mouse click, adjust so upper left
3545 corner of the menu as a whole ends up at given coordinates. This
3546 is what x-popup-menu says in its documentation. */
3548 y
+= 1.5*height
/(maxlines
+2);
3551 XMenuSetAEQ (menu
, TRUE
);
3552 XMenuSetFreeze (menu
, TRUE
);
3556 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3559 record_unwind_protect (pop_down_menu
,
3560 Fcons (make_save_value (f
, 0),
3561 make_save_value (menu
, 0)));
3563 /* Help display under X won't work because XMenuActivate contains
3564 a loop that doesn't give Emacs a chance to process it. */
3565 menu_help_frame
= f
;
3566 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3567 x
, y
, ButtonReleaseMask
, &datap
,
3568 menu_help_callback
);
3574 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3577 /* Find the item number SELIDX in pane number PANE. */
3579 while (i
< menu_items_used
)
3581 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3585 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3587 i
+= MENU_ITEMS_PANE_LENGTH
;
3596 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3599 entry
= Fcons (entry
, Qnil
);
3600 if (!NILP (pane_prefix
))
3601 entry
= Fcons (pane_prefix
, entry
);
3607 i
+= MENU_ITEMS_ITEM_LENGTH
;
3613 *error
= "Can't activate menu";
3618 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3619 the menu was invoked with a mouse event as POSITION). */
3621 Fsignal (Qquit
, Qnil
);
3626 unbind_to (specpdl_count
, Qnil
);
3631 #endif /* not USE_X_TOOLKIT */
3633 #endif /* HAVE_MENUS */
3638 staticpro (&menu_items
);
3640 menu_items_inuse
= Qnil
;
3642 Qdebug_on_next_call
= intern ("debug-on-next-call");
3643 staticpro (&Qdebug_on_next_call
);
3645 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3646 doc
: /* Frame for which we are updating a menu.
3647 The enable predicate for a menu command should check this variable. */);
3648 Vmenu_updating_frame
= Qnil
;
3650 #ifdef USE_X_TOOLKIT
3651 widget_id_tick
= (1<<16);
3652 next_menubar_widget_id
= 1;
3655 defsubr (&Sx_popup_menu
);
3657 defsubr (&Sx_popup_dialog
);
3661 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3662 (do not change this comment) */