1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 88, 93, 94, 96, 99, 2000, 2001
3 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"
57 /* This may include sys/types.h, and that somehow loses
58 if this is not done before the other system files. */
62 /* Load sys/types.h if not already loaded.
63 In some systems loading it twice is suicidal. */
65 #include <sys/types.h>
68 #include "dispextern.h"
71 #undef HAVE_MULTILINGUAL_MENU
75 #include <X11/IntrinsicP.h>
76 #include <X11/CoreP.h>
77 #include <X11/StringDefs.h>
78 #include <X11/Shell.h>
80 #include <X11/Xaw/Paned.h>
81 #endif /* USE_LUCID */
82 #include "../lwlib/lwlib.h"
83 #else /* not USE_X_TOOLKIT */
85 #include "../oldXMenu/XMenu.h"
87 #endif /* not USE_X_TOOLKIT */
88 #endif /* HAVE_X_WINDOWS */
95 Lisp_Object Vmenu_updating_frame
;
97 Lisp_Object Qdebug_on_next_call
;
99 extern Lisp_Object Qmenu_bar
;
100 extern Lisp_Object Qmouse_click
, Qevent_kind
;
102 extern Lisp_Object QCtoggle
, QCradio
;
104 extern Lisp_Object Voverriding_local_map
;
105 extern Lisp_Object Voverriding_local_map_menu_flag
;
107 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
109 extern Lisp_Object Qmenu_bar_update_hook
;
112 extern void set_frame_menubar ();
113 extern XtAppContext Xt_app_con
;
115 static Lisp_Object
xdialog_show ();
116 static void popup_get_selection ();
118 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
121 #endif /* USE_X_TOOLKIT */
126 extern void set_frame_menubar ();
127 static Lisp_Object
xdialog_show ();
130 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
131 Lisp_Object
, Lisp_Object
, Lisp_Object
,
132 Lisp_Object
, Lisp_Object
));
133 static int update_frame_menubar
P_ ((struct frame
*));
134 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
135 Lisp_Object
, char **));
136 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
137 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
139 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
*,
141 static void list_of_panes
P_ ((Lisp_Object
));
142 static void list_of_items
P_ ((Lisp_Object
));
144 extern EMACS_TIME timer_check
P_ ((int));
146 /* This holds a Lisp vector that holds the results of decoding
147 the keymaps or alist-of-alists that specify a menu.
149 It describes the panes and items within the panes.
151 Each pane is described by 3 elements in the vector:
152 t, the pane name, the pane's prefix key.
153 Then follow the pane's items, with 5 elements per item:
154 the item string, the enable flag, the item's value,
155 the definition, and the equivalent keyboard key's description string.
157 In some cases, multiple levels of menus may be described.
158 A single vector slot containing nil indicates the start of a submenu.
159 A single vector slot containing lambda indicates the end of a submenu.
160 The submenu follows a menu item which is the way to reach the submenu.
162 A single vector slot containing quote indicates that the
163 following items should appear on the right of a dialog box.
165 Using a Lisp vector to hold this information while we decode it
166 takes care of protecting all the data from GC. */
168 #define MENU_ITEMS_PANE_NAME 1
169 #define MENU_ITEMS_PANE_PREFIX 2
170 #define MENU_ITEMS_PANE_LENGTH 3
174 MENU_ITEMS_ITEM_NAME
= 0,
175 MENU_ITEMS_ITEM_ENABLE
,
176 MENU_ITEMS_ITEM_VALUE
,
177 MENU_ITEMS_ITEM_EQUIV_KEY
,
178 MENU_ITEMS_ITEM_DEFINITION
,
179 MENU_ITEMS_ITEM_TYPE
,
180 MENU_ITEMS_ITEM_SELECTED
,
181 MENU_ITEMS_ITEM_HELP
,
182 MENU_ITEMS_ITEM_LENGTH
185 static Lisp_Object menu_items
;
187 /* If non-nil, means that the global vars defined here are already in use.
188 Used to detect cases where we try to re-enter this non-reentrant code. */
189 static Lisp_Object menu_items_inuse
;
191 /* Number of slots currently allocated in menu_items. */
192 static int menu_items_allocated
;
194 /* This is the index in menu_items of the first empty slot. */
195 static int menu_items_used
;
197 /* The number of panes currently recorded in menu_items,
198 excluding those within submenus. */
199 static int menu_items_n_panes
;
201 /* Current depth within submenus. */
202 static int menu_items_submenu_depth
;
204 /* Flag which when set indicates a dialog or menu has been posted by
205 Xt on behalf of one of the widget sets. */
206 static int popup_activated_flag
;
208 static int next_menubar_widget_id
;
210 /* This is set nonzero after the user activates the menu bar, and set
211 to zero again after the menu bars are redisplayed by prepare_menu_bar.
212 While it is nonzero, all calls to set_frame_menubar go deep.
214 I don't understand why this is needed, but it does seem to be
215 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
217 int pending_menu_activation
;
221 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
223 static struct frame
*
224 menubar_id_to_frame (id
)
227 Lisp_Object tail
, frame
;
230 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
233 if (!GC_FRAMEP (frame
))
236 if (!FRAME_WINDOW_P (f
))
238 if (f
->output_data
.x
->id
== id
)
246 /* Initialize the menu_items structure if we haven't already done so.
247 Also mark it as currently empty. */
252 if (NILP (menu_items
))
254 menu_items_allocated
= 60;
255 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
258 if (!NILP (menu_items_inuse
))
259 error ("Trying to use a menu from within a menu-entry");
260 menu_items_inuse
= Qt
;
262 menu_items_n_panes
= 0;
263 menu_items_submenu_depth
= 0;
266 /* Call at the end of generating the data in menu_items. */
274 unuse_menu_items (dummy
)
277 return menu_items_inuse
= Qnil
;
280 /* Call when finished using the data for the current menu
284 discard_menu_items ()
286 /* Free the structure if it is especially large.
287 Otherwise, hold on to it, to save time. */
288 if (menu_items_allocated
> 200)
291 menu_items_allocated
= 0;
293 xassert (NILP (menu_items_inuse
));
296 /* Make the menu_items vector twice as large. */
302 int old_size
= menu_items_allocated
;
305 menu_items_allocated
*= 2;
306 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
307 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
308 old_size
* sizeof (Lisp_Object
));
311 /* Begin a submenu. */
314 push_submenu_start ()
316 if (menu_items_used
+ 1 > menu_items_allocated
)
319 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
320 menu_items_submenu_depth
++;
328 if (menu_items_used
+ 1 > menu_items_allocated
)
331 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
332 menu_items_submenu_depth
--;
335 /* Indicate boundary between left and right. */
338 push_left_right_boundary ()
340 if (menu_items_used
+ 1 > menu_items_allocated
)
343 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
346 /* Start a new menu pane in menu_items.
347 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
350 push_menu_pane (name
, prefix_vec
)
351 Lisp_Object name
, prefix_vec
;
353 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
356 if (menu_items_submenu_depth
== 0)
357 menu_items_n_panes
++;
358 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
359 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
360 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
363 /* Push one menu item into the current pane. NAME is the string to
364 display. ENABLE if non-nil means this item can be selected. KEY
365 is the key generated by choosing this item, or nil if this item
366 doesn't really have a definition. DEF is the definition of this
367 item. EQUIV is the textual description of the keyboard equivalent
368 for this item (or nil if none). TYPE is the type of this menu
369 item, one of nil, `toggle' or `radio'. */
372 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
373 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
375 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
378 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
379 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
380 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
381 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
382 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
383 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
384 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
385 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
388 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
389 and generate menu panes for them in menu_items.
390 If NOTREAL is nonzero,
391 don't bother really computing whether an item is enabled. */
394 keymap_panes (keymaps
, nmaps
, notreal
)
395 Lisp_Object
*keymaps
;
403 /* Loop over the given keymaps, making a pane for each map.
404 But don't make a pane that is empty--ignore that map instead.
405 P is the number of panes we have made so far. */
406 for (mapno
= 0; mapno
< nmaps
; mapno
++)
407 single_keymap_panes (keymaps
[mapno
],
408 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
410 finish_menu_items ();
413 /* This is a recursive subroutine of keymap_panes.
414 It handles one keymap, KEYMAP.
415 The other arguments are passed along
416 or point to local variables of the previous function.
417 If NOTREAL is nonzero, only check for equivalent key bindings, don't
418 evaluate expressions in menu items and don't make any menu.
420 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
423 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
425 Lisp_Object pane_name
;
430 Lisp_Object pending_maps
= Qnil
;
431 Lisp_Object tail
, item
;
432 struct gcpro gcpro1
, gcpro2
;
438 push_menu_pane (pane_name
, prefix
);
441 /* Remember index for first item in this pane so we can go back and
442 add a prefix when (if) we see the first button. After that, notbuttons
443 is set to 0, to mark that we have seen a button and all non button
444 items need a prefix. */
445 notbuttons
= menu_items_used
;
448 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
450 GCPRO2 (keymap
, pending_maps
);
451 /* Look at each key binding, and if it is a menu item add it
455 single_menu_item (XCAR (item
), XCDR (item
),
456 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
457 else if (VECTORP (item
))
459 /* Loop over the char values represented in the vector. */
460 int len
= XVECTOR (item
)->size
;
462 for (c
= 0; c
< len
; c
++)
464 Lisp_Object character
;
465 XSETFASTINT (character
, c
);
466 single_menu_item (character
, XVECTOR (item
)->contents
[c
],
467 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
473 /* Process now any submenus which want to be panes at this level. */
474 while (!NILP (pending_maps
))
476 Lisp_Object elt
, eltcdr
, string
;
477 elt
= Fcar (pending_maps
);
479 string
= XCAR (eltcdr
);
480 /* We no longer discard the @ from the beginning of the string here.
481 Instead, we do this in xmenu_show. */
482 single_keymap_panes (Fcar (elt
), string
,
483 XCDR (eltcdr
), notreal
, maxdepth
- 1);
484 pending_maps
= Fcdr (pending_maps
);
488 /* This is a subroutine of single_keymap_panes that handles one
490 KEY is a key in a keymap and ITEM is its binding.
491 PENDING_MAPS_PTR points to a list of keymaps waiting to be made into
493 If NOTREAL is nonzero, only check for equivalent key bindings, don't
494 evaluate expressions in menu items and don't make any menu.
495 If we encounter submenus deeper than MAXDEPTH levels, ignore them.
496 NOTBUTTONS_PTR is only used when simulating toggle boxes and radio
497 buttons. It points to variable notbuttons in single_keymap_panes,
498 which keeps track of if we have seen a button in this menu or not. */
501 single_menu_item (key
, item
, pending_maps_ptr
, notreal
, maxdepth
,
503 Lisp_Object key
, item
;
504 Lisp_Object
*pending_maps_ptr
;
505 int maxdepth
, notreal
;
508 Lisp_Object map
, item_string
, enabled
;
509 struct gcpro gcpro1
, gcpro2
;
512 /* Parse the menu item and leave the result in item_properties. */
514 res
= parse_menu_item (item
, notreal
, 0);
517 return; /* Not a menu item. */
519 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
523 /* We don't want to make a menu, just traverse the keymaps to
524 precompute equivalent key bindings. */
526 single_keymap_panes (map
, Qnil
, key
, 1, maxdepth
- 1);
530 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
531 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
533 if (!NILP (map
) && SREF (item_string
, 0) == '@')
536 /* An enabled separate pane. Remember this to handle it later. */
537 *pending_maps_ptr
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
543 /* Simulate radio buttons and toggle boxes by putting a prefix in
546 Lisp_Object prefix
= Qnil
;
547 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
551 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
554 /* The first button. Line up previous items in this menu. */
556 int index
= *notbuttons_ptr
; /* Index for first item this menu. */
559 while (index
< menu_items_used
)
562 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
566 submenu
++; /* Skip sub menu. */
568 else if (EQ (tem
, Qlambda
))
571 submenu
--; /* End sub menu. */
573 else if (EQ (tem
, Qt
))
574 index
+= 3; /* Skip new pane marker. */
575 else if (EQ (tem
, Qquote
))
576 index
++; /* Skip a left, right divider. */
579 if (!submenu
&& SREF (tem
, 0) != '\0'
580 && SREF (tem
, 0) != '-')
581 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
582 = concat2 (build_string (" "), tem
);
583 index
+= MENU_ITEMS_ITEM_LENGTH
;
589 /* Calculate prefix, if any, for this item. */
590 if (EQ (type
, QCtoggle
))
591 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
592 else if (EQ (type
, QCradio
))
593 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
595 /* Not a button. If we have earlier buttons, then we need a prefix. */
596 else if (!*notbuttons_ptr
&& SREF (item_string
, 0) != '\0'
597 && SREF (item_string
, 0) != '-')
598 prefix
= build_string (" ");
601 item_string
= concat2 (prefix
, item_string
);
603 #endif /* not HAVE_BOXES */
605 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
607 /* Indicate visually that this is a submenu. */
608 item_string
= concat2 (item_string
, build_string (" >"));
611 push_menu_item (item_string
, enabled
, key
,
612 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
613 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
614 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
615 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
616 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
618 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
619 /* Display a submenu using the toolkit. */
620 if (! (NILP (map
) || NILP (enabled
)))
622 push_submenu_start ();
623 single_keymap_panes (map
, Qnil
, key
, 0, maxdepth
- 1);
629 /* Push all the panes and items of a menu described by the
630 alist-of-alists MENU.
631 This handles old-fashioned calls to x-popup-menu. */
641 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
643 Lisp_Object elt
, pane_name
, pane_data
;
645 pane_name
= Fcar (elt
);
646 CHECK_STRING (pane_name
);
647 push_menu_pane (pane_name
, Qnil
);
648 pane_data
= Fcdr (elt
);
649 CHECK_CONS (pane_data
);
650 list_of_items (pane_data
);
653 finish_menu_items ();
656 /* Push the items in a single pane defined by the alist PANE. */
662 Lisp_Object tail
, item
, item1
;
664 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
668 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
669 else if (NILP (item
))
670 push_left_right_boundary ();
675 CHECK_STRING (item1
);
676 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
681 #ifdef HAVE_X_WINDOWS
682 /* Return the mouse position in *X and *Y. The coordinates are window
683 relative for the edit window in frame F.
684 This is for Fx_popup_menu. The mouse_position_hook can not
685 be used for X, as it returns window relative coordinates
686 for the window where the mouse is in. This could be the menu bar,
687 the scroll bar or the edit window. Fx_popup_menu needs to be
688 sure it is the edit window. */
690 mouse_position_for_popup(f
, x
, y
)
695 Window root
, dummy_window
;
700 XQueryPointer (FRAME_X_DISPLAY (f
),
701 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
703 /* The root window which contains the pointer. */
706 /* Window pointer is on, not used */
709 /* The position on that root window. */
712 /* x/y in dummy_window coordinates, not used. */
715 /* Modifier keys and pointer buttons, about which
717 (unsigned int *) &dummy
);
721 /* xmenu_show expects window coordinates, not root window
722 coordinates. Translate. */
723 *x
-= f
->output_data
.x
->left_pos
724 + FRAME_OUTER_TO_INNER_DIFF_X (f
);
725 *y
-= f
->output_data
.x
->top_pos
726 + FRAME_OUTER_TO_INNER_DIFF_Y (f
);
729 #endif /* HAVE_X_WINDOWS */
731 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
732 doc
: /* Pop up a deck-of-cards menu and return user's selection.
733 POSITION is a position specification. This is either a mouse button event
734 or a list ((XOFFSET YOFFSET) WINDOW)
735 where XOFFSET and YOFFSET are positions in pixels from the top left
736 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)
737 This controls the position of the center of the first line
738 in the first pane of the menu, not the top left of the menu as a whole.
739 If POSITION is t, it means to use the current mouse position.
741 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
742 The menu items come from key bindings that have a menu string as well as
743 a definition; actually, the "definition" in such a key binding looks like
744 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
745 the keymap as a top-level element.
747 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
748 Otherwise, REAL-DEFINITION should be a valid key binding definition.
750 You can also use a list of keymaps as MENU.
751 Then each keymap makes a separate pane.
752 When MENU is a keymap or a list of keymaps, the return value
755 Alternatively, you can specify a menu of multiple panes
756 with a list of the form (TITLE PANE1 PANE2...),
757 where each pane is a list of form (TITLE ITEM1 ITEM2...).
758 Each ITEM is normally a cons cell (STRING . VALUE);
759 but a string can appear as an item--that makes a nonselectable line
761 With this form of menu, the return value is VALUE from the chosen item.
763 If POSITION is nil, don't display the menu at all, just precalculate the
764 cached information about equivalent key sequences. */)
766 Lisp_Object position
, menu
;
768 Lisp_Object keymap
, tem
;
769 int xpos
= 0, ypos
= 0;
772 Lisp_Object selection
;
774 Lisp_Object x
, y
, window
;
777 int specpdl_count
= SPECPDL_INDEX ();
781 if (! NILP (position
))
783 int get_current_pos_p
= 0;
786 /* Decode the first argument: find the window and the coordinates. */
787 if (EQ (position
, Qt
)
788 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
789 || EQ (XCAR (position
), Qtool_bar
))))
791 get_current_pos_p
= 1;
795 tem
= Fcar (position
);
798 window
= Fcar (Fcdr (position
));
800 y
= Fcar (Fcdr (tem
));
805 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
806 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
807 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
812 /* If a click happens in an external tool bar or a detached
813 tool bar, x and y is NIL. In that case, use the current
814 mouse position. This happens for the help button in the
815 tool bar. Ideally popup-menu should pass NIL to
816 this function, but it doesn't. */
817 if (NILP (x
) && NILP (y
))
818 get_current_pos_p
= 1;
821 if (get_current_pos_p
)
823 /* Use the mouse's current position. */
824 FRAME_PTR new_f
= SELECTED_FRAME ();
825 #ifdef HAVE_X_WINDOWS
826 /* Can't use mouse_position_hook for X since it returns
827 coordinates relative to the window the mouse is in,
828 we need coordinates relative to the edit widget always. */
833 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
834 /* cur_x/y may be negative, so use make_number. */
835 x
= make_number (cur_x
);
836 y
= make_number (cur_y
);
839 #else /* not HAVE_X_WINDOWS */
840 Lisp_Object bar_window
;
841 enum scroll_bar_part part
;
844 if (mouse_position_hook
)
845 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
846 &part
, &x
, &y
, &time
);
847 #endif /* not HAVE_X_WINDOWS */
850 XSETFRAME (window
, new_f
);
853 window
= selected_window
;
862 /* Decode where to put the menu. */
870 else if (WINDOWP (window
))
872 CHECK_LIVE_WINDOW (window
);
873 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
875 xpos
= (FONT_WIDTH (FRAME_FONT (f
))
876 * XFASTINT (XWINDOW (window
)->left
));
877 ypos
= (FRAME_LINE_HEIGHT (f
)
878 * XFASTINT (XWINDOW (window
)->top
));
881 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
882 but I don't want to make one now. */
883 CHECK_WINDOW (window
);
888 Vmenu_updating_frame
= Qnil
;
889 #endif /* HAVE_MENUS */
891 record_unwind_protect (unuse_menu_items
, Qnil
);
895 /* Decode the menu items from what was specified. */
897 keymap
= get_keymap (menu
, 0, 0);
900 /* We were given a keymap. Extract menu info from the keymap. */
903 /* Extract the detailed info to make one pane. */
904 keymap_panes (&menu
, 1, NILP (position
));
906 /* Search for a string appearing directly as an element of the keymap.
907 That string is the title of the menu. */
908 prompt
= Fkeymap_prompt (keymap
);
909 if (NILP (title
) && !NILP (prompt
))
912 /* Make that be the pane title of the first pane. */
913 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
914 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
918 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
920 /* We were given a list of keymaps. */
921 int nmaps
= XFASTINT (Flength (menu
));
923 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
928 /* The first keymap that has a prompt string
929 supplies the menu title. */
930 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
934 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
936 prompt
= Fkeymap_prompt (keymap
);
937 if (NILP (title
) && !NILP (prompt
))
941 /* Extract the detailed info to make one pane. */
942 keymap_panes (maps
, nmaps
, NILP (position
));
944 /* Make the title be the pane title of the first pane. */
945 if (!NILP (title
) && menu_items_n_panes
>= 0)
946 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
952 /* We were given an old-fashioned menu. */
954 CHECK_STRING (title
);
956 list_of_panes (Fcdr (menu
));
961 unbind_to (specpdl_count
, Qnil
);
965 discard_menu_items ();
971 /* Display them in a menu. */
974 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
975 keymaps
, title
, &error_name
);
978 discard_menu_items ();
981 #endif /* HAVE_MENUS */
983 if (error_name
) error (error_name
);
989 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
990 doc
: /* Pop up a dialog box and return user's selection.
991 POSITION specifies which frame to use.
992 This is normally a mouse button event or a window or frame.
993 If POSITION is t, it means to use the frame the mouse is on.
994 The dialog box appears in the middle of the specified frame.
996 CONTENTS specifies the alternatives to display in the dialog box.
997 It is a list of the form (TITLE ITEM1 ITEM2...).
998 Each ITEM is a cons cell (STRING . VALUE).
999 The return value is VALUE from the chosen item.
1001 An ITEM may also be just a string--that makes a nonselectable item.
1002 An ITEM may also be nil--that means to put all preceding items
1003 on the left of the dialog box and all following items on the right.
1004 \(By default, approximately half appear on each side.) */)
1005 (position
, contents
)
1006 Lisp_Object position
, contents
;
1013 /* Decode the first argument: find the window or frame to use. */
1014 if (EQ (position
, Qt
)
1015 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1016 || EQ (XCAR (position
), Qtool_bar
))))
1018 #if 0 /* Using the frame the mouse is on may not be right. */
1019 /* Use the mouse's current position. */
1020 FRAME_PTR new_f
= SELECTED_FRAME ();
1021 Lisp_Object bar_window
;
1022 enum scroll_bar_part part
;
1026 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1029 XSETFRAME (window
, new_f
);
1031 window
= selected_window
;
1033 window
= selected_window
;
1035 else if (CONSP (position
))
1038 tem
= Fcar (position
);
1040 window
= Fcar (Fcdr (position
));
1043 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1044 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1047 else if (WINDOWP (position
) || FRAMEP (position
))
1052 /* Decode where to put the menu. */
1054 if (FRAMEP (window
))
1055 f
= XFRAME (window
);
1056 else if (WINDOWP (window
))
1058 CHECK_LIVE_WINDOW (window
);
1059 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1062 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1063 but I don't want to make one now. */
1064 CHECK_WINDOW (window
);
1066 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1067 /* Display a menu with these alternatives
1068 in the middle of frame F. */
1070 Lisp_Object x
, y
, frame
, newpos
;
1071 XSETFRAME (frame
, f
);
1072 XSETINT (x
, x_pixel_width (f
) / 2);
1073 XSETINT (y
, x_pixel_height (f
) / 2);
1074 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1076 return Fx_popup_menu (newpos
,
1077 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1083 Lisp_Object selection
;
1084 int specpdl_count
= SPECPDL_INDEX ();
1086 /* Decode the dialog items from what was specified. */
1087 title
= Fcar (contents
);
1088 CHECK_STRING (title
);
1089 record_unwind_protect (unuse_menu_items
, Qnil
);
1091 list_of_panes (Fcons (contents
, Qnil
));
1093 /* Display them in a dialog box. */
1095 selection
= xdialog_show (f
, 0, title
, &error_name
);
1098 unbind_to (specpdl_count
, Qnil
);
1099 discard_menu_items ();
1101 if (error_name
) error (error_name
);
1107 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1109 /* Loop in Xt until the menu pulldown or dialog popup has been
1110 popped down (deactivated). This is used for x-popup-menu
1111 and x-popup-dialog; it is not used for the menu bar.
1113 If DO_TIMERS is nonzero, run timers.
1115 NOTE: All calls to popup_get_selection should be protected
1116 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1118 #ifdef USE_X_TOOLKIT
1120 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1121 XEvent
*initial_event
;
1122 struct x_display_info
*dpyinfo
;
1128 while (popup_activated_flag
)
1130 /* If we have no events to run, consider timers. */
1131 if (do_timers
&& !XtAppPending (Xt_app_con
))
1136 event
= *initial_event
;
1140 XtAppNextEvent (Xt_app_con
, &event
);
1142 /* Make sure we don't consider buttons grabbed after menu goes.
1143 And make sure to deactivate for any ButtonRelease,
1144 even if XtDispatchEvent doesn't do that. */
1145 if (event
.type
== ButtonRelease
1146 && dpyinfo
->display
== event
.xbutton
.display
)
1148 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1149 #ifdef USE_MOTIF /* Pretending that the event came from a
1150 Btn1Down seems the only way to convince Motif to
1151 activate its callbacks; setting the XmNmenuPost
1152 isn't working. --marcus@sysc.pdx.edu. */
1153 event
.xbutton
.button
= 1;
1154 /* Motif only pops down menus when no Ctrl, Alt or Mod
1155 key is pressed and the button is released. So reset key state
1156 so Motif thinks this is the case. */
1157 event
.xbutton
.state
= 0;
1160 /* If the user presses a key, deactivate the menu.
1161 The user is likely to do that if we get wedged.
1162 This is mostly for Lucid, Motif pops down the menu on ESC. */
1163 else if (event
.type
== KeyPress
1164 && dpyinfo
->display
== event
.xbutton
.display
)
1166 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1167 if (!IsModifierKey (keysym
))
1168 popup_activated_flag
= 0;
1171 x_dispatch_event (&event
, event
.xany
.display
);
1175 #endif /* USE_X_TOOLKIT */
1178 /* Loop util popup_activated_flag is set to zero in a callback.
1179 Used for popup menus and dialogs. */
1181 popup_widget_loop ()
1183 ++popup_activated_flag
;
1185 /* Process events in the Gtk event loop until done. */
1186 while (popup_activated_flag
)
1188 gtk_main_iteration ();
1193 /* Activate the menu bar of frame F.
1194 This is called from keyboard.c when it gets the
1195 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1197 To activate the menu bar, we use the X button-press event
1198 that was saved in saved_menu_event.
1199 That makes the toolkit do its thing.
1201 But first we recompute the menu bar contents (the whole tree).
1203 The reason for saving the button event until here, instead of
1204 passing it to the toolkit right away, is that we can safely
1205 execute Lisp code. */
1208 x_activate_menubar (f
)
1211 if (!f
->output_data
.x
->saved_menu_event
->type
)
1215 if (! xg_win_to_widget (f
->output_data
.x
->saved_menu_event
->xany
.window
))
1219 set_frame_menubar (f
, 0, 1);
1222 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1223 f
->output_data
.x
->saved_menu_event
);
1224 popup_activated_flag
= 1;
1226 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1230 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1231 pending_menu_activation
= 1;
1234 /* Ignore this if we get it a second time. */
1235 f
->output_data
.x
->saved_menu_event
->type
= 0;
1238 /* Detect if a dialog or menu has been posted. */
1243 return popup_activated_flag
;
1246 /* This callback is invoked when the user selects a menubar cascade
1247 pushbutton, but before the pulldown menu is posted. */
1251 popup_activate_callback (widget
, id
, client_data
)
1254 XtPointer client_data
;
1256 popup_activated_flag
= 1;
1260 /* This callback is invoked when a dialog or menu is finished being
1261 used and has been unposted. */
1265 popup_deactivate_callback (widget
, client_data
)
1267 gpointer client_data
;
1269 popup_activated_flag
= 0;
1273 popup_deactivate_callback (widget
, id
, client_data
)
1276 XtPointer client_data
;
1278 popup_activated_flag
= 0;
1283 /* Function that finds the frame for WIDGET and shows the HELP text
1285 F is the frame if known, or NULL if not known. */
1287 show_help_event (f
, widget
, help
)
1289 xt_or_gtk_widget widget
;
1296 XSETFRAME (frame
, f
);
1297 kbd_buffer_store_help_event (frame
, help
);
1301 /* WIDGET is the popup menu. It's parent is the frame's
1302 widget. See which frame that is. */
1303 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1306 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1308 frame
= XCAR (tail
);
1309 if (GC_FRAMEP (frame
)
1310 && (f
= XFRAME (frame
),
1311 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1315 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1319 /* Callback called when menu items are highlighted/unhighlighted
1320 while moving the mouse over them. WIDGET is the menu bar or menu
1321 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1322 the data structure for the menu item, or null in case of
1327 menu_highlight_callback (widget
, call_data
)
1331 xg_menu_item_cb_data
*cb_data
;
1334 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1336 if (! cb_data
) return;
1338 help
= call_data
? cb_data
->help
: Qnil
;
1340 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1341 Don't show help for them, they won't appear before the
1342 popup is popped down. */
1343 if (popup_activated_flag
<= 1)
1344 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1348 menu_highlight_callback (widget
, id
, call_data
)
1356 widget_value
*wv
= (widget_value
*) call_data
;
1358 help
= wv
? wv
->help
: Qnil
;
1360 /* Determine the frame for the help event. */
1361 f
= menubar_id_to_frame (id
);
1363 show_help_event (f
, widget
, help
);
1367 /* Find the menu selection and store it in the keyboard buffer.
1368 F is the frame the menu is on.
1369 MENU_BAR_ITEMS_USED is the length of VECTOR.
1370 VECTOR is an array of menu events for the whole menu.
1373 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1375 int menu_bar_items_used
;
1379 Lisp_Object prefix
, entry
;
1380 Lisp_Object
*subprefix_stack
;
1381 int submenu_depth
= 0;
1385 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1389 while (i
< menu_bar_items_used
)
1391 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1393 subprefix_stack
[submenu_depth
++] = prefix
;
1397 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1399 prefix
= subprefix_stack
[--submenu_depth
];
1402 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1404 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1405 i
+= MENU_ITEMS_PANE_LENGTH
;
1409 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1410 /* The EMACS_INT cast avoids a warning. There's no problem
1411 as long as pointers have enough bits to hold small integers. */
1412 if ((int) (EMACS_INT
) client_data
== i
)
1415 struct input_event buf
;
1418 XSETFRAME (frame
, f
);
1419 buf
.kind
= MENU_BAR_EVENT
;
1420 buf
.frame_or_window
= frame
;
1422 kbd_buffer_store_event (&buf
);
1424 for (j
= 0; j
< submenu_depth
; j
++)
1425 if (!NILP (subprefix_stack
[j
]))
1427 buf
.kind
= MENU_BAR_EVENT
;
1428 buf
.frame_or_window
= frame
;
1429 buf
.arg
= subprefix_stack
[j
];
1430 kbd_buffer_store_event (&buf
);
1435 buf
.kind
= MENU_BAR_EVENT
;
1436 buf
.frame_or_window
= frame
;
1438 kbd_buffer_store_event (&buf
);
1441 buf
.kind
= MENU_BAR_EVENT
;
1442 buf
.frame_or_window
= frame
;
1444 kbd_buffer_store_event (&buf
);
1448 i
+= MENU_ITEMS_ITEM_LENGTH
;
1455 /* Gtk calls callbacks just because we tell it what item should be
1456 selected in a radio group. If this variable is set to a non-zero
1457 value, we are creating menus and don't want callbacks right now.
1459 static int xg_crazy_callback_abort
;
1461 /* This callback is called from the menu bar pulldown menu
1462 when the user makes a selection.
1463 Figure out what the user chose
1464 and put the appropriate events into the keyboard buffer. */
1466 menubar_selection_callback (widget
, client_data
)
1468 gpointer client_data
;
1470 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1472 if (xg_crazy_callback_abort
)
1475 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1478 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1479 cb_data
->cl_data
->menu_bar_items_used
,
1480 cb_data
->cl_data
->menu_bar_vector
,
1481 cb_data
->call_data
);
1484 #else /* not USE_GTK */
1486 /* This callback is called from the menu bar pulldown menu
1487 when the user makes a selection.
1488 Figure out what the user chose
1489 and put the appropriate events into the keyboard buffer. */
1491 menubar_selection_callback (widget
, id
, client_data
)
1494 XtPointer client_data
;
1498 f
= menubar_id_to_frame (id
);
1501 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1502 f
->menu_bar_vector
, client_data
);
1504 #endif /* not USE_GTK */
1506 /* Allocate a widget_value, blocking input. */
1509 xmalloc_widget_value ()
1511 widget_value
*value
;
1514 value
= malloc_widget_value ();
1520 /* This recursively calls free_widget_value on the tree of widgets.
1521 It must free all data that was malloc'ed for these widget_values.
1522 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1523 must be left alone. */
1526 free_menubar_widget_value_tree (wv
)
1531 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1533 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1535 free_menubar_widget_value_tree (wv
->contents
);
1536 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1540 free_menubar_widget_value_tree (wv
->next
);
1541 wv
->next
= (widget_value
*) 0xDEADBEEF;
1544 free_widget_value (wv
);
1548 /* Set up data in menu_items for a menu bar item
1549 whose event type is ITEM_KEY (with string ITEM_NAME)
1550 and whose contents come from the list of keymaps MAPS. */
1553 parse_single_submenu (item_key
, item_name
, maps
)
1554 Lisp_Object item_key
, item_name
, maps
;
1558 Lisp_Object
*mapvec
;
1560 int top_level_items
= 0;
1562 length
= Flength (maps
);
1563 len
= XINT (length
);
1565 /* Convert the list MAPS into a vector MAPVEC. */
1566 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1567 for (i
= 0; i
< len
; i
++)
1569 mapvec
[i
] = Fcar (maps
);
1573 /* Loop over the given keymaps, making a pane for each map.
1574 But don't make a pane that is empty--ignore that map instead. */
1575 for (i
= 0; i
< len
; i
++)
1577 if (!KEYMAPP (mapvec
[i
]))
1579 /* Here we have a command at top level in the menu bar
1580 as opposed to a submenu. */
1581 top_level_items
= 1;
1582 push_menu_pane (Qnil
, Qnil
);
1583 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1584 Qnil
, Qnil
, Qnil
, Qnil
);
1589 prompt
= Fkeymap_prompt (mapvec
[i
]);
1590 single_keymap_panes (mapvec
[i
],
1591 !NILP (prompt
) ? prompt
: item_name
,
1596 return top_level_items
;
1599 /* Create a tree of widget_value objects
1600 representing the panes and items
1601 in menu_items starting at index START, up to index END. */
1603 static widget_value
*
1604 digest_single_submenu (start
, end
, top_level_items
)
1605 int start
, end
, top_level_items
;
1607 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1609 int submenu_depth
= 0;
1610 widget_value
**submenu_stack
;
1613 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1614 wv
= xmalloc_widget_value ();
1618 wv
->button_type
= BUTTON_TYPE_NONE
;
1624 /* Loop over all panes and items made by the preceding call
1625 to parse_single_submenu and construct a tree of widget_value objects.
1626 Ignore the panes and items used by previous calls to
1627 digest_single_submenu, even though those are also in menu_items. */
1631 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1633 submenu_stack
[submenu_depth
++] = save_wv
;
1638 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1641 save_wv
= submenu_stack
[--submenu_depth
];
1644 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1645 && submenu_depth
!= 0)
1646 i
+= MENU_ITEMS_PANE_LENGTH
;
1647 /* Ignore a nil in the item list.
1648 It's meaningful only for dialog boxes. */
1649 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1651 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1653 /* Create a new pane. */
1654 Lisp_Object pane_name
, prefix
;
1657 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1658 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1660 #ifndef HAVE_MULTILINGUAL_MENU
1661 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1663 pane_name
= ENCODE_SYSTEM (pane_name
);
1664 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1667 pane_string
= (NILP (pane_name
)
1668 ? "" : (char *) SDATA (pane_name
));
1669 /* If there is just one top-level pane, put all its items directly
1670 under the top-level menu. */
1671 if (menu_items_n_panes
== 1)
1674 /* If the pane has a meaningful name,
1675 make the pane a top-level menu item
1676 with its items as a submenu beneath it. */
1677 if (strcmp (pane_string
, ""))
1679 wv
= xmalloc_widget_value ();
1683 first_wv
->contents
= wv
;
1684 wv
->name
= pane_string
;
1685 /* Ignore the @ that means "separate pane".
1686 This is a kludge, but this isn't worth more time. */
1687 if (!NILP (prefix
) && wv
->name
[0] == '@')
1691 wv
->button_type
= BUTTON_TYPE_NONE
;
1696 i
+= MENU_ITEMS_PANE_LENGTH
;
1700 /* Create a new item within current pane. */
1701 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1704 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1705 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1706 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1707 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1708 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1709 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1710 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1712 #ifndef HAVE_MULTILINGUAL_MENU
1713 if (STRING_MULTIBYTE (item_name
))
1715 item_name
= ENCODE_SYSTEM (item_name
);
1716 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1719 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1721 descrip
= ENCODE_SYSTEM (descrip
);
1722 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1724 #endif /* not HAVE_MULTILINGUAL_MENU */
1726 wv
= xmalloc_widget_value ();
1730 save_wv
->contents
= wv
;
1732 wv
->name
= (char *) SDATA (item_name
);
1733 if (!NILP (descrip
))
1734 wv
->key
= (char *) SDATA (descrip
);
1736 /* The EMACS_INT cast avoids a warning. There's no problem
1737 as long as pointers have enough bits to hold small integers. */
1738 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1739 wv
->enabled
= !NILP (enable
);
1742 wv
->button_type
= BUTTON_TYPE_NONE
;
1743 else if (EQ (type
, QCradio
))
1744 wv
->button_type
= BUTTON_TYPE_RADIO
;
1745 else if (EQ (type
, QCtoggle
))
1746 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1750 wv
->selected
= !NILP (selected
);
1751 if (! STRINGP (help
))
1758 i
+= MENU_ITEMS_ITEM_LENGTH
;
1762 /* If we have just one "menu item"
1763 that was originally a button, return it by itself. */
1764 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1766 wv
= first_wv
->contents
;
1767 free_widget_value (first_wv
);
1774 /* Recompute all the widgets of frame F, when the menu bar has been
1775 changed. Value is non-zero if widgets were updated. */
1778 update_frame_menubar (f
)
1782 return xg_update_frame_menubar (f
);
1784 struct x_output
*x
= f
->output_data
.x
;
1787 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1791 /* Save the size of the frame because the pane widget doesn't accept
1792 to resize itself. So force it. */
1796 /* Do the voodoo which means "I'm changing lots of things, don't try
1797 to refigure sizes until I'm done." */
1798 lw_refigure_widget (x
->column_widget
, False
);
1800 /* The order in which children are managed is the top to bottom
1801 order in which they are displayed in the paned window. First,
1802 remove the text-area widget. */
1803 XtUnmanageChild (x
->edit_widget
);
1805 /* Remove the menubar that is there now, and put up the menubar that
1807 XtManageChild (x
->menubar_widget
);
1808 XtMapWidget (x
->menubar_widget
);
1809 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1811 /* Re-manage the text-area widget, and then thrash the sizes. */
1812 XtManageChild (x
->edit_widget
);
1813 lw_refigure_widget (x
->column_widget
, True
);
1815 /* Force the pane widget to resize itself with the right values. */
1816 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1822 /* Set the contents of the menubar widgets of frame F.
1823 The argument FIRST_TIME is currently ignored;
1824 it is set the first time this is called, from initialize_frame_menubar. */
1827 set_frame_menubar (f
, first_time
, deep_p
)
1832 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1833 #ifdef USE_X_TOOLKIT
1837 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1839 int *submenu_start
, *submenu_end
;
1840 int *submenu_top_level_items
, *submenu_n_panes
;
1843 XSETFRAME (Vmenu_updating_frame
, f
);
1845 #ifdef USE_X_TOOLKIT
1846 if (f
->output_data
.x
->id
== 0)
1847 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1848 id
= f
->output_data
.x
->id
;
1851 if (! menubar_widget
)
1853 else if (pending_menu_activation
&& !deep_p
)
1855 /* Make the first call for any given frame always go deep. */
1856 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1859 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1860 f
->output_data
.x
->saved_menu_event
->type
= 0;
1865 /* Make a widget-value tree representing the entire menu trees. */
1867 struct buffer
*prev
= current_buffer
;
1869 int specpdl_count
= SPECPDL_INDEX ();
1870 int previous_menu_items_used
= f
->menu_bar_items_used
;
1871 Lisp_Object
*previous_items
1872 = (Lisp_Object
*) alloca (previous_menu_items_used
1873 * sizeof (Lisp_Object
));
1875 /* If we are making a new widget, its contents are empty,
1876 do always reinitialize them. */
1877 if (! menubar_widget
)
1878 previous_menu_items_used
= 0;
1880 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1881 specbind (Qinhibit_quit
, Qt
);
1882 /* Don't let the debugger step into this code
1883 because it is not reentrant. */
1884 specbind (Qdebug_on_next_call
, Qnil
);
1886 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1887 record_unwind_protect (unuse_menu_items
, Qnil
);
1888 if (NILP (Voverriding_local_map_menu_flag
))
1890 specbind (Qoverriding_terminal_local_map
, Qnil
);
1891 specbind (Qoverriding_local_map
, Qnil
);
1894 set_buffer_internal_1 (XBUFFER (buffer
));
1896 /* Run the Lucid hook. */
1897 safe_run_hooks (Qactivate_menubar_hook
);
1899 /* If it has changed current-menubar from previous value,
1900 really recompute the menubar from the value. */
1901 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1902 call0 (Qrecompute_lucid_menubar
);
1903 safe_run_hooks (Qmenu_bar_update_hook
);
1904 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1906 items
= FRAME_MENU_BAR_ITEMS (f
);
1908 /* Save the frame's previous menu bar contents data. */
1909 if (previous_menu_items_used
)
1910 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1911 previous_menu_items_used
* sizeof (Lisp_Object
));
1913 /* Fill in menu_items with the current menu bar contents.
1914 This can evaluate Lisp code. */
1915 menu_items
= f
->menu_bar_vector
;
1916 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1917 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1918 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1919 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1920 submenu_top_level_items
1921 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1923 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1925 Lisp_Object key
, string
, maps
;
1929 key
= XVECTOR (items
)->contents
[i
];
1930 string
= XVECTOR (items
)->contents
[i
+ 1];
1931 maps
= XVECTOR (items
)->contents
[i
+ 2];
1935 submenu_start
[i
] = menu_items_used
;
1937 menu_items_n_panes
= 0;
1938 submenu_top_level_items
[i
]
1939 = parse_single_submenu (key
, string
, maps
);
1940 submenu_n_panes
[i
] = menu_items_n_panes
;
1942 submenu_end
[i
] = menu_items_used
;
1945 finish_menu_items ();
1947 /* Convert menu_items into widget_value trees
1948 to display the menu. This cannot evaluate Lisp code. */
1950 wv
= xmalloc_widget_value ();
1951 wv
->name
= "menubar";
1954 wv
->button_type
= BUTTON_TYPE_NONE
;
1958 for (i
= 0; i
< last_i
; i
+= 4)
1960 menu_items_n_panes
= submenu_n_panes
[i
];
1961 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1962 submenu_top_level_items
[i
]);
1966 first_wv
->contents
= wv
;
1967 /* Don't set wv->name here; GC during the loop might relocate it. */
1969 wv
->button_type
= BUTTON_TYPE_NONE
;
1973 set_buffer_internal_1 (prev
);
1974 unbind_to (specpdl_count
, Qnil
);
1976 /* If there has been no change in the Lisp-level contents
1977 of the menu bar, skip redisplaying it. Just exit. */
1979 for (i
= 0; i
< previous_menu_items_used
; i
++)
1980 if (menu_items_used
== i
1981 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1983 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1985 free_menubar_widget_value_tree (first_wv
);
1986 discard_menu_items ();
1991 /* Now GC cannot happen during the lifetime of the widget_value,
1992 so it's safe to store data from a Lisp_String. */
1993 wv
= first_wv
->contents
;
1994 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1997 string
= XVECTOR (items
)->contents
[i
+ 1];
2000 wv
->name
= (char *) SDATA (string
);
2004 f
->menu_bar_vector
= menu_items
;
2005 f
->menu_bar_items_used
= menu_items_used
;
2006 discard_menu_items ();
2010 /* Make a widget-value tree containing
2011 just the top level menu bar strings. */
2013 wv
= xmalloc_widget_value ();
2014 wv
->name
= "menubar";
2017 wv
->button_type
= BUTTON_TYPE_NONE
;
2021 items
= FRAME_MENU_BAR_ITEMS (f
);
2022 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2026 string
= XVECTOR (items
)->contents
[i
+ 1];
2030 wv
= xmalloc_widget_value ();
2031 wv
->name
= (char *) SDATA (string
);
2034 wv
->button_type
= BUTTON_TYPE_NONE
;
2036 /* This prevents lwlib from assuming this
2037 menu item is really supposed to be empty. */
2038 /* The EMACS_INT cast avoids a warning.
2039 This value just has to be different from small integers. */
2040 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2045 first_wv
->contents
= wv
;
2049 /* Forget what we thought we knew about what is in the
2050 detailed contents of the menu bar menus.
2051 Changing the top level always destroys the contents. */
2052 f
->menu_bar_items_used
= 0;
2055 /* Create or update the menu bar widget. */
2060 xg_crazy_callback_abort
= 1;
2063 /* The third arg is DEEP_P, which says to consider the entire
2064 menu trees we supply, rather than just the menu bar item names. */
2065 xg_modify_menubar_widgets (menubar_widget
,
2069 G_CALLBACK (menubar_selection_callback
),
2070 G_CALLBACK (popup_deactivate_callback
),
2071 G_CALLBACK (menu_highlight_callback
));
2075 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2078 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2079 G_CALLBACK (menubar_selection_callback
),
2080 G_CALLBACK (popup_deactivate_callback
),
2081 G_CALLBACK (menu_highlight_callback
));
2083 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2087 #else /* not USE_GTK */
2090 /* Disable resizing (done for Motif!) */
2091 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2093 /* The third arg is DEEP_P, which says to consider the entire
2094 menu trees we supply, rather than just the menu bar item names. */
2095 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2097 /* Re-enable the edit widget to resize. */
2098 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2102 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2103 f
->output_data
.x
->column_widget
,
2105 popup_activate_callback
,
2106 menubar_selection_callback
,
2107 popup_deactivate_callback
,
2108 menu_highlight_callback
);
2109 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2114 = (f
->output_data
.x
->menubar_widget
2115 ? (f
->output_data
.x
->menubar_widget
->core
.height
2116 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2119 #if 0 /* Experimentally, we now get the right results
2120 for -geometry -0-0 without this. 24 Aug 96, rms. */
2122 if (FRAME_EXTERNAL_MENU_BAR (f
))
2125 XtVaGetValues (f
->output_data
.x
->column_widget
,
2126 XtNinternalBorderWidth
, &ibw
, NULL
);
2127 menubar_size
+= ibw
;
2129 #endif /* USE_LUCID */
2132 f
->output_data
.x
->menubar_height
= menubar_size
;
2134 #endif /* not USE_GTK */
2136 free_menubar_widget_value_tree (first_wv
);
2137 update_frame_menubar (f
);
2140 xg_crazy_callback_abort
= 0;
2146 /* Called from Fx_create_frame to create the initial menubar of a frame
2147 before it is mapped, so that the window is mapped with the menubar already
2148 there instead of us tacking it on later and thrashing the window after it
2152 initialize_frame_menubar (f
)
2155 /* This function is called before the first chance to redisplay
2156 the frame. It has to be, so the frame will have the right size. */
2157 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2158 set_frame_menubar (f
, 1, 1);
2162 /* Get rid of the menu bar of frame F, and free its storage.
2163 This is used when deleting a frame, and when turning off the menu bar.
2164 For GTK this function is in gtkutil.c. */
2168 free_frame_menubar (f
)
2171 Widget menubar_widget
;
2173 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2175 f
->output_data
.x
->menubar_height
= 0;
2180 /* Removing the menu bar magically changes the shell widget's x
2181 and y position of (0, 0) which, when the menu bar is turned
2182 on again, leads to pull-down menuss appearing in strange
2183 positions near the upper-left corner of the display. This
2184 happens only with some window managers like twm and ctwm,
2185 but not with other like Motif's mwm or kwm, because the
2186 latter generate ConfigureNotify events when the menu bar
2187 is switched off, which fixes the shell position. */
2188 Position x0
, y0
, x1
, y1
;
2194 if (f
->output_data
.x
->widget
)
2195 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2198 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2199 f
->output_data
.x
->menubar_widget
= NULL
;
2202 if (f
->output_data
.x
->widget
)
2204 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2205 if (x1
== 0 && y1
== 0)
2206 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2213 #endif /* not USE_GTK */
2215 #endif /* USE_X_TOOLKIT || USE_GTK */
2217 /* xmenu_show actually displays a menu using the panes and items in menu_items
2218 and returns the value selected from it.
2219 There are two versions of xmenu_show, one for Xt and one for Xlib.
2220 Both assume input is blocked by the caller. */
2222 /* F is the frame the menu is for.
2223 X and Y are the frame-relative specified position,
2224 relative to the inside upper left corner of the frame F.
2225 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2226 KEYMAPS is 1 if this menu was specified with keymaps;
2227 in that case, we return a list containing the chosen item's value
2228 and perhaps also the pane's prefix.
2229 TITLE is the specified menu title.
2230 ERROR is a place to store an error message string in case of failure.
2231 (We return nil on failure, but the value doesn't actually matter.) */
2233 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2235 /* The item selected in the popup menu. */
2236 static Lisp_Object
*volatile menu_item_selection
;
2240 /* Used when position a popup menu. See menu_position_func and
2241 create_and_show_popup_menu below. */
2242 struct next_popup_x_y
2249 /* The menu position function to use if we are not putting a popup
2250 menu where the pointer is.
2251 MENU is the menu to pop up.
2252 X and Y shall on exit contain x/y where the menu shall pop up.
2253 PUSH_IN is not documented in the GTK manual.
2254 USER_DATA is any data passed in when calling gtk_menu_popup.
2255 Here it points to a struct next_popup_x_y where the coordinates
2256 to store in *X and *Y are as well as the frame for the popup.
2258 Here only X and Y are used. */
2260 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2267 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2269 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2270 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2275 /* Check if there is room for the menu. If not, adjust x/y so that
2276 the menu is fully visible. */
2277 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2278 if (data
->x
+ req
.width
> disp_width
)
2279 *x
-= data
->x
+ req
.width
- disp_width
;
2280 if (data
->y
+ req
.height
> disp_height
)
2281 *y
-= data
->y
+ req
.height
- disp_height
;
2285 popup_selection_callback (widget
, client_data
)
2287 gpointer client_data
;
2289 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2291 if (xg_crazy_callback_abort
) return;
2292 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2295 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2297 menu_item_selection will be set to the selection. */
2299 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2301 widget_value
*first_wv
;
2308 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2309 struct next_popup_x_y popup_x_y
;
2311 xg_crazy_callback_abort
= 1;
2312 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2313 G_CALLBACK (popup_selection_callback
),
2314 G_CALLBACK (popup_deactivate_callback
),
2315 G_CALLBACK (menu_highlight_callback
));
2316 xg_crazy_callback_abort
= 0;
2318 for (i
= 0; i
< 5; i
++)
2319 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2324 /* Not invoked by a click. pop up at x/y. */
2325 pos_func
= menu_position_func
;
2327 /* Adjust coordinates to be root-window-relative. */
2328 x
+= f
->output_data
.x
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2329 y
+= f
->output_data
.x
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2336 /* Display the menu. */
2337 gtk_widget_show_all (menu
);
2338 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2341 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2342 two. show_help_echo uses this to detect popup menus. */
2343 popup_activated_flag
= 1;
2344 /* Process events that apply to the menu. */
2345 popup_widget_loop ();
2348 xg_keep_popup (menu
, xg_did_tearoff
);
2350 gtk_widget_destroy (menu
);
2352 /* Must reset this manually because the button release event is not passed
2353 to Emacs event loop. */
2354 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2357 #else /* not USE_GTK */
2359 /* We need a unique id for each widget handled by the Lucid Widget
2362 For the main windows, and popup menus, we use this counter,
2363 which we increment each time after use. This starts from 1<<16.
2365 For menu bars, we use numbers starting at 0, counted in
2366 next_menubar_widget_id. */
2367 LWLIB_ID widget_id_tick
;
2370 popup_selection_callback (widget
, id
, client_data
)
2373 XtPointer client_data
;
2375 menu_item_selection
= (Lisp_Object
*) client_data
;
2378 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2380 menu_item_selection will be set to the selection. */
2382 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2384 widget_value
*first_wv
;
2392 XButtonPressedEvent dummy
;
2397 menu_id
= widget_id_tick
++;
2398 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2399 f
->output_data
.x
->widget
, 1, 0,
2400 popup_selection_callback
,
2401 popup_deactivate_callback
,
2402 menu_highlight_callback
);
2404 dummy
.type
= ButtonPress
;
2406 dummy
.send_event
= 0;
2407 dummy
.display
= FRAME_X_DISPLAY (f
);
2408 dummy
.time
= CurrentTime
;
2409 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2410 dummy
.window
= dummy
.root
;
2411 dummy
.subwindow
= dummy
.root
;
2415 /* Adjust coordinates to be root-window-relative. */
2416 x
+= f
->output_data
.x
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2417 y
+= f
->output_data
.x
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2424 for (i
= 0; i
< 5; i
++)
2425 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2428 /* Don't allow any geometry request from the user. */
2429 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2430 XtSetValues (menu
, av
, ac
);
2432 /* Display the menu. */
2433 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2434 popup_activated_flag
= 1;
2436 /* Process events that apply to the menu. */
2437 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 0);
2439 /* fp turned off the following statement and wrote a comment
2440 that it is unnecessary--that the menu has already disappeared.
2441 Nowadays the menu disappears ok, all right, but
2442 we need to delete the widgets or multiple ones will pile up. */
2443 lw_destroy_all_widgets (menu_id
);
2446 #endif /* not USE_GTK */
2449 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2459 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2460 widget_value
**submenu_stack
2461 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2462 Lisp_Object
*subprefix_stack
2463 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2464 int submenu_depth
= 0;
2470 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2472 *error
= "Empty menu";
2476 /* Create a tree of widget_value objects
2477 representing the panes and their items. */
2478 wv
= xmalloc_widget_value ();
2482 wv
->button_type
= BUTTON_TYPE_NONE
;
2487 /* Loop over all panes and items, filling in the tree. */
2489 while (i
< menu_items_used
)
2491 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2493 submenu_stack
[submenu_depth
++] = save_wv
;
2499 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2502 save_wv
= submenu_stack
[--submenu_depth
];
2506 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2507 && submenu_depth
!= 0)
2508 i
+= MENU_ITEMS_PANE_LENGTH
;
2509 /* Ignore a nil in the item list.
2510 It's meaningful only for dialog boxes. */
2511 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2513 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2515 /* Create a new pane. */
2516 Lisp_Object pane_name
, prefix
;
2519 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2520 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2522 #ifndef HAVE_MULTILINGUAL_MENU
2523 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2525 pane_name
= ENCODE_SYSTEM (pane_name
);
2526 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2529 pane_string
= (NILP (pane_name
)
2530 ? "" : (char *) SDATA (pane_name
));
2531 /* If there is just one top-level pane, put all its items directly
2532 under the top-level menu. */
2533 if (menu_items_n_panes
== 1)
2536 /* If the pane has a meaningful name,
2537 make the pane a top-level menu item
2538 with its items as a submenu beneath it. */
2539 if (!keymaps
&& strcmp (pane_string
, ""))
2541 wv
= xmalloc_widget_value ();
2545 first_wv
->contents
= wv
;
2546 wv
->name
= pane_string
;
2547 if (keymaps
&& !NILP (prefix
))
2551 wv
->button_type
= BUTTON_TYPE_NONE
;
2556 else if (first_pane
)
2562 i
+= MENU_ITEMS_PANE_LENGTH
;
2566 /* Create a new item within current pane. */
2567 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2568 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2569 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2570 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2571 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2572 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2573 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2574 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2576 #ifndef HAVE_MULTILINGUAL_MENU
2577 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2579 item_name
= ENCODE_SYSTEM (item_name
);
2580 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2583 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2585 descrip
= ENCODE_SYSTEM (descrip
);
2586 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2588 #endif /* not HAVE_MULTILINGUAL_MENU */
2590 wv
= xmalloc_widget_value ();
2594 save_wv
->contents
= wv
;
2595 wv
->name
= (char *) SDATA (item_name
);
2596 if (!NILP (descrip
))
2597 wv
->key
= (char *) SDATA (descrip
);
2599 /* If this item has a null value,
2600 make the call_data null so that it won't display a box
2601 when the mouse is on it. */
2603 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2604 wv
->enabled
= !NILP (enable
);
2607 wv
->button_type
= BUTTON_TYPE_NONE
;
2608 else if (EQ (type
, QCtoggle
))
2609 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2610 else if (EQ (type
, QCradio
))
2611 wv
->button_type
= BUTTON_TYPE_RADIO
;
2615 wv
->selected
= !NILP (selected
);
2617 if (! STRINGP (help
))
2624 i
+= MENU_ITEMS_ITEM_LENGTH
;
2628 /* Deal with the title, if it is non-nil. */
2631 widget_value
*wv_title
= xmalloc_widget_value ();
2632 widget_value
*wv_sep1
= xmalloc_widget_value ();
2633 widget_value
*wv_sep2
= xmalloc_widget_value ();
2635 wv_sep2
->name
= "--";
2636 wv_sep2
->next
= first_wv
->contents
;
2637 wv_sep2
->help
= Qnil
;
2639 wv_sep1
->name
= "--";
2640 wv_sep1
->next
= wv_sep2
;
2641 wv_sep1
->help
= Qnil
;
2643 #ifndef HAVE_MULTILINGUAL_MENU
2644 if (STRING_MULTIBYTE (title
))
2645 title
= ENCODE_SYSTEM (title
);
2648 wv_title
->name
= (char *) SDATA (title
);
2649 wv_title
->enabled
= TRUE
;
2650 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2651 wv_title
->next
= wv_sep1
;
2652 wv_title
->help
= Qnil
;
2653 first_wv
->contents
= wv_title
;
2656 /* No selection has been chosen yet. */
2657 menu_item_selection
= 0;
2659 /* Actually create and show the menu until popped down. */
2660 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2662 /* Free the widget_value objects we used to specify the contents. */
2663 free_menubar_widget_value_tree (first_wv
);
2665 /* Find the selected item, and its pane, to return
2666 the proper value. */
2667 if (menu_item_selection
!= 0)
2669 Lisp_Object prefix
, entry
;
2671 prefix
= entry
= Qnil
;
2673 while (i
< menu_items_used
)
2675 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2677 subprefix_stack
[submenu_depth
++] = prefix
;
2681 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2683 prefix
= subprefix_stack
[--submenu_depth
];
2686 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2689 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2690 i
+= MENU_ITEMS_PANE_LENGTH
;
2692 /* Ignore a nil in the item list.
2693 It's meaningful only for dialog boxes. */
2694 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2699 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2700 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2706 entry
= Fcons (entry
, Qnil
);
2708 entry
= Fcons (prefix
, entry
);
2709 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2710 if (!NILP (subprefix_stack
[j
]))
2711 entry
= Fcons (subprefix_stack
[j
], entry
);
2715 i
+= MENU_ITEMS_ITEM_LENGTH
;
2725 dialog_selection_callback (widget
, client_data
)
2727 gpointer client_data
;
2729 /* The EMACS_INT cast avoids a warning. There's no problem
2730 as long as pointers have enough bits to hold small integers. */
2731 if ((int) (EMACS_INT
) client_data
!= -1)
2732 menu_item_selection
= (Lisp_Object
*) client_data
;
2734 popup_activated_flag
= 0;
2737 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2739 menu_item_selection will be set to the selection. */
2741 create_and_show_dialog (f
, first_wv
)
2743 widget_value
*first_wv
;
2747 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2748 G_CALLBACK (dialog_selection_callback
),
2749 G_CALLBACK (popup_deactivate_callback
),
2754 /* Display the menu. */
2755 gtk_widget_show_all (menu
);
2757 /* Process events that apply to the menu. */
2758 popup_widget_loop ();
2760 gtk_widget_destroy (menu
);
2764 #else /* not USE_GTK */
2766 dialog_selection_callback (widget
, id
, client_data
)
2769 XtPointer client_data
;
2771 /* The EMACS_INT cast avoids a warning. There's no problem
2772 as long as pointers have enough bits to hold small integers. */
2773 if ((int) (EMACS_INT
) client_data
!= -1)
2774 menu_item_selection
= (Lisp_Object
*) client_data
;
2777 lw_destroy_all_widgets (id
);
2779 popup_activated_flag
= 0;
2783 /* ARG is the LWLIB ID of the dialog box, represented
2784 as a Lisp object as (HIGHPART . LOWPART). */
2787 xdialog_show_unwind (arg
)
2790 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2791 | XINT (XCDR (arg
)));
2793 lw_destroy_all_widgets (id
);
2795 popup_activated_flag
= 0;
2800 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2802 menu_item_selection will be set to the selection. */
2804 create_and_show_dialog (f
, first_wv
)
2806 widget_value
*first_wv
;
2810 dialog_id
= widget_id_tick
++;
2811 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2812 f
->output_data
.x
->widget
, 1, 0,
2813 dialog_selection_callback
, 0, 0);
2814 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2816 /* Display the dialog box. */
2817 lw_pop_up_all_widgets (dialog_id
);
2818 popup_activated_flag
= 1;
2820 /* Process events that apply to the dialog box.
2821 Also handle timers. */
2823 int count
= SPECPDL_INDEX ();
2824 int fact
= 4 * sizeof (LWLIB_ID
);
2826 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2827 record_unwind_protect (xdialog_show_unwind
,
2828 Fcons (make_number (dialog_id
>> (fact
)),
2829 make_number (dialog_id
& ~(-1 << (fact
)))));
2831 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
, 1);
2833 unbind_to (count
, Qnil
);
2837 #endif /* not USE_GTK */
2839 static char * button_names
[] = {
2840 "button1", "button2", "button3", "button4", "button5",
2841 "button6", "button7", "button8", "button9", "button10" };
2844 xdialog_show (f
, keymaps
, title
, error
)
2850 int i
, nb_buttons
=0;
2851 char dialog_name
[6];
2853 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2855 /* Number of elements seen so far, before boundary. */
2857 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2858 int boundary_seen
= 0;
2862 if (menu_items_n_panes
> 1)
2864 *error
= "Multiple panes in dialog box";
2868 /* Create a tree of widget_value objects
2869 representing the text label and buttons. */
2871 Lisp_Object pane_name
, prefix
;
2873 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2874 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2875 pane_string
= (NILP (pane_name
)
2876 ? "" : (char *) SDATA (pane_name
));
2877 prev_wv
= xmalloc_widget_value ();
2878 prev_wv
->value
= pane_string
;
2879 if (keymaps
&& !NILP (prefix
))
2881 prev_wv
->enabled
= 1;
2882 prev_wv
->name
= "message";
2883 prev_wv
->help
= Qnil
;
2886 /* Loop over all panes and items, filling in the tree. */
2887 i
= MENU_ITEMS_PANE_LENGTH
;
2888 while (i
< menu_items_used
)
2891 /* Create a new item within current pane. */
2892 Lisp_Object item_name
, enable
, descrip
;
2893 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2894 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2896 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2898 if (NILP (item_name
))
2900 free_menubar_widget_value_tree (first_wv
);
2901 *error
= "Submenu in dialog items";
2904 if (EQ (item_name
, Qquote
))
2906 /* This is the boundary between left-side elts
2907 and right-side elts. Stop incrementing right_count. */
2912 if (nb_buttons
>= 9)
2914 free_menubar_widget_value_tree (first_wv
);
2915 *error
= "Too many dialog items";
2919 wv
= xmalloc_widget_value ();
2921 wv
->name
= (char *) button_names
[nb_buttons
];
2922 if (!NILP (descrip
))
2923 wv
->key
= (char *) SDATA (descrip
);
2924 wv
->value
= (char *) SDATA (item_name
);
2925 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2926 wv
->enabled
= !NILP (enable
);
2930 if (! boundary_seen
)
2934 i
+= MENU_ITEMS_ITEM_LENGTH
;
2937 /* If the boundary was not specified,
2938 by default put half on the left and half on the right. */
2939 if (! boundary_seen
)
2940 left_count
= nb_buttons
- nb_buttons
/ 2;
2942 wv
= xmalloc_widget_value ();
2943 wv
->name
= dialog_name
;
2945 /* Dialog boxes use a really stupid name encoding
2946 which specifies how many buttons to use
2947 and how many buttons are on the right.
2948 The Q means something also. */
2949 dialog_name
[0] = 'Q';
2950 dialog_name
[1] = '0' + nb_buttons
;
2951 dialog_name
[2] = 'B';
2952 dialog_name
[3] = 'R';
2953 /* Number of buttons to put on the right. */
2954 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2956 wv
->contents
= first_wv
;
2960 /* No selection has been chosen yet. */
2961 menu_item_selection
= 0;
2963 /* Actually create and show the dialog. */
2964 create_and_show_dialog (f
, first_wv
);
2966 /* Free the widget_value objects we used to specify the contents. */
2967 free_menubar_widget_value_tree (first_wv
);
2969 /* Find the selected item, and its pane, to return
2970 the proper value. */
2971 if (menu_item_selection
!= 0)
2977 while (i
< menu_items_used
)
2981 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2984 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2985 i
+= MENU_ITEMS_PANE_LENGTH
;
2987 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2989 /* This is the boundary between left-side elts and
2996 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2997 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3001 entry
= Fcons (entry
, Qnil
);
3003 entry
= Fcons (prefix
, entry
);
3007 i
+= MENU_ITEMS_ITEM_LENGTH
;
3015 #else /* not USE_X_TOOLKIT && not USE_GTK */
3017 /* The frame of the last activated non-toolkit menu bar.
3018 Used to generate menu help events. */
3020 static struct frame
*menu_help_frame
;
3023 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3025 PANE is the pane number, and ITEM is the menu item number in
3026 the menu (currently not used).
3028 This cannot be done with generating a HELP_EVENT because
3029 XMenuActivate contains a loop that doesn't let Emacs process
3033 menu_help_callback (help_string
, pane
, item
)
3037 extern Lisp_Object Qmenu_item
;
3038 Lisp_Object
*first_item
;
3039 Lisp_Object pane_name
;
3040 Lisp_Object menu_object
;
3042 first_item
= XVECTOR (menu_items
)->contents
;
3043 if (EQ (first_item
[0], Qt
))
3044 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3045 else if (EQ (first_item
[0], Qquote
))
3046 /* This shouldn't happen, see xmenu_show. */
3047 pane_name
= empty_string
;
3049 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3051 /* (menu-item MENU-NAME PANE-NUMBER) */
3052 menu_object
= Fcons (Qmenu_item
,
3054 Fcons (make_number (pane
), Qnil
)));
3055 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3056 Qnil
, menu_object
, make_number (item
), 1);
3061 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3071 int pane
, selidx
, lpane
, status
;
3072 Lisp_Object entry
, pane_prefix
;
3074 int ulx
, uly
, width
, height
;
3075 int dispwidth
, dispheight
;
3079 unsigned int dummy_uint
;
3082 if (menu_items_n_panes
== 0)
3085 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3087 *error
= "Empty menu";
3091 /* Figure out which root window F is on. */
3092 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3093 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3094 &dummy_uint
, &dummy_uint
);
3096 /* Make the menu on that window. */
3097 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3100 *error
= "Can't create menu";
3104 #ifdef HAVE_X_WINDOWS
3105 /* Adjust coordinates to relative to the outer (window manager) window. */
3108 int win_x
= 0, win_y
= 0;
3110 /* Find the position of the outside upper-left corner of
3111 the inner window, with respect to the outer window. */
3112 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
3115 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3117 /* From-window, to-window. */
3118 f
->output_data
.x
->window_desc
,
3119 f
->output_data
.x
->parent_desc
,
3121 /* From-position, to-position. */
3122 0, 0, &win_x
, &win_y
,
3124 /* Child of window. */
3131 #endif /* HAVE_X_WINDOWS */
3133 /* Adjust coordinates to be root-window-relative. */
3134 x
+= f
->output_data
.x
->left_pos
;
3135 y
+= f
->output_data
.x
->top_pos
;
3137 /* Create all the necessary panes and their items. */
3139 while (i
< menu_items_used
)
3141 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3143 /* Create a new pane. */
3144 Lisp_Object pane_name
, prefix
;
3147 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3148 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3149 pane_string
= (NILP (pane_name
)
3150 ? "" : (char *) SDATA (pane_name
));
3151 if (keymaps
&& !NILP (prefix
))
3154 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3155 if (lpane
== XM_FAILURE
)
3157 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3158 *error
= "Can't create pane";
3161 i
+= MENU_ITEMS_PANE_LENGTH
;
3163 /* Find the width of the widest item in this pane. */
3166 while (j
< menu_items_used
)
3169 item
= XVECTOR (menu_items
)->contents
[j
];
3177 width
= SBYTES (item
);
3178 if (width
> maxwidth
)
3181 j
+= MENU_ITEMS_ITEM_LENGTH
;
3184 /* Ignore a nil in the item list.
3185 It's meaningful only for dialog boxes. */
3186 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3190 /* Create a new item within current pane. */
3191 Lisp_Object item_name
, enable
, descrip
, help
;
3192 unsigned char *item_data
;
3195 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3196 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3198 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3199 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3200 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3202 if (!NILP (descrip
))
3204 int gap
= maxwidth
- SBYTES (item_name
);
3207 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3208 item_name
= concat2 (item_name
, spacer
);
3209 item_name
= concat2 (item_name
, descrip
);
3210 item_data
= SDATA (item_name
);
3212 /* if alloca is fast, use that to make the space,
3213 to reduce gc needs. */
3215 = (unsigned char *) alloca (maxwidth
3216 + SBYTES (descrip
) + 1);
3217 bcopy (SDATA (item_name
), item_data
,
3218 SBYTES (item_name
));
3219 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3221 bcopy (SDATA (descrip
), item_data
+ j
,
3223 item_data
[j
+ SBYTES (descrip
)] = 0;
3227 item_data
= SDATA (item_name
);
3229 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3230 menu
, lpane
, 0, item_data
,
3231 !NILP (enable
), help_string
)
3234 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3235 *error
= "Can't add selection to menu";
3238 i
+= MENU_ITEMS_ITEM_LENGTH
;
3242 /* All set and ready to fly. */
3243 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3244 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3245 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3246 x
= min (x
, dispwidth
);
3247 y
= min (y
, dispheight
);
3250 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3251 &ulx
, &uly
, &width
, &height
);
3252 if (ulx
+width
> dispwidth
)
3254 x
-= (ulx
+ width
) - dispwidth
;
3255 ulx
= dispwidth
- width
;
3257 if (uly
+height
> dispheight
)
3259 y
-= (uly
+ height
) - dispheight
;
3260 uly
= dispheight
- height
;
3262 if (ulx
< 0) x
-= ulx
;
3263 if (uly
< 0) y
-= uly
;
3265 XMenuSetAEQ (menu
, TRUE
);
3266 XMenuSetFreeze (menu
, TRUE
);
3269 /* Help display under X won't work because XMenuActivate contains
3270 a loop that doesn't give Emacs a chance to process it. */
3271 menu_help_frame
= f
;
3272 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3273 x
, y
, ButtonReleaseMask
, &datap
,
3274 menu_help_callback
);
3277 #ifdef HAVE_X_WINDOWS
3278 /* Assume the mouse has moved out of the X window.
3279 If it has actually moved in, we will get an EnterNotify. */
3280 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3287 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3290 /* Find the item number SELIDX in pane number PANE. */
3292 while (i
< menu_items_used
)
3294 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3298 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3300 i
+= MENU_ITEMS_PANE_LENGTH
;
3309 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3312 entry
= Fcons (entry
, Qnil
);
3313 if (!NILP (pane_prefix
))
3314 entry
= Fcons (pane_prefix
, entry
);
3320 i
+= MENU_ITEMS_ITEM_LENGTH
;
3326 *error
= "Can't activate menu";
3332 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3334 #ifdef HAVE_X_WINDOWS
3335 /* State that no mouse buttons are now held.
3336 (The oldXMenu code doesn't track this info for us.)
3337 That is not necessarily true, but the fiction leads to reasonable
3338 results, and it is a pain to ask which are actually held now. */
3339 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3345 #endif /* not USE_X_TOOLKIT */
3347 #endif /* HAVE_MENUS */
3352 staticpro (&menu_items
);
3354 menu_items_inuse
= Qnil
;
3356 Qdebug_on_next_call
= intern ("debug-on-next-call");
3357 staticpro (&Qdebug_on_next_call
);
3359 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3360 doc
: /* Frame for which we are updating a menu.
3361 The enable predicate for a menu command should check this variable. */);
3362 Vmenu_updating_frame
= Qnil
;
3364 #ifdef USE_X_TOOLKIT
3365 widget_id_tick
= (1<<16);
3366 next_menubar_widget_id
= 1;
3369 defsubr (&Sx_popup_menu
);
3371 defsubr (&Sx_popup_dialog
);