1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994 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 Qdebug_on_next_call
;
91 extern Lisp_Object Qmenu_enable
;
92 extern Lisp_Object Qmenu_bar
;
93 extern Lisp_Object Qmouse_click
, Qevent_kind
;
95 extern Lisp_Object Vdefine_key_rebound_commands
;
97 extern Lisp_Object Voverriding_local_map
;
98 extern Lisp_Object Voverriding_local_map_menu_flag
;
100 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
102 extern Lisp_Object Qmenu_bar_update_hook
;
105 extern void set_frame_menubar ();
106 extern void process_expose_from_menu ();
107 extern XtAppContext Xt_app_con
;
109 static Lisp_Object
xdialog_show ();
110 void popup_get_selection ();
113 static Lisp_Object
xmenu_show ();
114 static void keymap_panes ();
115 static void single_keymap_panes ();
116 static void list_of_panes ();
117 static void list_of_items ();
119 /* This holds a Lisp vector that holds the results of decoding
120 the keymaps or alist-of-alists that specify a menu.
122 It describes the panes and items within the panes.
124 Each pane is described by 3 elements in the vector:
125 t, the pane name, the pane's prefix key.
126 Then follow the pane's items, with 5 elements per item:
127 the item string, the enable flag, the item's value,
128 the definition, and the equivalent keyboard key's description string.
130 In some cases, multiple levels of menus may be described.
131 A single vector slot containing nil indicates the start of a submenu.
132 A single vector slot containing lambda indicates the end of a submenu.
133 The submenu follows a menu item which is the way to reach the submenu.
135 A single vector slot containing quote indicates that the
136 following items should appear on the right of a dialog box.
138 Using a Lisp vector to hold this information while we decode it
139 takes care of protecting all the data from GC. */
141 #define MENU_ITEMS_PANE_NAME 1
142 #define MENU_ITEMS_PANE_PREFIX 2
143 #define MENU_ITEMS_PANE_LENGTH 3
145 #define MENU_ITEMS_ITEM_NAME 0
146 #define MENU_ITEMS_ITEM_ENABLE 1
147 #define MENU_ITEMS_ITEM_VALUE 2
148 #define MENU_ITEMS_ITEM_EQUIV_KEY 3
149 #define MENU_ITEMS_ITEM_DEFINITION 4
150 #define MENU_ITEMS_ITEM_LENGTH 5
152 static Lisp_Object menu_items
;
154 /* Number of slots currently allocated in menu_items. */
155 static int menu_items_allocated
;
157 /* This is the index in menu_items of the first empty slot. */
158 static int menu_items_used
;
160 /* The number of panes currently recorded in menu_items,
161 excluding those within submenus. */
162 static int menu_items_n_panes
;
164 /* Current depth within submenus. */
165 static int menu_items_submenu_depth
;
167 /* Flag which when set indicates a dialog or menu has been posted by
168 Xt on behalf of one of the widget sets. */
169 static int popup_activated_flag
;
171 static int next_menubar_widget_id
;
175 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
177 static struct frame
*
178 menubar_id_to_frame (id
)
181 Lisp_Object tail
, frame
;
184 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCONS (tail
)->cdr
)
186 frame
= XCONS (tail
)->car
;
187 if (!GC_FRAMEP (frame
))
190 if (f
->output_data
.nothing
== 1)
192 if (f
->output_data
.x
->id
== id
)
200 /* Initialize the menu_items structure if we haven't already done so.
201 Also mark it as currently empty. */
206 if (NILP (menu_items
))
208 menu_items_allocated
= 60;
209 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
213 menu_items_n_panes
= 0;
214 menu_items_submenu_depth
= 0;
217 /* Call at the end of generating the data in menu_items.
218 This fills in the number of items in the last pane. */
225 /* Call when finished using the data for the current menu
229 discard_menu_items ()
231 /* Free the structure if it is especially large.
232 Otherwise, hold on to it, to save time. */
233 if (menu_items_allocated
> 200)
236 menu_items_allocated
= 0;
240 /* Make the menu_items vector twice as large. */
246 int old_size
= menu_items_allocated
;
249 menu_items_allocated
*= 2;
250 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
251 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
252 old_size
* sizeof (Lisp_Object
));
255 /* Begin a submenu. */
258 push_submenu_start ()
260 if (menu_items_used
+ 1 > menu_items_allocated
)
263 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
264 menu_items_submenu_depth
++;
272 if (menu_items_used
+ 1 > menu_items_allocated
)
275 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
276 menu_items_submenu_depth
--;
279 /* Indicate boundary between left and right. */
282 push_left_right_boundary ()
284 if (menu_items_used
+ 1 > menu_items_allocated
)
287 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
290 /* Start a new menu pane in menu_items..
291 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
294 push_menu_pane (name
, prefix_vec
)
295 Lisp_Object name
, prefix_vec
;
297 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
300 if (menu_items_submenu_depth
== 0)
301 menu_items_n_panes
++;
302 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
303 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
304 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
307 /* Push one menu item into the current pane.
308 NAME is the string to display. ENABLE if non-nil means
309 this item can be selected. KEY is the key generated by
310 choosing this item, or nil if this item doesn't really have a definition.
311 DEF is the definition of this item.
312 EQUIV is the textual description of the keyboard equivalent for
313 this item (or nil if none). */
316 push_menu_item (name
, enable
, key
, def
, equiv
)
317 Lisp_Object name
, enable
, key
, def
, equiv
;
319 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
322 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
323 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
324 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
325 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
326 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
329 /* Figure out the current keyboard equivalent of a menu item ITEM1.
330 The item string for menu display should be ITEM_STRING.
331 Store the equivalent keyboard key sequence's
332 textual description into *DESCRIP_PTR.
333 Also cache them in the item itself.
334 Return the real definition to execute. */
337 menu_item_equiv_key (item_string
, item1
, descrip_ptr
)
338 Lisp_Object item_string
;
340 Lisp_Object
*descrip_ptr
;
342 /* This is the real definition--the function to run. */
344 /* This is the sublist that records cached equiv key data
345 so we can save time. */
346 Lisp_Object cachelist
;
347 /* These are the saved equivalent keyboard key sequence
348 and its key-description. */
349 Lisp_Object savedkey
, descrip
;
352 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
354 /* If a help string follows the item string, skip it. */
355 if (CONSP (XCONS (item1
)->cdr
)
356 && STRINGP (XCONS (XCONS (item1
)->cdr
)->car
))
357 item1
= XCONS (item1
)->cdr
;
361 /* Get out the saved equivalent-keyboard-key info. */
362 cachelist
= savedkey
= descrip
= Qnil
;
363 if (CONSP (def
) && CONSP (XCONS (def
)->car
)
364 && (NILP (XCONS (XCONS (def
)->car
)->car
)
365 || VECTORP (XCONS (XCONS (def
)->car
)->car
)))
367 cachelist
= XCONS (def
)->car
;
368 def
= XCONS (def
)->cdr
;
369 savedkey
= XCONS (cachelist
)->car
;
370 descrip
= XCONS (cachelist
)->cdr
;
373 GCPRO4 (def
, def1
, savedkey
, descrip
);
375 /* Is it still valid? */
377 if (!NILP (savedkey
))
378 def1
= Fkey_binding (savedkey
, Qnil
);
379 /* If not, update it. */
381 /* If the command is an alias for another
382 (such as easymenu.el and lmenu.el set it up),
383 check if the original command matches the cached command. */
384 && !(SYMBOLP (def
) && SYMBOLP (XSYMBOL (def
)->function
)
385 && EQ (def1
, XSYMBOL (def
)->function
))
386 /* If something had no key binding before, don't recheck it
387 because that is too slow--except if we have a list of rebound
388 commands in Vdefine_key_rebound_commands, do recheck any command
389 that appears in that list. */
390 && (NILP (cachelist
) || !NILP (savedkey
)
391 || (! EQ (Qt
, Vdefine_key_rebound_commands
)
392 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
)))))
396 /* If the command is an alias for another
397 (such as easymenu.el and lmenu.el set it up),
398 see if the original command name has equivalent keys. */
399 if (SYMBOLP (def
) && SYMBOLP (XSYMBOL (def
)->function
))
400 savedkey
= Fwhere_is_internal (XSYMBOL (def
)->function
,
403 /* Otherwise look up the specified command itself.
404 We don't try both, because that makes easymenu menus slow. */
405 savedkey
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
);
407 if (!NILP (savedkey
))
409 descrip
= Fkey_description (savedkey
);
410 descrip
= concat2 (make_string (" (", 3), descrip
);
411 descrip
= concat2 (descrip
, make_string (")", 1));
415 /* Cache the data we just got in a sublist of the menu binding. */
416 if (NILP (cachelist
))
418 CHECK_IMPURE (item1
);
419 XCONS (item1
)->cdr
= Fcons (Fcons (savedkey
, descrip
), def
);
423 XCONS (cachelist
)->car
= savedkey
;
424 XCONS (cachelist
)->cdr
= descrip
;
428 *descrip_ptr
= descrip
;
432 /* This is used as the handler when calling internal_condition_case_1. */
435 menu_item_enabled_p_1 (arg
)
438 /* If we got a quit from within the menu computation,
439 quit all the way out of it. This takes care of C-] in the debugger. */
440 if (CONSP (arg
) && EQ (XCONS (arg
)->car
, Qquit
))
441 Fsignal (Qquit
, Qnil
);
446 /* Return non-nil if the command DEF is enabled when used as a menu item.
447 This is based on looking for a menu-enable property.
448 If NOTREAL is set, don't bother really computing this. */
451 menu_item_enabled_p (def
, notreal
)
455 Lisp_Object enabled
, tem
;
462 /* No property, or nil, means enable.
463 Otherwise, enable if value is not nil. */
464 tem
= Fget (def
, Qmenu_enable
);
466 /* (condition-case nil (eval tem)
468 enabled
= internal_condition_case_1 (Feval
, tem
, Qerror
,
469 menu_item_enabled_p_1
);
474 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
475 and generate menu panes for them in menu_items.
476 If NOTREAL is nonzero,
477 don't bother really computing whether an item is enabled. */
480 keymap_panes (keymaps
, nmaps
, notreal
)
481 Lisp_Object
*keymaps
;
489 /* Loop over the given keymaps, making a pane for each map.
490 But don't make a pane that is empty--ignore that map instead.
491 P is the number of panes we have made so far. */
492 for (mapno
= 0; mapno
< nmaps
; mapno
++)
493 single_keymap_panes (keymaps
[mapno
], Qnil
, Qnil
, notreal
);
495 finish_menu_items ();
498 /* This is a recursive subroutine of keymap_panes.
499 It handles one keymap, KEYMAP.
500 The other arguments are passed along
501 or point to local variables of the previous function.
502 If NOTREAL is nonzero,
503 don't bother really computing whether an item is enabled. */
506 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
)
508 Lisp_Object pane_name
;
512 Lisp_Object pending_maps
;
513 Lisp_Object tail
, item
, item1
, item_string
, table
;
514 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
518 push_menu_pane (pane_name
, prefix
);
520 for (tail
= keymap
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
522 /* Look at each key binding, and if it has a menu string,
523 make a menu item from it. */
524 item
= XCONS (tail
)->car
;
527 item1
= XCONS (item
)->cdr
;
530 item_string
= XCONS (item1
)->car
;
531 if (STRINGP (item_string
))
533 /* This is the real definition--the function to run. */
535 /* These are the saved equivalent keyboard key sequence
536 and its key-description. */
538 Lisp_Object tem
, enabled
;
540 /* GCPRO because ...enabled_p will call eval
541 and ..._equiv_key may autoload something.
542 Protecting KEYMAP preserves everything we use;
543 aside from that, must protect whatever might be
544 a string. Since there's no GCPRO5, we refetch
545 item_string instead of protecting it. */
546 descrip
= def
= Qnil
;
547 GCPRO4 (keymap
, pending_maps
, def
, descrip
);
549 def
= menu_item_equiv_key (item_string
, item1
, &descrip
);
550 enabled
= menu_item_enabled_p (def
, notreal
);
554 item_string
= XCONS (item1
)->car
;
556 tem
= Fkeymapp (def
);
557 if (XSTRING (item_string
)->data
[0] == '@' && !NILP (tem
))
558 pending_maps
= Fcons (Fcons (def
, Fcons (item_string
, XCONS (item
)->car
)),
563 GCPRO4 (keymap
, pending_maps
, descrip
, item_string
);
564 submap
= get_keymap_1 (def
, 0, 1);
566 #ifndef USE_X_TOOLKIT
567 /* Indicate visually that this is a submenu. */
569 item_string
= concat2 (item_string
,
570 build_string (" >"));
572 /* If definition is nil, pass nil as the key. */
573 push_menu_item (item_string
, enabled
,
574 XCONS (item
)->car
, def
,
577 /* Display a submenu using the toolkit. */
580 push_submenu_start ();
581 single_keymap_panes (submap
, Qnil
,
582 XCONS (item
)->car
, notreal
);
590 else if (VECTORP (item
))
592 /* Loop over the char values represented in the vector. */
593 int len
= XVECTOR (item
)->size
;
595 for (c
= 0; c
< len
; c
++)
597 Lisp_Object character
;
598 XSETFASTINT (character
, c
);
599 item1
= XVECTOR (item
)->contents
[c
];
602 item_string
= XCONS (item1
)->car
;
603 if (STRINGP (item_string
))
607 /* These are the saved equivalent keyboard key sequence
608 and its key-description. */
610 Lisp_Object tem
, enabled
;
612 /* GCPRO because ...enabled_p will call eval
613 and ..._equiv_key may autoload something.
614 Protecting KEYMAP preserves everything we use;
615 aside from that, must protect whatever might be
616 a string. Since there's no GCPRO5, we refetch
617 item_string instead of protecting it. */
618 GCPRO4 (keymap
, pending_maps
, def
, descrip
);
619 descrip
= def
= Qnil
;
621 def
= menu_item_equiv_key (item_string
, item1
, &descrip
);
622 enabled
= menu_item_enabled_p (def
, notreal
);
626 item_string
= XCONS (item1
)->car
;
628 tem
= Fkeymapp (def
);
629 if (XSTRING (item_string
)->data
[0] == '@' && !NILP (tem
))
630 pending_maps
= Fcons (Fcons (def
, Fcons (item_string
, character
)),
635 GCPRO4 (keymap
, pending_maps
, descrip
, item_string
);
636 submap
= get_keymap_1 (def
, 0, 1);
638 #ifndef USE_X_TOOLKIT
640 item_string
= concat2 (item_string
,
641 build_string (" >"));
643 /* If definition is nil, pass nil as the key. */
644 push_menu_item (item_string
, enabled
, character
,
649 push_submenu_start ();
650 single_keymap_panes (submap
, Qnil
,
662 /* Process now any submenus which want to be panes at this level. */
663 while (!NILP (pending_maps
))
665 Lisp_Object elt
, eltcdr
, string
;
666 elt
= Fcar (pending_maps
);
667 eltcdr
= XCONS (elt
)->cdr
;
668 string
= XCONS (eltcdr
)->car
;
669 /* We no longer discard the @ from the beginning of the string here.
670 Instead, we do this in xmenu_show. */
671 single_keymap_panes (Fcar (elt
), string
,
672 XCONS (eltcdr
)->cdr
, notreal
);
673 pending_maps
= Fcdr (pending_maps
);
677 /* Push all the panes and items of a menu described by the
678 alist-of-alists MENU.
679 This handles old-fashioned calls to x-popup-menu. */
689 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
691 Lisp_Object elt
, pane_name
, pane_data
;
693 pane_name
= Fcar (elt
);
694 CHECK_STRING (pane_name
, 0);
695 push_menu_pane (pane_name
, Qnil
);
696 pane_data
= Fcdr (elt
);
697 CHECK_CONS (pane_data
, 0);
698 list_of_items (pane_data
);
701 finish_menu_items ();
704 /* Push the items in a single pane defined by the alist PANE. */
710 Lisp_Object tail
, item
, item1
;
712 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
716 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
);
717 else if (NILP (item
))
718 push_left_right_boundary ();
721 CHECK_CONS (item
, 0);
723 CHECK_STRING (item1
, 1);
724 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
);
729 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
730 "Pop up a deck-of-cards menu and return user's selection.\n\
731 POSITION is a position specification. This is either a mouse button event\n\
732 or a list ((XOFFSET YOFFSET) WINDOW)\n\
733 where XOFFSET and YOFFSET are positions in pixels from the top left\n\
734 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
735 This controls the position of the center of the first line\n\
736 in the first pane of the menu, not the top left of the menu as a whole.\n\
737 If POSITION is t, it means to use the current mouse position.\n\
739 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
740 The menu items come from key bindings that have a menu string as well as\n\
741 a definition; actually, the \"definition\" in such a key binding looks like\n\
742 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
743 the keymap as a top-level element.\n\n\
744 You can also use a list of keymaps as MENU.\n\
745 Then each keymap makes a separate pane.\n\
746 When MENU is a keymap or a list of keymaps, the return value\n\
747 is a list of events.\n\n\
748 Alternatively, you can specify a menu of multiple panes\n\
749 with a list of the form (TITLE PANE1 PANE2...),\n\
750 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
751 Each ITEM is normally a cons cell (STRING . VALUE);\n\
752 but a string can appear as an item--that makes a nonselectable line\n\
754 With this form of menu, the return value is VALUE from the chosen item.\n\
756 If POSITION is nil, don't display the menu at all, just precalculate the\n\
757 cached information about equivalent key sequences.")
759 Lisp_Object position
, menu
;
761 int number_of_panes
, panes
;
762 Lisp_Object keymap
, tem
;
766 Lisp_Object selection
;
769 Lisp_Object x
, y
, window
;
775 if (! NILP (position
))
779 /* Decode the first argument: find the window and the coordinates. */
780 if (EQ (position
, Qt
)
781 || (CONSP (position
) && EQ (XCONS (position
)->car
, Qmenu_bar
)))
783 /* Use the mouse's current position. */
784 FRAME_PTR new_f
= selected_frame
;
785 Lisp_Object bar_window
;
789 if (mouse_position_hook
)
790 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
791 &part
, &x
, &y
, &time
);
793 XSETFRAME (window
, new_f
);
796 window
= selected_window
;
803 tem
= Fcar (position
);
806 window
= Fcar (Fcdr (position
));
808 y
= Fcar (Fcdr (tem
));
813 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
814 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
815 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
824 /* Decode where to put the menu. */
832 else if (WINDOWP (window
))
834 CHECK_LIVE_WINDOW (window
, 0);
835 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
837 xpos
= (FONT_WIDTH (f
->output_data
.x
->font
) * XWINDOW (window
)->left
);
838 ypos
= (f
->output_data
.x
->line_height
* XWINDOW (window
)->top
);
841 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
842 but I don't want to make one now. */
843 CHECK_WINDOW (window
, 0);
848 #endif /* HAVE_MENUS */
853 /* Decode the menu items from what was specified. */
855 keymap
= Fkeymapp (menu
);
858 tem
= Fkeymapp (Fcar (menu
));
861 /* We were given a keymap. Extract menu info from the keymap. */
863 keymap
= get_keymap (menu
);
865 /* Extract the detailed info to make one pane. */
866 keymap_panes (&menu
, 1, NILP (position
));
868 /* Search for a string appearing directly as an element of the keymap.
869 That string is the title of the menu. */
870 prompt
= map_prompt (keymap
);
872 /* Make that be the pane title of the first pane. */
873 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
874 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
878 else if (!NILP (tem
))
880 /* We were given a list of keymaps. */
881 int nmaps
= XFASTINT (Flength (menu
));
883 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
888 /* The first keymap that has a prompt string
889 supplies the menu title. */
890 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
894 maps
[i
++] = keymap
= get_keymap (Fcar (tem
));
896 prompt
= map_prompt (keymap
);
897 if (NILP (title
) && !NILP (prompt
))
901 /* Extract the detailed info to make one pane. */
902 keymap_panes (maps
, nmaps
, NILP (position
));
904 /* Make the title be the pane title of the first pane. */
905 if (!NILP (title
) && menu_items_n_panes
>= 0)
906 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
912 /* We were given an old-fashioned menu. */
914 CHECK_STRING (title
, 1);
916 list_of_panes (Fcdr (menu
));
923 discard_menu_items ();
929 /* Display them in a menu. */
932 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
933 keymaps
, title
, &error_name
);
936 discard_menu_items ();
939 #endif /* HAVE_MENUS */
941 if (error_name
) error (error_name
);
947 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
948 "Pop up a dialog box and return user's selection.\n\
949 POSITION specifies which frame to use.\n\
950 This is normally a mouse button event or a window or frame.\n\
951 If POSITION is t, it means to use the frame the mouse is on.\n\
952 The dialog box appears in the middle of the specified frame.\n\
954 CONTENTS specifies the alternatives to display in the dialog box.\n\
955 It is a list of the form (TITLE ITEM1 ITEM2...).\n\
956 Each ITEM is a cons cell (STRING . VALUE).\n\
957 The return value is VALUE from the chosen item.\n\n\
958 An ITEM may also be just a string--that makes a nonselectable item.\n\
959 An ITEM may also be nil--that means to put all preceding items\n\
960 on the left of the dialog box and all following items on the right.\n\
961 \(By default, approximately half appear on each side.)")
963 Lisp_Object position
, contents
;
970 /* Decode the first argument: find the window or frame to use. */
971 if (EQ (position
, Qt
)
972 || (CONSP (position
) && EQ (XCONS (position
)->car
, Qmenu_bar
)))
974 #if 0 /* Using the frame the mouse is on may not be right. */
975 /* Use the mouse's current position. */
976 FRAME_PTR new_f
= selected_frame
;
977 Lisp_Object bar_window
;
982 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
985 XSETFRAME (window
, new_f
);
987 window
= selected_window
;
989 window
= selected_window
;
991 else if (CONSP (position
))
994 tem
= Fcar (position
);
996 window
= Fcar (Fcdr (position
));
999 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1000 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1003 else if (WINDOWP (position
) || FRAMEP (position
))
1006 /* Decode where to put the menu. */
1008 if (FRAMEP (window
))
1009 f
= XFRAME (window
);
1010 else if (WINDOWP (window
))
1012 CHECK_LIVE_WINDOW (window
, 0);
1013 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1016 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1017 but I don't want to make one now. */
1018 CHECK_WINDOW (window
, 0);
1020 #ifndef USE_X_TOOLKIT
1021 /* Display a menu with these alternatives
1022 in the middle of frame F. */
1024 Lisp_Object x
, y
, frame
, newpos
;
1025 XSETFRAME (frame
, f
);
1026 XSETINT (x
, x_pixel_width (f
) / 2);
1027 XSETINT (y
, x_pixel_height (f
) / 2);
1028 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1030 return Fx_popup_menu (newpos
,
1031 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1037 Lisp_Object selection
;
1039 /* Decode the dialog items from what was specified. */
1040 title
= Fcar (contents
);
1041 CHECK_STRING (title
, 1);
1043 list_of_panes (Fcons (contents
, Qnil
));
1045 /* Display them in a dialog box. */
1047 selection
= xdialog_show (f
, 0, title
, &error_name
);
1050 discard_menu_items ();
1052 if (error_name
) error (error_name
);
1058 #ifdef USE_X_TOOLKIT
1060 /* Loop in Xt until the menu pulldown or dialog popup has been
1061 popped down (deactivated). This is used for x-popup-menu
1062 and x-popup-dialog; it is not used for the menu bar any more.
1064 NOTE: All calls to popup_get_selection should be protected
1065 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1068 popup_get_selection (initial_event
, dpyinfo
, id
)
1069 XEvent
*initial_event
;
1070 struct x_display_info
*dpyinfo
;
1075 /* Define a queue to save up for later unreading
1076 all X events that don't pertain to the menu. */
1080 struct event_queue
*next
;
1083 struct event_queue
*queue
= NULL
;
1084 struct event_queue
*queue_tmp
;
1087 event
= *initial_event
;
1089 XtAppNextEvent (Xt_app_con
, &event
);
1093 /* Handle expose events for editor frames right away. */
1094 if (event
.type
== Expose
)
1095 process_expose_from_menu (event
);
1096 /* Make sure we don't consider buttons grabbed after menu goes. */
1097 else if (event
.type
== ButtonRelease
1098 && dpyinfo
->display
== event
.xbutton
.display
)
1099 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1100 /* If the user presses a key, deactivate the menu.
1101 The user is likely to do that if we get wedged. */
1102 else if (event
.type
== KeyPress
1103 && dpyinfo
->display
== event
.xbutton
.display
)
1105 popup_activated_flag
= 0;
1108 /* Button presses outside the menu also pop it down. */
1109 else if (event
.type
== ButtonPress
1110 && event
.xany
.display
== dpyinfo
->display
1111 && x_any_window_to_frame (dpyinfo
, event
.xany
.window
))
1113 popup_activated_flag
= 0;
1117 /* Queue all events not for this popup,
1118 except for Expose, which we've already handled.
1119 Note that the X window is associated with the frame if this
1120 is a menu bar popup, but not if it's a dialog box. So we use
1121 x_non_menubar_window_to_frame, not x_any_window_to_frame. */
1122 if (event
.type
!= Expose
1123 && (event
.xany
.display
!= dpyinfo
->display
1124 || x_non_menubar_window_to_frame (dpyinfo
, event
.xany
.window
)))
1126 queue_tmp
= (struct event_queue
*) malloc (sizeof (struct event_queue
));
1128 if (queue_tmp
!= NULL
)
1130 queue_tmp
->event
= event
;
1131 queue_tmp
->next
= queue
;
1136 XtDispatchEvent (&event
);
1138 if (!popup_activated ())
1140 XtAppNextEvent (Xt_app_con
, &event
);
1143 /* Unread any events that we got but did not handle. */
1144 while (queue
!= NULL
)
1147 XPutBackEvent (queue_tmp
->event
.xany
.display
, &queue_tmp
->event
);
1148 queue
= queue_tmp
->next
;
1149 free ((char *)queue_tmp
);
1150 /* Cause these events to get read as soon as we UNBLOCK_INPUT. */
1151 interrupt_input_pending
= 1;
1155 /* Activate the menu bar of frame F.
1156 This is called from keyboard.c when it gets the
1157 menu_bar_activate_event out of the Emacs event queue.
1159 To activate the menu bar, we use the X button-press event
1160 that was saved in saved_button_event.
1161 That makes the toolkit do its thing.
1163 But first we recompute the menu bar contents (the whole tree).
1165 The reason for saving the button event until here, instead of
1166 passing it to the toolkit right away, is that we can safely
1167 execute Lisp code. */
1169 x_activate_menubar (f
)
1172 if (f
->output_data
.x
->saved_button_event
->type
!= ButtonPress
)
1175 set_frame_menubar (f
, 0, 1);
1178 XtDispatchEvent ((XEvent
*) f
->output_data
.x
->saved_button_event
);
1181 /* Ignore this if we get it a second time. */
1182 f
->output_data
.x
->saved_button_event
->type
= 0;
1185 /* Detect if a dialog or menu has been posted. */
1190 return popup_activated_flag
;
1194 /* This callback is invoked when the user selects a menubar cascade
1195 pushbutton, but before the pulldown menu is posted. */
1198 popup_activate_callback (widget
, id
, client_data
)
1201 XtPointer client_data
;
1203 popup_activated_flag
= 1;
1206 /* This callback is called from the menu bar pulldown menu
1207 when the user makes a selection.
1208 Figure out what the user chose
1209 and put the appropriate events into the keyboard buffer. */
1212 menubar_selection_callback (widget
, id
, client_data
)
1215 XtPointer client_data
;
1217 Lisp_Object prefix
, entry
;
1218 FRAME_PTR f
= menubar_id_to_frame (id
);
1220 Lisp_Object
*subprefix_stack
;
1221 int submenu_depth
= 0;
1226 subprefix_stack
= (Lisp_Object
*) alloca (f
->menu_bar_items_used
* sizeof (Lisp_Object
));
1227 vector
= f
->menu_bar_vector
;
1230 while (i
< f
->menu_bar_items_used
)
1232 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1234 subprefix_stack
[submenu_depth
++] = prefix
;
1238 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1240 prefix
= subprefix_stack
[--submenu_depth
];
1243 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1245 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1246 i
+= MENU_ITEMS_PANE_LENGTH
;
1250 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1251 /* The EMACS_INT cast avoids a warning. There's no problem
1252 as long as pointers have enough bits to hold small integers. */
1253 if ((int) (EMACS_INT
) client_data
== i
)
1256 struct input_event buf
;
1259 XSETFRAME (frame
, f
);
1260 buf
.kind
= menu_bar_event
;
1261 buf
.frame_or_window
= Fcons (frame
, Fcons (Qmenu_bar
, Qnil
));
1262 kbd_buffer_store_event (&buf
);
1264 for (j
= 0; j
< submenu_depth
; j
++)
1265 if (!NILP (subprefix_stack
[j
]))
1267 buf
.kind
= menu_bar_event
;
1268 buf
.frame_or_window
= Fcons (frame
, subprefix_stack
[j
]);
1269 kbd_buffer_store_event (&buf
);
1274 buf
.kind
= menu_bar_event
;
1275 buf
.frame_or_window
= Fcons (frame
, prefix
);
1276 kbd_buffer_store_event (&buf
);
1279 buf
.kind
= menu_bar_event
;
1280 buf
.frame_or_window
= Fcons (frame
, entry
);
1281 kbd_buffer_store_event (&buf
);
1285 i
+= MENU_ITEMS_ITEM_LENGTH
;
1290 /* This callback is invoked when a dialog or menu is finished being
1291 used and has been unposted. */
1294 popup_deactivate_callback (widget
, id
, client_data
)
1297 XtPointer client_data
;
1299 popup_activated_flag
= 0;
1302 /* Allocate a widget_value, blocking input. */
1305 xmalloc_widget_value ()
1307 widget_value
*value
;
1310 value
= malloc_widget_value ();
1316 /* This recursively calls free_widget_value on the tree of widgets.
1317 It must free all data that was malloc'ed for these widget_values.
1318 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1319 must be left alone. */
1322 free_menubar_widget_value_tree (wv
)
1327 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1329 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1331 free_menubar_widget_value_tree (wv
->contents
);
1332 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1336 free_menubar_widget_value_tree (wv
->next
);
1337 wv
->next
= (widget_value
*) 0xDEADBEEF;
1340 free_widget_value (wv
);
1344 /* Return a tree of widget_value structures for a menu bar item
1345 whose event type is ITEM_KEY (with string ITEM_NAME)
1346 and whose contents come from the list of keymaps MAPS. */
1348 static widget_value
*
1349 single_submenu (item_key
, item_name
, maps
)
1350 Lisp_Object item_key
, item_name
, maps
;
1352 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1354 int submenu_depth
= 0;
1357 Lisp_Object
*mapvec
;
1358 widget_value
**submenu_stack
;
1360 int previous_items
= menu_items_used
;
1361 int top_level_items
= 0;
1363 length
= Flength (maps
);
1364 len
= XINT (length
);
1366 /* Convert the list MAPS into a vector MAPVEC. */
1367 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1368 for (i
= 0; i
< len
; i
++)
1370 mapvec
[i
] = Fcar (maps
);
1374 menu_items_n_panes
= 0;
1376 /* Loop over the given keymaps, making a pane for each map.
1377 But don't make a pane that is empty--ignore that map instead. */
1378 for (i
= 0; i
< len
; i
++)
1380 if (SYMBOLP (mapvec
[i
])
1381 || (CONSP (mapvec
[i
])
1382 && NILP (Fkeymapp (mapvec
[i
]))))
1384 /* Here we have a command at top level in the menu bar
1385 as opposed to a submenu. */
1386 top_level_items
= 1;
1387 push_menu_pane (Qnil
, Qnil
);
1388 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
], Qnil
);
1391 single_keymap_panes (mapvec
[i
], item_name
, item_key
, 0);
1394 /* Create a tree of widget_value objects
1395 representing the panes and their items. */
1398 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1399 wv
= xmalloc_widget_value ();
1407 /* Loop over all panes and items made during this call
1408 and construct a tree of widget_value objects.
1409 Ignore the panes and items made by previous calls to
1410 single_submenu, even though those are also in menu_items. */
1412 while (i
< menu_items_used
)
1414 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1416 submenu_stack
[submenu_depth
++] = save_wv
;
1421 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1424 save_wv
= submenu_stack
[--submenu_depth
];
1427 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1428 && submenu_depth
!= 0)
1429 i
+= MENU_ITEMS_PANE_LENGTH
;
1430 /* Ignore a nil in the item list.
1431 It's meaningful only for dialog boxes. */
1432 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1434 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1436 /* Create a new pane. */
1437 Lisp_Object pane_name
, prefix
;
1439 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1440 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1441 pane_string
= (NILP (pane_name
)
1442 ? "" : (char *) XSTRING (pane_name
)->data
);
1443 /* If there is just one top-level pane, put all its items directly
1444 under the top-level menu. */
1445 if (menu_items_n_panes
== 1)
1448 /* If the pane has a meaningful name,
1449 make the pane a top-level menu item
1450 with its items as a submenu beneath it. */
1451 if (strcmp (pane_string
, ""))
1453 wv
= xmalloc_widget_value ();
1457 first_wv
->contents
= wv
;
1458 wv
->name
= pane_string
;
1459 /* Ignore the @ that means "separate pane".
1460 This is a kludge, but this isn't worth more time. */
1461 if (!NILP (prefix
) && wv
->name
[0] == '@')
1468 i
+= MENU_ITEMS_PANE_LENGTH
;
1472 /* Create a new item within current pane. */
1473 Lisp_Object item_name
, enable
, descrip
, def
;
1474 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1475 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1477 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1478 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
1480 wv
= xmalloc_widget_value ();
1484 save_wv
->contents
= wv
;
1486 wv
->name
= (char *) XSTRING (item_name
)->data
;
1487 if (!NILP (descrip
))
1488 wv
->key
= (char *) XSTRING (descrip
)->data
;
1490 /* The EMACS_INT cast avoids a warning. There's no problem
1491 as long as pointers have enough bits to hold small integers. */
1492 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1493 wv
->enabled
= !NILP (enable
);
1496 i
+= MENU_ITEMS_ITEM_LENGTH
;
1500 /* If we have just one "menu item"
1501 that was originally a button, return it by itself. */
1502 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1504 wv
= first_wv
->contents
;
1505 free_widget_value (first_wv
);
1512 extern void EmacsFrameSetCharSize ();
1514 /* Recompute all the widgets of frame F, when the menu bar
1515 has been changed. */
1518 update_frame_menubar (f
)
1521 struct x_output
*x
= f
->output_data
.x
;
1523 int menubar_changed
;
1525 Dimension shell_height
;
1527 /* We assume the menubar contents has changed if the global flag is set,
1528 or if the current buffer has changed, or if the menubar has never
1529 been updated before.
1531 menubar_changed
= (x
->menubar_widget
1532 && !XtIsManaged (x
->menubar_widget
));
1534 if (! (menubar_changed
))
1538 /* Save the size of the frame because the pane widget doesn't accept to
1539 resize itself. So force it. */
1543 /* Do the voodoo which means "I'm changing lots of things, don't try to
1544 refigure sizes until I'm done." */
1545 lw_refigure_widget (x
->column_widget
, False
);
1547 /* the order in which children are managed is the top to
1548 bottom order in which they are displayed in the paned window.
1549 First, remove the text-area widget.
1551 XtUnmanageChild (x
->edit_widget
);
1553 /* remove the menubar that is there now, and put up the menubar that
1556 if (menubar_changed
)
1558 XtManageChild (x
->menubar_widget
);
1559 XtMapWidget (x
->menubar_widget
);
1560 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, 0);
1563 /* Re-manage the text-area widget, and then thrash the sizes. */
1564 XtManageChild (x
->edit_widget
);
1565 lw_refigure_widget (x
->column_widget
, True
);
1567 /* Force the pane widget to resize itself with the right values. */
1568 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1573 /* Set the contents of the menubar widgets of frame F.
1574 The argument FIRST_TIME is currently ignored;
1575 it is set the first time this is called, from initialize_frame_menubar. */
1578 set_frame_menubar (f
, first_time
, deep_p
)
1583 Widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1584 Lisp_Object tail
, items
, frame
;
1585 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1589 if (f
->output_data
.x
->id
== 0)
1590 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1591 id
= f
->output_data
.x
->id
;
1593 if (! menubar_widget
)
1596 wv
= xmalloc_widget_value ();
1597 wv
->name
= "menubar";
1604 /* Make a widget-value tree representing the entire menu trees. */
1606 struct buffer
*prev
= current_buffer
;
1608 int specpdl_count
= specpdl_ptr
- specpdl
;
1609 int previous_menu_items_used
= f
->menu_bar_items_used
;
1610 Lisp_Object
*previous_items
1611 = (Lisp_Object
*) alloca (previous_menu_items_used
1612 * sizeof (Lisp_Object
));
1614 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1615 specbind (Qinhibit_quit
, Qt
);
1616 /* Don't let the debugger step into this code
1617 because it is not reentrant. */
1618 specbind (Qdebug_on_next_call
, Qnil
);
1620 record_unwind_protect (Fstore_match_data
, Fmatch_data ());
1621 if (NILP (Voverriding_local_map_menu_flag
))
1623 specbind (Qoverriding_terminal_local_map
, Qnil
);
1624 specbind (Qoverriding_local_map
, Qnil
);
1627 set_buffer_internal_1 (XBUFFER (buffer
));
1629 /* Run the Lucid hook. */
1630 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1631 /* If it has changed current-menubar from previous value,
1632 really recompute the menubar from the value. */
1633 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1634 call0 (Qrecompute_lucid_menubar
);
1635 safe_run_hooks (Qmenu_bar_update_hook
);
1636 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1638 items
= FRAME_MENU_BAR_ITEMS (f
);
1640 inhibit_garbage_collection ();
1642 /* Save the frame's previous menu bar contents data. */
1643 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1644 previous_menu_items_used
* sizeof (Lisp_Object
));
1646 /* Fill in the current menu bar contents. */
1647 menu_items
= f
->menu_bar_vector
;
1648 menu_items_allocated
= XVECTOR (menu_items
)->size
;
1650 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1652 Lisp_Object key
, string
, maps
;
1654 key
= XVECTOR (items
)->contents
[i
];
1655 string
= XVECTOR (items
)->contents
[i
+ 1];
1656 maps
= XVECTOR (items
)->contents
[i
+ 2];
1660 wv
= single_submenu (key
, string
, maps
);
1664 first_wv
->contents
= wv
;
1665 /* Don't set wv->name here; GC during the loop might relocate it. */
1670 finish_menu_items ();
1672 set_buffer_internal_1 (prev
);
1673 unbind_to (specpdl_count
, Qnil
);
1675 /* If there has been no change in the Lisp-level contents
1676 of the menu bar, skip redisplaying it. Just exit. */
1678 for (i
= 0; i
< previous_menu_items_used
; i
++)
1679 if (menu_items_used
== i
1680 || (previous_items
[i
] != XVECTOR (menu_items
)->contents
[i
]))
1682 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1684 free_menubar_widget_value_tree (first_wv
);
1690 /* Now GC cannot happen during the lifetime of the widget_value,
1691 so it's safe to store data from a Lisp_String. */
1692 wv
= first_wv
->contents
;
1693 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1696 string
= XVECTOR (items
)->contents
[i
+ 1];
1699 wv
->name
= (char *) XSTRING (string
)->data
;
1703 f
->menu_bar_vector
= menu_items
;
1704 f
->menu_bar_items_used
= menu_items_used
;
1709 /* Make a widget-value tree containing
1710 just the top level menu bar strings. */
1712 items
= FRAME_MENU_BAR_ITEMS (f
);
1713 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1717 string
= XVECTOR (items
)->contents
[i
+ 1];
1721 wv
= xmalloc_widget_value ();
1722 wv
->name
= (char *) XSTRING (string
)->data
;
1729 first_wv
->contents
= wv
;
1733 /* Forget what we thought we knew about what is in the
1734 detailed contents of the menu bar menus.
1735 Changing the top level always destroys the contents. */
1736 f
->menu_bar_items_used
= 0;
1739 /* Create or update the menu bar widget. */
1745 /* Disable resizing (done for Motif!) */
1746 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1748 /* The third arg is DEEP_P, which says to consider the entire
1749 menu trees we supply, rather than just the menu bar item names. */
1750 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1752 /* Re-enable the edit widget to resize. */
1753 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1757 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1758 f
->output_data
.x
->column_widget
,
1760 popup_activate_callback
,
1761 menubar_selection_callback
,
1762 popup_deactivate_callback
);
1763 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1768 = (f
->output_data
.x
->menubar_widget
1769 ? (f
->output_data
.x
->menubar_widget
->core
.height
1770 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1774 if (FRAME_EXTERNAL_MENU_BAR (f
))
1777 XtVaGetValues (f
->output_data
.x
->column_widget
,
1778 XtNinternalBorderWidth
, &ibw
, NULL
);
1779 menubar_size
+= ibw
;
1781 #endif /* USE_LUCID */
1783 f
->output_data
.x
->menubar_height
= menubar_size
;
1786 free_menubar_widget_value_tree (first_wv
);
1788 update_frame_menubar (f
);
1793 /* Called from Fx_create_frame to create the initial menubar of a frame
1794 before it is mapped, so that the window is mapped with the menubar already
1795 there instead of us tacking it on later and thrashing the window after it
1799 initialize_frame_menubar (f
)
1802 /* This function is called before the first chance to redisplay
1803 the frame. It has to be, so the frame will have the right size. */
1804 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1805 set_frame_menubar (f
, 1, 1);
1808 /* Get rid of the menu bar of frame F, and free its storage.
1809 This is used when deleting a frame, and when turning off the menu bar. */
1812 free_frame_menubar (f
)
1815 Widget menubar_widget
;
1818 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1823 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1828 #endif /* USE_X_TOOLKIT */
1830 /* xmenu_show actually displays a menu using the panes and items in menu_items
1831 and returns the value selected from it.
1832 There are two versions of xmenu_show, one for Xt and one for Xlib.
1833 Both assume input is blocked by the caller. */
1835 /* F is the frame the menu is for.
1836 X and Y are the frame-relative specified position,
1837 relative to the inside upper left corner of the frame F.
1838 FOR_CLICK if this menu was invoked for a mouse click.
1839 KEYMAPS is 1 if this menu was specified with keymaps;
1840 in that case, we return a list containing the chosen item's value
1841 and perhaps also the pane's prefix.
1842 TITLE is the specified menu title.
1843 ERROR is a place to store an error message string in case of failure.
1844 (We return nil on failure, but the value doesn't actually matter.) */
1846 #ifdef USE_X_TOOLKIT
1848 /* We need a unique id for each widget handled by the Lucid Widget
1851 For the main windows, and popup menus, we use this counter,
1852 which we increment each time after use. This starts from 1<<16.
1854 For menu bars, we use numbers starting at 0, counted in
1855 next_menubar_widget_id. */
1856 LWLIB_ID widget_id_tick
;
1859 static Lisp_Object
*volatile menu_item_selection
;
1861 static Lisp_Object
*menu_item_selection
;
1865 popup_selection_callback (widget
, id
, client_data
)
1868 XtPointer client_data
;
1870 menu_item_selection
= (Lisp_Object
*) client_data
;
1874 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
1888 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1889 widget_value
**submenu_stack
1890 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1891 Lisp_Object
*subprefix_stack
1892 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1893 int submenu_depth
= 0;
1894 XButtonPressedEvent dummy
;
1897 int next_release_must_exit
= 0;
1901 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1903 *error
= "Empty menu";
1907 /* Create a tree of widget_value objects
1908 representing the panes and their items. */
1909 wv
= xmalloc_widget_value ();
1916 /* Loop over all panes and items, filling in the tree. */
1918 while (i
< menu_items_used
)
1920 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1922 submenu_stack
[submenu_depth
++] = save_wv
;
1928 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1931 save_wv
= submenu_stack
[--submenu_depth
];
1935 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1936 && submenu_depth
!= 0)
1937 i
+= MENU_ITEMS_PANE_LENGTH
;
1938 /* Ignore a nil in the item list.
1939 It's meaningful only for dialog boxes. */
1940 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1942 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1944 /* Create a new pane. */
1945 Lisp_Object pane_name
, prefix
;
1947 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1948 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1949 pane_string
= (NILP (pane_name
)
1950 ? "" : (char *) XSTRING (pane_name
)->data
);
1951 /* If there is just one top-level pane, put all its items directly
1952 under the top-level menu. */
1953 if (menu_items_n_panes
== 1)
1956 /* If the pane has a meaningful name,
1957 make the pane a top-level menu item
1958 with its items as a submenu beneath it. */
1959 if (!keymaps
&& strcmp (pane_string
, ""))
1961 wv
= xmalloc_widget_value ();
1965 first_wv
->contents
= wv
;
1966 wv
->name
= pane_string
;
1967 if (keymaps
&& !NILP (prefix
))
1974 else if (first_pane
)
1980 i
+= MENU_ITEMS_PANE_LENGTH
;
1984 /* Create a new item within current pane. */
1985 Lisp_Object item_name
, enable
, descrip
, def
;
1986 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1987 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1989 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1990 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
1992 wv
= xmalloc_widget_value ();
1996 save_wv
->contents
= wv
;
1997 wv
->name
= (char *) XSTRING (item_name
)->data
;
1998 if (!NILP (descrip
))
1999 wv
->key
= (char *) XSTRING (descrip
)->data
;
2001 /* If this item has a null value,
2002 make the call_data null so that it won't display a box
2003 when the mouse is on it. */
2005 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2006 wv
->enabled
= !NILP (enable
);
2009 i
+= MENU_ITEMS_ITEM_LENGTH
;
2013 /* Deal with the title, if it is non-nil. */
2016 widget_value
*wv_title
= xmalloc_widget_value ();
2017 widget_value
*wv_sep1
= xmalloc_widget_value ();
2018 widget_value
*wv_sep2
= xmalloc_widget_value ();
2020 wv_sep2
->name
= "--";
2021 wv_sep2
->next
= first_wv
->contents
;
2023 wv_sep1
->name
= "--";
2024 wv_sep1
->next
= wv_sep2
;
2026 wv_title
->name
= (char *) XSTRING (title
)->data
;
2027 wv_title
->enabled
= True
;
2028 wv_title
->next
= wv_sep1
;
2029 first_wv
->contents
= wv_title
;
2032 /* Actually create the menu. */
2033 menu_id
= widget_id_tick
++;
2034 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2035 f
->output_data
.x
->widget
, 1, 0,
2036 popup_selection_callback
,
2037 popup_deactivate_callback
);
2039 /* Adjust coordinates to relative to the outer (window manager) window. */
2042 int win_x
= 0, win_y
= 0;
2044 /* Find the position of the outside upper-left corner of
2045 the inner window, with respect to the outer window. */
2046 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2049 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2051 /* From-window, to-window. */
2052 f
->output_data
.x
->window_desc
,
2053 f
->output_data
.x
->parent_desc
,
2055 /* From-position, to-position. */
2056 0, 0, &win_x
, &win_y
,
2058 /* Child of window. */
2066 /* Adjust coordinates to be root-window-relative. */
2067 x
+= f
->output_data
.x
->left_pos
;
2068 y
+= f
->output_data
.x
->top_pos
;
2070 dummy
.type
= ButtonPress
;
2072 dummy
.send_event
= 0;
2073 dummy
.display
= FRAME_X_DISPLAY (f
);
2074 dummy
.time
= CurrentTime
;
2076 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2077 dummy
.window
= dummy
.root
;
2078 dummy
.subwindow
= dummy
.root
;
2084 /* Don't allow any geometry request from the user. */
2085 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2086 XtSetValues (menu
, av
, ac
);
2088 /* Free the widget_value objects we used to specify the contents. */
2089 free_menubar_widget_value_tree (first_wv
);
2091 /* No selection has been chosen yet. */
2092 menu_item_selection
= 0;
2094 /* Display the menu. */
2095 lw_popup_menu (menu
, &dummy
);
2096 popup_activated_flag
= 1;
2098 /* Process events that apply to the menu. */
2099 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
);
2101 /* fp turned off the following statement and wrote a comment
2102 that it is unnecessary--that the menu has already disappeared.
2103 Nowadays the menu disappears ok, all right, but
2104 we need to delete the widgets or multiple ones will pile up. */
2105 lw_destroy_all_widgets (menu_id
);
2107 /* Find the selected item, and its pane, to return
2108 the proper value. */
2109 if (menu_item_selection
!= 0)
2111 Lisp_Object prefix
, entry
;
2115 while (i
< menu_items_used
)
2117 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2119 subprefix_stack
[submenu_depth
++] = prefix
;
2123 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2125 prefix
= subprefix_stack
[--submenu_depth
];
2128 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2131 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2132 i
+= MENU_ITEMS_PANE_LENGTH
;
2134 /* Ignore a nil in the item list.
2135 It's meaningful only for dialog boxes. */
2136 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2141 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2142 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2148 entry
= Fcons (entry
, Qnil
);
2150 entry
= Fcons (prefix
, entry
);
2151 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2152 if (!NILP (subprefix_stack
[j
]))
2153 entry
= Fcons (subprefix_stack
[j
], entry
);
2157 i
+= MENU_ITEMS_ITEM_LENGTH
;
2166 dialog_selection_callback (widget
, id
, client_data
)
2169 XtPointer client_data
;
2171 /* The EMACS_INT cast avoids a warning. There's no problem
2172 as long as pointers have enough bits to hold small integers. */
2173 if ((int) (EMACS_INT
) client_data
!= -1)
2174 menu_item_selection
= (Lisp_Object
*) client_data
;
2176 lw_destroy_all_widgets (id
);
2178 popup_activated_flag
= 0;
2181 static char * button_names
[] = {
2182 "button1", "button2", "button3", "button4", "button5",
2183 "button6", "button7", "button8", "button9", "button10" };
2186 xdialog_show (f
, keymaps
, title
, error
)
2192 int i
, nb_buttons
=0;
2195 char dialog_name
[6];
2197 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2199 /* Number of elements seen so far, before boundary. */
2201 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2202 int boundary_seen
= 0;
2206 if (menu_items_n_panes
> 1)
2208 *error
= "Multiple panes in dialog box";
2212 /* Create a tree of widget_value objects
2213 representing the text label and buttons. */
2215 Lisp_Object pane_name
, prefix
;
2217 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2218 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2219 pane_string
= (NILP (pane_name
)
2220 ? "" : (char *) XSTRING (pane_name
)->data
);
2221 prev_wv
= xmalloc_widget_value ();
2222 prev_wv
->value
= pane_string
;
2223 if (keymaps
&& !NILP (prefix
))
2225 prev_wv
->enabled
= 1;
2226 prev_wv
->name
= "message";
2229 /* Loop over all panes and items, filling in the tree. */
2230 i
= MENU_ITEMS_PANE_LENGTH
;
2231 while (i
< menu_items_used
)
2234 /* Create a new item within current pane. */
2235 Lisp_Object item_name
, enable
, descrip
;
2236 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2237 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2239 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2241 if (NILP (item_name
))
2243 free_menubar_widget_value_tree (first_wv
);
2244 *error
= "Submenu in dialog items";
2247 if (EQ (item_name
, Qquote
))
2249 /* This is the boundary between left-side elts
2250 and right-side elts. Stop incrementing right_count. */
2255 if (nb_buttons
>= 10)
2257 free_menubar_widget_value_tree (first_wv
);
2258 *error
= "Too many dialog items";
2262 wv
= xmalloc_widget_value ();
2264 wv
->name
= (char *) button_names
[nb_buttons
];
2265 if (!NILP (descrip
))
2266 wv
->key
= (char *) XSTRING (descrip
)->data
;
2267 wv
->value
= (char *) XSTRING (item_name
)->data
;
2268 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2269 wv
->enabled
= !NILP (enable
);
2272 if (! boundary_seen
)
2276 i
+= MENU_ITEMS_ITEM_LENGTH
;
2279 /* If the boundary was not specified,
2280 by default put half on the left and half on the right. */
2281 if (! boundary_seen
)
2282 left_count
= nb_buttons
- nb_buttons
/ 2;
2284 wv
= xmalloc_widget_value ();
2285 wv
->name
= dialog_name
;
2287 /* Dialog boxes use a really stupid name encoding
2288 which specifies how many buttons to use
2289 and how many buttons are on the right.
2290 The Q means something also. */
2291 dialog_name
[0] = 'Q';
2292 dialog_name
[1] = '0' + nb_buttons
;
2293 dialog_name
[2] = 'B';
2294 dialog_name
[3] = 'R';
2295 /* Number of buttons to put on the right. */
2296 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2298 wv
->contents
= first_wv
;
2302 /* Actually create the dialog. */
2303 dialog_id
= widget_id_tick
++;
2304 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2305 f
->output_data
.x
->widget
, 1, 0,
2306 dialog_selection_callback
, 0);
2307 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2308 /* Free the widget_value objects we used to specify the contents. */
2309 free_menubar_widget_value_tree (first_wv
);
2311 /* No selection has been chosen yet. */
2312 menu_item_selection
= 0;
2314 /* Display the menu. */
2315 lw_pop_up_all_widgets (dialog_id
);
2316 popup_activated_flag
= 1;
2318 /* Process events that apply to the menu. */
2319 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
);
2321 lw_destroy_all_widgets (dialog_id
);
2323 /* Find the selected item, and its pane, to return
2324 the proper value. */
2325 if (menu_item_selection
!= 0)
2331 while (i
< menu_items_used
)
2335 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2338 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2339 i
+= MENU_ITEMS_PANE_LENGTH
;
2344 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2345 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2349 entry
= Fcons (entry
, Qnil
);
2351 entry
= Fcons (prefix
, entry
);
2355 i
+= MENU_ITEMS_ITEM_LENGTH
;
2362 #else /* not USE_X_TOOLKIT */
2365 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2375 int pane
, selidx
, lpane
, status
;
2376 Lisp_Object entry
, pane_prefix
;
2378 int ulx
, uly
, width
, height
;
2379 int dispwidth
, dispheight
;
2383 unsigned int dummy_uint
;
2386 if (menu_items_n_panes
== 0)
2389 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2391 *error
= "Empty menu";
2395 /* Figure out which root window F is on. */
2396 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2397 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2398 &dummy_uint
, &dummy_uint
);
2400 /* Make the menu on that window. */
2401 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2404 *error
= "Can't create menu";
2408 #ifdef HAVE_X_WINDOWS
2409 /* Adjust coordinates to relative to the outer (window manager) window. */
2412 int win_x
= 0, win_y
= 0;
2414 /* Find the position of the outside upper-left corner of
2415 the inner window, with respect to the outer window. */
2416 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2419 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2421 /* From-window, to-window. */
2422 f
->output_data
.x
->window_desc
,
2423 f
->output_data
.x
->parent_desc
,
2425 /* From-position, to-position. */
2426 0, 0, &win_x
, &win_y
,
2428 /* Child of window. */
2435 #endif /* HAVE_X_WINDOWS */
2437 /* Adjust coordinates to be root-window-relative. */
2438 x
+= f
->output_data
.x
->left_pos
;
2439 y
+= f
->output_data
.x
->top_pos
;
2441 /* Create all the necessary panes and their items. */
2443 while (i
< menu_items_used
)
2445 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2447 /* Create a new pane. */
2448 Lisp_Object pane_name
, prefix
;
2451 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2452 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2453 pane_string
= (NILP (pane_name
)
2454 ? "" : (char *) XSTRING (pane_name
)->data
);
2455 if (keymaps
&& !NILP (prefix
))
2458 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2459 if (lpane
== XM_FAILURE
)
2461 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2462 *error
= "Can't create pane";
2465 i
+= MENU_ITEMS_PANE_LENGTH
;
2467 /* Find the width of the widest item in this pane. */
2470 while (j
< menu_items_used
)
2473 item
= XVECTOR (menu_items
)->contents
[j
];
2481 width
= XSTRING (item
)->size
;
2482 if (width
> maxwidth
)
2485 j
+= MENU_ITEMS_ITEM_LENGTH
;
2488 /* Ignore a nil in the item list.
2489 It's meaningful only for dialog boxes. */
2490 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2494 /* Create a new item within current pane. */
2495 Lisp_Object item_name
, enable
, descrip
;
2496 unsigned char *item_data
;
2498 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2499 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2501 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2502 if (!NILP (descrip
))
2504 int gap
= maxwidth
- XSTRING (item_name
)->size
;
2507 spacer
= Fmake_string (make_number (gap
), make_number (' '));
2508 item_name
= concat2 (item_name
, spacer
);
2509 item_name
= concat2 (item_name
, descrip
);
2510 item_data
= XSTRING (item_name
)->data
;
2512 /* if alloca is fast, use that to make the space,
2513 to reduce gc needs. */
2515 = (unsigned char *) alloca (maxwidth
2516 + XSTRING (descrip
)->size
+ 1);
2517 bcopy (XSTRING (item_name
)->data
, item_data
,
2518 XSTRING (item_name
)->size
);
2519 for (j
= XSTRING (item_name
)->size
; j
< maxwidth
; j
++)
2521 bcopy (XSTRING (descrip
)->data
, item_data
+ j
,
2522 XSTRING (descrip
)->size
);
2523 item_data
[j
+ XSTRING (descrip
)->size
] = 0;
2527 item_data
= XSTRING (item_name
)->data
;
2529 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2530 menu
, lpane
, 0, item_data
,
2534 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2535 *error
= "Can't add selection to menu";
2538 i
+= MENU_ITEMS_ITEM_LENGTH
;
2542 /* All set and ready to fly. */
2543 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2544 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
),
2545 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2546 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
),
2547 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2548 x
= min (x
, dispwidth
);
2549 y
= min (y
, dispheight
);
2552 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2553 &ulx
, &uly
, &width
, &height
);
2554 if (ulx
+width
> dispwidth
)
2556 x
-= (ulx
+ width
) - dispwidth
;
2557 ulx
= dispwidth
- width
;
2559 if (uly
+height
> dispheight
)
2561 y
-= (uly
+ height
) - dispheight
;
2562 uly
= dispheight
- height
;
2564 if (ulx
< 0) x
-= ulx
;
2565 if (uly
< 0) y
-= uly
;
2567 XMenuSetAEQ (menu
, TRUE
);
2568 XMenuSetFreeze (menu
, TRUE
);
2571 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2572 x
, y
, ButtonReleaseMask
, &datap
);
2575 #ifdef HAVE_X_WINDOWS
2576 /* Assume the mouse has moved out of the X window.
2577 If it has actually moved in, we will get an EnterNotify. */
2578 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2585 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2588 /* Find the item number SELIDX in pane number PANE. */
2590 while (i
< menu_items_used
)
2592 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2596 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2598 i
+= MENU_ITEMS_PANE_LENGTH
;
2607 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2610 entry
= Fcons (entry
, Qnil
);
2611 if (!NILP (pane_prefix
))
2612 entry
= Fcons (pane_prefix
, entry
);
2618 i
+= MENU_ITEMS_ITEM_LENGTH
;
2624 *error
= "Can't activate menu";
2630 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2632 #ifdef HAVE_X_WINDOWS
2633 /* State that no mouse buttons are now held.
2634 (The oldXMenu code doesn't track this info for us.)
2635 That is not necessarily true, but the fiction leads to reasonable
2636 results, and it is a pain to ask which are actually held now. */
2637 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2643 #endif /* not USE_X_TOOLKIT */
2645 #endif /* HAVE_MENUS */
2649 staticpro (&menu_items
);
2652 Qdebug_on_next_call
= intern ("debug-on-next-call");
2653 staticpro (&Qdebug_on_next_call
);
2655 #ifdef USE_X_TOOLKIT
2656 widget_id_tick
= (1<<16);
2657 next_menubar_widget_id
= 1;
2660 defsubr (&Sx_popup_menu
);
2662 defsubr (&Sx_popup_dialog
);