1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 88, 93, 94, 96, 99, 2000, 2001, 2003
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* X pop-up deck-of-cards menu facility for GNU Emacs.
24 * Written by Jon Arnold and Roman Budzianowski
25 * Mods and rewrite by Robert Krawitz
29 /* Modified by Fred Pierresteguy on December 93
30 to make the popup menus and menubar use the Xt. */
32 /* Rewritten for clarity and GC protection by rms in Feb 94. */
36 /* On 4.3 this loses if it comes after xterm.h. */
42 #include "termhooks.h"
47 #include "blockinput.h"
57 /* This may include sys/types.h, and that somehow loses
58 if this is not done before the other system files. */
62 /* Load sys/types.h if not already loaded.
63 In some systems loading it twice is suicidal. */
65 #include <sys/types.h>
68 #include "dispextern.h"
71 #undef HAVE_MULTILINGUAL_MENU
75 #include <X11/IntrinsicP.h>
76 #include <X11/CoreP.h>
77 #include <X11/StringDefs.h>
78 #include <X11/Shell.h>
80 #include <X11/Xaw/Paned.h>
81 #endif /* USE_LUCID */
82 #include "../lwlib/lwlib.h"
83 #else /* not USE_X_TOOLKIT */
85 #include "../oldXMenu/XMenu.h"
87 #endif /* not USE_X_TOOLKIT */
88 #endif /* HAVE_X_WINDOWS */
95 Lisp_Object Vmenu_updating_frame
;
97 Lisp_Object Qdebug_on_next_call
;
99 extern Lisp_Object Qmenu_bar
;
100 extern Lisp_Object Qmouse_click
, Qevent_kind
;
102 extern Lisp_Object QCtoggle
, QCradio
;
104 extern Lisp_Object Voverriding_local_map
;
105 extern Lisp_Object Voverriding_local_map_menu_flag
;
107 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
109 extern Lisp_Object Qmenu_bar_update_hook
;
112 extern void set_frame_menubar ();
113 extern XtAppContext Xt_app_con
;
115 static Lisp_Object
xdialog_show ();
116 static void popup_get_selection ();
118 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
121 #endif /* USE_X_TOOLKIT */
126 extern void set_frame_menubar ();
127 static Lisp_Object
xdialog_show ();
130 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
131 Lisp_Object
, Lisp_Object
, Lisp_Object
,
132 Lisp_Object
, Lisp_Object
));
133 static int update_frame_menubar
P_ ((struct frame
*));
134 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
135 Lisp_Object
, char **));
136 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
137 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
139 static void list_of_panes
P_ ((Lisp_Object
));
140 static void list_of_items
P_ ((Lisp_Object
));
142 extern EMACS_TIME timer_check
P_ ((int));
144 /* This holds a Lisp vector that holds the results of decoding
145 the keymaps or alist-of-alists that specify a menu.
147 It describes the panes and items within the panes.
149 Each pane is described by 3 elements in the vector:
150 t, the pane name, the pane's prefix key.
151 Then follow the pane's items, with 5 elements per item:
152 the item string, the enable flag, the item's value,
153 the definition, and the equivalent keyboard key's description string.
155 In some cases, multiple levels of menus may be described.
156 A single vector slot containing nil indicates the start of a submenu.
157 A single vector slot containing lambda indicates the end of a submenu.
158 The submenu follows a menu item which is the way to reach the submenu.
160 A single vector slot containing quote indicates that the
161 following items should appear on the right of a dialog box.
163 Using a Lisp vector to hold this information while we decode it
164 takes care of protecting all the data from GC. */
166 #define MENU_ITEMS_PANE_NAME 1
167 #define MENU_ITEMS_PANE_PREFIX 2
168 #define MENU_ITEMS_PANE_LENGTH 3
172 MENU_ITEMS_ITEM_NAME
= 0,
173 MENU_ITEMS_ITEM_ENABLE
,
174 MENU_ITEMS_ITEM_VALUE
,
175 MENU_ITEMS_ITEM_EQUIV_KEY
,
176 MENU_ITEMS_ITEM_DEFINITION
,
177 MENU_ITEMS_ITEM_TYPE
,
178 MENU_ITEMS_ITEM_SELECTED
,
179 MENU_ITEMS_ITEM_HELP
,
180 MENU_ITEMS_ITEM_LENGTH
183 static Lisp_Object menu_items
;
185 /* If non-nil, means that the global vars defined here are already in use.
186 Used to detect cases where we try to re-enter this non-reentrant code. */
187 static Lisp_Object menu_items_inuse
;
189 /* Number of slots currently allocated in menu_items. */
190 static int menu_items_allocated
;
192 /* This is the index in menu_items of the first empty slot. */
193 static int menu_items_used
;
195 /* The number of panes currently recorded in menu_items,
196 excluding those within submenus. */
197 static int menu_items_n_panes
;
199 /* Current depth within submenus. */
200 static int menu_items_submenu_depth
;
202 /* Flag which when set indicates a dialog or menu has been posted by
203 Xt on behalf of one of the widget sets. */
204 static int popup_activated_flag
;
206 static int next_menubar_widget_id
;
208 /* This is set nonzero after the user activates the menu bar, and set
209 to zero again after the menu bars are redisplayed by prepare_menu_bar.
210 While it is nonzero, all calls to set_frame_menubar go deep.
212 I don't understand why this is needed, but it does seem to be
213 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
215 int pending_menu_activation
;
219 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
221 static struct frame
*
222 menubar_id_to_frame (id
)
225 Lisp_Object tail
, frame
;
228 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
231 if (!GC_FRAMEP (frame
))
234 if (!FRAME_WINDOW_P (f
))
236 if (f
->output_data
.x
->id
== id
)
244 /* Initialize the menu_items structure if we haven't already done so.
245 Also mark it as currently empty. */
250 if (NILP (menu_items
))
252 menu_items_allocated
= 60;
253 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
256 if (!NILP (menu_items_inuse
))
257 error ("Trying to use a menu from within a menu-entry");
258 menu_items_inuse
= Qt
;
260 menu_items_n_panes
= 0;
261 menu_items_submenu_depth
= 0;
264 /* Call at the end of generating the data in menu_items. */
272 unuse_menu_items (dummy
)
275 return menu_items_inuse
= Qnil
;
278 /* Call when finished using the data for the current menu
282 discard_menu_items ()
284 /* Free the structure if it is especially large.
285 Otherwise, hold on to it, to save time. */
286 if (menu_items_allocated
> 200)
289 menu_items_allocated
= 0;
291 xassert (NILP (menu_items_inuse
));
294 /* Make the menu_items vector twice as large. */
300 int old_size
= menu_items_allocated
;
303 menu_items_allocated
*= 2;
304 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
305 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
306 old_size
* sizeof (Lisp_Object
));
309 /* Begin a submenu. */
312 push_submenu_start ()
314 if (menu_items_used
+ 1 > menu_items_allocated
)
317 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
318 menu_items_submenu_depth
++;
326 if (menu_items_used
+ 1 > menu_items_allocated
)
329 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
330 menu_items_submenu_depth
--;
333 /* Indicate boundary between left and right. */
336 push_left_right_boundary ()
338 if (menu_items_used
+ 1 > menu_items_allocated
)
341 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
344 /* Start a new menu pane in menu_items.
345 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
348 push_menu_pane (name
, prefix_vec
)
349 Lisp_Object name
, prefix_vec
;
351 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
354 if (menu_items_submenu_depth
== 0)
355 menu_items_n_panes
++;
356 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
357 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
358 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
361 /* Push one menu item into the current pane. NAME is the string to
362 display. ENABLE if non-nil means this item can be selected. KEY
363 is the key generated by choosing this item, or nil if this item
364 doesn't really have a definition. DEF is the definition of this
365 item. EQUIV is the textual description of the keyboard equivalent
366 for this item (or nil if none). TYPE is the type of this menu
367 item, one of nil, `toggle' or `radio'. */
370 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
371 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
373 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
376 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
377 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
378 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
379 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
380 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
381 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
382 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
383 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
386 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
387 and generate menu panes for them in menu_items.
388 If NOTREAL is nonzero,
389 don't bother really computing whether an item is enabled. */
392 keymap_panes (keymaps
, nmaps
, notreal
)
393 Lisp_Object
*keymaps
;
401 /* Loop over the given keymaps, making a pane for each map.
402 But don't make a pane that is empty--ignore that map instead.
403 P is the number of panes we have made so far. */
404 for (mapno
= 0; mapno
< nmaps
; mapno
++)
405 single_keymap_panes (keymaps
[mapno
],
406 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
408 finish_menu_items ();
411 /* Args passed between single_keymap_panes and single_menu_item. */
414 Lisp_Object pending_maps
;
415 int maxdepth
, notreal
;
419 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
422 /* This is a recursive subroutine of keymap_panes.
423 It handles one keymap, KEYMAP.
424 The other arguments are passed along
425 or point to local variables of the previous function.
426 If NOTREAL is nonzero, only check for equivalent key bindings, don't
427 evaluate expressions in menu items and don't make any menu.
429 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
432 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
434 Lisp_Object pane_name
;
442 skp
.pending_maps
= Qnil
;
443 skp
.maxdepth
= maxdepth
;
444 skp
.notreal
= notreal
;
450 push_menu_pane (pane_name
, prefix
);
453 /* Remember index for first item in this pane so we can go back and
454 add a prefix when (if) we see the first button. After that, notbuttons
455 is set to 0, to mark that we have seen a button and all non button
456 items need a prefix. */
457 skp
.notbuttons
= menu_items_used
;
460 GCPRO1 (skp
.pending_maps
);
461 map_keymap (keymap
, single_menu_item
, Qnil
, &skp
, 1);
464 /* Process now any submenus which want to be panes at this level. */
465 while (CONSP (skp
.pending_maps
))
467 Lisp_Object elt
, eltcdr
, string
;
468 elt
= XCAR (skp
.pending_maps
);
470 string
= XCAR (eltcdr
);
471 /* We no longer discard the @ from the beginning of the string here.
472 Instead, we do this in xmenu_show. */
473 single_keymap_panes (Fcar (elt
), string
,
474 XCDR (eltcdr
), notreal
, maxdepth
- 1);
475 skp
.pending_maps
= XCDR (skp
.pending_maps
);
479 /* This is a subroutine of single_keymap_panes that handles one
481 KEY is a key in a keymap and ITEM is its binding.
482 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
484 If SKP->NOTREAL is nonzero, only check for equivalent key bindings, don't
485 evaluate expressions in menu items and don't make any menu.
486 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them.
487 SKP->NOTBUTTONS is only used when simulating toggle boxes and radio
488 buttons. It keeps track of if we have seen a button in this menu or
492 single_menu_item (key
, item
, dummy
, skp_v
)
493 Lisp_Object key
, item
, dummy
;
496 Lisp_Object map
, item_string
, enabled
;
497 struct gcpro gcpro1
, gcpro2
;
499 struct skp
*skp
= skp_v
;
501 /* Parse the menu item and leave the result in item_properties. */
503 res
= parse_menu_item (item
, skp
->notreal
, 0);
506 return; /* Not a menu item. */
508 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
512 /* We don't want to make a menu, just traverse the keymaps to
513 precompute equivalent key bindings. */
515 single_keymap_panes (map
, Qnil
, key
, 1, skp
->maxdepth
- 1);
519 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
520 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
522 if (!NILP (map
) && SREF (item_string
, 0) == '@')
525 /* An enabled separate pane. Remember this to handle it later. */
526 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
532 /* Simulate radio buttons and toggle boxes by putting a prefix in
535 Lisp_Object prefix
= Qnil
;
536 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
540 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
543 /* The first button. Line up previous items in this menu. */
545 int index
= skp
->notbuttons
; /* Index for first item this menu. */
548 while (index
< menu_items_used
)
551 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
555 submenu
++; /* Skip sub menu. */
557 else if (EQ (tem
, Qlambda
))
560 submenu
--; /* End sub menu. */
562 else if (EQ (tem
, Qt
))
563 index
+= 3; /* Skip new pane marker. */
564 else if (EQ (tem
, Qquote
))
565 index
++; /* Skip a left, right divider. */
568 if (!submenu
&& SREF (tem
, 0) != '\0'
569 && SREF (tem
, 0) != '-')
570 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
571 = concat2 (build_string (" "), tem
);
572 index
+= MENU_ITEMS_ITEM_LENGTH
;
578 /* Calculate prefix, if any, for this item. */
579 if (EQ (type
, QCtoggle
))
580 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
581 else if (EQ (type
, QCradio
))
582 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
584 /* Not a button. If we have earlier buttons, then we need a prefix. */
585 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
586 && SREF (item_string
, 0) != '-')
587 prefix
= build_string (" ");
590 item_string
= concat2 (prefix
, item_string
);
592 #endif /* not HAVE_BOXES */
594 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
596 /* Indicate visually that this is a submenu. */
597 item_string
= concat2 (item_string
, build_string (" >"));
600 push_menu_item (item_string
, enabled
, key
,
601 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
602 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
603 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
604 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
605 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
607 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
608 /* Display a submenu using the toolkit. */
609 if (! (NILP (map
) || NILP (enabled
)))
611 push_submenu_start ();
612 single_keymap_panes (map
, Qnil
, key
, 0, skp
->maxdepth
- 1);
618 /* Push all the panes and items of a menu described by the
619 alist-of-alists MENU.
620 This handles old-fashioned calls to x-popup-menu. */
630 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
632 Lisp_Object elt
, pane_name
, pane_data
;
634 pane_name
= Fcar (elt
);
635 CHECK_STRING (pane_name
);
636 push_menu_pane (pane_name
, Qnil
);
637 pane_data
= Fcdr (elt
);
638 CHECK_CONS (pane_data
);
639 list_of_items (pane_data
);
642 finish_menu_items ();
645 /* Push the items in a single pane defined by the alist PANE. */
651 Lisp_Object tail
, item
, item1
;
653 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
657 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
658 else if (NILP (item
))
659 push_left_right_boundary ();
664 CHECK_STRING (item1
);
665 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
670 #ifdef HAVE_X_WINDOWS
671 /* Return the mouse position in *X and *Y. The coordinates are window
672 relative for the edit window in frame F.
673 This is for Fx_popup_menu. The mouse_position_hook can not
674 be used for X, as it returns window relative coordinates
675 for the window where the mouse is in. This could be the menu bar,
676 the scroll bar or the edit window. Fx_popup_menu needs to be
677 sure it is the edit window. */
679 mouse_position_for_popup(f
, x
, y
)
684 Window root
, dummy_window
;
689 XQueryPointer (FRAME_X_DISPLAY (f
),
690 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
692 /* The root window which contains the pointer. */
695 /* Window pointer is on, not used */
698 /* The position on that root window. */
701 /* x/y in dummy_window coordinates, not used. */
704 /* Modifier keys and pointer buttons, about which
706 (unsigned int *) &dummy
);
710 /* xmenu_show expects window coordinates, not root window
711 coordinates. Translate. */
712 *x
-= f
->output_data
.x
->left_pos
713 + FRAME_OUTER_TO_INNER_DIFF_X (f
);
714 *y
-= f
->output_data
.x
->top_pos
715 + FRAME_OUTER_TO_INNER_DIFF_Y (f
);
718 #endif /* HAVE_X_WINDOWS */
720 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
721 doc
: /* Pop up a deck-of-cards menu and return user's selection.
722 POSITION is a position specification. This is either a mouse button event
723 or a list ((XOFFSET YOFFSET) WINDOW)
724 where XOFFSET and YOFFSET are positions in pixels from the top left
725 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)
726 This controls the position of the center of the first line
727 in the first pane of the menu, not the top left of the menu as a whole.
728 If POSITION is t, it means to use the current mouse position.
730 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
731 The menu items come from key bindings that have a menu string as well as
732 a definition; actually, the "definition" in such a key binding looks like
733 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
734 the keymap as a top-level element.
736 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
737 Otherwise, REAL-DEFINITION should be a valid key binding definition.
739 You can also use a list of keymaps as MENU.
740 Then each keymap makes a separate pane.
741 When MENU is a keymap or a list of keymaps, the return value
744 Alternatively, you can specify a menu of multiple panes
745 with a list of the form (TITLE PANE1 PANE2...),
746 where each pane is a list of form (TITLE ITEM1 ITEM2...).
747 Each ITEM is normally a cons cell (STRING . VALUE);
748 but a string can appear as an item--that makes a nonselectable line
750 With this form of menu, the return value is VALUE from the chosen item.
752 If POSITION is nil, don't display the menu at all, just precalculate the
753 cached information about equivalent key sequences. */)
755 Lisp_Object position
, menu
;
757 Lisp_Object keymap
, tem
;
758 int xpos
= 0, ypos
= 0;
761 Lisp_Object selection
;
763 Lisp_Object x
, y
, window
;
766 int specpdl_count
= SPECPDL_INDEX ();
770 if (! NILP (position
))
772 int get_current_pos_p
= 0;
775 /* Decode the first argument: find the window and the coordinates. */
776 if (EQ (position
, Qt
)
777 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
778 || EQ (XCAR (position
), Qtool_bar
))))
780 get_current_pos_p
= 1;
784 tem
= Fcar (position
);
787 window
= Fcar (Fcdr (position
));
789 y
= Fcar (Fcdr (tem
));
794 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
795 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
796 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
801 /* If a click happens in an external tool bar or a detached
802 tool bar, x and y is NIL. In that case, use the current
803 mouse position. This happens for the help button in the
804 tool bar. Ideally popup-menu should pass NIL to
805 this function, but it doesn't. */
806 if (NILP (x
) && NILP (y
))
807 get_current_pos_p
= 1;
810 if (get_current_pos_p
)
812 /* Use the mouse's current position. */
813 FRAME_PTR new_f
= SELECTED_FRAME ();
814 #ifdef HAVE_X_WINDOWS
815 /* Can't use mouse_position_hook for X since it returns
816 coordinates relative to the window the mouse is in,
817 we need coordinates relative to the edit widget always. */
822 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
823 /* cur_x/y may be negative, so use make_number. */
824 x
= make_number (cur_x
);
825 y
= make_number (cur_y
);
828 #else /* not HAVE_X_WINDOWS */
829 Lisp_Object bar_window
;
830 enum scroll_bar_part part
;
833 if (mouse_position_hook
)
834 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
835 &part
, &x
, &y
, &time
);
836 #endif /* not HAVE_X_WINDOWS */
839 XSETFRAME (window
, new_f
);
842 window
= selected_window
;
851 /* Decode where to put the menu. */
859 else if (WINDOWP (window
))
861 CHECK_LIVE_WINDOW (window
);
862 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
864 xpos
= (FONT_WIDTH (FRAME_FONT (f
))
865 * XFASTINT (XWINDOW (window
)->left
));
866 ypos
= (FRAME_LINE_HEIGHT (f
)
867 * XFASTINT (XWINDOW (window
)->top
));
870 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
871 but I don't want to make one now. */
872 CHECK_WINDOW (window
);
877 Vmenu_updating_frame
= Qnil
;
878 #endif /* HAVE_MENUS */
880 record_unwind_protect (unuse_menu_items
, Qnil
);
884 /* Decode the menu items from what was specified. */
886 keymap
= get_keymap (menu
, 0, 0);
889 /* We were given a keymap. Extract menu info from the keymap. */
892 /* Extract the detailed info to make one pane. */
893 keymap_panes (&menu
, 1, NILP (position
));
895 /* Search for a string appearing directly as an element of the keymap.
896 That string is the title of the menu. */
897 prompt
= Fkeymap_prompt (keymap
);
898 if (NILP (title
) && !NILP (prompt
))
901 /* Make that be the pane title of the first pane. */
902 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
903 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
907 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
909 /* We were given a list of keymaps. */
910 int nmaps
= XFASTINT (Flength (menu
));
912 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
917 /* The first keymap that has a prompt string
918 supplies the menu title. */
919 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
923 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
925 prompt
= Fkeymap_prompt (keymap
);
926 if (NILP (title
) && !NILP (prompt
))
930 /* Extract the detailed info to make one pane. */
931 keymap_panes (maps
, nmaps
, NILP (position
));
933 /* Make the title be the pane title of the first pane. */
934 if (!NILP (title
) && menu_items_n_panes
>= 0)
935 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
941 /* We were given an old-fashioned menu. */
943 CHECK_STRING (title
);
945 list_of_panes (Fcdr (menu
));
950 unbind_to (specpdl_count
, Qnil
);
954 discard_menu_items ();
960 /* Display them in a menu. */
963 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
964 keymaps
, title
, &error_name
);
967 discard_menu_items ();
970 #endif /* HAVE_MENUS */
972 if (error_name
) error (error_name
);
978 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
979 doc
: /* Pop up a dialog box and return user's selection.
980 POSITION specifies which frame to use.
981 This is normally a mouse button event or a window or frame.
982 If POSITION is t, it means to use the frame the mouse is on.
983 The dialog box appears in the middle of the specified frame.
985 CONTENTS specifies the alternatives to display in the dialog box.
986 It is a list of the form (TITLE ITEM1 ITEM2...).
987 Each ITEM is a cons cell (STRING . VALUE).
988 The return value is VALUE from the chosen item.
990 An ITEM may also be just a string--that makes a nonselectable item.
991 An ITEM may also be nil--that means to put all preceding items
992 on the left of the dialog box and all following items on the right.
993 \(By default, approximately half appear on each side.) */)
995 Lisp_Object position
, contents
;
1002 /* Decode the first argument: find the window or frame to use. */
1003 if (EQ (position
, Qt
)
1004 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1005 || EQ (XCAR (position
), Qtool_bar
))))
1007 #if 0 /* Using the frame the mouse is on may not be right. */
1008 /* Use the mouse's current position. */
1009 FRAME_PTR new_f
= SELECTED_FRAME ();
1010 Lisp_Object bar_window
;
1011 enum scroll_bar_part part
;
1015 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
1018 XSETFRAME (window
, new_f
);
1020 window
= selected_window
;
1022 window
= selected_window
;
1024 else if (CONSP (position
))
1027 tem
= Fcar (position
);
1029 window
= Fcar (Fcdr (position
));
1032 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1033 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1036 else if (WINDOWP (position
) || FRAMEP (position
))
1041 /* Decode where to put the menu. */
1043 if (FRAMEP (window
))
1044 f
= XFRAME (window
);
1045 else if (WINDOWP (window
))
1047 CHECK_LIVE_WINDOW (window
);
1048 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1051 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1052 but I don't want to make one now. */
1053 CHECK_WINDOW (window
);
1055 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1056 /* Display a menu with these alternatives
1057 in the middle of frame F. */
1059 Lisp_Object x
, y
, frame
, newpos
;
1060 XSETFRAME (frame
, f
);
1061 XSETINT (x
, x_pixel_width (f
) / 2);
1062 XSETINT (y
, x_pixel_height (f
) / 2);
1063 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
1065 return Fx_popup_menu (newpos
,
1066 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
1072 Lisp_Object selection
;
1073 int specpdl_count
= SPECPDL_INDEX ();
1075 /* Decode the dialog items from what was specified. */
1076 title
= Fcar (contents
);
1077 CHECK_STRING (title
);
1078 record_unwind_protect (unuse_menu_items
, Qnil
);
1080 list_of_panes (Fcons (contents
, Qnil
));
1082 /* Display them in a dialog box. */
1084 selection
= xdialog_show (f
, 0, title
, &error_name
);
1087 unbind_to (specpdl_count
, Qnil
);
1088 discard_menu_items ();
1090 if (error_name
) error (error_name
);
1096 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1098 /* Loop in Xt until the menu pulldown or dialog popup has been
1099 popped down (deactivated). This is used for x-popup-menu
1100 and x-popup-dialog; it is not used for the menu bar.
1102 If DO_TIMERS is nonzero, run timers.
1104 NOTE: All calls to popup_get_selection should be protected
1105 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1107 #ifdef USE_X_TOOLKIT
1109 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
1110 XEvent
*initial_event
;
1111 struct x_display_info
*dpyinfo
;
1117 while (popup_activated_flag
)
1119 /* If we have no events to run, consider timers. */
1120 if (do_timers
&& !XtAppPending (Xt_app_con
))
1125 event
= *initial_event
;
1129 XtAppNextEvent (Xt_app_con
, &event
);
1131 /* Make sure we don't consider buttons grabbed after menu goes.
1132 And make sure to deactivate for any ButtonRelease,
1133 even if XtDispatchEvent doesn't do that. */
1134 if (event
.type
== ButtonRelease
1135 && dpyinfo
->display
== event
.xbutton
.display
)
1137 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1138 #ifdef USE_MOTIF /* Pretending that the event came from a
1139 Btn1Down seems the only way to convince Motif to
1140 activate its callbacks; setting the XmNmenuPost
1141 isn't working. --marcus@sysc.pdx.edu. */
1142 event
.xbutton
.button
= 1;
1143 /* Motif only pops down menus when no Ctrl, Alt or Mod
1144 key is pressed and the button is released. So reset key state
1145 so Motif thinks this is the case. */
1146 event
.xbutton
.state
= 0;
1149 /* If the user presses a key, deactivate the menu.
1150 The user is likely to do that if we get wedged.
1151 This is mostly for Lucid, Motif pops down the menu on ESC. */
1152 else if (event
.type
== KeyPress
1153 && dpyinfo
->display
== event
.xbutton
.display
)
1155 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1156 if (!IsModifierKey (keysym
))
1157 popup_activated_flag
= 0;
1160 x_dispatch_event (&event
, event
.xany
.display
);
1164 #endif /* USE_X_TOOLKIT */
1167 /* Loop util popup_activated_flag is set to zero in a callback.
1168 Used for popup menus and dialogs. */
1170 popup_widget_loop ()
1172 ++popup_activated_flag
;
1174 /* Process events in the Gtk event loop until done. */
1175 while (popup_activated_flag
)
1177 gtk_main_iteration ();
1182 /* Activate the menu bar of frame F.
1183 This is called from keyboard.c when it gets the
1184 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
1186 To activate the menu bar, we use the X button-press event
1187 that was saved in saved_menu_event.
1188 That makes the toolkit do its thing.
1190 But first we recompute the menu bar contents (the whole tree).
1192 The reason for saving the button event until here, instead of
1193 passing it to the toolkit right away, is that we can safely
1194 execute Lisp code. */
1197 x_activate_menubar (f
)
1200 if (!f
->output_data
.x
->saved_menu_event
->type
)
1204 if (! xg_win_to_widget (f
->output_data
.x
->saved_menu_event
->xany
.window
))
1208 set_frame_menubar (f
, 0, 1);
1211 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
1212 f
->output_data
.x
->saved_menu_event
);
1213 popup_activated_flag
= 1;
1215 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
1219 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1220 pending_menu_activation
= 1;
1223 /* Ignore this if we get it a second time. */
1224 f
->output_data
.x
->saved_menu_event
->type
= 0;
1227 /* Detect if a dialog or menu has been posted. */
1232 return popup_activated_flag
;
1235 /* This callback is invoked when the user selects a menubar cascade
1236 pushbutton, but before the pulldown menu is posted. */
1240 popup_activate_callback (widget
, id
, client_data
)
1243 XtPointer client_data
;
1245 popup_activated_flag
= 1;
1249 /* This callback is invoked when a dialog or menu is finished being
1250 used and has been unposted. */
1254 popup_deactivate_callback (widget
, client_data
)
1256 gpointer client_data
;
1258 popup_activated_flag
= 0;
1262 popup_deactivate_callback (widget
, id
, client_data
)
1265 XtPointer client_data
;
1267 popup_activated_flag
= 0;
1272 /* Function that finds the frame for WIDGET and shows the HELP text
1274 F is the frame if known, or NULL if not known. */
1276 show_help_event (f
, widget
, help
)
1278 xt_or_gtk_widget widget
;
1285 XSETFRAME (frame
, f
);
1286 kbd_buffer_store_help_event (frame
, help
);
1290 /* WIDGET is the popup menu. It's parent is the frame's
1291 widget. See which frame that is. */
1292 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1295 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1297 frame
= XCAR (tail
);
1298 if (GC_FRAMEP (frame
)
1299 && (f
= XFRAME (frame
),
1300 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1304 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1308 /* Callback called when menu items are highlighted/unhighlighted
1309 while moving the mouse over them. WIDGET is the menu bar or menu
1310 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1311 the data structure for the menu item, or null in case of
1316 menu_highlight_callback (widget
, call_data
)
1320 xg_menu_item_cb_data
*cb_data
;
1323 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1325 if (! cb_data
) return;
1327 help
= call_data
? cb_data
->help
: Qnil
;
1329 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1330 Don't show help for them, they won't appear before the
1331 popup is popped down. */
1332 if (popup_activated_flag
<= 1)
1333 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1337 menu_highlight_callback (widget
, id
, call_data
)
1345 widget_value
*wv
= (widget_value
*) call_data
;
1347 help
= wv
? wv
->help
: Qnil
;
1349 /* Determine the frame for the help event. */
1350 f
= menubar_id_to_frame (id
);
1352 show_help_event (f
, widget
, help
);
1356 /* Find the menu selection and store it in the keyboard buffer.
1357 F is the frame the menu is on.
1358 MENU_BAR_ITEMS_USED is the length of VECTOR.
1359 VECTOR is an array of menu events for the whole menu.
1362 find_and_call_menu_selection (f
, menu_bar_items_used
, vector
, client_data
)
1364 int menu_bar_items_used
;
1368 Lisp_Object prefix
, entry
;
1369 Lisp_Object
*subprefix_stack
;
1370 int submenu_depth
= 0;
1374 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
1378 while (i
< menu_bar_items_used
)
1380 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1382 subprefix_stack
[submenu_depth
++] = prefix
;
1386 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1388 prefix
= subprefix_stack
[--submenu_depth
];
1391 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1393 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1394 i
+= MENU_ITEMS_PANE_LENGTH
;
1398 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1399 /* The EMACS_INT cast avoids a warning. There's no problem
1400 as long as pointers have enough bits to hold small integers. */
1401 if ((int) (EMACS_INT
) client_data
== i
)
1404 struct input_event buf
;
1407 XSETFRAME (frame
, f
);
1408 buf
.kind
= MENU_BAR_EVENT
;
1409 buf
.frame_or_window
= frame
;
1411 kbd_buffer_store_event (&buf
);
1413 for (j
= 0; j
< submenu_depth
; j
++)
1414 if (!NILP (subprefix_stack
[j
]))
1416 buf
.kind
= MENU_BAR_EVENT
;
1417 buf
.frame_or_window
= frame
;
1418 buf
.arg
= subprefix_stack
[j
];
1419 kbd_buffer_store_event (&buf
);
1424 buf
.kind
= MENU_BAR_EVENT
;
1425 buf
.frame_or_window
= frame
;
1427 kbd_buffer_store_event (&buf
);
1430 buf
.kind
= MENU_BAR_EVENT
;
1431 buf
.frame_or_window
= frame
;
1433 kbd_buffer_store_event (&buf
);
1437 i
+= MENU_ITEMS_ITEM_LENGTH
;
1444 /* Gtk calls callbacks just because we tell it what item should be
1445 selected in a radio group. If this variable is set to a non-zero
1446 value, we are creating menus and don't want callbacks right now.
1448 static int xg_crazy_callback_abort
;
1450 /* This callback is called from the menu bar pulldown menu
1451 when the user makes a selection.
1452 Figure out what the user chose
1453 and put the appropriate events into the keyboard buffer. */
1455 menubar_selection_callback (widget
, client_data
)
1457 gpointer client_data
;
1459 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1461 if (xg_crazy_callback_abort
)
1464 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1467 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1468 cb_data
->cl_data
->menu_bar_items_used
,
1469 cb_data
->cl_data
->menu_bar_vector
,
1470 cb_data
->call_data
);
1473 #else /* not USE_GTK */
1475 /* This callback is called from the menu bar pulldown menu
1476 when the user makes a selection.
1477 Figure out what the user chose
1478 and put the appropriate events into the keyboard buffer. */
1480 menubar_selection_callback (widget
, id
, client_data
)
1483 XtPointer client_data
;
1487 f
= menubar_id_to_frame (id
);
1490 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1491 f
->menu_bar_vector
, client_data
);
1493 #endif /* not USE_GTK */
1495 /* Allocate a widget_value, blocking input. */
1498 xmalloc_widget_value ()
1500 widget_value
*value
;
1503 value
= malloc_widget_value ();
1509 /* This recursively calls free_widget_value on the tree of widgets.
1510 It must free all data that was malloc'ed for these widget_values.
1511 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1512 must be left alone. */
1515 free_menubar_widget_value_tree (wv
)
1520 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1522 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1524 free_menubar_widget_value_tree (wv
->contents
);
1525 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1529 free_menubar_widget_value_tree (wv
->next
);
1530 wv
->next
= (widget_value
*) 0xDEADBEEF;
1533 free_widget_value (wv
);
1537 /* Set up data in menu_items for a menu bar item
1538 whose event type is ITEM_KEY (with string ITEM_NAME)
1539 and whose contents come from the list of keymaps MAPS. */
1542 parse_single_submenu (item_key
, item_name
, maps
)
1543 Lisp_Object item_key
, item_name
, maps
;
1547 Lisp_Object
*mapvec
;
1549 int top_level_items
= 0;
1551 length
= Flength (maps
);
1552 len
= XINT (length
);
1554 /* Convert the list MAPS into a vector MAPVEC. */
1555 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1556 for (i
= 0; i
< len
; i
++)
1558 mapvec
[i
] = Fcar (maps
);
1562 /* Loop over the given keymaps, making a pane for each map.
1563 But don't make a pane that is empty--ignore that map instead. */
1564 for (i
= 0; i
< len
; i
++)
1566 if (!KEYMAPP (mapvec
[i
]))
1568 /* Here we have a command at top level in the menu bar
1569 as opposed to a submenu. */
1570 top_level_items
= 1;
1571 push_menu_pane (Qnil
, Qnil
);
1572 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1573 Qnil
, Qnil
, Qnil
, Qnil
);
1578 prompt
= Fkeymap_prompt (mapvec
[i
]);
1579 single_keymap_panes (mapvec
[i
],
1580 !NILP (prompt
) ? prompt
: item_name
,
1585 return top_level_items
;
1588 /* Create a tree of widget_value objects
1589 representing the panes and items
1590 in menu_items starting at index START, up to index END. */
1592 static widget_value
*
1593 digest_single_submenu (start
, end
, top_level_items
)
1594 int start
, end
, top_level_items
;
1596 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1598 int submenu_depth
= 0;
1599 widget_value
**submenu_stack
;
1602 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1603 wv
= xmalloc_widget_value ();
1607 wv
->button_type
= BUTTON_TYPE_NONE
;
1613 /* Loop over all panes and items made by the preceding call
1614 to parse_single_submenu and construct a tree of widget_value objects.
1615 Ignore the panes and items used by previous calls to
1616 digest_single_submenu, even though those are also in menu_items. */
1620 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1622 submenu_stack
[submenu_depth
++] = save_wv
;
1627 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1630 save_wv
= submenu_stack
[--submenu_depth
];
1633 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1634 && submenu_depth
!= 0)
1635 i
+= MENU_ITEMS_PANE_LENGTH
;
1636 /* Ignore a nil in the item list.
1637 It's meaningful only for dialog boxes. */
1638 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1640 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1642 /* Create a new pane. */
1643 Lisp_Object pane_name
, prefix
;
1646 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1647 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1649 #ifndef HAVE_MULTILINGUAL_MENU
1650 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1652 pane_name
= ENCODE_SYSTEM (pane_name
);
1653 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
1656 pane_string
= (NILP (pane_name
)
1657 ? "" : (char *) SDATA (pane_name
));
1658 /* If there is just one top-level pane, put all its items directly
1659 under the top-level menu. */
1660 if (menu_items_n_panes
== 1)
1663 /* If the pane has a meaningful name,
1664 make the pane a top-level menu item
1665 with its items as a submenu beneath it. */
1666 if (strcmp (pane_string
, ""))
1668 wv
= xmalloc_widget_value ();
1672 first_wv
->contents
= wv
;
1673 wv
->name
= pane_string
;
1674 /* Ignore the @ that means "separate pane".
1675 This is a kludge, but this isn't worth more time. */
1676 if (!NILP (prefix
) && wv
->name
[0] == '@')
1680 wv
->button_type
= BUTTON_TYPE_NONE
;
1685 i
+= MENU_ITEMS_PANE_LENGTH
;
1689 /* Create a new item within current pane. */
1690 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1693 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1694 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1695 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1696 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1697 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1698 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1699 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1701 #ifndef HAVE_MULTILINGUAL_MENU
1702 if (STRING_MULTIBYTE (item_name
))
1704 item_name
= ENCODE_SYSTEM (item_name
);
1705 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
1708 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1710 descrip
= ENCODE_SYSTEM (descrip
);
1711 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
1713 #endif /* not HAVE_MULTILINGUAL_MENU */
1715 wv
= xmalloc_widget_value ();
1719 save_wv
->contents
= wv
;
1721 wv
->name
= (char *) SDATA (item_name
);
1722 if (!NILP (descrip
))
1723 wv
->key
= (char *) SDATA (descrip
);
1725 /* The EMACS_INT cast avoids a warning. There's no problem
1726 as long as pointers have enough bits to hold small integers. */
1727 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1728 wv
->enabled
= !NILP (enable
);
1731 wv
->button_type
= BUTTON_TYPE_NONE
;
1732 else if (EQ (type
, QCradio
))
1733 wv
->button_type
= BUTTON_TYPE_RADIO
;
1734 else if (EQ (type
, QCtoggle
))
1735 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1739 wv
->selected
= !NILP (selected
);
1740 if (! STRINGP (help
))
1747 i
+= MENU_ITEMS_ITEM_LENGTH
;
1751 /* If we have just one "menu item"
1752 that was originally a button, return it by itself. */
1753 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1755 wv
= first_wv
->contents
;
1756 free_widget_value (first_wv
);
1763 /* Recompute all the widgets of frame F, when the menu bar has been
1764 changed. Value is non-zero if widgets were updated. */
1767 update_frame_menubar (f
)
1771 return xg_update_frame_menubar (f
);
1773 struct x_output
*x
= f
->output_data
.x
;
1776 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1780 /* Save the size of the frame because the pane widget doesn't accept
1781 to resize itself. So force it. */
1785 /* Do the voodoo which means "I'm changing lots of things, don't try
1786 to refigure sizes until I'm done." */
1787 lw_refigure_widget (x
->column_widget
, False
);
1789 /* The order in which children are managed is the top to bottom
1790 order in which they are displayed in the paned window. First,
1791 remove the text-area widget. */
1792 XtUnmanageChild (x
->edit_widget
);
1794 /* Remove the menubar that is there now, and put up the menubar that
1796 XtManageChild (x
->menubar_widget
);
1797 XtMapWidget (x
->menubar_widget
);
1798 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1800 /* Re-manage the text-area widget, and then thrash the sizes. */
1801 XtManageChild (x
->edit_widget
);
1802 lw_refigure_widget (x
->column_widget
, True
);
1804 /* Force the pane widget to resize itself with the right values. */
1805 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1811 /* Set the contents of the menubar widgets of frame F.
1812 The argument FIRST_TIME is currently ignored;
1813 it is set the first time this is called, from initialize_frame_menubar. */
1816 set_frame_menubar (f
, first_time
, deep_p
)
1821 xt_or_gtk_widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1822 #ifdef USE_X_TOOLKIT
1826 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1828 int *submenu_start
, *submenu_end
;
1829 int *submenu_top_level_items
, *submenu_n_panes
;
1832 XSETFRAME (Vmenu_updating_frame
, f
);
1834 #ifdef USE_X_TOOLKIT
1835 if (f
->output_data
.x
->id
== 0)
1836 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1837 id
= f
->output_data
.x
->id
;
1840 if (! menubar_widget
)
1842 else if (pending_menu_activation
&& !deep_p
)
1844 /* Make the first call for any given frame always go deep. */
1845 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1848 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1849 f
->output_data
.x
->saved_menu_event
->type
= 0;
1854 /* Make a widget-value tree representing the entire menu trees. */
1856 struct buffer
*prev
= current_buffer
;
1858 int specpdl_count
= SPECPDL_INDEX ();
1859 int previous_menu_items_used
= f
->menu_bar_items_used
;
1860 Lisp_Object
*previous_items
1861 = (Lisp_Object
*) alloca (previous_menu_items_used
1862 * sizeof (Lisp_Object
));
1864 /* If we are making a new widget, its contents are empty,
1865 do always reinitialize them. */
1866 if (! menubar_widget
)
1867 previous_menu_items_used
= 0;
1869 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1870 specbind (Qinhibit_quit
, Qt
);
1871 /* Don't let the debugger step into this code
1872 because it is not reentrant. */
1873 specbind (Qdebug_on_next_call
, Qnil
);
1875 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1876 record_unwind_protect (unuse_menu_items
, Qnil
);
1877 if (NILP (Voverriding_local_map_menu_flag
))
1879 specbind (Qoverriding_terminal_local_map
, Qnil
);
1880 specbind (Qoverriding_local_map
, Qnil
);
1883 set_buffer_internal_1 (XBUFFER (buffer
));
1885 /* Run the Lucid hook. */
1886 safe_run_hooks (Qactivate_menubar_hook
);
1888 /* If it has changed current-menubar from previous value,
1889 really recompute the menubar from the value. */
1890 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1891 call0 (Qrecompute_lucid_menubar
);
1892 safe_run_hooks (Qmenu_bar_update_hook
);
1893 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1895 items
= FRAME_MENU_BAR_ITEMS (f
);
1897 /* Save the frame's previous menu bar contents data. */
1898 if (previous_menu_items_used
)
1899 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1900 previous_menu_items_used
* sizeof (Lisp_Object
));
1902 /* Fill in menu_items with the current menu bar contents.
1903 This can evaluate Lisp code. */
1904 menu_items
= f
->menu_bar_vector
;
1905 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1906 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1907 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1908 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1909 submenu_top_level_items
1910 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1912 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1914 Lisp_Object key
, string
, maps
;
1918 key
= XVECTOR (items
)->contents
[i
];
1919 string
= XVECTOR (items
)->contents
[i
+ 1];
1920 maps
= XVECTOR (items
)->contents
[i
+ 2];
1924 submenu_start
[i
] = menu_items_used
;
1926 menu_items_n_panes
= 0;
1927 submenu_top_level_items
[i
]
1928 = parse_single_submenu (key
, string
, maps
);
1929 submenu_n_panes
[i
] = menu_items_n_panes
;
1931 submenu_end
[i
] = menu_items_used
;
1934 finish_menu_items ();
1936 /* Convert menu_items into widget_value trees
1937 to display the menu. This cannot evaluate Lisp code. */
1939 wv
= xmalloc_widget_value ();
1940 wv
->name
= "menubar";
1943 wv
->button_type
= BUTTON_TYPE_NONE
;
1947 for (i
= 0; i
< last_i
; i
+= 4)
1949 menu_items_n_panes
= submenu_n_panes
[i
];
1950 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1951 submenu_top_level_items
[i
]);
1955 first_wv
->contents
= wv
;
1956 /* Don't set wv->name here; GC during the loop might relocate it. */
1958 wv
->button_type
= BUTTON_TYPE_NONE
;
1962 set_buffer_internal_1 (prev
);
1963 unbind_to (specpdl_count
, Qnil
);
1965 /* If there has been no change in the Lisp-level contents
1966 of the menu bar, skip redisplaying it. Just exit. */
1968 for (i
= 0; i
< previous_menu_items_used
; i
++)
1969 if (menu_items_used
== i
1970 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1972 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1974 free_menubar_widget_value_tree (first_wv
);
1975 discard_menu_items ();
1980 /* Now GC cannot happen during the lifetime of the widget_value,
1981 so it's safe to store data from a Lisp_String. */
1982 wv
= first_wv
->contents
;
1983 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1986 string
= XVECTOR (items
)->contents
[i
+ 1];
1989 wv
->name
= (char *) SDATA (string
);
1993 f
->menu_bar_vector
= menu_items
;
1994 f
->menu_bar_items_used
= menu_items_used
;
1995 discard_menu_items ();
1999 /* Make a widget-value tree containing
2000 just the top level menu bar strings. */
2002 wv
= xmalloc_widget_value ();
2003 wv
->name
= "menubar";
2006 wv
->button_type
= BUTTON_TYPE_NONE
;
2010 items
= FRAME_MENU_BAR_ITEMS (f
);
2011 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
2015 string
= XVECTOR (items
)->contents
[i
+ 1];
2019 wv
= xmalloc_widget_value ();
2020 wv
->name
= (char *) SDATA (string
);
2023 wv
->button_type
= BUTTON_TYPE_NONE
;
2025 /* This prevents lwlib from assuming this
2026 menu item is really supposed to be empty. */
2027 /* The EMACS_INT cast avoids a warning.
2028 This value just has to be different from small integers. */
2029 wv
->call_data
= (void *) (EMACS_INT
) (-1);
2034 first_wv
->contents
= wv
;
2038 /* Forget what we thought we knew about what is in the
2039 detailed contents of the menu bar menus.
2040 Changing the top level always destroys the contents. */
2041 f
->menu_bar_items_used
= 0;
2044 /* Create or update the menu bar widget. */
2049 xg_crazy_callback_abort
= 1;
2052 /* The third arg is DEEP_P, which says to consider the entire
2053 menu trees we supply, rather than just the menu bar item names. */
2054 xg_modify_menubar_widgets (menubar_widget
,
2058 G_CALLBACK (menubar_selection_callback
),
2059 G_CALLBACK (popup_deactivate_callback
),
2060 G_CALLBACK (menu_highlight_callback
));
2064 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
2067 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
2068 G_CALLBACK (menubar_selection_callback
),
2069 G_CALLBACK (popup_deactivate_callback
),
2070 G_CALLBACK (menu_highlight_callback
));
2072 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2076 #else /* not USE_GTK */
2079 /* Disable resizing (done for Motif!) */
2080 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
2082 /* The third arg is DEEP_P, which says to consider the entire
2083 menu trees we supply, rather than just the menu bar item names. */
2084 lw_modify_all_widgets (id
, first_wv
, deep_p
);
2086 /* Re-enable the edit widget to resize. */
2087 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
2091 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
2092 f
->output_data
.x
->column_widget
,
2094 popup_activate_callback
,
2095 menubar_selection_callback
,
2096 popup_deactivate_callback
,
2097 menu_highlight_callback
);
2098 f
->output_data
.x
->menubar_widget
= menubar_widget
;
2103 = (f
->output_data
.x
->menubar_widget
2104 ? (f
->output_data
.x
->menubar_widget
->core
.height
2105 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2108 #if 0 /* Experimentally, we now get the right results
2109 for -geometry -0-0 without this. 24 Aug 96, rms. */
2111 if (FRAME_EXTERNAL_MENU_BAR (f
))
2114 XtVaGetValues (f
->output_data
.x
->column_widget
,
2115 XtNinternalBorderWidth
, &ibw
, NULL
);
2116 menubar_size
+= ibw
;
2118 #endif /* USE_LUCID */
2121 f
->output_data
.x
->menubar_height
= menubar_size
;
2123 #endif /* not USE_GTK */
2125 free_menubar_widget_value_tree (first_wv
);
2126 update_frame_menubar (f
);
2129 xg_crazy_callback_abort
= 0;
2135 /* Called from Fx_create_frame to create the initial menubar of a frame
2136 before it is mapped, so that the window is mapped with the menubar already
2137 there instead of us tacking it on later and thrashing the window after it
2141 initialize_frame_menubar (f
)
2144 /* This function is called before the first chance to redisplay
2145 the frame. It has to be, so the frame will have the right size. */
2146 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
2147 set_frame_menubar (f
, 1, 1);
2151 /* Get rid of the menu bar of frame F, and free its storage.
2152 This is used when deleting a frame, and when turning off the menu bar.
2153 For GTK this function is in gtkutil.c. */
2157 free_frame_menubar (f
)
2160 Widget menubar_widget
;
2162 menubar_widget
= f
->output_data
.x
->menubar_widget
;
2164 f
->output_data
.x
->menubar_height
= 0;
2169 /* Removing the menu bar magically changes the shell widget's x
2170 and y position of (0, 0) which, when the menu bar is turned
2171 on again, leads to pull-down menuss appearing in strange
2172 positions near the upper-left corner of the display. This
2173 happens only with some window managers like twm and ctwm,
2174 but not with other like Motif's mwm or kwm, because the
2175 latter generate ConfigureNotify events when the menu bar
2176 is switched off, which fixes the shell position. */
2177 Position x0
, y0
, x1
, y1
;
2183 if (f
->output_data
.x
->widget
)
2184 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
2187 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
2188 f
->output_data
.x
->menubar_widget
= NULL
;
2191 if (f
->output_data
.x
->widget
)
2193 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
2194 if (x1
== 0 && y1
== 0)
2195 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
2202 #endif /* not USE_GTK */
2204 #endif /* USE_X_TOOLKIT || USE_GTK */
2206 /* xmenu_show actually displays a menu using the panes and items in menu_items
2207 and returns the value selected from it.
2208 There are two versions of xmenu_show, one for Xt and one for Xlib.
2209 Both assume input is blocked by the caller. */
2211 /* F is the frame the menu is for.
2212 X and Y are the frame-relative specified position,
2213 relative to the inside upper left corner of the frame F.
2214 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
2215 KEYMAPS is 1 if this menu was specified with keymaps;
2216 in that case, we return a list containing the chosen item's value
2217 and perhaps also the pane's prefix.
2218 TITLE is the specified menu title.
2219 ERROR is a place to store an error message string in case of failure.
2220 (We return nil on failure, but the value doesn't actually matter.) */
2222 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
2224 /* The item selected in the popup menu. */
2225 static Lisp_Object
*volatile menu_item_selection
;
2229 /* Used when position a popup menu. See menu_position_func and
2230 create_and_show_popup_menu below. */
2231 struct next_popup_x_y
2238 /* The menu position function to use if we are not putting a popup
2239 menu where the pointer is.
2240 MENU is the menu to pop up.
2241 X and Y shall on exit contain x/y where the menu shall pop up.
2242 PUSH_IN is not documented in the GTK manual.
2243 USER_DATA is any data passed in when calling gtk_menu_popup.
2244 Here it points to a struct next_popup_x_y where the coordinates
2245 to store in *X and *Y are as well as the frame for the popup.
2247 Here only X and Y are used. */
2249 menu_position_func (menu
, x
, y
, push_in
, user_data
)
2256 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
2258 int disp_width
= FRAME_X_DISPLAY_INFO (data
->f
)->width
;
2259 int disp_height
= FRAME_X_DISPLAY_INFO (data
->f
)->height
;
2264 /* Check if there is room for the menu. If not, adjust x/y so that
2265 the menu is fully visible. */
2266 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
2267 if (data
->x
+ req
.width
> disp_width
)
2268 *x
-= data
->x
+ req
.width
- disp_width
;
2269 if (data
->y
+ req
.height
> disp_height
)
2270 *y
-= data
->y
+ req
.height
- disp_height
;
2274 popup_selection_callback (widget
, client_data
)
2276 gpointer client_data
;
2278 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
2280 if (xg_crazy_callback_abort
) return;
2281 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
2284 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2286 menu_item_selection will be set to the selection. */
2288 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2290 widget_value
*first_wv
;
2297 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
2298 struct next_popup_x_y popup_x_y
;
2300 xg_crazy_callback_abort
= 1;
2301 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
2302 G_CALLBACK (popup_selection_callback
),
2303 G_CALLBACK (popup_deactivate_callback
),
2304 G_CALLBACK (menu_highlight_callback
));
2305 xg_crazy_callback_abort
= 0;
2307 for (i
= 0; i
< 5; i
++)
2308 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2313 /* Not invoked by a click. pop up at x/y. */
2314 pos_func
= menu_position_func
;
2316 /* Adjust coordinates to be root-window-relative. */
2317 x
+= f
->output_data
.x
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2318 y
+= f
->output_data
.x
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2325 /* Display the menu. */
2326 gtk_widget_show_all (menu
);
2327 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
2330 /* Set this to one. popup_widget_loop increases it by one, so it becomes
2331 two. show_help_echo uses this to detect popup menus. */
2332 popup_activated_flag
= 1;
2333 /* Process events that apply to the menu. */
2334 popup_widget_loop ();
2337 xg_keep_popup (menu
, xg_did_tearoff
);
2339 gtk_widget_destroy (menu
);
2341 /* Must reset this manually because the button release event is not passed
2342 to Emacs event loop. */
2343 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2346 #else /* not USE_GTK */
2348 /* We need a unique id for each widget handled by the Lucid Widget
2351 For the main windows, and popup menus, we use this counter,
2352 which we increment each time after use. This starts from 1<<16.
2354 For menu bars, we use numbers starting at 0, counted in
2355 next_menubar_widget_id. */
2356 LWLIB_ID widget_id_tick
;
2359 popup_selection_callback (widget
, id
, client_data
)
2362 XtPointer client_data
;
2364 menu_item_selection
= (Lisp_Object
*) client_data
;
2367 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
2369 menu_item_selection will be set to the selection. */
2371 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
2373 widget_value
*first_wv
;
2381 XButtonPressedEvent dummy
;
2386 menu_id
= widget_id_tick
++;
2387 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2388 f
->output_data
.x
->widget
, 1, 0,
2389 popup_selection_callback
,
2390 popup_deactivate_callback
,
2391 menu_highlight_callback
);
2393 dummy
.type
= ButtonPress
;
2395 dummy
.send_event
= 0;
2396 dummy
.display
= FRAME_X_DISPLAY (f
);
2397 dummy
.time
= CurrentTime
;
2398 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2399 dummy
.window
= dummy
.root
;
2400 dummy
.subwindow
= dummy
.root
;
2404 /* Adjust coordinates to be root-window-relative. */
2405 x
+= f
->output_data
.x
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2406 y
+= f
->output_data
.x
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2413 for (i
= 0; i
< 5; i
++)
2414 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2417 /* Don't allow any geometry request from the user. */
2418 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2419 XtSetValues (menu
, av
, ac
);
2421 /* Display the menu. */
2422 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2423 popup_activated_flag
= 1;
2425 /* Process events that apply to the menu. */
2426 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 0);
2428 /* fp turned off the following statement and wrote a comment
2429 that it is unnecessary--that the menu has already disappeared.
2430 Nowadays the menu disappears ok, all right, but
2431 we need to delete the widgets or multiple ones will pile up. */
2432 lw_destroy_all_widgets (menu_id
);
2435 #endif /* not USE_GTK */
2438 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2448 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2449 widget_value
**submenu_stack
2450 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
2451 Lisp_Object
*subprefix_stack
2452 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
2453 int submenu_depth
= 0;
2459 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2461 *error
= "Empty menu";
2465 /* Create a tree of widget_value objects
2466 representing the panes and their items. */
2467 wv
= xmalloc_widget_value ();
2471 wv
->button_type
= BUTTON_TYPE_NONE
;
2476 /* Loop over all panes and items, filling in the tree. */
2478 while (i
< menu_items_used
)
2480 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2482 submenu_stack
[submenu_depth
++] = save_wv
;
2488 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2491 save_wv
= submenu_stack
[--submenu_depth
];
2495 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2496 && submenu_depth
!= 0)
2497 i
+= MENU_ITEMS_PANE_LENGTH
;
2498 /* Ignore a nil in the item list.
2499 It's meaningful only for dialog boxes. */
2500 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2502 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2504 /* Create a new pane. */
2505 Lisp_Object pane_name
, prefix
;
2508 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2509 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2511 #ifndef HAVE_MULTILINGUAL_MENU
2512 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2514 pane_name
= ENCODE_SYSTEM (pane_name
);
2515 AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
) = pane_name
;
2518 pane_string
= (NILP (pane_name
)
2519 ? "" : (char *) SDATA (pane_name
));
2520 /* If there is just one top-level pane, put all its items directly
2521 under the top-level menu. */
2522 if (menu_items_n_panes
== 1)
2525 /* If the pane has a meaningful name,
2526 make the pane a top-level menu item
2527 with its items as a submenu beneath it. */
2528 if (!keymaps
&& strcmp (pane_string
, ""))
2530 wv
= xmalloc_widget_value ();
2534 first_wv
->contents
= wv
;
2535 wv
->name
= pane_string
;
2536 if (keymaps
&& !NILP (prefix
))
2540 wv
->button_type
= BUTTON_TYPE_NONE
;
2545 else if (first_pane
)
2551 i
+= MENU_ITEMS_PANE_LENGTH
;
2555 /* Create a new item within current pane. */
2556 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2557 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2558 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2559 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2560 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2561 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2562 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2563 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2565 #ifndef HAVE_MULTILINGUAL_MENU
2566 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2568 item_name
= ENCODE_SYSTEM (item_name
);
2569 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
) = item_name
;
2572 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2574 descrip
= ENCODE_SYSTEM (descrip
);
2575 AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
) = descrip
;
2577 #endif /* not HAVE_MULTILINGUAL_MENU */
2579 wv
= xmalloc_widget_value ();
2583 save_wv
->contents
= wv
;
2584 wv
->name
= (char *) SDATA (item_name
);
2585 if (!NILP (descrip
))
2586 wv
->key
= (char *) SDATA (descrip
);
2588 /* If this item has a null value,
2589 make the call_data null so that it won't display a box
2590 when the mouse is on it. */
2592 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2593 wv
->enabled
= !NILP (enable
);
2596 wv
->button_type
= BUTTON_TYPE_NONE
;
2597 else if (EQ (type
, QCtoggle
))
2598 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2599 else if (EQ (type
, QCradio
))
2600 wv
->button_type
= BUTTON_TYPE_RADIO
;
2604 wv
->selected
= !NILP (selected
);
2606 if (! STRINGP (help
))
2613 i
+= MENU_ITEMS_ITEM_LENGTH
;
2617 /* Deal with the title, if it is non-nil. */
2620 widget_value
*wv_title
= xmalloc_widget_value ();
2621 widget_value
*wv_sep1
= xmalloc_widget_value ();
2622 widget_value
*wv_sep2
= xmalloc_widget_value ();
2624 wv_sep2
->name
= "--";
2625 wv_sep2
->next
= first_wv
->contents
;
2626 wv_sep2
->help
= Qnil
;
2628 wv_sep1
->name
= "--";
2629 wv_sep1
->next
= wv_sep2
;
2630 wv_sep1
->help
= Qnil
;
2632 #ifndef HAVE_MULTILINGUAL_MENU
2633 if (STRING_MULTIBYTE (title
))
2634 title
= ENCODE_SYSTEM (title
);
2637 wv_title
->name
= (char *) SDATA (title
);
2638 wv_title
->enabled
= TRUE
;
2639 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2640 wv_title
->next
= wv_sep1
;
2641 wv_title
->help
= Qnil
;
2642 first_wv
->contents
= wv_title
;
2645 /* No selection has been chosen yet. */
2646 menu_item_selection
= 0;
2648 /* Actually create and show the menu until popped down. */
2649 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2651 /* Free the widget_value objects we used to specify the contents. */
2652 free_menubar_widget_value_tree (first_wv
);
2654 /* Find the selected item, and its pane, to return
2655 the proper value. */
2656 if (menu_item_selection
!= 0)
2658 Lisp_Object prefix
, entry
;
2660 prefix
= entry
= Qnil
;
2662 while (i
< menu_items_used
)
2664 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2666 subprefix_stack
[submenu_depth
++] = prefix
;
2670 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2672 prefix
= subprefix_stack
[--submenu_depth
];
2675 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2678 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2679 i
+= MENU_ITEMS_PANE_LENGTH
;
2681 /* Ignore a nil in the item list.
2682 It's meaningful only for dialog boxes. */
2683 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2688 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2689 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2695 entry
= Fcons (entry
, Qnil
);
2697 entry
= Fcons (prefix
, entry
);
2698 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2699 if (!NILP (subprefix_stack
[j
]))
2700 entry
= Fcons (subprefix_stack
[j
], entry
);
2704 i
+= MENU_ITEMS_ITEM_LENGTH
;
2714 dialog_selection_callback (widget
, client_data
)
2716 gpointer client_data
;
2718 /* The EMACS_INT cast avoids a warning. There's no problem
2719 as long as pointers have enough bits to hold small integers. */
2720 if ((int) (EMACS_INT
) client_data
!= -1)
2721 menu_item_selection
= (Lisp_Object
*) client_data
;
2723 popup_activated_flag
= 0;
2726 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2728 menu_item_selection will be set to the selection. */
2730 create_and_show_dialog (f
, first_wv
)
2732 widget_value
*first_wv
;
2736 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2737 G_CALLBACK (dialog_selection_callback
),
2738 G_CALLBACK (popup_deactivate_callback
),
2743 /* Display the menu. */
2744 gtk_widget_show_all (menu
);
2746 /* Process events that apply to the menu. */
2747 popup_widget_loop ();
2749 gtk_widget_destroy (menu
);
2753 #else /* not USE_GTK */
2755 dialog_selection_callback (widget
, id
, client_data
)
2758 XtPointer client_data
;
2760 /* The EMACS_INT cast avoids a warning. There's no problem
2761 as long as pointers have enough bits to hold small integers. */
2762 if ((int) (EMACS_INT
) client_data
!= -1)
2763 menu_item_selection
= (Lisp_Object
*) client_data
;
2766 lw_destroy_all_widgets (id
);
2768 popup_activated_flag
= 0;
2772 /* ARG is the LWLIB ID of the dialog box, represented
2773 as a Lisp object as (HIGHPART . LOWPART). */
2776 xdialog_show_unwind (arg
)
2779 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
2780 | XINT (XCDR (arg
)));
2782 lw_destroy_all_widgets (id
);
2784 popup_activated_flag
= 0;
2789 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2791 menu_item_selection will be set to the selection. */
2793 create_and_show_dialog (f
, first_wv
)
2795 widget_value
*first_wv
;
2799 dialog_id
= widget_id_tick
++;
2800 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2801 f
->output_data
.x
->widget
, 1, 0,
2802 dialog_selection_callback
, 0, 0);
2803 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2805 /* Display the dialog box. */
2806 lw_pop_up_all_widgets (dialog_id
);
2807 popup_activated_flag
= 1;
2809 /* Process events that apply to the dialog box.
2810 Also handle timers. */
2812 int count
= SPECPDL_INDEX ();
2813 int fact
= 4 * sizeof (LWLIB_ID
);
2815 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2816 record_unwind_protect (xdialog_show_unwind
,
2817 Fcons (make_number (dialog_id
>> (fact
)),
2818 make_number (dialog_id
& ~(-1 << (fact
)))));
2820 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
, 1);
2822 unbind_to (count
, Qnil
);
2826 #endif /* not USE_GTK */
2828 static char * button_names
[] = {
2829 "button1", "button2", "button3", "button4", "button5",
2830 "button6", "button7", "button8", "button9", "button10" };
2833 xdialog_show (f
, keymaps
, title
, error
)
2839 int i
, nb_buttons
=0;
2840 char dialog_name
[6];
2842 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2844 /* Number of elements seen so far, before boundary. */
2846 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2847 int boundary_seen
= 0;
2851 if (menu_items_n_panes
> 1)
2853 *error
= "Multiple panes in dialog box";
2857 /* Create a tree of widget_value objects
2858 representing the text label and buttons. */
2860 Lisp_Object pane_name
, prefix
;
2862 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2863 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2864 pane_string
= (NILP (pane_name
)
2865 ? "" : (char *) SDATA (pane_name
));
2866 prev_wv
= xmalloc_widget_value ();
2867 prev_wv
->value
= pane_string
;
2868 if (keymaps
&& !NILP (prefix
))
2870 prev_wv
->enabled
= 1;
2871 prev_wv
->name
= "message";
2872 prev_wv
->help
= Qnil
;
2875 /* Loop over all panes and items, filling in the tree. */
2876 i
= MENU_ITEMS_PANE_LENGTH
;
2877 while (i
< menu_items_used
)
2880 /* Create a new item within current pane. */
2881 Lisp_Object item_name
, enable
, descrip
;
2882 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2883 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2885 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2887 if (NILP (item_name
))
2889 free_menubar_widget_value_tree (first_wv
);
2890 *error
= "Submenu in dialog items";
2893 if (EQ (item_name
, Qquote
))
2895 /* This is the boundary between left-side elts
2896 and right-side elts. Stop incrementing right_count. */
2901 if (nb_buttons
>= 9)
2903 free_menubar_widget_value_tree (first_wv
);
2904 *error
= "Too many dialog items";
2908 wv
= xmalloc_widget_value ();
2910 wv
->name
= (char *) button_names
[nb_buttons
];
2911 if (!NILP (descrip
))
2912 wv
->key
= (char *) SDATA (descrip
);
2913 wv
->value
= (char *) SDATA (item_name
);
2914 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2915 wv
->enabled
= !NILP (enable
);
2919 if (! boundary_seen
)
2923 i
+= MENU_ITEMS_ITEM_LENGTH
;
2926 /* If the boundary was not specified,
2927 by default put half on the left and half on the right. */
2928 if (! boundary_seen
)
2929 left_count
= nb_buttons
- nb_buttons
/ 2;
2931 wv
= xmalloc_widget_value ();
2932 wv
->name
= dialog_name
;
2934 /* Dialog boxes use a really stupid name encoding
2935 which specifies how many buttons to use
2936 and how many buttons are on the right.
2937 The Q means something also. */
2938 dialog_name
[0] = 'Q';
2939 dialog_name
[1] = '0' + nb_buttons
;
2940 dialog_name
[2] = 'B';
2941 dialog_name
[3] = 'R';
2942 /* Number of buttons to put on the right. */
2943 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2945 wv
->contents
= first_wv
;
2949 /* No selection has been chosen yet. */
2950 menu_item_selection
= 0;
2952 /* Actually create and show the dialog. */
2953 create_and_show_dialog (f
, first_wv
);
2955 /* Free the widget_value objects we used to specify the contents. */
2956 free_menubar_widget_value_tree (first_wv
);
2958 /* Find the selected item, and its pane, to return
2959 the proper value. */
2960 if (menu_item_selection
!= 0)
2966 while (i
< menu_items_used
)
2970 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2973 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2974 i
+= MENU_ITEMS_PANE_LENGTH
;
2976 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2978 /* This is the boundary between left-side elts and
2985 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2986 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2990 entry
= Fcons (entry
, Qnil
);
2992 entry
= Fcons (prefix
, entry
);
2996 i
+= MENU_ITEMS_ITEM_LENGTH
;
3004 #else /* not USE_X_TOOLKIT && not USE_GTK */
3006 /* The frame of the last activated non-toolkit menu bar.
3007 Used to generate menu help events. */
3009 static struct frame
*menu_help_frame
;
3012 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3014 PANE is the pane number, and ITEM is the menu item number in
3015 the menu (currently not used).
3017 This cannot be done with generating a HELP_EVENT because
3018 XMenuActivate contains a loop that doesn't let Emacs process
3022 menu_help_callback (help_string
, pane
, item
)
3026 extern Lisp_Object Qmenu_item
;
3027 Lisp_Object
*first_item
;
3028 Lisp_Object pane_name
;
3029 Lisp_Object menu_object
;
3031 first_item
= XVECTOR (menu_items
)->contents
;
3032 if (EQ (first_item
[0], Qt
))
3033 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3034 else if (EQ (first_item
[0], Qquote
))
3035 /* This shouldn't happen, see xmenu_show. */
3036 pane_name
= empty_string
;
3038 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3040 /* (menu-item MENU-NAME PANE-NUMBER) */
3041 menu_object
= Fcons (Qmenu_item
,
3043 Fcons (make_number (pane
), Qnil
)));
3044 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3045 Qnil
, menu_object
, make_number (item
), 1);
3050 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
3060 int pane
, selidx
, lpane
, status
;
3061 Lisp_Object entry
, pane_prefix
;
3063 int ulx
, uly
, width
, height
;
3064 int dispwidth
, dispheight
;
3068 unsigned int dummy_uint
;
3071 if (menu_items_n_panes
== 0)
3074 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3076 *error
= "Empty menu";
3080 /* Figure out which root window F is on. */
3081 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
3082 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
3083 &dummy_uint
, &dummy_uint
);
3085 /* Make the menu on that window. */
3086 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
3089 *error
= "Can't create menu";
3093 #ifdef HAVE_X_WINDOWS
3094 /* Adjust coordinates to relative to the outer (window manager) window. */
3097 int win_x
= 0, win_y
= 0;
3099 /* Find the position of the outside upper-left corner of
3100 the inner window, with respect to the outer window. */
3101 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
3104 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
3106 /* From-window, to-window. */
3107 f
->output_data
.x
->window_desc
,
3108 f
->output_data
.x
->parent_desc
,
3110 /* From-position, to-position. */
3111 0, 0, &win_x
, &win_y
,
3113 /* Child of window. */
3120 #endif /* HAVE_X_WINDOWS */
3122 /* Adjust coordinates to be root-window-relative. */
3123 x
+= f
->output_data
.x
->left_pos
;
3124 y
+= f
->output_data
.x
->top_pos
;
3126 /* Create all the necessary panes and their items. */
3128 while (i
< menu_items_used
)
3130 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3132 /* Create a new pane. */
3133 Lisp_Object pane_name
, prefix
;
3136 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
3137 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3138 pane_string
= (NILP (pane_name
)
3139 ? "" : (char *) SDATA (pane_name
));
3140 if (keymaps
&& !NILP (prefix
))
3143 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
3144 if (lpane
== XM_FAILURE
)
3146 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3147 *error
= "Can't create pane";
3150 i
+= MENU_ITEMS_PANE_LENGTH
;
3152 /* Find the width of the widest item in this pane. */
3155 while (j
< menu_items_used
)
3158 item
= XVECTOR (menu_items
)->contents
[j
];
3166 width
= SBYTES (item
);
3167 if (width
> maxwidth
)
3170 j
+= MENU_ITEMS_ITEM_LENGTH
;
3173 /* Ignore a nil in the item list.
3174 It's meaningful only for dialog boxes. */
3175 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
3179 /* Create a new item within current pane. */
3180 Lisp_Object item_name
, enable
, descrip
, help
;
3181 unsigned char *item_data
;
3184 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
3185 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
3187 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
3188 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
3189 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
3191 if (!NILP (descrip
))
3193 int gap
= maxwidth
- SBYTES (item_name
);
3196 spacer
= Fmake_string (make_number (gap
), make_number (' '));
3197 item_name
= concat2 (item_name
, spacer
);
3198 item_name
= concat2 (item_name
, descrip
);
3199 item_data
= SDATA (item_name
);
3201 /* if alloca is fast, use that to make the space,
3202 to reduce gc needs. */
3204 = (unsigned char *) alloca (maxwidth
3205 + SBYTES (descrip
) + 1);
3206 bcopy (SDATA (item_name
), item_data
,
3207 SBYTES (item_name
));
3208 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3210 bcopy (SDATA (descrip
), item_data
+ j
,
3212 item_data
[j
+ SBYTES (descrip
)] = 0;
3216 item_data
= SDATA (item_name
);
3218 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
3219 menu
, lpane
, 0, item_data
,
3220 !NILP (enable
), help_string
)
3223 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3224 *error
= "Can't add selection to menu";
3227 i
+= MENU_ITEMS_ITEM_LENGTH
;
3231 /* All set and ready to fly. */
3232 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
3233 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3234 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
3235 x
= min (x
, dispwidth
);
3236 y
= min (y
, dispheight
);
3239 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
3240 &ulx
, &uly
, &width
, &height
);
3241 if (ulx
+width
> dispwidth
)
3243 x
-= (ulx
+ width
) - dispwidth
;
3244 ulx
= dispwidth
- width
;
3246 if (uly
+height
> dispheight
)
3248 y
-= (uly
+ height
) - dispheight
;
3249 uly
= dispheight
- height
;
3251 if (ulx
< 0) x
-= ulx
;
3252 if (uly
< 0) y
-= uly
;
3254 XMenuSetAEQ (menu
, TRUE
);
3255 XMenuSetFreeze (menu
, TRUE
);
3258 /* Help display under X won't work because XMenuActivate contains
3259 a loop that doesn't give Emacs a chance to process it. */
3260 menu_help_frame
= f
;
3261 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
3262 x
, y
, ButtonReleaseMask
, &datap
,
3263 menu_help_callback
);
3266 #ifdef HAVE_X_WINDOWS
3267 /* Assume the mouse has moved out of the X window.
3268 If it has actually moved in, we will get an EnterNotify. */
3269 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
3276 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
3279 /* Find the item number SELIDX in pane number PANE. */
3281 while (i
< menu_items_used
)
3283 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
3287 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
3289 i
+= MENU_ITEMS_PANE_LENGTH
;
3298 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
3301 entry
= Fcons (entry
, Qnil
);
3302 if (!NILP (pane_prefix
))
3303 entry
= Fcons (pane_prefix
, entry
);
3309 i
+= MENU_ITEMS_ITEM_LENGTH
;
3315 *error
= "Can't activate menu";
3321 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
3323 #ifdef HAVE_X_WINDOWS
3324 /* State that no mouse buttons are now held.
3325 (The oldXMenu code doesn't track this info for us.)
3326 That is not necessarily true, but the fiction leads to reasonable
3327 results, and it is a pain to ask which are actually held now. */
3328 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
3334 #endif /* not USE_X_TOOLKIT */
3336 #endif /* HAVE_MENUS */
3341 staticpro (&menu_items
);
3343 menu_items_inuse
= Qnil
;
3345 Qdebug_on_next_call
= intern ("debug-on-next-call");
3346 staticpro (&Qdebug_on_next_call
);
3348 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
3349 doc
: /* Frame for which we are updating a menu.
3350 The enable predicate for a menu command should check this variable. */);
3351 Vmenu_updating_frame
= Qnil
;
3353 #ifdef USE_X_TOOLKIT
3354 widget_id_tick
= (1<<16);
3355 next_menubar_widget_id
= 1;
3358 defsubr (&Sx_popup_menu
);
3360 defsubr (&Sx_popup_dialog
);