1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* X pop-up deck-of-cards menu facility for gnuemacs.
23 * Written by Jon Arnold and Roman Budzianowski
24 * Mods and rewrite by Robert Krawitz
28 /* Modified by Fred Pierresteguy on December 93
29 to make the popup menus and menubar use the Xt. */
31 /* Rewritten for clarity and GC protection by rms in Feb 94. */
33 /* On 4.3 this loses if it comes after xterm.h. */
39 #include "termhooks.h"
43 #include "blockinput.h"
52 /* This may include sys/types.h, and that somehow loses
53 if this is not done before the other system files. */
57 /* Load sys/types.h if not already loaded.
58 In some systems loading it twice is suicidal. */
60 #include <sys/types.h>
63 #include "dispextern.h"
68 #include <X11/IntrinsicP.h>
69 #include <X11/CoreP.h>
70 #include <X11/StringDefs.h>
71 #include <X11/Shell.h>
73 #include <X11/Xaw/Paned.h>
74 #endif /* USE_LUCID */
75 #include "../lwlib/lwlib.h"
76 #else /* not USE_X_TOOLKIT */
77 #include "../oldXMenu/XMenu.h"
78 #endif /* not USE_X_TOOLKIT */
79 #endif /* HAVE_X_WINDOWS */
81 #define min(x,y) (((x) < (y)) ? (x) : (y))
82 #define max(x,y) (((x) > (y)) ? (x) : (y))
89 Lisp_Object Vmenu_updating_frame
;
91 Lisp_Object Qdebug_on_next_call
;
93 Lisp_Object Qmenu_alias
;
95 extern Lisp_Object Qmenu_enable
;
96 extern Lisp_Object Qmenu_bar
;
97 extern Lisp_Object Qmouse_click
, Qevent_kind
;
99 extern Lisp_Object Vdefine_key_rebound_commands
;
101 extern Lisp_Object Voverriding_local_map
;
102 extern Lisp_Object Voverriding_local_map_menu_flag
;
104 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
106 extern Lisp_Object Qmenu_bar_update_hook
;
109 extern void set_frame_menubar ();
110 extern void process_expose_from_menu ();
111 extern XtAppContext Xt_app_con
;
113 static Lisp_Object
xdialog_show ();
114 void popup_get_selection ();
117 static Lisp_Object
xmenu_show ();
118 static void keymap_panes ();
119 static void single_keymap_panes ();
120 static void list_of_panes ();
121 static void list_of_items ();
123 /* This holds a Lisp vector that holds the results of decoding
124 the keymaps or alist-of-alists that specify a menu.
126 It describes the panes and items within the panes.
128 Each pane is described by 3 elements in the vector:
129 t, the pane name, the pane's prefix key.
130 Then follow the pane's items, with 5 elements per item:
131 the item string, the enable flag, the item's value,
132 the definition, and the equivalent keyboard key's description string.
134 In some cases, multiple levels of menus may be described.
135 A single vector slot containing nil indicates the start of a submenu.
136 A single vector slot containing lambda indicates the end of a submenu.
137 The submenu follows a menu item which is the way to reach the submenu.
139 A single vector slot containing quote indicates that the
140 following items should appear on the right of a dialog box.
142 Using a Lisp vector to hold this information while we decode it
143 takes care of protecting all the data from GC. */
145 #define MENU_ITEMS_PANE_NAME 1
146 #define MENU_ITEMS_PANE_PREFIX 2
147 #define MENU_ITEMS_PANE_LENGTH 3
149 #define MENU_ITEMS_ITEM_NAME 0
150 #define MENU_ITEMS_ITEM_ENABLE 1
151 #define MENU_ITEMS_ITEM_VALUE 2
152 #define MENU_ITEMS_ITEM_EQUIV_KEY 3
153 #define MENU_ITEMS_ITEM_DEFINITION 4
154 #define MENU_ITEMS_ITEM_LENGTH 5
156 static Lisp_Object menu_items
;
158 /* Number of slots currently allocated in menu_items. */
159 static int menu_items_allocated
;
161 /* This is the index in menu_items of the first empty slot. */
162 static int menu_items_used
;
164 /* The number of panes currently recorded in menu_items,
165 excluding those within submenus. */
166 static int menu_items_n_panes
;
168 /* Current depth within submenus. */
169 static int menu_items_submenu_depth
;
171 /* Flag which when set indicates a dialog or menu has been posted by
172 Xt on behalf of one of the widget sets. */
173 static int popup_activated_flag
;
175 static int next_menubar_widget_id
;
177 /* This is set nonzero after the user activates the menu bar, and set
178 to zero again after the menu bars are redisplayed by prepare_menu_bar.
179 While it is nonzero, all calls to set_frame_menubar go deep.
181 I don't understand why this is needed, but it does seem to be
182 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
184 int pending_menu_activation
;
188 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
190 static struct frame
*
191 menubar_id_to_frame (id
)
194 Lisp_Object tail
, frame
;
197 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCONS (tail
)->cdr
)
199 frame
= XCONS (tail
)->car
;
200 if (!GC_FRAMEP (frame
))
203 if (f
->output_data
.nothing
== 1)
205 if (f
->output_data
.x
->id
== id
)
213 /* Initialize the menu_items structure if we haven't already done so.
214 Also mark it as currently empty. */
219 if (NILP (menu_items
))
221 menu_items_allocated
= 60;
222 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
226 menu_items_n_panes
= 0;
227 menu_items_submenu_depth
= 0;
230 /* Call at the end of generating the data in menu_items.
231 This fills in the number of items in the last pane. */
238 /* Call when finished using the data for the current menu
242 discard_menu_items ()
244 /* Free the structure if it is especially large.
245 Otherwise, hold on to it, to save time. */
246 if (menu_items_allocated
> 200)
249 menu_items_allocated
= 0;
253 /* Make the menu_items vector twice as large. */
259 int old_size
= menu_items_allocated
;
262 menu_items_allocated
*= 2;
263 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
264 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
265 old_size
* sizeof (Lisp_Object
));
268 /* Begin a submenu. */
271 push_submenu_start ()
273 if (menu_items_used
+ 1 > menu_items_allocated
)
276 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
277 menu_items_submenu_depth
++;
285 if (menu_items_used
+ 1 > menu_items_allocated
)
288 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
289 menu_items_submenu_depth
--;
292 /* Indicate boundary between left and right. */
295 push_left_right_boundary ()
297 if (menu_items_used
+ 1 > menu_items_allocated
)
300 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
303 /* Start a new menu pane in menu_items..
304 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
307 push_menu_pane (name
, prefix_vec
)
308 Lisp_Object name
, prefix_vec
;
310 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
313 if (menu_items_submenu_depth
== 0)
314 menu_items_n_panes
++;
315 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
316 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
317 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
320 /* Push one menu item into the current pane.
321 NAME is the string to display. ENABLE if non-nil means
322 this item can be selected. KEY is the key generated by
323 choosing this item, or nil if this item doesn't really have a definition.
324 DEF is the definition of this item.
325 EQUIV is the textual description of the keyboard equivalent for
326 this item (or nil if none). */
329 push_menu_item (name
, enable
, key
, def
, equiv
)
330 Lisp_Object name
, enable
, key
, def
, equiv
;
332 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
335 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
336 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
337 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
338 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
339 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
342 /* Figure out the current keyboard equivalent of a menu item ITEM1.
343 The item string for menu display should be ITEM_STRING.
344 Store the equivalent keyboard key sequence's
345 textual description into *DESCRIP_PTR.
346 Also cache them in the item itself.
347 Return the real definition to execute. */
350 menu_item_equiv_key (item_string
, item1
, descrip_ptr
)
351 Lisp_Object item_string
;
353 Lisp_Object
*descrip_ptr
;
355 /* This is the real definition--the function to run. */
357 /* This is the sublist that records cached equiv key data
358 so we can save time. */
359 Lisp_Object cachelist
;
360 /* These are the saved equivalent keyboard key sequence
361 and its key-description. */
362 Lisp_Object savedkey
, descrip
;
365 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
367 /* If a help string follows the item string, skip it. */
368 if (CONSP (XCONS (item1
)->cdr
)
369 && STRINGP (XCONS (XCONS (item1
)->cdr
)->car
))
370 item1
= XCONS (item1
)->cdr
;
374 /* Get out the saved equivalent-keyboard-key info. */
375 cachelist
= savedkey
= descrip
= Qnil
;
376 if (CONSP (def
) && CONSP (XCONS (def
)->car
)
377 && (NILP (XCONS (XCONS (def
)->car
)->car
)
378 || VECTORP (XCONS (XCONS (def
)->car
)->car
)))
380 cachelist
= XCONS (def
)->car
;
381 def
= XCONS (def
)->cdr
;
382 savedkey
= XCONS (cachelist
)->car
;
383 descrip
= XCONS (cachelist
)->cdr
;
386 GCPRO4 (def
, def1
, savedkey
, descrip
);
388 /* Is it still valid? */
390 if (!NILP (savedkey
))
391 def1
= Fkey_binding (savedkey
, Qnil
);
392 /* If not, update it. */
394 /* If the command is an alias for another
395 (such as easymenu.el and lmenu.el set it up),
396 check if the original command matches the cached command. */
397 && !(SYMBOLP (def
) && SYMBOLP (XSYMBOL (def
)->function
)
398 && EQ (def1
, XSYMBOL (def
)->function
))
399 /* If something had no key binding before, don't recheck it
400 because that is too slow--except if we have a list of rebound
401 commands in Vdefine_key_rebound_commands, do recheck any command
402 that appears in that list. */
403 && (NILP (cachelist
) || !NILP (savedkey
)
404 || (! EQ (Qt
, Vdefine_key_rebound_commands
)
405 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
)))))
409 /* If the command is an alias for another
410 (such as easymenu.el and lmenu.el set it up),
411 see if the original command name has equivalent keys. */
412 if (SYMBOLP (def
) && SYMBOLP (XSYMBOL (def
)->function
)
413 && ! NILP (Fget (def
, Qmenu_alias
)))
414 savedkey
= Fwhere_is_internal (XSYMBOL (def
)->function
,
417 /* Otherwise look up the specified command itself.
418 We don't try both, because that makes easymenu menus slow. */
419 savedkey
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
);
421 if (!NILP (savedkey
))
423 descrip
= Fkey_description (savedkey
);
424 descrip
= concat2 (make_string (" (", 3), descrip
);
425 descrip
= concat2 (descrip
, make_string (")", 1));
429 /* Cache the data we just got in a sublist of the menu binding. */
430 if (NILP (cachelist
))
432 CHECK_IMPURE (item1
);
433 XCONS (item1
)->cdr
= Fcons (Fcons (savedkey
, descrip
), def
);
437 XCONS (cachelist
)->car
= savedkey
;
438 XCONS (cachelist
)->cdr
= descrip
;
442 *descrip_ptr
= descrip
;
446 /* This is used as the handler when calling internal_condition_case_1. */
449 menu_item_enabled_p_1 (arg
)
452 /* If we got a quit from within the menu computation,
453 quit all the way out of it. This takes care of C-] in the debugger. */
454 if (CONSP (arg
) && EQ (XCONS (arg
)->car
, Qquit
))
455 Fsignal (Qquit
, Qnil
);
460 /* Return non-nil if the command DEF is enabled when used as a menu item.
461 This is based on looking for a menu-enable property.
462 If NOTREAL is set, don't bother really computing this. */
465 menu_item_enabled_p (def
, notreal
)
469 Lisp_Object enabled
, tem
;
476 /* No property, or nil, means enable.
477 Otherwise, enable if value is not nil. */
478 tem
= Fget (def
, Qmenu_enable
);
480 /* (condition-case nil (eval tem)
482 enabled
= internal_condition_case_1 (Feval
, tem
, Qerror
,
483 menu_item_enabled_p_1
);
488 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
489 and generate menu panes for them in menu_items.
490 If NOTREAL is nonzero,
491 don't bother really computing whether an item is enabled. */
494 keymap_panes (keymaps
, nmaps
, notreal
)
495 Lisp_Object
*keymaps
;
503 /* Loop over the given keymaps, making a pane for each map.
504 But don't make a pane that is empty--ignore that map instead.
505 P is the number of panes we have made so far. */
506 for (mapno
= 0; mapno
< nmaps
; mapno
++)
507 single_keymap_panes (keymaps
[mapno
], Qnil
, Qnil
, notreal
, 10);
509 finish_menu_items ();
512 /* This is a recursive subroutine of keymap_panes.
513 It handles one keymap, KEYMAP.
514 The other arguments are passed along
515 or point to local variables of the previous function.
516 If NOTREAL is nonzero,
517 don't bother really computing whether an item is enabled.
519 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
522 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
524 Lisp_Object pane_name
;
529 Lisp_Object pending_maps
;
530 Lisp_Object tail
, item
, item1
, item_string
, table
;
531 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
538 push_menu_pane (pane_name
, prefix
);
540 for (tail
= keymap
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
542 /* Look at each key binding, and if it has a menu string,
543 make a menu item from it. */
544 item
= XCONS (tail
)->car
;
547 item1
= XCONS (item
)->cdr
;
550 item_string
= XCONS (item1
)->car
;
551 if (STRINGP (item_string
))
553 /* This is the real definition--the function to run. */
555 /* These are the saved equivalent keyboard key sequence
556 and its key-description. */
558 Lisp_Object tem
, enabled
;
560 /* GCPRO because ...enabled_p will call eval
561 and ..._equiv_key may autoload something.
562 Protecting KEYMAP preserves everything we use;
563 aside from that, must protect whatever might be
564 a string. Since there's no GCPRO5, we refetch
565 item_string instead of protecting it. */
566 descrip
= def
= Qnil
;
567 GCPRO4 (keymap
, pending_maps
, def
, descrip
);
569 def
= menu_item_equiv_key (item_string
, item1
, &descrip
);
570 enabled
= menu_item_enabled_p (def
, notreal
);
574 item_string
= XCONS (item1
)->car
;
576 tem
= Fkeymapp (def
);
577 if (XSTRING (item_string
)->data
[0] == '@' && !NILP (tem
))
578 pending_maps
= Fcons (Fcons (def
, Fcons (item_string
, XCONS (item
)->car
)),
583 GCPRO4 (keymap
, pending_maps
, descrip
, item_string
);
584 submap
= get_keymap_1 (def
, 0, 1);
586 #ifndef USE_X_TOOLKIT
587 /* Indicate visually that this is a submenu. */
589 item_string
= concat2 (item_string
,
590 build_string (" >"));
592 /* If definition is nil, pass nil as the key. */
593 push_menu_item (item_string
, enabled
,
594 XCONS (item
)->car
, def
,
597 /* Display a submenu using the toolkit. */
600 push_submenu_start ();
601 single_keymap_panes (submap
, Qnil
,
602 XCONS (item
)->car
, notreal
,
611 else if (VECTORP (item
))
613 /* Loop over the char values represented in the vector. */
614 int len
= XVECTOR (item
)->size
;
616 for (c
= 0; c
< len
; c
++)
618 Lisp_Object character
;
619 XSETFASTINT (character
, c
);
620 item1
= XVECTOR (item
)->contents
[c
];
623 item_string
= XCONS (item1
)->car
;
624 if (STRINGP (item_string
))
628 /* These are the saved equivalent keyboard key sequence
629 and its key-description. */
631 Lisp_Object tem
, enabled
;
633 /* GCPRO because ...enabled_p will call eval
634 and ..._equiv_key may autoload something.
635 Protecting KEYMAP preserves everything we use;
636 aside from that, must protect whatever might be
637 a string. Since there's no GCPRO5, we refetch
638 item_string instead of protecting it. */
639 GCPRO4 (keymap
, pending_maps
, def
, descrip
);
640 descrip
= def
= Qnil
;
642 def
= menu_item_equiv_key (item_string
, item1
, &descrip
);
643 enabled
= menu_item_enabled_p (def
, notreal
);
647 item_string
= XCONS (item1
)->car
;
649 tem
= Fkeymapp (def
);
650 if (XSTRING (item_string
)->data
[0] == '@' && !NILP (tem
))
651 pending_maps
= Fcons (Fcons (def
, Fcons (item_string
, character
)),
656 GCPRO4 (keymap
, pending_maps
, descrip
, item_string
);
657 submap
= get_keymap_1 (def
, 0, 1);
659 #ifndef USE_X_TOOLKIT
661 item_string
= concat2 (item_string
,
662 build_string (" >"));
664 /* If definition is nil, pass nil as the key. */
665 push_menu_item (item_string
, enabled
, character
,
670 push_submenu_start ();
671 single_keymap_panes (submap
, Qnil
,
684 /* Process now any submenus which want to be panes at this level. */
685 while (!NILP (pending_maps
))
687 Lisp_Object elt
, eltcdr
, string
;
688 elt
= Fcar (pending_maps
);
689 eltcdr
= XCONS (elt
)->cdr
;
690 string
= XCONS (eltcdr
)->car
;
691 /* We no longer discard the @ from the beginning of the string here.
692 Instead, we do this in xmenu_show. */
693 single_keymap_panes (Fcar (elt
), string
,
694 XCONS (eltcdr
)->cdr
, notreal
, maxdepth
- 1);
695 pending_maps
= Fcdr (pending_maps
);
699 /* Push all the panes and items of a menu described by the
700 alist-of-alists MENU.
701 This handles old-fashioned calls to x-popup-menu. */
711 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
713 Lisp_Object elt
, pane_name
, pane_data
;
715 pane_name
= Fcar (elt
);
716 CHECK_STRING (pane_name
, 0);
717 push_menu_pane (pane_name
, Qnil
);
718 pane_data
= Fcdr (elt
);
719 CHECK_CONS (pane_data
, 0);
720 list_of_items (pane_data
);
723 finish_menu_items ();
726 /* Push the items in a single pane defined by the alist PANE. */
732 Lisp_Object tail
, item
, item1
;
734 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
738 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
);
739 else if (NILP (item
))
740 push_left_right_boundary ();
743 CHECK_CONS (item
, 0);
745 CHECK_STRING (item1
, 1);
746 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
);
751 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
752 "Pop up a deck-of-cards menu and return user's selection.\n\
753 POSITION is a position specification. This is either a mouse button event\n\
754 or a list ((XOFFSET YOFFSET) WINDOW)\n\
755 where XOFFSET and YOFFSET are positions in pixels from the top left\n\
756 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
757 This controls the position of the center of the first line\n\
758 in the first pane of the menu, not the top left of the menu as a whole.\n\
759 If POSITION is t, it means to use the current mouse position.\n\
761 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
762 The menu items come from key bindings that have a menu string as well as\n\
763 a definition; actually, the \"definition\" in such a key binding looks like\n\
764 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
765 the keymap as a top-level element.\n\n\
766 You can also use a list of keymaps as MENU.\n\
767 Then each keymap makes a separate pane.\n\
768 When MENU is a keymap or a list of keymaps, the return value\n\
769 is a list of events.\n\n\
770 Alternatively, you can specify a menu of multiple panes\n\
771 with a list of the form (TITLE PANE1 PANE2...),\n\
772 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
773 Each ITEM is normally a cons cell (STRING . VALUE);\n\
774 but a string can appear as an item--that makes a nonselectable line\n\
776 With this form of menu, the return value is VALUE from the chosen item.\n\
778 If POSITION is nil, don't display the menu at all, just precalculate the\n\
779 cached information about equivalent key sequences.")
781 Lisp_Object position
, menu
;
783 int number_of_panes
, panes
;
784 Lisp_Object keymap
, tem
;
788 Lisp_Object selection
;
791 Lisp_Object x
, y
, window
;
797 if (! NILP (position
))
801 /* Decode the first argument: find the window and the coordinates. */
802 if (EQ (position
, Qt
)
803 || (CONSP (position
) && EQ (XCONS (position
)->car
, Qmenu_bar
)))
805 /* Use the mouse's current position. */
806 FRAME_PTR new_f
= selected_frame
;
807 Lisp_Object bar_window
;
811 if (mouse_position_hook
)
812 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
813 &part
, &x
, &y
, &time
);
815 XSETFRAME (window
, new_f
);
818 window
= selected_window
;
825 tem
= Fcar (position
);
828 window
= Fcar (Fcdr (position
));
830 y
= Fcar (Fcdr (tem
));
835 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
836 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
837 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
846 /* Decode where to put the menu. */
854 else if (WINDOWP (window
))
856 CHECK_LIVE_WINDOW (window
, 0);
857 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
859 xpos
= (FONT_WIDTH (f
->output_data
.x
->font
) * XWINDOW (window
)->left
);
860 ypos
= (f
->output_data
.x
->line_height
* XWINDOW (window
)->top
);
863 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
864 but I don't want to make one now. */
865 CHECK_WINDOW (window
, 0);
870 XSETFRAME (Vmenu_updating_frame
, f
);
872 Vmenu_updating_frame
= Qnil
;
873 #endif /* HAVE_MENUS */
878 /* Decode the menu items from what was specified. */
880 keymap
= Fkeymapp (menu
);
883 tem
= Fkeymapp (Fcar (menu
));
886 /* We were given a keymap. Extract menu info from the keymap. */
888 keymap
= get_keymap (menu
);
890 /* Extract the detailed info to make one pane. */
891 keymap_panes (&menu
, 1, NILP (position
));
893 /* Search for a string appearing directly as an element of the keymap.
894 That string is the title of the menu. */
895 prompt
= map_prompt (keymap
);
896 if (NILP (title
) && !NILP (prompt
))
899 /* Make that be the pane title of the first pane. */
900 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
901 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
905 else if (!NILP (tem
))
907 /* We were given a list of keymaps. */
908 int nmaps
= XFASTINT (Flength (menu
));
910 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
915 /* The first keymap that has a prompt string
916 supplies the menu title. */
917 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
921 maps
[i
++] = keymap
= get_keymap (Fcar (tem
));
923 prompt
= map_prompt (keymap
);
924 if (NILP (title
) && !NILP (prompt
))
928 /* Extract the detailed info to make one pane. */
929 keymap_panes (maps
, nmaps
, NILP (position
));
931 /* Make the title be the pane title of the first pane. */
932 if (!NILP (title
) && menu_items_n_panes
>= 0)
933 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
939 /* We were given an old-fashioned menu. */
941 CHECK_STRING (title
, 1);
943 list_of_panes (Fcdr (menu
));
950 discard_menu_items ();
956 /* Display them in a menu. */
959 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
960 keymaps
, title
, &error_name
);
963 discard_menu_items ();
966 #endif /* HAVE_MENUS */
968 if (error_name
) error (error_name
);
974 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
975 "Pop up a dialog box and return user's selection.\n\
976 POSITION specifies which frame to use.\n\
977 This is normally a mouse button event or a window or frame.\n\
978 If POSITION is t, it means to use the frame the mouse is on.\n\
979 The dialog box appears in the middle of the specified frame.\n\
981 CONTENTS specifies the alternatives to display in the dialog box.\n\
982 It is a list of the form (TITLE ITEM1 ITEM2...).\n\
983 Each ITEM is a cons cell (STRING . VALUE).\n\
984 The return value is VALUE from the chosen item.\n\n\
985 An ITEM may also be just a string--that makes a nonselectable item.\n\
986 An ITEM may also be nil--that means to put all preceding items\n\
987 on the left of the dialog box and all following items on the right.\n\
988 \(By default, approximately half appear on each side.)")
990 Lisp_Object position
, contents
;
997 /* Decode the first argument: find the window or frame to use. */
998 if (EQ (position
, Qt
)
999 || (CONSP (position
) && EQ (XCONS (position
)->car
, Qmenu_bar
)))
1001 #if 0 /* Using the frame the mouse is on may not be right. */
1002 /* Use the mouse's current position. */
1003 FRAME_PTR new_f
= selected_frame
;
1004 Lisp_Object bar_window
;
1009 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1012 XSETFRAME (window
, new_f
);
1014 window
= selected_window
;
1016 window
= selected_window
;
1018 else if (CONSP (position
))
1021 tem
= Fcar (position
);
1023 window
= Fcar (Fcdr (position
));
1026 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1027 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1030 else if (WINDOWP (position
) || FRAMEP (position
))
1035 /* Decode where to put the menu. */
1037 if (FRAMEP (window
))
1038 f
= XFRAME (window
);
1039 else if (WINDOWP (window
))
1041 CHECK_LIVE_WINDOW (window
, 0);
1042 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1045 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1046 but I don't want to make one now. */
1047 CHECK_WINDOW (window
, 0);
1049 #ifndef USE_X_TOOLKIT
1050 /* Display a menu with these alternatives
1051 in the middle of frame F. */
1053 Lisp_Object x
, y
, frame
, newpos
;
1054 XSETFRAME (frame
, f
);
1055 XSETINT (x
, x_pixel_width (f
) / 2);
1056 XSETINT (y
, x_pixel_height (f
) / 2);
1057 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1059 return Fx_popup_menu (newpos
,
1060 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1066 Lisp_Object selection
;
1068 /* Decode the dialog items from what was specified. */
1069 title
= Fcar (contents
);
1070 CHECK_STRING (title
, 1);
1072 list_of_panes (Fcons (contents
, Qnil
));
1074 /* Display them in a dialog box. */
1076 selection
= xdialog_show (f
, 0, title
, &error_name
);
1079 discard_menu_items ();
1081 if (error_name
) error (error_name
);
1087 #ifdef USE_X_TOOLKIT
1089 /* Loop in Xt until the menu pulldown or dialog popup has been
1090 popped down (deactivated). This is used for x-popup-menu
1091 and x-popup-dialog; it is not used for the menu bar any more.
1093 NOTE: All calls to popup_get_selection should be protected
1094 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1097 popup_get_selection (initial_event
, dpyinfo
, id
)
1098 XEvent
*initial_event
;
1099 struct x_display_info
*dpyinfo
;
1104 /* Define a queue to save up for later unreading
1105 all X events that don't pertain to the menu. */
1109 struct event_queue
*next
;
1112 struct event_queue
*queue
= NULL
;
1113 struct event_queue
*queue_tmp
;
1116 event
= *initial_event
;
1118 XtAppNextEvent (Xt_app_con
, &event
);
1122 /* Handle expose events for editor frames right away. */
1123 if (event
.type
== Expose
)
1124 process_expose_from_menu (event
);
1125 /* Make sure we don't consider buttons grabbed after menu goes.
1126 And make sure to deactivate for any ButtonRelease,
1127 even if XtDispatchEvent doesn't do that. */
1128 else if (event
.type
== ButtonRelease
1129 && dpyinfo
->display
== event
.xbutton
.display
)
1131 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1132 popup_activated_flag
= 0;
1133 #ifdef USE_MOTIF /* Pretending that the event came from a
1134 Btn1Down seems the only way to convince Motif to
1135 activate its callbacks; setting the XmNmenuPost
1136 isn't working. --marcus@sysc.pdx.edu. */
1137 event
.xbutton
.button
= 1;
1140 /* If the user presses a key, deactivate the menu.
1141 The user is likely to do that if we get wedged. */
1142 else if (event
.type
== KeyPress
1143 && dpyinfo
->display
== event
.xbutton
.display
)
1145 popup_activated_flag
= 0;
1148 /* Button presses outside the menu also pop it down. */
1149 else if (event
.type
== ButtonPress
1150 && event
.xany
.display
== dpyinfo
->display
1151 && x_any_window_to_frame (dpyinfo
, event
.xany
.window
))
1153 popup_activated_flag
= 0;
1157 /* Queue all events not for this popup,
1158 except for Expose, which we've already handled, and ButtonRelease.
1159 Note that the X window is associated with the frame if this
1160 is a menu bar popup, but not if it's a dialog box. So we use
1161 x_non_menubar_window_to_frame, not x_any_window_to_frame. */
1162 if (event
.type
!= Expose
1163 && !(event
.type
== ButtonRelease
1164 && dpyinfo
->display
== event
.xbutton
.display
)
1165 && (event
.xany
.display
!= dpyinfo
->display
1166 || x_non_menubar_window_to_frame (dpyinfo
, event
.xany
.window
)))
1168 queue_tmp
= (struct event_queue
*) malloc (sizeof (struct event_queue
));
1170 if (queue_tmp
!= NULL
)
1172 queue_tmp
->event
= event
;
1173 queue_tmp
->next
= queue
;
1178 XtDispatchEvent (&event
);
1180 if (!popup_activated ())
1182 XtAppNextEvent (Xt_app_con
, &event
);
1185 /* Unread any events that we got but did not handle. */
1186 while (queue
!= NULL
)
1189 XPutBackEvent (queue_tmp
->event
.xany
.display
, &queue_tmp
->event
);
1190 queue
= queue_tmp
->next
;
1191 free ((char *)queue_tmp
);
1192 /* Cause these events to get read as soon as we UNBLOCK_INPUT. */
1193 interrupt_input_pending
= 1;
1197 /* Activate the menu bar of frame F.
1198 This is called from keyboard.c when it gets the
1199 menu_bar_activate_event out of the Emacs event queue.
1201 To activate the menu bar, we use the X button-press event
1202 that was saved in saved_menu_event.
1203 That makes the toolkit do its thing.
1205 But first we recompute the menu bar contents (the whole tree).
1207 The reason for saving the button event until here, instead of
1208 passing it to the toolkit right away, is that we can safely
1209 execute Lisp code. */
1211 x_activate_menubar (f
)
1214 if (!f
->output_data
.x
->saved_menu_event
->type
)
1217 set_frame_menubar (f
, 0, 1);
1219 XtDispatchEvent ((XEvent
*) f
->output_data
.x
->saved_menu_event
);
1222 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1223 pending_menu_activation
= 1;
1226 /* Ignore this if we get it a second time. */
1227 f
->output_data
.x
->saved_menu_event
->type
= 0;
1230 /* Detect if a dialog or menu has been posted. */
1235 return popup_activated_flag
;
1239 /* This callback is invoked when the user selects a menubar cascade
1240 pushbutton, but before the pulldown menu is posted. */
1243 popup_activate_callback (widget
, id
, client_data
)
1246 XtPointer client_data
;
1248 popup_activated_flag
= 1;
1251 /* This callback is called from the menu bar pulldown menu
1252 when the user makes a selection.
1253 Figure out what the user chose
1254 and put the appropriate events into the keyboard buffer. */
1257 menubar_selection_callback (widget
, id
, client_data
)
1260 XtPointer client_data
;
1262 Lisp_Object prefix
, entry
;
1263 FRAME_PTR f
= menubar_id_to_frame (id
);
1265 Lisp_Object
*subprefix_stack
;
1266 int submenu_depth
= 0;
1271 subprefix_stack
= (Lisp_Object
*) alloca (f
->menu_bar_items_used
* sizeof (Lisp_Object
));
1272 vector
= f
->menu_bar_vector
;
1275 while (i
< f
->menu_bar_items_used
)
1277 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1279 subprefix_stack
[submenu_depth
++] = prefix
;
1283 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1285 prefix
= subprefix_stack
[--submenu_depth
];
1288 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1290 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1291 i
+= MENU_ITEMS_PANE_LENGTH
;
1295 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1296 /* The EMACS_INT cast avoids a warning. There's no problem
1297 as long as pointers have enough bits to hold small integers. */
1298 if ((int) (EMACS_INT
) client_data
== i
)
1301 struct input_event buf
;
1304 XSETFRAME (frame
, f
);
1305 buf
.kind
= menu_bar_event
;
1306 buf
.frame_or_window
= Fcons (frame
, Fcons (Qmenu_bar
, Qnil
));
1307 kbd_buffer_store_event (&buf
);
1309 for (j
= 0; j
< submenu_depth
; j
++)
1310 if (!NILP (subprefix_stack
[j
]))
1312 buf
.kind
= menu_bar_event
;
1313 buf
.frame_or_window
= Fcons (frame
, subprefix_stack
[j
]);
1314 kbd_buffer_store_event (&buf
);
1319 buf
.kind
= menu_bar_event
;
1320 buf
.frame_or_window
= Fcons (frame
, prefix
);
1321 kbd_buffer_store_event (&buf
);
1324 buf
.kind
= menu_bar_event
;
1325 buf
.frame_or_window
= Fcons (frame
, entry
);
1326 kbd_buffer_store_event (&buf
);
1330 i
+= MENU_ITEMS_ITEM_LENGTH
;
1335 /* This callback is invoked when a dialog or menu is finished being
1336 used and has been unposted. */
1339 popup_deactivate_callback (widget
, id
, client_data
)
1342 XtPointer client_data
;
1344 popup_activated_flag
= 0;
1347 /* Allocate a widget_value, blocking input. */
1350 xmalloc_widget_value ()
1352 widget_value
*value
;
1355 value
= malloc_widget_value ();
1361 /* This recursively calls free_widget_value on the tree of widgets.
1362 It must free all data that was malloc'ed for these widget_values.
1363 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1364 must be left alone. */
1367 free_menubar_widget_value_tree (wv
)
1372 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1374 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1376 free_menubar_widget_value_tree (wv
->contents
);
1377 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1381 free_menubar_widget_value_tree (wv
->next
);
1382 wv
->next
= (widget_value
*) 0xDEADBEEF;
1385 free_widget_value (wv
);
1389 /* Return a tree of widget_value structures for a menu bar item
1390 whose event type is ITEM_KEY (with string ITEM_NAME)
1391 and whose contents come from the list of keymaps MAPS. */
1393 static widget_value
*
1394 single_submenu (item_key
, item_name
, maps
)
1395 Lisp_Object item_key
, item_name
, maps
;
1397 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1399 int submenu_depth
= 0;
1402 Lisp_Object
*mapvec
;
1403 widget_value
**submenu_stack
;
1405 int previous_items
= menu_items_used
;
1406 int top_level_items
= 0;
1408 length
= Flength (maps
);
1409 len
= XINT (length
);
1411 /* Convert the list MAPS into a vector MAPVEC. */
1412 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1413 for (i
= 0; i
< len
; i
++)
1415 mapvec
[i
] = Fcar (maps
);
1419 menu_items_n_panes
= 0;
1421 /* Loop over the given keymaps, making a pane for each map.
1422 But don't make a pane that is empty--ignore that map instead. */
1423 for (i
= 0; i
< len
; i
++)
1425 if (SYMBOLP (mapvec
[i
])
1426 || (CONSP (mapvec
[i
])
1427 && NILP (Fkeymapp (mapvec
[i
]))))
1429 /* Here we have a command at top level in the menu bar
1430 as opposed to a submenu. */
1431 top_level_items
= 1;
1432 push_menu_pane (Qnil
, Qnil
);
1433 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
], Qnil
);
1436 single_keymap_panes (mapvec
[i
], item_name
, item_key
, 0, 10);
1439 /* Create a tree of widget_value objects
1440 representing the panes and their items. */
1443 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1444 wv
= xmalloc_widget_value ();
1452 /* Loop over all panes and items made during this call
1453 and construct a tree of widget_value objects.
1454 Ignore the panes and items made by previous calls to
1455 single_submenu, even though those are also in menu_items. */
1457 while (i
< menu_items_used
)
1459 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1461 submenu_stack
[submenu_depth
++] = save_wv
;
1466 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1469 save_wv
= submenu_stack
[--submenu_depth
];
1472 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1473 && submenu_depth
!= 0)
1474 i
+= MENU_ITEMS_PANE_LENGTH
;
1475 /* Ignore a nil in the item list.
1476 It's meaningful only for dialog boxes. */
1477 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1479 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1481 /* Create a new pane. */
1482 Lisp_Object pane_name
, prefix
;
1484 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1485 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1486 pane_string
= (NILP (pane_name
)
1487 ? "" : (char *) XSTRING (pane_name
)->data
);
1488 /* If there is just one top-level pane, put all its items directly
1489 under the top-level menu. */
1490 if (menu_items_n_panes
== 1)
1493 /* If the pane has a meaningful name,
1494 make the pane a top-level menu item
1495 with its items as a submenu beneath it. */
1496 if (strcmp (pane_string
, ""))
1498 wv
= xmalloc_widget_value ();
1502 first_wv
->contents
= wv
;
1503 wv
->name
= pane_string
;
1504 /* Ignore the @ that means "separate pane".
1505 This is a kludge, but this isn't worth more time. */
1506 if (!NILP (prefix
) && wv
->name
[0] == '@')
1513 i
+= MENU_ITEMS_PANE_LENGTH
;
1517 /* Create a new item within current pane. */
1518 Lisp_Object item_name
, enable
, descrip
, def
;
1519 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1520 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1522 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1523 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
1525 wv
= xmalloc_widget_value ();
1529 save_wv
->contents
= wv
;
1531 wv
->name
= (char *) XSTRING (item_name
)->data
;
1532 if (!NILP (descrip
))
1533 wv
->key
= (char *) XSTRING (descrip
)->data
;
1535 /* The EMACS_INT cast avoids a warning. There's no problem
1536 as long as pointers have enough bits to hold small integers. */
1537 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1538 wv
->enabled
= !NILP (enable
);
1541 i
+= MENU_ITEMS_ITEM_LENGTH
;
1545 /* If we have just one "menu item"
1546 that was originally a button, return it by itself. */
1547 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1549 wv
= first_wv
->contents
;
1550 free_widget_value (first_wv
);
1557 extern void EmacsFrameSetCharSize ();
1559 /* Recompute all the widgets of frame F, when the menu bar
1560 has been changed. */
1563 update_frame_menubar (f
)
1566 struct x_output
*x
= f
->output_data
.x
;
1568 int menubar_changed
;
1570 Dimension shell_height
;
1572 /* We assume the menubar contents has changed if the global flag is set,
1573 or if the current buffer has changed, or if the menubar has never
1574 been updated before.
1576 menubar_changed
= (x
->menubar_widget
1577 && !XtIsManaged (x
->menubar_widget
));
1579 if (! (menubar_changed
))
1583 /* Save the size of the frame because the pane widget doesn't accept to
1584 resize itself. So force it. */
1588 /* Do the voodoo which means "I'm changing lots of things, don't try to
1589 refigure sizes until I'm done." */
1590 lw_refigure_widget (x
->column_widget
, False
);
1592 /* the order in which children are managed is the top to
1593 bottom order in which they are displayed in the paned window.
1594 First, remove the text-area widget.
1596 XtUnmanageChild (x
->edit_widget
);
1598 /* remove the menubar that is there now, and put up the menubar that
1601 if (menubar_changed
)
1603 XtManageChild (x
->menubar_widget
);
1604 XtMapWidget (x
->menubar_widget
);
1605 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, 0);
1608 /* Re-manage the text-area widget, and then thrash the sizes. */
1609 XtManageChild (x
->edit_widget
);
1610 lw_refigure_widget (x
->column_widget
, True
);
1612 /* Force the pane widget to resize itself with the right values. */
1613 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1618 /* Set the contents of the menubar widgets of frame F.
1619 The argument FIRST_TIME is currently ignored;
1620 it is set the first time this is called, from initialize_frame_menubar. */
1623 set_frame_menubar (f
, first_time
, deep_p
)
1628 Widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1629 Lisp_Object tail
, items
, frame
;
1630 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1634 XSETFRAME (Vmenu_updating_frame
, f
);
1636 if (f
->output_data
.x
->id
== 0)
1637 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1638 id
= f
->output_data
.x
->id
;
1640 if (! menubar_widget
)
1642 else if (pending_menu_activation
&& !deep_p
)
1644 /* Make the first call for any given frame always go deep. */
1645 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1648 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1649 f
->output_data
.x
->saved_menu_event
->type
= 0;
1652 wv
= xmalloc_widget_value ();
1653 wv
->name
= "menubar";
1660 /* Make a widget-value tree representing the entire menu trees. */
1662 struct buffer
*prev
= current_buffer
;
1664 int specpdl_count
= specpdl_ptr
- specpdl
;
1665 int previous_menu_items_used
= f
->menu_bar_items_used
;
1666 Lisp_Object
*previous_items
1667 = (Lisp_Object
*) alloca (previous_menu_items_used
1668 * sizeof (Lisp_Object
));
1670 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1671 specbind (Qinhibit_quit
, Qt
);
1672 /* Don't let the debugger step into this code
1673 because it is not reentrant. */
1674 specbind (Qdebug_on_next_call
, Qnil
);
1676 record_unwind_protect (Fstore_match_data
, Fmatch_data (Qnil
, Qnil
));
1677 if (NILP (Voverriding_local_map_menu_flag
))
1679 specbind (Qoverriding_terminal_local_map
, Qnil
);
1680 specbind (Qoverriding_local_map
, Qnil
);
1683 set_buffer_internal_1 (XBUFFER (buffer
));
1685 /* Run the Lucid hook. */
1686 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1687 /* If it has changed current-menubar from previous value,
1688 really recompute the menubar from the value. */
1689 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1690 call0 (Qrecompute_lucid_menubar
);
1691 safe_run_hooks (Qmenu_bar_update_hook
);
1692 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1694 items
= FRAME_MENU_BAR_ITEMS (f
);
1696 inhibit_garbage_collection ();
1698 /* Save the frame's previous menu bar contents data. */
1699 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1700 previous_menu_items_used
* sizeof (Lisp_Object
));
1702 /* Fill in the current menu bar contents. */
1703 menu_items
= f
->menu_bar_vector
;
1704 menu_items_allocated
= XVECTOR (menu_items
)->size
;
1706 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1708 Lisp_Object key
, string
, maps
;
1710 key
= XVECTOR (items
)->contents
[i
];
1711 string
= XVECTOR (items
)->contents
[i
+ 1];
1712 maps
= XVECTOR (items
)->contents
[i
+ 2];
1716 wv
= single_submenu (key
, string
, maps
);
1720 first_wv
->contents
= wv
;
1721 /* Don't set wv->name here; GC during the loop might relocate it. */
1726 finish_menu_items ();
1728 set_buffer_internal_1 (prev
);
1729 unbind_to (specpdl_count
, Qnil
);
1731 /* If there has been no change in the Lisp-level contents
1732 of the menu bar, skip redisplaying it. Just exit. */
1734 for (i
= 0; i
< previous_menu_items_used
; i
++)
1735 if (menu_items_used
== i
1736 || (previous_items
[i
] != XVECTOR (menu_items
)->contents
[i
]))
1738 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1740 free_menubar_widget_value_tree (first_wv
);
1746 /* Now GC cannot happen during the lifetime of the widget_value,
1747 so it's safe to store data from a Lisp_String. */
1748 wv
= first_wv
->contents
;
1749 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1752 string
= XVECTOR (items
)->contents
[i
+ 1];
1755 wv
->name
= (char *) XSTRING (string
)->data
;
1759 f
->menu_bar_vector
= menu_items
;
1760 f
->menu_bar_items_used
= menu_items_used
;
1765 /* Make a widget-value tree containing
1766 just the top level menu bar strings. */
1768 items
= FRAME_MENU_BAR_ITEMS (f
);
1769 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1773 string
= XVECTOR (items
)->contents
[i
+ 1];
1777 wv
= xmalloc_widget_value ();
1778 wv
->name
= (char *) XSTRING (string
)->data
;
1781 /* This prevents lwlib from assuming this
1782 menu item is really supposed to be empty. */
1783 /* The EMACS_INT cast avoids a warning.
1784 This value just has to be different from small integers. */
1785 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1790 first_wv
->contents
= wv
;
1794 /* Forget what we thought we knew about what is in the
1795 detailed contents of the menu bar menus.
1796 Changing the top level always destroys the contents. */
1797 f
->menu_bar_items_used
= 0;
1800 /* Create or update the menu bar widget. */
1806 /* Disable resizing (done for Motif!) */
1807 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1809 /* The third arg is DEEP_P, which says to consider the entire
1810 menu trees we supply, rather than just the menu bar item names. */
1811 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1813 /* Re-enable the edit widget to resize. */
1814 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1818 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1819 f
->output_data
.x
->column_widget
,
1821 popup_activate_callback
,
1822 menubar_selection_callback
,
1823 popup_deactivate_callback
);
1824 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1829 = (f
->output_data
.x
->menubar_widget
1830 ? (f
->output_data
.x
->menubar_widget
->core
.height
1831 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1834 #if 0 /* Experimentally, we now get the right results
1835 for -geometry -0-0 without this. 24 Aug 96, rms. */
1837 if (FRAME_EXTERNAL_MENU_BAR (f
))
1840 XtVaGetValues (f
->output_data
.x
->column_widget
,
1841 XtNinternalBorderWidth
, &ibw
, NULL
);
1842 menubar_size
+= ibw
;
1844 #endif /* USE_LUCID */
1847 f
->output_data
.x
->menubar_height
= menubar_size
;
1850 free_menubar_widget_value_tree (first_wv
);
1852 update_frame_menubar (f
);
1857 /* Called from Fx_create_frame to create the initial menubar of a frame
1858 before it is mapped, so that the window is mapped with the menubar already
1859 there instead of us tacking it on later and thrashing the window after it
1863 initialize_frame_menubar (f
)
1866 /* This function is called before the first chance to redisplay
1867 the frame. It has to be, so the frame will have the right size. */
1868 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1869 set_frame_menubar (f
, 1, 1);
1872 /* Get rid of the menu bar of frame F, and free its storage.
1873 This is used when deleting a frame, and when turning off the menu bar. */
1876 free_frame_menubar (f
)
1879 Widget menubar_widget
;
1882 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1887 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1892 #endif /* USE_X_TOOLKIT */
1894 /* xmenu_show actually displays a menu using the panes and items in menu_items
1895 and returns the value selected from it.
1896 There are two versions of xmenu_show, one for Xt and one for Xlib.
1897 Both assume input is blocked by the caller. */
1899 /* F is the frame the menu is for.
1900 X and Y are the frame-relative specified position,
1901 relative to the inside upper left corner of the frame F.
1902 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1903 KEYMAPS is 1 if this menu was specified with keymaps;
1904 in that case, we return a list containing the chosen item's value
1905 and perhaps also the pane's prefix.
1906 TITLE is the specified menu title.
1907 ERROR is a place to store an error message string in case of failure.
1908 (We return nil on failure, but the value doesn't actually matter.) */
1910 #ifdef USE_X_TOOLKIT
1912 /* We need a unique id for each widget handled by the Lucid Widget
1915 For the main windows, and popup menus, we use this counter,
1916 which we increment each time after use. This starts from 1<<16.
1918 For menu bars, we use numbers starting at 0, counted in
1919 next_menubar_widget_id. */
1920 LWLIB_ID widget_id_tick
;
1923 static Lisp_Object
*volatile menu_item_selection
;
1925 static Lisp_Object
*menu_item_selection
;
1929 popup_selection_callback (widget
, id
, client_data
)
1932 XtPointer client_data
;
1934 menu_item_selection
= (Lisp_Object
*) client_data
;
1938 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
1952 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1953 widget_value
**submenu_stack
1954 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1955 Lisp_Object
*subprefix_stack
1956 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1957 int submenu_depth
= 0;
1958 XButtonPressedEvent dummy
;
1961 int next_release_must_exit
= 0;
1965 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1967 *error
= "Empty menu";
1971 /* Create a tree of widget_value objects
1972 representing the panes and their items. */
1973 wv
= xmalloc_widget_value ();
1980 /* Loop over all panes and items, filling in the tree. */
1982 while (i
< menu_items_used
)
1984 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1986 submenu_stack
[submenu_depth
++] = save_wv
;
1992 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1995 save_wv
= submenu_stack
[--submenu_depth
];
1999 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2000 && submenu_depth
!= 0)
2001 i
+= MENU_ITEMS_PANE_LENGTH
;
2002 /* Ignore a nil in the item list.
2003 It's meaningful only for dialog boxes. */
2004 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2006 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2008 /* Create a new pane. */
2009 Lisp_Object pane_name
, prefix
;
2011 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2012 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2013 pane_string
= (NILP (pane_name
)
2014 ? "" : (char *) XSTRING (pane_name
)->data
);
2015 /* If there is just one top-level pane, put all its items directly
2016 under the top-level menu. */
2017 if (menu_items_n_panes
== 1)
2020 /* If the pane has a meaningful name,
2021 make the pane a top-level menu item
2022 with its items as a submenu beneath it. */
2023 if (!keymaps
&& strcmp (pane_string
, ""))
2025 wv
= xmalloc_widget_value ();
2029 first_wv
->contents
= wv
;
2030 wv
->name
= pane_string
;
2031 if (keymaps
&& !NILP (prefix
))
2038 else if (first_pane
)
2044 i
+= MENU_ITEMS_PANE_LENGTH
;
2048 /* Create a new item within current pane. */
2049 Lisp_Object item_name
, enable
, descrip
, def
;
2050 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2051 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2053 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2054 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
2056 wv
= xmalloc_widget_value ();
2060 save_wv
->contents
= wv
;
2061 wv
->name
= (char *) XSTRING (item_name
)->data
;
2062 if (!NILP (descrip
))
2063 wv
->key
= (char *) XSTRING (descrip
)->data
;
2065 /* If this item has a null value,
2066 make the call_data null so that it won't display a box
2067 when the mouse is on it. */
2069 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2070 wv
->enabled
= !NILP (enable
);
2073 i
+= MENU_ITEMS_ITEM_LENGTH
;
2077 /* Deal with the title, if it is non-nil. */
2080 widget_value
*wv_title
= xmalloc_widget_value ();
2081 widget_value
*wv_sep1
= xmalloc_widget_value ();
2082 widget_value
*wv_sep2
= xmalloc_widget_value ();
2084 wv_sep2
->name
= "--";
2085 wv_sep2
->next
= first_wv
->contents
;
2087 wv_sep1
->name
= "--";
2088 wv_sep1
->next
= wv_sep2
;
2090 wv_title
->name
= (char *) XSTRING (title
)->data
;
2091 wv_title
->enabled
= True
;
2092 wv_title
->next
= wv_sep1
;
2093 first_wv
->contents
= wv_title
;
2096 /* Actually create the menu. */
2097 menu_id
= widget_id_tick
++;
2098 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2099 f
->output_data
.x
->widget
, 1, 0,
2100 popup_selection_callback
,
2101 popup_deactivate_callback
);
2103 /* Adjust coordinates to relative to the outer (window manager) window. */
2106 int win_x
= 0, win_y
= 0;
2108 /* Find the position of the outside upper-left corner of
2109 the inner window, with respect to the outer window. */
2110 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2113 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2115 /* From-window, to-window. */
2116 f
->output_data
.x
->window_desc
,
2117 f
->output_data
.x
->parent_desc
,
2119 /* From-position, to-position. */
2120 0, 0, &win_x
, &win_y
,
2122 /* Child of window. */
2130 /* Adjust coordinates to be root-window-relative. */
2131 x
+= f
->output_data
.x
->left_pos
;
2132 y
+= f
->output_data
.x
->top_pos
;
2134 dummy
.type
= ButtonPress
;
2136 dummy
.send_event
= 0;
2137 dummy
.display
= FRAME_X_DISPLAY (f
);
2138 dummy
.time
= CurrentTime
;
2139 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2140 dummy
.window
= dummy
.root
;
2141 dummy
.subwindow
= dummy
.root
;
2146 dummy
.state
= (FRAME_X_DISPLAY_INFO (f
)->grabbed
>> 1) * Button1Mask
;
2148 for (i
= 0; i
< 5; i
++)
2149 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2152 /* Don't allow any geometry request from the user. */
2153 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2154 XtSetValues (menu
, av
, ac
);
2156 /* Free the widget_value objects we used to specify the contents. */
2157 free_menubar_widget_value_tree (first_wv
);
2159 /* No selection has been chosen yet. */
2160 menu_item_selection
= 0;
2162 /* Display the menu. */
2163 lw_popup_menu (menu
, &dummy
);
2164 popup_activated_flag
= 1;
2166 /* Process events that apply to the menu. */
2167 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
);
2169 /* fp turned off the following statement and wrote a comment
2170 that it is unnecessary--that the menu has already disappeared.
2171 Nowadays the menu disappears ok, all right, but
2172 we need to delete the widgets or multiple ones will pile up. */
2173 lw_destroy_all_widgets (menu_id
);
2175 /* Find the selected item, and its pane, to return
2176 the proper value. */
2177 if (menu_item_selection
!= 0)
2179 Lisp_Object prefix
, entry
;
2183 while (i
< menu_items_used
)
2185 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2187 subprefix_stack
[submenu_depth
++] = prefix
;
2191 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2193 prefix
= subprefix_stack
[--submenu_depth
];
2196 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2199 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2200 i
+= MENU_ITEMS_PANE_LENGTH
;
2202 /* Ignore a nil in the item list.
2203 It's meaningful only for dialog boxes. */
2204 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2209 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2210 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2216 entry
= Fcons (entry
, Qnil
);
2218 entry
= Fcons (prefix
, entry
);
2219 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2220 if (!NILP (subprefix_stack
[j
]))
2221 entry
= Fcons (subprefix_stack
[j
], entry
);
2225 i
+= MENU_ITEMS_ITEM_LENGTH
;
2234 dialog_selection_callback (widget
, id
, client_data
)
2237 XtPointer client_data
;
2239 /* The EMACS_INT cast avoids a warning. There's no problem
2240 as long as pointers have enough bits to hold small integers. */
2241 if ((int) (EMACS_INT
) client_data
!= -1)
2242 menu_item_selection
= (Lisp_Object
*) client_data
;
2244 lw_destroy_all_widgets (id
);
2246 popup_activated_flag
= 0;
2249 static char * button_names
[] = {
2250 "button1", "button2", "button3", "button4", "button5",
2251 "button6", "button7", "button8", "button9", "button10" };
2254 xdialog_show (f
, keymaps
, title
, error
)
2260 int i
, nb_buttons
=0;
2263 char dialog_name
[6];
2265 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2267 /* Number of elements seen so far, before boundary. */
2269 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2270 int boundary_seen
= 0;
2274 if (menu_items_n_panes
> 1)
2276 *error
= "Multiple panes in dialog box";
2280 /* Create a tree of widget_value objects
2281 representing the text label and buttons. */
2283 Lisp_Object pane_name
, prefix
;
2285 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2286 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2287 pane_string
= (NILP (pane_name
)
2288 ? "" : (char *) XSTRING (pane_name
)->data
);
2289 prev_wv
= xmalloc_widget_value ();
2290 prev_wv
->value
= pane_string
;
2291 if (keymaps
&& !NILP (prefix
))
2293 prev_wv
->enabled
= 1;
2294 prev_wv
->name
= "message";
2297 /* Loop over all panes and items, filling in the tree. */
2298 i
= MENU_ITEMS_PANE_LENGTH
;
2299 while (i
< menu_items_used
)
2302 /* Create a new item within current pane. */
2303 Lisp_Object item_name
, enable
, descrip
;
2304 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2305 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2307 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2309 if (NILP (item_name
))
2311 free_menubar_widget_value_tree (first_wv
);
2312 *error
= "Submenu in dialog items";
2315 if (EQ (item_name
, Qquote
))
2317 /* This is the boundary between left-side elts
2318 and right-side elts. Stop incrementing right_count. */
2323 if (nb_buttons
>= 9)
2325 free_menubar_widget_value_tree (first_wv
);
2326 *error
= "Too many dialog items";
2330 wv
= xmalloc_widget_value ();
2332 wv
->name
= (char *) button_names
[nb_buttons
];
2333 if (!NILP (descrip
))
2334 wv
->key
= (char *) XSTRING (descrip
)->data
;
2335 wv
->value
= (char *) XSTRING (item_name
)->data
;
2336 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2337 wv
->enabled
= !NILP (enable
);
2340 if (! boundary_seen
)
2344 i
+= MENU_ITEMS_ITEM_LENGTH
;
2347 /* If the boundary was not specified,
2348 by default put half on the left and half on the right. */
2349 if (! boundary_seen
)
2350 left_count
= nb_buttons
- nb_buttons
/ 2;
2352 wv
= xmalloc_widget_value ();
2353 wv
->name
= dialog_name
;
2355 /* Dialog boxes use a really stupid name encoding
2356 which specifies how many buttons to use
2357 and how many buttons are on the right.
2358 The Q means something also. */
2359 dialog_name
[0] = 'Q';
2360 dialog_name
[1] = '0' + nb_buttons
;
2361 dialog_name
[2] = 'B';
2362 dialog_name
[3] = 'R';
2363 /* Number of buttons to put on the right. */
2364 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2366 wv
->contents
= first_wv
;
2370 /* Actually create the dialog. */
2371 dialog_id
= widget_id_tick
++;
2372 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2373 f
->output_data
.x
->widget
, 1, 0,
2374 dialog_selection_callback
, 0);
2375 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2376 /* Free the widget_value objects we used to specify the contents. */
2377 free_menubar_widget_value_tree (first_wv
);
2379 /* No selection has been chosen yet. */
2380 menu_item_selection
= 0;
2382 /* Display the menu. */
2383 lw_pop_up_all_widgets (dialog_id
);
2384 popup_activated_flag
= 1;
2386 /* Process events that apply to the menu. */
2387 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
);
2389 lw_destroy_all_widgets (dialog_id
);
2391 /* Find the selected item, and its pane, to return
2392 the proper value. */
2393 if (menu_item_selection
!= 0)
2399 while (i
< menu_items_used
)
2403 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2406 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2407 i
+= MENU_ITEMS_PANE_LENGTH
;
2412 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2413 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2417 entry
= Fcons (entry
, Qnil
);
2419 entry
= Fcons (prefix
, entry
);
2423 i
+= MENU_ITEMS_ITEM_LENGTH
;
2430 #else /* not USE_X_TOOLKIT */
2433 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2443 int pane
, selidx
, lpane
, status
;
2444 Lisp_Object entry
, pane_prefix
;
2446 int ulx
, uly
, width
, height
;
2447 int dispwidth
, dispheight
;
2451 unsigned int dummy_uint
;
2454 if (menu_items_n_panes
== 0)
2457 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2459 *error
= "Empty menu";
2463 /* Figure out which root window F is on. */
2464 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2465 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2466 &dummy_uint
, &dummy_uint
);
2468 /* Make the menu on that window. */
2469 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2472 *error
= "Can't create menu";
2476 #ifdef HAVE_X_WINDOWS
2477 /* Adjust coordinates to relative to the outer (window manager) window. */
2480 int win_x
= 0, win_y
= 0;
2482 /* Find the position of the outside upper-left corner of
2483 the inner window, with respect to the outer window. */
2484 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2487 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2489 /* From-window, to-window. */
2490 f
->output_data
.x
->window_desc
,
2491 f
->output_data
.x
->parent_desc
,
2493 /* From-position, to-position. */
2494 0, 0, &win_x
, &win_y
,
2496 /* Child of window. */
2503 #endif /* HAVE_X_WINDOWS */
2505 /* Adjust coordinates to be root-window-relative. */
2506 x
+= f
->output_data
.x
->left_pos
;
2507 y
+= f
->output_data
.x
->top_pos
;
2509 /* Create all the necessary panes and their items. */
2511 while (i
< menu_items_used
)
2513 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2515 /* Create a new pane. */
2516 Lisp_Object pane_name
, prefix
;
2519 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2520 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2521 pane_string
= (NILP (pane_name
)
2522 ? "" : (char *) XSTRING (pane_name
)->data
);
2523 if (keymaps
&& !NILP (prefix
))
2526 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2527 if (lpane
== XM_FAILURE
)
2529 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2530 *error
= "Can't create pane";
2533 i
+= MENU_ITEMS_PANE_LENGTH
;
2535 /* Find the width of the widest item in this pane. */
2538 while (j
< menu_items_used
)
2541 item
= XVECTOR (menu_items
)->contents
[j
];
2549 width
= XSTRING (item
)->size
;
2550 if (width
> maxwidth
)
2553 j
+= MENU_ITEMS_ITEM_LENGTH
;
2556 /* Ignore a nil in the item list.
2557 It's meaningful only for dialog boxes. */
2558 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2562 /* Create a new item within current pane. */
2563 Lisp_Object item_name
, enable
, descrip
;
2564 unsigned char *item_data
;
2566 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2567 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2569 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2570 if (!NILP (descrip
))
2572 int gap
= maxwidth
- XSTRING (item_name
)->size
;
2575 spacer
= Fmake_string (make_number (gap
), make_number (' '));
2576 item_name
= concat2 (item_name
, spacer
);
2577 item_name
= concat2 (item_name
, descrip
);
2578 item_data
= XSTRING (item_name
)->data
;
2580 /* if alloca is fast, use that to make the space,
2581 to reduce gc needs. */
2583 = (unsigned char *) alloca (maxwidth
2584 + XSTRING (descrip
)->size
+ 1);
2585 bcopy (XSTRING (item_name
)->data
, item_data
,
2586 XSTRING (item_name
)->size
);
2587 for (j
= XSTRING (item_name
)->size
; j
< maxwidth
; j
++)
2589 bcopy (XSTRING (descrip
)->data
, item_data
+ j
,
2590 XSTRING (descrip
)->size
);
2591 item_data
[j
+ XSTRING (descrip
)->size
] = 0;
2595 item_data
= XSTRING (item_name
)->data
;
2597 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2598 menu
, lpane
, 0, item_data
,
2602 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2603 *error
= "Can't add selection to menu";
2606 i
+= MENU_ITEMS_ITEM_LENGTH
;
2610 /* All set and ready to fly. */
2611 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2612 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
),
2613 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2614 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
),
2615 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2616 x
= min (x
, dispwidth
);
2617 y
= min (y
, dispheight
);
2620 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2621 &ulx
, &uly
, &width
, &height
);
2622 if (ulx
+width
> dispwidth
)
2624 x
-= (ulx
+ width
) - dispwidth
;
2625 ulx
= dispwidth
- width
;
2627 if (uly
+height
> dispheight
)
2629 y
-= (uly
+ height
) - dispheight
;
2630 uly
= dispheight
- height
;
2632 if (ulx
< 0) x
-= ulx
;
2633 if (uly
< 0) y
-= uly
;
2635 XMenuSetAEQ (menu
, TRUE
);
2636 XMenuSetFreeze (menu
, TRUE
);
2639 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2640 x
, y
, ButtonReleaseMask
, &datap
);
2643 #ifdef HAVE_X_WINDOWS
2644 /* Assume the mouse has moved out of the X window.
2645 If it has actually moved in, we will get an EnterNotify. */
2646 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2653 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2656 /* Find the item number SELIDX in pane number PANE. */
2658 while (i
< menu_items_used
)
2660 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2664 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2666 i
+= MENU_ITEMS_PANE_LENGTH
;
2675 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2678 entry
= Fcons (entry
, Qnil
);
2679 if (!NILP (pane_prefix
))
2680 entry
= Fcons (pane_prefix
, entry
);
2686 i
+= MENU_ITEMS_ITEM_LENGTH
;
2692 *error
= "Can't activate menu";
2698 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2700 #ifdef HAVE_X_WINDOWS
2701 /* State that no mouse buttons are now held.
2702 (The oldXMenu code doesn't track this info for us.)
2703 That is not necessarily true, but the fiction leads to reasonable
2704 results, and it is a pain to ask which are actually held now. */
2705 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2711 #endif /* not USE_X_TOOLKIT */
2713 #endif /* HAVE_MENUS */
2717 staticpro (&menu_items
);
2720 Qmenu_alias
= intern ("menu-alias");
2721 staticpro (&Qmenu_alias
);
2723 Qdebug_on_next_call
= intern ("debug-on-next-call");
2724 staticpro (&Qdebug_on_next_call
);
2726 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
2727 "Frame for which we are updating a menu.\n\
2728 The enable predicate for a menu command should check this variable.");
2729 Vmenu_updating_frame
= Qnil
;
2731 #ifdef USE_X_TOOLKIT
2732 widget_id_tick
= (1<<16);
2733 next_menubar_widget_id
= 1;
2736 defsubr (&Sx_popup_menu
);
2738 defsubr (&Sx_popup_dialog
);