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. */
44 #include "termhooks.h"
49 #include "blockinput.h"
53 #include "sysselect.h"
60 /* This may include sys/types.h, and that somehow loses
61 if this is not done before the other system files. */
65 /* Load sys/types.h if not already loaded.
66 In some systems loading it twice is suicidal. */
68 #include <sys/types.h>
71 #include "dispextern.h"
74 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
75 code accepts the Emacs internal encoding. */
76 #undef HAVE_MULTILINGUAL_MENU
80 #include <X11/IntrinsicP.h>
81 #include <X11/CoreP.h>
82 #include <X11/StringDefs.h>
83 #include <X11/Shell.h>
85 #include <X11/Xaw/Paned.h>
86 #endif /* USE_LUCID */
87 #include "../lwlib/lwlib.h"
88 #else /* not USE_X_TOOLKIT */
90 #include "../oldXMenu/XMenu.h"
92 #endif /* not USE_X_TOOLKIT */
93 #endif /* HAVE_X_WINDOWS */
100 Lisp_Object 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
;
710 XQueryPointer (FRAME_X_DISPLAY (f
),
711 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
713 /* The root window which contains the pointer. */
716 /* Window pointer is on, not used */
719 /* The position on that root window. */
722 /* x/y in dummy_window coordinates, not used. */
725 /* Modifier keys and pointer buttons, about which
727 (unsigned int *) &dummy
);
731 /* xmenu_show expects window coordinates, not root window
732 coordinates. Translate. */
733 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
734 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
737 #endif /* HAVE_X_WINDOWS */
739 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
740 doc
: /* Pop up a deck-of-cards menu and return user's selection.
741 POSITION is a position specification. This is either a mouse button event
742 or a list ((XOFFSET YOFFSET) WINDOW)
743 where XOFFSET and YOFFSET are positions in pixels from the top left
744 corner of WINDOW. (WINDOW may be a window or a frame object.)
745 This controls the position of the top left of the menu as a whole.
746 If POSITION is t, it means to use the current mouse position.
748 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
749 The menu items come from key bindings that have a menu string as well as
750 a definition; actually, the "definition" in such a key binding looks like
751 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
752 the keymap as a top-level element.
754 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
755 Otherwise, REAL-DEFINITION should be a valid key binding definition.
757 You can also use a list of keymaps as MENU.
758 Then each keymap makes a separate pane.
760 When MENU is a keymap or a list of keymaps, the return value is the
761 list of events corresponding to the user's choice. Note that
762 `x-popup-menu' does not actually execute the command bound to that
765 Alternatively, you can specify a menu of multiple panes
766 with a list of the form (TITLE PANE1 PANE2...),
767 where each pane is a list of form (TITLE ITEM1 ITEM2...).
768 Each ITEM is normally a cons cell (STRING . VALUE);
769 but a string can appear as an item--that makes a nonselectable line
771 With this form of menu, the return value is VALUE from the chosen item.
773 If POSITION is nil, don't display the menu at all, just precalculate the
774 cached information about equivalent key sequences.
776 If the user gets rid of the menu without making a valid choice, for
777 instance by clicking the mouse away from a valid choice or by typing
778 keyboard input, then this normally results in a quit and
779 `x-popup-menu' does not return. But if POSITION is a mouse button
780 event (indicating that the user invoked the menu with the mouse) then
781 no quit occurs and `x-popup-menu' returns nil. */)
783 Lisp_Object position
, menu
;
785 Lisp_Object keymap
, tem
;
786 int xpos
= 0, ypos
= 0;
788 char *error_name
= NULL
;
789 Lisp_Object selection
;
791 Lisp_Object x
, y
, window
;
794 int specpdl_count
= SPECPDL_INDEX ();
798 if (! NILP (position
))
800 int get_current_pos_p
= 0;
803 /* Decode the first argument: find the window and the coordinates. */
804 if (EQ (position
, Qt
)
805 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
806 || EQ (XCAR (position
), Qtool_bar
))))
808 get_current_pos_p
= 1;
812 tem
= Fcar (position
);
815 window
= Fcar (Fcdr (position
));
817 y
= Fcar (XCDR (tem
));
822 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
823 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
824 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
829 /* If a click happens in an external tool bar or a detached
830 tool bar, x and y is NIL. In that case, use the current
831 mouse position. This happens for the help button in the
832 tool bar. Ideally popup-menu should pass NIL to
833 this function, but it doesn't. */
834 if (NILP (x
) && NILP (y
))
835 get_current_pos_p
= 1;
838 if (get_current_pos_p
)
840 /* Use the mouse's current position. */
841 FRAME_PTR new_f
= SELECTED_FRAME ();
842 #ifdef HAVE_X_WINDOWS
843 /* Can't use mouse_position_hook for X since it returns
844 coordinates relative to the window the mouse is in,
845 we need coordinates relative to the edit widget always. */
850 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
851 /* cur_x/y may be negative, so use make_number. */
852 x
= make_number (cur_x
);
853 y
= make_number (cur_y
);
856 #else /* not HAVE_X_WINDOWS */
857 Lisp_Object bar_window
;
858 enum scroll_bar_part part
;
861 if (mouse_position_hook
)
862 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
863 &part
, &x
, &y
, &time
);
864 #endif /* not HAVE_X_WINDOWS */
867 XSETFRAME (window
, new_f
);
870 window
= selected_window
;
879 /* Decode where to put the menu. */
887 else if (WINDOWP (window
))
889 CHECK_LIVE_WINDOW (window
);
890 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
892 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
893 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
896 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
897 but I don't want to make one now. */
898 CHECK_WINDOW (window
);
903 XSETFRAME (Vmenu_updating_frame
, f
);
906 Vmenu_updating_frame
= Qnil
;
907 #endif /* HAVE_MENUS */
909 record_unwind_protect (unuse_menu_items
, Qnil
);
913 /* Decode the menu items from what was specified. */
915 keymap
= get_keymap (menu
, 0, 0);
918 /* We were given a keymap. Extract menu info from the keymap. */
921 /* Extract the detailed info to make one pane. */
922 keymap_panes (&menu
, 1, NILP (position
));
924 /* Search for a string appearing directly as an element of the keymap.
925 That string is the title of the menu. */
926 prompt
= Fkeymap_prompt (keymap
);
927 if (NILP (title
) && !NILP (prompt
))
930 /* Make that be the pane title of the first pane. */
931 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
932 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
936 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
938 /* We were given a list of keymaps. */
939 int nmaps
= XFASTINT (Flength (menu
));
941 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
946 /* The first keymap that has a prompt string
947 supplies the menu title. */
948 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
952 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
954 prompt
= Fkeymap_prompt (keymap
);
955 if (NILP (title
) && !NILP (prompt
))
959 /* Extract the detailed info to make one pane. */
960 keymap_panes (maps
, nmaps
, NILP (position
));
962 /* Make the title be the pane title of the first pane. */
963 if (!NILP (title
) && menu_items_n_panes
>= 0)
964 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
970 /* We were given an old-fashioned menu. */
972 CHECK_STRING (title
);
974 list_of_panes (Fcdr (menu
));
979 unbind_to (specpdl_count
, Qnil
);
983 discard_menu_items ();
989 /* Display them in a menu. */
992 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
993 keymaps
, title
, &error_name
);
996 discard_menu_items ();
999 #endif /* HAVE_MENUS */
1001 if (error_name
) error (error_name
);
1007 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
1008 doc
: /* Pop up a dialog box and return user's selection.
1009 POSITION specifies which frame to use.
1010 This is normally a mouse button event or a window or frame.
1011 If POSITION is t, it means to use the frame the mouse is on.
1012 The dialog box appears in the middle of the specified frame.
1014 CONTENTS specifies the alternatives to display in the dialog box.
1015 It is a list of the form (DIALOG ITEM1 ITEM2...).
1016 Each ITEM is a cons cell (STRING . VALUE).
1017 The return value is VALUE from the chosen item.
1019 An ITEM may also be just a string--that makes a nonselectable item.
1020 An ITEM may also be nil--that means to put all preceding items
1021 on the left of the dialog box and all following items on the right.
1022 \(By default, approximately half appear on each side.)
1024 If HEADER is non-nil, the frame title for the box is "Information",
1025 otherwise it is "Question".
1027 If the user gets rid of the dialog box without making a valid choice,
1028 for instance using the window manager, then this produces a quit and
1029 `x-popup-dialog' does not return. */)
1030 (position
, contents
, header
)
1031 Lisp_Object position
, contents
, header
;
1038 /* Decode the first argument: find the window or frame to use. */
1039 if (EQ (position
, Qt
)
1040 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1041 || EQ (XCAR (position
), Qtool_bar
))))
1043 #if 0 /* Using the frame the mouse is on may not be right. */
1044 /* Use the mouse's current position. */
1045 FRAME_PTR new_f
= SELECTED_FRAME ();
1046 Lisp_Object bar_window
;
1047 enum scroll_bar_part part
;
1051 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1054 XSETFRAME (window
, new_f
);
1056 window
= selected_window
;
1058 window
= selected_window
;
1060 else if (CONSP (position
))
1063 tem
= Fcar (position
);
1065 window
= Fcar (Fcdr (position
));
1068 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1069 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1072 else if (WINDOWP (position
) || FRAMEP (position
))
1077 /* Decode where to put the menu. */
1079 if (FRAMEP (window
))
1080 f
= XFRAME (window
);
1081 else if (WINDOWP (window
))
1083 CHECK_LIVE_WINDOW (window
);
1084 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1087 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1088 but I don't want to make one now. */
1089 CHECK_WINDOW (window
);
1091 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1092 /* Display a menu with these alternatives
1093 in the middle of frame F. */
1095 Lisp_Object x
, y
, frame
, newpos
;
1096 XSETFRAME (frame
, f
);
1097 XSETINT (x
, x_pixel_width (f
) / 2);
1098 XSETINT (y
, x_pixel_height (f
) / 2);
1099 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1101 return Fx_popup_menu (newpos
,
1102 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1108 Lisp_Object selection
;
1109 int specpdl_count
= SPECPDL_INDEX ();
1111 /* Decode the dialog items from what was specified. */
1112 title
= Fcar (contents
);
1113 CHECK_STRING (title
);
1114 record_unwind_protect (unuse_menu_items
, Qnil
);
1116 if (NILP (Fcar (Fcdr (contents
))))
1117 /* No buttons specified, add an "Ok" button so users can pop down
1118 the dialog. Also, the lesstif/motif version crashes if there are
1120 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1122 list_of_panes (Fcons (contents
, Qnil
));
1124 /* Display them in a dialog box. */
1126 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
1129 unbind_to (specpdl_count
, Qnil
);
1130 discard_menu_items ();
1132 if (error_name
) error (error_name
);
1141 /* Set menu_items_inuse so no other popup menu or dialog is created. */
1144 x_menu_set_in_use (in_use
)
1147 menu_items_inuse
= in_use
? Qt
: Qnil
;
1148 popup_activated_flag
= in_use
;
1151 /* Wait for an X event to arrive or for a timer to expire. */
1154 x_menu_wait_for_event (void *data
)
1156 extern EMACS_TIME timer_check
P_ ((int));
1158 /* Another way to do this is to register a timer callback, that can be
1159 done in GTK and Xt. But we have to do it like this when using only X
1160 anyway, and with callbacks we would have three variants for timer handling
1161 instead of the small ifdefs below. */
1164 #ifdef USE_X_TOOLKIT
1165 ! XtAppPending (Xt_app_con
)
1166 #elif defined USE_GTK
1167 ! gtk_events_pending ()
1169 ! XPending ((Display
*) data
)
1173 EMACS_TIME next_time
= timer_check (1);
1174 long secs
= EMACS_SECS (next_time
);
1175 long usecs
= EMACS_USECS (next_time
);
1176 SELECT_TYPE read_fds
;
1177 struct x_display_info
*dpyinfo
;
1180 FD_ZERO (&read_fds
);
1181 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1183 int fd
= ConnectionNumber (dpyinfo
->display
);
1184 FD_SET (fd
, &read_fds
);
1188 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1190 /* Sometimes timer_check returns -1 (no timers) even if there are
1191 timers. So do a timeout anyway. */
1192 EMACS_SET_SECS (next_time
, 1);
1193 EMACS_SET_USECS (next_time
, 0);
1196 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1199 #endif /* ! MSDOS */
1202 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1204 #ifdef USE_X_TOOLKIT
1206 /* Loop in Xt until the menu pulldown or dialog popup has been
1207 popped down (deactivated). This is used for x-popup-menu
1208 and x-popup-dialog; it is not used for the menu bar.
1210 NOTE: All calls to popup_get_selection should be protected
1211 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1214 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1215 XEvent
*initial_event
;
1216 struct x_display_info
*dpyinfo
;
1222 while (popup_activated_flag
)
1226 event
= *initial_event
;
1231 if (do_timers
) x_menu_wait_for_event (0);
1232 XtAppNextEvent (Xt_app_con
, &event
);
1235 /* Make sure we don't consider buttons grabbed after menu goes.
1236 And make sure to deactivate for any ButtonRelease,
1237 even if XtDispatchEvent doesn't do that. */
1238 if (event
.type
== ButtonRelease
1239 && dpyinfo
->display
== event
.xbutton
.display
)
1241 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1242 #ifdef USE_MOTIF /* Pretending that the event came from a
1243 Btn1Down seems the only way to convince Motif to
1244 activate its callbacks; setting the XmNmenuPost
1245 isn't working. --marcus@sysc.pdx.edu. */
1246 event
.xbutton
.button
= 1;
1247 /* Motif only pops down menus when no Ctrl, Alt or Mod
1248 key is pressed and the button is released. So reset key state
1249 so Motif thinks this is the case. */
1250 event
.xbutton
.state
= 0;
1253 /* Pop down on C-g and Escape. */
1254 else if (event
.type
== KeyPress
1255 && dpyinfo
->display
== event
.xbutton
.display
)
1257 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1259 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
1260 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
1261 popup_activated_flag
= 0;
1264 x_dispatch_event (&event
, event
.xany
.display
);
1268 #endif /* USE_X_TOOLKIT */
1271 /* Loop util popup_activated_flag is set to zero in a callback.
1272 Used for popup menus and dialogs. */
1275 popup_widget_loop (do_timers
, widget
)
1279 ++popup_activated_flag
;
1281 /* Process events in the Gtk event loop until done. */
1282 while (popup_activated_flag
)
1284 if (do_timers
) x_menu_wait_for_event (0);
1285 gtk_main_iteration ();
1290 /* Activate the menu bar of frame F.
1291 This is called from keyboard.c when it gets the
1292 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1294 To activate the menu bar, we use the X button-press event
1295 that was saved in saved_menu_event.
1296 That makes the toolkit do its thing.
1298 But first we recompute the menu bar contents (the whole tree).
1300 The reason for saving the button event until here, instead of
1301 passing it to the toolkit right away, is that we can safely
1302 execute Lisp code. */
1305 x_activate_menubar (f
)
1308 if (!f
->output_data
.x
->saved_menu_event
->type
)
1312 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1313 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1317 set_frame_menubar (f
, 0, 1);
1320 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1321 f
->output_data
.x
->saved_menu_event
);
1322 popup_activated_flag
= 1;
1324 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1328 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1329 pending_menu_activation
= 1;
1332 /* Ignore this if we get it a second time. */
1333 f
->output_data
.x
->saved_menu_event
->type
= 0;
1336 /* Detect if a dialog or menu has been posted. */
1341 return popup_activated_flag
;
1344 /* This callback is invoked when the user selects a menubar cascade
1345 pushbutton, but before the pulldown menu is posted. */
1349 popup_activate_callback (widget
, id
, client_data
)
1352 XtPointer client_data
;
1354 popup_activated_flag
= 1;
1358 /* This callback is invoked when a dialog or menu is finished being
1359 used and has been unposted. */
1363 popup_deactivate_callback (widget
, client_data
)
1365 gpointer client_data
;
1367 popup_activated_flag
= 0;
1371 popup_deactivate_callback (widget
, id
, client_data
)
1374 XtPointer client_data
;
1376 popup_activated_flag
= 0;
1381 /* Function that finds the frame for WIDGET and shows the HELP text
1383 F is the frame if known, or NULL if not known. */
1385 show_help_event (f
, widget
, help
)
1387 xt_or_gtk_widget widget
;
1394 XSETFRAME (frame
, f
);
1395 kbd_buffer_store_help_event (frame
, help
);
1399 #if 0 /* This code doesn't do anything useful. ++kfs */
1400 /* WIDGET is the popup menu. It's parent is the frame's
1401 widget. See which frame that is. */
1402 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1405 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1407 frame
= XCAR (tail
);
1408 if (GC_FRAMEP (frame
)
1409 && (f
= XFRAME (frame
),
1410 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1414 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1418 /* Callback called when menu items are highlighted/unhighlighted
1419 while moving the mouse over them. WIDGET is the menu bar or menu
1420 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1421 the data structure for the menu item, or null in case of
1426 menu_highlight_callback (widget
, call_data
)
1430 xg_menu_item_cb_data
*cb_data
;
1433 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1435 if (! cb_data
) return;
1437 help
= call_data
? cb_data
->help
: Qnil
;
1439 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1440 Don't show help for them, they won't appear before the
1441 popup is popped down. */
1442 if (popup_activated_flag
<= 1)
1443 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1447 menu_highlight_callback (widget
, id
, call_data
)
1455 widget_value
*wv
= (widget_value
*) call_data
;
1457 help
= wv
? wv
->help
: Qnil
;
1459 /* Determine the frame for the help event. */
1460 f
= menubar_id_to_frame (id
);
1462 show_help_event (f
, widget
, help
);
1466 /* Find the menu selection and store it in the keyboard buffer.
1467 F is the frame the menu is on.
1468 MENU_BAR_ITEMS_USED is the length of VECTOR.
1469 VECTOR is an array of menu events for the whole menu. */
1472 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1474 int menu_bar_items_used
;
1478 Lisp_Object prefix
, entry
;
1479 Lisp_Object
*subprefix_stack
;
1480 int submenu_depth
= 0;
1484 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1488 while (i
< menu_bar_items_used
)
1490 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1492 subprefix_stack
[submenu_depth
++] = prefix
;
1496 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1498 prefix
= subprefix_stack
[--submenu_depth
];
1501 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1503 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1504 i
+= MENU_ITEMS_PANE_LENGTH
;
1508 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1509 /* The EMACS_INT cast avoids a warning. There's no problem
1510 as long as pointers have enough bits to hold small integers. */
1511 if ((int) (EMACS_INT
) client_data
== i
)
1514 struct input_event buf
;
1518 XSETFRAME (frame
, f
);
1519 buf
.kind
= MENU_BAR_EVENT
;
1520 buf
.frame_or_window
= frame
;
1522 kbd_buffer_store_event (&buf
);
1524 for (j
= 0; j
< submenu_depth
; j
++)
1525 if (!NILP (subprefix_stack
[j
]))
1527 buf
.kind
= MENU_BAR_EVENT
;
1528 buf
.frame_or_window
= frame
;
1529 buf
.arg
= subprefix_stack
[j
];
1530 kbd_buffer_store_event (&buf
);
1535 buf
.kind
= MENU_BAR_EVENT
;
1536 buf
.frame_or_window
= frame
;
1538 kbd_buffer_store_event (&buf
);
1541 buf
.kind
= MENU_BAR_EVENT
;
1542 buf
.frame_or_window
= frame
;
1544 kbd_buffer_store_event (&buf
);
1548 i
+= MENU_ITEMS_ITEM_LENGTH
;
1555 /* Gtk calls callbacks just because we tell it what item should be
1556 selected in a radio group. If this variable is set to a non-zero
1557 value, we are creating menus and don't want callbacks right now.
1559 static int xg_crazy_callback_abort
;
1561 /* This callback is called from the menu bar pulldown menu
1562 when the user makes a selection.
1563 Figure out what the user chose
1564 and put the appropriate events into the keyboard buffer. */
1566 menubar_selection_callback (widget
, client_data
)
1568 gpointer client_data
;
1570 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1572 if (xg_crazy_callback_abort
)
1575 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1578 /* For a group of radio buttons, GTK calls the selection callback first
1579 for the item that was active before the selection and then for the one that
1580 is active after the selection. For C-h k this means we get the help on
1581 the deselected item and then the selected item is executed. Prevent that
1582 by ignoring the non-active item. */
1583 if (GTK_IS_RADIO_MENU_ITEM (widget
)
1584 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
1587 /* When a menu is popped down, X generates a focus event (i.e. focus
1588 goes back to the frame below the menu). Since GTK buffers events,
1589 we force it out here before the menu selection event. Otherwise
1590 sit-for will exit at once if the focus event follows the menu selection
1594 while (gtk_events_pending ())
1595 gtk_main_iteration ();
1598 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1599 cb_data
->cl_data
->menu_bar_items_used
,
1600 cb_data
->cl_data
->menu_bar_vector
,
1601 cb_data
->call_data
);
1604 #else /* not USE_GTK */
1606 /* This callback is called from the menu bar pulldown menu
1607 when the user makes a selection.
1608 Figure out what the user chose
1609 and put the appropriate events into the keyboard buffer. */
1611 menubar_selection_callback (widget
, id
, client_data
)
1614 XtPointer client_data
;
1618 f
= menubar_id_to_frame (id
);
1621 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1622 f
->menu_bar_vector
, client_data
);
1624 #endif /* not USE_GTK */
1626 /* Allocate a widget_value, blocking input. */
1629 xmalloc_widget_value ()
1631 widget_value
*value
;
1634 value
= malloc_widget_value ();
1640 /* This recursively calls free_widget_value on the tree of widgets.
1641 It must free all data that was malloc'ed for these widget_values.
1642 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1643 must be left alone. */
1646 free_menubar_widget_value_tree (wv
)
1651 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1653 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1655 free_menubar_widget_value_tree (wv
->contents
);
1656 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1660 free_menubar_widget_value_tree (wv
->next
);
1661 wv
->next
= (widget_value
*) 0xDEADBEEF;
1664 free_widget_value (wv
);
1668 /* Set up data in menu_items for a menu bar item
1669 whose event type is ITEM_KEY (with string ITEM_NAME)
1670 and whose contents come from the list of keymaps MAPS. */
1673 parse_single_submenu (item_key
, item_name
, maps
)
1674 Lisp_Object item_key
, item_name
, maps
;
1678 Lisp_Object
*mapvec
;
1680 int top_level_items
= 0;
1682 length
= Flength (maps
);
1683 len
= XINT (length
);
1685 /* Convert the list MAPS into a vector MAPVEC. */
1686 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1687 for (i
= 0; i
< len
; i
++)
1689 mapvec
[i
] = Fcar (maps
);
1693 /* Loop over the given keymaps, making a pane for each map.
1694 But don't make a pane that is empty--ignore that map instead. */
1695 for (i
= 0; i
< len
; i
++)
1697 if (!KEYMAPP (mapvec
[i
]))
1699 /* Here we have a command at top level in the menu bar
1700 as opposed to a submenu. */
1701 top_level_items
= 1;
1702 push_menu_pane (Qnil
, Qnil
);
1703 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1704 Qnil
, Qnil
, Qnil
, Qnil
);
1709 prompt
= Fkeymap_prompt (mapvec
[i
]);
1710 single_keymap_panes (mapvec
[i
],
1711 !NILP (prompt
) ? prompt
: item_name
,
1716 return top_level_items
;
1719 /* Create a tree of widget_value objects
1720 representing the panes and items
1721 in menu_items starting at index START, up to index END. */
1723 static widget_value
*
1724 digest_single_submenu (start
, end
, top_level_items
)
1725 int start
, end
, top_level_items
;
1727 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1729 int submenu_depth
= 0;
1730 widget_value
**submenu_stack
;
1733 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1734 wv
= xmalloc_widget_value ();
1738 wv
->button_type
= BUTTON_TYPE_NONE
;
1744 /* Loop over all panes and items made by the preceding call
1745 to parse_single_submenu and construct a tree of widget_value objects.
1746 Ignore the panes and items used by previous calls to
1747 digest_single_submenu, even though those are also in menu_items. */
1751 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1753 submenu_stack
[submenu_depth
++] = save_wv
;
1758 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1761 save_wv
= submenu_stack
[--submenu_depth
];
1764 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1765 && submenu_depth
!= 0)
1766 i
+= MENU_ITEMS_PANE_LENGTH
;
1767 /* Ignore a nil in the item list.
1768 It's meaningful only for dialog boxes. */
1769 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1771 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1773 /* Create a new pane. */
1774 Lisp_Object pane_name
, prefix
;
1777 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1778 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1780 #ifndef HAVE_MULTILINGUAL_MENU
1781 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1783 pane_name
= ENCODE_MENU_STRING (pane_name
);
1784 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1787 pane_string
= (NILP (pane_name
)
1788 ? "" : (char *) SDATA (pane_name
));
1789 /* If there is just one top-level pane, put all its items directly
1790 under the top-level menu. */
1791 if (menu_items_n_panes
== 1)
1794 /* If the pane has a meaningful name,
1795 make the pane a top-level menu item
1796 with its items as a submenu beneath it. */
1797 if (strcmp (pane_string
, ""))
1799 wv
= xmalloc_widget_value ();
1803 first_wv
->contents
= wv
;
1804 wv
->lname
= pane_name
;
1805 /* Set value to 1 so update_submenu_strings can handle '@' */
1806 wv
->value
= (char *)1;
1808 wv
->button_type
= BUTTON_TYPE_NONE
;
1816 i
+= MENU_ITEMS_PANE_LENGTH
;
1820 /* Create a new item within current pane. */
1821 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1824 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1825 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1826 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1827 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1828 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1829 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1830 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1832 #ifndef HAVE_MULTILINGUAL_MENU
1833 if (STRING_MULTIBYTE (item_name
))
1835 item_name
= ENCODE_MENU_STRING (item_name
);
1836 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1839 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1841 descrip
= ENCODE_MENU_STRING (descrip
);
1842 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1844 #endif /* not HAVE_MULTILINGUAL_MENU */
1846 wv
= xmalloc_widget_value ();
1850 save_wv
->contents
= wv
;
1852 wv
->lname
= item_name
;
1853 if (!NILP (descrip
))
1856 /* The EMACS_INT cast avoids a warning. There's no problem
1857 as long as pointers have enough bits to hold small integers. */
1858 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1859 wv
->enabled
= !NILP (enable
);
1862 wv
->button_type
= BUTTON_TYPE_NONE
;
1863 else if (EQ (type
, QCradio
))
1864 wv
->button_type
= BUTTON_TYPE_RADIO
;
1865 else if (EQ (type
, QCtoggle
))
1866 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1870 wv
->selected
= !NILP (selected
);
1871 if (! STRINGP (help
))
1878 i
+= MENU_ITEMS_ITEM_LENGTH
;
1882 /* If we have just one "menu item"
1883 that was originally a button, return it by itself. */
1884 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1886 wv
= first_wv
->contents
;
1887 free_widget_value (first_wv
);
1894 /* Walk through the widget_value tree starting at FIRST_WV and update
1895 the char * pointers from the corresponding lisp values.
1896 We do this after building the whole tree, since GC may happen while the
1897 tree is constructed, and small strings are relocated. So we must wait
1898 until no GC can happen before storing pointers into lisp values. */
1900 update_submenu_strings (first_wv
)
1901 widget_value
*first_wv
;
1905 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1907 if (STRINGP (wv
->lname
))
1909 wv
->name
= (char *) SDATA (wv
->lname
);
1911 /* Ignore the @ that means "separate pane".
1912 This is a kludge, but this isn't worth more time. */
1913 if (wv
->value
== (char *)1)
1915 if (wv
->name
[0] == '@')
1921 if (STRINGP (wv
->lkey
))
1922 wv
->key
= (char *) SDATA (wv
->lkey
);
1925 update_submenu_strings (wv
->contents
);
1930 /* Recompute all the widgets of frame F, when the menu bar has been
1931 changed. Value is non-zero if widgets were updated. */
1934 update_frame_menubar (f
)
1938 return xg_update_frame_menubar (f
);
1940 struct x_output
*x
= f
->output_data
.x
;
1943 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1947 /* Save the size of the frame because the pane widget doesn't accept
1948 to resize itself. So force it. */
1949 columns
= FRAME_COLS (f
);
1950 rows
= FRAME_LINES (f
);
1952 /* Do the voodoo which means "I'm changing lots of things, don't try
1953 to refigure sizes until I'm done." */
1954 lw_refigure_widget (x
->column_widget
, False
);
1956 /* The order in which children are managed is the top to bottom
1957 order in which they are displayed in the paned window. First,
1958 remove the text-area widget. */
1959 XtUnmanageChild (x
->edit_widget
);
1961 /* Remove the menubar that is there now, and put up the menubar that
1963 XtManageChild (x
->menubar_widget
);
1964 XtMapWidget (x
->menubar_widget
);
1965 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1967 /* Re-manage the text-area widget, and then thrash the sizes. */
1968 XtManageChild (x
->edit_widget
);
1969 lw_refigure_widget (x
->column_widget
, True
);
1971 /* Force the pane widget to resize itself with the right values. */
1972 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1978 /* Set the contents of the menubar widgets of frame F.
1979 The argument FIRST_TIME is currently ignored;
1980 it is set the first time this is called, from initialize_frame_menubar. */
1983 set_frame_menubar (f
, first_time
, deep_p
)
1988 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1989 #ifdef USE_X_TOOLKIT
1993 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1995 int *submenu_start
, *submenu_end
;
1996 int *submenu_top_level_items
, *submenu_n_panes
;
1999 XSETFRAME (Vmenu_updating_frame
, f
);
2001 #ifdef USE_X_TOOLKIT
2002 if (f
->output_data
.x
->id
== 0)
2003 f
->output_data
.x
->id
= next_menubar_widget_id
++;
2004 id
= f
->output_data
.x
->id
;
2007 if (! menubar_widget
)
2009 else if (pending_menu_activation
&& !deep_p
)
2011 /* Make the first call for any given frame always go deep. */
2012 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
2015 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
2016 f
->output_data
.x
->saved_menu_event
->type
= 0;
2020 /* If we have detached menus, we must update deep so detached menus
2021 also gets updated. */
2022 deep_p
= deep_p
|| xg_have_tear_offs ();
2027 /* Make a widget-value tree representing the entire menu trees. */
2029 struct buffer
*prev
= current_buffer
;
2031 int specpdl_count
= SPECPDL_INDEX ();
2032 int previous_menu_items_used
= f
->menu_bar_items_used
;
2033 Lisp_Object
*previous_items
2034 = (Lisp_Object
*) alloca (previous_menu_items_used
2035 * sizeof (Lisp_Object
));
2037 /* If we are making a new widget, its contents are empty,
2038 do always reinitialize them. */
2039 if (! menubar_widget
)
2040 previous_menu_items_used
= 0;
2042 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
2043 specbind (Qinhibit_quit
, Qt
);
2044 /* Don't let the debugger step into this code
2045 because it is not reentrant. */
2046 specbind (Qdebug_on_next_call
, Qnil
);
2048 record_unwind_save_match_data ();
2049 record_unwind_protect (unuse_menu_items
, Qnil
);
2050 if (NILP (Voverriding_local_map_menu_flag
))
2052 specbind (Qoverriding_terminal_local_map
, Qnil
);
2053 specbind (Qoverriding_local_map
, Qnil
);
2056 set_buffer_internal_1 (XBUFFER (buffer
));
2058 /* Run the Lucid hook. */
2059 safe_run_hooks (Qactivate_menubar_hook
);
2061 /* If it has changed current-menubar from previous value,
2062 really recompute the menubar from the value. */
2063 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2064 call0 (Qrecompute_lucid_menubar
);
2065 safe_run_hooks (Qmenu_bar_update_hook
);
2066 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2068 items
= FRAME_MENU_BAR_ITEMS (f
);
2070 /* Save the frame's previous menu bar contents data. */
2071 if (previous_menu_items_used
)
2072 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2073 previous_menu_items_used
* sizeof (Lisp_Object
));
2075 /* Fill in menu_items with the current menu bar contents.
2076 This can evaluate Lisp code. */
2077 menu_items
= f
->menu_bar_vector
;
2078 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2079 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2080 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2081 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2082 submenu_top_level_items
2083 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2085 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2087 Lisp_Object key
, string
, maps
;
2091 key
= XVECTOR (items
)->contents
[i
];
2092 string
= XVECTOR (items
)->contents
[i
+ 1];
2093 maps
= XVECTOR (items
)->contents
[i
+ 2];
2097 submenu_start
[i
] = menu_items_used
;
2099 menu_items_n_panes
= 0;
2100 submenu_top_level_items
[i
]
2101 = parse_single_submenu (key
, string
, maps
);
2102 submenu_n_panes
[i
] = menu_items_n_panes
;
2104 submenu_end
[i
] = menu_items_used
;
2107 finish_menu_items ();
2109 /* Convert menu_items into widget_value trees
2110 to display the menu. This cannot evaluate Lisp code. */
2112 wv
= xmalloc_widget_value ();
2113 wv
->name
= "menubar";
2116 wv
->button_type
= BUTTON_TYPE_NONE
;
2120 for (i
= 0; i
< last_i
; i
+= 4)
2122 menu_items_n_panes
= submenu_n_panes
[i
];
2123 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2124 submenu_top_level_items
[i
]);
2128 first_wv
->contents
= wv
;
2129 /* Don't set wv->name here; GC during the loop might relocate it. */
2131 wv
->button_type
= BUTTON_TYPE_NONE
;
2135 set_buffer_internal_1 (prev
);
2136 unbind_to (specpdl_count
, Qnil
);
2138 /* If there has been no change in the Lisp-level contents
2139 of the menu bar, skip redisplaying it. Just exit. */
2141 for (i
= 0; i
< previous_menu_items_used
; i
++)
2142 if (menu_items_used
== i
2143 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2145 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2147 free_menubar_widget_value_tree (first_wv
);
2148 discard_menu_items ();
2153 /* Now GC cannot happen during the lifetime of the widget_value,
2154 so it's safe to store data from a Lisp_String. */
2155 wv
= first_wv
->contents
;
2156 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2159 string
= XVECTOR (items
)->contents
[i
+ 1];
2162 wv
->name
= (char *) SDATA (string
);
2163 update_submenu_strings (wv
->contents
);
2167 f
->menu_bar_vector
= menu_items
;
2168 f
->menu_bar_items_used
= menu_items_used
;
2169 discard_menu_items ();
2173 /* Make a widget-value tree containing
2174 just the top level menu bar strings. */
2176 wv
= xmalloc_widget_value ();
2177 wv
->name
= "menubar";
2180 wv
->button_type
= BUTTON_TYPE_NONE
;
2184 items
= FRAME_MENU_BAR_ITEMS (f
);
2185 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2189 string
= XVECTOR (items
)->contents
[i
+ 1];
2193 wv
= xmalloc_widget_value ();
2194 wv
->name
= (char *) SDATA (string
);
2197 wv
->button_type
= BUTTON_TYPE_NONE
;
2199 /* This prevents lwlib from assuming this
2200 menu item is really supposed to be empty. */
2201 /* The EMACS_INT cast avoids a warning.
2202 This value just has to be different from small integers. */
2203 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2208 first_wv
->contents
= wv
;
2212 /* Forget what we thought we knew about what is in the
2213 detailed contents of the menu bar menus.
2214 Changing the top level always destroys the contents. */
2215 f
->menu_bar_items_used
= 0;
2218 /* Create or update the menu bar widget. */
2223 xg_crazy_callback_abort
= 1;
2226 /* The fourth arg is DEEP_P, which says to consider the entire
2227 menu trees we supply, rather than just the menu bar item names. */
2228 xg_modify_menubar_widgets (menubar_widget
,
2232 G_CALLBACK (menubar_selection_callback
),
2233 G_CALLBACK (popup_deactivate_callback
),
2234 G_CALLBACK (menu_highlight_callback
));
2238 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2241 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2242 G_CALLBACK (menubar_selection_callback
),
2243 G_CALLBACK (popup_deactivate_callback
),
2244 G_CALLBACK (menu_highlight_callback
));
2246 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2250 #else /* not USE_GTK */
2253 /* Disable resizing (done for Motif!) */
2254 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2256 /* The third arg is DEEP_P, which says to consider the entire
2257 menu trees we supply, rather than just the menu bar item names. */
2258 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2260 /* Re-enable the edit widget to resize. */
2261 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2265 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
2266 XtTranslations override
= XtParseTranslationTable (menuOverride
);
2268 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2269 f
->output_data
.x
->column_widget
,
2271 popup_activate_callback
,
2272 menubar_selection_callback
,
2273 popup_deactivate_callback
,
2274 menu_highlight_callback
);
2275 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2277 /* Make menu pop down on C-g. */
2278 XtOverrideTranslations (menubar_widget
, override
);
2283 = (f
->output_data
.x
->menubar_widget
2284 ? (f
->output_data
.x
->menubar_widget
->core
.height
2285 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2288 #if 0 /* Experimentally, we now get the right results
2289 for -geometry -0-0 without this. 24 Aug 96, rms. */
2291 if (FRAME_EXTERNAL_MENU_BAR (f
))
2294 XtVaGetValues (f
->output_data
.x
->column_widget
,
2295 XtNinternalBorderWidth
, &ibw
, NULL
);
2296 menubar_size
+= ibw
;
2298 #endif /* USE_LUCID */
2301 f
->output_data
.x
->menubar_height
= menubar_size
;
2303 #endif /* not USE_GTK */
2305 free_menubar_widget_value_tree (first_wv
);
2306 update_frame_menubar (f
);
2309 xg_crazy_callback_abort
= 0;
2315 /* Called from Fx_create_frame to create the initial menubar of a frame
2316 before it is mapped, so that the window is mapped with the menubar already
2317 there instead of us tacking it on later and thrashing the window after it
2321 initialize_frame_menubar (f
)
2324 /* This function is called before the first chance to redisplay
2325 the frame. It has to be, so the frame will have the right size. */
2326 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2327 set_frame_menubar (f
, 1, 1);
2331 /* Get rid of the menu bar of frame F, and free its storage.
2332 This is used when deleting a frame, and when turning off the menu bar.
2333 For GTK this function is in gtkutil.c. */
2337 free_frame_menubar (f
)
2340 Widget menubar_widget
;
2342 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2344 f
->output_data
.x
->menubar_height
= 0;
2349 /* Removing the menu bar magically changes the shell widget's x
2350 and y position of (0, 0) which, when the menu bar is turned
2351 on again, leads to pull-down menuss appearing in strange
2352 positions near the upper-left corner of the display. This
2353 happens only with some window managers like twm and ctwm,
2354 but not with other like Motif's mwm or kwm, because the
2355 latter generate ConfigureNotify events when the menu bar
2356 is switched off, which fixes the shell position. */
2357 Position x0
, y0
, x1
, y1
;
2363 if (f
->output_data
.x
->widget
)
2364 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2367 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2368 f
->output_data
.x
->menubar_widget
= NULL
;
2371 if (f
->output_data
.x
->widget
)
2373 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2374 if (x1
== 0 && y1
== 0)
2375 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2382 #endif /* not USE_GTK */
2384 #endif /* USE_X_TOOLKIT || USE_GTK */
2386 /* xmenu_show actually displays a menu using the panes and items in menu_items
2387 and returns the value selected from it.
2388 There are two versions of xmenu_show, one for Xt and one for Xlib.
2389 Both assume input is blocked by the caller. */
2391 /* F is the frame the menu is for.
2392 X and Y are the frame-relative specified position,
2393 relative to the inside upper left corner of the frame F.
2394 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2395 KEYMAPS is 1 if this menu was specified with keymaps;
2396 in that case, we return a list containing the chosen item's value
2397 and perhaps also the pane's prefix.
2398 TITLE is the specified menu title.
2399 ERROR is a place to store an error message string in case of failure.
2400 (We return nil on failure, but the value doesn't actually matter.) */
2402 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2404 /* The item selected in the popup menu. */
2405 static Lisp_Object
*volatile menu_item_selection
;
2409 /* Used when position a popup menu. See menu_position_func and
2410 create_and_show_popup_menu below. */
2411 struct next_popup_x_y
2418 /* The menu position function to use if we are not putting a popup
2419 menu where the pointer is.
2420 MENU is the menu to pop up.
2421 X and Y shall on exit contain x/y where the menu shall pop up.
2422 PUSH_IN is not documented in the GTK manual.
2423 USER_DATA is any data passed in when calling gtk_menu_popup.
2424 Here it points to a struct next_popup_x_y where the coordinates
2425 to store in *X and *Y are as well as the frame for the popup.
2427 Here only X and Y are used. */
2429 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2436 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2438 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2439 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2444 /* Check if there is room for the menu. If not, adjust x/y so that
2445 the menu is fully visible. */
2446 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2447 if (data
->x
+ req
.width
> disp_width
)
2448 *x
-= data
->x
+ req
.width
- disp_width
;
2449 if (data
->y
+ req
.height
> disp_height
)
2450 *y
-= data
->y
+ req
.height
- disp_height
;
2454 popup_selection_callback (widget
, client_data
)
2456 gpointer client_data
;
2458 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2460 if (xg_crazy_callback_abort
) return;
2461 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2468 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
2470 popup_activated_flag
= 0;
2472 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
2477 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2479 menu_item_selection will be set to the selection. */
2481 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2483 widget_value
*first_wv
;
2490 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2491 struct next_popup_x_y popup_x_y
;
2492 int specpdl_count
= SPECPDL_INDEX ();
2494 xg_crazy_callback_abort
= 1;
2495 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2496 G_CALLBACK (popup_selection_callback
),
2497 G_CALLBACK (popup_deactivate_callback
),
2498 G_CALLBACK (menu_highlight_callback
));
2499 xg_crazy_callback_abort
= 0;
2503 /* Not invoked by a click. pop up at x/y. */
2504 pos_func
= menu_position_func
;
2506 /* Adjust coordinates to be root-window-relative. */
2507 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2508 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2514 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
2518 for (i
= 0; i
< 5; i
++)
2519 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2523 /* Display the menu. */
2524 gtk_widget_show_all (menu
);
2525 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2527 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2529 if (GTK_WIDGET_MAPPED (menu
))
2531 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2532 two. show_help_echo uses this to detect popup menus. */
2533 popup_activated_flag
= 1;
2534 /* Process events that apply to the menu. */
2535 popup_widget_loop (1, menu
);
2538 unbind_to (specpdl_count
, Qnil
);
2540 /* Must reset this manually because the button release event is not passed
2541 to Emacs event loop. */
2542 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2545 #else /* not USE_GTK */
2547 /* We need a unique id for each widget handled by the Lucid Widget
2550 For the main windows, and popup menus, we use this counter,
2551 which we increment each time after use. This starts from 1<<16.
2553 For menu bars, we use numbers starting at 0, counted in
2554 next_menubar_widget_id. */
2555 LWLIB_ID widget_id_tick
;
2558 popup_selection_callback (widget
, id
, client_data
)
2561 XtPointer client_data
;
2563 menu_item_selection
= (Lisp_Object
*) client_data
;
2566 /* ARG is the LWLIB ID of the dialog box, represented
2567 as a Lisp object as (HIGHPART . LOWPART). */
2573 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2574 | XINT (XCDR (arg
)));
2577 lw_destroy_all_widgets (id
);
2579 popup_activated_flag
= 0;
2584 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2586 menu_item_selection will be set to the selection. */
2588 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2590 widget_value
*first_wv
;
2598 XButtonPressedEvent dummy
;
2602 menu_id
= widget_id_tick
++;
2603 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2604 f
->output_data
.x
->widget
, 1, 0,
2605 popup_selection_callback
,
2606 popup_deactivate_callback
,
2607 menu_highlight_callback
);
2609 dummy
.type
= ButtonPress
;
2611 dummy
.send_event
= 0;
2612 dummy
.display
= FRAME_X_DISPLAY (f
);
2613 dummy
.time
= CurrentTime
;
2614 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2615 dummy
.window
= dummy
.root
;
2616 dummy
.subwindow
= dummy
.root
;
2620 /* Adjust coordinates to be root-window-relative. */
2621 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2622 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2629 for (i
= 0; i
< 5; i
++)
2630 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2633 /* Don't allow any geometry request from the user. */
2634 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2635 XtSetValues (menu
, av
, ac
);
2637 /* Display the menu. */
2638 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2639 popup_activated_flag
= 1;
2642 int fact
= 4 * sizeof (LWLIB_ID
);
2643 int specpdl_count
= SPECPDL_INDEX ();
2644 record_unwind_protect (pop_down_menu
,
2645 Fcons (make_number (menu_id
>> (fact
)),
2646 make_number (menu_id
& ~(-1 << (fact
)))));
2648 /* Process events that apply to the menu. */
2649 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
2651 unbind_to (specpdl_count
, Qnil
);
2655 #endif /* not USE_GTK */
2658 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2668 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2669 widget_value
**submenu_stack
2670 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2671 Lisp_Object
*subprefix_stack
2672 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2673 int submenu_depth
= 0;
2679 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2681 *error
= "Empty menu";
2685 /* Create a tree of widget_value objects
2686 representing the panes and their items. */
2687 wv
= xmalloc_widget_value ();
2691 wv
->button_type
= BUTTON_TYPE_NONE
;
2696 /* Loop over all panes and items, filling in the tree. */
2698 while (i
< menu_items_used
)
2700 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2702 submenu_stack
[submenu_depth
++] = save_wv
;
2708 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2711 save_wv
= submenu_stack
[--submenu_depth
];
2715 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2716 && submenu_depth
!= 0)
2717 i
+= MENU_ITEMS_PANE_LENGTH
;
2718 /* Ignore a nil in the item list.
2719 It's meaningful only for dialog boxes. */
2720 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2722 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2724 /* Create a new pane. */
2725 Lisp_Object pane_name
, prefix
;
2728 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2729 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2731 #ifndef HAVE_MULTILINGUAL_MENU
2732 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2734 pane_name
= ENCODE_MENU_STRING (pane_name
);
2735 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2738 pane_string
= (NILP (pane_name
)
2739 ? "" : (char *) SDATA (pane_name
));
2740 /* If there is just one top-level pane, put all its items directly
2741 under the top-level menu. */
2742 if (menu_items_n_panes
== 1)
2745 /* If the pane has a meaningful name,
2746 make the pane a top-level menu item
2747 with its items as a submenu beneath it. */
2748 if (!keymaps
&& strcmp (pane_string
, ""))
2750 wv
= xmalloc_widget_value ();
2754 first_wv
->contents
= wv
;
2755 wv
->name
= pane_string
;
2756 if (keymaps
&& !NILP (prefix
))
2760 wv
->button_type
= BUTTON_TYPE_NONE
;
2765 else if (first_pane
)
2771 i
+= MENU_ITEMS_PANE_LENGTH
;
2775 /* Create a new item within current pane. */
2776 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2777 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2778 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2779 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2780 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2781 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2782 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2783 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2785 #ifndef HAVE_MULTILINGUAL_MENU
2786 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2788 item_name
= ENCODE_MENU_STRING (item_name
);
2789 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2792 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2794 descrip
= ENCODE_MENU_STRING (descrip
);
2795 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2797 #endif /* not HAVE_MULTILINGUAL_MENU */
2799 wv
= xmalloc_widget_value ();
2803 save_wv
->contents
= wv
;
2804 wv
->name
= (char *) SDATA (item_name
);
2805 if (!NILP (descrip
))
2806 wv
->key
= (char *) SDATA (descrip
);
2808 /* If this item has a null value,
2809 make the call_data null so that it won't display a box
2810 when the mouse is on it. */
2812 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2813 wv
->enabled
= !NILP (enable
);
2816 wv
->button_type
= BUTTON_TYPE_NONE
;
2817 else if (EQ (type
, QCtoggle
))
2818 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2819 else if (EQ (type
, QCradio
))
2820 wv
->button_type
= BUTTON_TYPE_RADIO
;
2824 wv
->selected
= !NILP (selected
);
2826 if (! STRINGP (help
))
2833 i
+= MENU_ITEMS_ITEM_LENGTH
;
2837 /* Deal with the title, if it is non-nil. */
2840 widget_value
*wv_title
= xmalloc_widget_value ();
2841 widget_value
*wv_sep1
= xmalloc_widget_value ();
2842 widget_value
*wv_sep2
= xmalloc_widget_value ();
2844 wv_sep2
->name
= "--";
2845 wv_sep2
->next
= first_wv
->contents
;
2846 wv_sep2
->help
= Qnil
;
2848 wv_sep1
->name
= "--";
2849 wv_sep1
->next
= wv_sep2
;
2850 wv_sep1
->help
= Qnil
;
2852 #ifndef HAVE_MULTILINGUAL_MENU
2853 if (STRING_MULTIBYTE (title
))
2854 title
= ENCODE_MENU_STRING (title
);
2857 wv_title
->name
= (char *) SDATA (title
);
2858 wv_title
->enabled
= TRUE
;
2859 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2860 wv_title
->next
= wv_sep1
;
2861 wv_title
->help
= Qnil
;
2862 first_wv
->contents
= wv_title
;
2865 /* No selection has been chosen yet. */
2866 menu_item_selection
= 0;
2868 /* Actually create and show the menu until popped down. */
2869 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2871 /* Free the widget_value objects we used to specify the contents. */
2872 free_menubar_widget_value_tree (first_wv
);
2874 /* Find the selected item, and its pane, to return
2875 the proper value. */
2876 if (menu_item_selection
!= 0)
2878 Lisp_Object prefix
, entry
;
2880 prefix
= entry
= Qnil
;
2882 while (i
< menu_items_used
)
2884 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2886 subprefix_stack
[submenu_depth
++] = prefix
;
2890 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2892 prefix
= subprefix_stack
[--submenu_depth
];
2895 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2898 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2899 i
+= MENU_ITEMS_PANE_LENGTH
;
2901 /* Ignore a nil in the item list.
2902 It's meaningful only for dialog boxes. */
2903 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2908 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2909 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2915 entry
= Fcons (entry
, Qnil
);
2917 entry
= Fcons (prefix
, entry
);
2918 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2919 if (!NILP (subprefix_stack
[j
]))
2920 entry
= Fcons (subprefix_stack
[j
], entry
);
2924 i
+= MENU_ITEMS_ITEM_LENGTH
;
2928 else if (!for_click
)
2929 /* Make "Cancel" equivalent to C-g. */
2930 Fsignal (Qquit
, Qnil
);
2937 dialog_selection_callback (widget
, client_data
)
2939 gpointer client_data
;
2941 /* The EMACS_INT cast avoids a warning. There's no problem
2942 as long as pointers have enough bits to hold small integers. */
2943 if ((int) (EMACS_INT
) client_data
!= -1)
2944 menu_item_selection
= (Lisp_Object
*) client_data
;
2946 popup_activated_flag
= 0;
2949 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2951 menu_item_selection will be set to the selection. */
2953 create_and_show_dialog (f
, first_wv
)
2955 widget_value
*first_wv
;
2959 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2960 G_CALLBACK (dialog_selection_callback
),
2961 G_CALLBACK (popup_deactivate_callback
),
2966 int specpdl_count
= SPECPDL_INDEX ();
2967 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2969 /* Display the menu. */
2970 gtk_widget_show_all (menu
);
2972 /* Process events that apply to the menu. */
2973 popup_widget_loop (1, menu
);
2975 unbind_to (specpdl_count
, Qnil
);
2979 #else /* not USE_GTK */
2981 dialog_selection_callback (widget
, id
, client_data
)
2984 XtPointer client_data
;
2986 /* The EMACS_INT cast avoids a warning. There's no problem
2987 as long as pointers have enough bits to hold small integers. */
2988 if ((int) (EMACS_INT
) client_data
!= -1)
2989 menu_item_selection
= (Lisp_Object
*) client_data
;
2992 lw_destroy_all_widgets (id
);
2994 popup_activated_flag
= 0;
2998 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
3000 menu_item_selection will be set to the selection. */
3002 create_and_show_dialog (f
, first_wv
)
3004 widget_value
*first_wv
;
3008 dialog_id
= widget_id_tick
++;
3009 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
3010 f
->output_data
.x
->widget
, 1, 0,
3011 dialog_selection_callback
, 0, 0);
3012 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
3014 /* Display the dialog box. */
3015 lw_pop_up_all_widgets (dialog_id
);
3016 popup_activated_flag
= 1;
3018 /* Process events that apply to the dialog box.
3019 Also handle timers. */
3021 int count
= SPECPDL_INDEX ();
3022 int fact
= 4 * sizeof (LWLIB_ID
);
3024 /* xdialog_show_unwind is responsible for popping the dialog box down. */
3025 record_unwind_protect (pop_down_menu
,
3026 Fcons (make_number (dialog_id
>> (fact
)),
3027 make_number (dialog_id
& ~(-1 << (fact
)))));
3029 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
3032 unbind_to (count
, Qnil
);
3036 #endif /* not USE_GTK */
3038 static char * button_names
[] = {
3039 "button1", "button2", "button3", "button4", "button5",
3040 "button6", "button7", "button8", "button9", "button10" };
3043 xdialog_show (f
, keymaps
, title
, header
, error_name
)
3046 Lisp_Object title
, header
;
3049 int i
, nb_buttons
=0;
3050 char dialog_name
[6];
3052 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
3054 /* Number of elements seen so far, before boundary. */
3056 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
3057 int boundary_seen
= 0;
3061 if (menu_items_n_panes
> 1)
3063 *error_name
= "Multiple panes in dialog box";
3067 /* Create a tree of widget_value objects
3068 representing the text label and buttons. */
3070 Lisp_Object pane_name
, prefix
;
3072 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
3073 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
3074 pane_string
= (NILP (pane_name
)
3075 ? "" : (char *) SDATA (pane_name
));
3076 prev_wv
= xmalloc_widget_value ();
3077 prev_wv
->value
= pane_string
;
3078 if (keymaps
&& !NILP (prefix
))
3080 prev_wv
->enabled
= 1;
3081 prev_wv
->name
= "message";
3082 prev_wv
->help
= Qnil
;
3085 /* Loop over all panes and items, filling in the tree. */
3086 i
= MENU_ITEMS_PANE_LENGTH
;
3087 while (i
< menu_items_used
)
3090 /* Create a new item within current pane. */
3091 Lisp_Object item_name
, enable
, descrip
;
3092 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3093 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3095 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3097 if (NILP (item_name
))
3099 free_menubar_widget_value_tree (first_wv
);
3100 *error_name
= "Submenu in dialog items";
3103 if (EQ (item_name
, Qquote
))
3105 /* This is the boundary between left-side elts
3106 and right-side elts. Stop incrementing right_count. */
3111 if (nb_buttons
>= 9)
3113 free_menubar_widget_value_tree (first_wv
);
3114 *error_name
= "Too many dialog items";
3118 wv
= xmalloc_widget_value ();
3120 wv
->name
= (char *) button_names
[nb_buttons
];
3121 if (!NILP (descrip
))
3122 wv
->key
= (char *) SDATA (descrip
);
3123 wv
->value
= (char *) SDATA (item_name
);
3124 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3125 wv
->enabled
= !NILP (enable
);
3129 if (! boundary_seen
)
3133 i
+= MENU_ITEMS_ITEM_LENGTH
;
3136 /* If the boundary was not specified,
3137 by default put half on the left and half on the right. */
3138 if (! boundary_seen
)
3139 left_count
= nb_buttons
- nb_buttons
/ 2;
3141 wv
= xmalloc_widget_value ();
3142 wv
->name
= dialog_name
;
3145 /* Frame title: 'Q' = Question, 'I' = Information.
3146 Can also have 'E' = Error if, one day, we want
3147 a popup for errors. */
3149 dialog_name
[0] = 'Q';
3151 dialog_name
[0] = 'I';
3153 /* Dialog boxes use a really stupid name encoding
3154 which specifies how many buttons to use
3155 and how many buttons are on the right. */
3156 dialog_name
[1] = '0' + nb_buttons
;
3157 dialog_name
[2] = 'B';
3158 dialog_name
[3] = 'R';
3159 /* Number of buttons to put on the right. */
3160 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3162 wv
->contents
= first_wv
;
3166 /* No selection has been chosen yet. */
3167 menu_item_selection
= 0;
3169 /* Actually create and show the dialog. */
3170 create_and_show_dialog (f
, first_wv
);
3172 /* Free the widget_value objects we used to specify the contents. */
3173 free_menubar_widget_value_tree (first_wv
);
3175 /* Find the selected item, and its pane, to return
3176 the proper value. */
3177 if (menu_item_selection
!= 0)
3183 while (i
< menu_items_used
)
3187 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3190 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3191 i
+= MENU_ITEMS_PANE_LENGTH
;
3193 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3195 /* This is the boundary between left-side elts and
3202 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3203 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3207 entry
= Fcons (entry
, Qnil
);
3209 entry
= Fcons (prefix
, entry
);
3213 i
+= MENU_ITEMS_ITEM_LENGTH
;
3218 /* Make "Cancel" equivalent to C-g. */
3219 Fsignal (Qquit
, Qnil
);
3224 #else /* not USE_X_TOOLKIT && not USE_GTK */
3226 /* The frame of the last activated non-toolkit menu bar.
3227 Used to generate menu help events. */
3229 static struct frame
*menu_help_frame
;
3232 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3234 PANE is the pane number, and ITEM is the menu item number in
3235 the menu (currently not used).
3237 This cannot be done with generating a HELP_EVENT because
3238 XMenuActivate contains a loop that doesn't let Emacs process
3242 menu_help_callback (help_string
, pane
, item
)
3246 extern Lisp_Object Qmenu_item
;
3247 Lisp_Object
*first_item
;
3248 Lisp_Object pane_name
;
3249 Lisp_Object menu_object
;
3251 first_item
= XVECTOR (menu_items
)->contents
;
3252 if (EQ (first_item
[0], Qt
))
3253 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3254 else if (EQ (first_item
[0], Qquote
))
3255 /* This shouldn't happen, see xmenu_show. */
3256 pane_name
= empty_string
;
3258 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3260 /* (menu-item MENU-NAME PANE-NUMBER) */
3261 menu_object
= Fcons (Qmenu_item
,
3263 Fcons (make_number (pane
), Qnil
)));
3264 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3265 Qnil
, menu_object
, make_number (item
), 1);
3272 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
3273 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
3275 FRAME_PTR f
= p1
->pointer
;
3276 XMenu
*menu
= p2
->pointer
;
3280 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
3281 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
3283 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3285 #ifdef HAVE_X_WINDOWS
3286 /* Assume the mouse has moved out of the X window.
3287 If it has actually moved in, we will get an EnterNotify. */
3288 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3290 /* State that no mouse buttons are now held.
3291 (The oldXMenu code doesn't track this info for us.)
3292 That is not necessarily true, but the fiction leads to reasonable
3293 results, and it is a pain to ask which are actually held now. */
3294 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3296 #endif /* HAVE_X_WINDOWS */
3305 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3315 int pane
, selidx
, lpane
, status
;
3316 Lisp_Object entry
, pane_prefix
;
3318 int ulx
, uly
, width
, height
;
3319 int dispwidth
, dispheight
;
3320 int i
, j
, lines
, maxlines
;
3323 unsigned int dummy_uint
;
3324 int specpdl_count
= SPECPDL_INDEX ();
3327 if (menu_items_n_panes
== 0)
3330 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3332 *error
= "Empty menu";
3336 /* Figure out which root window F is on. */
3337 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3338 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3339 &dummy_uint
, &dummy_uint
);
3341 /* Make the menu on that window. */
3342 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3345 *error
= "Can't create menu";
3349 /* Don't GC while we prepare and show the menu,
3350 because we give the oldxmenu library pointers to the
3351 contents of strings. */
3352 inhibit_garbage_collection ();
3354 #ifdef HAVE_X_WINDOWS
3355 /* Adjust coordinates to relative to the outer (window manager) window. */
3356 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
3357 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
3358 #endif /* HAVE_X_WINDOWS */
3360 /* Adjust coordinates to be root-window-relative. */
3364 /* Create all the necessary panes and their items. */
3365 maxlines
= lines
= i
= 0;
3366 while (i
< menu_items_used
)
3368 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3370 /* Create a new pane. */
3371 Lisp_Object pane_name
, prefix
;
3374 maxlines
= max (maxlines
, lines
);
3376 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3377 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3378 pane_string
= (NILP (pane_name
)
3379 ? "" : (char *) SDATA (pane_name
));
3380 if (keymaps
&& !NILP (prefix
))
3383 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3384 if (lpane
== XM_FAILURE
)
3386 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3387 *error
= "Can't create pane";
3390 i
+= MENU_ITEMS_PANE_LENGTH
;
3392 /* Find the width of the widest item in this pane. */
3395 while (j
< menu_items_used
)
3398 item
= XVECTOR (menu_items
)->contents
[j
];
3406 width
= SBYTES (item
);
3407 if (width
> maxwidth
)
3410 j
+= MENU_ITEMS_ITEM_LENGTH
;
3413 /* Ignore a nil in the item list.
3414 It's meaningful only for dialog boxes. */
3415 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3419 /* Create a new item within current pane. */
3420 Lisp_Object item_name
, enable
, descrip
, help
;
3421 unsigned char *item_data
;
3424 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3425 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3427 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3428 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3429 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3431 if (!NILP (descrip
))
3433 int gap
= maxwidth
- SBYTES (item_name
);
3436 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3437 item_name
= concat2 (item_name
, spacer
);
3438 item_name
= concat2 (item_name
, descrip
);
3439 item_data
= SDATA (item_name
);
3441 /* if alloca is fast, use that to make the space,
3442 to reduce gc needs. */
3444 = (unsigned char *) alloca (maxwidth
3445 + SBYTES (descrip
) + 1);
3446 bcopy (SDATA (item_name
), item_data
,
3447 SBYTES (item_name
));
3448 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3450 bcopy (SDATA (descrip
), item_data
+ j
,
3452 item_data
[j
+ SBYTES (descrip
)] = 0;
3456 item_data
= SDATA (item_name
);
3458 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3459 menu
, lpane
, 0, item_data
,
3460 !NILP (enable
), help_string
)
3463 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3464 *error
= "Can't add selection to menu";
3467 i
+= MENU_ITEMS_ITEM_LENGTH
;
3472 maxlines
= max (maxlines
, lines
);
3474 /* All set and ready to fly. */
3475 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3476 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3477 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3478 x
= min (x
, dispwidth
);
3479 y
= min (y
, dispheight
);
3482 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3483 &ulx
, &uly
, &width
, &height
);
3484 if (ulx
+width
> dispwidth
)
3486 x
-= (ulx
+ width
) - dispwidth
;
3487 ulx
= dispwidth
- width
;
3489 if (uly
+height
> dispheight
)
3491 y
-= (uly
+ height
) - dispheight
;
3492 uly
= dispheight
- height
;
3494 if (ulx
< 0) x
-= ulx
;
3495 if (uly
< 0) y
-= uly
;
3499 /* If position was not given by a mouse click, adjust so upper left
3500 corner of the menu as a whole ends up at given coordinates. This
3501 is what x-popup-menu says in its documentation. */
3503 y
+= 1.5*height
/(maxlines
+2);
3506 XMenuSetAEQ (menu
, TRUE
);
3507 XMenuSetFreeze (menu
, TRUE
);
3511 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3514 record_unwind_protect (pop_down_menu
,
3515 Fcons (make_save_value (f
, 0),
3516 make_save_value (menu
, 0)));
3518 /* Help display under X won't work because XMenuActivate contains
3519 a loop that doesn't give Emacs a chance to process it. */
3520 menu_help_frame
= f
;
3521 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3522 x
, y
, ButtonReleaseMask
, &datap
,
3523 menu_help_callback
);
3529 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3532 /* Find the item number SELIDX in pane number PANE. */
3534 while (i
< menu_items_used
)
3536 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3540 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3542 i
+= MENU_ITEMS_PANE_LENGTH
;
3551 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3554 entry
= Fcons (entry
, Qnil
);
3555 if (!NILP (pane_prefix
))
3556 entry
= Fcons (pane_prefix
, entry
);
3562 i
+= MENU_ITEMS_ITEM_LENGTH
;
3568 *error
= "Can't activate menu";
3573 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3574 the menu was invoked with a mouse event as POSITION). */
3576 Fsignal (Qquit
, Qnil
);
3581 unbind_to (specpdl_count
, Qnil
);
3586 #endif /* not USE_X_TOOLKIT */
3588 #endif /* HAVE_MENUS */
3593 staticpro (&menu_items
);
3595 menu_items_inuse
= Qnil
;
3597 Qdebug_on_next_call
= intern ("debug-on-next-call");
3598 staticpro (&Qdebug_on_next_call
);
3600 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3601 doc
: /* Frame for which we are updating a menu.
3602 The enable predicate for a menu command should check this variable. */);
3603 Vmenu_updating_frame
= Qnil
;
3605 #ifdef USE_X_TOOLKIT
3606 widget_id_tick
= (1<<16);
3607 next_menubar_widget_id
= 1;
3610 defsubr (&Sx_popup_menu
);
3612 defsubr (&Sx_popup_dialog
);
3616 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3617 (do not change this comment) */