1 /* Platform-independent code for terminal communications.
2 Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
28 #include "termhooks.h"
29 #include "blockinput.h"
30 #include "dispextern.h"
33 #include "../lwlib/lwlib.h"
51 extern AppendMenuW_Proc unicode_append_menu
;
52 extern HMENU current_popup_menu
;
54 #endif /* HAVE_NTGUI */
58 /* Define HAVE_BOXES if menus can handle radio and toggle buttons. */
59 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NTGUI)
63 Lisp_Object menu_items
;
65 /* If non-nil, means that the global vars defined here are already in use.
66 Used to detect cases where we try to re-enter this non-reentrant code. */
67 Lisp_Object menu_items_inuse
;
69 /* Number of slots currently allocated in menu_items. */
70 int menu_items_allocated
;
72 /* This is the index in menu_items of the first empty slot. */
75 /* The number of panes currently recorded in menu_items,
76 excluding those within submenus. */
77 int menu_items_n_panes
;
79 /* Current depth within submenus. */
80 static int menu_items_submenu_depth
;
83 init_menu_items (void)
85 if (!NILP (menu_items_inuse
))
86 error ("Trying to use a menu from within a menu-entry");
88 if (NILP (menu_items
))
90 menu_items_allocated
= 60;
91 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
94 menu_items_inuse
= Qt
;
96 menu_items_n_panes
= 0;
97 menu_items_submenu_depth
= 0;
100 /* Call at the end of generating the data in menu_items. */
103 finish_menu_items (void)
108 unuse_menu_items (Lisp_Object dummy
)
110 return menu_items_inuse
= Qnil
;
113 /* Call when finished using the data for the current menu
117 discard_menu_items (void)
119 /* Free the structure if it is especially large.
120 Otherwise, hold on to it, to save time. */
121 if (menu_items_allocated
> 200)
124 menu_items_allocated
= 0;
126 xassert (NILP (menu_items_inuse
));
131 cleanup_popup_menu (Lisp_Object arg
)
133 discard_menu_items ();
138 /* This undoes save_menu_items, and it is called by the specpdl unwind
142 restore_menu_items (Lisp_Object saved
)
144 menu_items
= XCAR (saved
);
145 menu_items_inuse
= (! NILP (menu_items
) ? Qt
: Qnil
);
146 menu_items_allocated
= (VECTORP (menu_items
) ? ASIZE (menu_items
) : 0);
147 saved
= XCDR (saved
);
148 menu_items_used
= XINT (XCAR (saved
));
149 saved
= XCDR (saved
);
150 menu_items_n_panes
= XINT (XCAR (saved
));
151 saved
= XCDR (saved
);
152 menu_items_submenu_depth
= XINT (XCAR (saved
));
156 /* Push the whole state of menu_items processing onto the specpdl.
157 It will be restored when the specpdl is unwound. */
160 save_menu_items (void)
162 Lisp_Object saved
= list4 (!NILP (menu_items_inuse
) ? menu_items
: Qnil
,
163 make_number (menu_items_used
),
164 make_number (menu_items_n_panes
),
165 make_number (menu_items_submenu_depth
));
166 record_unwind_protect (restore_menu_items
, saved
);
167 menu_items_inuse
= Qnil
;
172 /* Make the menu_items vector twice as large. */
175 grow_menu_items (void)
177 menu_items_allocated
*= 2;
178 menu_items
= larger_vector (menu_items
, menu_items_allocated
, Qnil
);
181 /* Begin a submenu. */
184 push_submenu_start (void)
186 if (menu_items_used
+ 1 > menu_items_allocated
)
189 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
190 menu_items_submenu_depth
++;
196 push_submenu_end (void)
198 if (menu_items_used
+ 1 > menu_items_allocated
)
201 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
202 menu_items_submenu_depth
--;
205 /* Indicate boundary between left and right. */
208 push_left_right_boundary (void)
210 if (menu_items_used
+ 1 > menu_items_allocated
)
213 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
216 /* Start a new menu pane in menu_items.
217 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
220 push_menu_pane (Lisp_Object name
, Lisp_Object prefix_vec
)
222 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
225 if (menu_items_submenu_depth
== 0)
226 menu_items_n_panes
++;
227 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
228 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
229 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
232 /* Push one menu item into the current pane. NAME is the string to
233 display. ENABLE if non-nil means this item can be selected. KEY
234 is the key generated by choosing this item, or nil if this item
235 doesn't really have a definition. DEF is the definition of this
236 item. EQUIV is the textual description of the keyboard equivalent
237 for this item (or nil if none). TYPE is the type of this menu
238 item, one of nil, `toggle' or `radio'. */
241 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
)
243 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
246 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_NAME
, name
);
247 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_ENABLE
, enable
);
248 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_VALUE
, key
);
249 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_EQUIV_KEY
, equiv
);
250 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_DEFINITION
, def
);
251 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_TYPE
, type
);
252 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_SELECTED
, selected
);
253 ASET (menu_items
, menu_items_used
+ MENU_ITEMS_ITEM_HELP
, help
);
255 menu_items_used
+= MENU_ITEMS_ITEM_LENGTH
;
258 /* Args passed between single_keymap_panes and single_menu_item. */
261 Lisp_Object pending_maps
;
266 static void single_menu_item (Lisp_Object
, Lisp_Object
, Lisp_Object
,
269 /* This is a recursive subroutine of keymap_panes.
270 It handles one keymap, KEYMAP.
271 The other arguments are passed along
272 or point to local variables of the previous function.
274 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
277 single_keymap_panes (Lisp_Object keymap
, Lisp_Object pane_name
,
278 Lisp_Object prefix
, int maxdepth
)
283 skp
.pending_maps
= Qnil
;
284 skp
.maxdepth
= maxdepth
;
290 push_menu_pane (pane_name
, prefix
);
293 /* Remember index for first item in this pane so we can go back and
294 add a prefix when (if) we see the first button. After that, notbuttons
295 is set to 0, to mark that we have seen a button and all non button
296 items need a prefix. */
297 skp
.notbuttons
= menu_items_used
;
300 GCPRO1 (skp
.pending_maps
);
301 map_keymap_canonical (keymap
, single_menu_item
, Qnil
, &skp
);
304 /* Process now any submenus which want to be panes at this level. */
305 while (CONSP (skp
.pending_maps
))
307 Lisp_Object elt
, eltcdr
, string
;
308 elt
= XCAR (skp
.pending_maps
);
310 string
= XCAR (eltcdr
);
311 /* We no longer discard the @ from the beginning of the string here.
312 Instead, we do this in *menu_show. */
313 single_keymap_panes (Fcar (elt
), string
, XCDR (eltcdr
), maxdepth
- 1);
314 skp
.pending_maps
= XCDR (skp
.pending_maps
);
318 /* This is a subroutine of single_keymap_panes that handles one
320 KEY is a key in a keymap and ITEM is its binding.
321 SKP->PENDING_MAPS_PTR is a list of keymaps waiting to be made into
323 If we encounter submenus deeper than SKP->MAXDEPTH levels, ignore them. */
326 single_menu_item (Lisp_Object key
, Lisp_Object item
, Lisp_Object dummy
, void *skp_v
)
328 Lisp_Object map
, item_string
, enabled
;
329 struct gcpro gcpro1
, gcpro2
;
331 struct skp
*skp
= skp_v
;
333 /* Parse the menu item and leave the result in item_properties. */
335 res
= parse_menu_item (item
, 0);
338 return; /* Not a menu item. */
340 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
342 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
343 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
345 if (!NILP (map
) && SREF (item_string
, 0) == '@')
348 /* An enabled separate pane. Remember this to handle it later. */
349 skp
->pending_maps
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
354 #if defined(HAVE_X_WINDOWS) || defined(MSDOS)
356 /* Simulate radio buttons and toggle boxes by putting a prefix in
359 Lisp_Object prefix
= Qnil
;
360 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
364 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
367 /* The first button. Line up previous items in this menu. */
369 int index
= skp
->notbuttons
; /* Index for first item this menu. */
372 while (index
< menu_items_used
)
375 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
379 submenu
++; /* Skip sub menu. */
381 else if (EQ (tem
, Qlambda
))
384 submenu
--; /* End sub menu. */
386 else if (EQ (tem
, Qt
))
387 index
+= 3; /* Skip new pane marker. */
388 else if (EQ (tem
, Qquote
))
389 index
++; /* Skip a left, right divider. */
392 if (!submenu
&& SREF (tem
, 0) != '\0'
393 && SREF (tem
, 0) != '-')
394 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
395 = concat2 (build_string (" "), tem
);
396 index
+= MENU_ITEMS_ITEM_LENGTH
;
402 /* Calculate prefix, if any, for this item. */
403 if (EQ (type
, QCtoggle
))
404 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
405 else if (EQ (type
, QCradio
))
406 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
408 /* Not a button. If we have earlier buttons, then we need a prefix. */
409 else if (!skp
->notbuttons
&& SREF (item_string
, 0) != '\0'
410 && SREF (item_string
, 0) != '-')
411 prefix
= build_string (" ");
414 item_string
= concat2 (prefix
, item_string
);
416 #endif /* not HAVE_BOXES */
418 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
420 /* Indicate visually that this is a submenu. */
421 item_string
= concat2 (item_string
, build_string (" >"));
424 #endif /* HAVE_X_WINDOWS || MSDOS */
426 push_menu_item (item_string
, enabled
, key
,
427 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
428 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
429 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
430 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
431 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
433 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
434 /* Display a submenu using the toolkit. */
435 if (! (NILP (map
) || NILP (enabled
)))
437 push_submenu_start ();
438 single_keymap_panes (map
, Qnil
, key
, skp
->maxdepth
- 1);
444 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
445 and generate menu panes for them in menu_items. */
448 keymap_panes (Lisp_Object
*keymaps
, int nmaps
)
454 /* Loop over the given keymaps, making a pane for each map.
455 But don't make a pane that is empty--ignore that map instead.
456 P is the number of panes we have made so far. */
457 for (mapno
= 0; mapno
< nmaps
; mapno
++)
458 single_keymap_panes (keymaps
[mapno
],
459 Fkeymap_prompt (keymaps
[mapno
]), Qnil
, 10);
461 finish_menu_items ();
465 /* Push the items in a single pane defined by the alist PANE. */
467 list_of_items (Lisp_Object pane
)
469 Lisp_Object tail
, item
, item1
;
471 for (tail
= pane
; CONSP (tail
); tail
= XCDR (tail
))
475 push_menu_item (ENCODE_MENU_STRING (item
), Qnil
, Qnil
, Qt
,
476 Qnil
, Qnil
, Qnil
, Qnil
);
477 else if (CONSP (item
))
480 CHECK_STRING (item1
);
481 push_menu_item (ENCODE_MENU_STRING (item1
), Qt
, XCDR (item
),
482 Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
485 push_left_right_boundary ();
490 /* Push all the panes and items of a menu described by the
491 alist-of-alists MENU.
492 This handles old-fashioned calls to x-popup-menu. */
494 list_of_panes (Lisp_Object menu
)
500 for (tail
= menu
; CONSP (tail
); tail
= XCDR (tail
))
502 Lisp_Object elt
, pane_name
, pane_data
;
504 pane_name
= Fcar (elt
);
505 CHECK_STRING (pane_name
);
506 push_menu_pane (ENCODE_MENU_STRING (pane_name
), Qnil
);
507 pane_data
= Fcdr (elt
);
508 CHECK_CONS (pane_data
);
509 list_of_items (pane_data
);
512 finish_menu_items ();
515 /* Set up data in menu_items for a menu bar item
516 whose event type is ITEM_KEY (with string ITEM_NAME)
517 and whose contents come from the list of keymaps MAPS. */
519 parse_single_submenu (Lisp_Object item_key
, Lisp_Object item_name
, Lisp_Object maps
)
525 int top_level_items
= 0;
527 length
= Flength (maps
);
530 /* Convert the list MAPS into a vector MAPVEC. */
531 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
532 for (i
= 0; i
< len
; i
++)
534 mapvec
[i
] = Fcar (maps
);
538 /* Loop over the given keymaps, making a pane for each map.
539 But don't make a pane that is empty--ignore that map instead. */
540 for (i
= 0; i
< len
; i
++)
542 if (!KEYMAPP (mapvec
[i
]))
544 /* Here we have a command at top level in the menu bar
545 as opposed to a submenu. */
547 push_menu_pane (Qnil
, Qnil
);
548 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
549 Qnil
, Qnil
, Qnil
, Qnil
);
554 prompt
= Fkeymap_prompt (mapvec
[i
]);
555 single_keymap_panes (mapvec
[i
],
556 !NILP (prompt
) ? prompt
: item_name
,
561 return top_level_items
;
565 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS) || defined (HAVE_NTGUI)
567 /* Allocate a widget_value, blocking input. */
570 xmalloc_widget_value (void)
575 value
= malloc_widget_value ();
581 /* This recursively calls free_widget_value on the tree of widgets.
582 It must free all data that was malloc'ed for these widget_values.
583 In Emacs, many slots are pointers into the data of Lisp_Strings, and
584 must be left alone. */
587 free_menubar_widget_value_tree (widget_value
*wv
)
591 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
593 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
595 free_menubar_widget_value_tree (wv
->contents
);
596 wv
->contents
= (widget_value
*) 0xDEADBEEF;
600 free_menubar_widget_value_tree (wv
->next
);
601 wv
->next
= (widget_value
*) 0xDEADBEEF;
604 free_widget_value (wv
);
608 /* Create a tree of widget_value objects
609 representing the panes and items
610 in menu_items starting at index START, up to index END. */
613 digest_single_submenu (int start
, int end
, int top_level_items
)
615 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
617 int submenu_depth
= 0;
618 widget_value
**submenu_stack
;
622 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
623 wv
= xmalloc_widget_value ();
627 wv
->button_type
= BUTTON_TYPE_NONE
;
633 /* Loop over all panes and items made by the preceding call
634 to parse_single_submenu and construct a tree of widget_value objects.
635 Ignore the panes and items used by previous calls to
636 digest_single_submenu, even though those are also in menu_items. */
640 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
642 submenu_stack
[submenu_depth
++] = save_wv
;
647 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
650 save_wv
= submenu_stack
[--submenu_depth
];
653 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
654 && submenu_depth
!= 0)
655 i
+= MENU_ITEMS_PANE_LENGTH
;
656 /* Ignore a nil in the item list.
657 It's meaningful only for dialog boxes. */
658 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
660 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
662 /* Create a new pane. */
663 Lisp_Object pane_name
, prefix
;
664 const char *pane_string
;
668 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
669 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
672 if (STRINGP (pane_name
))
674 if (unicode_append_menu
)
675 /* Encode as UTF-8 for now. */
676 pane_name
= ENCODE_UTF_8 (pane_name
);
677 else if (STRING_MULTIBYTE (pane_name
))
678 pane_name
= ENCODE_SYSTEM (pane_name
);
680 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
682 #elif defined (USE_LUCID) && defined (HAVE_XFT)
683 if (STRINGP (pane_name
))
685 pane_name
= ENCODE_UTF_8 (pane_name
);
686 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
688 #elif !defined (HAVE_MULTILINGUAL_MENU)
689 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
691 pane_name
= ENCODE_MENU_STRING (pane_name
);
692 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
696 pane_string
= (NILP (pane_name
)
697 ? "" : SSDATA (pane_name
));
698 /* If there is just one top-level pane, put all its items directly
699 under the top-level menu. */
700 if (menu_items_n_panes
== 1)
703 /* If the pane has a meaningful name,
704 make the pane a top-level menu item
705 with its items as a submenu beneath it. */
706 if (strcmp (pane_string
, ""))
708 wv
= xmalloc_widget_value ();
712 first_wv
->contents
= wv
;
713 wv
->lname
= pane_name
;
714 /* Set value to 1 so update_submenu_strings can handle '@' */
715 wv
->value
= (char *)1;
717 wv
->button_type
= BUTTON_TYPE_NONE
;
725 i
+= MENU_ITEMS_PANE_LENGTH
;
729 /* Create a new item within current pane. */
730 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
733 /* All items should be contained in panes. */
737 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
738 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
739 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
740 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
741 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
742 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
743 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
746 if (STRINGP (item_name
))
748 if (unicode_append_menu
)
749 item_name
= ENCODE_UTF_8 (item_name
);
750 else if (STRING_MULTIBYTE (item_name
))
751 item_name
= ENCODE_SYSTEM (item_name
);
753 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
756 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
758 descrip
= ENCODE_SYSTEM (descrip
);
759 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
762 if (STRINGP (item_name
))
764 item_name
= ENCODE_UTF_8 (item_name
);
765 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
768 if (STRINGP (descrip
))
770 descrip
= ENCODE_UTF_8 (descrip
);
771 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
773 #elif !defined (HAVE_MULTILINGUAL_MENU)
774 if (STRING_MULTIBYTE (item_name
))
776 item_name
= ENCODE_MENU_STRING (item_name
);
777 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
780 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
782 descrip
= ENCODE_MENU_STRING (descrip
);
783 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
787 wv
= xmalloc_widget_value ();
791 save_wv
->contents
= wv
;
793 wv
->lname
= item_name
;
797 /* The EMACS_INT cast avoids a warning. There's no problem
798 as long as pointers have enough bits to hold small integers. */
799 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
800 wv
->enabled
= !NILP (enable
);
803 wv
->button_type
= BUTTON_TYPE_NONE
;
804 else if (EQ (type
, QCradio
))
805 wv
->button_type
= BUTTON_TYPE_RADIO
;
806 else if (EQ (type
, QCtoggle
))
807 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
811 wv
->selected
= !NILP (selected
);
812 if (! STRINGP (help
))
819 i
+= MENU_ITEMS_ITEM_LENGTH
;
823 /* If we have just one "menu item"
824 that was originally a button, return it by itself. */
825 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
827 wv
= first_wv
->contents
;
828 free_widget_value (first_wv
);
835 /* Walk through the widget_value tree starting at FIRST_WV and update
836 the char * pointers from the corresponding lisp values.
837 We do this after building the whole tree, since GC may happen while the
838 tree is constructed, and small strings are relocated. So we must wait
839 until no GC can happen before storing pointers into lisp values. */
841 update_submenu_strings (widget_value
*first_wv
)
845 for (wv
= first_wv
; wv
; wv
= wv
->next
)
847 if (STRINGP (wv
->lname
))
849 wv
->name
= SSDATA (wv
->lname
);
851 /* Ignore the @ that means "separate pane".
852 This is a kludge, but this isn't worth more time. */
853 if (wv
->value
== (char *)1)
855 if (wv
->name
[0] == '@')
861 if (STRINGP (wv
->lkey
))
862 wv
->key
= SSDATA (wv
->lkey
);
865 update_submenu_strings (wv
->contents
);
869 /* Find the menu selection and store it in the keyboard buffer.
870 F is the frame the menu is on.
871 MENU_BAR_ITEMS_USED is the length of VECTOR.
872 VECTOR is an array of menu events for the whole menu. */
875 find_and_call_menu_selection (FRAME_PTR f
, int menu_bar_items_used
, Lisp_Object vector
, void *client_data
)
877 Lisp_Object prefix
, entry
;
878 Lisp_Object
*subprefix_stack
;
879 int submenu_depth
= 0;
883 subprefix_stack
= (Lisp_Object
*) alloca (menu_bar_items_used
* sizeof (Lisp_Object
));
887 while (i
< menu_bar_items_used
)
889 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
891 subprefix_stack
[submenu_depth
++] = prefix
;
895 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
897 prefix
= subprefix_stack
[--submenu_depth
];
900 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
902 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
903 i
+= MENU_ITEMS_PANE_LENGTH
;
907 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
908 /* The EMACS_INT cast avoids a warning. There's no problem
909 as long as pointers have enough bits to hold small integers. */
910 if ((int) (EMACS_INT
) client_data
== i
)
913 struct input_event buf
;
917 XSETFRAME (frame
, f
);
918 buf
.kind
= MENU_BAR_EVENT
;
919 buf
.frame_or_window
= frame
;
921 kbd_buffer_store_event (&buf
);
923 for (j
= 0; j
< submenu_depth
; j
++)
924 if (!NILP (subprefix_stack
[j
]))
926 buf
.kind
= MENU_BAR_EVENT
;
927 buf
.frame_or_window
= frame
;
928 buf
.arg
= subprefix_stack
[j
];
929 kbd_buffer_store_event (&buf
);
934 buf
.kind
= MENU_BAR_EVENT
;
935 buf
.frame_or_window
= frame
;
937 kbd_buffer_store_event (&buf
);
940 buf
.kind
= MENU_BAR_EVENT
;
941 buf
.frame_or_window
= frame
;
943 kbd_buffer_store_event (&buf
);
947 i
+= MENU_ITEMS_ITEM_LENGTH
;
952 #endif /* USE_X_TOOLKIT || USE_GTK || HAVE_NS || HAVE_NTGUI */
955 /* As above, but return the menu selection instead of storing in kb buffer.
956 If keymaps==1, return full prefixes to selection. */
958 find_and_return_menu_selection (FRAME_PTR f
, int keymaps
, void *client_data
)
960 Lisp_Object prefix
, entry
;
962 Lisp_Object
*subprefix_stack
;
963 int submenu_depth
= 0;
965 prefix
= entry
= Qnil
;
968 (Lisp_Object
*)alloca(menu_items_used
* sizeof (Lisp_Object
));
970 while (i
< menu_items_used
)
972 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
974 subprefix_stack
[submenu_depth
++] = prefix
;
978 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
980 prefix
= subprefix_stack
[--submenu_depth
];
983 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
986 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
987 i
+= MENU_ITEMS_PANE_LENGTH
;
989 /* Ignore a nil in the item list.
990 It's meaningful only for dialog boxes. */
991 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
996 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
997 if ((EMACS_INT
)client_data
== (EMACS_INT
)(&XVECTOR (menu_items
)->contents
[i
]))
1003 entry
= Fcons (entry
, Qnil
);
1005 entry
= Fcons (prefix
, entry
);
1006 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1007 if (!NILP (subprefix_stack
[j
]))
1008 entry
= Fcons (subprefix_stack
[j
], entry
);
1012 i
+= MENU_ITEMS_ITEM_LENGTH
;
1017 #endif /* HAVE_NS */
1019 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
1020 doc
: /* Pop up a deck-of-cards menu and return user's selection.
1021 POSITION is a position specification. This is either a mouse button event
1022 or a list ((XOFFSET YOFFSET) WINDOW)
1023 where XOFFSET and YOFFSET are positions in pixels from the top left
1024 corner of WINDOW. (WINDOW may be a window or a frame object.)
1025 This controls the position of the top left of the menu as a whole.
1026 If POSITION is t, it means to use the current mouse position.
1028 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
1029 The menu items come from key bindings that have a menu string as well as
1030 a definition; actually, the "definition" in such a key binding looks like
1031 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
1032 the keymap as a top-level element.
1034 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
1035 Otherwise, REAL-DEFINITION should be a valid key binding definition.
1037 You can also use a list of keymaps as MENU.
1038 Then each keymap makes a separate pane.
1040 When MENU is a keymap or a list of keymaps, the return value is the
1041 list of events corresponding to the user's choice. Note that
1042 `x-popup-menu' does not actually execute the command bound to that
1045 Alternatively, you can specify a menu of multiple panes
1046 with a list of the form (TITLE PANE1 PANE2...),
1047 where each pane is a list of form (TITLE ITEM1 ITEM2...).
1048 Each ITEM is normally a cons cell (STRING . VALUE);
1049 but a string can appear as an item--that makes a nonselectable line
1051 With this form of menu, the return value is VALUE from the chosen item.
1053 If POSITION is nil, don't display the menu at all, just precalculate the
1054 cached information about equivalent key sequences.
1056 If the user gets rid of the menu without making a valid choice, for
1057 instance by clicking the mouse away from a valid choice or by typing
1058 keyboard input, then this normally results in a quit and
1059 `x-popup-menu' does not return. But if POSITION is a mouse button
1060 event (indicating that the user invoked the menu with the mouse) then
1061 no quit occurs and `x-popup-menu' returns nil. */)
1062 (Lisp_Object position
, Lisp_Object menu
)
1064 Lisp_Object keymap
, tem
;
1065 int xpos
= 0, ypos
= 0;
1067 const char *error_name
= NULL
;
1068 Lisp_Object selection
= Qnil
;
1070 Lisp_Object x
, y
, window
;
1073 int specpdl_count
= SPECPDL_INDEX ();
1074 struct gcpro gcpro1
;
1076 if (NILP (position
))
1077 /* This is an obsolete call, which wants us to precompute the
1078 keybinding equivalents, but we don't do that any more anyway. */
1083 int get_current_pos_p
= 0;
1084 /* FIXME!! check_w32 (); or check_x (); or check_ns (); */
1086 /* Decode the first argument: find the window and the coordinates. */
1087 if (EQ (position
, Qt
)
1088 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
1089 || EQ (XCAR (position
), Qtool_bar
))))
1091 get_current_pos_p
= 1;
1095 tem
= Fcar (position
);
1098 window
= Fcar (Fcdr (position
));
1100 y
= Fcar (XCDR (tem
));
1105 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
1106 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
1107 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
1112 /* If a click happens in an external tool bar or a detached
1113 tool bar, x and y is NIL. In that case, use the current
1114 mouse position. This happens for the help button in the
1115 tool bar. Ideally popup-menu should pass NIL to
1116 this function, but it doesn't. */
1117 if (NILP (x
) && NILP (y
))
1118 get_current_pos_p
= 1;
1121 if (get_current_pos_p
)
1123 /* Use the mouse's current position. */
1124 FRAME_PTR new_f
= SELECTED_FRAME ();
1125 #ifdef HAVE_X_WINDOWS
1126 /* Can't use mouse_position_hook for X since it returns
1127 coordinates relative to the window the mouse is in,
1128 we need coordinates relative to the edit widget always. */
1133 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
1134 /* cur_x/y may be negative, so use make_number. */
1135 x
= make_number (cur_x
);
1136 y
= make_number (cur_y
);
1139 #else /* not HAVE_X_WINDOWS */
1140 Lisp_Object bar_window
;
1141 enum scroll_bar_part part
;
1143 void (*mouse_position_hook
) (struct frame
**, int,
1145 enum scroll_bar_part
*,
1149 FRAME_TERMINAL (new_f
)->mouse_position_hook
;
1151 if (mouse_position_hook
)
1152 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
1153 &part
, &x
, &y
, &time
);
1154 #endif /* not HAVE_X_WINDOWS */
1157 XSETFRAME (window
, new_f
);
1160 window
= selected_window
;
1169 /* Decode where to put the menu. */
1171 if (FRAMEP (window
))
1173 f
= XFRAME (window
);
1177 else if (WINDOWP (window
))
1179 struct window
*win
= XWINDOW (window
);
1180 CHECK_LIVE_WINDOW (window
);
1181 f
= XFRAME (WINDOW_FRAME (win
));
1183 xpos
= WINDOW_LEFT_EDGE_X (win
);
1184 ypos
= WINDOW_TOP_EDGE_Y (win
);
1187 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
1188 but I don't want to make one now. */
1189 CHECK_WINDOW (window
);
1194 /* FIXME: Find a more general check! */
1195 if (!(FRAME_X_P (f
) || FRAME_MSDOS_P (f
)
1196 || FRAME_W32_P (f
) || FRAME_NS_P (f
)))
1197 error ("Can not put GUI menu on this terminal");
1199 XSETFRAME (Vmenu_updating_frame
, f
);
1201 #endif /* HAVE_MENUS */
1203 /* Now parse the lisp menus. */
1204 record_unwind_protect (unuse_menu_items
, Qnil
);
1209 /* Decode the menu items from what was specified. */
1211 keymap
= get_keymap (menu
, 0, 0);
1214 /* We were given a keymap. Extract menu info from the keymap. */
1217 /* Extract the detailed info to make one pane. */
1218 keymap_panes (&menu
, 1);
1220 /* Search for a string appearing directly as an element of the keymap.
1221 That string is the title of the menu. */
1222 prompt
= Fkeymap_prompt (keymap
);
1225 #ifdef HAVE_NS /* Is that needed and NS-specific? --Stef */
1227 title
= build_string ("Select");
1230 /* Make that be the pane title of the first pane. */
1231 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
1232 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, prompt
);
1236 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
1238 /* We were given a list of keymaps. */
1239 int nmaps
= XFASTINT (Flength (menu
));
1241 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
1246 /* The first keymap that has a prompt string
1247 supplies the menu title. */
1248 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
1252 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
1254 prompt
= Fkeymap_prompt (keymap
);
1255 if (NILP (title
) && !NILP (prompt
))
1259 /* Extract the detailed info to make one pane. */
1260 keymap_panes (maps
, nmaps
);
1262 /* Make the title be the pane title of the first pane. */
1263 if (!NILP (title
) && menu_items_n_panes
>= 0)
1264 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, title
);
1270 /* We were given an old-fashioned menu. */
1271 title
= Fcar (menu
);
1272 CHECK_STRING (title
);
1274 list_of_panes (Fcdr (menu
));
1279 unbind_to (specpdl_count
, Qnil
);
1282 #ifdef HAVE_WINDOW_SYSTEM
1283 /* Hide a previous tip, if any. */
1287 #ifdef HAVE_NTGUI /* FIXME: Is it really w32-specific? --Stef */
1288 /* If resources from a previous popup menu still exist, does nothing
1289 until the `menu_free_timer' has freed them (see w32fns.c). This
1290 can occur if you press ESC or click outside a menu without selecting
1293 if (current_popup_menu
)
1295 discard_menu_items ();
1296 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1302 #ifdef HAVE_NS /* FIXME: ns-specific, why? --Stef */
1303 record_unwind_protect (cleanup_popup_menu
, Qnil
);
1306 /* Display them in a menu. */
1309 /* FIXME: Use a terminal hook! */
1310 #if defined HAVE_NTGUI
1311 selection
= w32_menu_show (f
, xpos
, ypos
, for_click
,
1312 keymaps
, title
, &error_name
);
1313 #elif defined HAVE_NS
1314 selection
= ns_menu_show (f
, xpos
, ypos
, for_click
,
1315 keymaps
, title
, &error_name
);
1316 #else /* MSDOS and X11 */
1317 /* Assume last_event_timestamp is the timestamp of the button event.
1318 Is this assumption ever violated? We can't use the timestamp
1319 stored within POSITION because there the top bits from the actual
1320 timestamp may be truncated away (Bug#4930). */
1321 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
1322 keymaps
, title
, &error_name
,
1323 last_event_timestamp
);
1329 unbind_to (specpdl_count
, Qnil
);
1331 discard_menu_items ();
1334 #ifdef HAVE_NTGUI /* FIXME: Is it really w32-specific? --Stef */
1335 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1338 #endif /* HAVE_MENUS */
1342 if (error_name
) error (error_name
);
1349 staticpro (&menu_items
);
1351 menu_items_inuse
= Qnil
;
1353 defsubr (&Sx_popup_menu
);