1 /* Platform-independent code for terminal communications.
3 Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2014 Free Software
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/>. */
23 #include <limits.h> /* for INT_MAX */
30 #include "termhooks.h"
31 #include "blockinput.h"
32 #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 /* Return non-zero if menus can handle radio and toggle buttons. */
58 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NTGUI) || defined(HAVE_NS)
59 if (FRAME_WINDOW_P (XFRAME (Vmenu_updating_frame
)))
65 Lisp_Object menu_items
;
67 /* If non-nil, means that the global vars defined here are already in use.
68 Used to detect cases where we try to re-enter this non-reentrant code. */
69 Lisp_Object menu_items_inuse
;
71 /* Number of slots currently allocated in menu_items. */
72 int menu_items_allocated
;
74 /* This is the index in menu_items of the first empty slot. */
77 /* The number of panes currently recorded in menu_items,
78 excluding those within submenus. */
79 int menu_items_n_panes
;
81 /* Current depth within submenus. */
82 static int menu_items_submenu_depth
;
85 init_menu_items (void)
87 if (!NILP (menu_items_inuse
))
88 error ("Trying to use a menu from within a menu-entry");
90 if (NILP (menu_items
))
92 menu_items_allocated
= 60;
93 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
96 menu_items_inuse
= Qt
;
98 menu_items_n_panes
= 0;
99 menu_items_submenu_depth
= 0;
102 /* Call at the end of generating the data in menu_items. */
105 finish_menu_items (void)
110 unuse_menu_items (void)
112 menu_items_inuse
= Qnil
;
115 /* Call when finished using the data for the current menu
119 discard_menu_items (void)
121 /* Free the structure if it is especially large.
122 Otherwise, hold on to it, to save time. */
123 if (menu_items_allocated
> 200)
126 menu_items_allocated
= 0;
128 eassert (NILP (menu_items_inuse
));
131 /* This undoes save_menu_items, and it is called by the specpdl unwind
135 restore_menu_items (Lisp_Object saved
)
137 menu_items
= XCAR (saved
);
138 menu_items_inuse
= (! NILP (menu_items
) ? Qt
: Qnil
);
139 menu_items_allocated
= (VECTORP (menu_items
) ? ASIZE (menu_items
) : 0);
140 saved
= XCDR (saved
);
141 menu_items_used
= XINT (XCAR (saved
));
142 saved
= XCDR (saved
);
143 menu_items_n_panes
= XINT (XCAR (saved
));
144 saved
= XCDR (saved
);
145 menu_items_submenu_depth
= XINT (XCAR (saved
));
148 /* Push the whole state of menu_items processing onto the specpdl.
149 It will be restored when the specpdl is unwound. */
152 save_menu_items (void)
154 Lisp_Object saved
= list4 (!NILP (menu_items_inuse
) ? menu_items
: Qnil
,
155 make_number (menu_items_used
),
156 make_number (menu_items_n_panes
),
157 make_number (menu_items_submenu_depth
));
158 record_unwind_protect (restore_menu_items
, saved
);
159 menu_items_inuse
= Qnil
;
164 /* Ensure that there is room for ITEMS items in the menu_items vector. */
167 ensure_menu_items (int items
)
169 int incr
= items
- (menu_items_allocated
- menu_items_used
);
172 menu_items
= larger_vector (menu_items
, incr
, INT_MAX
);
173 menu_items_allocated
= ASIZE (menu_items
);
177 #if (defined USE_X_TOOLKIT || defined USE_GTK || defined HAVE_NS \
178 || defined HAVE_NTGUI)
180 /* Begin a submenu. */
183 push_submenu_start (void)
185 ensure_menu_items (1);
186 ASET (menu_items
, menu_items_used
, Qnil
);
188 menu_items_submenu_depth
++;
194 push_submenu_end (void)
196 ensure_menu_items (1);
197 ASET (menu_items
, menu_items_used
, Qlambda
);
199 menu_items_submenu_depth
--;
202 #endif /* USE_X_TOOLKIT || USE_GTK || HAVE_NS || defined HAVE_NTGUI */
204 /* Indicate boundary between left and right. */
207 push_left_right_boundary (void)
209 ensure_menu_items (1);
210 ASET (menu_items
, menu_items_used
, Qquote
);
214 /* Start a new menu pane in menu_items.
215 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
218 push_menu_pane (Lisp_Object name
, Lisp_Object prefix_vec
)
220 ensure_menu_items (MENU_ITEMS_PANE_LENGTH
);
221 if (menu_items_submenu_depth
== 0)
222 menu_items_n_panes
++;
223 ASET (menu_items
, menu_items_used
, Qt
);
225 ASET (menu_items
, menu_items_used
, name
);
227 ASET (menu_items
, menu_items_used
, prefix_vec
);
231 /* Push one menu item into the current pane. NAME is the string to
232 display. ENABLE if non-nil means this item can be selected. KEY
233 is the key generated by choosing this item, or nil if this item
234 doesn't really have a definition. DEF is the definition of this
235 item. EQUIV is the textual description of the keyboard equivalent
236 for this item (or nil if none). TYPE is the type of this menu
237 item, one of nil, `toggle' or `radio'. */
240 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
)
242 ensure_menu_items (MENU_ITEMS_ITEM_LENGTH
);
244 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_NAME
, name
);
245 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_ENABLE
, enable
);
246 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_VALUE
, key
);
247 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_EQUIV_KEY
, equiv
);
248 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_DEFINITION
, def
);
249 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_TYPE
, type
);
250 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_SELECTED
, selected
);
251 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_HELP
, help
);
253 menu_items_used
+= MENU_ITEMS_ITEM_LENGTH
;
256 /* Args passed between single_keymap_panes and single_menu_item. */
259 Lisp_Object pending_maps
;
264 static void single_menu_item (Lisp_Object
, Lisp_Object
, Lisp_Object
,
267 /* This is a recursive subroutine of keymap_panes.
268 It handles one keymap, KEYMAP.
269 The other arguments are passed along
270 or point to local variables of the previous function.
272 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
275 single_keymap_panes (Lisp_Object keymap
, Lisp_Object pane_name
,
276 Lisp_Object prefix
, int maxdepth
)
281 skp
.pending_maps
= Qnil
;
282 skp
.maxdepth
= maxdepth
;
288 push_menu_pane (pane_name
, prefix
);
292 /* Remember index for first item in this pane so we can go back
293 and add a prefix when (if) we see the first button. After
294 that, notbuttons is set to 0, to mark that we have seen a
295 button and all non button items need a prefix. */
296 skp
.notbuttons
= menu_items_used
;
299 GCPRO1 (skp
.pending_maps
);
300 map_keymap_canonical (keymap
, single_menu_item
, Qnil
, &skp
);
303 /* Process now any submenus which want to be panes at this level. */
304 while (CONSP (skp
.pending_maps
))
306 Lisp_Object elt
, eltcdr
, string
;
307 elt
= XCAR (skp
.pending_maps
);
309 string
= XCAR (eltcdr
);
310 /* We no longer discard the @ from the beginning of the string here.
311 Instead, we do this in *menu_show. */
312 single_keymap_panes (Fcar (elt
), string
, XCDR (eltcdr
), maxdepth
- 1);
313 skp
.pending_maps
= XCDR (skp
.pending_maps
);
317 /* This is a subroutine of single_keymap_panes that handles one
319 KEY is a key in a keymap and ITEM is its binding.
320 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
322 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them. */
325 single_menu_item (Lisp_Object key
, Lisp_Object item
, Lisp_Object dummy
, void *skp_v
)
327 Lisp_Object map
, item_string
, enabled
;
328 struct gcpro gcpro1
, gcpro2
;
330 struct skp
*skp
= skp_v
;
332 /* Parse the menu item and leave the result in item_properties. */
334 res
= parse_menu_item (item
, 0);
337 return; /* Not a menu item. */
339 map
= AREF (item_properties
, ITEM_PROPERTY_MAP
);
341 enabled
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
342 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
344 if (!NILP (map
) && SREF (item_string
, 0) == '@')
347 /* An enabled separate pane. Remember this to handle it later. */
348 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
353 /* Simulate radio buttons and toggle boxes by putting a prefix in
357 Lisp_Object prefix
= Qnil
;
358 Lisp_Object type
= AREF (item_properties
, ITEM_PROPERTY_TYPE
);
362 = AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
365 /* The first button. Line up previous items in this menu. */
367 int idx
= skp
->notbuttons
; /* Index for first item this menu. */
370 while (idx
< menu_items_used
)
373 = AREF (menu_items
, idx
+ MENU_ITEMS_ITEM_NAME
);
377 submenu
++; /* Skip sub menu. */
379 else if (EQ (tem
, Qlambda
))
382 submenu
--; /* End sub menu. */
384 else if (EQ (tem
, Qt
))
385 idx
+= 3; /* Skip new pane marker. */
386 else if (EQ (tem
, Qquote
))
387 idx
++; /* Skip a left, right divider. */
390 if (!submenu
&& SREF (tem
, 0) != '\0'
391 && SREF (tem
, 0) != '-')
392 ASET (menu_items
, idx
+ MENU_ITEMS_ITEM_NAME
,
393 concat2 (build_string (" "), tem
));
394 idx
+= MENU_ITEMS_ITEM_LENGTH
;
400 /* Calculate prefix, if any, for this item. */
401 if (EQ (type
, QCtoggle
))
402 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
403 else if (EQ (type
, QCradio
))
404 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
406 /* Not a button. If we have earlier buttons, then we need a prefix. */
407 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
408 && SREF (item_string
, 0) != '-')
409 prefix
= build_string (" ");
412 item_string
= concat2 (prefix
, item_string
);
415 if ((FRAME_TERMCAP_P (XFRAME (Vmenu_updating_frame
))
416 || FRAME_MSDOS_P (XFRAME (Vmenu_updating_frame
)))
418 /* Indicate visually that this is a submenu. */
419 item_string
= concat2 (item_string
, build_string (" >"));
421 push_menu_item (item_string
, enabled
, key
,
422 AREF (item_properties
, ITEM_PROPERTY_DEF
),
423 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
),
424 AREF (item_properties
, ITEM_PROPERTY_TYPE
),
425 AREF (item_properties
, ITEM_PROPERTY_SELECTED
),
426 AREF (item_properties
, ITEM_PROPERTY_HELP
));
428 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
429 /* Display a submenu using the toolkit. */
430 if (FRAME_WINDOW_P (XFRAME (Vmenu_updating_frame
))
431 && ! (NILP (map
) || NILP (enabled
)))
433 push_submenu_start ();
434 single_keymap_panes (map
, Qnil
, key
, skp
->maxdepth
- 1);
440 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
441 and generate menu panes for them in menu_items. */
444 keymap_panes (Lisp_Object
*keymaps
, ptrdiff_t nmaps
)
450 /* Loop over the given keymaps, making a pane for each map.
451 But don't make a pane that is empty--ignore that map instead.
452 P is the number of panes we have made so far. */
453 for (mapno
= 0; mapno
< nmaps
; mapno
++)
454 single_keymap_panes (keymaps
[mapno
],
455 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, 10);
457 finish_menu_items ();
460 /* Encode a menu string as appropriate for menu-updating-frame's type. */
462 encode_menu_string (Lisp_Object str
)
464 /* TTY menu strings are encoded by write_glyphs, when they are
465 delivered to the glass, so no need to encode them here. */
466 if (FRAME_TERMCAP_P (XFRAME (Vmenu_updating_frame
)))
468 return ENCODE_MENU_STRING (str
);
471 /* Push the items in a single pane defined by the alist PANE. */
473 list_of_items (Lisp_Object pane
)
475 Lisp_Object tail
, item
, item1
;
477 for (tail
= pane
; CONSP (tail
); tail
= XCDR (tail
))
481 push_menu_item (encode_menu_string (item
), Qnil
, Qnil
, Qt
,
482 Qnil
, Qnil
, Qnil
, Qnil
);
483 else if (CONSP (item
))
486 CHECK_STRING (item1
);
487 push_menu_item (encode_menu_string (item1
), Qt
, XCDR (item
),
488 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
491 push_left_right_boundary ();
496 /* Push all the panes and items of a menu described by the
497 alist-of-alists MENU.
498 This handles old-fashioned calls to x-popup-menu. */
500 list_of_panes (Lisp_Object menu
)
506 for (tail
= menu
; CONSP (tail
); tail
= XCDR (tail
))
508 Lisp_Object elt
, pane_name
, pane_data
;
510 pane_name
= Fcar (elt
);
511 CHECK_STRING (pane_name
);
512 push_menu_pane (encode_menu_string (pane_name
), Qnil
);
513 pane_data
= Fcdr (elt
);
514 CHECK_CONS (pane_data
);
515 list_of_items (pane_data
);
518 finish_menu_items ();
521 /* Set up data in menu_items for a menu bar item
522 whose event type is ITEM_KEY (with string ITEM_NAME)
523 and whose contents come from the list of keymaps MAPS. */
525 parse_single_submenu (Lisp_Object item_key
, Lisp_Object item_name
,
532 bool top_level_items
= 0;
535 length
= Flength (maps
);
538 /* Convert the list MAPS into a vector MAPVEC. */
539 SAFE_ALLOCA_LISP (mapvec
, len
);
540 for (i
= 0; i
< len
; i
++)
542 mapvec
[i
] = Fcar (maps
);
546 /* Loop over the given keymaps, making a pane for each map.
547 But don't make a pane that is empty--ignore that map instead. */
548 for (i
= 0; i
< len
; i
++)
550 if (!KEYMAPP (mapvec
[i
]))
552 /* Here we have a command at top level in the menu bar
553 as opposed to a submenu. */
555 push_menu_pane (Qnil
, Qnil
);
556 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
557 Qnil
, Qnil
, Qnil
, Qnil
);
562 prompt
= Fkeymap_prompt (mapvec
[i
]);
563 single_keymap_panes (mapvec
[i
],
564 !NILP (prompt
) ? prompt
: item_name
,
570 return top_level_items
;
574 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
576 /* Allocate and basically initialize widget_value, blocking input. */
579 make_widget_value (const char *name
, char *value
,
580 bool enabled
, Lisp_Object help
)
585 wv
= xzalloc (sizeof (widget_value
));
588 wv
->name
= (char *) name
;
590 wv
->enabled
= enabled
;
595 /* This recursively calls xfree 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;
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
, bool top_level_items
)
629 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
631 int submenu_depth
= 0;
632 widget_value
**submenu_stack
;
634 struct frame
*f
= XFRAME (Vmenu_updating_frame
);
636 submenu_stack
= alloca (menu_items_used
* sizeof *submenu_stack
);
637 wv
= make_widget_value ("menu", NULL
, true, Qnil
);
638 wv
->button_type
= BUTTON_TYPE_NONE
;
643 /* Loop over all panes and items made by the preceding call
644 to parse_single_submenu and construct a tree of widget_value objects.
645 Ignore the panes and items used by previous calls to
646 digest_single_submenu, even though those are also in menu_items. */
650 if (EQ (AREF (menu_items
, i
), Qnil
))
652 submenu_stack
[submenu_depth
++] = save_wv
;
657 else if (EQ (AREF (menu_items
, i
), Qlambda
))
660 save_wv
= submenu_stack
[--submenu_depth
];
663 else if (EQ (AREF (menu_items
, i
), Qt
)
664 && submenu_depth
!= 0)
665 i
+= MENU_ITEMS_PANE_LENGTH
;
666 /* Ignore a nil in the item list.
667 It's meaningful only for dialog boxes. */
668 else if (EQ (AREF (menu_items
, i
), Qquote
))
670 else if (EQ (AREF (menu_items
, i
), Qt
))
672 /* Create a new pane. */
673 Lisp_Object pane_name
;
674 const char *pane_string
;
678 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
680 /* TTY menus display menu items via tty_write_glyphs, which
681 will encode the strings as appropriate. */
682 if (!FRAME_TERMCAP_P (f
))
685 if (STRINGP (pane_name
))
687 if (unicode_append_menu
)
688 /* Encode as UTF-8 for now. */
689 pane_name
= ENCODE_UTF_8 (pane_name
);
690 else if (STRING_MULTIBYTE (pane_name
))
691 pane_name
= ENCODE_SYSTEM (pane_name
);
693 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
695 #elif defined (USE_LUCID) && defined (HAVE_XFT)
696 if (STRINGP (pane_name
))
698 pane_name
= ENCODE_UTF_8 (pane_name
);
699 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
701 #elif !defined (HAVE_MULTILINGUAL_MENU)
702 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
704 pane_name
= ENCODE_MENU_STRING (pane_name
);
705 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
710 pane_string
= (NILP (pane_name
)
711 ? "" : SSDATA (pane_name
));
712 /* If there is just one top-level pane, put all its items directly
713 under the top-level menu. */
714 if (menu_items_n_panes
== 1)
717 /* If the pane has a meaningful name,
718 make the pane a top-level menu item
719 with its items as a submenu beneath it. */
720 if (strcmp (pane_string
, ""))
722 /* Set value to 1 so update_submenu_strings can handle '@'. */
723 wv
= make_widget_value (NULL
, (char *) 1, true, Qnil
);
727 first_wv
->contents
= wv
;
728 wv
->lname
= pane_name
;
729 wv
->button_type
= BUTTON_TYPE_NONE
;
736 i
+= MENU_ITEMS_PANE_LENGTH
;
740 /* Create a new item within current pane. */
741 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
744 /* All items should be contained in panes. */
748 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
749 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
750 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
751 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
752 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
753 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
754 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
756 /* TTY menu items and their descriptions will be encoded by
758 if (!FRAME_TERMCAP_P (f
))
761 if (STRINGP (item_name
))
763 if (unicode_append_menu
)
764 item_name
= ENCODE_UTF_8 (item_name
);
765 else if (STRING_MULTIBYTE (item_name
))
766 item_name
= ENCODE_SYSTEM (item_name
);
768 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
771 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
773 descrip
= ENCODE_SYSTEM (descrip
);
774 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
777 if (STRINGP (item_name
))
779 item_name
= ENCODE_UTF_8 (item_name
);
780 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
783 if (STRINGP (descrip
))
785 descrip
= ENCODE_UTF_8 (descrip
);
786 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
788 #elif !defined (HAVE_MULTILINGUAL_MENU)
789 if (STRING_MULTIBYTE (item_name
))
791 item_name
= ENCODE_MENU_STRING (item_name
);
792 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
795 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
797 descrip
= ENCODE_MENU_STRING (descrip
);
798 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
803 wv
= make_widget_value (NULL
, NULL
, !NILP (enable
),
804 STRINGP (help
) ? help
: Qnil
);
808 save_wv
->contents
= wv
;
810 wv
->lname
= item_name
;
813 /* The intptr_t cast avoids a warning. There's no problem
814 as long as pointers have enough bits to hold small integers. */
815 wv
->call_data
= (!NILP (def
) ? (void *) (intptr_t) i
: 0);
818 wv
->button_type
= BUTTON_TYPE_NONE
;
819 else if (EQ (type
, QCradio
))
820 wv
->button_type
= BUTTON_TYPE_RADIO
;
821 else if (EQ (type
, QCtoggle
))
822 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
826 wv
->selected
= !NILP (selected
);
830 i
+= MENU_ITEMS_ITEM_LENGTH
;
834 /* If we have just one "menu item"
835 that was originally a button, return it by itself. */
836 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
838 wv
= first_wv
->contents
;
846 /* Walk through the widget_value tree starting at FIRST_WV and update
847 the char * pointers from the corresponding lisp values.
848 We do this after building the whole tree, since GC may happen while the
849 tree is constructed, and small strings are relocated. So we must wait
850 until no GC can happen before storing pointers into lisp values. */
852 update_submenu_strings (widget_value
*first_wv
)
856 for (wv
= first_wv
; wv
; wv
= wv
->next
)
858 if (STRINGP (wv
->lname
))
860 wv
->name
= SSDATA (wv
->lname
);
862 /* Ignore the @ that means "separate pane".
863 This is a kludge, but this isn't worth more time. */
864 if (wv
->value
== (char *)1)
866 if (wv
->name
[0] == '@')
872 if (STRINGP (wv
->lkey
))
873 wv
->key
= SSDATA (wv
->lkey
);
876 update_submenu_strings (wv
->contents
);
880 /* Find the menu selection and store it in the keyboard buffer.
881 F is the frame the menu is on.
882 MENU_BAR_ITEMS_USED is the length of VECTOR.
883 VECTOR is an array of menu events for the whole menu. */
886 find_and_call_menu_selection (struct frame
*f
, int menu_bar_items_used
,
887 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, return full prefixes to selection. */
970 find_and_return_menu_selection (struct frame
*f
, bool 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
= list1 (entry
);
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 */
1031 menu_item_width (const unsigned char *str
)
1034 const unsigned char *p
;
1036 for (len
= 0, p
= str
; *p
; )
1039 int ch
= STRING_CHAR_AND_LENGTH (p
, ch_len
);
1041 len
+= CHAR_WIDTH (ch
);
1047 DEFUN ("menu-bar-menu-at-x-y", Fmenu_bar_menu_at_x_y
, Smenu_bar_menu_at_x_y
,
1049 doc
: /* Return the menu-bar menu on FRAME at pixel coordinates X, Y.
1050 X and Y are frame-relative pixel coordinates, assumed to define
1051 a location within the menu bar.
1052 If FRAME is nil or omitted, it defaults to the selected frame.
1054 Value is the symbol of the menu at X/Y, or nil if the specified
1055 coordinates are not within the FRAME's menu bar. The symbol can
1056 be used to look up the menu like this:
1058 (lookup-key MAP [menu-bar SYMBOL])
1060 where MAP is either the current global map or the current local map,
1061 since menu-bar items come from both.
1063 This function can return non-nil only on a text-terminal frame
1064 or on an X frame that doesn't use any GUI toolkit. Otherwise,
1065 Emacs does not manage the menu bar and cannot convert coordinates
1066 into menu items. */)
1067 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame
)
1070 struct frame
*f
= decode_any_frame (frame
);
1072 if (!FRAME_LIVE_P (f
))
1075 pixel_to_glyph_coords (f
, XINT (x
), XINT (y
), &col
, &row
, NULL
, 1);
1076 if (0 <= row
&& row
< FRAME_MENU_BAR_LINES (f
))
1078 Lisp_Object items
, item
;
1081 /* Find the menu bar item under `col'. */
1083 items
= FRAME_MENU_BAR_ITEMS (f
);
1084 /* This loop assumes a single menu-bar line, and will fail to
1085 find an item if it is not in the first line. Note that
1086 make_lispy_event in keyboard.c makes the same assumption. */
1087 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1089 Lisp_Object pos
, str
;
1091 str
= AREF (items
, i
+ 1);
1092 pos
= AREF (items
, i
+ 3);
1095 if (XINT (pos
) <= col
1096 /* We use <= so the blank between 2 items on a TTY is
1097 considered part of the previous item. */
1098 && col
<= XINT (pos
) + menu_item_width (SDATA (str
)))
1100 item
= AREF (items
, i
);
1109 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
1110 doc
: /* Pop up a deck-of-cards menu and return user's selection.
1111 POSITION is a position specification. This is either a mouse button event
1112 or a list ((XOFFSET YOFFSET) WINDOW)
1113 where XOFFSET and YOFFSET are positions in pixels from the top left
1114 corner of WINDOW. (WINDOW may be a window or a frame object.)
1115 This controls the position of the top left of the menu as a whole.
1116 If POSITION is t, it means to use the current mouse position.
1118 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
1119 The menu items come from key bindings that have a menu string as well as
1120 a definition; actually, the "definition" in such a key binding looks like
1121 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
1122 the keymap as a top-level element.
1124 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
1125 Otherwise, REAL-DEFINITION should be a valid key binding definition.
1127 You can also use a list of keymaps as MENU.
1128 Then each keymap makes a separate pane.
1130 When MENU is a keymap or a list of keymaps, the return value is the
1131 list of events corresponding to the user's choice. Note that
1132 `x-popup-menu' does not actually execute the command bound to that
1135 Alternatively, you can specify a menu of multiple panes
1136 with a list of the form (TITLE PANE1 PANE2...),
1137 where each pane is a list of form (TITLE ITEM1 ITEM2...).
1138 Each ITEM is normally a cons cell (STRING . VALUE);
1139 but a string can appear as an item--that makes a nonselectable line
1141 With this form of menu, the return value is VALUE from the chosen item.
1143 If POSITION is nil, don't display the menu at all, just precalculate the
1144 cached information about equivalent key sequences.
1146 If the user gets rid of the menu without making a valid choice, for
1147 instance by clicking the mouse away from a valid choice or by typing
1148 keyboard input, then this normally results in a quit and
1149 `x-popup-menu' does not return. But if POSITION is a mouse button
1150 event (indicating that the user invoked the menu with the mouse) then
1151 no quit occurs and `x-popup-menu' returns nil. */)
1152 (Lisp_Object position
, Lisp_Object menu
)
1154 Lisp_Object keymap
, tem
, tem2
;
1155 int xpos
= 0, ypos
= 0;
1157 const char *error_name
= NULL
;
1158 Lisp_Object selection
= Qnil
;
1159 struct frame
*f
= NULL
;
1160 Lisp_Object x
, y
, window
;
1163 ptrdiff_t specpdl_count2
;
1164 struct gcpro gcpro1
;
1166 if (NILP (position
))
1167 /* This is an obsolete call, which wants us to precompute the
1168 keybinding equivalents, but we don't do that any more anyway. */
1175 bool get_current_pos_p
= 0;
1177 /* Decode the first argument: find the window and the coordinates. */
1178 if (EQ (position
, Qt
)
1179 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1180 || EQ (XCAR (position
), Qtool_bar
))))
1182 get_current_pos_p
= 1;
1186 tem
= Fcar (position
);
1189 window
= Fcar (Fcdr (position
));
1191 y
= Fcar (XCDR (tem
));
1195 menuflags
|= MENU_FOR_CLICK
;
1196 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1197 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1198 tem2
= Fcar (Fcdr (tem
)); /* POSN_POSN (tem) */
1199 /* The MENU_KBD_NAVIGATION field is set when the menu
1200 was invoked by F10, which probably means they have no
1201 mouse. In that case, we let them switch between
1202 top-level menu-bar menus by using C-f/C-b and
1203 horizontal arrow keys, since they cannot click the
1204 mouse to open a different submenu. This flag is only
1205 supported by tty_menu_show. We set it when POSITION
1206 and last_nonmenu_event are different, which means we
1207 constructed POSITION by hand (in popup-menu, see
1208 menu-bar.el) to look like a mouse click on the menu bar
1210 if (!EQ (POSN_POSN (last_nonmenu_event
),
1211 POSN_POSN (position
))
1212 && CONSP (tem2
) && EQ (Fcar (tem2
), Qmenu_bar
))
1213 menuflags
|= MENU_KBD_NAVIGATION
;
1214 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
1219 /* If a click happens in an external tool bar or a detached
1220 tool bar, x and y is NIL. In that case, use the current
1221 mouse position. This happens for the help button in the
1222 tool bar. Ideally popup-menu should pass NIL to
1223 this function, but it doesn't. */
1224 if (NILP (x
) && NILP (y
))
1225 get_current_pos_p
= 1;
1228 if (get_current_pos_p
)
1230 /* Use the mouse's current position. */
1231 struct frame
*new_f
= SELECTED_FRAME ();
1232 #ifdef HAVE_X_WINDOWS
1233 /* Can't use mouse_position_hook for X since it returns
1234 coordinates relative to the window the mouse is in,
1235 we need coordinates relative to the edit widget always. */
1240 x_relative_mouse_position (new_f
, &cur_x
, &cur_y
);
1241 /* cur_x/y may be negative, so use make_number. */
1242 x
= make_number (cur_x
);
1243 y
= make_number (cur_y
);
1246 #else /* not HAVE_X_WINDOWS */
1247 Lisp_Object bar_window
;
1248 enum scroll_bar_part part
;
1250 void (*mouse_position_hook
) (struct frame
**, int,
1252 enum scroll_bar_part
*,
1256 FRAME_TERMINAL (new_f
)->mouse_position_hook
;
1258 if (mouse_position_hook
)
1259 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
1260 &part
, &x
, &y
, &time
);
1261 #endif /* not HAVE_X_WINDOWS */
1264 XSETFRAME (window
, new_f
);
1267 window
= selected_window
;
1273 /* Decode where to put the menu. */
1275 if (FRAMEP (window
))
1277 f
= XFRAME (window
);
1281 else if (WINDOWP (window
))
1283 struct window
*win
= XWINDOW (window
);
1284 CHECK_LIVE_WINDOW (window
);
1285 f
= XFRAME (WINDOW_FRAME (win
));
1287 xpos
= WINDOW_LEFT_EDGE_X (win
);
1288 ypos
= WINDOW_TOP_EDGE_Y (win
);
1291 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1292 but I don't want to make one now. */
1293 CHECK_WINDOW (window
);
1295 CHECK_RANGED_INTEGER (x
,
1296 (xpos
< INT_MIN
- MOST_NEGATIVE_FIXNUM
1297 ? (EMACS_INT
) INT_MIN
- xpos
1298 : MOST_NEGATIVE_FIXNUM
),
1300 CHECK_RANGED_INTEGER (y
,
1301 (ypos
< INT_MIN
- MOST_NEGATIVE_FIXNUM
1302 ? (EMACS_INT
) INT_MIN
- ypos
1303 : MOST_NEGATIVE_FIXNUM
),
1308 XSETFRAME (Vmenu_updating_frame
, f
);
1311 /* Now parse the lisp menus. */
1312 record_unwind_protect_void (unuse_menu_items
);
1317 /* Decode the menu items from what was specified. */
1319 keymap
= get_keymap (menu
, 0, 0);
1322 /* We were given a keymap. Extract menu info from the keymap. */
1325 /* Extract the detailed info to make one pane. */
1326 keymap_panes (&menu
, 1);
1328 /* Search for a string appearing directly as an element of the keymap.
1329 That string is the title of the menu. */
1330 prompt
= Fkeymap_prompt (keymap
);
1333 #ifdef HAVE_NS /* Is that needed and NS-specific? --Stef */
1335 title
= build_string ("Select");
1338 /* Make that be the pane title of the first pane. */
1339 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
1340 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, prompt
);
1342 menuflags
|= MENU_KEYMAPS
;
1344 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
1346 /* We were given a list of keymaps. */
1347 EMACS_INT nmaps
= XFASTINT (Flength (menu
));
1352 SAFE_ALLOCA_LISP (maps
, nmaps
);
1355 /* The first keymap that has a prompt string
1356 supplies the menu title. */
1357 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
1361 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
1363 prompt
= Fkeymap_prompt (keymap
);
1364 if (NILP (title
) && !NILP (prompt
))
1368 /* Extract the detailed info to make one pane. */
1369 keymap_panes (maps
, nmaps
);
1371 /* Make the title be the pane title of the first pane. */
1372 if (!NILP (title
) && menu_items_n_panes
>= 0)
1373 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, title
);
1375 menuflags
|= MENU_KEYMAPS
;
1381 /* We were given an old-fashioned menu. */
1382 title
= Fcar (menu
);
1383 CHECK_STRING (title
);
1385 list_of_panes (Fcdr (menu
));
1387 menuflags
&= ~MENU_KEYMAPS
;
1392 #ifdef HAVE_WINDOW_SYSTEM
1393 /* Hide a previous tip, if any. */
1394 if (!FRAME_TERMCAP_P (f
))
1398 #ifdef HAVE_NTGUI /* FIXME: Is it really w32-specific? --Stef */
1399 /* If resources from a previous popup menu still exist, does nothing
1400 until the `menu_free_timer' has freed them (see w32fns.c). This
1401 can occur if you press ESC or click outside a menu without selecting
1404 if (current_popup_menu
&& FRAME_W32_P (f
))
1406 discard_menu_items ();
1407 FRAME_DISPLAY_INFO (f
)->grabbed
= 0;
1415 #ifdef HAVE_NS /* FIXME: ns-specific, why? --Stef */
1416 record_unwind_protect_void (discard_menu_items
);
1419 /* Display them in a menu, but not if F is the initial frame that
1420 doesn't have its hooks set (e.g., in a batch session), because
1421 such a frame cannot display menus. */
1422 if (!FRAME_INITIAL_P (f
))
1423 selection
= FRAME_TERMINAL (f
)->menu_show_hook (f
, xpos
, ypos
, menuflags
,
1424 title
, &error_name
);
1427 discard_menu_items ();
1432 #ifdef HAVE_NTGUI /* FIXME: Is it really w32-specific? --Stef */
1433 if (FRAME_W32_P (f
))
1434 FRAME_DISPLAY_INFO (f
)->grabbed
= 0;
1439 if (error_name
) error ("%s", error_name
);
1443 /* If F's terminal is not capable of displaying a popup dialog,
1444 emulate it with a menu. */
1447 emulate_dialog_with_menu (struct frame
*f
, Lisp_Object contents
)
1449 Lisp_Object x
, y
, frame
, newpos
, prompt
= Fcar (contents
);
1450 int x_coord
, y_coord
;
1452 if (FRAME_WINDOW_P (f
))
1454 x_coord
= FRAME_PIXEL_WIDTH (f
);
1455 y_coord
= FRAME_PIXEL_HEIGHT (f
);
1459 x_coord
= FRAME_COLS (f
);
1460 /* Center the title at frame middle. (TTY menus have
1461 their upper-left corner at the given position.) */
1462 if (STRINGP (prompt
))
1463 x_coord
-= SCHARS (prompt
);
1464 y_coord
= FRAME_LINES (f
);
1467 XSETFRAME (frame
, f
);
1468 XSETINT (x
, x_coord
/ 2);
1469 XSETINT (y
, y_coord
/ 2);
1470 newpos
= list2 (list2 (x
, y
), frame
);
1472 return Fx_popup_menu (newpos
, list2 (prompt
, contents
));
1475 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
1476 doc
: /* Pop up a dialog box and return user's selection.
1477 POSITION specifies which frame to use.
1478 This is normally a mouse button event or a window or frame.
1479 If POSITION is t, it means to use the frame the mouse is on.
1480 The dialog box appears in the middle of the specified frame.
1482 CONTENTS specifies the alternatives to display in the dialog box.
1483 It is a list of the form (DIALOG ITEM1 ITEM2...).
1484 Each ITEM is a cons cell (STRING . VALUE).
1485 The return value is VALUE from the chosen item.
1487 An ITEM may also be just a string--that makes a nonselectable item.
1488 An ITEM may also be nil--that means to put all preceding items
1489 on the left of the dialog box and all following items on the right.
1490 \(By default, approximately half appear on each side.)
1492 If HEADER is non-nil, the frame title for the box is "Information",
1493 otherwise it is "Question".
1495 If the user gets rid of the dialog box without making a valid choice,
1496 for instance using the window manager, then this produces a quit and
1497 `x-popup-dialog' does not return. */)
1498 (Lisp_Object position
, Lisp_Object contents
, Lisp_Object header
)
1500 struct frame
*f
= NULL
;
1503 /* Decode the first argument: find the window or frame to use. */
1504 if (EQ (position
, Qt
)
1505 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1506 || EQ (XCAR (position
), Qtool_bar
))))
1507 window
= selected_window
;
1508 else if (CONSP (position
))
1510 Lisp_Object tem
= XCAR (position
);
1512 window
= Fcar (XCDR (position
));
1515 tem
= Fcar (XCDR (position
)); /* EVENT_START (position) */
1516 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1519 else if (WINDOWP (position
) || FRAMEP (position
))
1524 /* Decode where to put the menu. */
1526 if (FRAMEP (window
))
1527 f
= XFRAME (window
);
1528 else if (WINDOWP (window
))
1530 CHECK_LIVE_WINDOW (window
);
1531 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
1534 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1535 but I don't want to make one now. */
1536 CHECK_WINDOW (window
);
1538 /* Force a redisplay before showing the dialog. If a frame is created
1539 just before showing the dialog, its contents may not have been fully
1540 drawn, as this depends on timing of events from the X server. Redisplay
1541 is not done when a dialog is shown. If redisplay could be done in the
1542 X event loop (i.e. the X event loop does not run in a signal handler)
1543 this would not be needed.
1545 Do this before creating the widget value that points to Lisp
1546 string contents, because Fredisplay may GC and relocate them. */
1549 /* Display the popup dialog by a terminal-specific hook ... */
1550 if (FRAME_TERMINAL (f
)->popup_dialog_hook
)
1552 Lisp_Object selection
1553 = FRAME_TERMINAL (f
)->popup_dialog_hook (f
, header
, contents
);
1555 /* NTGUI supports only simple dialogs with Yes/No choices. For
1556 other dialogs, it returns the symbol 'unsupported--w32-dialog',
1557 as a signal for the caller to fall back to the emulation code. */
1558 if (!EQ (selection
, Qunsupported__w32_dialog
))
1562 /* ... or emulate it with a menu. */
1563 return emulate_dialog_with_menu (f
, contents
);
1571 staticpro (&menu_items
);
1573 menu_items_inuse
= Qnil
;