1 /* Platform-independent code for terminal communications.
3 Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2012
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #include <limits.h> /* for INT_MAX */
31 #include "termhooks.h"
32 #include "blockinput.h"
33 #include "dispextern.h"
36 #include "../lwlib/lwlib.h"
39 #ifdef HAVE_WINDOW_SYSTEM
41 #endif /* HAVE_WINDOW_SYSTEM */
45 # define unicode_append_menu AppendMenuW
46 # else /* !NTGUI_UNICODE */
47 extern AppendMenuW_Proc unicode_append_menu
;
48 # endif /* NTGUI_UNICODE */
49 extern HMENU current_popup_menu
;
50 #endif /* HAVE_NTGUI */
54 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
55 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NTGUI)
59 Lisp_Object menu_items
;
61 /* If non-nil, means that the global vars defined here are already in use.
62 Used to detect cases where we try to re-enter this non-reentrant code. */
63 #if ! (defined USE_GTK || defined USE_MOTIF)
66 Lisp_Object menu_items_inuse
;
68 /* Number of slots currently allocated in menu_items. */
69 int menu_items_allocated
;
71 /* This is the index in menu_items of the first empty slot. */
74 /* The number of panes currently recorded in menu_items,
75 excluding those within submenus. */
76 int menu_items_n_panes
;
78 /* Current depth within submenus. */
79 static int menu_items_submenu_depth
;
82 init_menu_items (void)
84 if (!NILP (menu_items_inuse
))
85 error ("Trying to use a menu from within a menu-entry");
87 if (NILP (menu_items
))
89 menu_items_allocated
= 60;
90 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
93 menu_items_inuse
= Qt
;
95 menu_items_n_panes
= 0;
96 menu_items_submenu_depth
= 0;
99 /* Call at the end of generating the data in menu_items. */
102 finish_menu_items (void)
107 unuse_menu_items (Lisp_Object dummy
)
109 return menu_items_inuse
= Qnil
;
112 /* Call when finished using the data for the current menu
116 discard_menu_items (void)
118 /* Free the structure if it is especially large.
119 Otherwise, hold on to it, to save time. */
120 if (menu_items_allocated
> 200)
123 menu_items_allocated
= 0;
125 eassert (NILP (menu_items_inuse
));
130 cleanup_popup_menu (Lisp_Object arg
)
132 discard_menu_items ();
137 /* This undoes save_menu_items, and it is called by the specpdl unwind
141 restore_menu_items (Lisp_Object saved
)
143 menu_items
= XCAR (saved
);
144 menu_items_inuse
= (! NILP (menu_items
) ? Qt
: Qnil
);
145 menu_items_allocated
= (VECTORP (menu_items
) ? ASIZE (menu_items
) : 0);
146 saved
= XCDR (saved
);
147 menu_items_used
= XINT (XCAR (saved
));
148 saved
= XCDR (saved
);
149 menu_items_n_panes
= XINT (XCAR (saved
));
150 saved
= XCDR (saved
);
151 menu_items_submenu_depth
= XINT (XCAR (saved
));
155 /* Push the whole state of menu_items processing onto the specpdl.
156 It will be restored when the specpdl is unwound. */
159 save_menu_items (void)
161 Lisp_Object saved
= list4 (!NILP (menu_items_inuse
) ? menu_items
: Qnil
,
162 make_number (menu_items_used
),
163 make_number (menu_items_n_panes
),
164 make_number (menu_items_submenu_depth
));
165 record_unwind_protect (restore_menu_items
, saved
);
166 menu_items_inuse
= Qnil
;
171 /* Ensure that there is room for ITEMS items in the menu_items vector. */
174 ensure_menu_items (int items
)
176 int incr
= items
- (menu_items_allocated
- menu_items_used
);
179 menu_items
= larger_vector (menu_items
, incr
, INT_MAX
);
180 menu_items_allocated
= ASIZE (menu_items
);
184 #if (defined USE_X_TOOLKIT || defined USE_GTK || defined HAVE_NS \
185 || defined HAVE_NTGUI)
187 /* Begin a submenu. */
190 push_submenu_start (void)
192 ensure_menu_items (1);
193 ASET (menu_items
, menu_items_used
, Qnil
);
195 menu_items_submenu_depth
++;
201 push_submenu_end (void)
203 ensure_menu_items (1);
204 ASET (menu_items
, menu_items_used
, Qlambda
);
206 menu_items_submenu_depth
--;
209 #endif /* USE_X_TOOLKIT || USE_GTK || HAVE_NS || defined HAVE_NTGUI */
211 /* Indicate boundary between left and right. */
214 push_left_right_boundary (void)
216 ensure_menu_items (1);
217 ASET (menu_items
, menu_items_used
, Qquote
);
221 /* Start a new menu pane in menu_items.
222 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
225 push_menu_pane (Lisp_Object name
, Lisp_Object prefix_vec
)
227 ensure_menu_items (MENU_ITEMS_PANE_LENGTH
);
228 if (menu_items_submenu_depth
== 0)
229 menu_items_n_panes
++;
230 ASET (menu_items
, menu_items_used
, Qt
);
232 ASET (menu_items
, menu_items_used
, name
);
234 ASET (menu_items
, menu_items_used
, prefix_vec
);
238 /* Push one menu item into the current pane. NAME is the string to
239 display. ENABLE if non-nil means this item can be selected. KEY
240 is the key generated by choosing this item, or nil if this item
241 doesn't really have a definition. DEF is the definition of this
242 item. EQUIV is the textual description of the keyboard equivalent
243 for this item (or nil if none). TYPE is the type of this menu
244 item, one of nil, `toggle' or `radio'. */
247 push_menu_item (Lisp_Object name
, Lisp_Object enable
, Lisp_Object key
, Lisp_Object def
, Lisp_Object equiv
, Lisp_Object type
, Lisp_Object selected
, Lisp_Object help
)
249 ensure_menu_items (MENU_ITEMS_ITEM_LENGTH
);
251 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_NAME
, name
);
252 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_ENABLE
, enable
);
253 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_VALUE
, key
);
254 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_EQUIV_KEY
, equiv
);
255 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_DEFINITION
, def
);
256 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_TYPE
, type
);
257 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_SELECTED
, selected
);
258 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_HELP
, help
);
260 menu_items_used
+= MENU_ITEMS_ITEM_LENGTH
;
263 /* Args passed between single_keymap_panes and single_menu_item. */
266 Lisp_Object pending_maps
;
271 static void single_menu_item (Lisp_Object
, Lisp_Object
, Lisp_Object
,
274 /* This is a recursive subroutine of keymap_panes.
275 It handles one keymap, KEYMAP.
276 The other arguments are passed along
277 or point to local variables of the previous function.
279 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
282 single_keymap_panes (Lisp_Object keymap
, Lisp_Object pane_name
,
283 Lisp_Object prefix
, int maxdepth
)
288 skp
.pending_maps
= Qnil
;
289 skp
.maxdepth
= maxdepth
;
295 push_menu_pane (pane_name
, prefix
);
298 /* Remember index for first item in this pane so we can go back and
299 add a prefix when (if) we see the first button. After that, notbuttons
300 is set to 0, to mark that we have seen a button and all non button
301 items need a prefix. */
302 skp
.notbuttons
= menu_items_used
;
305 GCPRO1 (skp
.pending_maps
);
306 map_keymap_canonical (keymap
, single_menu_item
, Qnil
, &skp
);
309 /* Process now any submenus which want to be panes at this level. */
310 while (CONSP (skp
.pending_maps
))
312 Lisp_Object elt
, eltcdr
, string
;
313 elt
= XCAR (skp
.pending_maps
);
315 string
= XCAR (eltcdr
);
316 /* We no longer discard the @ from the beginning of the string here.
317 Instead, we do this in *menu_show. */
318 single_keymap_panes (Fcar (elt
), string
, XCDR (eltcdr
), maxdepth
- 1);
319 skp
.pending_maps
= XCDR (skp
.pending_maps
);
323 /* This is a subroutine of single_keymap_panes that handles one
325 KEY is a key in a keymap and ITEM is its binding.
326 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
328 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them. */
331 single_menu_item (Lisp_Object key
, Lisp_Object item
, Lisp_Object dummy
, void *skp_v
)
333 Lisp_Object map
, item_string
, enabled
;
334 struct gcpro gcpro1
, gcpro2
;
336 struct skp
*skp
= skp_v
;
338 /* Parse the menu item and leave the result in item_properties. */
340 res
= parse_menu_item (item
, 0);
343 return; /* Not a menu item. */
345 map
= AREF (item_properties
, ITEM_PROPERTY_MAP
);
347 enabled
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
348 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
350 if (!NILP (map
) && SREF (item_string
, 0) == '@')
353 /* An enabled separate pane. Remember this to handle it later. */
354 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
359 #if defined (HAVE_X_WINDOWS) || defined (MSDOS)
361 /* Simulate radio buttons and toggle boxes by putting a prefix in
364 Lisp_Object prefix
= Qnil
;
365 Lisp_Object type
= AREF (item_properties
, ITEM_PROPERTY_TYPE
);
369 = AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
372 /* The first button. Line up previous items in this menu. */
374 int idx
= skp
->notbuttons
; /* Index for first item this menu. */
377 while (idx
< menu_items_used
)
380 = AREF (menu_items
, idx
+ MENU_ITEMS_ITEM_NAME
);
384 submenu
++; /* Skip sub menu. */
386 else if (EQ (tem
, Qlambda
))
389 submenu
--; /* End sub menu. */
391 else if (EQ (tem
, Qt
))
392 idx
+= 3; /* Skip new pane marker. */
393 else if (EQ (tem
, Qquote
))
394 idx
++; /* Skip a left, right divider. */
397 if (!submenu
&& SREF (tem
, 0) != '\0'
398 && SREF (tem
, 0) != '-')
399 ASET (menu_items
, idx
+ MENU_ITEMS_ITEM_NAME
,
400 concat2 (build_string (" "), tem
));
401 idx
+= MENU_ITEMS_ITEM_LENGTH
;
407 /* Calculate prefix, if any, for this item. */
408 if (EQ (type
, QCtoggle
))
409 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
410 else if (EQ (type
, QCradio
))
411 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
413 /* Not a button. If we have earlier buttons, then we need a prefix. */
414 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
415 && SREF (item_string
, 0) != '-')
416 prefix
= build_string (" ");
419 item_string
= concat2 (prefix
, item_string
);
421 #endif /* not HAVE_BOXES */
423 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
425 /* Indicate visually that this is a submenu. */
426 item_string
= concat2 (item_string
, build_string (" >"));
429 #endif /* HAVE_X_WINDOWS || MSDOS */
431 push_menu_item (item_string
, enabled
, key
,
432 AREF (item_properties
, ITEM_PROPERTY_DEF
),
433 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
),
434 AREF (item_properties
, ITEM_PROPERTY_TYPE
),
435 AREF (item_properties
, ITEM_PROPERTY_SELECTED
),
436 AREF (item_properties
, ITEM_PROPERTY_HELP
));
438 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
439 /* Display a submenu using the toolkit. */
440 if (! (NILP (map
) || NILP (enabled
)))
442 push_submenu_start ();
443 single_keymap_panes (map
, Qnil
, key
, skp
->maxdepth
- 1);
449 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
450 and generate menu panes for them in menu_items. */
453 keymap_panes (Lisp_Object
*keymaps
, ptrdiff_t nmaps
)
459 /* Loop over the given keymaps, making a pane for each map.
460 But don't make a pane that is empty--ignore that map instead.
461 P is the number of panes we have made so far. */
462 for (mapno
= 0; mapno
< nmaps
; mapno
++)
463 single_keymap_panes (keymaps
[mapno
],
464 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, 10);
466 finish_menu_items ();
470 /* Push the items in a single pane defined by the alist PANE. */
472 list_of_items (Lisp_Object pane
)
474 Lisp_Object tail
, item
, item1
;
476 for (tail
= pane
; CONSP (tail
); tail
= XCDR (tail
))
480 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
481 Qnil
, Qnil
, Qnil
, Qnil
);
482 else if (CONSP (item
))
485 CHECK_STRING (item1
);
486 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, XCDR (item
),
487 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
490 push_left_right_boundary ();
495 /* Push all the panes and items of a menu described by the
496 alist-of-alists MENU.
497 This handles old-fashioned calls to x-popup-menu. */
499 list_of_panes (Lisp_Object menu
)
505 for (tail
= menu
; CONSP (tail
); tail
= XCDR (tail
))
507 Lisp_Object elt
, pane_name
, pane_data
;
509 pane_name
= Fcar (elt
);
510 CHECK_STRING (pane_name
);
511 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
512 pane_data
= Fcdr (elt
);
513 CHECK_CONS (pane_data
);
514 list_of_items (pane_data
);
517 finish_menu_items ();
520 /* Set up data in menu_items for a menu bar item
521 whose event type is ITEM_KEY (with string ITEM_NAME)
522 and whose contents come from the list of keymaps MAPS. */
524 parse_single_submenu (Lisp_Object item_key
, Lisp_Object item_name
, Lisp_Object maps
)
530 int top_level_items
= 0;
533 length
= Flength (maps
);
536 /* Convert the list MAPS into a vector MAPVEC. */
537 SAFE_ALLOCA_LISP (mapvec
, len
);
538 for (i
= 0; i
< len
; i
++)
540 mapvec
[i
] = Fcar (maps
);
544 /* Loop over the given keymaps, making a pane for each map.
545 But don't make a pane that is empty--ignore that map instead. */
546 for (i
= 0; i
< len
; i
++)
548 if (!KEYMAPP (mapvec
[i
]))
550 /* Here we have a command at top level in the menu bar
551 as opposed to a submenu. */
553 push_menu_pane (Qnil
, Qnil
);
554 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
555 Qnil
, Qnil
, Qnil
, Qnil
);
560 prompt
= Fkeymap_prompt (mapvec
[i
]);
561 single_keymap_panes (mapvec
[i
],
562 !NILP (prompt
) ? prompt
: item_name
,
568 return top_level_items
;
572 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
574 /* Allocate a widget_value, blocking input. */
577 xmalloc_widget_value (void)
582 value
= malloc_widget_value ();
588 /* This recursively calls free_widget_value on the tree of widgets.
589 It must free all data that was malloc'ed for these widget_values.
590 In Emacs, many slots are pointers into the data of Lisp_Strings, and
591 must be left alone. */
594 free_menubar_widget_value_tree (widget_value
*wv
)
598 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
600 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
602 free_menubar_widget_value_tree (wv
->contents
);
603 wv
->contents
= (widget_value
*) 0xDEADBEEF;
607 free_menubar_widget_value_tree (wv
->next
);
608 wv
->next
= (widget_value
*) 0xDEADBEEF;
611 free_widget_value (wv
);
615 /* Create a tree of widget_value objects
616 representing the panes and items
617 in menu_items starting at index START, up to index END. */
620 digest_single_submenu (int start
, int end
, int top_level_items
)
622 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
624 int submenu_depth
= 0;
625 widget_value
**submenu_stack
;
628 submenu_stack
= alloca (menu_items_used
* sizeof *submenu_stack
);
629 wv
= xmalloc_widget_value ();
633 wv
->button_type
= BUTTON_TYPE_NONE
;
639 /* Loop over all panes and items made by the preceding call
640 to parse_single_submenu and construct a tree of widget_value objects.
641 Ignore the panes and items used by previous calls to
642 digest_single_submenu, even though those are also in menu_items. */
646 if (EQ (AREF (menu_items
, i
), Qnil
))
648 submenu_stack
[submenu_depth
++] = save_wv
;
653 else if (EQ (AREF (menu_items
, i
), Qlambda
))
656 save_wv
= submenu_stack
[--submenu_depth
];
659 else if (EQ (AREF (menu_items
, i
), Qt
)
660 && submenu_depth
!= 0)
661 i
+= MENU_ITEMS_PANE_LENGTH
;
662 /* Ignore a nil in the item list.
663 It's meaningful only for dialog boxes. */
664 else if (EQ (AREF (menu_items
, i
), Qquote
))
666 else if (EQ (AREF (menu_items
, i
), Qt
))
668 /* Create a new pane. */
669 Lisp_Object pane_name
;
670 const char *pane_string
;
674 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
677 if (STRINGP (pane_name
))
679 if (unicode_append_menu
)
680 /* Encode as UTF-8 for now. */
681 pane_name
= ENCODE_UTF_8 (pane_name
);
682 else if (STRING_MULTIBYTE (pane_name
))
683 pane_name
= ENCODE_SYSTEM (pane_name
);
685 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
687 #elif defined (USE_LUCID) && defined (HAVE_XFT)
688 if (STRINGP (pane_name
))
690 pane_name
= ENCODE_UTF_8 (pane_name
);
691 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
693 #elif !defined (HAVE_MULTILINGUAL_MENU)
694 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
696 pane_name
= ENCODE_MENU_STRING (pane_name
);
697 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
701 pane_string
= (NILP (pane_name
)
702 ? "" : SSDATA (pane_name
));
703 /* If there is just one top-level pane, put all its items directly
704 under the top-level menu. */
705 if (menu_items_n_panes
== 1)
708 /* If the pane has a meaningful name,
709 make the pane a top-level menu item
710 with its items as a submenu beneath it. */
711 if (strcmp (pane_string
, ""))
713 wv
= xmalloc_widget_value ();
717 first_wv
->contents
= wv
;
718 wv
->lname
= pane_name
;
719 /* Set value to 1 so update_submenu_strings can handle '@' */
720 wv
->value
= (char *)1;
722 wv
->button_type
= BUTTON_TYPE_NONE
;
730 i
+= MENU_ITEMS_PANE_LENGTH
;
734 /* Create a new item within current pane. */
735 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
738 /* All items should be contained in panes. */
742 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
743 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
744 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
745 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
746 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
747 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
748 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
751 if (STRINGP (item_name
))
753 if (unicode_append_menu
)
754 item_name
= ENCODE_UTF_8 (item_name
);
755 else if (STRING_MULTIBYTE (item_name
))
756 item_name
= ENCODE_SYSTEM (item_name
);
758 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
761 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
763 descrip
= ENCODE_SYSTEM (descrip
);
764 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
767 if (STRINGP (item_name
))
769 item_name
= ENCODE_UTF_8 (item_name
);
770 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
773 if (STRINGP (descrip
))
775 descrip
= ENCODE_UTF_8 (descrip
);
776 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
778 #elif !defined (HAVE_MULTILINGUAL_MENU)
779 if (STRING_MULTIBYTE (item_name
))
781 item_name
= ENCODE_MENU_STRING (item_name
);
782 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
785 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
787 descrip
= ENCODE_MENU_STRING (descrip
);
788 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
792 wv
= xmalloc_widget_value ();
796 save_wv
->contents
= wv
;
798 wv
->lname
= item_name
;
802 /* The intptr_t cast avoids a warning. There's no problem
803 as long as pointers have enough bits to hold small integers. */
804 wv
->call_data
= (!NILP (def
) ? (void *) (intptr_t) i
: 0);
805 wv
->enabled
= !NILP (enable
);
808 wv
->button_type
= BUTTON_TYPE_NONE
;
809 else if (EQ (type
, QCradio
))
810 wv
->button_type
= BUTTON_TYPE_RADIO
;
811 else if (EQ (type
, QCtoggle
))
812 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
816 wv
->selected
= !NILP (selected
);
817 if (! STRINGP (help
))
824 i
+= MENU_ITEMS_ITEM_LENGTH
;
828 /* If we have just one "menu item"
829 that was originally a button, return it by itself. */
830 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
832 wv
= first_wv
->contents
;
833 free_widget_value (first_wv
);
840 /* Walk through the widget_value tree starting at FIRST_WV and update
841 the char * pointers from the corresponding lisp values.
842 We do this after building the whole tree, since GC may happen while the
843 tree is constructed, and small strings are relocated. So we must wait
844 until no GC can happen before storing pointers into lisp values. */
846 update_submenu_strings (widget_value
*first_wv
)
850 for (wv
= first_wv
; wv
; wv
= wv
->next
)
852 if (STRINGP (wv
->lname
))
854 wv
->name
= SSDATA (wv
->lname
);
856 /* Ignore the @ that means "separate pane".
857 This is a kludge, but this isn't worth more time. */
858 if (wv
->value
== (char *)1)
860 if (wv
->name
[0] == '@')
866 if (STRINGP (wv
->lkey
))
867 wv
->key
= SSDATA (wv
->lkey
);
870 update_submenu_strings (wv
->contents
);
874 /* Find the menu selection and store it in the keyboard buffer.
875 F is the frame the menu is on.
876 MENU_BAR_ITEMS_USED is the length of VECTOR.
877 VECTOR is an array of menu events for the whole menu. */
880 find_and_call_menu_selection (FRAME_PTR f
, int menu_bar_items_used
, Lisp_Object vector
, void *client_data
)
882 Lisp_Object prefix
, entry
;
883 Lisp_Object
*subprefix_stack
;
884 int submenu_depth
= 0;
888 subprefix_stack
= alloca (menu_bar_items_used
* sizeof *subprefix_stack
);
892 while (i
< menu_bar_items_used
)
894 if (EQ (AREF (vector
, i
), Qnil
))
896 subprefix_stack
[submenu_depth
++] = prefix
;
900 else if (EQ (AREF (vector
, i
), Qlambda
))
902 prefix
= subprefix_stack
[--submenu_depth
];
905 else if (EQ (AREF (vector
, i
), Qt
))
907 prefix
= AREF (vector
, i
+ MENU_ITEMS_PANE_PREFIX
);
908 i
+= MENU_ITEMS_PANE_LENGTH
;
912 entry
= AREF (vector
, i
+ MENU_ITEMS_ITEM_VALUE
);
913 /* Treat the pointer as an integer. There's no problem
914 as long as pointers have enough bits to hold small integers. */
915 if ((intptr_t) client_data
== i
)
918 struct input_event buf
;
922 XSETFRAME (frame
, f
);
923 buf
.kind
= MENU_BAR_EVENT
;
924 buf
.frame_or_window
= frame
;
926 kbd_buffer_store_event (&buf
);
928 for (j
= 0; j
< submenu_depth
; j
++)
929 if (!NILP (subprefix_stack
[j
]))
931 buf
.kind
= MENU_BAR_EVENT
;
932 buf
.frame_or_window
= frame
;
933 buf
.arg
= subprefix_stack
[j
];
934 kbd_buffer_store_event (&buf
);
939 buf
.kind
= MENU_BAR_EVENT
;
940 buf
.frame_or_window
= frame
;
942 kbd_buffer_store_event (&buf
);
945 buf
.kind
= MENU_BAR_EVENT
;
946 buf
.frame_or_window
= frame
;
948 kbd_buffer_store_event (&buf
);
952 i
+= MENU_ITEMS_ITEM_LENGTH
;
957 #endif /* USE_X_TOOLKIT || USE_GTK || HAVE_NS || HAVE_NTGUI */
960 /* As above, but return the menu selection instead of storing in kb buffer.
961 If keymaps==1, return full prefixes to selection. */
963 find_and_return_menu_selection (FRAME_PTR f
, int keymaps
, void *client_data
)
965 Lisp_Object prefix
, entry
;
967 Lisp_Object
*subprefix_stack
;
968 int submenu_depth
= 0;
970 prefix
= entry
= Qnil
;
972 subprefix_stack
= alloca (menu_items_used
* word_size
);
974 while (i
< menu_items_used
)
976 if (EQ (AREF (menu_items
, i
), Qnil
))
978 subprefix_stack
[submenu_depth
++] = prefix
;
982 else if (EQ (AREF (menu_items
, i
), Qlambda
))
984 prefix
= subprefix_stack
[--submenu_depth
];
987 else if (EQ (AREF (menu_items
, i
), Qt
))
990 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
991 i
+= MENU_ITEMS_PANE_LENGTH
;
993 /* Ignore a nil in the item list.
994 It's meaningful only for dialog boxes. */
995 else if (EQ (AREF (menu_items
, i
), Qquote
))
1000 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
1001 if (aref_addr (menu_items
, i
) == client_data
)
1007 entry
= Fcons (entry
, Qnil
);
1009 entry
= Fcons (prefix
, entry
);
1010 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1011 if (!NILP (subprefix_stack
[j
]))
1012 entry
= Fcons (subprefix_stack
[j
], entry
);
1016 i
+= MENU_ITEMS_ITEM_LENGTH
;
1021 #endif /* HAVE_NS */
1023 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
1024 doc
: /* Pop up a deck-of-cards menu and return user's selection.
1025 POSITION is a position specification. This is either a mouse button event
1026 or a list ((XOFFSET YOFFSET) WINDOW)
1027 where XOFFSET and YOFFSET are positions in pixels from the top left
1028 corner of WINDOW. (WINDOW may be a window or a frame object.)
1029 This controls the position of the top left of the menu as a whole.
1030 If POSITION is t, it means to use the current mouse position.
1032 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
1033 The menu items come from key bindings that have a menu string as well as
1034 a definition; actually, the "definition" in such a key binding looks like
1035 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
1036 the keymap as a top-level element.
1038 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
1039 Otherwise, REAL-DEFINITION should be a valid key binding definition.
1041 You can also use a list of keymaps as MENU.
1042 Then each keymap makes a separate pane.
1044 When MENU is a keymap or a list of keymaps, the return value is the
1045 list of events corresponding to the user's choice. Note that
1046 `x-popup-menu' does not actually execute the command bound to that
1049 Alternatively, you can specify a menu of multiple panes
1050 with a list of the form (TITLE PANE1 PANE2...),
1051 where each pane is a list of form (TITLE ITEM1 ITEM2...).
1052 Each ITEM is normally a cons cell (STRING . VALUE);
1053 but a string can appear as an item--that makes a nonselectable line
1055 With this form of menu, the return value is VALUE from the chosen item.
1057 If POSITION is nil, don't display the menu at all, just precalculate the
1058 cached information about equivalent key sequences.
1060 If the user gets rid of the menu without making a valid choice, for
1061 instance by clicking the mouse away from a valid choice or by typing
1062 keyboard input, then this normally results in a quit and
1063 `x-popup-menu' does not return. But if POSITION is a mouse button
1064 event (indicating that the user invoked the menu with the mouse) then
1065 no quit occurs and `x-popup-menu' returns nil. */)
1066 (Lisp_Object position
, Lisp_Object menu
)
1068 Lisp_Object keymap
, tem
;
1069 int xpos
= 0, ypos
= 0;
1071 const char *error_name
= NULL
;
1072 Lisp_Object selection
= Qnil
;
1074 Lisp_Object x
, y
, window
;
1077 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1078 struct gcpro gcpro1
;
1080 if (NILP (position
))
1081 /* This is an obsolete call, which wants us to precompute the
1082 keybinding equivalents, but we don't do that any more anyway. */
1087 int get_current_pos_p
= 0;
1088 /* FIXME!! check_w32 (); or check_x (); or check_ns (); */
1090 /* Decode the first argument: find the window and the coordinates. */
1091 if (EQ (position
, Qt
)
1092 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1093 || EQ (XCAR (position
), Qtool_bar
))))
1095 get_current_pos_p
= 1;
1099 tem
= Fcar (position
);
1102 window
= Fcar (Fcdr (position
));
1104 y
= Fcar (XCDR (tem
));
1109 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1110 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1111 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
1116 /* If a click happens in an external tool bar or a detached
1117 tool bar, x and y is NIL. In that case, use the current
1118 mouse position. This happens for the help button in the
1119 tool bar. Ideally popup-menu should pass NIL to
1120 this function, but it doesn't. */
1121 if (NILP (x
) && NILP (y
))
1122 get_current_pos_p
= 1;
1125 if (get_current_pos_p
)
1127 /* Use the mouse's current position. */
1128 FRAME_PTR new_f
= SELECTED_FRAME ();
1129 #ifdef HAVE_X_WINDOWS
1130 /* Can't use mouse_position_hook for X since it returns
1131 coordinates relative to the window the mouse is in,
1132 we need coordinates relative to the edit widget always. */
1137 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
1138 /* cur_x/y may be negative, so use make_number. */
1139 x
= make_number (cur_x
);
1140 y
= make_number (cur_y
);
1143 #else /* not HAVE_X_WINDOWS */
1144 Lisp_Object bar_window
;
1145 enum scroll_bar_part part
;
1147 void (*mouse_position_hook
) (struct frame
**, int,
1149 enum scroll_bar_part
*,
1153 FRAME_TERMINAL (new_f
)->mouse_position_hook
;
1155 if (mouse_position_hook
)
1156 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
1157 &part
, &x
, &y
, &time
);
1158 #endif /* not HAVE_X_WINDOWS */
1161 XSETFRAME (window
, new_f
);
1164 window
= selected_window
;
1170 /* Decode where to put the menu. */
1172 if (FRAMEP (window
))
1174 f
= XFRAME (window
);
1178 else if (WINDOWP (window
))
1180 struct window
*win
= XWINDOW (window
);
1181 CHECK_LIVE_WINDOW (window
);
1182 f
= XFRAME (WINDOW_FRAME (win
));
1184 xpos
= WINDOW_LEFT_EDGE_X (win
);
1185 ypos
= WINDOW_TOP_EDGE_Y (win
);
1188 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1189 but I don't want to make one now. */
1190 CHECK_WINDOW (window
);
1192 CHECK_RANGED_INTEGER (x
,
1193 (xpos
< INT_MIN
- MOST_NEGATIVE_FIXNUM
1194 ? (EMACS_INT
) INT_MIN
- xpos
1195 : MOST_NEGATIVE_FIXNUM
),
1197 CHECK_RANGED_INTEGER (y
,
1198 (ypos
< INT_MIN
- MOST_NEGATIVE_FIXNUM
1199 ? (EMACS_INT
) INT_MIN
- ypos
1200 : MOST_NEGATIVE_FIXNUM
),
1205 /* FIXME: Find a more general check! */
1206 if (!(FRAME_X_P (f
) || FRAME_MSDOS_P (f
)
1207 || FRAME_W32_P (f
) || FRAME_NS_P (f
)))
1208 error ("Can not put GUI menu on this terminal");
1210 XSETFRAME (Vmenu_updating_frame
, f
);
1212 #endif /* HAVE_MENUS */
1214 /* Now parse the lisp menus. */
1215 record_unwind_protect (unuse_menu_items
, Qnil
);
1220 /* Decode the menu items from what was specified. */
1222 keymap
= get_keymap (menu
, 0, 0);
1225 /* We were given a keymap. Extract menu info from the keymap. */
1228 /* Extract the detailed info to make one pane. */
1229 keymap_panes (&menu
, 1);
1231 /* Search for a string appearing directly as an element of the keymap.
1232 That string is the title of the menu. */
1233 prompt
= Fkeymap_prompt (keymap
);
1236 #ifdef HAVE_NS /* Is that needed and NS-specific? --Stef */
1238 title
= build_string ("Select");
1241 /* Make that be the pane title of the first pane. */
1242 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
1243 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, prompt
);
1247 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
1249 /* We were given a list of keymaps. */
1250 EMACS_INT nmaps
= XFASTINT (Flength (menu
));
1255 SAFE_ALLOCA_LISP (maps
, nmaps
);
1258 /* The first keymap that has a prompt string
1259 supplies the menu title. */
1260 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
1264 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
1266 prompt
= Fkeymap_prompt (keymap
);
1267 if (NILP (title
) && !NILP (prompt
))
1271 /* Extract the detailed info to make one pane. */
1272 keymap_panes (maps
, nmaps
);
1274 /* Make the title be the pane title of the first pane. */
1275 if (!NILP (title
) && menu_items_n_panes
>= 0)
1276 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, title
);
1284 /* We were given an old-fashioned menu. */
1285 title
= Fcar (menu
);
1286 CHECK_STRING (title
);
1288 list_of_panes (Fcdr (menu
));
1293 unbind_to (specpdl_count
, Qnil
);
1296 #ifdef HAVE_WINDOW_SYSTEM
1297 /* Hide a previous tip, if any. */
1301 #ifdef HAVE_NTGUI /* FIXME: Is it really w32-specific? --Stef */
1302 /* If resources from a previous popup menu still exist, does nothing
1303 until the `menu_free_timer' has freed them (see w32fns.c). This
1304 can occur if you press ESC or click outside a menu without selecting
1307 if (current_popup_menu
)
1309 discard_menu_items ();
1310 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1316 #ifdef HAVE_NS /* FIXME: ns-specific, why? --Stef */
1317 record_unwind_protect (cleanup_popup_menu
, Qnil
);
1320 /* Display them in a menu. */
1323 /* FIXME: Use a terminal hook! */
1324 #if defined HAVE_NTGUI
1325 selection
= w32_menu_show (f
, xpos
, ypos
, for_click
,
1326 keymaps
, title
, &error_name
);
1327 #elif defined HAVE_NS
1328 selection
= ns_menu_show (f
, xpos
, ypos
, for_click
,
1329 keymaps
, title
, &error_name
);
1330 #else /* MSDOS and X11 */
1331 /* Assume last_event_timestamp is the timestamp of the button event.
1332 Is this assumption ever violated? We can't use the timestamp
1333 stored within POSITION because there the top bits from the actual
1334 timestamp may be truncated away (Bug#4930). */
1335 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
1336 keymaps
, title
, &error_name
,
1337 last_event_timestamp
);
1343 unbind_to (specpdl_count
, Qnil
);
1345 discard_menu_items ();
1348 #ifdef HAVE_NTGUI /* FIXME: Is it really w32-specific? --Stef */
1349 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1352 #endif /* HAVE_MENUS */
1356 if (error_name
) error ("%s", error_name
);
1363 staticpro (&menu_items
);
1365 menu_items_inuse
= Qnil
;
1367 defsubr (&Sx_popup_menu
);