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 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
);
1120 /* Set menu_items_inuse so no other popup menu or dialog is created. */
1123 x_menu_set_in_use (in_use
)
1126 menu_items_inuse
= in_use
? Qt
: Qnil
;
1127 popup_activated_flag
= in_use
;
1130 /* Wait for an X event to arrive or for a timer to expire. */
1133 x_menu_wait_for_event (void *data
)
1135 extern EMACS_TIME timer_check
P_ ((int));
1137 /* Another way to do this is to register a timer callback, that can be
1138 done in GTK and Xt. But we have to do it like this when using only X
1139 anyway, and with callbacks we would have three variants for timer handling
1140 instead of the small ifdefs below. */
1143 #ifdef USE_X_TOOLKIT
1144 ! XtAppPending (Xt_app_con
)
1145 #elif defined USE_GTK
1146 ! gtk_events_pending ()
1148 ! XPending ((Display
*) data
)
1152 EMACS_TIME next_time
= timer_check (1);
1153 long secs
= EMACS_SECS (next_time
);
1154 long usecs
= EMACS_USECS (next_time
);
1155 SELECT_TYPE read_fds
;
1156 struct x_display_info
*dpyinfo
;
1159 FD_ZERO (&read_fds
);
1160 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
1162 int fd
= ConnectionNumber (dpyinfo
->display
);
1163 FD_SET (fd
, &read_fds
);
1167 if (secs
< 0 || (secs
== 0 && usecs
== 0))
1169 /* Sometimes timer_check returns -1 (no timers) even if there are
1170 timers. So do a timeout anyway. */
1171 EMACS_SET_SECS (next_time
, 1);
1172 EMACS_SET_USECS (next_time
, 0);
1175 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
1178 #endif /* ! MSDOS */
1181 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1183 #ifdef USE_X_TOOLKIT
1185 /* Loop in Xt until the menu pulldown or dialog popup has been
1186 popped down (deactivated). This is used for x-popup-menu
1187 and x-popup-dialog; it is not used for the menu bar.
1189 If DOWN_ON_KEYPRESS is nonzero, pop down if a key is pressed.
1191 NOTE: All calls to popup_get_selection should be protected
1192 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1195 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
, down_on_keypress
)
1196 XEvent
*initial_event
;
1197 struct x_display_info
*dpyinfo
;
1200 int down_on_keypress
;
1204 while (popup_activated_flag
)
1208 event
= *initial_event
;
1213 if (do_timers
) x_menu_wait_for_event (0);
1214 XtAppNextEvent (Xt_app_con
, &event
);
1217 /* Make sure we don't consider buttons grabbed after menu goes.
1218 And make sure to deactivate for any ButtonRelease,
1219 even if XtDispatchEvent doesn't do that. */
1220 if (event
.type
== ButtonRelease
1221 && dpyinfo
->display
== event
.xbutton
.display
)
1223 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1224 #ifdef USE_MOTIF /* Pretending that the event came from a
1225 Btn1Down seems the only way to convince Motif to
1226 activate its callbacks; setting the XmNmenuPost
1227 isn't working. --marcus@sysc.pdx.edu. */
1228 event
.xbutton
.button
= 1;
1229 /* Motif only pops down menus when no Ctrl, Alt or Mod
1230 key is pressed and the button is released. So reset key state
1231 so Motif thinks this is the case. */
1232 event
.xbutton
.state
= 0;
1235 /* Pop down on C-g and Escape. */
1236 else if (event
.type
== KeyPress
1238 && dpyinfo
->display
== event
.xbutton
.display
)
1240 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1242 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
1243 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
1244 popup_activated_flag
= 0;
1247 x_dispatch_event (&event
, event
.xany
.display
);
1251 #endif /* USE_X_TOOLKIT */
1254 /* Loop util popup_activated_flag is set to zero in a callback.
1255 Used for popup menus and dialogs. */
1258 popup_widget_loop (do_timers
, widget
)
1262 ++popup_activated_flag
;
1264 /* Process events in the Gtk event loop until done. */
1265 while (popup_activated_flag
)
1267 if (do_timers
) x_menu_wait_for_event (0);
1268 gtk_main_iteration ();
1273 /* Activate the menu bar of frame F.
1274 This is called from keyboard.c when it gets the
1275 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1277 To activate the menu bar, we use the X button-press event
1278 that was saved in saved_menu_event.
1279 That makes the toolkit do its thing.
1281 But first we recompute the menu bar contents (the whole tree).
1283 The reason for saving the button event until here, instead of
1284 passing it to the toolkit right away, is that we can safely
1285 execute Lisp code. */
1288 x_activate_menubar (f
)
1291 if (!f
->output_data
.x
->saved_menu_event
->type
)
1295 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
1296 f
->output_data
.x
->saved_menu_event
->xany
.window
))
1300 set_frame_menubar (f
, 0, 1);
1303 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1304 f
->output_data
.x
->saved_menu_event
);
1305 popup_activated_flag
= 1;
1307 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1311 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1312 pending_menu_activation
= 1;
1315 /* Ignore this if we get it a second time. */
1316 f
->output_data
.x
->saved_menu_event
->type
= 0;
1319 /* Detect if a dialog or menu has been posted. */
1324 return popup_activated_flag
;
1327 /* This callback is invoked when the user selects a menubar cascade
1328 pushbutton, but before the pulldown menu is posted. */
1332 popup_activate_callback (widget
, id
, client_data
)
1335 XtPointer client_data
;
1337 popup_activated_flag
= 1;
1341 /* This callback is invoked when a dialog or menu is finished being
1342 used and has been unposted. */
1346 popup_deactivate_callback (widget
, client_data
)
1348 gpointer client_data
;
1350 popup_activated_flag
= 0;
1354 popup_deactivate_callback (widget
, id
, client_data
)
1357 XtPointer client_data
;
1359 popup_activated_flag
= 0;
1364 /* Function that finds the frame for WIDGET and shows the HELP text
1366 F is the frame if known, or NULL if not known. */
1368 show_help_event (f
, widget
, help
)
1370 xt_or_gtk_widget widget
;
1377 XSETFRAME (frame
, f
);
1378 kbd_buffer_store_help_event (frame
, help
);
1382 #if 0 /* This code doesn't do anything useful. ++kfs */
1383 /* WIDGET is the popup menu. It's parent is the frame's
1384 widget. See which frame that is. */
1385 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1388 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1390 frame
= XCAR (tail
);
1391 if (GC_FRAMEP (frame
)
1392 && (f
= XFRAME (frame
),
1393 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1397 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1401 /* Callback called when menu items are highlighted/unhighlighted
1402 while moving the mouse over them. WIDGET is the menu bar or menu
1403 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1404 the data structure for the menu item, or null in case of
1409 menu_highlight_callback (widget
, call_data
)
1413 xg_menu_item_cb_data
*cb_data
;
1416 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1418 if (! cb_data
) return;
1420 help
= call_data
? cb_data
->help
: Qnil
;
1422 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1423 Don't show help for them, they won't appear before the
1424 popup is popped down. */
1425 if (popup_activated_flag
<= 1)
1426 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1430 menu_highlight_callback (widget
, id
, call_data
)
1438 widget_value
*wv
= (widget_value
*) call_data
;
1440 help
= wv
? wv
->help
: Qnil
;
1442 /* Determine the frame for the help event. */
1443 f
= menubar_id_to_frame (id
);
1445 show_help_event (f
, widget
, help
);
1449 /* Find the menu selection and store it in the keyboard buffer.
1450 F is the frame the menu is on.
1451 MENU_BAR_ITEMS_USED is the length of VECTOR.
1452 VECTOR is an array of menu events for the whole menu.
1455 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1457 int menu_bar_items_used
;
1461 Lisp_Object prefix
, entry
;
1462 Lisp_Object
*subprefix_stack
;
1463 int submenu_depth
= 0;
1467 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1471 while (i
< menu_bar_items_used
)
1473 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1475 subprefix_stack
[submenu_depth
++] = prefix
;
1479 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1481 prefix
= subprefix_stack
[--submenu_depth
];
1484 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1486 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1487 i
+= MENU_ITEMS_PANE_LENGTH
;
1491 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1492 /* The EMACS_INT cast avoids a warning. There's no problem
1493 as long as pointers have enough bits to hold small integers. */
1494 if ((int) (EMACS_INT
) client_data
== i
)
1497 struct input_event buf
;
1501 XSETFRAME (frame
, f
);
1502 buf
.kind
= MENU_BAR_EVENT
;
1503 buf
.frame_or_window
= frame
;
1505 kbd_buffer_store_event (&buf
);
1507 for (j
= 0; j
< submenu_depth
; j
++)
1508 if (!NILP (subprefix_stack
[j
]))
1510 buf
.kind
= MENU_BAR_EVENT
;
1511 buf
.frame_or_window
= frame
;
1512 buf
.arg
= subprefix_stack
[j
];
1513 kbd_buffer_store_event (&buf
);
1518 buf
.kind
= MENU_BAR_EVENT
;
1519 buf
.frame_or_window
= frame
;
1521 kbd_buffer_store_event (&buf
);
1524 buf
.kind
= MENU_BAR_EVENT
;
1525 buf
.frame_or_window
= frame
;
1527 kbd_buffer_store_event (&buf
);
1531 i
+= MENU_ITEMS_ITEM_LENGTH
;
1538 /* Gtk calls callbacks just because we tell it what item should be
1539 selected in a radio group. If this variable is set to a non-zero
1540 value, we are creating menus and don't want callbacks right now.
1542 static int xg_crazy_callback_abort
;
1544 /* This callback is called from the menu bar pulldown menu
1545 when the user makes a selection.
1546 Figure out what the user chose
1547 and put the appropriate events into the keyboard buffer. */
1549 menubar_selection_callback (widget
, client_data
)
1551 gpointer client_data
;
1553 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1555 if (xg_crazy_callback_abort
)
1558 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1561 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1562 cb_data
->cl_data
->menu_bar_items_used
,
1563 cb_data
->cl_data
->menu_bar_vector
,
1564 cb_data
->call_data
);
1567 #else /* not USE_GTK */
1569 /* This callback is called from the menu bar pulldown menu
1570 when the user makes a selection.
1571 Figure out what the user chose
1572 and put the appropriate events into the keyboard buffer. */
1574 menubar_selection_callback (widget
, id
, client_data
)
1577 XtPointer client_data
;
1581 f
= menubar_id_to_frame (id
);
1584 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1585 f
->menu_bar_vector
, client_data
);
1587 #endif /* not USE_GTK */
1589 /* Allocate a widget_value, blocking input. */
1592 xmalloc_widget_value ()
1594 widget_value
*value
;
1597 value
= malloc_widget_value ();
1603 /* This recursively calls free_widget_value on the tree of widgets.
1604 It must free all data that was malloc'ed for these widget_values.
1605 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1606 must be left alone. */
1609 free_menubar_widget_value_tree (wv
)
1614 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1616 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1618 free_menubar_widget_value_tree (wv
->contents
);
1619 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1623 free_menubar_widget_value_tree (wv
->next
);
1624 wv
->next
= (widget_value
*) 0xDEADBEEF;
1627 free_widget_value (wv
);
1631 /* Set up data in menu_items for a menu bar item
1632 whose event type is ITEM_KEY (with string ITEM_NAME)
1633 and whose contents come from the list of keymaps MAPS. */
1636 parse_single_submenu (item_key
, item_name
, maps
)
1637 Lisp_Object item_key
, item_name
, maps
;
1641 Lisp_Object
*mapvec
;
1643 int top_level_items
= 0;
1645 length
= Flength (maps
);
1646 len
= XINT (length
);
1648 /* Convert the list MAPS into a vector MAPVEC. */
1649 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1650 for (i
= 0; i
< len
; i
++)
1652 mapvec
[i
] = Fcar (maps
);
1656 /* Loop over the given keymaps, making a pane for each map.
1657 But don't make a pane that is empty--ignore that map instead. */
1658 for (i
= 0; i
< len
; i
++)
1660 if (!KEYMAPP (mapvec
[i
]))
1662 /* Here we have a command at top level in the menu bar
1663 as opposed to a submenu. */
1664 top_level_items
= 1;
1665 push_menu_pane (Qnil
, Qnil
);
1666 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1667 Qnil
, Qnil
, Qnil
, Qnil
);
1672 prompt
= Fkeymap_prompt (mapvec
[i
]);
1673 single_keymap_panes (mapvec
[i
],
1674 !NILP (prompt
) ? prompt
: item_name
,
1679 return top_level_items
;
1682 /* Create a tree of widget_value objects
1683 representing the panes and items
1684 in menu_items starting at index START, up to index END. */
1686 static widget_value
*
1687 digest_single_submenu (start
, end
, top_level_items
)
1688 int start
, end
, top_level_items
;
1690 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1692 int submenu_depth
= 0;
1693 widget_value
**submenu_stack
;
1696 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1697 wv
= xmalloc_widget_value ();
1701 wv
->button_type
= BUTTON_TYPE_NONE
;
1707 /* Loop over all panes and items made by the preceding call
1708 to parse_single_submenu and construct a tree of widget_value objects.
1709 Ignore the panes and items used by previous calls to
1710 digest_single_submenu, even though those are also in menu_items. */
1714 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1716 submenu_stack
[submenu_depth
++] = save_wv
;
1721 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1724 save_wv
= submenu_stack
[--submenu_depth
];
1727 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1728 && submenu_depth
!= 0)
1729 i
+= MENU_ITEMS_PANE_LENGTH
;
1730 /* Ignore a nil in the item list.
1731 It's meaningful only for dialog boxes. */
1732 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1734 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1736 /* Create a new pane. */
1737 Lisp_Object pane_name
, prefix
;
1740 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1741 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1743 #ifndef HAVE_MULTILINGUAL_MENU
1744 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1746 pane_name
= ENCODE_SYSTEM (pane_name
);
1747 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1750 pane_string
= (NILP (pane_name
)
1751 ? "" : (char *) SDATA (pane_name
));
1752 /* If there is just one top-level pane, put all its items directly
1753 under the top-level menu. */
1754 if (menu_items_n_panes
== 1)
1757 /* If the pane has a meaningful name,
1758 make the pane a top-level menu item
1759 with its items as a submenu beneath it. */
1760 if (strcmp (pane_string
, ""))
1762 wv
= xmalloc_widget_value ();
1766 first_wv
->contents
= wv
;
1767 wv
->lname
= pane_name
;
1768 /* Set value to 1 so update_submenu_strings can handle '@' */
1769 wv
->value
= (char *)1;
1771 wv
->button_type
= BUTTON_TYPE_NONE
;
1776 i
+= MENU_ITEMS_PANE_LENGTH
;
1780 /* Create a new item within current pane. */
1781 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1784 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1785 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1786 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1787 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1788 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1789 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1790 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1792 #ifndef HAVE_MULTILINGUAL_MENU
1793 if (STRING_MULTIBYTE (item_name
))
1795 item_name
= ENCODE_MENU_STRING (item_name
);
1796 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1799 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1801 descrip
= ENCODE_MENU_STRING (descrip
);
1802 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1804 #endif /* not HAVE_MULTILINGUAL_MENU */
1806 wv
= xmalloc_widget_value ();
1810 save_wv
->contents
= wv
;
1812 wv
->lname
= item_name
;
1813 if (!NILP (descrip
))
1816 /* The EMACS_INT cast avoids a warning. There's no problem
1817 as long as pointers have enough bits to hold small integers. */
1818 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1819 wv
->enabled
= !NILP (enable
);
1822 wv
->button_type
= BUTTON_TYPE_NONE
;
1823 else if (EQ (type
, QCradio
))
1824 wv
->button_type
= BUTTON_TYPE_RADIO
;
1825 else if (EQ (type
, QCtoggle
))
1826 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1830 wv
->selected
= !NILP (selected
);
1831 if (! STRINGP (help
))
1838 i
+= MENU_ITEMS_ITEM_LENGTH
;
1842 /* If we have just one "menu item"
1843 that was originally a button, return it by itself. */
1844 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1846 wv
= first_wv
->contents
;
1847 free_widget_value (first_wv
);
1854 /* Walk through the widget_value tree starting at FIRST_WV and update
1855 the char * pointers from the corresponding lisp values.
1856 We do this after building the whole tree, since GC may happen while the
1857 tree is constructed, and small strings are relocated. So we must wait
1858 until no GC can happen before storing pointers into lisp values. */
1860 update_submenu_strings (first_wv
)
1861 widget_value
*first_wv
;
1865 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1867 if (STRINGP (wv
->lname
))
1869 wv
->name
= SDATA (wv
->lname
);
1871 /* Ignore the @ that means "separate pane".
1872 This is a kludge, but this isn't worth more time. */
1873 if (wv
->value
== (char *)1)
1875 if (wv
->name
[0] == '@')
1881 if (STRINGP (wv
->lkey
))
1882 wv
->key
= SDATA (wv
->lkey
);
1885 update_submenu_strings (wv
->contents
);
1890 /* Recompute all the widgets of frame F, when the menu bar has been
1891 changed. Value is non-zero if widgets were updated. */
1894 update_frame_menubar (f
)
1898 return xg_update_frame_menubar (f
);
1900 struct x_output
*x
= f
->output_data
.x
;
1903 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1907 /* Save the size of the frame because the pane widget doesn't accept
1908 to resize itself. So force it. */
1909 columns
= FRAME_COLS (f
);
1910 rows
= FRAME_LINES (f
);
1912 /* Do the voodoo which means "I'm changing lots of things, don't try
1913 to refigure sizes until I'm done." */
1914 lw_refigure_widget (x
->column_widget
, False
);
1916 /* The order in which children are managed is the top to bottom
1917 order in which they are displayed in the paned window. First,
1918 remove the text-area widget. */
1919 XtUnmanageChild (x
->edit_widget
);
1921 /* Remove the menubar that is there now, and put up the menubar that
1923 XtManageChild (x
->menubar_widget
);
1924 XtMapWidget (x
->menubar_widget
);
1925 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1927 /* Re-manage the text-area widget, and then thrash the sizes. */
1928 XtManageChild (x
->edit_widget
);
1929 lw_refigure_widget (x
->column_widget
, True
);
1931 /* Force the pane widget to resize itself with the right values. */
1932 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1938 /* Set the contents of the menubar widgets of frame F.
1939 The argument FIRST_TIME is currently ignored;
1940 it is set the first time this is called, from initialize_frame_menubar. */
1943 set_frame_menubar (f
, first_time
, deep_p
)
1948 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1949 #ifdef USE_X_TOOLKIT
1953 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1955 int *submenu_start
, *submenu_end
;
1956 int *submenu_top_level_items
, *submenu_n_panes
;
1959 XSETFRAME (Vmenu_updating_frame
, f
);
1961 #ifdef USE_X_TOOLKIT
1962 if (f
->output_data
.x
->id
== 0)
1963 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1964 id
= f
->output_data
.x
->id
;
1967 if (! menubar_widget
)
1969 else if (pending_menu_activation
&& !deep_p
)
1971 /* Make the first call for any given frame always go deep. */
1972 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1975 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1976 f
->output_data
.x
->saved_menu_event
->type
= 0;
1980 /* If we have detached menus, we must update deep so detached menus
1981 also gets updated. */
1982 deep_p
= deep_p
|| xg_have_tear_offs ();
1987 /* Make a widget-value tree representing the entire menu trees. */
1989 struct buffer
*prev
= current_buffer
;
1991 int specpdl_count
= SPECPDL_INDEX ();
1992 int previous_menu_items_used
= f
->menu_bar_items_used
;
1993 Lisp_Object
*previous_items
1994 = (Lisp_Object
*) alloca (previous_menu_items_used
1995 * sizeof (Lisp_Object
));
1997 /* If we are making a new widget, its contents are empty,
1998 do always reinitialize them. */
1999 if (! menubar_widget
)
2000 previous_menu_items_used
= 0;
2002 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
2003 specbind (Qinhibit_quit
, Qt
);
2004 /* Don't let the debugger step into this code
2005 because it is not reentrant. */
2006 specbind (Qdebug_on_next_call
, Qnil
);
2008 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
2009 record_unwind_protect (unuse_menu_items
, Qnil
);
2010 if (NILP (Voverriding_local_map_menu_flag
))
2012 specbind (Qoverriding_terminal_local_map
, Qnil
);
2013 specbind (Qoverriding_local_map
, Qnil
);
2016 set_buffer_internal_1 (XBUFFER (buffer
));
2018 /* Run the Lucid hook. */
2019 safe_run_hooks (Qactivate_menubar_hook
);
2021 /* If it has changed current-menubar from previous value,
2022 really recompute the menubar from the value. */
2023 if (! NILP (Vlucid_menu_bar_dirty_flag
))
2024 call0 (Qrecompute_lucid_menubar
);
2025 safe_run_hooks (Qmenu_bar_update_hook
);
2026 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2028 items
= FRAME_MENU_BAR_ITEMS (f
);
2030 /* Save the frame's previous menu bar contents data. */
2031 if (previous_menu_items_used
)
2032 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
2033 previous_menu_items_used
* sizeof (Lisp_Object
));
2035 /* Fill in menu_items with the current menu bar contents.
2036 This can evaluate Lisp code. */
2037 menu_items
= f
->menu_bar_vector
;
2038 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
2039 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2040 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2041 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
2042 submenu_top_level_items
2043 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
2045 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2047 Lisp_Object key
, string
, maps
;
2051 key
= XVECTOR (items
)->contents
[i
];
2052 string
= XVECTOR (items
)->contents
[i
+ 1];
2053 maps
= XVECTOR (items
)->contents
[i
+ 2];
2057 submenu_start
[i
] = menu_items_used
;
2059 menu_items_n_panes
= 0;
2060 submenu_top_level_items
[i
]
2061 = parse_single_submenu (key
, string
, maps
);
2062 submenu_n_panes
[i
] = menu_items_n_panes
;
2064 submenu_end
[i
] = menu_items_used
;
2067 finish_menu_items ();
2069 /* Convert menu_items into widget_value trees
2070 to display the menu. This cannot evaluate Lisp code. */
2072 wv
= xmalloc_widget_value ();
2073 wv
->name
= "menubar";
2076 wv
->button_type
= BUTTON_TYPE_NONE
;
2080 for (i
= 0; i
< last_i
; i
+= 4)
2082 menu_items_n_panes
= submenu_n_panes
[i
];
2083 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
2084 submenu_top_level_items
[i
]);
2088 first_wv
->contents
= wv
;
2089 /* Don't set wv->name here; GC during the loop might relocate it. */
2091 wv
->button_type
= BUTTON_TYPE_NONE
;
2095 set_buffer_internal_1 (prev
);
2096 unbind_to (specpdl_count
, Qnil
);
2098 /* If there has been no change in the Lisp-level contents
2099 of the menu bar, skip redisplaying it. Just exit. */
2101 for (i
= 0; i
< previous_menu_items_used
; i
++)
2102 if (menu_items_used
== i
2103 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
2105 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
2107 free_menubar_widget_value_tree (first_wv
);
2108 discard_menu_items ();
2113 /* Now GC cannot happen during the lifetime of the widget_value,
2114 so it's safe to store data from a Lisp_String. */
2115 wv
= first_wv
->contents
;
2116 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2119 string
= XVECTOR (items
)->contents
[i
+ 1];
2122 wv
->name
= (char *) SDATA (string
);
2123 update_submenu_strings (wv
->contents
);
2127 f
->menu_bar_vector
= menu_items
;
2128 f
->menu_bar_items_used
= menu_items_used
;
2129 discard_menu_items ();
2133 /* Make a widget-value tree containing
2134 just the top level menu bar strings. */
2136 wv
= xmalloc_widget_value ();
2137 wv
->name
= "menubar";
2140 wv
->button_type
= BUTTON_TYPE_NONE
;
2144 items
= FRAME_MENU_BAR_ITEMS (f
);
2145 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2149 string
= XVECTOR (items
)->contents
[i
+ 1];
2153 wv
= xmalloc_widget_value ();
2154 wv
->name
= (char *) SDATA (string
);
2157 wv
->button_type
= BUTTON_TYPE_NONE
;
2159 /* This prevents lwlib from assuming this
2160 menu item is really supposed to be empty. */
2161 /* The EMACS_INT cast avoids a warning.
2162 This value just has to be different from small integers. */
2163 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2168 first_wv
->contents
= wv
;
2172 /* Forget what we thought we knew about what is in the
2173 detailed contents of the menu bar menus.
2174 Changing the top level always destroys the contents. */
2175 f
->menu_bar_items_used
= 0;
2178 /* Create or update the menu bar widget. */
2183 xg_crazy_callback_abort
= 1;
2186 /* The fourth arg is DEEP_P, which says to consider the entire
2187 menu trees we supply, rather than just the menu bar item names. */
2188 xg_modify_menubar_widgets (menubar_widget
,
2192 G_CALLBACK (menubar_selection_callback
),
2193 G_CALLBACK (popup_deactivate_callback
),
2194 G_CALLBACK (menu_highlight_callback
));
2198 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2201 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2202 G_CALLBACK (menubar_selection_callback
),
2203 G_CALLBACK (popup_deactivate_callback
),
2204 G_CALLBACK (menu_highlight_callback
));
2206 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2210 #else /* not USE_GTK */
2213 /* Disable resizing (done for Motif!) */
2214 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2216 /* The third arg is DEEP_P, which says to consider the entire
2217 menu trees we supply, rather than just the menu bar item names. */
2218 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2220 /* Re-enable the edit widget to resize. */
2221 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2225 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
2226 XtTranslations override
= XtParseTranslationTable (menuOverride
);
2228 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2229 f
->output_data
.x
->column_widget
,
2231 popup_activate_callback
,
2232 menubar_selection_callback
,
2233 popup_deactivate_callback
,
2234 menu_highlight_callback
);
2235 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2237 /* Make menu pop down on C-g. */
2238 XtOverrideTranslations (menubar_widget
, override
);
2243 = (f
->output_data
.x
->menubar_widget
2244 ? (f
->output_data
.x
->menubar_widget
->core
.height
2245 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2248 #if 0 /* Experimentally, we now get the right results
2249 for -geometry -0-0 without this. 24 Aug 96, rms. */
2251 if (FRAME_EXTERNAL_MENU_BAR (f
))
2254 XtVaGetValues (f
->output_data
.x
->column_widget
,
2255 XtNinternalBorderWidth
, &ibw
, NULL
);
2256 menubar_size
+= ibw
;
2258 #endif /* USE_LUCID */
2261 f
->output_data
.x
->menubar_height
= menubar_size
;
2263 #endif /* not USE_GTK */
2265 free_menubar_widget_value_tree (first_wv
);
2266 update_frame_menubar (f
);
2269 xg_crazy_callback_abort
= 0;
2275 /* Called from Fx_create_frame to create the initial menubar of a frame
2276 before it is mapped, so that the window is mapped with the menubar already
2277 there instead of us tacking it on later and thrashing the window after it
2281 initialize_frame_menubar (f
)
2284 /* This function is called before the first chance to redisplay
2285 the frame. It has to be, so the frame will have the right size. */
2286 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2287 set_frame_menubar (f
, 1, 1);
2291 /* Get rid of the menu bar of frame F, and free its storage.
2292 This is used when deleting a frame, and when turning off the menu bar.
2293 For GTK this function is in gtkutil.c. */
2297 free_frame_menubar (f
)
2300 Widget menubar_widget
;
2302 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2304 f
->output_data
.x
->menubar_height
= 0;
2309 /* Removing the menu bar magically changes the shell widget's x
2310 and y position of (0, 0) which, when the menu bar is turned
2311 on again, leads to pull-down menuss appearing in strange
2312 positions near the upper-left corner of the display. This
2313 happens only with some window managers like twm and ctwm,
2314 but not with other like Motif's mwm or kwm, because the
2315 latter generate ConfigureNotify events when the menu bar
2316 is switched off, which fixes the shell position. */
2317 Position x0
, y0
, x1
, y1
;
2323 if (f
->output_data
.x
->widget
)
2324 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2327 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2328 f
->output_data
.x
->menubar_widget
= NULL
;
2331 if (f
->output_data
.x
->widget
)
2333 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2334 if (x1
== 0 && y1
== 0)
2335 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2342 #endif /* not USE_GTK */
2344 #endif /* USE_X_TOOLKIT || USE_GTK */
2346 /* xmenu_show actually displays a menu using the panes and items in menu_items
2347 and returns the value selected from it.
2348 There are two versions of xmenu_show, one for Xt and one for Xlib.
2349 Both assume input is blocked by the caller. */
2351 /* F is the frame the menu is for.
2352 X and Y are the frame-relative specified position,
2353 relative to the inside upper left corner of the frame F.
2354 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2355 KEYMAPS is 1 if this menu was specified with keymaps;
2356 in that case, we return a list containing the chosen item's value
2357 and perhaps also the pane's prefix.
2358 TITLE is the specified menu title.
2359 ERROR is a place to store an error message string in case of failure.
2360 (We return nil on failure, but the value doesn't actually matter.) */
2362 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2364 /* The item selected in the popup menu. */
2365 static Lisp_Object
*volatile menu_item_selection
;
2369 /* Used when position a popup menu. See menu_position_func and
2370 create_and_show_popup_menu below. */
2371 struct next_popup_x_y
2378 /* The menu position function to use if we are not putting a popup
2379 menu where the pointer is.
2380 MENU is the menu to pop up.
2381 X and Y shall on exit contain x/y where the menu shall pop up.
2382 PUSH_IN is not documented in the GTK manual.
2383 USER_DATA is any data passed in when calling gtk_menu_popup.
2384 Here it points to a struct next_popup_x_y where the coordinates
2385 to store in *X and *Y are as well as the frame for the popup.
2387 Here only X and Y are used. */
2389 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2396 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2398 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2399 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2404 /* Check if there is room for the menu. If not, adjust x/y so that
2405 the menu is fully visible. */
2406 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2407 if (data
->x
+ req
.width
> disp_width
)
2408 *x
-= data
->x
+ req
.width
- disp_width
;
2409 if (data
->y
+ req
.height
> disp_height
)
2410 *y
-= data
->y
+ req
.height
- disp_height
;
2414 popup_selection_callback (widget
, client_data
)
2416 gpointer client_data
;
2418 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2420 if (xg_crazy_callback_abort
) return;
2421 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2428 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
2430 popup_activated_flag
= 0;
2432 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
2437 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2439 menu_item_selection will be set to the selection. */
2441 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2443 widget_value
*first_wv
;
2450 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2451 struct next_popup_x_y popup_x_y
;
2452 int specpdl_count
= SPECPDL_INDEX ();
2454 xg_crazy_callback_abort
= 1;
2455 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2456 G_CALLBACK (popup_selection_callback
),
2457 G_CALLBACK (popup_deactivate_callback
),
2458 G_CALLBACK (menu_highlight_callback
));
2459 xg_crazy_callback_abort
= 0;
2461 for (i
= 0; i
< 5; i
++)
2462 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2467 /* Not invoked by a click. pop up at x/y. */
2468 pos_func
= menu_position_func
;
2470 /* Adjust coordinates to be root-window-relative. */
2471 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2472 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2479 /* Display the menu. */
2480 gtk_widget_show_all (menu
);
2481 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2483 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2485 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2486 two. show_help_echo uses this to detect popup menus. */
2487 popup_activated_flag
= 1;
2488 /* Process events that apply to the menu. */
2489 popup_widget_loop (1, menu
);
2491 unbind_to (specpdl_count
, Qnil
);
2493 /* Must reset this manually because the button release event is not passed
2494 to Emacs event loop. */
2495 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2498 #else /* not USE_GTK */
2500 /* We need a unique id for each widget handled by the Lucid Widget
2503 For the main windows, and popup menus, we use this counter,
2504 which we increment each time after use. This starts from 1<<16.
2506 For menu bars, we use numbers starting at 0, counted in
2507 next_menubar_widget_id. */
2508 LWLIB_ID widget_id_tick
;
2511 popup_selection_callback (widget
, id
, client_data
)
2514 XtPointer client_data
;
2516 menu_item_selection
= (Lisp_Object
*) client_data
;
2519 /* ARG is the LWLIB ID of the dialog box, represented
2520 as a Lisp object as (HIGHPART . LOWPART). */
2526 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2527 | XINT (XCDR (arg
)));
2530 lw_destroy_all_widgets (id
);
2532 popup_activated_flag
= 0;
2537 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2539 menu_item_selection will be set to the selection. */
2541 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2543 widget_value
*first_wv
;
2551 XButtonPressedEvent dummy
;
2555 menu_id
= widget_id_tick
++;
2556 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2557 f
->output_data
.x
->widget
, 1, 0,
2558 popup_selection_callback
,
2559 popup_deactivate_callback
,
2560 menu_highlight_callback
);
2562 dummy
.type
= ButtonPress
;
2564 dummy
.send_event
= 0;
2565 dummy
.display
= FRAME_X_DISPLAY (f
);
2566 dummy
.time
= CurrentTime
;
2567 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2568 dummy
.window
= dummy
.root
;
2569 dummy
.subwindow
= dummy
.root
;
2573 /* Adjust coordinates to be root-window-relative. */
2574 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2575 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2582 for (i
= 0; i
< 5; i
++)
2583 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2586 /* Don't allow any geometry request from the user. */
2587 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2588 XtSetValues (menu
, av
, ac
);
2590 /* Display the menu. */
2591 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2592 popup_activated_flag
= 1;
2595 int fact
= 4 * sizeof (LWLIB_ID
);
2596 int specpdl_count
= SPECPDL_INDEX ();
2597 record_unwind_protect (pop_down_menu
,
2598 Fcons (make_number (menu_id
>> (fact
)),
2599 make_number (menu_id
& ~(-1 << (fact
)))));
2601 /* Process events that apply to the menu. */
2602 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1, 0);
2604 unbind_to (specpdl_count
, Qnil
);
2608 #endif /* not USE_GTK */
2611 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2621 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2622 widget_value
**submenu_stack
2623 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2624 Lisp_Object
*subprefix_stack
2625 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2626 int submenu_depth
= 0;
2632 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2634 *error
= "Empty menu";
2638 /* Create a tree of widget_value objects
2639 representing the panes and their items. */
2640 wv
= xmalloc_widget_value ();
2644 wv
->button_type
= BUTTON_TYPE_NONE
;
2649 /* Loop over all panes and items, filling in the tree. */
2651 while (i
< menu_items_used
)
2653 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2655 submenu_stack
[submenu_depth
++] = save_wv
;
2661 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2664 save_wv
= submenu_stack
[--submenu_depth
];
2668 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2669 && submenu_depth
!= 0)
2670 i
+= MENU_ITEMS_PANE_LENGTH
;
2671 /* Ignore a nil in the item list.
2672 It's meaningful only for dialog boxes. */
2673 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2675 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2677 /* Create a new pane. */
2678 Lisp_Object pane_name
, prefix
;
2681 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2682 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2684 #ifndef HAVE_MULTILINGUAL_MENU
2685 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2687 pane_name
= ENCODE_SYSTEM (pane_name
);
2688 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2691 pane_string
= (NILP (pane_name
)
2692 ? "" : (char *) SDATA (pane_name
));
2693 /* If there is just one top-level pane, put all its items directly
2694 under the top-level menu. */
2695 if (menu_items_n_panes
== 1)
2698 /* If the pane has a meaningful name,
2699 make the pane a top-level menu item
2700 with its items as a submenu beneath it. */
2701 if (!keymaps
&& strcmp (pane_string
, ""))
2703 wv
= xmalloc_widget_value ();
2707 first_wv
->contents
= wv
;
2708 wv
->name
= pane_string
;
2709 if (keymaps
&& !NILP (prefix
))
2713 wv
->button_type
= BUTTON_TYPE_NONE
;
2718 else if (first_pane
)
2724 i
+= MENU_ITEMS_PANE_LENGTH
;
2728 /* Create a new item within current pane. */
2729 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2730 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2731 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2732 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2733 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2734 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2735 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2736 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2738 #ifndef HAVE_MULTILINGUAL_MENU
2739 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2741 item_name
= ENCODE_MENU_STRING (item_name
);
2742 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2745 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2747 descrip
= ENCODE_MENU_STRING (descrip
);
2748 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2750 #endif /* not HAVE_MULTILINGUAL_MENU */
2752 wv
= xmalloc_widget_value ();
2756 save_wv
->contents
= wv
;
2757 wv
->name
= (char *) SDATA (item_name
);
2758 if (!NILP (descrip
))
2759 wv
->key
= (char *) SDATA (descrip
);
2761 /* If this item has a null value,
2762 make the call_data null so that it won't display a box
2763 when the mouse is on it. */
2765 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2766 wv
->enabled
= !NILP (enable
);
2769 wv
->button_type
= BUTTON_TYPE_NONE
;
2770 else if (EQ (type
, QCtoggle
))
2771 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2772 else if (EQ (type
, QCradio
))
2773 wv
->button_type
= BUTTON_TYPE_RADIO
;
2777 wv
->selected
= !NILP (selected
);
2779 if (! STRINGP (help
))
2786 i
+= MENU_ITEMS_ITEM_LENGTH
;
2790 /* Deal with the title, if it is non-nil. */
2793 widget_value
*wv_title
= xmalloc_widget_value ();
2794 widget_value
*wv_sep1
= xmalloc_widget_value ();
2795 widget_value
*wv_sep2
= xmalloc_widget_value ();
2797 wv_sep2
->name
= "--";
2798 wv_sep2
->next
= first_wv
->contents
;
2799 wv_sep2
->help
= Qnil
;
2801 wv_sep1
->name
= "--";
2802 wv_sep1
->next
= wv_sep2
;
2803 wv_sep1
->help
= Qnil
;
2805 #ifndef HAVE_MULTILINGUAL_MENU
2806 if (STRING_MULTIBYTE (title
))
2807 title
= ENCODE_MENU_STRING (title
);
2810 wv_title
->name
= (char *) SDATA (title
);
2811 wv_title
->enabled
= TRUE
;
2812 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2813 wv_title
->next
= wv_sep1
;
2814 wv_title
->help
= Qnil
;
2815 first_wv
->contents
= wv_title
;
2818 /* No selection has been chosen yet. */
2819 menu_item_selection
= 0;
2821 /* Actually create and show the menu until popped down. */
2822 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2824 /* Free the widget_value objects we used to specify the contents. */
2825 free_menubar_widget_value_tree (first_wv
);
2827 /* Find the selected item, and its pane, to return
2828 the proper value. */
2829 if (menu_item_selection
!= 0)
2831 Lisp_Object prefix
, entry
;
2833 prefix
= entry
= Qnil
;
2835 while (i
< menu_items_used
)
2837 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2839 subprefix_stack
[submenu_depth
++] = prefix
;
2843 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2845 prefix
= subprefix_stack
[--submenu_depth
];
2848 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2851 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2852 i
+= MENU_ITEMS_PANE_LENGTH
;
2854 /* Ignore a nil in the item list.
2855 It's meaningful only for dialog boxes. */
2856 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2861 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2862 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2868 entry
= Fcons (entry
, Qnil
);
2870 entry
= Fcons (prefix
, entry
);
2871 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2872 if (!NILP (subprefix_stack
[j
]))
2873 entry
= Fcons (subprefix_stack
[j
], entry
);
2877 i
+= MENU_ITEMS_ITEM_LENGTH
;
2887 dialog_selection_callback (widget
, client_data
)
2889 gpointer client_data
;
2891 /* The EMACS_INT cast avoids a warning. There's no problem
2892 as long as pointers have enough bits to hold small integers. */
2893 if ((int) (EMACS_INT
) client_data
!= -1)
2894 menu_item_selection
= (Lisp_Object
*) client_data
;
2896 popup_activated_flag
= 0;
2899 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2901 menu_item_selection will be set to the selection. */
2903 create_and_show_dialog (f
, first_wv
)
2905 widget_value
*first_wv
;
2909 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2910 G_CALLBACK (dialog_selection_callback
),
2911 G_CALLBACK (popup_deactivate_callback
),
2916 int specpdl_count
= SPECPDL_INDEX ();
2917 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2919 /* Display the menu. */
2920 gtk_widget_show_all (menu
);
2922 /* Process events that apply to the menu. */
2923 popup_widget_loop (1, menu
);
2925 unbind_to (specpdl_count
, Qnil
);
2929 #else /* not USE_GTK */
2931 dialog_selection_callback (widget
, id
, client_data
)
2934 XtPointer client_data
;
2936 /* The EMACS_INT cast avoids a warning. There's no problem
2937 as long as pointers have enough bits to hold small integers. */
2938 if ((int) (EMACS_INT
) client_data
!= -1)
2939 menu_item_selection
= (Lisp_Object
*) client_data
;
2942 lw_destroy_all_widgets (id
);
2944 popup_activated_flag
= 0;
2948 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2950 menu_item_selection will be set to the selection. */
2952 create_and_show_dialog (f
, first_wv
)
2954 widget_value
*first_wv
;
2958 dialog_id
= widget_id_tick
++;
2959 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2960 f
->output_data
.x
->widget
, 1, 0,
2961 dialog_selection_callback
, 0, 0);
2962 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2964 /* Display the dialog box. */
2965 lw_pop_up_all_widgets (dialog_id
);
2966 popup_activated_flag
= 1;
2968 /* Process events that apply to the dialog box.
2969 Also handle timers. */
2971 int count
= SPECPDL_INDEX ();
2972 int fact
= 4 * sizeof (LWLIB_ID
);
2974 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2975 record_unwind_protect (pop_down_menu
,
2976 Fcons (make_number (dialog_id
>> (fact
)),
2977 make_number (dialog_id
& ~(-1 << (fact
)))));
2979 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
2982 unbind_to (count
, Qnil
);
2986 #endif /* not USE_GTK */
2988 static char * button_names
[] = {
2989 "button1", "button2", "button3", "button4", "button5",
2990 "button6", "button7", "button8", "button9", "button10" };
2993 xdialog_show (f
, keymaps
, title
, error
)
2999 int i
, nb_buttons
=0;
3000 char dialog_name
[6];
3002 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
3004 /* Number of elements seen so far, before boundary. */
3006 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
3007 int boundary_seen
= 0;
3011 if (menu_items_n_panes
> 1)
3013 *error
= "Multiple panes in dialog box";
3017 /* Create a tree of widget_value objects
3018 representing the text label and buttons. */
3020 Lisp_Object pane_name
, prefix
;
3022 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
3023 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
3024 pane_string
= (NILP (pane_name
)
3025 ? "" : (char *) SDATA (pane_name
));
3026 prev_wv
= xmalloc_widget_value ();
3027 prev_wv
->value
= pane_string
;
3028 if (keymaps
&& !NILP (prefix
))
3030 prev_wv
->enabled
= 1;
3031 prev_wv
->name
= "message";
3032 prev_wv
->help
= Qnil
;
3035 /* Loop over all panes and items, filling in the tree. */
3036 i
= MENU_ITEMS_PANE_LENGTH
;
3037 while (i
< menu_items_used
)
3040 /* Create a new item within current pane. */
3041 Lisp_Object item_name
, enable
, descrip
;
3042 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3043 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3045 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3047 if (NILP (item_name
))
3049 free_menubar_widget_value_tree (first_wv
);
3050 *error
= "Submenu in dialog items";
3053 if (EQ (item_name
, Qquote
))
3055 /* This is the boundary between left-side elts
3056 and right-side elts. Stop incrementing right_count. */
3061 if (nb_buttons
>= 9)
3063 free_menubar_widget_value_tree (first_wv
);
3064 *error
= "Too many dialog items";
3068 wv
= xmalloc_widget_value ();
3070 wv
->name
= (char *) button_names
[nb_buttons
];
3071 if (!NILP (descrip
))
3072 wv
->key
= (char *) SDATA (descrip
);
3073 wv
->value
= (char *) SDATA (item_name
);
3074 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
3075 wv
->enabled
= !NILP (enable
);
3079 if (! boundary_seen
)
3083 i
+= MENU_ITEMS_ITEM_LENGTH
;
3086 /* If the boundary was not specified,
3087 by default put half on the left and half on the right. */
3088 if (! boundary_seen
)
3089 left_count
= nb_buttons
- nb_buttons
/ 2;
3091 wv
= xmalloc_widget_value ();
3092 wv
->name
= dialog_name
;
3094 /* Dialog boxes use a really stupid name encoding
3095 which specifies how many buttons to use
3096 and how many buttons are on the right.
3097 The Q means something also. */
3098 dialog_name
[0] = 'Q';
3099 dialog_name
[1] = '0' + nb_buttons
;
3100 dialog_name
[2] = 'B';
3101 dialog_name
[3] = 'R';
3102 /* Number of buttons to put on the right. */
3103 dialog_name
[4] = '0' + nb_buttons
- left_count
;
3105 wv
->contents
= first_wv
;
3109 /* No selection has been chosen yet. */
3110 menu_item_selection
= 0;
3112 /* Actually create and show the dialog. */
3113 create_and_show_dialog (f
, first_wv
);
3115 /* Free the widget_value objects we used to specify the contents. */
3116 free_menubar_widget_value_tree (first_wv
);
3118 /* Find the selected item, and its pane, to return
3119 the proper value. */
3120 if (menu_item_selection
!= 0)
3126 while (i
< menu_items_used
)
3130 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3133 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3134 i
+= MENU_ITEMS_PANE_LENGTH
;
3136 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3138 /* This is the boundary between left-side elts and
3145 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3146 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
3150 entry
= Fcons (entry
, Qnil
);
3152 entry
= Fcons (prefix
, entry
);
3156 i
+= MENU_ITEMS_ITEM_LENGTH
;
3161 /* Make "Cancel" equivalent to C-g. */
3162 Fsignal (Qquit
, Qnil
);
3167 #else /* not USE_X_TOOLKIT && not USE_GTK */
3169 /* The frame of the last activated non-toolkit menu bar.
3170 Used to generate menu help events. */
3172 static struct frame
*menu_help_frame
;
3175 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3177 PANE is the pane number, and ITEM is the menu item number in
3178 the menu (currently not used).
3180 This cannot be done with generating a HELP_EVENT because
3181 XMenuActivate contains a loop that doesn't let Emacs process
3185 menu_help_callback (help_string
, pane
, item
)
3189 extern Lisp_Object Qmenu_item
;
3190 Lisp_Object
*first_item
;
3191 Lisp_Object pane_name
;
3192 Lisp_Object menu_object
;
3194 first_item
= XVECTOR (menu_items
)->contents
;
3195 if (EQ (first_item
[0], Qt
))
3196 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3197 else if (EQ (first_item
[0], Qquote
))
3198 /* This shouldn't happen, see xmenu_show. */
3199 pane_name
= empty_string
;
3201 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3203 /* (menu-item MENU-NAME PANE-NUMBER) */
3204 menu_object
= Fcons (Qmenu_item
,
3206 Fcons (make_number (pane
), Qnil
)));
3207 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3208 Qnil
, menu_object
, make_number (item
), 1);
3215 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
3216 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
3218 FRAME_PTR f
= p1
->pointer
;
3219 XMenu
*menu
= p2
->pointer
;
3223 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
3224 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
3226 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3228 #ifdef HAVE_X_WINDOWS
3229 /* Assume the mouse has moved out of the X window.
3230 If it has actually moved in, we will get an EnterNotify. */
3231 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3233 /* State that no mouse buttons are now held.
3234 (The oldXMenu code doesn't track this info for us.)
3235 That is not necessarily true, but the fiction leads to reasonable
3236 results, and it is a pain to ask which are actually held now. */
3237 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3239 #endif /* HAVE_X_WINDOWS */
3248 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3258 int pane
, selidx
, lpane
, status
;
3259 Lisp_Object entry
, pane_prefix
;
3261 int ulx
, uly
, width
, height
;
3262 int dispwidth
, dispheight
;
3263 int i
, j
, lines
, maxlines
;
3266 unsigned int dummy_uint
;
3267 int specpdl_count
= SPECPDL_INDEX ();
3270 if (menu_items_n_panes
== 0)
3273 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3275 *error
= "Empty menu";
3279 /* Figure out which root window F is on. */
3280 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3281 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3282 &dummy_uint
, &dummy_uint
);
3284 /* Make the menu on that window. */
3285 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3288 *error
= "Can't create menu";
3292 #ifdef HAVE_X_WINDOWS
3293 /* Adjust coordinates to relative to the outer (window manager) window. */
3294 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
3295 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
3296 #endif /* HAVE_X_WINDOWS */
3298 /* Adjust coordinates to be root-window-relative. */
3302 /* Create all the necessary panes and their items. */
3303 maxlines
= lines
= i
= 0;
3304 while (i
< menu_items_used
)
3306 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3308 /* Create a new pane. */
3309 Lisp_Object pane_name
, prefix
;
3312 maxlines
= max (maxlines
, lines
);
3314 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3315 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3316 pane_string
= (NILP (pane_name
)
3317 ? "" : (char *) SDATA (pane_name
));
3318 if (keymaps
&& !NILP (prefix
))
3321 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3322 if (lpane
== XM_FAILURE
)
3324 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3325 *error
= "Can't create pane";
3328 i
+= MENU_ITEMS_PANE_LENGTH
;
3330 /* Find the width of the widest item in this pane. */
3333 while (j
< menu_items_used
)
3336 item
= XVECTOR (menu_items
)->contents
[j
];
3344 width
= SBYTES (item
);
3345 if (width
> maxwidth
)
3348 j
+= MENU_ITEMS_ITEM_LENGTH
;
3351 /* Ignore a nil in the item list.
3352 It's meaningful only for dialog boxes. */
3353 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3357 /* Create a new item within current pane. */
3358 Lisp_Object item_name
, enable
, descrip
, help
;
3359 unsigned char *item_data
;
3362 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3363 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3365 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3366 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3367 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3369 if (!NILP (descrip
))
3371 int gap
= maxwidth
- SBYTES (item_name
);
3374 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3375 item_name
= concat2 (item_name
, spacer
);
3376 item_name
= concat2 (item_name
, descrip
);
3377 item_data
= SDATA (item_name
);
3379 /* if alloca is fast, use that to make the space,
3380 to reduce gc needs. */
3382 = (unsigned char *) alloca (maxwidth
3383 + SBYTES (descrip
) + 1);
3384 bcopy (SDATA (item_name
), item_data
,
3385 SBYTES (item_name
));
3386 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3388 bcopy (SDATA (descrip
), item_data
+ j
,
3390 item_data
[j
+ SBYTES (descrip
)] = 0;
3394 item_data
= SDATA (item_name
);
3396 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3397 menu
, lpane
, 0, item_data
,
3398 !NILP (enable
), help_string
)
3401 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3402 *error
= "Can't add selection to menu";
3405 i
+= MENU_ITEMS_ITEM_LENGTH
;
3410 maxlines
= max (maxlines
, lines
);
3412 /* All set and ready to fly. */
3413 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3414 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3415 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3416 x
= min (x
, dispwidth
);
3417 y
= min (y
, dispheight
);
3420 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3421 &ulx
, &uly
, &width
, &height
);
3422 if (ulx
+width
> dispwidth
)
3424 x
-= (ulx
+ width
) - dispwidth
;
3425 ulx
= dispwidth
- width
;
3427 if (uly
+height
> dispheight
)
3429 y
-= (uly
+ height
) - dispheight
;
3430 uly
= dispheight
- height
;
3432 if (ulx
< 0) x
-= ulx
;
3433 if (uly
< 0) y
-= uly
;
3437 /* If position was not given by a mouse click, adjust so upper left
3438 corner of the menu as a whole ends up at given coordinates. This
3439 is what x-popup-menu says in its documentation. */
3441 y
+= 1.5*height
/(maxlines
+2);
3444 XMenuSetAEQ (menu
, TRUE
);
3445 XMenuSetFreeze (menu
, TRUE
);
3449 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
3452 record_unwind_protect (pop_down_menu
,
3453 Fcons (make_save_value (f
, 0),
3454 make_save_value (menu
, 0)));
3456 /* Help display under X won't work because XMenuActivate contains
3457 a loop that doesn't give Emacs a chance to process it. */
3458 menu_help_frame
= f
;
3459 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3460 x
, y
, ButtonReleaseMask
, &datap
,
3461 menu_help_callback
);
3467 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3470 /* Find the item number SELIDX in pane number PANE. */
3472 while (i
< menu_items_used
)
3474 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3478 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3480 i
+= MENU_ITEMS_PANE_LENGTH
;
3489 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3492 entry
= Fcons (entry
, Qnil
);
3493 if (!NILP (pane_prefix
))
3494 entry
= Fcons (pane_prefix
, entry
);
3500 i
+= MENU_ITEMS_ITEM_LENGTH
;
3506 *error
= "Can't activate menu";
3511 /* Make "Cancel" equivalent to C-g unless this menu was popped up by
3514 Fsignal (Qquit
, Qnil
);
3519 unbind_to (specpdl_count
, Qnil
);
3524 #endif /* not USE_X_TOOLKIT */
3526 #endif /* HAVE_MENUS */
3531 staticpro (&menu_items
);
3533 menu_items_inuse
= Qnil
;
3535 Qdebug_on_next_call
= intern ("debug-on-next-call");
3536 staticpro (&Qdebug_on_next_call
);
3538 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3539 doc
: /* Frame for which we are updating a menu.
3540 The enable predicate for a menu command should check this variable. */);
3541 Vmenu_updating_frame
= Qnil
;
3543 #ifdef USE_X_TOOLKIT
3544 widget_id_tick
= (1<<16);
3545 next_menubar_widget_id
= 1;
3548 defsubr (&Sx_popup_menu
);
3550 defsubr (&Sx_popup_dialog
);
3554 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
3555 (do not change this comment) */