1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1999, 2000, 2001, 2003, 2004,
3 2005 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* X pop-up deck-of-cards menu facility for GNU Emacs.
24 * Written by Jon Arnold and Roman Budzianowski
25 * Mods and rewrite by Robert Krawitz
29 /* Modified by Fred Pierresteguy on December 93
30 to make the popup menus and menubar use the Xt. */
32 /* Rewritten for clarity and GC protection by rms in Feb 94. */
36 /* On 4.3 this loses if it comes after xterm.h. */
42 #include "termhooks.h"
47 #include "blockinput.h"
51 #include "sysselect.h"
58 /* This may include sys/types.h, and that somehow loses
59 if this is not done before the other system files. */
63 /* Load sys/types.h if not already loaded.
64 In some systems loading it twice is suicidal. */
66 #include <sys/types.h>
69 #include "dispextern.h"
72 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
73 code accepts the Emacs internal encoding. */
74 #undef HAVE_MULTILINGUAL_MENU
78 #include <X11/IntrinsicP.h>
79 #include <X11/CoreP.h>
80 #include <X11/StringDefs.h>
81 #include <X11/Shell.h>
83 #include <X11/Xaw/Paned.h>
84 #endif /* USE_LUCID */
85 #include "../lwlib/lwlib.h"
86 #else /* not USE_X_TOOLKIT */
88 #include "../oldXMenu/XMenu.h"
90 #endif /* not USE_X_TOOLKIT */
91 #endif /* HAVE_X_WINDOWS */
98 Lisp_Object Vmenu_updating_frame
;
100 Lisp_Object Qdebug_on_next_call
;
102 extern Lisp_Object Qmenu_bar
;
104 extern Lisp_Object QCtoggle
, QCradio
;
106 extern Lisp_Object Voverriding_local_map
;
107 extern Lisp_Object Voverriding_local_map_menu_flag
;
109 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
111 extern Lisp_Object Qmenu_bar_update_hook
;
114 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
115 extern XtAppContext Xt_app_con
;
117 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, char **));
118 static void popup_get_selection
P_ ((XEvent
*, struct x_display_info
*,
121 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
124 #endif /* USE_X_TOOLKIT */
129 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
130 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, char **));
133 /* This is how to deal with multibyte text if HAVE_MULTILINGUAL_MENU
134 isn't defined. The use of HAVE_MULTILINGUAL_MENU could probably be
135 confined to an extended version of this with sections of code below
136 using it unconditionally. */
138 /* gtk just uses utf-8. */
139 # define ENCODE_MENU_STRING(str) ENCODE_UTF_8 (str)
140 #elif defined HAVE_X_I18N
141 # define ENCODE_MENU_STRING(str) ENCODE_SYSTEM (str)
143 # define ENCODE_MENU_STRING(str) string_make_unibyte (str)
146 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
147 Lisp_Object
, Lisp_Object
, Lisp_Object
,
148 Lisp_Object
, Lisp_Object
));
149 static int update_frame_menubar
P_ ((struct frame
*));
150 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
151 Lisp_Object
, char **));
152 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
153 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
155 static void list_of_panes
P_ ((Lisp_Object
));
156 static void list_of_items
P_ ((Lisp_Object
));
159 /* This holds a Lisp vector that holds the results of decoding
160 the keymaps or alist-of-alists that specify a menu.
162 It describes the panes and items within the panes.
164 Each pane is described by 3 elements in the vector:
165 t, the pane name, the pane's prefix key.
166 Then follow the pane's items, with 5 elements per item:
167 the item string, the enable flag, the item's value,
168 the definition, and the equivalent keyboard key's description string.
170 In some cases, multiple levels of menus may be described.
171 A single vector slot containing nil indicates the start of a submenu.
172 A single vector slot containing lambda indicates the end of a submenu.
173 The submenu follows a menu item which is the way to reach the submenu.
175 A single vector slot containing quote indicates that the
176 following items should appear on the right of a dialog box.
178 Using a Lisp vector to hold this information while we decode it
179 takes care of protecting all the data from GC. */
181 #define MENU_ITEMS_PANE_NAME 1
182 #define MENU_ITEMS_PANE_PREFIX 2
183 #define MENU_ITEMS_PANE_LENGTH 3
187 MENU_ITEMS_ITEM_NAME
= 0,
188 MENU_ITEMS_ITEM_ENABLE
,
189 MENU_ITEMS_ITEM_VALUE
,
190 MENU_ITEMS_ITEM_EQUIV_KEY
,
191 MENU_ITEMS_ITEM_DEFINITION
,
192 MENU_ITEMS_ITEM_TYPE
,
193 MENU_ITEMS_ITEM_SELECTED
,
194 MENU_ITEMS_ITEM_HELP
,
195 MENU_ITEMS_ITEM_LENGTH
198 static Lisp_Object menu_items
;
200 /* If non-nil, means that the global vars defined here are already in use.
201 Used to detect cases where we try to re-enter this non-reentrant code. */
202 static Lisp_Object menu_items_inuse
;
204 /* Number of slots currently allocated in menu_items. */
205 static int menu_items_allocated
;
207 /* This is the index in menu_items of the first empty slot. */
208 static int menu_items_used
;
210 /* The number of panes currently recorded in menu_items,
211 excluding those within submenus. */
212 static int menu_items_n_panes
;
214 /* Current depth within submenus. */
215 static int menu_items_submenu_depth
;
217 /* Flag which when set indicates a dialog or menu has been posted by
218 Xt on behalf of one of the widget sets. */
219 static int popup_activated_flag
;
221 static int next_menubar_widget_id
;
223 /* This is set nonzero after the user activates the menu bar, and set
224 to zero again after the menu bars are redisplayed by prepare_menu_bar.
225 While it is nonzero, all calls to set_frame_menubar go deep.
227 I don't understand why this is needed, but it does seem to be
228 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
230 int pending_menu_activation
;
234 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
236 static struct frame
*
237 menubar_id_to_frame (id
)
240 Lisp_Object tail
, frame
;
243 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
246 if (!GC_FRAMEP (frame
))
249 if (!FRAME_WINDOW_P (f
))
251 if (f
->output_data
.x
->id
== id
)
259 /* Initialize the menu_items structure if we haven't already done so.
260 Also mark it as currently empty. */
265 if (NILP (menu_items
))
267 menu_items_allocated
= 60;
268 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
271 if (!NILP (menu_items_inuse
))
272 error ("Trying to use a menu from within a menu-entry");
273 menu_items_inuse
= Qt
;
275 menu_items_n_panes
= 0;
276 menu_items_submenu_depth
= 0;
279 /* Call at the end of generating the data in menu_items. */
287 unuse_menu_items (dummy
)
290 return menu_items_inuse
= Qnil
;
293 /* Call when finished using the data for the current menu
297 discard_menu_items ()
299 /* Free the structure if it is especially large.
300 Otherwise, hold on to it, to save time. */
301 if (menu_items_allocated
> 200)
304 menu_items_allocated
= 0;
306 xassert (NILP (menu_items_inuse
));
309 /* Make the menu_items vector twice as large. */
315 int old_size
= menu_items_allocated
;
318 menu_items_allocated
*= 2;
319 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
320 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
321 old_size
* sizeof (Lisp_Object
));
324 /* Begin a submenu. */
327 push_submenu_start ()
329 if (menu_items_used
+ 1 > menu_items_allocated
)
332 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
333 menu_items_submenu_depth
++;
341 if (menu_items_used
+ 1 > menu_items_allocated
)
344 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
345 menu_items_submenu_depth
--;
348 /* Indicate boundary between left and right. */
351 push_left_right_boundary ()
353 if (menu_items_used
+ 1 > menu_items_allocated
)
356 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
359 /* Start a new menu pane in menu_items.
360 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
363 push_menu_pane (name
, prefix_vec
)
364 Lisp_Object name
, prefix_vec
;
366 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
369 if (menu_items_submenu_depth
== 0)
370 menu_items_n_panes
++;
371 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
372 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
373 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
376 /* Push one menu item into the current pane. NAME is the string to
377 display. ENABLE if non-nil means this item can be selected. KEY
378 is the key generated by choosing this item, or nil if this item
379 doesn't really have a definition. DEF is the definition of this
380 item. EQUIV is the textual description of the keyboard equivalent
381 for this item (or nil if none). TYPE is the type of this menu
382 item, one of nil, `toggle' or `radio'. */
385 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
386 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
388 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
391 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
392 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
393 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
394 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
395 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
396 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
397 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
398 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
401 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
402 and generate menu panes for them in menu_items.
403 If NOTREAL is nonzero,
404 don't bother really computing whether an item is enabled. */
407 keymap_panes (keymaps
, nmaps
, notreal
)
408 Lisp_Object
*keymaps
;
416 /* Loop over the given keymaps, making a pane for each map.
417 But don't make a pane that is empty--ignore that map instead.
418 P is the number of panes we have made so far. */
419 for (mapno
= 0; mapno
< nmaps
; mapno
++)
420 single_keymap_panes (keymaps
[mapno
],
421 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
423 finish_menu_items ();
426 /* Args passed between single_keymap_panes and single_menu_item. */
429 Lisp_Object pending_maps
;
430 int maxdepth
, notreal
;
434 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
437 /* This is a recursive subroutine of keymap_panes.
438 It handles one keymap, KEYMAP.
439 The other arguments are passed along
440 or point to local variables of the previous function.
441 If NOTREAL is nonzero, only check for equivalent key bindings, don't
442 evaluate expressions in menu items and don't make any menu.
444 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
447 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
449 Lisp_Object pane_name
;
457 skp
.pending_maps
= Qnil
;
458 skp
.maxdepth
= maxdepth
;
459 skp
.notreal
= notreal
;
465 push_menu_pane (pane_name
, prefix
);
468 /* Remember index for first item in this pane so we can go back and
469 add a prefix when (if) we see the first button. After that, notbuttons
470 is set to 0, to mark that we have seen a button and all non button
471 items need a prefix. */
472 skp
.notbuttons
= menu_items_used
;
475 GCPRO1 (skp
.pending_maps
);
476 map_keymap (keymap
, single_menu_item
, Qnil
, &skp
, 1);
479 /* Process now any submenus which want to be panes at this level. */
480 while (CONSP (skp
.pending_maps
))
482 Lisp_Object elt
, eltcdr
, string
;
483 elt
= XCAR (skp
.pending_maps
);
485 string
= XCAR (eltcdr
);
486 /* We no longer discard the @ from the beginning of the string here.
487 Instead, we do this in xmenu_show. */
488 single_keymap_panes (Fcar (elt
), string
,
489 XCDR (eltcdr
), notreal
, maxdepth
- 1);
490 skp
.pending_maps
= XCDR (skp
.pending_maps
);
494 /* This is a subroutine of single_keymap_panes that handles one
496 KEY is a key in a keymap and ITEM is its binding.
497 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
499 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
500 evaluate expressions in menu items and don't make any menu.
501 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
502 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
503 buttons. It keeps track of if we have seen a button in this menu or
507 single_menu_item (key
, item
, dummy
, skp_v
)
508 Lisp_Object key
, item
, dummy
;
511 Lisp_Object map
, item_string
, enabled
;
512 struct gcpro gcpro1
, gcpro2
;
514 struct skp
*skp
= skp_v
;
516 /* Parse the menu item and leave the result in item_properties. */
518 res
= parse_menu_item (item
, skp
->notreal
, 0);
521 return; /* Not a menu item. */
523 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
527 /* We don't want to make a menu, just traverse the keymaps to
528 precompute equivalent key bindings. */
530 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
534 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
535 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
537 if (!NILP (map
) && SREF (item_string
, 0) == '@')
540 /* An enabled separate pane. Remember this to handle it later. */
541 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
547 /* Simulate radio buttons and toggle boxes by putting a prefix in
550 Lisp_Object prefix
= Qnil
;
551 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
555 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
558 /* The first button. Line up previous items in this menu. */
560 int index
= skp
->notbuttons
; /* Index for first item this menu. */
563 while (index
< menu_items_used
)
566 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
570 submenu
++; /* Skip sub menu. */
572 else if (EQ (tem
, Qlambda
))
575 submenu
--; /* End sub menu. */
577 else if (EQ (tem
, Qt
))
578 index
+= 3; /* Skip new pane marker. */
579 else if (EQ (tem
, Qquote
))
580 index
++; /* Skip a left, right divider. */
583 if (!submenu
&& SREF (tem
, 0) != '\0'
584 && SREF (tem
, 0) != '-')
585 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
586 = concat2 (build_string (" "), tem
);
587 index
+= MENU_ITEMS_ITEM_LENGTH
;
593 /* Calculate prefix, if any, for this item. */
594 if (EQ (type
, QCtoggle
))
595 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
596 else if (EQ (type
, QCradio
))
597 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
599 /* Not a button. If we have earlier buttons, then we need a prefix. */
600 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
601 && SREF (item_string
, 0) != '-')
602 prefix
= build_string (" ");
605 item_string
= concat2 (prefix
, item_string
);
607 #endif /* not HAVE_BOXES */
609 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
611 /* Indicate visually that this is a submenu. */
612 item_string
= concat2 (item_string
, build_string (" >"));
615 push_menu_item (item_string
, enabled
, key
,
616 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
617 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
618 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
619 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
620 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
622 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
623 /* Display a submenu using the toolkit. */
624 if (! (NILP (map
) || NILP (enabled
)))
626 push_submenu_start ();
627 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
633 /* Push all the panes and items of a menu described by the
634 alist-of-alists MENU.
635 This handles old-fashioned calls to x-popup-menu. */
645 for (tail
= menu
; CONSP (tail
); tail
= XCDR (tail
))
647 Lisp_Object elt
, pane_name
, pane_data
;
649 pane_name
= Fcar (elt
);
650 CHECK_STRING (pane_name
);
651 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
652 pane_data
= Fcdr (elt
);
653 CHECK_CONS (pane_data
);
654 list_of_items (pane_data
);
657 finish_menu_items ();
660 /* Push the items in a single pane defined by the alist PANE. */
666 Lisp_Object tail
, item
, item1
;
668 for (tail
= pane
; CONSP (tail
); tail
= XCDR (tail
))
672 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
673 Qnil
, Qnil
, Qnil
, Qnil
);
674 else if (CONSP (item
))
677 CHECK_STRING (item1
);
678 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, XCDR (item
),
679 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
682 push_left_right_boundary ();
687 #ifdef HAVE_X_WINDOWS
688 /* Return the mouse position in *X and *Y. The coordinates are window
689 relative for the edit window in frame F.
690 This is for Fx_popup_menu. The mouse_position_hook can not
691 be used for X, as it returns window relative coordinates
692 for the window where the mouse is in. This could be the menu bar,
693 the scroll bar or the edit window. Fx_popup_menu needs to be
694 sure it is the edit window. */
696 mouse_position_for_popup (f
, x
, y
)
701 Window root
, dummy_window
;
706 XQueryPointer (FRAME_X_DISPLAY (f
),
707 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
709 /* The root window which contains the pointer. */
712 /* Window pointer is on, not used */
715 /* The position on that root window. */
718 /* x/y in dummy_window coordinates, not used. */
721 /* Modifier keys and pointer buttons, about which
723 (unsigned int *) &dummy
);
727 /* xmenu_show expects window coordinates, not root window
728 coordinates. Translate. */
729 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
730 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
733 #endif /* HAVE_X_WINDOWS */
735 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
736 doc
: /* Pop up a deck-of-cards menu and return user's selection.
737 POSITION is a position specification. This is either a mouse button event
738 or a list ((XOFFSET YOFFSET) WINDOW)
739 where XOFFSET and YOFFSET are positions in pixels from the top left
740 corner of WINDOW. (WINDOW may be a window or a frame object.)
741 This controls the position of the top left of the menu as a whole.
742 If POSITION is t, it means to use the current mouse position.
744 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
745 The menu items come from key bindings that have a menu string as well as
746 a definition; actually, the "definition" in such a key binding looks like
747 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
748 the keymap as a top-level element.
750 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
751 Otherwise, REAL-DEFINITION should be a valid key binding definition.
753 You can also use a list of keymaps as MENU.
754 Then each keymap makes a separate pane.
756 When MENU is a keymap or a list of keymaps, the return value is the
757 list of events corresponding to the user's choice. Note that
758 `x-popup-menu' does not actually execute the command bound to that
761 Alternatively, you can specify a menu of multiple panes
762 with a list of the form (TITLE PANE1 PANE2...),
763 where each pane is a list of form (TITLE ITEM1 ITEM2...).
764 Each ITEM is normally a cons cell (STRING . VALUE);
765 but a string can appear as an item--that makes a nonselectable line
767 With this form of menu, the return value is VALUE from the chosen item.
769 If POSITION is nil, don't display the menu at all, just precalculate the
770 cached information about equivalent key sequences.
772 If the user gets rid of the menu without making a valid choice, for
773 instance by clicking the mouse away from a valid choice or by typing
774 keyboard input, then this normally results in a quit and
775 `x-popup-menu' does not return. But if POSITION is a mouse button
776 event (indicating that the user invoked the menu with the mouse) then
777 no quit occurs and `x-popup-menu' returns nil. */)
779 Lisp_Object position
, menu
;
781 Lisp_Object keymap
, tem
;
782 int xpos
= 0, ypos
= 0;
784 char *error_name
= NULL
;
785 Lisp_Object selection
;
787 Lisp_Object x
, y
, window
;
790 int specpdl_count
= SPECPDL_INDEX ();
794 if (! NILP (position
))
796 int get_current_pos_p
= 0;
799 /* Decode the first argument: find the window and the coordinates. */
800 if (EQ (position
, Qt
)
801 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
802 || EQ (XCAR (position
), Qtool_bar
))))
804 get_current_pos_p
= 1;
808 tem
= Fcar (position
);
811 window
= Fcar (Fcdr (position
));
813 y
= Fcar (XCDR (tem
));
818 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
819 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
820 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
825 /* If a click happens in an external tool bar or a detached
826 tool bar, x and y is NIL. In that case, use the current
827 mouse position. This happens for the help button in the
828 tool bar. Ideally popup-menu should pass NIL to
829 this function, but it doesn't. */
830 if (NILP (x
) && NILP (y
))
831 get_current_pos_p
= 1;
834 if (get_current_pos_p
)
836 /* Use the mouse's current position. */
837 FRAME_PTR new_f
= SELECTED_FRAME ();
838 #ifdef HAVE_X_WINDOWS
839 /* Can't use mouse_position_hook for X since it returns
840 coordinates relative to the window the mouse is in,
841 we need coordinates relative to the edit widget always. */
846 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
847 /* cur_x/y may be negative, so use make_number. */
848 x
= make_number (cur_x
);
849 y
= make_number (cur_y
);
852 #else /* not HAVE_X_WINDOWS */
853 Lisp_Object bar_window
;
854 enum scroll_bar_part part
;
857 if (mouse_position_hook
)
858 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
859 &part
, &x
, &y
, &time
);
860 #endif /* not HAVE_X_WINDOWS */
863 XSETFRAME (window
, new_f
);
866 window
= selected_window
;
875 /* Decode where to put the menu. */
883 else if (WINDOWP (window
))
885 CHECK_LIVE_WINDOW (window
);
886 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
888 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
889 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
892 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
893 but I don't want to make one now. */
894 CHECK_WINDOW (window
);
899 Vmenu_updating_frame
= Qnil
;
900 #endif /* HAVE_MENUS */
902 record_unwind_protect (unuse_menu_items
, Qnil
);
906 /* Decode the menu items from what was specified. */
908 keymap
= get_keymap (menu
, 0, 0);
911 /* We were given a keymap. Extract menu info from the keymap. */
914 /* Extract the detailed info to make one pane. */
915 keymap_panes (&menu
, 1, NILP (position
));
917 /* Search for a string appearing directly as an element of the keymap.
918 That string is the title of the menu. */
919 prompt
= Fkeymap_prompt (keymap
);
920 if (NILP (title
) && !NILP (prompt
))
923 /* Make that be the pane title of the first pane. */
924 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
925 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
929 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
931 /* We were given a list of keymaps. */
932 int nmaps
= XFASTINT (Flength (menu
));
934 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
939 /* The first keymap that has a prompt string
940 supplies the menu title. */
941 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
945 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
947 prompt
= Fkeymap_prompt (keymap
);
948 if (NILP (title
) && !NILP (prompt
))
952 /* Extract the detailed info to make one pane. */
953 keymap_panes (maps
, nmaps
, NILP (position
));
955 /* Make the title be the pane title of the first pane. */
956 if (!NILP (title
) && menu_items_n_panes
>= 0)
957 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
963 /* We were given an old-fashioned menu. */
965 CHECK_STRING (title
);
967 list_of_panes (Fcdr (menu
));
972 unbind_to (specpdl_count
, Qnil
);
976 discard_menu_items ();
982 /* Display them in a menu. */
985 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
986 keymaps
, title
, &error_name
);
989 discard_menu_items ();
992 #endif /* HAVE_MENUS */
994 if (error_name
) error (error_name
);
1000 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
1001 doc
: /* Pop up a dialog box and return user's selection.
1002 POSITION specifies which frame to use.
1003 This is normally a mouse button event or a window or frame.
1004 If POSITION is t, it means to use the frame the mouse is on.
1005 The dialog box appears in the middle of the specified frame.
1007 CONTENTS specifies the alternatives to display in the dialog box.
1008 It is a list of the form (TITLE ITEM1 ITEM2...).
1009 Each ITEM is a cons cell (STRING . VALUE).
1010 The return value is VALUE from the chosen item.
1012 An ITEM may also be just a string--that makes a nonselectable item.
1013 An ITEM may also be nil--that means to put all preceding items
1014 on the left of the dialog box and all following items on the right.
1015 \(By default, approximately half appear on each side.)
1017 If the user gets rid of the dialog box without making a valid choice,
1018 for instance using the window manager, then this produces a quit and
1019 `x-popup-dialog' does not return. */)
1020 (position
, contents
)
1021 Lisp_Object position
, contents
;
1028 /* Decode the first argument: find the window or frame to use. */
1029 if (EQ (position
, Qt
)
1030 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1031 || EQ (XCAR (position
), Qtool_bar
))))
1033 #if 0 /* Using the frame the mouse is on may not be right. */
1034 /* Use the mouse's current position. */
1035 FRAME_PTR new_f
= SELECTED_FRAME ();
1036 Lisp_Object bar_window
;
1037 enum scroll_bar_part part
;
1041 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1044 XSETFRAME (window
, new_f
);
1046 window
= selected_window
;
1048 window
= selected_window
;
1050 else if (CONSP (position
))
1053 tem
= Fcar (position
);
1055 window
= Fcar (Fcdr (position
));
1058 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1059 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1062 else if (WINDOWP (position
) || FRAMEP (position
))
1067 /* Decode where to put the menu. */
1069 if (FRAMEP (window
))
1070 f
= XFRAME (window
);
1071 else if (WINDOWP (window
))
1073 CHECK_LIVE_WINDOW (window
);
1074 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1077 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1078 but I don't want to make one now. */
1079 CHECK_WINDOW (window
);
1081 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1082 /* Display a menu with these alternatives
1083 in the middle of frame F. */
1085 Lisp_Object x
, y
, frame
, newpos
;
1086 XSETFRAME (frame
, f
);
1087 XSETINT (x
, x_pixel_width (f
) / 2);
1088 XSETINT (y
, x_pixel_height (f
) / 2);
1089 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1091 return Fx_popup_menu (newpos
,
1092 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1098 Lisp_Object selection
;
1099 int specpdl_count
= SPECPDL_INDEX ();
1101 /* Decode the dialog items from what was specified. */
1102 title
= Fcar (contents
);
1103 CHECK_STRING (title
);
1104 record_unwind_protect (unuse_menu_items
, Qnil
);
1106 if (NILP (Fcar (Fcdr (contents
))))
1107 /* No buttons specified, add an "Ok" button so users can pop down
1108 the dialog. Also, the lesstif/motif version crashes if there are
1110 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1112 list_of_panes (Fcons (contents
, Qnil
));
1114 /* Display them in a dialog box. */
1116 selection
= xdialog_show (f
, 0, title
, &error_name
);
1119 unbind_to (specpdl_count
, Qnil
);
1120 discard_menu_items ();
1122 if (error_name
) error (error_name
);
1131 /* Set menu_items_inuse so no other popup menu or dialog is created. */
1134 x_menu_set_in_use (in_use
)
1137 menu_items_inuse
= in_use
? Qt
: Qnil
;
1138 popup_activated_flag
= in_use
;
1141 /* Wait for an X event to arrive or for a timer to expire. */
1144 x_menu_wait_for_event (void *data
)
1146 extern EMACS_TIME timer_check
P_ ((int));
1148 /* Another way to do this is to register a timer callback, that can be
1149 done in GTK and Xt. But we have to do it like this when using only X
1150 anyway, and with callbacks we would have three variants for timer handling
1151 instead of the small ifdefs below. */
1154 #ifdef USE_X_TOOLKIT
1155 ! XtAppPending (Xt_app_con
)
1156 #elif defined USE_GTK
1157 ! gtk_events_pending ()
1159 ! XPending ((Display
*) data
)
1163 EMACS_TIME next_time
= timer_check (1);
1164 long secs
= EMACS_SECS (next_time
);
1165 long usecs
= EMACS_USECS (next_time
);
1166 SELECT_TYPE read_fds
;
1167 struct x_display_info
*dpyinfo
;
1170 FD_ZERO (&read_fds
);
1171 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1173 int fd
= ConnectionNumber (dpyinfo
->display
);
1174 FD_SET (fd
, &read_fds
);
1178 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1180 /* Sometimes timer_check returns -1 (no timers) even if there are
1181 timers. So do a timeout anyway. */
1182 EMACS_SET_SECS (next_time
, 1);
1183 EMACS_SET_USECS (next_time
, 0);
1186 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1189 #endif /* ! MSDOS */
1192 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1194 #ifdef USE_X_TOOLKIT
1196 /* Loop in Xt until the menu pulldown or dialog popup has been
1197 popped down (deactivated). This is used for x-popup-menu
1198 and x-popup-dialog; it is not used for the menu bar.
1200 NOTE: All calls to popup_get_selection should be protected
1201 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1204 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1205 XEvent
*initial_event
;
1206 struct x_display_info
*dpyinfo
;
1212 while (popup_activated_flag
)
1216 event
= *initial_event
;
1221 if (do_timers
) x_menu_wait_for_event (0);
1222 XtAppNextEvent (Xt_app_con
, &event
);
1225 /* Make sure we don't consider buttons grabbed after menu goes.
1226 And make sure to deactivate for any ButtonRelease,
1227 even if XtDispatchEvent doesn't do that. */
1228 if (event
.type
== ButtonRelease
1229 && dpyinfo
->display
== event
.xbutton
.display
)
1231 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1232 #ifdef USE_MOTIF /* Pretending that the event came from a
1233 Btn1Down seems the only way to convince Motif to
1234 activate its callbacks; setting the XmNmenuPost
1235 isn't working. --marcus@sysc.pdx.edu. */
1236 event
.xbutton
.button
= 1;
1237 /* Motif only pops down menus when no Ctrl, Alt or Mod
1238 key is pressed and the button is released. So reset key state
1239 so Motif thinks this is the case. */
1240 event
.xbutton
.state
= 0;
1243 /* Pop down on C-g and Escape. */
1244 else if (event
.type
== KeyPress
1245 && dpyinfo
->display
== event
.xbutton
.display
)
1247 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1249 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
1250 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
1251 popup_activated_flag
= 0;
1254 x_dispatch_event (&event
, event
.xany
.display
);
1258 #endif /* USE_X_TOOLKIT */
1261 /* Loop util popup_activated_flag is set to zero in a callback.
1262 Used for popup menus and dialogs. */
1265 popup_widget_loop (do_timers
, widget
)
1269 ++popup_activated_flag
;
1271 /* Process events in the Gtk event loop until done. */
1272 while (popup_activated_flag
)
1274 if (do_timers
) x_menu_wait_for_event (0);
1275 gtk_main_iteration ();
1280 /* Activate the menu bar of frame F.
1281 This is called from keyboard.c when it gets the
1282 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1284 To activate the menu bar, we use the X button-press event
1285 that was saved in saved_menu_event.
1286 That makes the toolkit do its thing.
1288 But first we recompute the menu bar contents (the whole tree).
1290 The reason for saving the button event until here, instead of
1291 passing it to the toolkit right away, is that we can safely
1292 execute Lisp code. */
1295 x_activate_menubar (f
)
1298 if (!f
->output_data
.x
->saved_menu_event
->type
)
1302 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1303 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1307 set_frame_menubar (f
, 0, 1);
1310 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1311 f
->output_data
.x
->saved_menu_event
);
1312 popup_activated_flag
= 1;
1314 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1318 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1319 pending_menu_activation
= 1;
1322 /* Ignore this if we get it a second time. */
1323 f
->output_data
.x
->saved_menu_event
->type
= 0;
1326 /* Detect if a dialog or menu has been posted. */
1331 return popup_activated_flag
;
1334 /* This callback is invoked when the user selects a menubar cascade
1335 pushbutton, but before the pulldown menu is posted. */
1339 popup_activate_callback (widget
, id
, client_data
)
1342 XtPointer client_data
;
1344 popup_activated_flag
= 1;
1348 /* This callback is invoked when a dialog or menu is finished being
1349 used and has been unposted. */
1353 popup_deactivate_callback (widget
, client_data
)
1355 gpointer client_data
;
1357 popup_activated_flag
= 0;
1361 popup_deactivate_callback (widget
, id
, client_data
)
1364 XtPointer client_data
;
1366 popup_activated_flag
= 0;
1371 /* Function that finds the frame for WIDGET and shows the HELP text
1373 F is the frame if known, or NULL if not known. */
1375 show_help_event (f
, widget
, help
)
1377 xt_or_gtk_widget widget
;
1384 XSETFRAME (frame
, f
);
1385 kbd_buffer_store_help_event (frame
, help
);
1389 #if 0 /* This code doesn't do anything useful. ++kfs */
1390 /* WIDGET is the popup menu. It's parent is the frame's
1391 widget. See which frame that is. */
1392 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1395 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1397 frame
= XCAR (tail
);
1398 if (GC_FRAMEP (frame
)
1399 && (f
= XFRAME (frame
),
1400 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1404 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1408 /* Callback called when menu items are highlighted/unhighlighted
1409 while moving the mouse over them. WIDGET is the menu bar or menu
1410 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1411 the data structure for the menu item, or null in case of
1416 menu_highlight_callback (widget
, call_data
)
1420 xg_menu_item_cb_data
*cb_data
;
1423 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1425 if (! cb_data
) return;
1427 help
= call_data
? cb_data
->help
: Qnil
;
1429 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1430 Don't show help for them, they won't appear before the
1431 popup is popped down. */
1432 if (popup_activated_flag
<= 1)
1433 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1437 menu_highlight_callback (widget
, id
, call_data
)
1445 widget_value
*wv
= (widget_value
*) call_data
;
1447 help
= wv
? wv
->help
: Qnil
;
1449 /* Determine the frame for the help event. */
1450 f
= menubar_id_to_frame (id
);
1452 show_help_event (f
, widget
, help
);
1456 /* Find the menu selection and store it in the keyboard buffer.
1457 F is the frame the menu is on.
1458 MENU_BAR_ITEMS_USED is the length of VECTOR.
1459 VECTOR is an array of menu events for the whole menu. */
1462 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1464 int menu_bar_items_used
;
1468 Lisp_Object prefix
, entry
;
1469 Lisp_Object
*subprefix_stack
;
1470 int submenu_depth
= 0;
1474 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1478 while (i
< menu_bar_items_used
)
1480 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1482 subprefix_stack
[submenu_depth
++] = prefix
;
1486 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1488 prefix
= subprefix_stack
[--submenu_depth
];
1491 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1493 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1494 i
+= MENU_ITEMS_PANE_LENGTH
;
1498 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1499 /* The EMACS_INT cast avoids a warning. There's no problem
1500 as long as pointers have enough bits to hold small integers. */
1501 if ((int) (EMACS_INT
) client_data
== i
)
1504 struct input_event buf
;
1508 XSETFRAME (frame
, f
);
1509 buf
.kind
= MENU_BAR_EVENT
;
1510 buf
.frame_or_window
= frame
;
1512 kbd_buffer_store_event (&buf
);
1514 for (j
= 0; j
< submenu_depth
; j
++)
1515 if (!NILP (subprefix_stack
[j
]))
1517 buf
.kind
= MENU_BAR_EVENT
;
1518 buf
.frame_or_window
= frame
;
1519 buf
.arg
= subprefix_stack
[j
];
1520 kbd_buffer_store_event (&buf
);
1525 buf
.kind
= MENU_BAR_EVENT
;
1526 buf
.frame_or_window
= frame
;
1528 kbd_buffer_store_event (&buf
);
1531 buf
.kind
= MENU_BAR_EVENT
;
1532 buf
.frame_or_window
= frame
;
1534 kbd_buffer_store_event (&buf
);
1538 i
+= MENU_ITEMS_ITEM_LENGTH
;
1545 /* Gtk calls callbacks just because we tell it what item should be
1546 selected in a radio group. If this variable is set to a non-zero
1547 value, we are creating menus and don't want callbacks right now.
1549 static int xg_crazy_callback_abort
;
1551 /* This callback is called from the menu bar pulldown menu
1552 when the user makes a selection.
1553 Figure out what the user chose
1554 and put the appropriate events into the keyboard buffer. */
1556 menubar_selection_callback (widget
, client_data
)
1558 gpointer client_data
;
1560 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1562 if (xg_crazy_callback_abort
)
1565 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1568 /* When a menu is popped down, X generates a focus event (i.e. focus
1569 goes back to the frame below the menu). Since GTK buffers events,
1570 we force it out here before the menu selection event. Otherwise
1571 sit-for will exit at once if the focus event follows the menu selection
1575 while (gtk_events_pending ())
1576 gtk_main_iteration ();
1579 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1580 cb_data
->cl_data
->menu_bar_items_used
,
1581 cb_data
->cl_data
->menu_bar_vector
,
1582 cb_data
->call_data
);
1585 #else /* not USE_GTK */
1587 /* This callback is called from the menu bar pulldown menu
1588 when the user makes a selection.
1589 Figure out what the user chose
1590 and put the appropriate events into the keyboard buffer. */
1592 menubar_selection_callback (widget
, id
, client_data
)
1595 XtPointer client_data
;
1599 f
= menubar_id_to_frame (id
);
1602 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1603 f
->menu_bar_vector
, client_data
);
1605 #endif /* not USE_GTK */
1607 /* Allocate a widget_value, blocking input. */
1610 xmalloc_widget_value ()
1612 widget_value
*value
;
1615 value
= malloc_widget_value ();
1621 /* This recursively calls free_widget_value on the tree of widgets.
1622 It must free all data that was malloc'ed for these widget_values.
1623 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1624 must be left alone. */
1627 free_menubar_widget_value_tree (wv
)
1632 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1634 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1636 free_menubar_widget_value_tree (wv
->contents
);
1637 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1641 free_menubar_widget_value_tree (wv
->next
);
1642 wv
->next
= (widget_value
*) 0xDEADBEEF;
1645 free_widget_value (wv
);
1649 /* Set up data in menu_items for a menu bar item
1650 whose event type is ITEM_KEY (with string ITEM_NAME)
1651 and whose contents come from the list of keymaps MAPS. */
1654 parse_single_submenu (item_key
, item_name
, maps
)
1655 Lisp_Object item_key
, item_name
, maps
;
1659 Lisp_Object
*mapvec
;
1661 int top_level_items
= 0;
1663 length
= Flength (maps
);
1664 len
= XINT (length
);
1666 /* Convert the list MAPS into a vector MAPVEC. */
1667 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1668 for (i
= 0; i
< len
; i
++)
1670 mapvec
[i
] = Fcar (maps
);
1674 /* Loop over the given keymaps, making a pane for each map.
1675 But don't make a pane that is empty--ignore that map instead. */
1676 for (i
= 0; i
< len
; i
++)
1678 if (!KEYMAPP (mapvec
[i
]))
1680 /* Here we have a command at top level in the menu bar
1681 as opposed to a submenu. */
1682 top_level_items
= 1;
1683 push_menu_pane (Qnil
, Qnil
);
1684 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1685 Qnil
, Qnil
, Qnil
, Qnil
);
1690 prompt
= Fkeymap_prompt (mapvec
[i
]);
1691 single_keymap_panes (mapvec
[i
],
1692 !NILP (prompt
) ? prompt
: item_name
,
1697 return top_level_items
;
1700 /* Create a tree of widget_value objects
1701 representing the panes and items
1702 in menu_items starting at index START, up to index END. */
1704 static widget_value
*
1705 digest_single_submenu (start
, end
, top_level_items
)
1706 int start
, end
, top_level_items
;
1708 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1710 int submenu_depth
= 0;
1711 widget_value
**submenu_stack
;
1714 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1715 wv
= xmalloc_widget_value ();
1719 wv
->button_type
= BUTTON_TYPE_NONE
;
1725 /* Loop over all panes and items made by the preceding call
1726 to parse_single_submenu and construct a tree of widget_value objects.
1727 Ignore the panes and items used by previous calls to
1728 digest_single_submenu, even though those are also in menu_items. */
1732 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1734 submenu_stack
[submenu_depth
++] = save_wv
;
1739 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1742 save_wv
= submenu_stack
[--submenu_depth
];
1745 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1746 && submenu_depth
!= 0)
1747 i
+= MENU_ITEMS_PANE_LENGTH
;
1748 /* Ignore a nil in the item list.
1749 It's meaningful only for dialog boxes. */
1750 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1752 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1754 /* Create a new pane. */
1755 Lisp_Object pane_name
, prefix
;
1758 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1759 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1761 #ifndef HAVE_MULTILINGUAL_MENU
1762 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1764 pane_name
= ENCODE_MENU_STRING (pane_name
);
1765 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1768 pane_string
= (NILP (pane_name
)
1769 ? "" : (char *) SDATA (pane_name
));
1770 /* If there is just one top-level pane, put all its items directly
1771 under the top-level menu. */
1772 if (menu_items_n_panes
== 1)
1775 /* If the pane has a meaningful name,
1776 make the pane a top-level menu item
1777 with its items as a submenu beneath it. */
1778 if (strcmp (pane_string
, ""))
1780 wv
= xmalloc_widget_value ();
1784 first_wv
->contents
= wv
;
1785 wv
->lname
= pane_name
;
1786 /* Set value to 1 so update_submenu_strings can handle '@' */
1787 wv
->value
= (char *)1;
1789 wv
->button_type
= BUTTON_TYPE_NONE
;
1794 i
+= MENU_ITEMS_PANE_LENGTH
;
1798 /* Create a new item within current pane. */
1799 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1802 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1803 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1804 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1805 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1806 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1807 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1808 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1810 #ifndef HAVE_MULTILINGUAL_MENU
1811 if (STRING_MULTIBYTE (item_name
))
1813 item_name
= ENCODE_MENU_STRING (item_name
);
1814 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1817 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1819 descrip
= ENCODE_MENU_STRING (descrip
);
1820 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1822 #endif /* not HAVE_MULTILINGUAL_MENU */
1824 wv
= xmalloc_widget_value ();
1828 save_wv
->contents
= wv
;
1830 wv
->lname
= item_name
;
1831 if (!NILP (descrip
))
1834 /* The EMACS_INT cast avoids a warning. There's no problem
1835 as long as pointers have enough bits to hold small integers. */
1836 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1837 wv
->enabled
= !NILP (enable
);
1840 wv
->button_type
= BUTTON_TYPE_NONE
;
1841 else if (EQ (type
, QCradio
))
1842 wv
->button_type
= BUTTON_TYPE_RADIO
;
1843 else if (EQ (type
, QCtoggle
))
1844 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1848 wv
->selected
= !NILP (selected
);
1849 if (! STRINGP (help
))
1856 i
+= MENU_ITEMS_ITEM_LENGTH
;
1860 /* If we have just one "menu item"
1861 that was originally a button, return it by itself. */
1862 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1864 wv
= first_wv
->contents
;
1865 free_widget_value (first_wv
);
1872 /* Walk through the widget_value tree starting at FIRST_WV and update
1873 the char * pointers from the corresponding lisp values.
1874 We do this after building the whole tree, since GC may happen while the
1875 tree is constructed, and small strings are relocated. So we must wait
1876 until no GC can happen before storing pointers into lisp values. */
1878 update_submenu_strings (first_wv
)
1879 widget_value
*first_wv
;
1883 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1885 if (STRINGP (wv
->lname
))
1887 wv
->name
= SDATA (wv
->lname
);
1889 /* Ignore the @ that means "separate pane".
1890 This is a kludge, but this isn't worth more time. */
1891 if (wv
->value
== (char *)1)
1893 if (wv
->name
[0] == '@')
1899 if (STRINGP (wv
->lkey
))
1900 wv
->key
= SDATA (wv
->lkey
);
1903 update_submenu_strings (wv
->contents
);
1908 /* Recompute all the widgets of frame F, when the menu bar has been
1909 changed. Value is non-zero if widgets were updated. */
1912 update_frame_menubar (f
)
1916 return xg_update_frame_menubar (f
);
1918 struct x_output
*x
= f
->output_data
.x
;
1921 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1925 /* Save the size of the frame because the pane widget doesn't accept
1926 to resize itself. So force it. */
1927 columns
= FRAME_COLS (f
);
1928 rows
= FRAME_LINES (f
);
1930 /* Do the voodoo which means "I'm changing lots of things, don't try
1931 to refigure sizes until I'm done." */
1932 lw_refigure_widget (x
->column_widget
, False
);
1934 /* The order in which children are managed is the top to bottom
1935 order in which they are displayed in the paned window. First,
1936 remove the text-area widget. */
1937 XtUnmanageChild (x
->edit_widget
);
1939 /* Remove the menubar that is there now, and put up the menubar that
1941 XtManageChild (x
->menubar_widget
);
1942 XtMapWidget (x
->menubar_widget
);
1943 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1945 /* Re-manage the text-area widget, and then thrash the sizes. */
1946 XtManageChild (x
->edit_widget
);
1947 lw_refigure_widget (x
->column_widget
, True
);
1949 /* Force the pane widget to resize itself with the right values. */
1950 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1956 /* Set the contents of the menubar widgets of frame F.
1957 The argument FIRST_TIME is currently ignored;
1958 it is set the first time this is called, from initialize_frame_menubar. */
1961 set_frame_menubar (f
, first_time
, deep_p
)
1966 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1967 #ifdef USE_X_TOOLKIT
1971 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1973 int *submenu_start
, *submenu_end
;
1974 int *submenu_top_level_items
, *submenu_n_panes
;
1977 XSETFRAME (Vmenu_updating_frame
, f
);
1979 #ifdef USE_X_TOOLKIT
1980 if (f
->output_data
.x
->id
== 0)
1981 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1982 id
= f
->output_data
.x
->id
;
1985 if (! menubar_widget
)
1987 else if (pending_menu_activation
&& !deep_p
)
1989 /* Make the first call for any given frame always go deep. */
1990 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1993 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1994 f
->output_data
.x
->saved_menu_event
->type
= 0;
1998 /* If we have detached menus, we must update deep so detached menus
1999 also gets updated. */
2000 deep_p
= deep_p
|| xg_have_tear_offs ();
2005 /* Make a widget-value tree representing the entire menu trees. */
2007 struct buffer
*prev
= current_buffer
;
2009 int specpdl_count
= SPECPDL_INDEX ();
2010 int previous_menu_items_used
= f
->menu_bar_items_used
;
2011 Lisp_Object
*previous_items
2012 = (Lisp_Object
*) alloca (previous_menu_items_used
2013 * sizeof (Lisp_Object
));
2015 /* If we are making a new widget, its contents are empty,
2016 do always reinitialize them. */
2017 if (! menubar_widget
)
2018 previous_menu_items_used
= 0;
2020 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
2021 specbind (Qinhibit_quit
, Qt
);
2022 /* Don't let the debugger step into this code
2023 because it is not reentrant. */
2024 specbind (Qdebug_on_next_call
, Qnil
);
2026 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
2027 record_unwind_protect (unuse_menu_items
, Qnil
);
2028 if (NILP (Voverriding_local_map_menu_flag
))
2030 specbind (Qoverriding_terminal_local_map
, Qnil
);
2031 specbind (Qoverriding_local_map
, Qnil
);
2034 set_buffer_internal_1 (XBUFFER (buffer
));
2036 /* Run the Lucid hook. */
2037 safe_run_hooks (Qactivate_menubar_hook
);
2039 /* If it has changed current-menubar from previous value,
2040 really recompute the menubar from the value. */
2041 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2042 call0 (Qrecompute_lucid_menubar
);
2043 safe_run_hooks (Qmenu_bar_update_hook
);
2044 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2046 items
= FRAME_MENU_BAR_ITEMS (f
);
2048 /* Save the frame's previous menu bar contents data. */
2049 if (previous_menu_items_used
)
2050 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2051 previous_menu_items_used
* sizeof (Lisp_Object
));
2053 /* Fill in menu_items with the current menu bar contents.
2054 This can evaluate Lisp code. */
2055 menu_items
= f
->menu_bar_vector
;
2056 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2057 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2058 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2059 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2060 submenu_top_level_items
2061 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2063 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2065 Lisp_Object key
, string
, maps
;
2069 key
= XVECTOR (items
)->contents
[i
];
2070 string
= XVECTOR (items
)->contents
[i
+ 1];
2071 maps
= XVECTOR (items
)->contents
[i
+ 2];
2075 submenu_start
[i
] = menu_items_used
;
2077 menu_items_n_panes
= 0;
2078 submenu_top_level_items
[i
]
2079 = parse_single_submenu (key
, string
, maps
);
2080 submenu_n_panes
[i
] = menu_items_n_panes
;
2082 submenu_end
[i
] = menu_items_used
;
2085 finish_menu_items ();
2087 /* Convert menu_items into widget_value trees
2088 to display the menu. This cannot evaluate Lisp code. */
2090 wv
= xmalloc_widget_value ();
2091 wv
->name
= "menubar";
2094 wv
->button_type
= BUTTON_TYPE_NONE
;
2098 for (i
= 0; i
< last_i
; i
+= 4)
2100 menu_items_n_panes
= submenu_n_panes
[i
];
2101 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2102 submenu_top_level_items
[i
]);
2106 first_wv
->contents
= wv
;
2107 /* Don't set wv->name here; GC during the loop might relocate it. */
2109 wv
->button_type
= BUTTON_TYPE_NONE
;
2113 set_buffer_internal_1 (prev
);
2114 unbind_to (specpdl_count
, Qnil
);
2116 /* If there has been no change in the Lisp-level contents
2117 of the menu bar, skip redisplaying it. Just exit. */
2119 for (i
= 0; i
< previous_menu_items_used
; i
++)
2120 if (menu_items_used
== i
2121 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2123 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2125 free_menubar_widget_value_tree (first_wv
);
2126 discard_menu_items ();
2131 /* Now GC cannot happen during the lifetime of the widget_value,
2132 so it's safe to store data from a Lisp_String. */
2133 wv
= first_wv
->contents
;
2134 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2137 string
= XVECTOR (items
)->contents
[i
+ 1];
2140 wv
->name
= (char *) SDATA (string
);
2141 update_submenu_strings (wv
->contents
);
2145 f
->menu_bar_vector
= menu_items
;
2146 f
->menu_bar_items_used
= menu_items_used
;
2147 discard_menu_items ();
2151 /* Make a widget-value tree containing
2152 just the top level menu bar strings. */
2154 wv
= xmalloc_widget_value ();
2155 wv
->name
= "menubar";
2158 wv
->button_type
= BUTTON_TYPE_NONE
;
2162 items
= FRAME_MENU_BAR_ITEMS (f
);
2163 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2167 string
= XVECTOR (items
)->contents
[i
+ 1];
2171 wv
= xmalloc_widget_value ();
2172 wv
->name
= (char *) SDATA (string
);
2175 wv
->button_type
= BUTTON_TYPE_NONE
;
2177 /* This prevents lwlib from assuming this
2178 menu item is really supposed to be empty. */
2179 /* The EMACS_INT cast avoids a warning.
2180 This value just has to be different from small integers. */
2181 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2186 first_wv
->contents
= wv
;
2190 /* Forget what we thought we knew about what is in the
2191 detailed contents of the menu bar menus.
2192 Changing the top level always destroys the contents. */
2193 f
->menu_bar_items_used
= 0;
2196 /* Create or update the menu bar widget. */
2201 xg_crazy_callback_abort
= 1;
2204 /* The fourth arg is DEEP_P, which says to consider the entire
2205 menu trees we supply, rather than just the menu bar item names. */
2206 xg_modify_menubar_widgets (menubar_widget
,
2210 G_CALLBACK (menubar_selection_callback
),
2211 G_CALLBACK (popup_deactivate_callback
),
2212 G_CALLBACK (menu_highlight_callback
));
2216 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2219 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2220 G_CALLBACK (menubar_selection_callback
),
2221 G_CALLBACK (popup_deactivate_callback
),
2222 G_CALLBACK (menu_highlight_callback
));
2224 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2228 #else /* not USE_GTK */
2231 /* Disable resizing (done for Motif!) */
2232 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2234 /* The third arg is DEEP_P, which says to consider the entire
2235 menu trees we supply, rather than just the menu bar item names. */
2236 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2238 /* Re-enable the edit widget to resize. */
2239 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2243 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
2244 XtTranslations override
= XtParseTranslationTable (menuOverride
);
2246 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2247 f
->output_data
.x
->column_widget
,
2249 popup_activate_callback
,
2250 menubar_selection_callback
,
2251 popup_deactivate_callback
,
2252 menu_highlight_callback
);
2253 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2255 /* Make menu pop down on C-g. */
2256 XtOverrideTranslations (menubar_widget
, override
);
2261 = (f
->output_data
.x
->menubar_widget
2262 ? (f
->output_data
.x
->menubar_widget
->core
.height
2263 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2266 #if 0 /* Experimentally, we now get the right results
2267 for -geometry -0-0 without this. 24 Aug 96, rms. */
2269 if (FRAME_EXTERNAL_MENU_BAR (f
))
2272 XtVaGetValues (f
->output_data
.x
->column_widget
,
2273 XtNinternalBorderWidth
, &ibw
, NULL
);
2274 menubar_size
+= ibw
;
2276 #endif /* USE_LUCID */
2279 f
->output_data
.x
->menubar_height
= menubar_size
;
2281 #endif /* not USE_GTK */
2283 free_menubar_widget_value_tree (first_wv
);
2284 update_frame_menubar (f
);
2287 xg_crazy_callback_abort
= 0;
2293 /* Called from Fx_create_frame to create the initial menubar of a frame
2294 before it is mapped, so that the window is mapped with the menubar already
2295 there instead of us tacking it on later and thrashing the window after it
2299 initialize_frame_menubar (f
)
2302 /* This function is called before the first chance to redisplay
2303 the frame. It has to be, so the frame will have the right size. */
2304 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2305 set_frame_menubar (f
, 1, 1);
2309 /* Get rid of the menu bar of frame F, and free its storage.
2310 This is used when deleting a frame, and when turning off the menu bar.
2311 For GTK this function is in gtkutil.c. */
2315 free_frame_menubar (f
)
2318 Widget menubar_widget
;
2320 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2322 f
->output_data
.x
->menubar_height
= 0;
2327 /* Removing the menu bar magically changes the shell widget's x
2328 and y position of (0, 0) which, when the menu bar is turned
2329 on again, leads to pull-down menuss appearing in strange
2330 positions near the upper-left corner of the display. This
2331 happens only with some window managers like twm and ctwm,
2332 but not with other like Motif's mwm or kwm, because the
2333 latter generate ConfigureNotify events when the menu bar
2334 is switched off, which fixes the shell position. */
2335 Position x0
, y0
, x1
, y1
;
2341 if (f
->output_data
.x
->widget
)
2342 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2345 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2346 f
->output_data
.x
->menubar_widget
= NULL
;
2349 if (f
->output_data
.x
->widget
)
2351 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2352 if (x1
== 0 && y1
== 0)
2353 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2360 #endif /* not USE_GTK */
2362 #endif /* USE_X_TOOLKIT || USE_GTK */
2364 /* xmenu_show actually displays a menu using the panes and items in menu_items
2365 and returns the value selected from it.
2366 There are two versions of xmenu_show, one for Xt and one for Xlib.
2367 Both assume input is blocked by the caller. */
2369 /* F is the frame the menu is for.
2370 X and Y are the frame-relative specified position,
2371 relative to the inside upper left corner of the frame F.
2372 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2373 KEYMAPS is 1 if this menu was specified with keymaps;
2374 in that case, we return a list containing the chosen item's value
2375 and perhaps also the pane's prefix.
2376 TITLE is the specified menu title.
2377 ERROR is a place to store an error message string in case of failure.
2378 (We return nil on failure, but the value doesn't actually matter.) */
2380 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2382 /* The item selected in the popup menu. */
2383 static Lisp_Object
*volatile menu_item_selection
;
2387 /* Used when position a popup menu. See menu_position_func and
2388 create_and_show_popup_menu below. */
2389 struct next_popup_x_y
2396 /* The menu position function to use if we are not putting a popup
2397 menu where the pointer is.
2398 MENU is the menu to pop up.
2399 X and Y shall on exit contain x/y where the menu shall pop up.
2400 PUSH_IN is not documented in the GTK manual.
2401 USER_DATA is any data passed in when calling gtk_menu_popup.
2402 Here it points to a struct next_popup_x_y where the coordinates
2403 to store in *X and *Y are as well as the frame for the popup.
2405 Here only X and Y are used. */
2407 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2414 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2416 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2417 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2422 /* Check if there is room for the menu. If not, adjust x/y so that
2423 the menu is fully visible. */
2424 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2425 if (data
->x
+ req
.width
> disp_width
)
2426 *x
-= data
->x
+ req
.width
- disp_width
;
2427 if (data
->y
+ req
.height
> disp_height
)
2428 *y
-= data
->y
+ req
.height
- disp_height
;
2432 popup_selection_callback (widget
, client_data
)
2434 gpointer client_data
;
2436 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2438 if (xg_crazy_callback_abort
) return;
2439 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2446 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
2448 popup_activated_flag
= 0;
2450 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
2455 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2457 menu_item_selection will be set to the selection. */
2459 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2461 widget_value
*first_wv
;
2468 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2469 struct next_popup_x_y popup_x_y
;
2470 int specpdl_count
= SPECPDL_INDEX ();
2472 xg_crazy_callback_abort
= 1;
2473 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2474 G_CALLBACK (popup_selection_callback
),
2475 G_CALLBACK (popup_deactivate_callback
),
2476 G_CALLBACK (menu_highlight_callback
));
2477 xg_crazy_callback_abort
= 0;
2481 /* Not invoked by a click. pop up at x/y. */
2482 pos_func
= menu_position_func
;
2484 /* Adjust coordinates to be root-window-relative. */
2485 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2486 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2492 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
2496 for (i
= 0; i
< 5; i
++)
2497 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2501 /* Display the menu. */
2502 gtk_widget_show_all (menu
);
2503 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2505 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2507 if (GTK_WIDGET_MAPPED (menu
))
2509 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2510 two. show_help_echo uses this to detect popup menus. */
2511 popup_activated_flag
= 1;
2512 /* Process events that apply to the menu. */
2513 popup_widget_loop (1, menu
);
2516 unbind_to (specpdl_count
, Qnil
);
2518 /* Must reset this manually because the button release event is not passed
2519 to Emacs event loop. */
2520 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2523 #else /* not USE_GTK */
2525 /* We need a unique id for each widget handled by the Lucid Widget
2528 For the main windows, and popup menus, we use this counter,
2529 which we increment each time after use. This starts from 1<<16.
2531 For menu bars, we use numbers starting at 0, counted in
2532 next_menubar_widget_id. */
2533 LWLIB_ID widget_id_tick
;
2536 popup_selection_callback (widget
, id
, client_data
)
2539 XtPointer client_data
;
2541 menu_item_selection
= (Lisp_Object
*) client_data
;
2544 /* ARG is the LWLIB ID of the dialog box, represented
2545 as a Lisp object as (HIGHPART . LOWPART). */
2551 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2552 | XINT (XCDR (arg
)));
2555 lw_destroy_all_widgets (id
);
2557 popup_activated_flag
= 0;
2562 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2564 menu_item_selection will be set to the selection. */
2566 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2568 widget_value
*first_wv
;
2576 XButtonPressedEvent dummy
;
2580 menu_id
= widget_id_tick
++;
2581 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2582 f
->output_data
.x
->widget
, 1, 0,
2583 popup_selection_callback
,
2584 popup_deactivate_callback
,
2585 menu_highlight_callback
);
2587 dummy
.type
= ButtonPress
;
2589 dummy
.send_event
= 0;
2590 dummy
.display
= FRAME_X_DISPLAY (f
);
2591 dummy
.time
= CurrentTime
;
2592 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2593 dummy
.window
= dummy
.root
;
2594 dummy
.subwindow
= dummy
.root
;
2598 /* Adjust coordinates to be root-window-relative. */
2599 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2600 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2607 for (i
= 0; i
< 5; i
++)
2608 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2611 /* Don't allow any geometry request from the user. */
2612 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2613 XtSetValues (menu
, av
, ac
);
2615 /* Display the menu. */
2616 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2617 popup_activated_flag
= 1;
2620 int fact
= 4 * sizeof (LWLIB_ID
);
2621 int specpdl_count
= SPECPDL_INDEX ();
2622 record_unwind_protect (pop_down_menu
,
2623 Fcons (make_number (menu_id
>> (fact
)),
2624 make_number (menu_id
& ~(-1 << (fact
)))));
2626 /* Process events that apply to the menu. */
2627 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
2629 unbind_to (specpdl_count
, Qnil
);
2633 #endif /* not USE_GTK */
2636 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2646 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2647 widget_value
**submenu_stack
2648 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2649 Lisp_Object
*subprefix_stack
2650 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2651 int submenu_depth
= 0;
2657 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2659 *error
= "Empty menu";
2663 /* Create a tree of widget_value objects
2664 representing the panes and their items. */
2665 wv
= xmalloc_widget_value ();
2669 wv
->button_type
= BUTTON_TYPE_NONE
;
2674 /* Loop over all panes and items, filling in the tree. */
2676 while (i
< menu_items_used
)
2678 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2680 submenu_stack
[submenu_depth
++] = save_wv
;
2686 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2689 save_wv
= submenu_stack
[--submenu_depth
];
2693 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2694 && submenu_depth
!= 0)
2695 i
+= MENU_ITEMS_PANE_LENGTH
;
2696 /* Ignore a nil in the item list.
2697 It's meaningful only for dialog boxes. */
2698 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2700 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2702 /* Create a new pane. */
2703 Lisp_Object pane_name
, prefix
;
2706 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2707 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2709 #ifndef HAVE_MULTILINGUAL_MENU
2710 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2712 pane_name
= ENCODE_MENU_STRING (pane_name
);
2713 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2716 pane_string
= (NILP (pane_name
)
2717 ? "" : (char *) SDATA (pane_name
));
2718 /* If there is just one top-level pane, put all its items directly
2719 under the top-level menu. */
2720 if (menu_items_n_panes
== 1)
2723 /* If the pane has a meaningful name,
2724 make the pane a top-level menu item
2725 with its items as a submenu beneath it. */
2726 if (!keymaps
&& strcmp (pane_string
, ""))
2728 wv
= xmalloc_widget_value ();
2732 first_wv
->contents
= wv
;
2733 wv
->name
= pane_string
;
2734 if (keymaps
&& !NILP (prefix
))
2738 wv
->button_type
= BUTTON_TYPE_NONE
;
2743 else if (first_pane
)
2749 i
+= MENU_ITEMS_PANE_LENGTH
;
2753 /* Create a new item within current pane. */
2754 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2755 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2756 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2757 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2758 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2759 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2760 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2761 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2763 #ifndef HAVE_MULTILINGUAL_MENU
2764 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2766 item_name
= ENCODE_MENU_STRING (item_name
);
2767 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2770 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2772 descrip
= ENCODE_MENU_STRING (descrip
);
2773 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2775 #endif /* not HAVE_MULTILINGUAL_MENU */
2777 wv
= xmalloc_widget_value ();
2781 save_wv
->contents
= wv
;
2782 wv
->name
= (char *) SDATA (item_name
);
2783 if (!NILP (descrip
))
2784 wv
->key
= (char *) SDATA (descrip
);
2786 /* If this item has a null value,
2787 make the call_data null so that it won't display a box
2788 when the mouse is on it. */
2790 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2791 wv
->enabled
= !NILP (enable
);
2794 wv
->button_type
= BUTTON_TYPE_NONE
;
2795 else if (EQ (type
, QCtoggle
))
2796 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2797 else if (EQ (type
, QCradio
))
2798 wv
->button_type
= BUTTON_TYPE_RADIO
;
2802 wv
->selected
= !NILP (selected
);
2804 if (! STRINGP (help
))
2811 i
+= MENU_ITEMS_ITEM_LENGTH
;
2815 /* Deal with the title, if it is non-nil. */
2818 widget_value
*wv_title
= xmalloc_widget_value ();
2819 widget_value
*wv_sep1
= xmalloc_widget_value ();
2820 widget_value
*wv_sep2
= xmalloc_widget_value ();
2822 wv_sep2
->name
= "--";
2823 wv_sep2
->next
= first_wv
->contents
;
2824 wv_sep2
->help
= Qnil
;
2826 wv_sep1
->name
= "--";
2827 wv_sep1
->next
= wv_sep2
;
2828 wv_sep1
->help
= Qnil
;
2830 #ifndef HAVE_MULTILINGUAL_MENU
2831 if (STRING_MULTIBYTE (title
))
2832 title
= ENCODE_MENU_STRING (title
);
2835 wv_title
->name
= (char *) SDATA (title
);
2836 wv_title
->enabled
= TRUE
;
2837 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2838 wv_title
->next
= wv_sep1
;
2839 wv_title
->help
= Qnil
;
2840 first_wv
->contents
= wv_title
;
2843 /* No selection has been chosen yet. */
2844 menu_item_selection
= 0;
2846 /* Actually create and show the menu until popped down. */
2847 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2849 /* Free the widget_value objects we used to specify the contents. */
2850 free_menubar_widget_value_tree (first_wv
);
2852 /* Find the selected item, and its pane, to return
2853 the proper value. */
2854 if (menu_item_selection
!= 0)
2856 Lisp_Object prefix
, entry
;
2858 prefix
= entry
= Qnil
;
2860 while (i
< menu_items_used
)
2862 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2864 subprefix_stack
[submenu_depth
++] = prefix
;
2868 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2870 prefix
= subprefix_stack
[--submenu_depth
];
2873 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2876 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2877 i
+= MENU_ITEMS_PANE_LENGTH
;
2879 /* Ignore a nil in the item list.
2880 It's meaningful only for dialog boxes. */
2881 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2886 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2887 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2893 entry
= Fcons (entry
, Qnil
);
2895 entry
= Fcons (prefix
, entry
);
2896 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2897 if (!NILP (subprefix_stack
[j
]))
2898 entry
= Fcons (subprefix_stack
[j
], entry
);
2902 i
+= MENU_ITEMS_ITEM_LENGTH
;
2906 else if (!for_click
)
2907 /* Make "Cancel" equivalent to C-g. */
2908 Fsignal (Qquit
, Qnil
);
2915 dialog_selection_callback (widget
, client_data
)
2917 gpointer client_data
;
2919 /* The EMACS_INT cast avoids a warning. There's no problem
2920 as long as pointers have enough bits to hold small integers. */
2921 if ((int) (EMACS_INT
) client_data
!= -1)
2922 menu_item_selection
= (Lisp_Object
*) client_data
;
2924 popup_activated_flag
= 0;
2927 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2929 menu_item_selection will be set to the selection. */
2931 create_and_show_dialog (f
, first_wv
)
2933 widget_value
*first_wv
;
2937 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2938 G_CALLBACK (dialog_selection_callback
),
2939 G_CALLBACK (popup_deactivate_callback
),
2944 int specpdl_count
= SPECPDL_INDEX ();
2945 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2947 /* Display the menu. */
2948 gtk_widget_show_all (menu
);
2950 /* Process events that apply to the menu. */
2951 popup_widget_loop (1, menu
);
2953 unbind_to (specpdl_count
, Qnil
);
2957 #else /* not USE_GTK */
2959 dialog_selection_callback (widget
, id
, client_data
)
2962 XtPointer client_data
;
2964 /* The EMACS_INT cast avoids a warning. There's no problem
2965 as long as pointers have enough bits to hold small integers. */
2966 if ((int) (EMACS_INT
) client_data
!= -1)
2967 menu_item_selection
= (Lisp_Object
*) client_data
;
2970 lw_destroy_all_widgets (id
);
2972 popup_activated_flag
= 0;
2976 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2978 menu_item_selection will be set to the selection. */
2980 create_and_show_dialog (f
, first_wv
)
2982 widget_value
*first_wv
;
2986 dialog_id
= widget_id_tick
++;
2987 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2988 f
->output_data
.x
->widget
, 1, 0,
2989 dialog_selection_callback
, 0, 0);
2990 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2992 /* Display the dialog box. */
2993 lw_pop_up_all_widgets (dialog_id
);
2994 popup_activated_flag
= 1;
2996 /* Process events that apply to the dialog box.
2997 Also handle timers. */
2999 int count
= SPECPDL_INDEX ();
3000 int fact
= 4 * sizeof (LWLIB_ID
);
3002 /* xdialog_show_unwind is responsible for popping the dialog box down. */
3003 record_unwind_protect (pop_down_menu
,
3004 Fcons (make_number (dialog_id
>> (fact
)),
3005 make_number (dialog_id
& ~(-1 << (fact
)))));
3007 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
3010 unbind_to (count
, Qnil
);
3014 #endif /* not USE_GTK */
3016 static char * button_names
[] = {
3017 "button1", "button2", "button3", "button4", "button5",
3018 "button6", "button7", "button8", "button9", "button10" };
3021 xdialog_show (f
, keymaps
, title
, error
)
3027 int i
, nb_buttons
=0;
3028 char dialog_name
[6];
3030 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
3032 /* Number of elements seen so far, before boundary. */
3034 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
3035 int boundary_seen
= 0;
3039 if (menu_items_n_panes
> 1)
3041 *error
= "Multiple panes in dialog box";
3045 /* Create a tree of widget_value objects
3046 representing the text label and buttons. */
3048 Lisp_Object pane_name
, prefix
;
3050 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
3051 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
3052 pane_string
= (NILP (pane_name
)
3053 ? "" : (char *) SDATA (pane_name
));
3054 prev_wv
= xmalloc_widget_value ();
3055 prev_wv
->value
= pane_string
;
3056 if (keymaps
&& !NILP (prefix
))
3058 prev_wv
->enabled
= 1;
3059 prev_wv
->name
= "message";
3060 prev_wv
->help
= Qnil
;
3063 /* Loop over all panes and items, filling in the tree. */
3064 i
= MENU_ITEMS_PANE_LENGTH
;
3065 while (i
< menu_items_used
)
3068 /* Create a new item within current pane. */
3069 Lisp_Object item_name
, enable
, descrip
;
3070 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3071 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3073 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3075 if (NILP (item_name
))
3077 free_menubar_widget_value_tree (first_wv
);
3078 *error
= "Submenu in dialog items";
3081 if (EQ (item_name
, Qquote
))
3083 /* This is the boundary between left-side elts
3084 and right-side elts. Stop incrementing right_count. */
3089 if (nb_buttons
>= 9)
3091 free_menubar_widget_value_tree (first_wv
);
3092 *error
= "Too many dialog items";
3096 wv
= xmalloc_widget_value ();
3098 wv
->name
= (char *) button_names
[nb_buttons
];
3099 if (!NILP (descrip
))
3100 wv
->key
= (char *) SDATA (descrip
);
3101 wv
->value
= (char *) SDATA (item_name
);
3102 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3103 wv
->enabled
= !NILP (enable
);
3107 if (! boundary_seen
)
3111 i
+= MENU_ITEMS_ITEM_LENGTH
;
3114 /* If the boundary was not specified,
3115 by default put half on the left and half on the right. */
3116 if (! boundary_seen
)
3117 left_count
= nb_buttons
- nb_buttons
/ 2;
3119 wv
= xmalloc_widget_value ();
3120 wv
->name
= dialog_name
;
3122 /* Dialog boxes use a really stupid name encoding
3123 which specifies how many buttons to use
3124 and how many buttons are on the right.
3125 The Q means something also. */
3126 dialog_name
[0] = 'Q';
3127 dialog_name
[1] = '0' + nb_buttons
;
3128 dialog_name
[2] = 'B';
3129 dialog_name
[3] = 'R';
3130 /* Number of buttons to put on the right. */
3131 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3133 wv
->contents
= first_wv
;
3137 /* No selection has been chosen yet. */
3138 menu_item_selection
= 0;
3140 /* Actually create and show the dialog. */
3141 create_and_show_dialog (f
, first_wv
);
3143 /* Free the widget_value objects we used to specify the contents. */
3144 free_menubar_widget_value_tree (first_wv
);
3146 /* Find the selected item, and its pane, to return
3147 the proper value. */
3148 if (menu_item_selection
!= 0)
3154 while (i
< menu_items_used
)
3158 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3161 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3162 i
+= MENU_ITEMS_PANE_LENGTH
;
3164 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3166 /* This is the boundary between left-side elts and
3173 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3174 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3178 entry
= Fcons (entry
, Qnil
);
3180 entry
= Fcons (prefix
, entry
);
3184 i
+= MENU_ITEMS_ITEM_LENGTH
;
3189 /* Make "Cancel" equivalent to C-g. */
3190 Fsignal (Qquit
, Qnil
);
3195 #else /* not USE_X_TOOLKIT && not USE_GTK */
3197 /* The frame of the last activated non-toolkit menu bar.
3198 Used to generate menu help events. */
3200 static struct frame
*menu_help_frame
;
3203 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3205 PANE is the pane number, and ITEM is the menu item number in
3206 the menu (currently not used).
3208 This cannot be done with generating a HELP_EVENT because
3209 XMenuActivate contains a loop that doesn't let Emacs process
3213 menu_help_callback (help_string
, pane
, item
)
3217 extern Lisp_Object Qmenu_item
;
3218 Lisp_Object
*first_item
;
3219 Lisp_Object pane_name
;
3220 Lisp_Object menu_object
;
3222 first_item
= XVECTOR (menu_items
)->contents
;
3223 if (EQ (first_item
[0], Qt
))
3224 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3225 else if (EQ (first_item
[0], Qquote
))
3226 /* This shouldn't happen, see xmenu_show. */
3227 pane_name
= empty_string
;
3229 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3231 /* (menu-item MENU-NAME PANE-NUMBER) */
3232 menu_object
= Fcons (Qmenu_item
,
3234 Fcons (make_number (pane
), Qnil
)));
3235 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3236 Qnil
, menu_object
, make_number (item
), 1);
3243 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
3244 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
3246 FRAME_PTR f
= p1
->pointer
;
3247 XMenu
*menu
= p2
->pointer
;
3251 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
3252 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
3254 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3256 #ifdef HAVE_X_WINDOWS
3257 /* Assume the mouse has moved out of the X window.
3258 If it has actually moved in, we will get an EnterNotify. */
3259 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3261 /* State that no mouse buttons are now held.
3262 (The oldXMenu code doesn't track this info for us.)
3263 That is not necessarily true, but the fiction leads to reasonable
3264 results, and it is a pain to ask which are actually held now. */
3265 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3267 #endif /* HAVE_X_WINDOWS */
3276 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3286 int pane
, selidx
, lpane
, status
;
3287 Lisp_Object entry
, pane_prefix
;
3289 int ulx
, uly
, width
, height
;
3290 int dispwidth
, dispheight
;
3291 int i
, j
, lines
, maxlines
;
3294 unsigned int dummy_uint
;
3295 int specpdl_count
= SPECPDL_INDEX ();
3298 if (menu_items_n_panes
== 0)
3301 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3303 *error
= "Empty menu";
3307 /* Figure out which root window F is on. */
3308 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3309 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3310 &dummy_uint
, &dummy_uint
);
3312 /* Make the menu on that window. */
3313 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3316 *error
= "Can't create menu";
3320 #ifdef HAVE_X_WINDOWS
3321 /* Adjust coordinates to relative to the outer (window manager) window. */
3322 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
3323 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
3324 #endif /* HAVE_X_WINDOWS */
3326 /* Adjust coordinates to be root-window-relative. */
3330 /* Create all the necessary panes and their items. */
3331 maxlines
= lines
= i
= 0;
3332 while (i
< menu_items_used
)
3334 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3336 /* Create a new pane. */
3337 Lisp_Object pane_name
, prefix
;
3340 maxlines
= max (maxlines
, lines
);
3342 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3343 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3344 pane_string
= (NILP (pane_name
)
3345 ? "" : (char *) SDATA (pane_name
));
3346 if (keymaps
&& !NILP (prefix
))
3349 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3350 if (lpane
== XM_FAILURE
)
3352 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3353 *error
= "Can't create pane";
3356 i
+= MENU_ITEMS_PANE_LENGTH
;
3358 /* Find the width of the widest item in this pane. */
3361 while (j
< menu_items_used
)
3364 item
= XVECTOR (menu_items
)->contents
[j
];
3372 width
= SBYTES (item
);
3373 if (width
> maxwidth
)
3376 j
+= MENU_ITEMS_ITEM_LENGTH
;
3379 /* Ignore a nil in the item list.
3380 It's meaningful only for dialog boxes. */
3381 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3385 /* Create a new item within current pane. */
3386 Lisp_Object item_name
, enable
, descrip
, help
;
3387 unsigned char *item_data
;
3390 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3391 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3393 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3394 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3395 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3397 if (!NILP (descrip
))
3399 int gap
= maxwidth
- SBYTES (item_name
);
3402 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3403 item_name
= concat2 (item_name
, spacer
);
3404 item_name
= concat2 (item_name
, descrip
);
3405 item_data
= SDATA (item_name
);
3407 /* if alloca is fast, use that to make the space,
3408 to reduce gc needs. */
3410 = (unsigned char *) alloca (maxwidth
3411 + SBYTES (descrip
) + 1);
3412 bcopy (SDATA (item_name
), item_data
,
3413 SBYTES (item_name
));
3414 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3416 bcopy (SDATA (descrip
), item_data
+ j
,
3418 item_data
[j
+ SBYTES (descrip
)] = 0;
3422 item_data
= SDATA (item_name
);
3424 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3425 menu
, lpane
, 0, item_data
,
3426 !NILP (enable
), help_string
)
3429 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3430 *error
= "Can't add selection to menu";
3433 i
+= MENU_ITEMS_ITEM_LENGTH
;
3438 maxlines
= max (maxlines
, lines
);
3440 /* All set and ready to fly. */
3441 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3442 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3443 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3444 x
= min (x
, dispwidth
);
3445 y
= min (y
, dispheight
);
3448 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3449 &ulx
, &uly
, &width
, &height
);
3450 if (ulx
+width
> dispwidth
)
3452 x
-= (ulx
+ width
) - dispwidth
;
3453 ulx
= dispwidth
- width
;
3455 if (uly
+height
> dispheight
)
3457 y
-= (uly
+ height
) - dispheight
;
3458 uly
= dispheight
- height
;
3460 if (ulx
< 0) x
-= ulx
;
3461 if (uly
< 0) y
-= uly
;
3465 /* If position was not given by a mouse click, adjust so upper left
3466 corner of the menu as a whole ends up at given coordinates. This
3467 is what x-popup-menu says in its documentation. */
3469 y
+= 1.5*height
/(maxlines
+2);
3472 XMenuSetAEQ (menu
, TRUE
);
3473 XMenuSetFreeze (menu
, TRUE
);
3477 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3480 record_unwind_protect (pop_down_menu
,
3481 Fcons (make_save_value (f
, 0),
3482 make_save_value (menu
, 0)));
3484 /* Help display under X won't work because XMenuActivate contains
3485 a loop that doesn't give Emacs a chance to process it. */
3486 menu_help_frame
= f
;
3487 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3488 x
, y
, ButtonReleaseMask
, &datap
,
3489 menu_help_callback
);
3495 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3498 /* Find the item number SELIDX in pane number PANE. */
3500 while (i
< menu_items_used
)
3502 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3506 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3508 i
+= MENU_ITEMS_PANE_LENGTH
;
3517 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3520 entry
= Fcons (entry
, Qnil
);
3521 if (!NILP (pane_prefix
))
3522 entry
= Fcons (pane_prefix
, entry
);
3528 i
+= MENU_ITEMS_ITEM_LENGTH
;
3534 *error
= "Can't activate menu";
3539 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3540 the menu was invoked with a mouse event as POSITION). */
3542 Fsignal (Qquit
, Qnil
);
3547 unbind_to (specpdl_count
, Qnil
);
3552 #endif /* not USE_X_TOOLKIT */
3554 #endif /* HAVE_MENUS */
3559 staticpro (&menu_items
);
3561 menu_items_inuse
= Qnil
;
3563 Qdebug_on_next_call
= intern ("debug-on-next-call");
3564 staticpro (&Qdebug_on_next_call
);
3566 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3567 doc
: /* Frame for which we are updating a menu.
3568 The enable predicate for a menu command should check this variable. */);
3569 Vmenu_updating_frame
= Qnil
;
3571 #ifdef USE_X_TOOLKIT
3572 widget_id_tick
= (1<<16);
3573 next_menubar_widget_id
= 1;
3576 defsubr (&Sx_popup_menu
);
3578 defsubr (&Sx_popup_dialog
);
3582 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3583 (do not change this comment) */