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"
54 extern AppendMenuW_Proc unicode_append_menu
;
55 extern HMENU current_popup_menu
;
57 #endif /* HAVE_NTGUI */
61 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
62 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NTGUI)
66 Lisp_Object menu_items
;
68 /* If non-nil, means that the global vars defined here are already in use.
69 Used to detect cases where we try to re-enter this non-reentrant code. */
70 #if ! (defined USE_GTK || defined USE_MOTIF)
73 Lisp_Object menu_items_inuse
;
75 /* Number of slots currently allocated in menu_items. */
76 int menu_items_allocated
;
78 /* This is the index in menu_items of the first empty slot. */
81 /* The number of panes currently recorded in menu_items,
82 excluding those within submenus. */
83 int menu_items_n_panes
;
85 /* Current depth within submenus. */
86 static int menu_items_submenu_depth
;
89 init_menu_items (void)
91 if (!NILP (menu_items_inuse
))
92 error ("Trying to use a menu from within a menu-entry");
94 if (NILP (menu_items
))
96 menu_items_allocated
= 60;
97 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
100 menu_items_inuse
= Qt
;
102 menu_items_n_panes
= 0;
103 menu_items_submenu_depth
= 0;
106 /* Call at the end of generating the data in menu_items. */
109 finish_menu_items (void)
114 unuse_menu_items (Lisp_Object dummy
)
116 return menu_items_inuse
= Qnil
;
119 /* Call when finished using the data for the current menu
123 discard_menu_items (void)
125 /* Free the structure if it is especially large.
126 Otherwise, hold on to it, to save time. */
127 if (menu_items_allocated
> 200)
130 menu_items_allocated
= 0;
132 eassert (NILP (menu_items_inuse
));
137 cleanup_popup_menu (Lisp_Object arg
)
139 discard_menu_items ();
144 /* This undoes save_menu_items, and it is called by the specpdl unwind
148 restore_menu_items (Lisp_Object saved
)
150 menu_items
= XCAR (saved
);
151 menu_items_inuse
= (! NILP (menu_items
) ? Qt
: Qnil
);
152 menu_items_allocated
= (VECTORP (menu_items
) ? ASIZE (menu_items
) : 0);
153 saved
= XCDR (saved
);
154 menu_items_used
= XINT (XCAR (saved
));
155 saved
= XCDR (saved
);
156 menu_items_n_panes
= XINT (XCAR (saved
));
157 saved
= XCDR (saved
);
158 menu_items_submenu_depth
= XINT (XCAR (saved
));
162 /* Push the whole state of menu_items processing onto the specpdl.
163 It will be restored when the specpdl is unwound. */
166 save_menu_items (void)
168 Lisp_Object saved
= list4 (!NILP (menu_items_inuse
) ? menu_items
: Qnil
,
169 make_number (menu_items_used
),
170 make_number (menu_items_n_panes
),
171 make_number (menu_items_submenu_depth
));
172 record_unwind_protect (restore_menu_items
, saved
);
173 menu_items_inuse
= Qnil
;
178 /* Ensure that there is room for ITEMS items in the menu_items vector. */
181 ensure_menu_items (int items
)
183 int incr
= items
- (menu_items_allocated
- menu_items_used
);
186 menu_items
= larger_vector (menu_items
, incr
, INT_MAX
);
187 menu_items_allocated
= ASIZE (menu_items
);
191 #if (defined USE_X_TOOLKIT || defined USE_GTK || defined HAVE_NS \
192 || defined HAVE_NTGUI)
194 /* Begin a submenu. */
197 push_submenu_start (void)
199 ensure_menu_items (1);
200 ASET (menu_items
, menu_items_used
, Qnil
);
202 menu_items_submenu_depth
++;
208 push_submenu_end (void)
210 ensure_menu_items (1);
211 ASET (menu_items
, menu_items_used
, Qlambda
);
213 menu_items_submenu_depth
--;
216 #endif /* USE_X_TOOLKIT || USE_GTK || HAVE_NS || defined HAVE_NTGUI */
218 /* Indicate boundary between left and right. */
221 push_left_right_boundary (void)
223 ensure_menu_items (1);
224 ASET (menu_items
, menu_items_used
, Qquote
);
228 /* Start a new menu pane in menu_items.
229 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
232 push_menu_pane (Lisp_Object name
, Lisp_Object prefix_vec
)
234 ensure_menu_items (MENU_ITEMS_PANE_LENGTH
);
235 if (menu_items_submenu_depth
== 0)
236 menu_items_n_panes
++;
237 ASET (menu_items
, menu_items_used
, Qt
);
239 ASET (menu_items
, menu_items_used
, name
);
241 ASET (menu_items
, menu_items_used
, prefix_vec
);
245 /* Push one menu item into the current pane. NAME is the string to
246 display. ENABLE if non-nil means this item can be selected. KEY
247 is the key generated by choosing this item, or nil if this item
248 doesn't really have a definition. DEF is the definition of this
249 item. EQUIV is the textual description of the keyboard equivalent
250 for this item (or nil if none). TYPE is the type of this menu
251 item, one of nil, `toggle' or `radio'. */
254 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
)
256 ensure_menu_items (MENU_ITEMS_ITEM_LENGTH
);
258 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_NAME
, name
);
259 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_ENABLE
, enable
);
260 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_VALUE
, key
);
261 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_EQUIV_KEY
, equiv
);
262 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_DEFINITION
, def
);
263 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_TYPE
, type
);
264 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_SELECTED
, selected
);
265 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_HELP
, help
);
267 menu_items_used
+= MENU_ITEMS_ITEM_LENGTH
;
270 /* Args passed between single_keymap_panes and single_menu_item. */
273 Lisp_Object pending_maps
;
278 static void single_menu_item (Lisp_Object
, Lisp_Object
, Lisp_Object
,
281 /* This is a recursive subroutine of keymap_panes.
282 It handles one keymap, KEYMAP.
283 The other arguments are passed along
284 or point to local variables of the previous function.
286 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
289 single_keymap_panes (Lisp_Object keymap
, Lisp_Object pane_name
,
290 Lisp_Object prefix
, int maxdepth
)
295 skp
.pending_maps
= Qnil
;
296 skp
.maxdepth
= maxdepth
;
302 push_menu_pane (pane_name
, prefix
);
305 /* Remember index for first item in this pane so we can go back and
306 add a prefix when (if) we see the first button. After that, notbuttons
307 is set to 0, to mark that we have seen a button and all non button
308 items need a prefix. */
309 skp
.notbuttons
= menu_items_used
;
312 GCPRO1 (skp
.pending_maps
);
313 map_keymap_canonical (keymap
, single_menu_item
, Qnil
, &skp
);
316 /* Process now any submenus which want to be panes at this level. */
317 while (CONSP (skp
.pending_maps
))
319 Lisp_Object elt
, eltcdr
, string
;
320 elt
= XCAR (skp
.pending_maps
);
322 string
= XCAR (eltcdr
);
323 /* We no longer discard the @ from the beginning of the string here.
324 Instead, we do this in *menu_show. */
325 single_keymap_panes (Fcar (elt
), string
, XCDR (eltcdr
), maxdepth
- 1);
326 skp
.pending_maps
= XCDR (skp
.pending_maps
);
330 /* This is a subroutine of single_keymap_panes that handles one
332 KEY is a key in a keymap and ITEM is its binding.
333 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
335 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them. */
338 single_menu_item (Lisp_Object key
, Lisp_Object item
, Lisp_Object dummy
, void *skp_v
)
340 Lisp_Object map
, item_string
, enabled
;
341 struct gcpro gcpro1
, gcpro2
;
343 struct skp
*skp
= skp_v
;
345 /* Parse the menu item and leave the result in item_properties. */
347 res
= parse_menu_item (item
, 0);
350 return; /* Not a menu item. */
352 map
= AREF (item_properties
, ITEM_PROPERTY_MAP
);
354 enabled
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
355 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
357 if (!NILP (map
) && SREF (item_string
, 0) == '@')
360 /* An enabled separate pane. Remember this to handle it later. */
361 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
366 #if defined (HAVE_X_WINDOWS) || defined (MSDOS)
368 /* Simulate radio buttons and toggle boxes by putting a prefix in
371 Lisp_Object prefix
= Qnil
;
372 Lisp_Object type
= AREF (item_properties
, ITEM_PROPERTY_TYPE
);
376 = AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
379 /* The first button. Line up previous items in this menu. */
381 int idx
= skp
->notbuttons
; /* Index for first item this menu. */
384 while (idx
< menu_items_used
)
387 = AREF (menu_items
, idx
+ MENU_ITEMS_ITEM_NAME
);
391 submenu
++; /* Skip sub menu. */
393 else if (EQ (tem
, Qlambda
))
396 submenu
--; /* End sub menu. */
398 else if (EQ (tem
, Qt
))
399 idx
+= 3; /* Skip new pane marker. */
400 else if (EQ (tem
, Qquote
))
401 idx
++; /* Skip a left, right divider. */
404 if (!submenu
&& SREF (tem
, 0) != '\0'
405 && SREF (tem
, 0) != '-')
406 ASET (menu_items
, idx
+ MENU_ITEMS_ITEM_NAME
,
407 concat2 (build_string (" "), tem
));
408 idx
+= MENU_ITEMS_ITEM_LENGTH
;
414 /* Calculate prefix, if any, for this item. */
415 if (EQ (type
, QCtoggle
))
416 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
417 else if (EQ (type
, QCradio
))
418 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
420 /* Not a button. If we have earlier buttons, then we need a prefix. */
421 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
422 && SREF (item_string
, 0) != '-')
423 prefix
= build_string (" ");
426 item_string
= concat2 (prefix
, item_string
);
428 #endif /* not HAVE_BOXES */
430 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
432 /* Indicate visually that this is a submenu. */
433 item_string
= concat2 (item_string
, build_string (" >"));
436 #endif /* HAVE_X_WINDOWS || MSDOS */
438 push_menu_item (item_string
, enabled
, key
,
439 AREF (item_properties
, ITEM_PROPERTY_DEF
),
440 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
),
441 AREF (item_properties
, ITEM_PROPERTY_TYPE
),
442 AREF (item_properties
, ITEM_PROPERTY_SELECTED
),
443 AREF (item_properties
, ITEM_PROPERTY_HELP
));
445 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
446 /* Display a submenu using the toolkit. */
447 if (! (NILP (map
) || NILP (enabled
)))
449 push_submenu_start ();
450 single_keymap_panes (map
, Qnil
, key
, skp
->maxdepth
- 1);
456 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
457 and generate menu panes for them in menu_items. */
460 keymap_panes (Lisp_Object
*keymaps
, ptrdiff_t nmaps
)
466 /* Loop over the given keymaps, making a pane for each map.
467 But don't make a pane that is empty--ignore that map instead.
468 P is the number of panes we have made so far. */
469 for (mapno
= 0; mapno
< nmaps
; mapno
++)
470 single_keymap_panes (keymaps
[mapno
],
471 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, 10);
473 finish_menu_items ();
477 /* Push the items in a single pane defined by the alist PANE. */
479 list_of_items (Lisp_Object pane
)
481 Lisp_Object tail
, item
, item1
;
483 for (tail
= pane
; CONSP (tail
); tail
= XCDR (tail
))
487 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
488 Qnil
, Qnil
, Qnil
, Qnil
);
489 else if (CONSP (item
))
492 CHECK_STRING (item1
);
493 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, XCDR (item
),
494 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
497 push_left_right_boundary ();
502 /* Push all the panes and items of a menu described by the
503 alist-of-alists MENU.
504 This handles old-fashioned calls to x-popup-menu. */
506 list_of_panes (Lisp_Object menu
)
512 for (tail
= menu
; CONSP (tail
); tail
= XCDR (tail
))
514 Lisp_Object elt
, pane_name
, pane_data
;
516 pane_name
= Fcar (elt
);
517 CHECK_STRING (pane_name
);
518 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
519 pane_data
= Fcdr (elt
);
520 CHECK_CONS (pane_data
);
521 list_of_items (pane_data
);
524 finish_menu_items ();
527 /* Set up data in menu_items for a menu bar item
528 whose event type is ITEM_KEY (with string ITEM_NAME)
529 and whose contents come from the list of keymaps MAPS. */
531 parse_single_submenu (Lisp_Object item_key
, Lisp_Object item_name
, Lisp_Object maps
)
537 int top_level_items
= 0;
540 length
= Flength (maps
);
543 /* Convert the list MAPS into a vector MAPVEC. */
544 SAFE_ALLOCA_LISP (mapvec
, len
);
545 for (i
= 0; i
< len
; i
++)
547 mapvec
[i
] = Fcar (maps
);
551 /* Loop over the given keymaps, making a pane for each map.
552 But don't make a pane that is empty--ignore that map instead. */
553 for (i
= 0; i
< len
; i
++)
555 if (!KEYMAPP (mapvec
[i
]))
557 /* Here we have a command at top level in the menu bar
558 as opposed to a submenu. */
560 push_menu_pane (Qnil
, Qnil
);
561 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
562 Qnil
, Qnil
, Qnil
, Qnil
);
567 prompt
= Fkeymap_prompt (mapvec
[i
]);
568 single_keymap_panes (mapvec
[i
],
569 !NILP (prompt
) ? prompt
: item_name
,
575 return top_level_items
;
579 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
581 /* Allocate a widget_value, blocking input. */
584 xmalloc_widget_value (void)
589 value
= malloc_widget_value ();
595 /* This recursively calls free_widget_value on the tree of widgets.
596 It must free all data that was malloc'ed for these widget_values.
597 In Emacs, many slots are pointers into the data of Lisp_Strings, and
598 must be left alone. */
601 free_menubar_widget_value_tree (widget_value
*wv
)
605 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
607 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
609 free_menubar_widget_value_tree (wv
->contents
);
610 wv
->contents
= (widget_value
*) 0xDEADBEEF;
614 free_menubar_widget_value_tree (wv
->next
);
615 wv
->next
= (widget_value
*) 0xDEADBEEF;
618 free_widget_value (wv
);
622 /* Create a tree of widget_value objects
623 representing the panes and items
624 in menu_items starting at index START, up to index END. */
627 digest_single_submenu (int start
, int end
, int top_level_items
)
629 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
631 int submenu_depth
= 0;
632 widget_value
**submenu_stack
;
635 submenu_stack
= alloca (menu_items_used
* sizeof *submenu_stack
);
636 wv
= xmalloc_widget_value ();
640 wv
->button_type
= BUTTON_TYPE_NONE
;
646 /* Loop over all panes and items made by the preceding call
647 to parse_single_submenu and construct a tree of widget_value objects.
648 Ignore the panes and items used by previous calls to
649 digest_single_submenu, even though those are also in menu_items. */
653 if (EQ (AREF (menu_items
, i
), Qnil
))
655 submenu_stack
[submenu_depth
++] = save_wv
;
660 else if (EQ (AREF (menu_items
, i
), Qlambda
))
663 save_wv
= submenu_stack
[--submenu_depth
];
666 else if (EQ (AREF (menu_items
, i
), Qt
)
667 && submenu_depth
!= 0)
668 i
+= MENU_ITEMS_PANE_LENGTH
;
669 /* Ignore a nil in the item list.
670 It's meaningful only for dialog boxes. */
671 else if (EQ (AREF (menu_items
, i
), Qquote
))
673 else if (EQ (AREF (menu_items
, i
), Qt
))
675 /* Create a new pane. */
676 Lisp_Object pane_name
;
677 const char *pane_string
;
681 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
684 if (STRINGP (pane_name
))
686 if (unicode_append_menu
)
687 /* Encode as UTF-8 for now. */
688 pane_name
= ENCODE_UTF_8 (pane_name
);
689 else if (STRING_MULTIBYTE (pane_name
))
690 pane_name
= ENCODE_SYSTEM (pane_name
);
692 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
694 #elif defined (USE_LUCID) && defined (HAVE_XFT)
695 if (STRINGP (pane_name
))
697 pane_name
= ENCODE_UTF_8 (pane_name
);
698 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
700 #elif !defined (HAVE_MULTILINGUAL_MENU)
701 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
703 pane_name
= ENCODE_MENU_STRING (pane_name
);
704 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
708 pane_string
= (NILP (pane_name
)
709 ? "" : SSDATA (pane_name
));
710 /* If there is just one top-level pane, put all its items directly
711 under the top-level menu. */
712 if (menu_items_n_panes
== 1)
715 /* If the pane has a meaningful name,
716 make the pane a top-level menu item
717 with its items as a submenu beneath it. */
718 if (strcmp (pane_string
, ""))
720 wv
= xmalloc_widget_value ();
724 first_wv
->contents
= wv
;
725 wv
->lname
= pane_name
;
726 /* Set value to 1 so update_submenu_strings can handle '@' */
727 wv
->value
= (char *)1;
729 wv
->button_type
= BUTTON_TYPE_NONE
;
737 i
+= MENU_ITEMS_PANE_LENGTH
;
741 /* Create a new item within current pane. */
742 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
745 /* All items should be contained in panes. */
749 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
750 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
751 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
752 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
753 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
754 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
755 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
758 if (STRINGP (item_name
))
760 if (unicode_append_menu
)
761 item_name
= ENCODE_UTF_8 (item_name
);
762 else if (STRING_MULTIBYTE (item_name
))
763 item_name
= ENCODE_SYSTEM (item_name
);
765 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
768 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
770 descrip
= ENCODE_SYSTEM (descrip
);
771 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
774 if (STRINGP (item_name
))
776 item_name
= ENCODE_UTF_8 (item_name
);
777 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
780 if (STRINGP (descrip
))
782 descrip
= ENCODE_UTF_8 (descrip
);
783 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
785 #elif !defined (HAVE_MULTILINGUAL_MENU)
786 if (STRING_MULTIBYTE (item_name
))
788 item_name
= ENCODE_MENU_STRING (item_name
);
789 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
792 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
794 descrip
= ENCODE_MENU_STRING (descrip
);
795 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
799 wv
= xmalloc_widget_value ();
803 save_wv
->contents
= wv
;
805 wv
->lname
= item_name
;
809 /* The intptr_t cast avoids a warning. There's no problem
810 as long as pointers have enough bits to hold small integers. */
811 wv
->call_data
= (!NILP (def
) ? (void *) (intptr_t) i
: 0);
812 wv
->enabled
= !NILP (enable
);
815 wv
->button_type
= BUTTON_TYPE_NONE
;
816 else if (EQ (type
, QCradio
))
817 wv
->button_type
= BUTTON_TYPE_RADIO
;
818 else if (EQ (type
, QCtoggle
))
819 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
823 wv
->selected
= !NILP (selected
);
824 if (! STRINGP (help
))
831 i
+= MENU_ITEMS_ITEM_LENGTH
;
835 /* If we have just one "menu item"
836 that was originally a button, return it by itself. */
837 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
839 wv
= first_wv
->contents
;
840 free_widget_value (first_wv
);
847 /* Walk through the widget_value tree starting at FIRST_WV and update
848 the char * pointers from the corresponding lisp values.
849 We do this after building the whole tree, since GC may happen while the
850 tree is constructed, and small strings are relocated. So we must wait
851 until no GC can happen before storing pointers into lisp values. */
853 update_submenu_strings (widget_value
*first_wv
)
857 for (wv
= first_wv
; wv
; wv
= wv
->next
)
859 if (STRINGP (wv
->lname
))
861 wv
->name
= SSDATA (wv
->lname
);
863 /* Ignore the @ that means "separate pane".
864 This is a kludge, but this isn't worth more time. */
865 if (wv
->value
== (char *)1)
867 if (wv
->name
[0] == '@')
873 if (STRINGP (wv
->lkey
))
874 wv
->key
= SSDATA (wv
->lkey
);
877 update_submenu_strings (wv
->contents
);
881 /* Find the menu selection and store it in the keyboard buffer.
882 F is the frame the menu is on.
883 MENU_BAR_ITEMS_USED is the length of VECTOR.
884 VECTOR is an array of menu events for the whole menu. */
887 find_and_call_menu_selection (FRAME_PTR f
, int menu_bar_items_used
, Lisp_Object vector
, void *client_data
)
889 Lisp_Object prefix
, entry
;
890 Lisp_Object
*subprefix_stack
;
891 int submenu_depth
= 0;
895 subprefix_stack
= alloca (menu_bar_items_used
* sizeof *subprefix_stack
);
899 while (i
< menu_bar_items_used
)
901 if (EQ (AREF (vector
, i
), Qnil
))
903 subprefix_stack
[submenu_depth
++] = prefix
;
907 else if (EQ (AREF (vector
, i
), Qlambda
))
909 prefix
= subprefix_stack
[--submenu_depth
];
912 else if (EQ (AREF (vector
, i
), Qt
))
914 prefix
= AREF (vector
, i
+ MENU_ITEMS_PANE_PREFIX
);
915 i
+= MENU_ITEMS_PANE_LENGTH
;
919 entry
= AREF (vector
, i
+ MENU_ITEMS_ITEM_VALUE
);
920 /* Treat the pointer as an integer. There's no problem
921 as long as pointers have enough bits to hold small integers. */
922 if ((intptr_t) client_data
== i
)
925 struct input_event buf
;
929 XSETFRAME (frame
, f
);
930 buf
.kind
= MENU_BAR_EVENT
;
931 buf
.frame_or_window
= frame
;
933 kbd_buffer_store_event (&buf
);
935 for (j
= 0; j
< submenu_depth
; j
++)
936 if (!NILP (subprefix_stack
[j
]))
938 buf
.kind
= MENU_BAR_EVENT
;
939 buf
.frame_or_window
= frame
;
940 buf
.arg
= subprefix_stack
[j
];
941 kbd_buffer_store_event (&buf
);
946 buf
.kind
= MENU_BAR_EVENT
;
947 buf
.frame_or_window
= frame
;
949 kbd_buffer_store_event (&buf
);
952 buf
.kind
= MENU_BAR_EVENT
;
953 buf
.frame_or_window
= frame
;
955 kbd_buffer_store_event (&buf
);
959 i
+= MENU_ITEMS_ITEM_LENGTH
;
964 #endif /* USE_X_TOOLKIT || USE_GTK || HAVE_NS || HAVE_NTGUI */
967 /* As above, but return the menu selection instead of storing in kb buffer.
968 If keymaps==1, return full prefixes to selection. */
970 find_and_return_menu_selection (FRAME_PTR f
, int keymaps
, void *client_data
)
972 Lisp_Object prefix
, entry
;
974 Lisp_Object
*subprefix_stack
;
975 int submenu_depth
= 0;
977 prefix
= entry
= Qnil
;
979 subprefix_stack
= alloca (menu_items_used
* word_size
);
981 while (i
< menu_items_used
)
983 if (EQ (AREF (menu_items
, i
), Qnil
))
985 subprefix_stack
[submenu_depth
++] = prefix
;
989 else if (EQ (AREF (menu_items
, i
), Qlambda
))
991 prefix
= subprefix_stack
[--submenu_depth
];
994 else if (EQ (AREF (menu_items
, i
), Qt
))
997 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
998 i
+= MENU_ITEMS_PANE_LENGTH
;
1000 /* Ignore a nil in the item list.
1001 It's meaningful only for dialog boxes. */
1002 else if (EQ (AREF (menu_items
, i
), Qquote
))
1007 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
1008 if (aref_addr (menu_items
, i
) == client_data
)
1014 entry
= Fcons (entry
, Qnil
);
1016 entry
= Fcons (prefix
, entry
);
1017 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1018 if (!NILP (subprefix_stack
[j
]))
1019 entry
= Fcons (subprefix_stack
[j
], entry
);
1023 i
+= MENU_ITEMS_ITEM_LENGTH
;
1028 #endif /* HAVE_NS */
1030 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
1031 doc
: /* Pop up a deck-of-cards menu and return user's selection.
1032 POSITION is a position specification. This is either a mouse button event
1033 or a list ((XOFFSET YOFFSET) WINDOW)
1034 where XOFFSET and YOFFSET are positions in pixels from the top left
1035 corner of WINDOW. (WINDOW may be a window or a frame object.)
1036 This controls the position of the top left of the menu as a whole.
1037 If POSITION is t, it means to use the current mouse position.
1039 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
1040 The menu items come from key bindings that have a menu string as well as
1041 a definition; actually, the "definition" in such a key binding looks like
1042 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
1043 the keymap as a top-level element.
1045 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
1046 Otherwise, REAL-DEFINITION should be a valid key binding definition.
1048 You can also use a list of keymaps as MENU.
1049 Then each keymap makes a separate pane.
1051 When MENU is a keymap or a list of keymaps, the return value is the
1052 list of events corresponding to the user's choice. Note that
1053 `x-popup-menu' does not actually execute the command bound to that
1056 Alternatively, you can specify a menu of multiple panes
1057 with a list of the form (TITLE PANE1 PANE2...),
1058 where each pane is a list of form (TITLE ITEM1 ITEM2...).
1059 Each ITEM is normally a cons cell (STRING . VALUE);
1060 but a string can appear as an item--that makes a nonselectable line
1062 With this form of menu, the return value is VALUE from the chosen item.
1064 If POSITION is nil, don't display the menu at all, just precalculate the
1065 cached information about equivalent key sequences.
1067 If the user gets rid of the menu without making a valid choice, for
1068 instance by clicking the mouse away from a valid choice or by typing
1069 keyboard input, then this normally results in a quit and
1070 `x-popup-menu' does not return. But if POSITION is a mouse button
1071 event (indicating that the user invoked the menu with the mouse) then
1072 no quit occurs and `x-popup-menu' returns nil. */)
1073 (Lisp_Object position
, Lisp_Object menu
)
1075 Lisp_Object keymap
, tem
;
1076 int xpos
= 0, ypos
= 0;
1078 const char *error_name
= NULL
;
1079 Lisp_Object selection
= Qnil
;
1081 Lisp_Object x
, y
, window
;
1084 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1085 struct gcpro gcpro1
;
1087 if (NILP (position
))
1088 /* This is an obsolete call, which wants us to precompute the
1089 keybinding equivalents, but we don't do that any more anyway. */
1094 int get_current_pos_p
= 0;
1095 /* FIXME!! check_w32 (); or check_x (); or check_ns (); */
1097 /* Decode the first argument: find the window and the coordinates. */
1098 if (EQ (position
, Qt
)
1099 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1100 || EQ (XCAR (position
), Qtool_bar
))))
1102 get_current_pos_p
= 1;
1106 tem
= Fcar (position
);
1109 window
= Fcar (Fcdr (position
));
1111 y
= Fcar (XCDR (tem
));
1116 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1117 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1118 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
1123 /* If a click happens in an external tool bar or a detached
1124 tool bar, x and y is NIL. In that case, use the current
1125 mouse position. This happens for the help button in the
1126 tool bar. Ideally popup-menu should pass NIL to
1127 this function, but it doesn't. */
1128 if (NILP (x
) && NILP (y
))
1129 get_current_pos_p
= 1;
1132 if (get_current_pos_p
)
1134 /* Use the mouse's current position. */
1135 FRAME_PTR new_f
= SELECTED_FRAME ();
1136 #ifdef HAVE_X_WINDOWS
1137 /* Can't use mouse_position_hook for X since it returns
1138 coordinates relative to the window the mouse is in,
1139 we need coordinates relative to the edit widget always. */
1144 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
1145 /* cur_x/y may be negative, so use make_number. */
1146 x
= make_number (cur_x
);
1147 y
= make_number (cur_y
);
1150 #else /* not HAVE_X_WINDOWS */
1151 Lisp_Object bar_window
;
1152 enum scroll_bar_part part
;
1154 void (*mouse_position_hook
) (struct frame
**, int,
1156 enum scroll_bar_part
*,
1160 FRAME_TERMINAL (new_f
)->mouse_position_hook
;
1162 if (mouse_position_hook
)
1163 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
1164 &part
, &x
, &y
, &time
);
1165 #endif /* not HAVE_X_WINDOWS */
1168 XSETFRAME (window
, new_f
);
1171 window
= selected_window
;
1177 /* Decode where to put the menu. */
1179 if (FRAMEP (window
))
1181 f
= XFRAME (window
);
1185 else if (WINDOWP (window
))
1187 struct window
*win
= XWINDOW (window
);
1188 CHECK_LIVE_WINDOW (window
);
1189 f
= XFRAME (WINDOW_FRAME (win
));
1191 xpos
= WINDOW_LEFT_EDGE_X (win
);
1192 ypos
= WINDOW_TOP_EDGE_Y (win
);
1195 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1196 but I don't want to make one now. */
1197 CHECK_WINDOW (window
);
1199 CHECK_RANGED_INTEGER (x
,
1200 (xpos
< INT_MIN
- MOST_NEGATIVE_FIXNUM
1201 ? (EMACS_INT
) INT_MIN
- xpos
1202 : MOST_NEGATIVE_FIXNUM
),
1204 CHECK_RANGED_INTEGER (y
,
1205 (ypos
< INT_MIN
- MOST_NEGATIVE_FIXNUM
1206 ? (EMACS_INT
) INT_MIN
- ypos
1207 : MOST_NEGATIVE_FIXNUM
),
1212 /* FIXME: Find a more general check! */
1213 if (!(FRAME_X_P (f
) || FRAME_MSDOS_P (f
)
1214 || FRAME_W32_P (f
) || FRAME_NS_P (f
)))
1215 error ("Can not put GUI menu on this terminal");
1217 XSETFRAME (Vmenu_updating_frame
, f
);
1219 #endif /* HAVE_MENUS */
1221 /* Now parse the lisp menus. */
1222 record_unwind_protect (unuse_menu_items
, Qnil
);
1227 /* Decode the menu items from what was specified. */
1229 keymap
= get_keymap (menu
, 0, 0);
1232 /* We were given a keymap. Extract menu info from the keymap. */
1235 /* Extract the detailed info to make one pane. */
1236 keymap_panes (&menu
, 1);
1238 /* Search for a string appearing directly as an element of the keymap.
1239 That string is the title of the menu. */
1240 prompt
= Fkeymap_prompt (keymap
);
1243 #ifdef HAVE_NS /* Is that needed and NS-specific? --Stef */
1245 title
= build_string ("Select");
1248 /* Make that be the pane title of the first pane. */
1249 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
1250 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, prompt
);
1254 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
1256 /* We were given a list of keymaps. */
1257 EMACS_INT nmaps
= XFASTINT (Flength (menu
));
1262 SAFE_ALLOCA_LISP (maps
, nmaps
);
1265 /* The first keymap that has a prompt string
1266 supplies the menu title. */
1267 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
1271 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
1273 prompt
= Fkeymap_prompt (keymap
);
1274 if (NILP (title
) && !NILP (prompt
))
1278 /* Extract the detailed info to make one pane. */
1279 keymap_panes (maps
, nmaps
);
1281 /* Make the title be the pane title of the first pane. */
1282 if (!NILP (title
) && menu_items_n_panes
>= 0)
1283 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, title
);
1291 /* We were given an old-fashioned menu. */
1292 title
= Fcar (menu
);
1293 CHECK_STRING (title
);
1295 list_of_panes (Fcdr (menu
));
1300 unbind_to (specpdl_count
, Qnil
);
1303 #ifdef HAVE_WINDOW_SYSTEM
1304 /* Hide a previous tip, if any. */
1308 #ifdef HAVE_NTGUI /* FIXME: Is it really w32-specific? --Stef */
1309 /* If resources from a previous popup menu still exist, does nothing
1310 until the `menu_free_timer' has freed them (see w32fns.c). This
1311 can occur if you press ESC or click outside a menu without selecting
1314 if (current_popup_menu
)
1316 discard_menu_items ();
1317 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1323 #ifdef HAVE_NS /* FIXME: ns-specific, why? --Stef */
1324 record_unwind_protect (cleanup_popup_menu
, Qnil
);
1327 /* Display them in a menu. */
1330 /* FIXME: Use a terminal hook! */
1331 #if defined HAVE_NTGUI
1332 selection
= w32_menu_show (f
, xpos
, ypos
, for_click
,
1333 keymaps
, title
, &error_name
);
1334 #elif defined HAVE_NS
1335 selection
= ns_menu_show (f
, xpos
, ypos
, for_click
,
1336 keymaps
, title
, &error_name
);
1337 #else /* MSDOS and X11 */
1338 /* Assume last_event_timestamp is the timestamp of the button event.
1339 Is this assumption ever violated? We can't use the timestamp
1340 stored within POSITION because there the top bits from the actual
1341 timestamp may be truncated away (Bug#4930). */
1342 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
1343 keymaps
, title
, &error_name
,
1344 last_event_timestamp
);
1350 unbind_to (specpdl_count
, Qnil
);
1352 discard_menu_items ();
1355 #ifdef HAVE_NTGUI /* FIXME: Is it really w32-specific? --Stef */
1356 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1359 #endif /* HAVE_MENUS */
1363 if (error_name
) error ("%s", error_name
);
1370 staticpro (&menu_items
);
1372 menu_items_inuse
= Qnil
;
1374 defsubr (&Sx_popup_menu
);