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"
51 #include "sysselect.h"
58 /* This may include sys/types.h, and that somehow loses
59 if this is not done before the other system files. */
63 /* Load sys/types.h if not already loaded.
64 In some systems loading it twice is suicidal. */
66 #include <sys/types.h>
69 #include "dispextern.h"
72 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
73 code accepts the Emacs internal encoding. */
74 #undef HAVE_MULTILINGUAL_MENU
78 #include <X11/IntrinsicP.h>
79 #include <X11/CoreP.h>
80 #include <X11/StringDefs.h>
81 #include <X11/Shell.h>
83 #include <X11/Xaw/Paned.h>
84 #endif /* USE_LUCID */
85 #include "../lwlib/lwlib.h"
86 #else /* not USE_X_TOOLKIT */
88 #include "../oldXMenu/XMenu.h"
90 #endif /* not USE_X_TOOLKIT */
91 #endif /* HAVE_X_WINDOWS */
98 Lisp_Object Vmenu_updating_frame
;
100 Lisp_Object Qdebug_on_next_call
;
102 extern Lisp_Object Qmenu_bar
;
104 extern Lisp_Object QCtoggle
, QCradio
;
106 extern Lisp_Object Voverriding_local_map
;
107 extern Lisp_Object Voverriding_local_map_menu_flag
;
109 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
111 extern Lisp_Object Qmenu_bar_update_hook
;
114 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
115 extern XtAppContext Xt_app_con
;
117 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, char **));
118 static void popup_get_selection
P_ ((XEvent
*, struct x_display_info
*,
119 LWLIB_ID
, int, int));
121 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
124 #endif /* USE_X_TOOLKIT */
129 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
130 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, char **));
133 /* This is how to deal with multibyte text if HAVE_MULTILINGUAL_MENU
134 isn't defined. The use of HAVE_MULTILINGUAL_MENU could probably be
135 confined to an extended version of this with sections of code below
136 using it unconditionally. */
138 /* gtk just uses utf-8. */
139 # define ENCODE_MENU_STRING(str) ENCODE_UTF_8 (str)
141 /* I'm not convinced ENCODE_SYSTEM is defined correctly, or maybe
142 something else should be used here. Except under MS-Windows it
143 just converts to unibyte, but encoding with `locale-coding-system'
144 seems better -- X may actually display the result correctly, and
145 it's not necessarily equivalent to the unibyte text. -- fx */
146 # define ENCODE_MENU_STRING(str) ENCODE_SYSTEM (str)
149 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
150 Lisp_Object
, Lisp_Object
, Lisp_Object
,
151 Lisp_Object
, Lisp_Object
));
152 static int update_frame_menubar
P_ ((struct frame
*));
153 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
154 Lisp_Object
, char **));
155 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
156 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
158 static void list_of_panes
P_ ((Lisp_Object
));
159 static void list_of_items
P_ ((Lisp_Object
));
162 /* This holds a Lisp vector that holds the results of decoding
163 the keymaps or alist-of-alists that specify a menu.
165 It describes the panes and items within the panes.
167 Each pane is described by 3 elements in the vector:
168 t, the pane name, the pane's prefix key.
169 Then follow the pane's items, with 5 elements per item:
170 the item string, the enable flag, the item's value,
171 the definition, and the equivalent keyboard key's description string.
173 In some cases, multiple levels of menus may be described.
174 A single vector slot containing nil indicates the start of a submenu.
175 A single vector slot containing lambda indicates the end of a submenu.
176 The submenu follows a menu item which is the way to reach the submenu.
178 A single vector slot containing quote indicates that the
179 following items should appear on the right of a dialog box.
181 Using a Lisp vector to hold this information while we decode it
182 takes care of protecting all the data from GC. */
184 #define MENU_ITEMS_PANE_NAME 1
185 #define MENU_ITEMS_PANE_PREFIX 2
186 #define MENU_ITEMS_PANE_LENGTH 3
190 MENU_ITEMS_ITEM_NAME
= 0,
191 MENU_ITEMS_ITEM_ENABLE
,
192 MENU_ITEMS_ITEM_VALUE
,
193 MENU_ITEMS_ITEM_EQUIV_KEY
,
194 MENU_ITEMS_ITEM_DEFINITION
,
195 MENU_ITEMS_ITEM_TYPE
,
196 MENU_ITEMS_ITEM_SELECTED
,
197 MENU_ITEMS_ITEM_HELP
,
198 MENU_ITEMS_ITEM_LENGTH
201 static Lisp_Object menu_items
;
203 /* If non-nil, means that the global vars defined here are already in use.
204 Used to detect cases where we try to re-enter this non-reentrant code. */
205 static Lisp_Object menu_items_inuse
;
207 /* Number of slots currently allocated in menu_items. */
208 static int menu_items_allocated
;
210 /* This is the index in menu_items of the first empty slot. */
211 static int menu_items_used
;
213 /* The number of panes currently recorded in menu_items,
214 excluding those within submenus. */
215 static int menu_items_n_panes
;
217 /* Current depth within submenus. */
218 static int menu_items_submenu_depth
;
220 /* Flag which when set indicates a dialog or menu has been posted by
221 Xt on behalf of one of the widget sets. */
222 static int popup_activated_flag
;
224 static int next_menubar_widget_id
;
226 /* This is set nonzero after the user activates the menu bar, and set
227 to zero again after the menu bars are redisplayed by prepare_menu_bar.
228 While it is nonzero, all calls to set_frame_menubar go deep.
230 I don't understand why this is needed, but it does seem to be
231 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
233 int pending_menu_activation
;
237 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
239 static struct frame
*
240 menubar_id_to_frame (id
)
243 Lisp_Object tail
, frame
;
246 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
249 if (!GC_FRAMEP (frame
))
252 if (!FRAME_WINDOW_P (f
))
254 if (f
->output_data
.x
->id
== id
)
262 /* Initialize the menu_items structure if we haven't already done so.
263 Also mark it as currently empty. */
268 if (NILP (menu_items
))
270 menu_items_allocated
= 60;
271 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
274 if (!NILP (menu_items_inuse
))
275 error ("Trying to use a menu from within a menu-entry");
276 menu_items_inuse
= Qt
;
278 menu_items_n_panes
= 0;
279 menu_items_submenu_depth
= 0;
282 /* Call at the end of generating the data in menu_items. */
290 unuse_menu_items (dummy
)
293 return menu_items_inuse
= Qnil
;
296 /* Call when finished using the data for the current menu
300 discard_menu_items ()
302 /* Free the structure if it is especially large.
303 Otherwise, hold on to it, to save time. */
304 if (menu_items_allocated
> 200)
307 menu_items_allocated
= 0;
309 xassert (NILP (menu_items_inuse
));
312 /* Make the menu_items vector twice as large. */
318 int old_size
= menu_items_allocated
;
321 menu_items_allocated
*= 2;
322 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
323 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
324 old_size
* sizeof (Lisp_Object
));
327 /* Begin a submenu. */
330 push_submenu_start ()
332 if (menu_items_used
+ 1 > menu_items_allocated
)
335 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
336 menu_items_submenu_depth
++;
344 if (menu_items_used
+ 1 > menu_items_allocated
)
347 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
348 menu_items_submenu_depth
--;
351 /* Indicate boundary between left and right. */
354 push_left_right_boundary ()
356 if (menu_items_used
+ 1 > menu_items_allocated
)
359 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
362 /* Start a new menu pane in menu_items.
363 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
366 push_menu_pane (name
, prefix_vec
)
367 Lisp_Object name
, prefix_vec
;
369 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
372 if (menu_items_submenu_depth
== 0)
373 menu_items_n_panes
++;
374 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
375 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
376 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
379 /* Push one menu item into the current pane. NAME is the string to
380 display. ENABLE if non-nil means this item can be selected. KEY
381 is the key generated by choosing this item, or nil if this item
382 doesn't really have a definition. DEF is the definition of this
383 item. EQUIV is the textual description of the keyboard equivalent
384 for this item (or nil if none). TYPE is the type of this menu
385 item, one of nil, `toggle' or `radio'. */
388 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
389 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
391 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
394 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
395 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
396 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
397 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
398 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
399 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
400 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
401 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
404 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
405 and generate menu panes for them in menu_items.
406 If NOTREAL is nonzero,
407 don't bother really computing whether an item is enabled. */
410 keymap_panes (keymaps
, nmaps
, notreal
)
411 Lisp_Object
*keymaps
;
419 /* Loop over the given keymaps, making a pane for each map.
420 But don't make a pane that is empty--ignore that map instead.
421 P is the number of panes we have made so far. */
422 for (mapno
= 0; mapno
< nmaps
; mapno
++)
423 single_keymap_panes (keymaps
[mapno
],
424 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
426 finish_menu_items ();
429 /* Args passed between single_keymap_panes and single_menu_item. */
432 Lisp_Object pending_maps
;
433 int maxdepth
, notreal
;
437 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
440 /* This is a recursive subroutine of keymap_panes.
441 It handles one keymap, KEYMAP.
442 The other arguments are passed along
443 or point to local variables of the previous function.
444 If NOTREAL is nonzero, only check for equivalent key bindings, don't
445 evaluate expressions in menu items and don't make any menu.
447 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
450 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
452 Lisp_Object pane_name
;
460 skp
.pending_maps
= Qnil
;
461 skp
.maxdepth
= maxdepth
;
462 skp
.notreal
= notreal
;
468 push_menu_pane (pane_name
, prefix
);
471 /* Remember index for first item in this pane so we can go back and
472 add a prefix when (if) we see the first button. After that, notbuttons
473 is set to 0, to mark that we have seen a button and all non button
474 items need a prefix. */
475 skp
.notbuttons
= menu_items_used
;
478 GCPRO1 (skp
.pending_maps
);
479 map_keymap (keymap
, single_menu_item
, Qnil
, &skp
, 1);
482 /* Process now any submenus which want to be panes at this level. */
483 while (CONSP (skp
.pending_maps
))
485 Lisp_Object elt
, eltcdr
, string
;
486 elt
= XCAR (skp
.pending_maps
);
488 string
= XCAR (eltcdr
);
489 /* We no longer discard the @ from the beginning of the string here.
490 Instead, we do this in xmenu_show. */
491 single_keymap_panes (Fcar (elt
), string
,
492 XCDR (eltcdr
), notreal
, maxdepth
- 1);
493 skp
.pending_maps
= XCDR (skp
.pending_maps
);
497 /* This is a subroutine of single_keymap_panes that handles one
499 KEY is a key in a keymap and ITEM is its binding.
500 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
502 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
503 evaluate expressions in menu items and don't make any menu.
504 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
505 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
506 buttons. It keeps track of if we have seen a button in this menu or
510 single_menu_item (key
, item
, dummy
, skp_v
)
511 Lisp_Object key
, item
, dummy
;
514 Lisp_Object map
, item_string
, enabled
;
515 struct gcpro gcpro1
, gcpro2
;
517 struct skp
*skp
= skp_v
;
519 /* Parse the menu item and leave the result in item_properties. */
521 res
= parse_menu_item (item
, skp
->notreal
, 0);
524 return; /* Not a menu item. */
526 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
530 /* We don't want to make a menu, just traverse the keymaps to
531 precompute equivalent key bindings. */
533 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
537 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
538 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
540 if (!NILP (map
) && SREF (item_string
, 0) == '@')
543 /* An enabled separate pane. Remember this to handle it later. */
544 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
550 /* Simulate radio buttons and toggle boxes by putting a prefix in
553 Lisp_Object prefix
= Qnil
;
554 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
558 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
561 /* The first button. Line up previous items in this menu. */
563 int index
= skp
->notbuttons
; /* Index for first item this menu. */
566 while (index
< menu_items_used
)
569 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
573 submenu
++; /* Skip sub menu. */
575 else if (EQ (tem
, Qlambda
))
578 submenu
--; /* End sub menu. */
580 else if (EQ (tem
, Qt
))
581 index
+= 3; /* Skip new pane marker. */
582 else if (EQ (tem
, Qquote
))
583 index
++; /* Skip a left, right divider. */
586 if (!submenu
&& SREF (tem
, 0) != '\0'
587 && SREF (tem
, 0) != '-')
588 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
589 = concat2 (build_string (" "), tem
);
590 index
+= MENU_ITEMS_ITEM_LENGTH
;
596 /* Calculate prefix, if any, for this item. */
597 if (EQ (type
, QCtoggle
))
598 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
599 else if (EQ (type
, QCradio
))
600 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
602 /* Not a button. If we have earlier buttons, then we need a prefix. */
603 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
604 && SREF (item_string
, 0) != '-')
605 prefix
= build_string (" ");
608 item_string
= concat2 (prefix
, item_string
);
610 #endif /* not HAVE_BOXES */
612 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
614 /* Indicate visually that this is a submenu. */
615 item_string
= concat2 (item_string
, build_string (" >"));
618 push_menu_item (item_string
, enabled
, key
,
619 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
620 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
621 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
622 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
623 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
625 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
626 /* Display a submenu using the toolkit. */
627 if (! (NILP (map
) || NILP (enabled
)))
629 push_submenu_start ();
630 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
636 /* Push all the panes and items of a menu described by the
637 alist-of-alists MENU.
638 This handles old-fashioned calls to x-popup-menu. */
648 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
650 Lisp_Object elt
, pane_name
, pane_data
;
652 pane_name
= Fcar (elt
);
653 CHECK_STRING (pane_name
);
654 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
655 pane_data
= Fcdr (elt
);
656 CHECK_CONS (pane_data
);
657 list_of_items (pane_data
);
660 finish_menu_items ();
663 /* Push the items in a single pane defined by the alist PANE. */
669 Lisp_Object tail
, item
, item1
;
671 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
675 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
676 Qnil
, Qnil
, Qnil
, Qnil
);
677 else if (NILP (item
))
678 push_left_right_boundary ();
683 CHECK_STRING (item1
);
684 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, Fcdr (item
),
685 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
690 #ifdef HAVE_X_WINDOWS
691 /* Return the mouse position in *X and *Y. The coordinates are window
692 relative for the edit window in frame F.
693 This is for Fx_popup_menu. The mouse_position_hook can not
694 be used for X, as it returns window relative coordinates
695 for the window where the mouse is in. This could be the menu bar,
696 the scroll bar or the edit window. Fx_popup_menu needs to be
697 sure it is the edit window. */
699 mouse_position_for_popup (f
, x
, y
)
704 Window root
, dummy_window
;
709 XQueryPointer (FRAME_X_DISPLAY (f
),
710 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
712 /* The root window which contains the pointer. */
715 /* Window pointer is on, not used */
718 /* The position on that root window. */
721 /* x/y in dummy_window coordinates, not used. */
724 /* Modifier keys and pointer buttons, about which
726 (unsigned int *) &dummy
);
730 /* xmenu_show expects window coordinates, not root window
731 coordinates. Translate. */
732 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
733 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
736 #endif /* HAVE_X_WINDOWS */
738 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
739 doc
: /* Pop up a deck-of-cards menu and return user's selection.
740 POSITION is a position specification. This is either a mouse button event
741 or a list ((XOFFSET YOFFSET) WINDOW)
742 where XOFFSET and YOFFSET are positions in pixels from the top left
743 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)
744 This controls the position of the center of the first line
745 in the first pane of the menu, not the top left of the menu as a whole.
746 If POSITION is t, it means to use the current mouse position.
748 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
749 The menu items come from key bindings that have a menu string as well as
750 a definition; actually, the "definition" in such a key binding looks like
751 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
752 the keymap as a top-level element.
754 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
755 Otherwise, REAL-DEFINITION should be a valid key binding definition.
757 You can also use a list of keymaps as MENU.
758 Then each keymap makes a separate pane.
759 When MENU is a keymap or a list of keymaps, the return value
762 Alternatively, you can specify a menu of multiple panes
763 with a list of the form (TITLE PANE1 PANE2...),
764 where each pane is a list of form (TITLE ITEM1 ITEM2...).
765 Each ITEM is normally a cons cell (STRING . VALUE);
766 but a string can appear as an item--that makes a nonselectable line
768 With this form of menu, the return value is VALUE from the chosen item.
770 If POSITION is nil, don't display the menu at all, just precalculate the
771 cached information about equivalent key sequences. */)
773 Lisp_Object position
, menu
;
775 Lisp_Object keymap
, tem
;
776 int xpos
= 0, ypos
= 0;
779 Lisp_Object selection
;
781 Lisp_Object x
, y
, window
;
784 int specpdl_count
= SPECPDL_INDEX ();
788 if (! NILP (position
))
790 int get_current_pos_p
= 0;
793 /* Decode the first argument: find the window and the coordinates. */
794 if (EQ (position
, Qt
)
795 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
796 || EQ (XCAR (position
), Qtool_bar
))))
798 get_current_pos_p
= 1;
802 tem
= Fcar (position
);
805 window
= Fcar (Fcdr (position
));
807 y
= Fcar (Fcdr (tem
));
812 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
813 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
814 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
819 /* If a click happens in an external tool bar or a detached
820 tool bar, x and y is NIL. In that case, use the current
821 mouse position. This happens for the help button in the
822 tool bar. Ideally popup-menu should pass NIL to
823 this function, but it doesn't. */
824 if (NILP (x
) && NILP (y
))
825 get_current_pos_p
= 1;
828 if (get_current_pos_p
)
830 /* Use the mouse's current position. */
831 FRAME_PTR new_f
= SELECTED_FRAME ();
832 #ifdef HAVE_X_WINDOWS
833 /* Can't use mouse_position_hook for X since it returns
834 coordinates relative to the window the mouse is in,
835 we need coordinates relative to the edit widget always. */
840 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
841 /* cur_x/y may be negative, so use make_number. */
842 x
= make_number (cur_x
);
843 y
= make_number (cur_y
);
846 #else /* not HAVE_X_WINDOWS */
847 Lisp_Object bar_window
;
848 enum scroll_bar_part part
;
851 if (mouse_position_hook
)
852 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
853 &part
, &x
, &y
, &time
);
854 #endif /* not HAVE_X_WINDOWS */
857 XSETFRAME (window
, new_f
);
860 window
= selected_window
;
869 /* Decode where to put the menu. */
877 else if (WINDOWP (window
))
879 CHECK_LIVE_WINDOW (window
);
880 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
882 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
883 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
886 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
887 but I don't want to make one now. */
888 CHECK_WINDOW (window
);
893 Vmenu_updating_frame
= Qnil
;
894 #endif /* HAVE_MENUS */
896 record_unwind_protect (unuse_menu_items
, Qnil
);
900 /* Decode the menu items from what was specified. */
902 keymap
= get_keymap (menu
, 0, 0);
905 /* We were given a keymap. Extract menu info from the keymap. */
908 /* Extract the detailed info to make one pane. */
909 keymap_panes (&menu
, 1, NILP (position
));
911 /* Search for a string appearing directly as an element of the keymap.
912 That string is the title of the menu. */
913 prompt
= Fkeymap_prompt (keymap
);
914 if (NILP (title
) && !NILP (prompt
))
917 /* Make that be the pane title of the first pane. */
918 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
919 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
923 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
925 /* We were given a list of keymaps. */
926 int nmaps
= XFASTINT (Flength (menu
));
928 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
933 /* The first keymap that has a prompt string
934 supplies the menu title. */
935 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
939 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
941 prompt
= Fkeymap_prompt (keymap
);
942 if (NILP (title
) && !NILP (prompt
))
946 /* Extract the detailed info to make one pane. */
947 keymap_panes (maps
, nmaps
, NILP (position
));
949 /* Make the title be the pane title of the first pane. */
950 if (!NILP (title
) && menu_items_n_panes
>= 0)
951 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
957 /* We were given an old-fashioned menu. */
959 CHECK_STRING (title
);
961 list_of_panes (Fcdr (menu
));
966 unbind_to (specpdl_count
, Qnil
);
970 discard_menu_items ();
976 /* Display them in a menu. */
979 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
980 keymaps
, title
, &error_name
);
983 discard_menu_items ();
986 #endif /* HAVE_MENUS */
988 if (error_name
) error (error_name
);
994 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
995 doc
: /* Pop up a dialog box and return user's selection.
996 POSITION specifies which frame to use.
997 This is normally a mouse button event or a window or frame.
998 If POSITION is t, it means to use the frame the mouse is on.
999 The dialog box appears in the middle of the specified frame.
1001 CONTENTS specifies the alternatives to display in the dialog box.
1002 It is a list of the form (TITLE ITEM1 ITEM2...).
1003 Each ITEM is a cons cell (STRING . VALUE).
1004 The return value is VALUE from the chosen item.
1006 An ITEM may also be just a string--that makes a nonselectable item.
1007 An ITEM may also be nil--that means to put all preceding items
1008 on the left of the dialog box and all following items on the right.
1009 \(By default, approximately half appear on each side.) */)
1010 (position
, contents
)
1011 Lisp_Object position
, contents
;
1018 /* Decode the first argument: find the window or frame to use. */
1019 if (EQ (position
, Qt
)
1020 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1021 || EQ (XCAR (position
), Qtool_bar
))))
1023 #if 0 /* Using the frame the mouse is on may not be right. */
1024 /* Use the mouse's current position. */
1025 FRAME_PTR new_f
= SELECTED_FRAME ();
1026 Lisp_Object bar_window
;
1027 enum scroll_bar_part part
;
1031 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1034 XSETFRAME (window
, new_f
);
1036 window
= selected_window
;
1038 window
= selected_window
;
1040 else if (CONSP (position
))
1043 tem
= Fcar (position
);
1045 window
= Fcar (Fcdr (position
));
1048 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1049 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1052 else if (WINDOWP (position
) || FRAMEP (position
))
1057 /* Decode where to put the menu. */
1059 if (FRAMEP (window
))
1060 f
= XFRAME (window
);
1061 else if (WINDOWP (window
))
1063 CHECK_LIVE_WINDOW (window
);
1064 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1067 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1068 but I don't want to make one now. */
1069 CHECK_WINDOW (window
);
1071 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1072 /* Display a menu with these alternatives
1073 in the middle of frame F. */
1075 Lisp_Object x
, y
, frame
, newpos
;
1076 XSETFRAME (frame
, f
);
1077 XSETINT (x
, x_pixel_width (f
) / 2);
1078 XSETINT (y
, x_pixel_height (f
) / 2);
1079 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1081 return Fx_popup_menu (newpos
,
1082 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1088 Lisp_Object selection
;
1089 int specpdl_count
= SPECPDL_INDEX ();
1091 /* Decode the dialog items from what was specified. */
1092 title
= Fcar (contents
);
1093 CHECK_STRING (title
);
1094 record_unwind_protect (unuse_menu_items
, Qnil
);
1096 if (NILP (Fcar (Fcdr (contents
))))
1097 /* No buttons specified, add an "Ok" button so users can pop down
1098 the dialog. Also, the lesstif/motif version crashes if there are
1100 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
1102 list_of_panes (Fcons (contents
, Qnil
));
1104 /* Display them in a dialog box. */
1106 selection
= xdialog_show (f
, 0, title
, &error_name
);
1109 unbind_to (specpdl_count
, Qnil
);
1110 discard_menu_items ();
1112 if (error_name
) error (error_name
);
1121 /* Wait for an X event to arrive or for a timer to expire. */
1124 x_menu_wait_for_event (void *data
)
1126 extern EMACS_TIME timer_check
P_ ((int));
1128 /* Another way to do this is to register a timer callback, that can be
1129 done in GTK and Xt. But we have to do it like this when using only X
1130 anyway, and with callbacks we would have three variants for timer handling
1131 instead of the small ifdefs below. */
1134 #ifdef USE_X_TOOLKIT
1135 XtAppPending (Xt_app_con
)
1136 #elif defined USE_GTK
1137 ! gtk_events_pending ()
1139 ! XPending ((Display
*) data
)
1143 EMACS_TIME next_time
= timer_check (1);
1144 long secs
= EMACS_SECS (next_time
);
1145 long usecs
= EMACS_USECS (next_time
);
1146 SELECT_TYPE read_fds
;
1147 struct x_display_info
*dpyinfo
;
1150 FD_ZERO (&read_fds
);
1151 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1153 int fd
= ConnectionNumber (dpyinfo
->display
);
1154 FD_SET (fd
, &read_fds
);
1158 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1160 /* Sometimes timer_check returns -1 (no timers) even if there are
1161 timers. So do a timeout anyway. */
1162 EMACS_SET_SECS (next_time
, 1);
1163 EMACS_SET_USECS (next_time
, 0);
1166 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1169 #endif /* ! MSDOS */
1172 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1174 /* Loop in Xt until the menu pulldown or dialog popup has been
1175 popped down (deactivated). This is used for x-popup-menu
1176 and x-popup-dialog; it is not used for the menu bar.
1178 If DOWN_ON_KEYPRESS is nonzero, pop down if a key is pressed.
1180 NOTE: All calls to popup_get_selection should be protected
1181 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1183 #ifdef USE_X_TOOLKIT
1185 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
, down_on_keypress
)
1186 XEvent
*initial_event
;
1187 struct x_display_info
*dpyinfo
;
1190 int down_on_keypress
;
1194 while (popup_activated_flag
)
1198 event
= *initial_event
;
1203 if (do_timers
) x_menu_wait_for_event (0);
1204 XtAppNextEvent (Xt_app_con
, &event
);
1207 /* Make sure we don't consider buttons grabbed after menu goes.
1208 And make sure to deactivate for any ButtonRelease,
1209 even if XtDispatchEvent doesn't do that. */
1210 if (event
.type
== ButtonRelease
1211 && dpyinfo
->display
== event
.xbutton
.display
)
1213 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1214 #ifdef USE_MOTIF /* Pretending that the event came from a
1215 Btn1Down seems the only way to convince Motif to
1216 activate its callbacks; setting the XmNmenuPost
1217 isn't working. --marcus@sysc.pdx.edu. */
1218 event
.xbutton
.button
= 1;
1219 /* Motif only pops down menus when no Ctrl, Alt or Mod
1220 key is pressed and the button is released. So reset key state
1221 so Motif thinks this is the case. */
1222 event
.xbutton
.state
= 0;
1225 /* If the user presses a key that doesn't go to the menu,
1226 deactivate the menu.
1227 The user is likely to do that if we get wedged.
1228 All toolkits now pop down menus on ESC.
1229 For dialogs however, the focus may not be on the dialog, so
1230 in that case, we pop down. */
1231 else if (event
.type
== KeyPress
1233 && dpyinfo
->display
== event
.xbutton
.display
)
1235 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1236 if (!IsModifierKey (keysym
)
1237 && x_any_window_to_frame (dpyinfo
, event
.xany
.window
) != NULL
)
1238 popup_activated_flag
= 0;
1241 x_dispatch_event (&event
, event
.xany
.display
);
1245 #endif /* USE_X_TOOLKIT */
1248 /* Loop util popup_activated_flag is set to zero in a callback.
1249 Used for popup menus and dialogs. */
1251 popup_widget_loop (do_timers
)
1254 ++popup_activated_flag
;
1256 /* Process events in the Gtk event loop until done. */
1257 while (popup_activated_flag
)
1259 if (do_timers
) x_menu_wait_for_event (0);
1260 gtk_main_iteration ();
1265 /* Activate the menu bar of frame F.
1266 This is called from keyboard.c when it gets the
1267 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1269 To activate the menu bar, we use the X button-press event
1270 that was saved in saved_menu_event.
1271 That makes the toolkit do its thing.
1273 But first we recompute the menu bar contents (the whole tree).
1275 The reason for saving the button event until here, instead of
1276 passing it to the toolkit right away, is that we can safely
1277 execute Lisp code. */
1280 x_activate_menubar (f
)
1283 if (!f
->output_data
.x
->saved_menu_event
->type
)
1287 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1288 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1292 set_frame_menubar (f
, 0, 1);
1295 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1296 f
->output_data
.x
->saved_menu_event
);
1297 popup_activated_flag
= 1;
1299 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1303 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1304 pending_menu_activation
= 1;
1307 /* Ignore this if we get it a second time. */
1308 f
->output_data
.x
->saved_menu_event
->type
= 0;
1311 /* Detect if a dialog or menu has been posted. */
1316 return popup_activated_flag
;
1319 /* This callback is invoked when the user selects a menubar cascade
1320 pushbutton, but before the pulldown menu is posted. */
1324 popup_activate_callback (widget
, id
, client_data
)
1327 XtPointer client_data
;
1329 popup_activated_flag
= 1;
1333 /* This callback is invoked when a dialog or menu is finished being
1334 used and has been unposted. */
1338 popup_deactivate_callback (widget
, client_data
)
1340 gpointer client_data
;
1342 popup_activated_flag
= 0;
1346 popup_deactivate_callback (widget
, id
, client_data
)
1349 XtPointer client_data
;
1351 popup_activated_flag
= 0;
1356 /* Function that finds the frame for WIDGET and shows the HELP text
1358 F is the frame if known, or NULL if not known. */
1360 show_help_event (f
, widget
, help
)
1362 xt_or_gtk_widget widget
;
1369 XSETFRAME (frame
, f
);
1370 kbd_buffer_store_help_event (frame
, help
);
1374 #if 0 /* This code doesn't do anything useful. ++kfs */
1375 /* WIDGET is the popup menu. It's parent is the frame's
1376 widget. See which frame that is. */
1377 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1380 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1382 frame
= XCAR (tail
);
1383 if (GC_FRAMEP (frame
)
1384 && (f
= XFRAME (frame
),
1385 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1389 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1393 /* Callback called when menu items are highlighted/unhighlighted
1394 while moving the mouse over them. WIDGET is the menu bar or menu
1395 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1396 the data structure for the menu item, or null in case of
1401 menu_highlight_callback (widget
, call_data
)
1405 xg_menu_item_cb_data
*cb_data
;
1408 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1410 if (! cb_data
) return;
1412 help
= call_data
? cb_data
->help
: Qnil
;
1414 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1415 Don't show help for them, they won't appear before the
1416 popup is popped down. */
1417 if (popup_activated_flag
<= 1)
1418 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1422 menu_highlight_callback (widget
, id
, call_data
)
1430 widget_value
*wv
= (widget_value
*) call_data
;
1432 help
= wv
? wv
->help
: Qnil
;
1434 /* Determine the frame for the help event. */
1435 f
= menubar_id_to_frame (id
);
1437 show_help_event (f
, widget
, help
);
1441 /* Find the menu selection and store it in the keyboard buffer.
1442 F is the frame the menu is on.
1443 MENU_BAR_ITEMS_USED is the length of VECTOR.
1444 VECTOR is an array of menu events for the whole menu.
1447 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1449 int menu_bar_items_used
;
1453 Lisp_Object prefix
, entry
;
1454 Lisp_Object
*subprefix_stack
;
1455 int submenu_depth
= 0;
1459 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1463 while (i
< menu_bar_items_used
)
1465 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1467 subprefix_stack
[submenu_depth
++] = prefix
;
1471 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1473 prefix
= subprefix_stack
[--submenu_depth
];
1476 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1478 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1479 i
+= MENU_ITEMS_PANE_LENGTH
;
1483 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1484 /* The EMACS_INT cast avoids a warning. There's no problem
1485 as long as pointers have enough bits to hold small integers. */
1486 if ((int) (EMACS_INT
) client_data
== i
)
1489 struct input_event buf
;
1493 XSETFRAME (frame
, f
);
1494 buf
.kind
= MENU_BAR_EVENT
;
1495 buf
.frame_or_window
= frame
;
1497 kbd_buffer_store_event (&buf
);
1499 for (j
= 0; j
< submenu_depth
; j
++)
1500 if (!NILP (subprefix_stack
[j
]))
1502 buf
.kind
= MENU_BAR_EVENT
;
1503 buf
.frame_or_window
= frame
;
1504 buf
.arg
= subprefix_stack
[j
];
1505 kbd_buffer_store_event (&buf
);
1510 buf
.kind
= MENU_BAR_EVENT
;
1511 buf
.frame_or_window
= frame
;
1513 kbd_buffer_store_event (&buf
);
1516 buf
.kind
= MENU_BAR_EVENT
;
1517 buf
.frame_or_window
= frame
;
1519 kbd_buffer_store_event (&buf
);
1523 i
+= MENU_ITEMS_ITEM_LENGTH
;
1530 /* Gtk calls callbacks just because we tell it what item should be
1531 selected in a radio group. If this variable is set to a non-zero
1532 value, we are creating menus and don't want callbacks right now.
1534 static int xg_crazy_callback_abort
;
1536 /* This callback is called from the menu bar pulldown menu
1537 when the user makes a selection.
1538 Figure out what the user chose
1539 and put the appropriate events into the keyboard buffer. */
1541 menubar_selection_callback (widget
, client_data
)
1543 gpointer client_data
;
1545 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1547 if (xg_crazy_callback_abort
)
1550 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1553 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1554 cb_data
->cl_data
->menu_bar_items_used
,
1555 cb_data
->cl_data
->menu_bar_vector
,
1556 cb_data
->call_data
);
1559 #else /* not USE_GTK */
1561 /* This callback is called from the menu bar pulldown menu
1562 when the user makes a selection.
1563 Figure out what the user chose
1564 and put the appropriate events into the keyboard buffer. */
1566 menubar_selection_callback (widget
, id
, client_data
)
1569 XtPointer client_data
;
1573 f
= menubar_id_to_frame (id
);
1576 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1577 f
->menu_bar_vector
, client_data
);
1579 #endif /* not USE_GTK */
1581 /* Allocate a widget_value, blocking input. */
1584 xmalloc_widget_value ()
1586 widget_value
*value
;
1589 value
= malloc_widget_value ();
1595 /* This recursively calls free_widget_value on the tree of widgets.
1596 It must free all data that was malloc'ed for these widget_values.
1597 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1598 must be left alone. */
1601 free_menubar_widget_value_tree (wv
)
1606 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1608 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1610 free_menubar_widget_value_tree (wv
->contents
);
1611 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1615 free_menubar_widget_value_tree (wv
->next
);
1616 wv
->next
= (widget_value
*) 0xDEADBEEF;
1619 free_widget_value (wv
);
1623 /* Set up data in menu_items for a menu bar item
1624 whose event type is ITEM_KEY (with string ITEM_NAME)
1625 and whose contents come from the list of keymaps MAPS. */
1628 parse_single_submenu (item_key
, item_name
, maps
)
1629 Lisp_Object item_key
, item_name
, maps
;
1633 Lisp_Object
*mapvec
;
1635 int top_level_items
= 0;
1637 length
= Flength (maps
);
1638 len
= XINT (length
);
1640 /* Convert the list MAPS into a vector MAPVEC. */
1641 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1642 for (i
= 0; i
< len
; i
++)
1644 mapvec
[i
] = Fcar (maps
);
1648 /* Loop over the given keymaps, making a pane for each map.
1649 But don't make a pane that is empty--ignore that map instead. */
1650 for (i
= 0; i
< len
; i
++)
1652 if (!KEYMAPP (mapvec
[i
]))
1654 /* Here we have a command at top level in the menu bar
1655 as opposed to a submenu. */
1656 top_level_items
= 1;
1657 push_menu_pane (Qnil
, Qnil
);
1658 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1659 Qnil
, Qnil
, Qnil
, Qnil
);
1664 prompt
= Fkeymap_prompt (mapvec
[i
]);
1665 single_keymap_panes (mapvec
[i
],
1666 !NILP (prompt
) ? prompt
: item_name
,
1671 return top_level_items
;
1674 /* Create a tree of widget_value objects
1675 representing the panes and items
1676 in menu_items starting at index START, up to index END. */
1678 static widget_value
*
1679 digest_single_submenu (start
, end
, top_level_items
)
1680 int start
, end
, top_level_items
;
1682 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1684 int submenu_depth
= 0;
1685 widget_value
**submenu_stack
;
1688 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1689 wv
= xmalloc_widget_value ();
1693 wv
->button_type
= BUTTON_TYPE_NONE
;
1699 /* Loop over all panes and items made by the preceding call
1700 to parse_single_submenu and construct a tree of widget_value objects.
1701 Ignore the panes and items used by previous calls to
1702 digest_single_submenu, even though those are also in menu_items. */
1706 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1708 submenu_stack
[submenu_depth
++] = save_wv
;
1713 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1716 save_wv
= submenu_stack
[--submenu_depth
];
1719 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1720 && submenu_depth
!= 0)
1721 i
+= MENU_ITEMS_PANE_LENGTH
;
1722 /* Ignore a nil in the item list.
1723 It's meaningful only for dialog boxes. */
1724 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1726 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1728 /* Create a new pane. */
1729 Lisp_Object pane_name
, prefix
;
1732 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1733 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1735 #ifndef HAVE_MULTILINGUAL_MENU
1736 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1738 pane_name
= ENCODE_SYSTEM (pane_name
);
1739 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1742 pane_string
= (NILP (pane_name
)
1743 ? "" : (char *) SDATA (pane_name
));
1744 /* If there is just one top-level pane, put all its items directly
1745 under the top-level menu. */
1746 if (menu_items_n_panes
== 1)
1749 /* If the pane has a meaningful name,
1750 make the pane a top-level menu item
1751 with its items as a submenu beneath it. */
1752 if (strcmp (pane_string
, ""))
1754 wv
= xmalloc_widget_value ();
1758 first_wv
->contents
= wv
;
1759 wv
->lname
= pane_name
;
1760 /* Set value to 1 so update_submenu_strings can handle '@' */
1761 wv
->value
= (char *)1;
1763 wv
->button_type
= BUTTON_TYPE_NONE
;
1768 i
+= MENU_ITEMS_PANE_LENGTH
;
1772 /* Create a new item within current pane. */
1773 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1776 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1777 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1778 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1779 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1780 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1781 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1782 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1784 #ifndef HAVE_MULTILINGUAL_MENU
1785 if (STRING_MULTIBYTE (item_name
))
1787 item_name
= ENCODE_MENU_STRING (item_name
);
1788 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1791 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1793 descrip
= ENCODE_MENU_STRING (descrip
);
1794 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1796 #endif /* not HAVE_MULTILINGUAL_MENU */
1798 wv
= xmalloc_widget_value ();
1802 save_wv
->contents
= wv
;
1804 wv
->lname
= item_name
;
1805 if (!NILP (descrip
))
1808 /* The EMACS_INT cast avoids a warning. There's no problem
1809 as long as pointers have enough bits to hold small integers. */
1810 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1811 wv
->enabled
= !NILP (enable
);
1814 wv
->button_type
= BUTTON_TYPE_NONE
;
1815 else if (EQ (type
, QCradio
))
1816 wv
->button_type
= BUTTON_TYPE_RADIO
;
1817 else if (EQ (type
, QCtoggle
))
1818 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1822 wv
->selected
= !NILP (selected
);
1823 if (! STRINGP (help
))
1830 i
+= MENU_ITEMS_ITEM_LENGTH
;
1834 /* If we have just one "menu item"
1835 that was originally a button, return it by itself. */
1836 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1838 wv
= first_wv
->contents
;
1839 free_widget_value (first_wv
);
1846 /* Walk through the widget_value tree starting at FIRST_WV and update
1847 the char * pointers from the corresponding lisp values.
1848 We do this after building the whole tree, since GC may happen while the
1849 tree is constructed, and small strings are relocated. So we must wait
1850 until no GC can happen before storing pointers into lisp values. */
1852 update_submenu_strings (first_wv
)
1853 widget_value
*first_wv
;
1857 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1859 if (STRINGP (wv
->lname
))
1861 wv
->name
= SDATA (wv
->lname
);
1863 /* Ignore the @ that means "separate pane".
1864 This is a kludge, but this isn't worth more time. */
1865 if (wv
->value
== (char *)1)
1867 if (wv
->name
[0] == '@')
1873 if (STRINGP (wv
->lkey
))
1874 wv
->key
= SDATA (wv
->lkey
);
1877 update_submenu_strings (wv
->contents
);
1882 /* Recompute all the widgets of frame F, when the menu bar has been
1883 changed. Value is non-zero if widgets were updated. */
1886 update_frame_menubar (f
)
1890 return xg_update_frame_menubar (f
);
1892 struct x_output
*x
= f
->output_data
.x
;
1895 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1899 /* Save the size of the frame because the pane widget doesn't accept
1900 to resize itself. So force it. */
1901 columns
= FRAME_COLS (f
);
1902 rows
= FRAME_LINES (f
);
1904 /* Do the voodoo which means "I'm changing lots of things, don't try
1905 to refigure sizes until I'm done." */
1906 lw_refigure_widget (x
->column_widget
, False
);
1908 /* The order in which children are managed is the top to bottom
1909 order in which they are displayed in the paned window. First,
1910 remove the text-area widget. */
1911 XtUnmanageChild (x
->edit_widget
);
1913 /* Remove the menubar that is there now, and put up the menubar that
1915 XtManageChild (x
->menubar_widget
);
1916 XtMapWidget (x
->menubar_widget
);
1917 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1919 /* Re-manage the text-area widget, and then thrash the sizes. */
1920 XtManageChild (x
->edit_widget
);
1921 lw_refigure_widget (x
->column_widget
, True
);
1923 /* Force the pane widget to resize itself with the right values. */
1924 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1930 /* Set the contents of the menubar widgets of frame F.
1931 The argument FIRST_TIME is currently ignored;
1932 it is set the first time this is called, from initialize_frame_menubar. */
1935 set_frame_menubar (f
, first_time
, deep_p
)
1940 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1941 #ifdef USE_X_TOOLKIT
1945 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1947 int *submenu_start
, *submenu_end
;
1948 int *submenu_top_level_items
, *submenu_n_panes
;
1951 XSETFRAME (Vmenu_updating_frame
, f
);
1953 #ifdef USE_X_TOOLKIT
1954 if (f
->output_data
.x
->id
== 0)
1955 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1956 id
= f
->output_data
.x
->id
;
1959 if (! menubar_widget
)
1961 else if (pending_menu_activation
&& !deep_p
)
1963 /* Make the first call for any given frame always go deep. */
1964 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1967 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1968 f
->output_data
.x
->saved_menu_event
->type
= 0;
1972 /* If we have detached menus, we must update deep so detached menus
1973 also gets updated. */
1974 deep_p
= deep_p
|| xg_have_tear_offs ();
1979 /* Make a widget-value tree representing the entire menu trees. */
1981 struct buffer
*prev
= current_buffer
;
1983 int specpdl_count
= SPECPDL_INDEX ();
1984 int previous_menu_items_used
= f
->menu_bar_items_used
;
1985 Lisp_Object
*previous_items
1986 = (Lisp_Object
*) alloca (previous_menu_items_used
1987 * sizeof (Lisp_Object
));
1989 /* If we are making a new widget, its contents are empty,
1990 do always reinitialize them. */
1991 if (! menubar_widget
)
1992 previous_menu_items_used
= 0;
1994 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1995 specbind (Qinhibit_quit
, Qt
);
1996 /* Don't let the debugger step into this code
1997 because it is not reentrant. */
1998 specbind (Qdebug_on_next_call
, Qnil
);
2000 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
2001 record_unwind_protect (unuse_menu_items
, Qnil
);
2002 if (NILP (Voverriding_local_map_menu_flag
))
2004 specbind (Qoverriding_terminal_local_map
, Qnil
);
2005 specbind (Qoverriding_local_map
, Qnil
);
2008 set_buffer_internal_1 (XBUFFER (buffer
));
2010 /* Run the Lucid hook. */
2011 safe_run_hooks (Qactivate_menubar_hook
);
2013 /* If it has changed current-menubar from previous value,
2014 really recompute the menubar from the value. */
2015 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2016 call0 (Qrecompute_lucid_menubar
);
2017 safe_run_hooks (Qmenu_bar_update_hook
);
2018 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2020 items
= FRAME_MENU_BAR_ITEMS (f
);
2022 /* Save the frame's previous menu bar contents data. */
2023 if (previous_menu_items_used
)
2024 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2025 previous_menu_items_used
* sizeof (Lisp_Object
));
2027 /* Fill in menu_items with the current menu bar contents.
2028 This can evaluate Lisp code. */
2029 menu_items
= f
->menu_bar_vector
;
2030 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2031 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2032 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2033 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2034 submenu_top_level_items
2035 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2037 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2039 Lisp_Object key
, string
, maps
;
2043 key
= XVECTOR (items
)->contents
[i
];
2044 string
= XVECTOR (items
)->contents
[i
+ 1];
2045 maps
= XVECTOR (items
)->contents
[i
+ 2];
2049 submenu_start
[i
] = menu_items_used
;
2051 menu_items_n_panes
= 0;
2052 submenu_top_level_items
[i
]
2053 = parse_single_submenu (key
, string
, maps
);
2054 submenu_n_panes
[i
] = menu_items_n_panes
;
2056 submenu_end
[i
] = menu_items_used
;
2059 finish_menu_items ();
2061 /* Convert menu_items into widget_value trees
2062 to display the menu. This cannot evaluate Lisp code. */
2064 wv
= xmalloc_widget_value ();
2065 wv
->name
= "menubar";
2068 wv
->button_type
= BUTTON_TYPE_NONE
;
2072 for (i
= 0; i
< last_i
; i
+= 4)
2074 menu_items_n_panes
= submenu_n_panes
[i
];
2075 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2076 submenu_top_level_items
[i
]);
2080 first_wv
->contents
= wv
;
2081 /* Don't set wv->name here; GC during the loop might relocate it. */
2083 wv
->button_type
= BUTTON_TYPE_NONE
;
2087 set_buffer_internal_1 (prev
);
2088 unbind_to (specpdl_count
, Qnil
);
2090 /* If there has been no change in the Lisp-level contents
2091 of the menu bar, skip redisplaying it. Just exit. */
2093 for (i
= 0; i
< previous_menu_items_used
; i
++)
2094 if (menu_items_used
== i
2095 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2097 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2099 free_menubar_widget_value_tree (first_wv
);
2100 discard_menu_items ();
2105 /* Now GC cannot happen during the lifetime of the widget_value,
2106 so it's safe to store data from a Lisp_String. */
2107 wv
= first_wv
->contents
;
2108 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2111 string
= XVECTOR (items
)->contents
[i
+ 1];
2114 wv
->name
= (char *) SDATA (string
);
2115 update_submenu_strings (wv
->contents
);
2119 f
->menu_bar_vector
= menu_items
;
2120 f
->menu_bar_items_used
= menu_items_used
;
2121 discard_menu_items ();
2125 /* Make a widget-value tree containing
2126 just the top level menu bar strings. */
2128 wv
= xmalloc_widget_value ();
2129 wv
->name
= "menubar";
2132 wv
->button_type
= BUTTON_TYPE_NONE
;
2136 items
= FRAME_MENU_BAR_ITEMS (f
);
2137 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2141 string
= XVECTOR (items
)->contents
[i
+ 1];
2145 wv
= xmalloc_widget_value ();
2146 wv
->name
= (char *) SDATA (string
);
2149 wv
->button_type
= BUTTON_TYPE_NONE
;
2151 /* This prevents lwlib from assuming this
2152 menu item is really supposed to be empty. */
2153 /* The EMACS_INT cast avoids a warning.
2154 This value just has to be different from small integers. */
2155 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2160 first_wv
->contents
= wv
;
2164 /* Forget what we thought we knew about what is in the
2165 detailed contents of the menu bar menus.
2166 Changing the top level always destroys the contents. */
2167 f
->menu_bar_items_used
= 0;
2170 /* Create or update the menu bar widget. */
2175 xg_crazy_callback_abort
= 1;
2178 /* The fourth arg is DEEP_P, which says to consider the entire
2179 menu trees we supply, rather than just the menu bar item names. */
2180 xg_modify_menubar_widgets (menubar_widget
,
2184 G_CALLBACK (menubar_selection_callback
),
2185 G_CALLBACK (popup_deactivate_callback
),
2186 G_CALLBACK (menu_highlight_callback
));
2190 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2193 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2194 G_CALLBACK (menubar_selection_callback
),
2195 G_CALLBACK (popup_deactivate_callback
),
2196 G_CALLBACK (menu_highlight_callback
));
2198 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2202 #else /* not USE_GTK */
2205 /* Disable resizing (done for Motif!) */
2206 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2208 /* The third arg is DEEP_P, which says to consider the entire
2209 menu trees we supply, rather than just the menu bar item names. */
2210 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2212 /* Re-enable the edit widget to resize. */
2213 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2217 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2218 f
->output_data
.x
->column_widget
,
2220 popup_activate_callback
,
2221 menubar_selection_callback
,
2222 popup_deactivate_callback
,
2223 menu_highlight_callback
);
2224 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2229 = (f
->output_data
.x
->menubar_widget
2230 ? (f
->output_data
.x
->menubar_widget
->core
.height
2231 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2234 #if 0 /* Experimentally, we now get the right results
2235 for -geometry -0-0 without this. 24 Aug 96, rms. */
2237 if (FRAME_EXTERNAL_MENU_BAR (f
))
2240 XtVaGetValues (f
->output_data
.x
->column_widget
,
2241 XtNinternalBorderWidth
, &ibw
, NULL
);
2242 menubar_size
+= ibw
;
2244 #endif /* USE_LUCID */
2247 f
->output_data
.x
->menubar_height
= menubar_size
;
2249 #endif /* not USE_GTK */
2251 free_menubar_widget_value_tree (first_wv
);
2252 update_frame_menubar (f
);
2255 xg_crazy_callback_abort
= 0;
2261 /* Called from Fx_create_frame to create the initial menubar of a frame
2262 before it is mapped, so that the window is mapped with the menubar already
2263 there instead of us tacking it on later and thrashing the window after it
2267 initialize_frame_menubar (f
)
2270 /* This function is called before the first chance to redisplay
2271 the frame. It has to be, so the frame will have the right size. */
2272 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2273 set_frame_menubar (f
, 1, 1);
2277 /* Get rid of the menu bar of frame F, and free its storage.
2278 This is used when deleting a frame, and when turning off the menu bar.
2279 For GTK this function is in gtkutil.c. */
2283 free_frame_menubar (f
)
2286 Widget menubar_widget
;
2288 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2290 f
->output_data
.x
->menubar_height
= 0;
2295 /* Removing the menu bar magically changes the shell widget's x
2296 and y position of (0, 0) which, when the menu bar is turned
2297 on again, leads to pull-down menuss appearing in strange
2298 positions near the upper-left corner of the display. This
2299 happens only with some window managers like twm and ctwm,
2300 but not with other like Motif's mwm or kwm, because the
2301 latter generate ConfigureNotify events when the menu bar
2302 is switched off, which fixes the shell position. */
2303 Position x0
, y0
, x1
, y1
;
2309 if (f
->output_data
.x
->widget
)
2310 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2313 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2314 f
->output_data
.x
->menubar_widget
= NULL
;
2317 if (f
->output_data
.x
->widget
)
2319 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2320 if (x1
== 0 && y1
== 0)
2321 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2328 #endif /* not USE_GTK */
2330 #endif /* USE_X_TOOLKIT || USE_GTK */
2332 /* xmenu_show actually displays a menu using the panes and items in menu_items
2333 and returns the value selected from it.
2334 There are two versions of xmenu_show, one for Xt and one for Xlib.
2335 Both assume input is blocked by the caller. */
2337 /* F is the frame the menu is for.
2338 X and Y are the frame-relative specified position,
2339 relative to the inside upper left corner of the frame F.
2340 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2341 KEYMAPS is 1 if this menu was specified with keymaps;
2342 in that case, we return a list containing the chosen item's value
2343 and perhaps also the pane's prefix.
2344 TITLE is the specified menu title.
2345 ERROR is a place to store an error message string in case of failure.
2346 (We return nil on failure, but the value doesn't actually matter.) */
2348 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2350 /* The item selected in the popup menu. */
2351 static Lisp_Object
*volatile menu_item_selection
;
2355 /* Used when position a popup menu. See menu_position_func and
2356 create_and_show_popup_menu below. */
2357 struct next_popup_x_y
2364 /* The menu position function to use if we are not putting a popup
2365 menu where the pointer is.
2366 MENU is the menu to pop up.
2367 X and Y shall on exit contain x/y where the menu shall pop up.
2368 PUSH_IN is not documented in the GTK manual.
2369 USER_DATA is any data passed in when calling gtk_menu_popup.
2370 Here it points to a struct next_popup_x_y where the coordinates
2371 to store in *X and *Y are as well as the frame for the popup.
2373 Here only X and Y are used. */
2375 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2382 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2384 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2385 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2390 /* Check if there is room for the menu. If not, adjust x/y so that
2391 the menu is fully visible. */
2392 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2393 if (data
->x
+ req
.width
> disp_width
)
2394 *x
-= data
->x
+ req
.width
- disp_width
;
2395 if (data
->y
+ req
.height
> disp_height
)
2396 *y
-= data
->y
+ req
.height
- disp_height
;
2400 popup_selection_callback (widget
, client_data
)
2402 gpointer client_data
;
2404 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2406 if (xg_crazy_callback_abort
) return;
2407 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2410 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2412 menu_item_selection will be set to the selection. */
2414 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2416 widget_value
*first_wv
;
2423 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2424 struct next_popup_x_y popup_x_y
;
2426 xg_crazy_callback_abort
= 1;
2427 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2428 G_CALLBACK (popup_selection_callback
),
2429 G_CALLBACK (popup_deactivate_callback
),
2430 G_CALLBACK (menu_highlight_callback
));
2431 xg_crazy_callback_abort
= 0;
2433 for (i
= 0; i
< 5; i
++)
2434 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2439 /* Not invoked by a click. pop up at x/y. */
2440 pos_func
= menu_position_func
;
2442 /* Adjust coordinates to be root-window-relative. */
2443 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2444 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2451 /* Display the menu. */
2452 gtk_widget_show_all (menu
);
2453 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2455 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2456 two. show_help_echo uses this to detect popup menus. */
2457 popup_activated_flag
= 1;
2458 /* Process events that apply to the menu. */
2459 popup_widget_loop (0);
2461 gtk_widget_destroy (menu
);
2463 /* Must reset this manually because the button release event is not passed
2464 to Emacs event loop. */
2465 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2468 #else /* not USE_GTK */
2470 /* We need a unique id for each widget handled by the Lucid Widget
2473 For the main windows, and popup menus, we use this counter,
2474 which we increment each time after use. This starts from 1<<16.
2476 For menu bars, we use numbers starting at 0, counted in
2477 next_menubar_widget_id. */
2478 LWLIB_ID widget_id_tick
;
2481 popup_selection_callback (widget
, id
, client_data
)
2484 XtPointer client_data
;
2486 menu_item_selection
= (Lisp_Object
*) client_data
;
2489 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2491 menu_item_selection will be set to the selection. */
2493 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2495 widget_value
*first_wv
;
2503 XButtonPressedEvent dummy
;
2507 menu_id
= widget_id_tick
++;
2508 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2509 f
->output_data
.x
->widget
, 1, 0,
2510 popup_selection_callback
,
2511 popup_deactivate_callback
,
2512 menu_highlight_callback
);
2514 dummy
.type
= ButtonPress
;
2516 dummy
.send_event
= 0;
2517 dummy
.display
= FRAME_X_DISPLAY (f
);
2518 dummy
.time
= CurrentTime
;
2519 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2520 dummy
.window
= dummy
.root
;
2521 dummy
.subwindow
= dummy
.root
;
2525 /* Adjust coordinates to be root-window-relative. */
2526 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2527 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2534 for (i
= 0; i
< 5; i
++)
2535 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2538 /* Don't allow any geometry request from the user. */
2539 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2540 XtSetValues (menu
, av
, ac
);
2542 /* Display the menu. */
2543 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2544 popup_activated_flag
= 1;
2546 /* Process events that apply to the menu. */
2547 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 0, 0);
2549 /* fp turned off the following statement and wrote a comment
2550 that it is unnecessary--that the menu has already disappeared.
2551 Nowadays the menu disappears ok, all right, but
2552 we need to delete the widgets or multiple ones will pile up. */
2553 lw_destroy_all_widgets (menu_id
);
2556 #endif /* not USE_GTK */
2559 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2569 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2570 widget_value
**submenu_stack
2571 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2572 Lisp_Object
*subprefix_stack
2573 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2574 int submenu_depth
= 0;
2580 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2582 *error
= "Empty menu";
2586 /* Create a tree of widget_value objects
2587 representing the panes and their items. */
2588 wv
= xmalloc_widget_value ();
2592 wv
->button_type
= BUTTON_TYPE_NONE
;
2597 /* Loop over all panes and items, filling in the tree. */
2599 while (i
< menu_items_used
)
2601 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2603 submenu_stack
[submenu_depth
++] = save_wv
;
2609 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2612 save_wv
= submenu_stack
[--submenu_depth
];
2616 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2617 && submenu_depth
!= 0)
2618 i
+= MENU_ITEMS_PANE_LENGTH
;
2619 /* Ignore a nil in the item list.
2620 It's meaningful only for dialog boxes. */
2621 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2623 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2625 /* Create a new pane. */
2626 Lisp_Object pane_name
, prefix
;
2629 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2630 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2632 #ifndef HAVE_MULTILINGUAL_MENU
2633 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2635 pane_name
= ENCODE_SYSTEM (pane_name
);
2636 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2639 pane_string
= (NILP (pane_name
)
2640 ? "" : (char *) SDATA (pane_name
));
2641 /* If there is just one top-level pane, put all its items directly
2642 under the top-level menu. */
2643 if (menu_items_n_panes
== 1)
2646 /* If the pane has a meaningful name,
2647 make the pane a top-level menu item
2648 with its items as a submenu beneath it. */
2649 if (!keymaps
&& strcmp (pane_string
, ""))
2651 wv
= xmalloc_widget_value ();
2655 first_wv
->contents
= wv
;
2656 wv
->name
= pane_string
;
2657 if (keymaps
&& !NILP (prefix
))
2661 wv
->button_type
= BUTTON_TYPE_NONE
;
2666 else if (first_pane
)
2672 i
+= MENU_ITEMS_PANE_LENGTH
;
2676 /* Create a new item within current pane. */
2677 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2678 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2679 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2680 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2681 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2682 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2683 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2684 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2686 #ifndef HAVE_MULTILINGUAL_MENU
2687 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2689 item_name
= ENCODE_MENU_STRING (item_name
);
2690 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2693 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2695 descrip
= ENCODE_MENU_STRING (descrip
);
2696 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2698 #endif /* not HAVE_MULTILINGUAL_MENU */
2700 wv
= xmalloc_widget_value ();
2704 save_wv
->contents
= wv
;
2705 wv
->name
= (char *) SDATA (item_name
);
2706 if (!NILP (descrip
))
2707 wv
->key
= (char *) SDATA (descrip
);
2709 /* If this item has a null value,
2710 make the call_data null so that it won't display a box
2711 when the mouse is on it. */
2713 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2714 wv
->enabled
= !NILP (enable
);
2717 wv
->button_type
= BUTTON_TYPE_NONE
;
2718 else if (EQ (type
, QCtoggle
))
2719 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2720 else if (EQ (type
, QCradio
))
2721 wv
->button_type
= BUTTON_TYPE_RADIO
;
2725 wv
->selected
= !NILP (selected
);
2727 if (! STRINGP (help
))
2734 i
+= MENU_ITEMS_ITEM_LENGTH
;
2738 /* Deal with the title, if it is non-nil. */
2741 widget_value
*wv_title
= xmalloc_widget_value ();
2742 widget_value
*wv_sep1
= xmalloc_widget_value ();
2743 widget_value
*wv_sep2
= xmalloc_widget_value ();
2745 wv_sep2
->name
= "--";
2746 wv_sep2
->next
= first_wv
->contents
;
2747 wv_sep2
->help
= Qnil
;
2749 wv_sep1
->name
= "--";
2750 wv_sep1
->next
= wv_sep2
;
2751 wv_sep1
->help
= Qnil
;
2753 #ifndef HAVE_MULTILINGUAL_MENU
2754 if (STRING_MULTIBYTE (title
))
2755 title
= ENCODE_MENU_STRING (title
);
2758 wv_title
->name
= (char *) SDATA (title
);
2759 wv_title
->enabled
= TRUE
;
2760 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2761 wv_title
->next
= wv_sep1
;
2762 wv_title
->help
= Qnil
;
2763 first_wv
->contents
= wv_title
;
2766 /* No selection has been chosen yet. */
2767 menu_item_selection
= 0;
2769 /* Actually create and show the menu until popped down. */
2770 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2772 /* Free the widget_value objects we used to specify the contents. */
2773 free_menubar_widget_value_tree (first_wv
);
2775 /* Find the selected item, and its pane, to return
2776 the proper value. */
2777 if (menu_item_selection
!= 0)
2779 Lisp_Object prefix
, entry
;
2781 prefix
= entry
= Qnil
;
2783 while (i
< menu_items_used
)
2785 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2787 subprefix_stack
[submenu_depth
++] = prefix
;
2791 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2793 prefix
= subprefix_stack
[--submenu_depth
];
2796 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2799 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2800 i
+= MENU_ITEMS_PANE_LENGTH
;
2802 /* Ignore a nil in the item list.
2803 It's meaningful only for dialog boxes. */
2804 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2809 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2810 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2816 entry
= Fcons (entry
, Qnil
);
2818 entry
= Fcons (prefix
, entry
);
2819 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2820 if (!NILP (subprefix_stack
[j
]))
2821 entry
= Fcons (subprefix_stack
[j
], entry
);
2825 i
+= MENU_ITEMS_ITEM_LENGTH
;
2835 dialog_selection_callback (widget
, client_data
)
2837 gpointer client_data
;
2839 /* The EMACS_INT cast avoids a warning. There's no problem
2840 as long as pointers have enough bits to hold small integers. */
2841 if ((int) (EMACS_INT
) client_data
!= -1)
2842 menu_item_selection
= (Lisp_Object
*) client_data
;
2844 popup_activated_flag
= 0;
2847 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2849 menu_item_selection will be set to the selection. */
2851 create_and_show_dialog (f
, first_wv
)
2853 widget_value
*first_wv
;
2857 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2858 G_CALLBACK (dialog_selection_callback
),
2859 G_CALLBACK (popup_deactivate_callback
),
2864 /* Display the menu. */
2865 gtk_widget_show_all (menu
);
2867 /* Process events that apply to the menu. */
2868 popup_widget_loop (1);
2870 gtk_widget_destroy (menu
);
2874 #else /* not USE_GTK */
2876 dialog_selection_callback (widget
, id
, client_data
)
2879 XtPointer client_data
;
2881 /* The EMACS_INT cast avoids a warning. There's no problem
2882 as long as pointers have enough bits to hold small integers. */
2883 if ((int) (EMACS_INT
) client_data
!= -1)
2884 menu_item_selection
= (Lisp_Object
*) client_data
;
2887 lw_destroy_all_widgets (id
);
2889 popup_activated_flag
= 0;
2893 /* ARG is the LWLIB ID of the dialog box, represented
2894 as a Lisp object as (HIGHPART . LOWPART). */
2897 xdialog_show_unwind (arg
)
2900 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2901 | XINT (XCDR (arg
)));
2903 lw_destroy_all_widgets (id
);
2905 popup_activated_flag
= 0;
2910 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2912 menu_item_selection will be set to the selection. */
2914 create_and_show_dialog (f
, first_wv
)
2916 widget_value
*first_wv
;
2920 dialog_id
= widget_id_tick
++;
2921 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2922 f
->output_data
.x
->widget
, 1, 0,
2923 dialog_selection_callback
, 0, 0);
2924 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2926 /* Display the dialog box. */
2927 lw_pop_up_all_widgets (dialog_id
);
2928 popup_activated_flag
= 1;
2930 /* Process events that apply to the dialog box.
2931 Also handle timers. */
2933 int count
= SPECPDL_INDEX ();
2934 int fact
= 4 * sizeof (LWLIB_ID
);
2936 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2937 record_unwind_protect (xdialog_show_unwind
,
2938 Fcons (make_number (dialog_id
>> (fact
)),
2939 make_number (dialog_id
& ~(-1 << (fact
)))));
2941 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
2944 unbind_to (count
, Qnil
);
2948 #endif /* not USE_GTK */
2950 static char * button_names
[] = {
2951 "button1", "button2", "button3", "button4", "button5",
2952 "button6", "button7", "button8", "button9", "button10" };
2955 xdialog_show (f
, keymaps
, title
, error
)
2961 int i
, nb_buttons
=0;
2962 char dialog_name
[6];
2964 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2966 /* Number of elements seen so far, before boundary. */
2968 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2969 int boundary_seen
= 0;
2973 if (menu_items_n_panes
> 1)
2975 *error
= "Multiple panes in dialog box";
2979 /* Create a tree of widget_value objects
2980 representing the text label and buttons. */
2982 Lisp_Object pane_name
, prefix
;
2984 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2985 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2986 pane_string
= (NILP (pane_name
)
2987 ? "" : (char *) SDATA (pane_name
));
2988 prev_wv
= xmalloc_widget_value ();
2989 prev_wv
->value
= pane_string
;
2990 if (keymaps
&& !NILP (prefix
))
2992 prev_wv
->enabled
= 1;
2993 prev_wv
->name
= "message";
2994 prev_wv
->help
= Qnil
;
2997 /* Loop over all panes and items, filling in the tree. */
2998 i
= MENU_ITEMS_PANE_LENGTH
;
2999 while (i
< menu_items_used
)
3002 /* Create a new item within current pane. */
3003 Lisp_Object item_name
, enable
, descrip
;
3004 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3005 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3007 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3009 if (NILP (item_name
))
3011 free_menubar_widget_value_tree (first_wv
);
3012 *error
= "Submenu in dialog items";
3015 if (EQ (item_name
, Qquote
))
3017 /* This is the boundary between left-side elts
3018 and right-side elts. Stop incrementing right_count. */
3023 if (nb_buttons
>= 9)
3025 free_menubar_widget_value_tree (first_wv
);
3026 *error
= "Too many dialog items";
3030 wv
= xmalloc_widget_value ();
3032 wv
->name
= (char *) button_names
[nb_buttons
];
3033 if (!NILP (descrip
))
3034 wv
->key
= (char *) SDATA (descrip
);
3035 wv
->value
= (char *) SDATA (item_name
);
3036 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3037 wv
->enabled
= !NILP (enable
);
3041 if (! boundary_seen
)
3045 i
+= MENU_ITEMS_ITEM_LENGTH
;
3048 /* If the boundary was not specified,
3049 by default put half on the left and half on the right. */
3050 if (! boundary_seen
)
3051 left_count
= nb_buttons
- nb_buttons
/ 2;
3053 wv
= xmalloc_widget_value ();
3054 wv
->name
= dialog_name
;
3056 /* Dialog boxes use a really stupid name encoding
3057 which specifies how many buttons to use
3058 and how many buttons are on the right.
3059 The Q means something also. */
3060 dialog_name
[0] = 'Q';
3061 dialog_name
[1] = '0' + nb_buttons
;
3062 dialog_name
[2] = 'B';
3063 dialog_name
[3] = 'R';
3064 /* Number of buttons to put on the right. */
3065 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3067 wv
->contents
= first_wv
;
3071 /* No selection has been chosen yet. */
3072 menu_item_selection
= 0;
3074 /* Actually create and show the dialog. */
3075 create_and_show_dialog (f
, first_wv
);
3077 /* Free the widget_value objects we used to specify the contents. */
3078 free_menubar_widget_value_tree (first_wv
);
3080 /* Find the selected item, and its pane, to return
3081 the proper value. */
3082 if (menu_item_selection
!= 0)
3088 while (i
< menu_items_used
)
3092 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3095 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3096 i
+= MENU_ITEMS_PANE_LENGTH
;
3098 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3100 /* This is the boundary between left-side elts and
3107 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3108 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3112 entry
= Fcons (entry
, Qnil
);
3114 entry
= Fcons (prefix
, entry
);
3118 i
+= MENU_ITEMS_ITEM_LENGTH
;
3126 #else /* not USE_X_TOOLKIT && not USE_GTK */
3128 /* The frame of the last activated non-toolkit menu bar.
3129 Used to generate menu help events. */
3131 static struct frame
*menu_help_frame
;
3134 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3136 PANE is the pane number, and ITEM is the menu item number in
3137 the menu (currently not used).
3139 This cannot be done with generating a HELP_EVENT because
3140 XMenuActivate contains a loop that doesn't let Emacs process
3144 menu_help_callback (help_string
, pane
, item
)
3148 extern Lisp_Object Qmenu_item
;
3149 Lisp_Object
*first_item
;
3150 Lisp_Object pane_name
;
3151 Lisp_Object menu_object
;
3153 first_item
= XVECTOR (menu_items
)->contents
;
3154 if (EQ (first_item
[0], Qt
))
3155 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3156 else if (EQ (first_item
[0], Qquote
))
3157 /* This shouldn't happen, see xmenu_show. */
3158 pane_name
= empty_string
;
3160 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3162 /* (menu-item MENU-NAME PANE-NUMBER) */
3163 menu_object
= Fcons (Qmenu_item
,
3165 Fcons (make_number (pane
), Qnil
)));
3166 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3167 Qnil
, menu_object
, make_number (item
), 1);
3172 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3182 int pane
, selidx
, lpane
, status
;
3183 Lisp_Object entry
, pane_prefix
;
3185 int ulx
, uly
, width
, height
;
3186 int dispwidth
, dispheight
;
3190 unsigned int dummy_uint
;
3193 if (menu_items_n_panes
== 0)
3196 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3198 *error
= "Empty menu";
3202 /* Figure out which root window F is on. */
3203 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3204 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3205 &dummy_uint
, &dummy_uint
);
3207 /* Make the menu on that window. */
3208 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3211 *error
= "Can't create menu";
3215 #ifdef HAVE_X_WINDOWS
3216 /* Adjust coordinates to relative to the outer (window manager) window. */
3219 int win_x
= 0, win_y
= 0;
3221 /* Find the position of the outside upper-left corner of
3222 the inner window, with respect to the outer window. */
3223 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
3226 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3228 /* From-window, to-window. */
3229 f
->output_data
.x
->window_desc
,
3230 f
->output_data
.x
->parent_desc
,
3232 /* From-position, to-position. */
3233 0, 0, &win_x
, &win_y
,
3235 /* Child of window. */
3242 #endif /* HAVE_X_WINDOWS */
3244 /* Adjust coordinates to be root-window-relative. */
3248 /* Create all the necessary panes and their items. */
3250 while (i
< menu_items_used
)
3252 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3254 /* Create a new pane. */
3255 Lisp_Object pane_name
, prefix
;
3258 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3259 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3260 pane_string
= (NILP (pane_name
)
3261 ? "" : (char *) SDATA (pane_name
));
3262 if (keymaps
&& !NILP (prefix
))
3265 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3266 if (lpane
== XM_FAILURE
)
3268 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3269 *error
= "Can't create pane";
3272 i
+= MENU_ITEMS_PANE_LENGTH
;
3274 /* Find the width of the widest item in this pane. */
3277 while (j
< menu_items_used
)
3280 item
= XVECTOR (menu_items
)->contents
[j
];
3288 width
= SBYTES (item
);
3289 if (width
> maxwidth
)
3292 j
+= MENU_ITEMS_ITEM_LENGTH
;
3295 /* Ignore a nil in the item list.
3296 It's meaningful only for dialog boxes. */
3297 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3301 /* Create a new item within current pane. */
3302 Lisp_Object item_name
, enable
, descrip
, help
;
3303 unsigned char *item_data
;
3306 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3307 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3309 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3310 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3311 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3313 if (!NILP (descrip
))
3315 int gap
= maxwidth
- SBYTES (item_name
);
3318 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3319 item_name
= concat2 (item_name
, spacer
);
3320 item_name
= concat2 (item_name
, descrip
);
3321 item_data
= SDATA (item_name
);
3323 /* if alloca is fast, use that to make the space,
3324 to reduce gc needs. */
3326 = (unsigned char *) alloca (maxwidth
3327 + SBYTES (descrip
) + 1);
3328 bcopy (SDATA (item_name
), item_data
,
3329 SBYTES (item_name
));
3330 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3332 bcopy (SDATA (descrip
), item_data
+ j
,
3334 item_data
[j
+ SBYTES (descrip
)] = 0;
3338 item_data
= SDATA (item_name
);
3340 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3341 menu
, lpane
, 0, item_data
,
3342 !NILP (enable
), help_string
)
3345 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3346 *error
= "Can't add selection to menu";
3349 i
+= MENU_ITEMS_ITEM_LENGTH
;
3353 /* All set and ready to fly. */
3354 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3355 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3356 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3357 x
= min (x
, dispwidth
);
3358 y
= min (y
, dispheight
);
3361 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3362 &ulx
, &uly
, &width
, &height
);
3363 if (ulx
+width
> dispwidth
)
3365 x
-= (ulx
+ width
) - dispwidth
;
3366 ulx
= dispwidth
- width
;
3368 if (uly
+height
> dispheight
)
3370 y
-= (uly
+ height
) - dispheight
;
3371 uly
= dispheight
- height
;
3373 if (ulx
< 0) x
-= ulx
;
3374 if (uly
< 0) y
-= uly
;
3376 XMenuSetAEQ (menu
, TRUE
);
3377 XMenuSetFreeze (menu
, TRUE
);
3381 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3384 /* Help display under X won't work because XMenuActivate contains
3385 a loop that doesn't give Emacs a chance to process it. */
3386 menu_help_frame
= f
;
3387 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3388 x
, y
, ButtonReleaseMask
, &datap
,
3389 menu_help_callback
);
3392 #ifdef HAVE_X_WINDOWS
3393 /* Assume the mouse has moved out of the X window.
3394 If it has actually moved in, we will get an EnterNotify. */
3395 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3402 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3405 /* Find the item number SELIDX in pane number PANE. */
3407 while (i
< menu_items_used
)
3409 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3413 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3415 i
+= MENU_ITEMS_PANE_LENGTH
;
3424 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3427 entry
= Fcons (entry
, Qnil
);
3428 if (!NILP (pane_prefix
))
3429 entry
= Fcons (pane_prefix
, entry
);
3435 i
+= MENU_ITEMS_ITEM_LENGTH
;
3441 *error
= "Can't activate menu";
3447 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3449 #ifdef HAVE_X_WINDOWS
3450 /* State that no mouse buttons are now held.
3451 (The oldXMenu code doesn't track this info for us.)
3452 That is not necessarily true, but the fiction leads to reasonable
3453 results, and it is a pain to ask which are actually held now. */
3454 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3460 #endif /* not USE_X_TOOLKIT */
3462 #endif /* HAVE_MENUS */
3467 staticpro (&menu_items
);
3469 menu_items_inuse
= Qnil
;
3471 Qdebug_on_next_call
= intern ("debug-on-next-call");
3472 staticpro (&Qdebug_on_next_call
);
3474 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3475 doc
: /* Frame for which we are updating a menu.
3476 The enable predicate for a menu command should check this variable. */);
3477 Vmenu_updating_frame
= Qnil
;
3479 #ifdef USE_X_TOOLKIT
3480 widget_id_tick
= (1<<16);
3481 next_menubar_widget_id
= 1;
3484 defsubr (&Sx_popup_menu
);
3486 defsubr (&Sx_popup_dialog
);
3490 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3491 (do not change this comment) */