1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1999, 2000, 2001, 2003, 2004
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* X pop-up deck-of-cards menu facility for GNU Emacs.
24 * Written by Jon Arnold and Roman Budzianowski
25 * Mods and rewrite by Robert Krawitz
29 /* Modified by Fred Pierresteguy on December 93
30 to make the popup menus and menubar use the Xt. */
32 /* Rewritten for clarity and GC protection by rms in Feb 94. */
36 /* On 4.3 this loses if it comes after xterm.h. */
42 #include "termhooks.h"
47 #include "blockinput.h"
57 /* This may include sys/types.h, and that somehow loses
58 if this is not done before the other system files. */
62 /* Load sys/types.h if not already loaded.
63 In some systems loading it twice is suicidal. */
65 #include <sys/types.h>
68 #include "dispextern.h"
71 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
72 code accepts the Emacs internal encoding. */
73 #undef HAVE_MULTILINGUAL_MENU
77 #include <X11/IntrinsicP.h>
78 #include <X11/CoreP.h>
79 #include <X11/StringDefs.h>
80 #include <X11/Shell.h>
82 #include <X11/Xaw/Paned.h>
83 #endif /* USE_LUCID */
84 #include "../lwlib/lwlib.h"
85 #else /* not USE_X_TOOLKIT */
87 #include "../oldXMenu/XMenu.h"
89 #endif /* not USE_X_TOOLKIT */
90 #endif /* HAVE_X_WINDOWS */
97 Lisp_Object Vmenu_updating_frame
;
99 Lisp_Object Qdebug_on_next_call
;
101 extern Lisp_Object Qmenu_bar
;
103 extern Lisp_Object QCtoggle
, QCradio
;
105 extern Lisp_Object Voverriding_local_map
;
106 extern Lisp_Object Voverriding_local_map_menu_flag
;
108 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
110 extern Lisp_Object Qmenu_bar_update_hook
;
113 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
114 extern XtAppContext Xt_app_con
;
116 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, char **));
117 static void popup_get_selection
P_ ((XEvent
*, struct x_display_info
*,
120 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
123 #endif /* USE_X_TOOLKIT */
128 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
129 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, char **));
132 /* This is how to deal with multibyte text if HAVE_MULTILINGUAL_MENU
133 isn't defined. The use of HAVE_MULTILINGUAL_MENU could probably be
134 confined to an extended version of this with sections of code below
135 using it unconditionally. */
137 /* gtk just uses utf-8. */
138 # define ENCODE_MENU_STRING(str) ENCODE_UTF_8 (str)
140 /* I'm not convinced ENCODE_SYSTEM is defined correctly, or maybe
141 something else should be used here. Except under MS-Windows it
142 just converts to unibyte, but encoding with `locale-coding-system'
143 seems better -- X may actually display the result correctly, and
144 it's not necessarily equivalent to the unibyte text. -- fx */
145 # define ENCODE_MENU_STRING(str) ENCODE_SYSTEM (str)
148 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
149 Lisp_Object
, Lisp_Object
, Lisp_Object
,
150 Lisp_Object
, Lisp_Object
));
151 static int update_frame_menubar
P_ ((struct frame
*));
152 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
153 Lisp_Object
, char **));
154 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
155 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
157 static void list_of_panes
P_ ((Lisp_Object
));
158 static void list_of_items
P_ ((Lisp_Object
));
161 /* This holds a Lisp vector that holds the results of decoding
162 the keymaps or alist-of-alists that specify a menu.
164 It describes the panes and items within the panes.
166 Each pane is described by 3 elements in the vector:
167 t, the pane name, the pane's prefix key.
168 Then follow the pane's items, with 5 elements per item:
169 the item string, the enable flag, the item's value,
170 the definition, and the equivalent keyboard key's description string.
172 In some cases, multiple levels of menus may be described.
173 A single vector slot containing nil indicates the start of a submenu.
174 A single vector slot containing lambda indicates the end of a submenu.
175 The submenu follows a menu item which is the way to reach the submenu.
177 A single vector slot containing quote indicates that the
178 following items should appear on the right of a dialog box.
180 Using a Lisp vector to hold this information while we decode it
181 takes care of protecting all the data from GC. */
183 #define MENU_ITEMS_PANE_NAME 1
184 #define MENU_ITEMS_PANE_PREFIX 2
185 #define MENU_ITEMS_PANE_LENGTH 3
189 MENU_ITEMS_ITEM_NAME
= 0,
190 MENU_ITEMS_ITEM_ENABLE
,
191 MENU_ITEMS_ITEM_VALUE
,
192 MENU_ITEMS_ITEM_EQUIV_KEY
,
193 MENU_ITEMS_ITEM_DEFINITION
,
194 MENU_ITEMS_ITEM_TYPE
,
195 MENU_ITEMS_ITEM_SELECTED
,
196 MENU_ITEMS_ITEM_HELP
,
197 MENU_ITEMS_ITEM_LENGTH
200 static Lisp_Object menu_items
;
202 /* If non-nil, means that the global vars defined here are already in use.
203 Used to detect cases where we try to re-enter this non-reentrant code. */
204 static Lisp_Object menu_items_inuse
;
206 /* Number of slots currently allocated in menu_items. */
207 static int menu_items_allocated
;
209 /* This is the index in menu_items of the first empty slot. */
210 static int menu_items_used
;
212 /* The number of panes currently recorded in menu_items,
213 excluding those within submenus. */
214 static int menu_items_n_panes
;
216 /* Current depth within submenus. */
217 static int menu_items_submenu_depth
;
219 /* Flag which when set indicates a dialog or menu has been posted by
220 Xt on behalf of one of the widget sets. */
221 static int popup_activated_flag
;
223 static int next_menubar_widget_id
;
225 /* This is set nonzero after the user activates the menu bar, and set
226 to zero again after the menu bars are redisplayed by prepare_menu_bar.
227 While it is nonzero, all calls to set_frame_menubar go deep.
229 I don't understand why this is needed, but it does seem to be
230 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
232 int pending_menu_activation
;
236 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
238 static struct frame
*
239 menubar_id_to_frame (id
)
242 Lisp_Object tail
, frame
;
245 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
248 if (!GC_FRAMEP (frame
))
251 if (!FRAME_WINDOW_P (f
))
253 if (f
->output_data
.x
->id
== id
)
261 /* Initialize the menu_items structure if we haven't already done so.
262 Also mark it as currently empty. */
267 if (NILP (menu_items
))
269 menu_items_allocated
= 60;
270 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
273 if (!NILP (menu_items_inuse
))
274 error ("Trying to use a menu from within a menu-entry");
275 menu_items_inuse
= Qt
;
277 menu_items_n_panes
= 0;
278 menu_items_submenu_depth
= 0;
281 /* Call at the end of generating the data in menu_items. */
289 unuse_menu_items (dummy
)
292 return menu_items_inuse
= Qnil
;
295 /* Call when finished using the data for the current menu
299 discard_menu_items ()
301 /* Free the structure if it is especially large.
302 Otherwise, hold on to it, to save time. */
303 if (menu_items_allocated
> 200)
306 menu_items_allocated
= 0;
308 xassert (NILP (menu_items_inuse
));
311 /* Make the menu_items vector twice as large. */
317 int old_size
= menu_items_allocated
;
320 menu_items_allocated
*= 2;
321 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
322 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
323 old_size
* sizeof (Lisp_Object
));
326 /* Begin a submenu. */
329 push_submenu_start ()
331 if (menu_items_used
+ 1 > menu_items_allocated
)
334 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
335 menu_items_submenu_depth
++;
343 if (menu_items_used
+ 1 > menu_items_allocated
)
346 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
347 menu_items_submenu_depth
--;
350 /* Indicate boundary between left and right. */
353 push_left_right_boundary ()
355 if (menu_items_used
+ 1 > menu_items_allocated
)
358 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
361 /* Start a new menu pane in menu_items.
362 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
365 push_menu_pane (name
, prefix_vec
)
366 Lisp_Object name
, prefix_vec
;
368 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
371 if (menu_items_submenu_depth
== 0)
372 menu_items_n_panes
++;
373 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
374 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
375 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
378 /* Push one menu item into the current pane. NAME is the string to
379 display. ENABLE if non-nil means this item can be selected. KEY
380 is the key generated by choosing this item, or nil if this item
381 doesn't really have a definition. DEF is the definition of this
382 item. EQUIV is the textual description of the keyboard equivalent
383 for this item (or nil if none). TYPE is the type of this menu
384 item, one of nil, `toggle' or `radio'. */
387 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
388 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
390 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
393 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
394 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
395 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
396 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
397 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
398 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
399 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
400 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
403 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
404 and generate menu panes for them in menu_items.
405 If NOTREAL is nonzero,
406 don't bother really computing whether an item is enabled. */
409 keymap_panes (keymaps
, nmaps
, notreal
)
410 Lisp_Object
*keymaps
;
418 /* Loop over the given keymaps, making a pane for each map.
419 But don't make a pane that is empty--ignore that map instead.
420 P is the number of panes we have made so far. */
421 for (mapno
= 0; mapno
< nmaps
; mapno
++)
422 single_keymap_panes (keymaps
[mapno
],
423 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
425 finish_menu_items ();
428 /* Args passed between single_keymap_panes and single_menu_item. */
431 Lisp_Object pending_maps
;
432 int maxdepth
, notreal
;
436 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
439 /* This is a recursive subroutine of keymap_panes.
440 It handles one keymap, KEYMAP.
441 The other arguments are passed along
442 or point to local variables of the previous function.
443 If NOTREAL is nonzero, only check for equivalent key bindings, don't
444 evaluate expressions in menu items and don't make any menu.
446 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
449 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
451 Lisp_Object pane_name
;
459 skp
.pending_maps
= Qnil
;
460 skp
.maxdepth
= maxdepth
;
461 skp
.notreal
= notreal
;
467 push_menu_pane (pane_name
, prefix
);
470 /* Remember index for first item in this pane so we can go back and
471 add a prefix when (if) we see the first button. After that, notbuttons
472 is set to 0, to mark that we have seen a button and all non button
473 items need a prefix. */
474 skp
.notbuttons
= menu_items_used
;
477 GCPRO1 (skp
.pending_maps
);
478 map_keymap (keymap
, single_menu_item
, Qnil
, &skp
, 1);
481 /* Process now any submenus which want to be panes at this level. */
482 while (CONSP (skp
.pending_maps
))
484 Lisp_Object elt
, eltcdr
, string
;
485 elt
= XCAR (skp
.pending_maps
);
487 string
= XCAR (eltcdr
);
488 /* We no longer discard the @ from the beginning of the string here.
489 Instead, we do this in xmenu_show. */
490 single_keymap_panes (Fcar (elt
), string
,
491 XCDR (eltcdr
), notreal
, maxdepth
- 1);
492 skp
.pending_maps
= XCDR (skp
.pending_maps
);
496 /* This is a subroutine of single_keymap_panes that handles one
498 KEY is a key in a keymap and ITEM is its binding.
499 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
501 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
502 evaluate expressions in menu items and don't make any menu.
503 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
504 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
505 buttons. It keeps track of if we have seen a button in this menu or
509 single_menu_item (key
, item
, dummy
, skp_v
)
510 Lisp_Object key
, item
, dummy
;
513 Lisp_Object map
, item_string
, enabled
;
514 struct gcpro gcpro1
, gcpro2
;
516 struct skp
*skp
= skp_v
;
518 /* Parse the menu item and leave the result in item_properties. */
520 res
= parse_menu_item (item
, skp
->notreal
, 0);
523 return; /* Not a menu item. */
525 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
529 /* We don't want to make a menu, just traverse the keymaps to
530 precompute equivalent key bindings. */
532 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
536 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
537 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
539 if (!NILP (map
) && SREF (item_string
, 0) == '@')
542 /* An enabled separate pane. Remember this to handle it later. */
543 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
549 /* Simulate radio buttons and toggle boxes by putting a prefix in
552 Lisp_Object prefix
= Qnil
;
553 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
557 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
560 /* The first button. Line up previous items in this menu. */
562 int index
= skp
->notbuttons
; /* Index for first item this menu. */
565 while (index
< menu_items_used
)
568 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
572 submenu
++; /* Skip sub menu. */
574 else if (EQ (tem
, Qlambda
))
577 submenu
--; /* End sub menu. */
579 else if (EQ (tem
, Qt
))
580 index
+= 3; /* Skip new pane marker. */
581 else if (EQ (tem
, Qquote
))
582 index
++; /* Skip a left, right divider. */
585 if (!submenu
&& SREF (tem
, 0) != '\0'
586 && SREF (tem
, 0) != '-')
587 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
588 = concat2 (build_string (" "), tem
);
589 index
+= MENU_ITEMS_ITEM_LENGTH
;
595 /* Calculate prefix, if any, for this item. */
596 if (EQ (type
, QCtoggle
))
597 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
598 else if (EQ (type
, QCradio
))
599 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
601 /* Not a button. If we have earlier buttons, then we need a prefix. */
602 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
603 && SREF (item_string
, 0) != '-')
604 prefix
= build_string (" ");
607 item_string
= concat2 (prefix
, item_string
);
609 #endif /* not HAVE_BOXES */
611 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
613 /* Indicate visually that this is a submenu. */
614 item_string
= concat2 (item_string
, build_string (" >"));
617 push_menu_item (item_string
, enabled
, key
,
618 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
619 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
620 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
621 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
622 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
624 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
625 /* Display a submenu using the toolkit. */
626 if (! (NILP (map
) || NILP (enabled
)))
628 push_submenu_start ();
629 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
635 /* Push all the panes and items of a menu described by the
636 alist-of-alists MENU.
637 This handles old-fashioned calls to x-popup-menu. */
647 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
649 Lisp_Object elt
, pane_name
, pane_data
;
651 pane_name
= Fcar (elt
);
652 CHECK_STRING (pane_name
);
653 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
654 pane_data
= Fcdr (elt
);
655 CHECK_CONS (pane_data
);
656 list_of_items (pane_data
);
659 finish_menu_items ();
662 /* Push the items in a single pane defined by the alist PANE. */
668 Lisp_Object tail
, item
, item1
;
670 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
674 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
675 Qnil
, Qnil
, Qnil
, Qnil
);
676 else if (NILP (item
))
677 push_left_right_boundary ();
682 CHECK_STRING (item1
);
683 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, Fcdr (item
),
684 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
689 #ifdef HAVE_X_WINDOWS
690 /* Return the mouse position in *X and *Y. The coordinates are window
691 relative for the edit window in frame F.
692 This is for Fx_popup_menu. The mouse_position_hook can not
693 be used for X, as it returns window relative coordinates
694 for the window where the mouse is in. This could be the menu bar,
695 the scroll bar or the edit window. Fx_popup_menu needs to be
696 sure it is the edit window. */
698 mouse_position_for_popup (f
, x
, y
)
703 Window root
, dummy_window
;
708 XQueryPointer (FRAME_X_DISPLAY (f
),
709 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
711 /* The root window which contains the pointer. */
714 /* Window pointer is on, not used */
717 /* The position on that root window. */
720 /* x/y in dummy_window coordinates, not used. */
723 /* Modifier keys and pointer buttons, about which
725 (unsigned int *) &dummy
);
729 /* xmenu_show expects window coordinates, not root window
730 coordinates. Translate. */
731 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
732 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
735 #endif /* HAVE_X_WINDOWS */
737 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
738 doc
: /* Pop up a deck-of-cards menu and return user's selection.
739 POSITION is a position specification. This is either a mouse button event
740 or a list ((XOFFSET YOFFSET) WINDOW)
741 where XOFFSET and YOFFSET are positions in pixels from the top left
742 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)
743 This controls the position of the center of the first line
744 in the first pane of the menu, not the top left of the menu as a whole.
745 If POSITION is t, it means to use the current mouse position.
747 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
748 The menu items come from key bindings that have a menu string as well as
749 a definition; actually, the "definition" in such a key binding looks like
750 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
751 the keymap as a top-level element.
753 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
754 Otherwise, REAL-DEFINITION should be a valid key binding definition.
756 You can also use a list of keymaps as MENU.
757 Then each keymap makes a separate pane.
758 When MENU is a keymap or a list of keymaps, the return value
761 Alternatively, you can specify a menu of multiple panes
762 with a list of the form (TITLE PANE1 PANE2...),
763 where each pane is a list of form (TITLE ITEM1 ITEM2...).
764 Each ITEM is normally a cons cell (STRING . VALUE);
765 but a string can appear as an item--that makes a nonselectable line
767 With this form of menu, the return value is VALUE from the chosen item.
769 If POSITION is nil, don't display the menu at all, just precalculate the
770 cached information about equivalent key sequences. */)
772 Lisp_Object position
, menu
;
774 Lisp_Object keymap
, tem
;
775 int xpos
= 0, ypos
= 0;
778 Lisp_Object selection
;
780 Lisp_Object x
, y
, window
;
783 int specpdl_count
= SPECPDL_INDEX ();
787 if (! NILP (position
))
789 int get_current_pos_p
= 0;
792 /* Decode the first argument: find the window and the coordinates. */
793 if (EQ (position
, Qt
)
794 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
795 || EQ (XCAR (position
), Qtool_bar
))))
797 get_current_pos_p
= 1;
801 tem
= Fcar (position
);
804 window
= Fcar (Fcdr (position
));
806 y
= Fcar (Fcdr (tem
));
811 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
812 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
813 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
818 /* If a click happens in an external tool bar or a detached
819 tool bar, x and y is NIL. In that case, use the current
820 mouse position. This happens for the help button in the
821 tool bar. Ideally popup-menu should pass NIL to
822 this function, but it doesn't. */
823 if (NILP (x
) && NILP (y
))
824 get_current_pos_p
= 1;
827 if (get_current_pos_p
)
829 /* Use the mouse's current position. */
830 FRAME_PTR new_f
= SELECTED_FRAME ();
831 #ifdef HAVE_X_WINDOWS
832 /* Can't use mouse_position_hook for X since it returns
833 coordinates relative to the window the mouse is in,
834 we need coordinates relative to the edit widget always. */
839 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
840 /* cur_x/y may be negative, so use make_number. */
841 x
= make_number (cur_x
);
842 y
= make_number (cur_y
);
845 #else /* not HAVE_X_WINDOWS */
846 Lisp_Object bar_window
;
847 enum scroll_bar_part part
;
850 if (mouse_position_hook
)
851 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
852 &part
, &x
, &y
, &time
);
853 #endif /* not HAVE_X_WINDOWS */
856 XSETFRAME (window
, new_f
);
859 window
= selected_window
;
868 /* Decode where to put the menu. */
876 else if (WINDOWP (window
))
878 CHECK_LIVE_WINDOW (window
);
879 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
881 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
882 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
885 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
886 but I don't want to make one now. */
887 CHECK_WINDOW (window
);
892 Vmenu_updating_frame
= Qnil
;
893 #endif /* HAVE_MENUS */
895 record_unwind_protect (unuse_menu_items
, Qnil
);
899 /* Decode the menu items from what was specified. */
901 keymap
= get_keymap (menu
, 0, 0);
904 /* We were given a keymap. Extract menu info from the keymap. */
907 /* Extract the detailed info to make one pane. */
908 keymap_panes (&menu
, 1, NILP (position
));
910 /* Search for a string appearing directly as an element of the keymap.
911 That string is the title of the menu. */
912 prompt
= Fkeymap_prompt (keymap
);
913 if (NILP (title
) && !NILP (prompt
))
916 /* Make that be the pane title of the first pane. */
917 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
918 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
922 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
924 /* We were given a list of keymaps. */
925 int nmaps
= XFASTINT (Flength (menu
));
927 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
932 /* The first keymap that has a prompt string
933 supplies the menu title. */
934 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
938 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
940 prompt
= Fkeymap_prompt (keymap
);
941 if (NILP (title
) && !NILP (prompt
))
945 /* Extract the detailed info to make one pane. */
946 keymap_panes (maps
, nmaps
, NILP (position
));
948 /* Make the title be the pane title of the first pane. */
949 if (!NILP (title
) && menu_items_n_panes
>= 0)
950 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
956 /* We were given an old-fashioned menu. */
958 CHECK_STRING (title
);
960 list_of_panes (Fcdr (menu
));
965 unbind_to (specpdl_count
, Qnil
);
969 discard_menu_items ();
975 /* Display them in a menu. */
978 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
979 keymaps
, title
, &error_name
);
982 discard_menu_items ();
985 #endif /* HAVE_MENUS */
987 if (error_name
) error (error_name
);
993 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
994 doc
: /* Pop up a dialog box and return user's selection.
995 POSITION specifies which frame to use.
996 This is normally a mouse button event or a window or frame.
997 If POSITION is t, it means to use the frame the mouse is on.
998 The dialog box appears in the middle of the specified frame.
1000 CONTENTS specifies the alternatives to display in the dialog box.
1001 It is a list of the form (TITLE ITEM1 ITEM2...).
1002 Each ITEM is a cons cell (STRING . VALUE).
1003 The return value is VALUE from the chosen item.
1005 An ITEM may also be just a string--that makes a nonselectable item.
1006 An ITEM may also be nil--that means to put all preceding items
1007 on the left of the dialog box and all following items on the right.
1008 \(By default, approximately half appear on each side.) */)
1009 (position
, contents
)
1010 Lisp_Object position
, contents
;
1017 /* Decode the first argument: find the window or frame to use. */
1018 if (EQ (position
, Qt
)
1019 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1020 || EQ (XCAR (position
), Qtool_bar
))))
1022 #if 0 /* Using the frame the mouse is on may not be right. */
1023 /* Use the mouse's current position. */
1024 FRAME_PTR new_f
= SELECTED_FRAME ();
1025 Lisp_Object bar_window
;
1026 enum scroll_bar_part part
;
1030 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1033 XSETFRAME (window
, new_f
);
1035 window
= selected_window
;
1037 window
= selected_window
;
1039 else if (CONSP (position
))
1042 tem
= Fcar (position
);
1044 window
= Fcar (Fcdr (position
));
1047 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1048 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1051 else if (WINDOWP (position
) || FRAMEP (position
))
1056 /* Decode where to put the menu. */
1058 if (FRAMEP (window
))
1059 f
= XFRAME (window
);
1060 else if (WINDOWP (window
))
1062 CHECK_LIVE_WINDOW (window
);
1063 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1066 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1067 but I don't want to make one now. */
1068 CHECK_WINDOW (window
);
1070 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1071 /* Display a menu with these alternatives
1072 in the middle of frame F. */
1074 Lisp_Object x
, y
, frame
, newpos
;
1075 XSETFRAME (frame
, f
);
1076 XSETINT (x
, x_pixel_width (f
) / 2);
1077 XSETINT (y
, x_pixel_height (f
) / 2);
1078 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1080 return Fx_popup_menu (newpos
,
1081 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1087 Lisp_Object selection
;
1088 int specpdl_count
= SPECPDL_INDEX ();
1090 /* Decode the dialog items from what was specified. */
1091 title
= Fcar (contents
);
1092 CHECK_STRING (title
);
1093 record_unwind_protect (unuse_menu_items
, Qnil
);
1095 if (NILP (Fcar (Fcdr (contents
))))
1096 /* No buttons specified, add an "Ok" button so users can pop down
1097 the dialog. Also, the lesstif/motif version crashes if there are
1099 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1101 list_of_panes (Fcons (contents
, Qnil
));
1103 /* Display them in a dialog box. */
1105 selection
= xdialog_show (f
, 0, title
, &error_name
);
1108 unbind_to (specpdl_count
, Qnil
);
1109 discard_menu_items ();
1111 if (error_name
) error (error_name
);
1117 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1119 /* Loop in Xt until the menu pulldown or dialog popup has been
1120 popped down (deactivated). This is used for x-popup-menu
1121 and x-popup-dialog; it is not used for the menu bar.
1123 If DOWN_ON_KEYPRESS is nonzero, pop down if a key is pressed.
1125 This function used to have a DO_TIMERS argument which was
1126 1 in the dialog case, and caused it to run Lisp-level timers.
1127 That was unsafe so we removed it, but does anyone remember
1128 why menus and dialogs were treated differently?
1130 NOTE: All calls to popup_get_selection should be protected
1131 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1133 #ifdef USE_X_TOOLKIT
1135 popup_get_selection (initial_event
, dpyinfo
, id
, down_on_keypress
)
1136 XEvent
*initial_event
;
1137 struct x_display_info
*dpyinfo
;
1139 int down_on_keypress
;
1143 while (popup_activated_flag
)
1147 event
= *initial_event
;
1151 XtAppNextEvent (Xt_app_con
, &event
);
1153 /* Make sure we don't consider buttons grabbed after menu goes.
1154 And make sure to deactivate for any ButtonRelease,
1155 even if XtDispatchEvent doesn't do that. */
1156 if (event
.type
== ButtonRelease
1157 && dpyinfo
->display
== event
.xbutton
.display
)
1159 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1160 #ifdef USE_MOTIF /* Pretending that the event came from a
1161 Btn1Down seems the only way to convince Motif to
1162 activate its callbacks; setting the XmNmenuPost
1163 isn't working. --marcus@sysc.pdx.edu. */
1164 event
.xbutton
.button
= 1;
1165 /* Motif only pops down menus when no Ctrl, Alt or Mod
1166 key is pressed and the button is released. So reset key state
1167 so Motif thinks this is the case. */
1168 event
.xbutton
.state
= 0;
1171 /* If the user presses a key that doesn't go to the menu,
1172 deactivate the menu.
1173 The user is likely to do that if we get wedged.
1174 All toolkits now pop down menus on ESC.
1175 For dialogs however, the focus may not be on the dialog, so
1176 in that case, we pop down. */
1177 else if (event
.type
== KeyPress
1179 && dpyinfo
->display
== event
.xbutton
.display
)
1181 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1182 if (!IsModifierKey (keysym
)
1183 && x_any_window_to_frame (dpyinfo
, event
.xany
.window
) != NULL
)
1184 popup_activated_flag
= 0;
1187 x_dispatch_event (&event
, event
.xany
.display
);
1191 #endif /* USE_X_TOOLKIT */
1194 /* Loop util popup_activated_flag is set to zero in a callback.
1195 Used for popup menus and dialogs. */
1197 popup_widget_loop ()
1199 ++popup_activated_flag
;
1201 /* Process events in the Gtk event loop until done. */
1202 while (popup_activated_flag
)
1204 gtk_main_iteration ();
1209 /* Activate the menu bar of frame F.
1210 This is called from keyboard.c when it gets the
1211 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1213 To activate the menu bar, we use the X button-press event
1214 that was saved in saved_menu_event.
1215 That makes the toolkit do its thing.
1217 But first we recompute the menu bar contents (the whole tree).
1219 The reason for saving the button event until here, instead of
1220 passing it to the toolkit right away, is that we can safely
1221 execute Lisp code. */
1224 x_activate_menubar (f
)
1227 if (!f
->output_data
.x
->saved_menu_event
->type
)
1231 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1232 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1236 set_frame_menubar (f
, 0, 1);
1239 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1240 f
->output_data
.x
->saved_menu_event
);
1241 popup_activated_flag
= 1;
1243 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1247 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1248 pending_menu_activation
= 1;
1251 /* Ignore this if we get it a second time. */
1252 f
->output_data
.x
->saved_menu_event
->type
= 0;
1255 /* Detect if a dialog or menu has been posted. */
1260 return popup_activated_flag
;
1263 /* This callback is invoked when the user selects a menubar cascade
1264 pushbutton, but before the pulldown menu is posted. */
1268 popup_activate_callback (widget
, id
, client_data
)
1271 XtPointer client_data
;
1273 popup_activated_flag
= 1;
1277 /* This callback is invoked when a dialog or menu is finished being
1278 used and has been unposted. */
1282 popup_deactivate_callback (widget
, client_data
)
1284 gpointer client_data
;
1286 popup_activated_flag
= 0;
1290 popup_deactivate_callback (widget
, id
, client_data
)
1293 XtPointer client_data
;
1295 popup_activated_flag
= 0;
1300 /* Function that finds the frame for WIDGET and shows the HELP text
1302 F is the frame if known, or NULL if not known. */
1304 show_help_event (f
, widget
, help
)
1306 xt_or_gtk_widget widget
;
1313 XSETFRAME (frame
, f
);
1314 kbd_buffer_store_help_event (frame
, help
);
1318 #if 0 /* This code doesn't do anything useful. ++kfs */
1319 /* WIDGET is the popup menu. It's parent is the frame's
1320 widget. See which frame that is. */
1321 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1324 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1326 frame
= XCAR (tail
);
1327 if (GC_FRAMEP (frame
)
1328 && (f
= XFRAME (frame
),
1329 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1333 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1337 /* Callback called when menu items are highlighted/unhighlighted
1338 while moving the mouse over them. WIDGET is the menu bar or menu
1339 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1340 the data structure for the menu item, or null in case of
1345 menu_highlight_callback (widget
, call_data
)
1349 xg_menu_item_cb_data
*cb_data
;
1352 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1354 if (! cb_data
) return;
1356 help
= call_data
? cb_data
->help
: Qnil
;
1358 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1359 Don't show help for them, they won't appear before the
1360 popup is popped down. */
1361 if (popup_activated_flag
<= 1)
1362 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1366 menu_highlight_callback (widget
, id
, call_data
)
1374 widget_value
*wv
= (widget_value
*) call_data
;
1376 help
= wv
? wv
->help
: Qnil
;
1378 /* Determine the frame for the help event. */
1379 f
= menubar_id_to_frame (id
);
1381 show_help_event (f
, widget
, help
);
1385 /* Find the menu selection and store it in the keyboard buffer.
1386 F is the frame the menu is on.
1387 MENU_BAR_ITEMS_USED is the length of VECTOR.
1388 VECTOR is an array of menu events for the whole menu.
1391 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1393 int menu_bar_items_used
;
1397 Lisp_Object prefix
, entry
;
1398 Lisp_Object
*subprefix_stack
;
1399 int submenu_depth
= 0;
1403 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1407 while (i
< menu_bar_items_used
)
1409 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1411 subprefix_stack
[submenu_depth
++] = prefix
;
1415 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1417 prefix
= subprefix_stack
[--submenu_depth
];
1420 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1422 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1423 i
+= MENU_ITEMS_PANE_LENGTH
;
1427 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1428 /* The EMACS_INT cast avoids a warning. There's no problem
1429 as long as pointers have enough bits to hold small integers. */
1430 if ((int) (EMACS_INT
) client_data
== i
)
1433 struct input_event buf
;
1437 XSETFRAME (frame
, f
);
1438 buf
.kind
= MENU_BAR_EVENT
;
1439 buf
.frame_or_window
= frame
;
1441 kbd_buffer_store_event (&buf
);
1443 for (j
= 0; j
< submenu_depth
; j
++)
1444 if (!NILP (subprefix_stack
[j
]))
1446 buf
.kind
= MENU_BAR_EVENT
;
1447 buf
.frame_or_window
= frame
;
1448 buf
.arg
= subprefix_stack
[j
];
1449 kbd_buffer_store_event (&buf
);
1454 buf
.kind
= MENU_BAR_EVENT
;
1455 buf
.frame_or_window
= frame
;
1457 kbd_buffer_store_event (&buf
);
1460 buf
.kind
= MENU_BAR_EVENT
;
1461 buf
.frame_or_window
= frame
;
1463 kbd_buffer_store_event (&buf
);
1467 i
+= MENU_ITEMS_ITEM_LENGTH
;
1474 /* Gtk calls callbacks just because we tell it what item should be
1475 selected in a radio group. If this variable is set to a non-zero
1476 value, we are creating menus and don't want callbacks right now.
1478 static int xg_crazy_callback_abort
;
1480 /* This callback is called from the menu bar pulldown menu
1481 when the user makes a selection.
1482 Figure out what the user chose
1483 and put the appropriate events into the keyboard buffer. */
1485 menubar_selection_callback (widget
, client_data
)
1487 gpointer client_data
;
1489 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1491 if (xg_crazy_callback_abort
)
1494 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1497 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1498 cb_data
->cl_data
->menu_bar_items_used
,
1499 cb_data
->cl_data
->menu_bar_vector
,
1500 cb_data
->call_data
);
1503 #else /* not USE_GTK */
1505 /* This callback is called from the menu bar pulldown menu
1506 when the user makes a selection.
1507 Figure out what the user chose
1508 and put the appropriate events into the keyboard buffer. */
1510 menubar_selection_callback (widget
, id
, client_data
)
1513 XtPointer client_data
;
1517 f
= menubar_id_to_frame (id
);
1520 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1521 f
->menu_bar_vector
, client_data
);
1523 #endif /* not USE_GTK */
1525 /* Allocate a widget_value, blocking input. */
1528 xmalloc_widget_value ()
1530 widget_value
*value
;
1533 value
= malloc_widget_value ();
1539 /* This recursively calls free_widget_value on the tree of widgets.
1540 It must free all data that was malloc'ed for these widget_values.
1541 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1542 must be left alone. */
1545 free_menubar_widget_value_tree (wv
)
1550 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1552 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1554 free_menubar_widget_value_tree (wv
->contents
);
1555 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1559 free_menubar_widget_value_tree (wv
->next
);
1560 wv
->next
= (widget_value
*) 0xDEADBEEF;
1563 free_widget_value (wv
);
1567 /* Set up data in menu_items for a menu bar item
1568 whose event type is ITEM_KEY (with string ITEM_NAME)
1569 and whose contents come from the list of keymaps MAPS. */
1572 parse_single_submenu (item_key
, item_name
, maps
)
1573 Lisp_Object item_key
, item_name
, maps
;
1577 Lisp_Object
*mapvec
;
1579 int top_level_items
= 0;
1581 length
= Flength (maps
);
1582 len
= XINT (length
);
1584 /* Convert the list MAPS into a vector MAPVEC. */
1585 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1586 for (i
= 0; i
< len
; i
++)
1588 mapvec
[i
] = Fcar (maps
);
1592 /* Loop over the given keymaps, making a pane for each map.
1593 But don't make a pane that is empty--ignore that map instead. */
1594 for (i
= 0; i
< len
; i
++)
1596 if (!KEYMAPP (mapvec
[i
]))
1598 /* Here we have a command at top level in the menu bar
1599 as opposed to a submenu. */
1600 top_level_items
= 1;
1601 push_menu_pane (Qnil
, Qnil
);
1602 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1603 Qnil
, Qnil
, Qnil
, Qnil
);
1608 prompt
= Fkeymap_prompt (mapvec
[i
]);
1609 single_keymap_panes (mapvec
[i
],
1610 !NILP (prompt
) ? prompt
: item_name
,
1615 return top_level_items
;
1618 /* Create a tree of widget_value objects
1619 representing the panes and items
1620 in menu_items starting at index START, up to index END. */
1622 static widget_value
*
1623 digest_single_submenu (start
, end
, top_level_items
)
1624 int start
, end
, top_level_items
;
1626 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1628 int submenu_depth
= 0;
1629 widget_value
**submenu_stack
;
1632 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1633 wv
= xmalloc_widget_value ();
1637 wv
->button_type
= BUTTON_TYPE_NONE
;
1643 /* Loop over all panes and items made by the preceding call
1644 to parse_single_submenu and construct a tree of widget_value objects.
1645 Ignore the panes and items used by previous calls to
1646 digest_single_submenu, even though those are also in menu_items. */
1650 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1652 submenu_stack
[submenu_depth
++] = save_wv
;
1657 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1660 save_wv
= submenu_stack
[--submenu_depth
];
1663 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1664 && submenu_depth
!= 0)
1665 i
+= MENU_ITEMS_PANE_LENGTH
;
1666 /* Ignore a nil in the item list.
1667 It's meaningful only for dialog boxes. */
1668 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1670 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1672 /* Create a new pane. */
1673 Lisp_Object pane_name
, prefix
;
1676 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1677 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1679 #ifndef HAVE_MULTILINGUAL_MENU
1680 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1682 pane_name
= ENCODE_SYSTEM (pane_name
);
1683 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1686 pane_string
= (NILP (pane_name
)
1687 ? "" : (char *) SDATA (pane_name
));
1688 /* If there is just one top-level pane, put all its items directly
1689 under the top-level menu. */
1690 if (menu_items_n_panes
== 1)
1693 /* If the pane has a meaningful name,
1694 make the pane a top-level menu item
1695 with its items as a submenu beneath it. */
1696 if (strcmp (pane_string
, ""))
1698 wv
= xmalloc_widget_value ();
1702 first_wv
->contents
= wv
;
1703 wv
->lname
= pane_name
;
1704 /* Set value to 1 so update_submenu_strings can handle '@' */
1705 wv
->value
= (char *)1;
1707 wv
->button_type
= BUTTON_TYPE_NONE
;
1712 i
+= MENU_ITEMS_PANE_LENGTH
;
1716 /* Create a new item within current pane. */
1717 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1720 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1721 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1722 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1723 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1724 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1725 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1726 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1728 #ifndef HAVE_MULTILINGUAL_MENU
1729 if (STRING_MULTIBYTE (item_name
))
1731 item_name
= ENCODE_MENU_STRING (item_name
);
1732 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1735 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1737 descrip
= ENCODE_MENU_STRING (descrip
);
1738 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1740 #endif /* not HAVE_MULTILINGUAL_MENU */
1742 wv
= xmalloc_widget_value ();
1746 save_wv
->contents
= wv
;
1748 wv
->lname
= item_name
;
1749 if (!NILP (descrip
))
1752 /* The EMACS_INT cast avoids a warning. There's no problem
1753 as long as pointers have enough bits to hold small integers. */
1754 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1755 wv
->enabled
= !NILP (enable
);
1758 wv
->button_type
= BUTTON_TYPE_NONE
;
1759 else if (EQ (type
, QCradio
))
1760 wv
->button_type
= BUTTON_TYPE_RADIO
;
1761 else if (EQ (type
, QCtoggle
))
1762 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1766 wv
->selected
= !NILP (selected
);
1767 if (! STRINGP (help
))
1774 i
+= MENU_ITEMS_ITEM_LENGTH
;
1778 /* If we have just one "menu item"
1779 that was originally a button, return it by itself. */
1780 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1782 wv
= first_wv
->contents
;
1783 free_widget_value (first_wv
);
1790 /* Walk through the widget_value tree starting at FIRST_WV and update
1791 the char * pointers from the corresponding lisp values.
1792 We do this after building the whole tree, since GC may happen while the
1793 tree is constructed, and small strings are relocated. So we must wait
1794 until no GC can happen before storing pointers into lisp values. */
1796 update_submenu_strings (first_wv
)
1797 widget_value
*first_wv
;
1801 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1803 if (STRINGP (wv
->lname
))
1805 wv
->name
= SDATA (wv
->lname
);
1807 /* Ignore the @ that means "separate pane".
1808 This is a kludge, but this isn't worth more time. */
1809 if (wv
->value
== (char *)1)
1811 if (wv
->name
[0] == '@')
1817 if (STRINGP (wv
->lkey
))
1818 wv
->key
= SDATA (wv
->lkey
);
1821 update_submenu_strings (wv
->contents
);
1826 /* Recompute all the widgets of frame F, when the menu bar has been
1827 changed. Value is non-zero if widgets were updated. */
1830 update_frame_menubar (f
)
1834 return xg_update_frame_menubar (f
);
1836 struct x_output
*x
= f
->output_data
.x
;
1839 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1843 /* Save the size of the frame because the pane widget doesn't accept
1844 to resize itself. So force it. */
1845 columns
= FRAME_COLS (f
);
1846 rows
= FRAME_LINES (f
);
1848 /* Do the voodoo which means "I'm changing lots of things, don't try
1849 to refigure sizes until I'm done." */
1850 lw_refigure_widget (x
->column_widget
, False
);
1852 /* The order in which children are managed is the top to bottom
1853 order in which they are displayed in the paned window. First,
1854 remove the text-area widget. */
1855 XtUnmanageChild (x
->edit_widget
);
1857 /* Remove the menubar that is there now, and put up the menubar that
1859 XtManageChild (x
->menubar_widget
);
1860 XtMapWidget (x
->menubar_widget
);
1861 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1863 /* Re-manage the text-area widget, and then thrash the sizes. */
1864 XtManageChild (x
->edit_widget
);
1865 lw_refigure_widget (x
->column_widget
, True
);
1867 /* Force the pane widget to resize itself with the right values. */
1868 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1874 /* Set the contents of the menubar widgets of frame F.
1875 The argument FIRST_TIME is currently ignored;
1876 it is set the first time this is called, from initialize_frame_menubar. */
1879 set_frame_menubar (f
, first_time
, deep_p
)
1884 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1885 #ifdef USE_X_TOOLKIT
1889 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1891 int *submenu_start
, *submenu_end
;
1892 int *submenu_top_level_items
, *submenu_n_panes
;
1895 XSETFRAME (Vmenu_updating_frame
, f
);
1897 #ifdef USE_X_TOOLKIT
1898 if (f
->output_data
.x
->id
== 0)
1899 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1900 id
= f
->output_data
.x
->id
;
1903 if (! menubar_widget
)
1905 else if (pending_menu_activation
&& !deep_p
)
1907 /* Make the first call for any given frame always go deep. */
1908 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1911 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1912 f
->output_data
.x
->saved_menu_event
->type
= 0;
1916 /* If we have detached menus, we must update deep so detached menus
1917 also gets updated. */
1918 deep_p
= deep_p
|| xg_have_tear_offs ();
1923 /* Make a widget-value tree representing the entire menu trees. */
1925 struct buffer
*prev
= current_buffer
;
1927 int specpdl_count
= SPECPDL_INDEX ();
1928 int previous_menu_items_used
= f
->menu_bar_items_used
;
1929 Lisp_Object
*previous_items
1930 = (Lisp_Object
*) alloca (previous_menu_items_used
1931 * sizeof (Lisp_Object
));
1933 /* If we are making a new widget, its contents are empty,
1934 do always reinitialize them. */
1935 if (! menubar_widget
)
1936 previous_menu_items_used
= 0;
1938 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1939 specbind (Qinhibit_quit
, Qt
);
1940 /* Don't let the debugger step into this code
1941 because it is not reentrant. */
1942 specbind (Qdebug_on_next_call
, Qnil
);
1944 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1945 record_unwind_protect (unuse_menu_items
, Qnil
);
1946 if (NILP (Voverriding_local_map_menu_flag
))
1948 specbind (Qoverriding_terminal_local_map
, Qnil
);
1949 specbind (Qoverriding_local_map
, Qnil
);
1952 set_buffer_internal_1 (XBUFFER (buffer
));
1954 /* Run the Lucid hook. */
1955 safe_run_hooks (Qactivate_menubar_hook
);
1957 /* If it has changed current-menubar from previous value,
1958 really recompute the menubar from the value. */
1959 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1960 call0 (Qrecompute_lucid_menubar
);
1961 safe_run_hooks (Qmenu_bar_update_hook
);
1962 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1964 items
= FRAME_MENU_BAR_ITEMS (f
);
1966 /* Save the frame's previous menu bar contents data. */
1967 if (previous_menu_items_used
)
1968 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1969 previous_menu_items_used
* sizeof (Lisp_Object
));
1971 /* Fill in menu_items with the current menu bar contents.
1972 This can evaluate Lisp code. */
1973 menu_items
= f
->menu_bar_vector
;
1974 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1975 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1976 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1977 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1978 submenu_top_level_items
1979 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1981 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1983 Lisp_Object key
, string
, maps
;
1987 key
= XVECTOR (items
)->contents
[i
];
1988 string
= XVECTOR (items
)->contents
[i
+ 1];
1989 maps
= XVECTOR (items
)->contents
[i
+ 2];
1993 submenu_start
[i
] = menu_items_used
;
1995 menu_items_n_panes
= 0;
1996 submenu_top_level_items
[i
]
1997 = parse_single_submenu (key
, string
, maps
);
1998 submenu_n_panes
[i
] = menu_items_n_panes
;
2000 submenu_end
[i
] = menu_items_used
;
2003 finish_menu_items ();
2005 /* Convert menu_items into widget_value trees
2006 to display the menu. This cannot evaluate Lisp code. */
2008 wv
= xmalloc_widget_value ();
2009 wv
->name
= "menubar";
2012 wv
->button_type
= BUTTON_TYPE_NONE
;
2016 for (i
= 0; i
< last_i
; i
+= 4)
2018 menu_items_n_panes
= submenu_n_panes
[i
];
2019 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2020 submenu_top_level_items
[i
]);
2024 first_wv
->contents
= wv
;
2025 /* Don't set wv->name here; GC during the loop might relocate it. */
2027 wv
->button_type
= BUTTON_TYPE_NONE
;
2031 set_buffer_internal_1 (prev
);
2032 unbind_to (specpdl_count
, Qnil
);
2034 /* If there has been no change in the Lisp-level contents
2035 of the menu bar, skip redisplaying it. Just exit. */
2037 for (i
= 0; i
< previous_menu_items_used
; i
++)
2038 if (menu_items_used
== i
2039 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2041 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2043 free_menubar_widget_value_tree (first_wv
);
2044 discard_menu_items ();
2049 /* Now GC cannot happen during the lifetime of the widget_value,
2050 so it's safe to store data from a Lisp_String. */
2051 wv
= first_wv
->contents
;
2052 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2055 string
= XVECTOR (items
)->contents
[i
+ 1];
2058 wv
->name
= (char *) SDATA (string
);
2059 update_submenu_strings (wv
->contents
);
2063 f
->menu_bar_vector
= menu_items
;
2064 f
->menu_bar_items_used
= menu_items_used
;
2065 discard_menu_items ();
2069 /* Make a widget-value tree containing
2070 just the top level menu bar strings. */
2072 wv
= xmalloc_widget_value ();
2073 wv
->name
= "menubar";
2076 wv
->button_type
= BUTTON_TYPE_NONE
;
2080 items
= FRAME_MENU_BAR_ITEMS (f
);
2081 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2085 string
= XVECTOR (items
)->contents
[i
+ 1];
2089 wv
= xmalloc_widget_value ();
2090 wv
->name
= (char *) SDATA (string
);
2093 wv
->button_type
= BUTTON_TYPE_NONE
;
2095 /* This prevents lwlib from assuming this
2096 menu item is really supposed to be empty. */
2097 /* The EMACS_INT cast avoids a warning.
2098 This value just has to be different from small integers. */
2099 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2104 first_wv
->contents
= wv
;
2108 /* Forget what we thought we knew about what is in the
2109 detailed contents of the menu bar menus.
2110 Changing the top level always destroys the contents. */
2111 f
->menu_bar_items_used
= 0;
2114 /* Create or update the menu bar widget. */
2119 xg_crazy_callback_abort
= 1;
2122 /* The fourth arg is DEEP_P, which says to consider the entire
2123 menu trees we supply, rather than just the menu bar item names. */
2124 xg_modify_menubar_widgets (menubar_widget
,
2128 G_CALLBACK (menubar_selection_callback
),
2129 G_CALLBACK (popup_deactivate_callback
),
2130 G_CALLBACK (menu_highlight_callback
));
2134 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2137 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2138 G_CALLBACK (menubar_selection_callback
),
2139 G_CALLBACK (popup_deactivate_callback
),
2140 G_CALLBACK (menu_highlight_callback
));
2142 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2146 #else /* not USE_GTK */
2149 /* Disable resizing (done for Motif!) */
2150 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2152 /* The third arg is DEEP_P, which says to consider the entire
2153 menu trees we supply, rather than just the menu bar item names. */
2154 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2156 /* Re-enable the edit widget to resize. */
2157 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2161 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2162 f
->output_data
.x
->column_widget
,
2164 popup_activate_callback
,
2165 menubar_selection_callback
,
2166 popup_deactivate_callback
,
2167 menu_highlight_callback
);
2168 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2173 = (f
->output_data
.x
->menubar_widget
2174 ? (f
->output_data
.x
->menubar_widget
->core
.height
2175 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2178 #if 0 /* Experimentally, we now get the right results
2179 for -geometry -0-0 without this. 24 Aug 96, rms. */
2181 if (FRAME_EXTERNAL_MENU_BAR (f
))
2184 XtVaGetValues (f
->output_data
.x
->column_widget
,
2185 XtNinternalBorderWidth
, &ibw
, NULL
);
2186 menubar_size
+= ibw
;
2188 #endif /* USE_LUCID */
2191 f
->output_data
.x
->menubar_height
= menubar_size
;
2193 #endif /* not USE_GTK */
2195 free_menubar_widget_value_tree (first_wv
);
2196 update_frame_menubar (f
);
2199 xg_crazy_callback_abort
= 0;
2205 /* Called from Fx_create_frame to create the initial menubar of a frame
2206 before it is mapped, so that the window is mapped with the menubar already
2207 there instead of us tacking it on later and thrashing the window after it
2211 initialize_frame_menubar (f
)
2214 /* This function is called before the first chance to redisplay
2215 the frame. It has to be, so the frame will have the right size. */
2216 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2217 set_frame_menubar (f
, 1, 1);
2221 /* Get rid of the menu bar of frame F, and free its storage.
2222 This is used when deleting a frame, and when turning off the menu bar.
2223 For GTK this function is in gtkutil.c. */
2227 free_frame_menubar (f
)
2230 Widget menubar_widget
;
2232 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2234 f
->output_data
.x
->menubar_height
= 0;
2239 /* Removing the menu bar magically changes the shell widget's x
2240 and y position of (0, 0) which, when the menu bar is turned
2241 on again, leads to pull-down menuss appearing in strange
2242 positions near the upper-left corner of the display. This
2243 happens only with some window managers like twm and ctwm,
2244 but not with other like Motif's mwm or kwm, because the
2245 latter generate ConfigureNotify events when the menu bar
2246 is switched off, which fixes the shell position. */
2247 Position x0
, y0
, x1
, y1
;
2253 if (f
->output_data
.x
->widget
)
2254 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2257 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2258 f
->output_data
.x
->menubar_widget
= NULL
;
2261 if (f
->output_data
.x
->widget
)
2263 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2264 if (x1
== 0 && y1
== 0)
2265 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2272 #endif /* not USE_GTK */
2274 #endif /* USE_X_TOOLKIT || USE_GTK */
2276 /* xmenu_show actually displays a menu using the panes and items in menu_items
2277 and returns the value selected from it.
2278 There are two versions of xmenu_show, one for Xt and one for Xlib.
2279 Both assume input is blocked by the caller. */
2281 /* F is the frame the menu is for.
2282 X and Y are the frame-relative specified position,
2283 relative to the inside upper left corner of the frame F.
2284 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2285 KEYMAPS is 1 if this menu was specified with keymaps;
2286 in that case, we return a list containing the chosen item's value
2287 and perhaps also the pane's prefix.
2288 TITLE is the specified menu title.
2289 ERROR is a place to store an error message string in case of failure.
2290 (We return nil on failure, but the value doesn't actually matter.) */
2292 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2294 /* The item selected in the popup menu. */
2295 static Lisp_Object
*volatile menu_item_selection
;
2299 /* Used when position a popup menu. See menu_position_func and
2300 create_and_show_popup_menu below. */
2301 struct next_popup_x_y
2308 /* The menu position function to use if we are not putting a popup
2309 menu where the pointer is.
2310 MENU is the menu to pop up.
2311 X and Y shall on exit contain x/y where the menu shall pop up.
2312 PUSH_IN is not documented in the GTK manual.
2313 USER_DATA is any data passed in when calling gtk_menu_popup.
2314 Here it points to a struct next_popup_x_y where the coordinates
2315 to store in *X and *Y are as well as the frame for the popup.
2317 Here only X and Y are used. */
2319 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2326 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2328 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2329 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2334 /* Check if there is room for the menu. If not, adjust x/y so that
2335 the menu is fully visible. */
2336 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2337 if (data
->x
+ req
.width
> disp_width
)
2338 *x
-= data
->x
+ req
.width
- disp_width
;
2339 if (data
->y
+ req
.height
> disp_height
)
2340 *y
-= data
->y
+ req
.height
- disp_height
;
2344 popup_selection_callback (widget
, client_data
)
2346 gpointer client_data
;
2348 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2350 if (xg_crazy_callback_abort
) return;
2351 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2354 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2356 menu_item_selection will be set to the selection. */
2358 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2360 widget_value
*first_wv
;
2367 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2368 struct next_popup_x_y popup_x_y
;
2370 xg_crazy_callback_abort
= 1;
2371 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2372 G_CALLBACK (popup_selection_callback
),
2373 G_CALLBACK (popup_deactivate_callback
),
2374 G_CALLBACK (menu_highlight_callback
));
2375 xg_crazy_callback_abort
= 0;
2377 for (i
= 0; i
< 5; i
++)
2378 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2383 /* Not invoked by a click. pop up at x/y. */
2384 pos_func
= menu_position_func
;
2386 /* Adjust coordinates to be root-window-relative. */
2387 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2388 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2395 /* Display the menu. */
2396 gtk_widget_show_all (menu
);
2397 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2399 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2400 two. show_help_echo uses this to detect popup menus. */
2401 popup_activated_flag
= 1;
2402 /* Process events that apply to the menu. */
2403 popup_widget_loop ();
2405 gtk_widget_destroy (menu
);
2407 /* Must reset this manually because the button release event is not passed
2408 to Emacs event loop. */
2409 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2412 #else /* not USE_GTK */
2414 /* We need a unique id for each widget handled by the Lucid Widget
2417 For the main windows, and popup menus, we use this counter,
2418 which we increment each time after use. This starts from 1<<16.
2420 For menu bars, we use numbers starting at 0, counted in
2421 next_menubar_widget_id. */
2422 LWLIB_ID widget_id_tick
;
2425 popup_selection_callback (widget
, id
, client_data
)
2428 XtPointer client_data
;
2430 menu_item_selection
= (Lisp_Object
*) client_data
;
2433 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2435 menu_item_selection will be set to the selection. */
2437 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2439 widget_value
*first_wv
;
2447 XButtonPressedEvent dummy
;
2451 menu_id
= widget_id_tick
++;
2452 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2453 f
->output_data
.x
->widget
, 1, 0,
2454 popup_selection_callback
,
2455 popup_deactivate_callback
,
2456 menu_highlight_callback
);
2458 dummy
.type
= ButtonPress
;
2460 dummy
.send_event
= 0;
2461 dummy
.display
= FRAME_X_DISPLAY (f
);
2462 dummy
.time
= CurrentTime
;
2463 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2464 dummy
.window
= dummy
.root
;
2465 dummy
.subwindow
= dummy
.root
;
2469 /* Adjust coordinates to be root-window-relative. */
2470 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2471 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2478 for (i
= 0; i
< 5; i
++)
2479 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2482 /* Don't allow any geometry request from the user. */
2483 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2484 XtSetValues (menu
, av
, ac
);
2486 /* Display the menu. */
2487 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2488 popup_activated_flag
= 1;
2490 /* Process events that apply to the menu. */
2491 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 0);
2493 /* fp turned off the following statement and wrote a comment
2494 that it is unnecessary--that the menu has already disappeared.
2495 Nowadays the menu disappears ok, all right, but
2496 we need to delete the widgets or multiple ones will pile up. */
2497 lw_destroy_all_widgets (menu_id
);
2500 #endif /* not USE_GTK */
2503 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2513 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2514 widget_value
**submenu_stack
2515 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2516 Lisp_Object
*subprefix_stack
2517 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2518 int submenu_depth
= 0;
2524 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2526 *error
= "Empty menu";
2530 /* Create a tree of widget_value objects
2531 representing the panes and their items. */
2532 wv
= xmalloc_widget_value ();
2536 wv
->button_type
= BUTTON_TYPE_NONE
;
2541 /* Loop over all panes and items, filling in the tree. */
2543 while (i
< menu_items_used
)
2545 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2547 submenu_stack
[submenu_depth
++] = save_wv
;
2553 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2556 save_wv
= submenu_stack
[--submenu_depth
];
2560 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2561 && submenu_depth
!= 0)
2562 i
+= MENU_ITEMS_PANE_LENGTH
;
2563 /* Ignore a nil in the item list.
2564 It's meaningful only for dialog boxes. */
2565 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2567 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2569 /* Create a new pane. */
2570 Lisp_Object pane_name
, prefix
;
2573 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2574 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2576 #ifndef HAVE_MULTILINGUAL_MENU
2577 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2579 pane_name
= ENCODE_SYSTEM (pane_name
);
2580 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2583 pane_string
= (NILP (pane_name
)
2584 ? "" : (char *) SDATA (pane_name
));
2585 /* If there is just one top-level pane, put all its items directly
2586 under the top-level menu. */
2587 if (menu_items_n_panes
== 1)
2590 /* If the pane has a meaningful name,
2591 make the pane a top-level menu item
2592 with its items as a submenu beneath it. */
2593 if (!keymaps
&& strcmp (pane_string
, ""))
2595 wv
= xmalloc_widget_value ();
2599 first_wv
->contents
= wv
;
2600 wv
->name
= pane_string
;
2601 if (keymaps
&& !NILP (prefix
))
2605 wv
->button_type
= BUTTON_TYPE_NONE
;
2610 else if (first_pane
)
2616 i
+= MENU_ITEMS_PANE_LENGTH
;
2620 /* Create a new item within current pane. */
2621 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2622 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2623 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2624 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2625 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2626 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2627 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2628 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2630 #ifndef HAVE_MULTILINGUAL_MENU
2631 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2633 item_name
= ENCODE_MENU_STRING (item_name
);
2634 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2637 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2639 descrip
= ENCODE_MENU_STRING (descrip
);
2640 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2642 #endif /* not HAVE_MULTILINGUAL_MENU */
2644 wv
= xmalloc_widget_value ();
2648 save_wv
->contents
= wv
;
2649 wv
->name
= (char *) SDATA (item_name
);
2650 if (!NILP (descrip
))
2651 wv
->key
= (char *) SDATA (descrip
);
2653 /* If this item has a null value,
2654 make the call_data null so that it won't display a box
2655 when the mouse is on it. */
2657 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2658 wv
->enabled
= !NILP (enable
);
2661 wv
->button_type
= BUTTON_TYPE_NONE
;
2662 else if (EQ (type
, QCtoggle
))
2663 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2664 else if (EQ (type
, QCradio
))
2665 wv
->button_type
= BUTTON_TYPE_RADIO
;
2669 wv
->selected
= !NILP (selected
);
2671 if (! STRINGP (help
))
2678 i
+= MENU_ITEMS_ITEM_LENGTH
;
2682 /* Deal with the title, if it is non-nil. */
2685 widget_value
*wv_title
= xmalloc_widget_value ();
2686 widget_value
*wv_sep1
= xmalloc_widget_value ();
2687 widget_value
*wv_sep2
= xmalloc_widget_value ();
2689 wv_sep2
->name
= "--";
2690 wv_sep2
->next
= first_wv
->contents
;
2691 wv_sep2
->help
= Qnil
;
2693 wv_sep1
->name
= "--";
2694 wv_sep1
->next
= wv_sep2
;
2695 wv_sep1
->help
= Qnil
;
2697 #ifndef HAVE_MULTILINGUAL_MENU
2698 if (STRING_MULTIBYTE (title
))
2699 title
= ENCODE_MENU_STRING (title
);
2702 wv_title
->name
= (char *) SDATA (title
);
2703 wv_title
->enabled
= TRUE
;
2704 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2705 wv_title
->next
= wv_sep1
;
2706 wv_title
->help
= Qnil
;
2707 first_wv
->contents
= wv_title
;
2710 /* No selection has been chosen yet. */
2711 menu_item_selection
= 0;
2713 /* Actually create and show the menu until popped down. */
2714 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2716 /* Free the widget_value objects we used to specify the contents. */
2717 free_menubar_widget_value_tree (first_wv
);
2719 /* Find the selected item, and its pane, to return
2720 the proper value. */
2721 if (menu_item_selection
!= 0)
2723 Lisp_Object prefix
, entry
;
2725 prefix
= entry
= Qnil
;
2727 while (i
< menu_items_used
)
2729 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2731 subprefix_stack
[submenu_depth
++] = prefix
;
2735 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2737 prefix
= subprefix_stack
[--submenu_depth
];
2740 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2743 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2744 i
+= MENU_ITEMS_PANE_LENGTH
;
2746 /* Ignore a nil in the item list.
2747 It's meaningful only for dialog boxes. */
2748 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2753 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2754 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2760 entry
= Fcons (entry
, Qnil
);
2762 entry
= Fcons (prefix
, entry
);
2763 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2764 if (!NILP (subprefix_stack
[j
]))
2765 entry
= Fcons (subprefix_stack
[j
], entry
);
2769 i
+= MENU_ITEMS_ITEM_LENGTH
;
2779 dialog_selection_callback (widget
, client_data
)
2781 gpointer client_data
;
2783 /* The EMACS_INT cast avoids a warning. There's no problem
2784 as long as pointers have enough bits to hold small integers. */
2785 if ((int) (EMACS_INT
) client_data
!= -1)
2786 menu_item_selection
= (Lisp_Object
*) client_data
;
2788 popup_activated_flag
= 0;
2791 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2793 menu_item_selection will be set to the selection. */
2795 create_and_show_dialog (f
, first_wv
)
2797 widget_value
*first_wv
;
2801 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2802 G_CALLBACK (dialog_selection_callback
),
2803 G_CALLBACK (popup_deactivate_callback
),
2808 /* Display the menu. */
2809 gtk_widget_show_all (menu
);
2811 /* Process events that apply to the menu. */
2812 popup_widget_loop ();
2814 gtk_widget_destroy (menu
);
2818 #else /* not USE_GTK */
2820 dialog_selection_callback (widget
, id
, client_data
)
2823 XtPointer client_data
;
2825 /* The EMACS_INT cast avoids a warning. There's no problem
2826 as long as pointers have enough bits to hold small integers. */
2827 if ((int) (EMACS_INT
) client_data
!= -1)
2828 menu_item_selection
= (Lisp_Object
*) client_data
;
2831 lw_destroy_all_widgets (id
);
2833 popup_activated_flag
= 0;
2837 /* ARG is the LWLIB ID of the dialog box, represented
2838 as a Lisp object as (HIGHPART . LOWPART). */
2841 xdialog_show_unwind (arg
)
2844 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2845 | XINT (XCDR (arg
)));
2847 lw_destroy_all_widgets (id
);
2849 popup_activated_flag
= 0;
2854 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2856 menu_item_selection will be set to the selection. */
2858 create_and_show_dialog (f
, first_wv
)
2860 widget_value
*first_wv
;
2864 dialog_id
= widget_id_tick
++;
2865 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2866 f
->output_data
.x
->widget
, 1, 0,
2867 dialog_selection_callback
, 0, 0);
2868 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2870 /* Display the dialog box. */
2871 lw_pop_up_all_widgets (dialog_id
);
2872 popup_activated_flag
= 1;
2874 /* Process events that apply to the dialog box.
2875 Also handle timers. */
2877 int count
= SPECPDL_INDEX ();
2878 int fact
= 4 * sizeof (LWLIB_ID
);
2880 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2881 record_unwind_protect (xdialog_show_unwind
,
2882 Fcons (make_number (dialog_id
>> (fact
)),
2883 make_number (dialog_id
& ~(-1 << (fact
)))));
2885 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
, 1);
2887 unbind_to (count
, Qnil
);
2891 #endif /* not USE_GTK */
2893 static char * button_names
[] = {
2894 "button1", "button2", "button3", "button4", "button5",
2895 "button6", "button7", "button8", "button9", "button10" };
2898 xdialog_show (f
, keymaps
, title
, error
)
2904 int i
, nb_buttons
=0;
2905 char dialog_name
[6];
2907 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2909 /* Number of elements seen so far, before boundary. */
2911 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2912 int boundary_seen
= 0;
2916 if (menu_items_n_panes
> 1)
2918 *error
= "Multiple panes in dialog box";
2922 /* Create a tree of widget_value objects
2923 representing the text label and buttons. */
2925 Lisp_Object pane_name
, prefix
;
2927 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2928 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2929 pane_string
= (NILP (pane_name
)
2930 ? "" : (char *) SDATA (pane_name
));
2931 prev_wv
= xmalloc_widget_value ();
2932 prev_wv
->value
= pane_string
;
2933 if (keymaps
&& !NILP (prefix
))
2935 prev_wv
->enabled
= 1;
2936 prev_wv
->name
= "message";
2937 prev_wv
->help
= Qnil
;
2940 /* Loop over all panes and items, filling in the tree. */
2941 i
= MENU_ITEMS_PANE_LENGTH
;
2942 while (i
< menu_items_used
)
2945 /* Create a new item within current pane. */
2946 Lisp_Object item_name
, enable
, descrip
;
2947 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2948 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2950 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2952 if (NILP (item_name
))
2954 free_menubar_widget_value_tree (first_wv
);
2955 *error
= "Submenu in dialog items";
2958 if (EQ (item_name
, Qquote
))
2960 /* This is the boundary between left-side elts
2961 and right-side elts. Stop incrementing right_count. */
2966 if (nb_buttons
>= 9)
2968 free_menubar_widget_value_tree (first_wv
);
2969 *error
= "Too many dialog items";
2973 wv
= xmalloc_widget_value ();
2975 wv
->name
= (char *) button_names
[nb_buttons
];
2976 if (!NILP (descrip
))
2977 wv
->key
= (char *) SDATA (descrip
);
2978 wv
->value
= (char *) SDATA (item_name
);
2979 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2980 wv
->enabled
= !NILP (enable
);
2984 if (! boundary_seen
)
2988 i
+= MENU_ITEMS_ITEM_LENGTH
;
2991 /* If the boundary was not specified,
2992 by default put half on the left and half on the right. */
2993 if (! boundary_seen
)
2994 left_count
= nb_buttons
- nb_buttons
/ 2;
2996 wv
= xmalloc_widget_value ();
2997 wv
->name
= dialog_name
;
2999 /* Dialog boxes use a really stupid name encoding
3000 which specifies how many buttons to use
3001 and how many buttons are on the right.
3002 The Q means something also. */
3003 dialog_name
[0] = 'Q';
3004 dialog_name
[1] = '0' + nb_buttons
;
3005 dialog_name
[2] = 'B';
3006 dialog_name
[3] = 'R';
3007 /* Number of buttons to put on the right. */
3008 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3010 wv
->contents
= first_wv
;
3014 /* No selection has been chosen yet. */
3015 menu_item_selection
= 0;
3017 /* Actually create and show the dialog. */
3018 create_and_show_dialog (f
, first_wv
);
3020 /* Free the widget_value objects we used to specify the contents. */
3021 free_menubar_widget_value_tree (first_wv
);
3023 /* Find the selected item, and its pane, to return
3024 the proper value. */
3025 if (menu_item_selection
!= 0)
3031 while (i
< menu_items_used
)
3035 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3038 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3039 i
+= MENU_ITEMS_PANE_LENGTH
;
3041 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3043 /* This is the boundary between left-side elts and
3050 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3051 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3055 entry
= Fcons (entry
, Qnil
);
3057 entry
= Fcons (prefix
, entry
);
3061 i
+= MENU_ITEMS_ITEM_LENGTH
;
3069 #else /* not USE_X_TOOLKIT && not USE_GTK */
3071 /* The frame of the last activated non-toolkit menu bar.
3072 Used to generate menu help events. */
3074 static struct frame
*menu_help_frame
;
3077 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3079 PANE is the pane number, and ITEM is the menu item number in
3080 the menu (currently not used).
3082 This cannot be done with generating a HELP_EVENT because
3083 XMenuActivate contains a loop that doesn't let Emacs process
3087 menu_help_callback (help_string
, pane
, item
)
3091 extern Lisp_Object Qmenu_item
;
3092 Lisp_Object
*first_item
;
3093 Lisp_Object pane_name
;
3094 Lisp_Object menu_object
;
3096 first_item
= XVECTOR (menu_items
)->contents
;
3097 if (EQ (first_item
[0], Qt
))
3098 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3099 else if (EQ (first_item
[0], Qquote
))
3100 /* This shouldn't happen, see xmenu_show. */
3101 pane_name
= empty_string
;
3103 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3105 /* (menu-item MENU-NAME PANE-NUMBER) */
3106 menu_object
= Fcons (Qmenu_item
,
3108 Fcons (make_number (pane
), Qnil
)));
3109 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3110 Qnil
, menu_object
, make_number (item
), 1);
3115 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3125 int pane
, selidx
, lpane
, status
;
3126 Lisp_Object entry
, pane_prefix
;
3128 int ulx
, uly
, width
, height
;
3129 int dispwidth
, dispheight
;
3133 unsigned int dummy_uint
;
3136 if (menu_items_n_panes
== 0)
3139 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3141 *error
= "Empty menu";
3145 /* Figure out which root window F is on. */
3146 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3147 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3148 &dummy_uint
, &dummy_uint
);
3150 /* Make the menu on that window. */
3151 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3154 *error
= "Can't create menu";
3158 #ifdef HAVE_X_WINDOWS
3159 /* Adjust coordinates to relative to the outer (window manager) window. */
3162 int win_x
= 0, win_y
= 0;
3164 /* Find the position of the outside upper-left corner of
3165 the inner window, with respect to the outer window. */
3166 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
3169 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3171 /* From-window, to-window. */
3172 f
->output_data
.x
->window_desc
,
3173 f
->output_data
.x
->parent_desc
,
3175 /* From-position, to-position. */
3176 0, 0, &win_x
, &win_y
,
3178 /* Child of window. */
3185 #endif /* HAVE_X_WINDOWS */
3187 /* Adjust coordinates to be root-window-relative. */
3191 /* Create all the necessary panes and their items. */
3193 while (i
< menu_items_used
)
3195 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3197 /* Create a new pane. */
3198 Lisp_Object pane_name
, prefix
;
3201 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3202 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3203 pane_string
= (NILP (pane_name
)
3204 ? "" : (char *) SDATA (pane_name
));
3205 if (keymaps
&& !NILP (prefix
))
3208 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3209 if (lpane
== XM_FAILURE
)
3211 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3212 *error
= "Can't create pane";
3215 i
+= MENU_ITEMS_PANE_LENGTH
;
3217 /* Find the width of the widest item in this pane. */
3220 while (j
< menu_items_used
)
3223 item
= XVECTOR (menu_items
)->contents
[j
];
3231 width
= SBYTES (item
);
3232 if (width
> maxwidth
)
3235 j
+= MENU_ITEMS_ITEM_LENGTH
;
3238 /* Ignore a nil in the item list.
3239 It's meaningful only for dialog boxes. */
3240 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3244 /* Create a new item within current pane. */
3245 Lisp_Object item_name
, enable
, descrip
, help
;
3246 unsigned char *item_data
;
3249 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3250 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3252 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3253 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3254 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3256 if (!NILP (descrip
))
3258 int gap
= maxwidth
- SBYTES (item_name
);
3261 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3262 item_name
= concat2 (item_name
, spacer
);
3263 item_name
= concat2 (item_name
, descrip
);
3264 item_data
= SDATA (item_name
);
3266 /* if alloca is fast, use that to make the space,
3267 to reduce gc needs. */
3269 = (unsigned char *) alloca (maxwidth
3270 + SBYTES (descrip
) + 1);
3271 bcopy (SDATA (item_name
), item_data
,
3272 SBYTES (item_name
));
3273 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3275 bcopy (SDATA (descrip
), item_data
+ j
,
3277 item_data
[j
+ SBYTES (descrip
)] = 0;
3281 item_data
= SDATA (item_name
);
3283 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3284 menu
, lpane
, 0, item_data
,
3285 !NILP (enable
), help_string
)
3288 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3289 *error
= "Can't add selection to menu";
3292 i
+= MENU_ITEMS_ITEM_LENGTH
;
3296 /* All set and ready to fly. */
3297 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3298 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3299 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3300 x
= min (x
, dispwidth
);
3301 y
= min (y
, dispheight
);
3304 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3305 &ulx
, &uly
, &width
, &height
);
3306 if (ulx
+width
> dispwidth
)
3308 x
-= (ulx
+ width
) - dispwidth
;
3309 ulx
= dispwidth
- width
;
3311 if (uly
+height
> dispheight
)
3313 y
-= (uly
+ height
) - dispheight
;
3314 uly
= dispheight
- height
;
3316 if (ulx
< 0) x
-= ulx
;
3317 if (uly
< 0) y
-= uly
;
3319 XMenuSetAEQ (menu
, TRUE
);
3320 XMenuSetFreeze (menu
, TRUE
);
3323 /* Help display under X won't work because XMenuActivate contains
3324 a loop that doesn't give Emacs a chance to process it. */
3325 menu_help_frame
= f
;
3326 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3327 x
, y
, ButtonReleaseMask
, &datap
,
3328 menu_help_callback
);
3331 #ifdef HAVE_X_WINDOWS
3332 /* Assume the mouse has moved out of the X window.
3333 If it has actually moved in, we will get an EnterNotify. */
3334 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3341 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3344 /* Find the item number SELIDX in pane number PANE. */
3346 while (i
< menu_items_used
)
3348 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3352 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3354 i
+= MENU_ITEMS_PANE_LENGTH
;
3363 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3366 entry
= Fcons (entry
, Qnil
);
3367 if (!NILP (pane_prefix
))
3368 entry
= Fcons (pane_prefix
, entry
);
3374 i
+= MENU_ITEMS_ITEM_LENGTH
;
3380 *error
= "Can't activate menu";
3386 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3388 #ifdef HAVE_X_WINDOWS
3389 /* State that no mouse buttons are now held.
3390 (The oldXMenu code doesn't track this info for us.)
3391 That is not necessarily true, but the fiction leads to reasonable
3392 results, and it is a pain to ask which are actually held now. */
3393 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3399 #endif /* not USE_X_TOOLKIT */
3401 #endif /* HAVE_MENUS */
3406 staticpro (&menu_items
);
3408 menu_items_inuse
= Qnil
;
3410 Qdebug_on_next_call
= intern ("debug-on-next-call");
3411 staticpro (&Qdebug_on_next_call
);
3413 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3414 doc
: /* Frame for which we are updating a menu.
3415 The enable predicate for a menu command should check this variable. */);
3416 Vmenu_updating_frame
= Qnil
;
3418 #ifdef USE_X_TOOLKIT
3419 widget_id_tick
= (1<<16);
3420 next_menubar_widget_id
= 1;
3423 defsubr (&Sx_popup_menu
);
3425 defsubr (&Sx_popup_dialog
);
3429 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3430 (do not change this comment) */