(large-file-warning-threshold): Add type, groups.
[emacs.git] / src / w32menu.c
blob872cb12e9977cffe094728ab803929a7ad6344a6
1 /* Menu support for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1986, 88, 93, 94, 96, 98, 1999 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 2, or (at your option)
9 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; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 #include <config.h>
22 #include <signal.h>
24 #include <stdio.h>
25 #include "lisp.h"
26 #include "termhooks.h"
27 #include "keyboard.h"
28 #include "keymap.h"
29 #include "frame.h"
30 #include "window.h"
31 #include "blockinput.h"
32 #include "buffer.h"
33 #include "charset.h"
34 #include "coding.h"
36 /* This may include sys/types.h, and that somehow loses
37 if this is not done before the other system files. */
38 #include "w32term.h"
40 /* Load sys/types.h if not already loaded.
41 In some systems loading it twice is suicidal. */
42 #ifndef makedev
43 #include <sys/types.h>
44 #endif
46 #include "dispextern.h"
48 #undef HAVE_MULTILINGUAL_MENU
49 #undef HAVE_DIALOGS /* TODO: Implement native dialogs. */
51 /******************************************************************/
52 /* Definitions copied from lwlib.h */
54 typedef void * XtPointer;
55 typedef char Boolean;
57 enum button_type
59 BUTTON_TYPE_NONE,
60 BUTTON_TYPE_TOGGLE,
61 BUTTON_TYPE_RADIO
64 /* This structure is based on the one in ../lwlib/lwlib.h, modified
65 for Windows. */
66 typedef struct _widget_value
68 /* name of widget */
69 char* name;
70 /* value (meaning depend on widget type) */
71 char* value;
72 /* keyboard equivalent. no implications for XtTranslations */
73 char* key;
74 /* Help string or nil if none.
75 GC finds this string through the frame's menu_bar_vector
76 or through menu_items. */
77 Lisp_Object help;
78 /* true if enabled */
79 Boolean enabled;
80 /* true if selected */
81 Boolean selected;
82 /* The type of a button. */
83 enum button_type button_type;
84 /* true if menu title */
85 Boolean title;
86 #if 0
87 /* true if was edited (maintained by get_value) */
88 Boolean edited;
89 /* true if has changed (maintained by lw library) */
90 change_type change;
91 /* true if this widget itself has changed,
92 but not counting the other widgets found in the `next' field. */
93 change_type this_one_change;
94 #endif
95 /* Contents of the sub-widgets, also selected slot for checkbox */
96 struct _widget_value* contents;
97 /* data passed to callback */
98 XtPointer call_data;
99 /* next one in the list */
100 struct _widget_value* next;
101 #if 0
102 /* slot for the toolkit dependent part. Always initialize to NULL. */
103 void* toolkit_data;
104 /* tell us if we should free the toolkit data slot when freeing the
105 widget_value itself. */
106 Boolean free_toolkit_data;
108 /* we resource the widget_value structures; this points to the next
109 one on the free list if this one has been deallocated.
111 struct _widget_value *free_list;
112 #endif
113 } widget_value;
115 /* Local memory management */
116 #define local_heap (GetProcessHeap ())
117 #define local_alloc(n) (HeapAlloc (local_heap, HEAP_ZERO_MEMORY, (n)))
118 #define local_free(p) (HeapFree (local_heap, 0, ((LPVOID) (p))))
120 #define malloc_widget_value() ((widget_value *) local_alloc (sizeof (widget_value)))
121 #define free_widget_value(wv) (local_free ((wv)))
123 /******************************************************************/
125 #ifndef TRUE
126 #define TRUE 1
127 #define FALSE 0
128 #endif /* no TRUE */
130 static HMENU current_popup_menu;
132 void syms_of_w32menu ();
133 void globals_of_w32menu ();
135 typedef BOOL (WINAPI * GetMenuItemInfoA_Proc) (
136 IN HMENU,
137 IN UINT,
138 IN BOOL,
139 IN OUT LPMENUITEMINFOA
141 typedef BOOL (WINAPI * SetMenuItemInfoA_Proc) (
142 IN HMENU,
143 IN UINT,
144 IN BOOL,
145 IN LPCMENUITEMINFOA
148 GetMenuItemInfoA_Proc get_menu_item_info=NULL;
149 SetMenuItemInfoA_Proc set_menu_item_info=NULL;
151 Lisp_Object Vmenu_updating_frame;
153 Lisp_Object Qdebug_on_next_call;
155 extern Lisp_Object Qmenu_bar;
156 extern Lisp_Object Qmouse_click, Qevent_kind;
158 extern Lisp_Object QCtoggle, QCradio;
160 extern Lisp_Object Voverriding_local_map;
161 extern Lisp_Object Voverriding_local_map_menu_flag;
163 extern Lisp_Object Qoverriding_local_map, Qoverriding_terminal_local_map;
165 extern Lisp_Object Qmenu_bar_update_hook;
167 void set_frame_menubar ();
169 static void push_menu_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
170 Lisp_Object, Lisp_Object, Lisp_Object,
171 Lisp_Object, Lisp_Object));
172 #ifdef HAVE_DIALOGS
173 static Lisp_Object w32_dialog_show ();
174 #endif
175 static Lisp_Object w32_menu_show ();
177 static void keymap_panes ();
178 static void single_keymap_panes ();
179 static void single_menu_item ();
180 static void list_of_panes ();
181 static void list_of_items ();
182 void w32_free_menu_strings (HWND);
184 /* This holds a Lisp vector that holds the results of decoding
185 the keymaps or alist-of-alists that specify a menu.
187 It describes the panes and items within the panes.
189 Each pane is described by 3 elements in the vector:
190 t, the pane name, the pane's prefix key.
191 Then follow the pane's items, with 5 elements per item:
192 the item string, the enable flag, the item's value,
193 the definition, and the equivalent keyboard key's description string.
195 In some cases, multiple levels of menus may be described.
196 A single vector slot containing nil indicates the start of a submenu.
197 A single vector slot containing lambda indicates the end of a submenu.
198 The submenu follows a menu item which is the way to reach the submenu.
200 A single vector slot containing quote indicates that the
201 following items should appear on the right of a dialog box.
203 Using a Lisp vector to hold this information while we decode it
204 takes care of protecting all the data from GC. */
206 #define MENU_ITEMS_PANE_NAME 1
207 #define MENU_ITEMS_PANE_PREFIX 2
208 #define MENU_ITEMS_PANE_LENGTH 3
210 enum menu_item_idx
212 MENU_ITEMS_ITEM_NAME = 0,
213 MENU_ITEMS_ITEM_ENABLE,
214 MENU_ITEMS_ITEM_VALUE,
215 MENU_ITEMS_ITEM_EQUIV_KEY,
216 MENU_ITEMS_ITEM_DEFINITION,
217 MENU_ITEMS_ITEM_TYPE,
218 MENU_ITEMS_ITEM_SELECTED,
219 MENU_ITEMS_ITEM_HELP,
220 MENU_ITEMS_ITEM_LENGTH
223 static Lisp_Object menu_items;
225 /* Number of slots currently allocated in menu_items. */
226 static int menu_items_allocated;
228 /* This is the index in menu_items of the first empty slot. */
229 static int menu_items_used;
231 /* The number of panes currently recorded in menu_items,
232 excluding those within submenus. */
233 static int menu_items_n_panes;
235 /* Current depth within submenus. */
236 static int menu_items_submenu_depth;
238 /* Flag which when set indicates a dialog or menu has been posted by
239 Xt on behalf of one of the widget sets. */
240 static int popup_activated_flag;
242 static int next_menubar_widget_id;
244 /* This is set nonzero after the user activates the menu bar, and set
245 to zero again after the menu bars are redisplayed by prepare_menu_bar.
246 While it is nonzero, all calls to set_frame_menubar go deep.
248 I don't understand why this is needed, but it does seem to be
249 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
251 int pending_menu_activation;
254 /* Return the frame whose ->output_data.w32->menubar_widget equals
255 ID, or 0 if none. */
257 static struct frame *
258 menubar_id_to_frame (id)
259 HMENU id;
261 Lisp_Object tail, frame;
262 FRAME_PTR f;
264 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
266 frame = XCAR (tail);
267 if (!GC_FRAMEP (frame))
268 continue;
269 f = XFRAME (frame);
270 if (!FRAME_WINDOW_P (f))
271 continue;
272 if (f->output_data.w32->menubar_widget == id)
273 return f;
275 return 0;
278 /* Initialize the menu_items structure if we haven't already done so.
279 Also mark it as currently empty. */
281 static void
282 init_menu_items ()
284 if (NILP (menu_items))
286 menu_items_allocated = 60;
287 menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
290 menu_items_used = 0;
291 menu_items_n_panes = 0;
292 menu_items_submenu_depth = 0;
295 /* Call at the end of generating the data in menu_items.
296 This fills in the number of items in the last pane. */
298 static void
299 finish_menu_items ()
303 /* Call when finished using the data for the current menu
304 in menu_items. */
306 static void
307 discard_menu_items ()
309 /* Free the structure if it is especially large.
310 Otherwise, hold on to it, to save time. */
311 if (menu_items_allocated > 200)
313 menu_items = Qnil;
314 menu_items_allocated = 0;
318 /* Make the menu_items vector twice as large. */
320 static void
321 grow_menu_items ()
323 Lisp_Object old;
324 int old_size = menu_items_allocated;
325 old = menu_items;
327 menu_items_allocated *= 2;
328 menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
329 bcopy (XVECTOR (old)->contents, XVECTOR (menu_items)->contents,
330 old_size * sizeof (Lisp_Object));
333 /* Begin a submenu. */
335 static void
336 push_submenu_start ()
338 if (menu_items_used + 1 > menu_items_allocated)
339 grow_menu_items ();
341 ASET (menu_items, menu_items_used++, Qnil);
342 menu_items_submenu_depth++;
345 /* End a submenu. */
347 static void
348 push_submenu_end ()
350 if (menu_items_used + 1 > menu_items_allocated)
351 grow_menu_items ();
353 ASET (menu_items, menu_items_used++, Qlambda);
354 menu_items_submenu_depth--;
357 /* Indicate boundary between left and right. */
359 static void
360 push_left_right_boundary ()
362 if (menu_items_used + 1 > menu_items_allocated)
363 grow_menu_items ();
365 ASET (menu_items, menu_items_used++, Qquote);
368 /* Start a new menu pane in menu_items.
369 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
371 static void
372 push_menu_pane (name, prefix_vec)
373 Lisp_Object name, prefix_vec;
375 if (menu_items_used + MENU_ITEMS_PANE_LENGTH > menu_items_allocated)
376 grow_menu_items ();
378 if (menu_items_submenu_depth == 0)
379 menu_items_n_panes++;
380 ASET (menu_items, menu_items_used++, Qt);
381 ASET (menu_items, menu_items_used++, name);
382 ASET (menu_items, menu_items_used++, prefix_vec);
385 /* Push one menu item into the current pane. NAME is the string to
386 display. ENABLE if non-nil means this item can be selected. KEY
387 is the key generated by choosing this item, or nil if this item
388 doesn't really have a definition. DEF is the definition of this
389 item. EQUIV is the textual description of the keyboard equivalent
390 for this item (or nil if none). TYPE is the type of this menu
391 item, one of nil, `toggle' or `radio'. */
393 static void
394 push_menu_item (name, enable, key, def, equiv, type, selected, help)
395 Lisp_Object name, enable, key, def, equiv, type, selected, help;
397 if (menu_items_used + MENU_ITEMS_ITEM_LENGTH > menu_items_allocated)
398 grow_menu_items ();
400 ASET (menu_items, menu_items_used++, name);
401 ASET (menu_items, menu_items_used++, enable);
402 ASET (menu_items, menu_items_used++, key);
403 ASET (menu_items, menu_items_used++, equiv);
404 ASET (menu_items, menu_items_used++, def);
405 ASET (menu_items, menu_items_used++, type);
406 ASET (menu_items, menu_items_used++, selected);
407 ASET (menu_items, menu_items_used++, help);
410 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
411 and generate menu panes for them in menu_items.
412 If NOTREAL is nonzero,
413 don't bother really computing whether an item is enabled. */
415 static void
416 keymap_panes (keymaps, nmaps, notreal)
417 Lisp_Object *keymaps;
418 int nmaps;
419 int notreal;
421 int mapno;
423 init_menu_items ();
425 /* Loop over the given keymaps, making a pane for each map.
426 But don't make a pane that is empty--ignore that map instead.
427 P is the number of panes we have made so far. */
428 for (mapno = 0; mapno < nmaps; mapno++)
429 single_keymap_panes (keymaps[mapno],
430 Fkeymap_prompt (keymaps[mapno]), Qnil, notreal, 10);
432 finish_menu_items ();
435 /* This is a recursive subroutine of keymap_panes.
436 It handles one keymap, KEYMAP.
437 The other arguments are passed along
438 or point to local variables of the previous function.
439 If NOTREAL is nonzero, only check for equivalent key bindings, don't
440 evaluate expressions in menu items and don't make any menu.
442 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
444 static void
445 single_keymap_panes (keymap, pane_name, prefix, notreal, maxdepth)
446 Lisp_Object keymap;
447 Lisp_Object pane_name;
448 Lisp_Object prefix;
449 int notreal;
450 int maxdepth;
452 Lisp_Object pending_maps = Qnil;
453 Lisp_Object tail, item;
454 struct gcpro gcpro1, gcpro2;
456 if (maxdepth <= 0)
457 return;
459 push_menu_pane (pane_name, prefix);
461 for (tail = keymap; CONSP (tail); tail = XCDR (tail))
463 GCPRO2 (keymap, pending_maps);
464 /* Look at each key binding, and if it is a menu item add it
465 to this menu. */
466 item = XCAR (tail);
467 if (CONSP (item))
468 single_menu_item (XCAR (item), XCDR (item),
469 &pending_maps, notreal, maxdepth);
470 else if (VECTORP (item))
472 /* Loop over the char values represented in the vector. */
473 int len = ASIZE (item);
474 int c;
475 for (c = 0; c < len; c++)
477 Lisp_Object character;
478 XSETFASTINT (character, c);
479 single_menu_item (character, AREF (item, c),
480 &pending_maps, notreal, maxdepth);
483 UNGCPRO;
486 /* Process now any submenus which want to be panes at this level. */
487 while (!NILP (pending_maps))
489 Lisp_Object elt, eltcdr, string;
490 elt = Fcar (pending_maps);
491 eltcdr = XCDR (elt);
492 string = XCAR (eltcdr);
493 /* We no longer discard the @ from the beginning of the string here.
494 Instead, we do this in w32_menu_show. */
495 single_keymap_panes (Fcar (elt), string,
496 XCDR (eltcdr), notreal, maxdepth - 1);
497 pending_maps = Fcdr (pending_maps);
501 /* This is a subroutine of single_keymap_panes that handles one
502 keymap entry.
503 KEY is a key in a keymap and ITEM is its binding.
504 PENDING_MAPS_PTR points to a list of keymaps waiting to be made into
505 separate panes.
506 If NOTREAL is nonzero, only check for equivalent key bindings, don't
507 evaluate expressions in menu items and don't make any menu.
508 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
510 static void
511 single_menu_item (key, item, pending_maps_ptr, notreal, maxdepth)
512 Lisp_Object key, item;
513 Lisp_Object *pending_maps_ptr;
514 int maxdepth, notreal;
516 Lisp_Object map, item_string, enabled;
517 struct gcpro gcpro1, gcpro2;
518 int res;
520 /* Parse the menu item and leave the result in item_properties. */
521 GCPRO2 (key, item);
522 res = parse_menu_item (item, notreal, 0);
523 UNGCPRO;
524 if (!res)
525 return; /* Not a menu item. */
527 map = AREF (item_properties, ITEM_PROPERTY_MAP);
529 if (notreal)
531 /* We don't want to make a menu, just traverse the keymaps to
532 precompute equivalent key bindings. */
533 if (!NILP (map))
534 single_keymap_panes (map, Qnil, key, 1, maxdepth - 1);
535 return;
538 enabled = AREF (item_properties, ITEM_PROPERTY_ENABLE);
539 item_string = AREF (item_properties, ITEM_PROPERTY_NAME);
541 if (!NILP (map) && SREF (item_string, 0) == '@')
543 if (!NILP (enabled))
544 /* An enabled separate pane. Remember this to handle it later. */
545 *pending_maps_ptr = Fcons (Fcons (map, Fcons (item_string, key)),
546 *pending_maps_ptr);
547 return;
550 push_menu_item (item_string, enabled, key,
551 AREF (item_properties, ITEM_PROPERTY_DEF),
552 AREF (item_properties, ITEM_PROPERTY_KEYEQ),
553 AREF (item_properties, ITEM_PROPERTY_TYPE),
554 AREF (item_properties, ITEM_PROPERTY_SELECTED),
555 AREF (item_properties, ITEM_PROPERTY_HELP));
557 /* Display a submenu using the toolkit. */
558 if (! (NILP (map) || NILP (enabled)))
560 push_submenu_start ();
561 single_keymap_panes (map, Qnil, key, 0, maxdepth - 1);
562 push_submenu_end ();
566 /* Push all the panes and items of a menu described by the
567 alist-of-alists MENU.
568 This handles old-fashioned calls to x-popup-menu. */
570 static void
571 list_of_panes (menu)
572 Lisp_Object menu;
574 Lisp_Object tail;
576 init_menu_items ();
578 for (tail = menu; !NILP (tail); tail = Fcdr (tail))
580 Lisp_Object elt, pane_name, pane_data;
581 elt = Fcar (tail);
582 pane_name = Fcar (elt);
583 CHECK_STRING (pane_name);
584 push_menu_pane (pane_name, Qnil);
585 pane_data = Fcdr (elt);
586 CHECK_CONS (pane_data);
587 list_of_items (pane_data);
590 finish_menu_items ();
593 /* Push the items in a single pane defined by the alist PANE. */
595 static void
596 list_of_items (pane)
597 Lisp_Object pane;
599 Lisp_Object tail, item, item1;
601 for (tail = pane; !NILP (tail); tail = Fcdr (tail))
603 item = Fcar (tail);
604 if (STRINGP (item))
605 push_menu_item (item, Qnil, Qnil, Qt, Qnil, Qnil, Qnil, Qnil);
606 else if (NILP (item))
607 push_left_right_boundary ();
608 else
610 CHECK_CONS (item);
611 item1 = Fcar (item);
612 CHECK_STRING (item1);
613 push_menu_item (item1, Qt, Fcdr (item), Qt, Qnil, Qnil, Qnil, Qnil);
618 DEFUN ("x-popup-menu", Fx_popup_menu, Sx_popup_menu, 2, 2, 0,
619 doc: /* Pop up a deck-of-cards menu and return user's selection.
620 POSITION is a position specification. This is either a mouse button
621 event or a list ((XOFFSET YOFFSET) WINDOW) where XOFFSET and YOFFSET
622 are positions in pixels from the top left corner of WINDOW's frame
623 \(WINDOW may be a frame object instead of a window). This controls the
624 position of the center of the first line in the first pane of the
625 menu, not the top left of the menu as a whole. If POSITION is t, it
626 means to use the current mouse position.
628 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
629 The menu items come from key bindings that have a menu string as well as
630 a definition; actually, the \"definition\" in such a key binding looks like
631 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
632 the keymap as a top-level element.
634 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
635 Otherwise, REAL-DEFINITION should be a valid key binding definition.
637 You can also use a list of keymaps as MENU. Then each keymap makes a
638 separate pane. When MENU is a keymap or a list of keymaps, the return
639 value is a list of events.
641 Alternatively, you can specify a menu of multiple panes with a list of
642 the form (TITLE PANE1 PANE2...), where each pane is a list of
643 form (TITLE ITEM1 ITEM2...).
644 Each ITEM is normally a cons cell (STRING . VALUE); but a string can
645 appear as an item--that makes a nonselectable line in the menu.
646 With this form of menu, the return value is VALUE from the chosen item.
648 If POSITION is nil, don't display the menu at all, just precalculate the
649 cached information about equivalent key sequences. */)
650 (position, menu)
651 Lisp_Object position, menu;
653 Lisp_Object keymap, tem;
654 int xpos = 0, ypos = 0;
655 Lisp_Object title;
656 char *error_name;
657 Lisp_Object selection;
658 FRAME_PTR f = NULL;
659 Lisp_Object x, y, window;
660 int keymaps = 0;
661 int for_click = 0;
662 struct gcpro gcpro1;
664 #ifdef HAVE_MENUS
665 if (! NILP (position))
667 check_w32 ();
669 /* Decode the first argument: find the window and the coordinates. */
670 if (EQ (position, Qt)
671 || (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
672 || EQ (XCAR (position), Qtool_bar))))
674 /* Use the mouse's current position. */
675 FRAME_PTR new_f = SELECTED_FRAME ();
676 Lisp_Object bar_window;
677 enum scroll_bar_part part;
678 unsigned long time;
680 if (mouse_position_hook)
681 (*mouse_position_hook) (&new_f, 1, &bar_window,
682 &part, &x, &y, &time);
683 if (new_f != 0)
684 XSETFRAME (window, new_f);
685 else
687 window = selected_window;
688 XSETFASTINT (x, 0);
689 XSETFASTINT (y, 0);
692 else
694 tem = Fcar (position);
695 if (CONSP (tem))
697 window = Fcar (Fcdr (position));
698 x = Fcar (tem);
699 y = Fcar (Fcdr (tem));
701 else
703 for_click = 1;
704 tem = Fcar (Fcdr (position)); /* EVENT_START (position) */
705 window = Fcar (tem); /* POSN_WINDOW (tem) */
706 tem = Fcar (Fcdr (Fcdr (tem))); /* POSN_WINDOW_POSN (tem) */
707 x = Fcar (tem);
708 y = Fcdr (tem);
712 CHECK_NUMBER (x);
713 CHECK_NUMBER (y);
715 /* Decode where to put the menu. */
717 if (FRAMEP (window))
719 f = XFRAME (window);
720 xpos = 0;
721 ypos = 0;
723 else if (WINDOWP (window))
725 CHECK_LIVE_WINDOW (window);
726 f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
728 xpos = WINDOW_LEFT_EDGE_X (XWINDOW (window));
729 ypos = WINDOW_TOP_EDGE_Y (XWINDOW (window));
731 else
732 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
733 but I don't want to make one now. */
734 CHECK_WINDOW (window);
736 xpos += XINT (x);
737 ypos += XINT (y);
739 XSETFRAME (Vmenu_updating_frame, f);
741 Vmenu_updating_frame = Qnil;
742 #endif /* HAVE_MENUS */
744 title = Qnil;
745 GCPRO1 (title);
747 /* Decode the menu items from what was specified. */
749 keymap = get_keymap (menu, 0, 0);
750 if (CONSP (keymap))
752 /* We were given a keymap. Extract menu info from the keymap. */
753 Lisp_Object prompt;
755 /* Extract the detailed info to make one pane. */
756 keymap_panes (&menu, 1, NILP (position));
758 /* Search for a string appearing directly as an element of the keymap.
759 That string is the title of the menu. */
760 prompt = Fkeymap_prompt (keymap);
761 if (NILP (title) && !NILP (prompt))
762 title = prompt;
764 /* Make that be the pane title of the first pane. */
765 if (!NILP (prompt) && menu_items_n_panes >= 0)
766 ASET (menu_items, MENU_ITEMS_PANE_NAME, prompt);
768 keymaps = 1;
770 else if (CONSP (menu) && KEYMAPP (XCAR (menu)))
772 /* We were given a list of keymaps. */
773 int nmaps = XFASTINT (Flength (menu));
774 Lisp_Object *maps
775 = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
776 int i;
778 title = Qnil;
780 /* The first keymap that has a prompt string
781 supplies the menu title. */
782 for (tem = menu, i = 0; CONSP (tem); tem = Fcdr (tem))
784 Lisp_Object prompt;
786 maps[i++] = keymap = get_keymap (Fcar (tem), 1, 0);
788 prompt = Fkeymap_prompt (keymap);
789 if (NILP (title) && !NILP (prompt))
790 title = prompt;
793 /* Extract the detailed info to make one pane. */
794 keymap_panes (maps, nmaps, NILP (position));
796 /* Make the title be the pane title of the first pane. */
797 if (!NILP (title) && menu_items_n_panes >= 0)
798 ASET (menu_items, MENU_ITEMS_PANE_NAME, title);
800 keymaps = 1;
802 else
804 /* We were given an old-fashioned menu. */
805 title = Fcar (menu);
806 CHECK_STRING (title);
808 list_of_panes (Fcdr (menu));
810 keymaps = 0;
813 if (NILP (position))
815 discard_menu_items ();
816 UNGCPRO;
817 return Qnil;
820 #ifdef HAVE_MENUS
821 /* If resources from a previous popup menu exist yet, does nothing
822 until the `menu_free_timer' has freed them (see w32fns.c).
824 if (current_popup_menu)
826 discard_menu_items ();
827 UNGCPRO;
828 return Qnil;
831 /* Display them in a menu. */
832 BLOCK_INPUT;
834 selection = w32_menu_show (f, xpos, ypos, for_click,
835 keymaps, title, &error_name);
836 UNBLOCK_INPUT;
838 discard_menu_items ();
839 #endif /* HAVE_MENUS */
841 UNGCPRO;
843 if (error_name) error (error_name);
844 return selection;
847 #ifdef HAVE_MENUS
849 DEFUN ("x-popup-dialog", Fx_popup_dialog, Sx_popup_dialog, 2, 2, 0,
850 doc: /* Pop up a dialog box and return user's selection.
851 POSITION specifies which frame to use.
852 This is normally a mouse button event or a window or frame.
853 If POSITION is t, it means to use the frame the mouse is on.
854 The dialog box appears in the middle of the specified frame.
856 CONTENTS specifies the alternatives to display in the dialog box.
857 It is a list of the form (TITLE ITEM1 ITEM2...).
858 Each ITEM is a cons cell (STRING . VALUE).
859 The return value is VALUE from the chosen item.
861 An ITEM may also be just a string--that makes a nonselectable item.
862 An ITEM may also be nil--that means to put all preceding items
863 on the left of the dialog box and all following items on the right.
864 \(By default, approximately half appear on each side.) */)
865 (position, contents)
866 Lisp_Object position, contents;
868 FRAME_PTR f = NULL;
869 Lisp_Object window;
871 check_w32 ();
873 /* Decode the first argument: find the window or frame to use. */
874 if (EQ (position, Qt)
875 || (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
876 || EQ (XCAR (position), Qtool_bar))))
878 #if 0 /* Using the frame the mouse is on may not be right. */
879 /* Use the mouse's current position. */
880 FRAME_PTR new_f = SELECTED_FRAME ();
881 Lisp_Object bar_window;
882 enum scroll_bar_part part;
883 unsigned long time;
884 Lisp_Object x, y;
886 (*mouse_position_hook) (&new_f, 1, &bar_window, &part, &x, &y, &time);
888 if (new_f != 0)
889 XSETFRAME (window, new_f);
890 else
891 window = selected_window;
892 #endif
893 window = selected_window;
895 else if (CONSP (position))
897 Lisp_Object tem;
898 tem = Fcar (position);
899 if (CONSP (tem))
900 window = Fcar (Fcdr (position));
901 else
903 tem = Fcar (Fcdr (position)); /* EVENT_START (position) */
904 window = Fcar (tem); /* POSN_WINDOW (tem) */
907 else if (WINDOWP (position) || FRAMEP (position))
908 window = position;
909 else
910 window = Qnil;
912 /* Decode where to put the menu. */
914 if (FRAMEP (window))
915 f = XFRAME (window);
916 else if (WINDOWP (window))
918 CHECK_LIVE_WINDOW (window);
919 f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
921 else
922 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
923 but I don't want to make one now. */
924 CHECK_WINDOW (window);
926 #ifndef HAVE_DIALOGS
927 /* Display a menu with these alternatives
928 in the middle of frame F. */
930 Lisp_Object x, y, frame, newpos;
931 XSETFRAME (frame, f);
932 XSETINT (x, x_pixel_width (f) / 2);
933 XSETINT (y, x_pixel_height (f) / 2);
934 newpos = Fcons (Fcons (x, Fcons (y, Qnil)), Fcons (frame, Qnil));
936 return Fx_popup_menu (newpos,
937 Fcons (Fcar (contents), Fcons (contents, Qnil)));
939 #else /* HAVE_DIALOGS */
941 Lisp_Object title;
942 char *error_name;
943 Lisp_Object selection;
945 /* Decode the dialog items from what was specified. */
946 title = Fcar (contents);
947 CHECK_STRING (title);
949 list_of_panes (Fcons (contents, Qnil));
951 /* Display them in a dialog box. */
952 BLOCK_INPUT;
953 selection = w32_dialog_show (f, 0, title, &error_name);
954 UNBLOCK_INPUT;
956 discard_menu_items ();
958 if (error_name) error (error_name);
959 return selection;
961 #endif /* HAVE_DIALOGS */
964 /* Activate the menu bar of frame F.
965 This is called from keyboard.c when it gets the
966 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
968 To activate the menu bar, we signal to the input thread that it can
969 return from the WM_INITMENU message, allowing the normal Windows
970 processing of the menus.
972 But first we recompute the menu bar contents (the whole tree).
974 This way we can safely execute Lisp code. */
976 void
977 x_activate_menubar (f)
978 FRAME_PTR f;
980 set_frame_menubar (f, 0, 1);
982 /* Lock out further menubar changes while active. */
983 f->output_data.w32->menubar_active = 1;
985 /* Signal input thread to return from WM_INITMENU. */
986 complete_deferred_msg (FRAME_W32_WINDOW (f), WM_INITMENU, 0);
989 /* This callback is called from the menu bar pulldown menu
990 when the user makes a selection.
991 Figure out what the user chose
992 and put the appropriate events into the keyboard buffer. */
994 void
995 menubar_selection_callback (FRAME_PTR f, void * client_data)
997 Lisp_Object prefix, entry;
998 Lisp_Object vector;
999 Lisp_Object *subprefix_stack;
1000 int submenu_depth = 0;
1001 int i;
1003 if (!f)
1004 return;
1005 entry = Qnil;
1006 subprefix_stack = (Lisp_Object *) alloca (f->menu_bar_items_used * sizeof (Lisp_Object));
1007 vector = f->menu_bar_vector;
1008 prefix = Qnil;
1009 i = 0;
1010 while (i < f->menu_bar_items_used)
1012 if (EQ (AREF (vector, i), Qnil))
1014 subprefix_stack[submenu_depth++] = prefix;
1015 prefix = entry;
1016 i++;
1018 else if (EQ (AREF (vector, i), Qlambda))
1020 prefix = subprefix_stack[--submenu_depth];
1021 i++;
1023 else if (EQ (AREF (vector, i), Qt))
1025 prefix = AREF (vector, i + MENU_ITEMS_PANE_PREFIX);
1026 i += MENU_ITEMS_PANE_LENGTH;
1028 else
1030 entry = AREF (vector, i + MENU_ITEMS_ITEM_VALUE);
1031 /* The EMACS_INT cast avoids a warning. There's no problem
1032 as long as pointers have enough bits to hold small integers. */
1033 if ((int) (EMACS_INT) client_data == i)
1035 int j;
1036 struct input_event buf;
1037 Lisp_Object frame;
1039 XSETFRAME (frame, f);
1040 buf.kind = MENU_BAR_EVENT;
1041 buf.frame_or_window = frame;
1042 buf.arg = frame;
1043 kbd_buffer_store_event (&buf);
1045 for (j = 0; j < submenu_depth; j++)
1046 if (!NILP (subprefix_stack[j]))
1048 buf.kind = MENU_BAR_EVENT;
1049 buf.frame_or_window = frame;
1050 buf.arg = subprefix_stack[j];
1051 kbd_buffer_store_event (&buf);
1054 if (!NILP (prefix))
1056 buf.kind = MENU_BAR_EVENT;
1057 buf.frame_or_window = frame;
1058 buf.arg = prefix;
1059 kbd_buffer_store_event (&buf);
1062 buf.kind = MENU_BAR_EVENT;
1063 buf.frame_or_window = frame;
1064 buf.arg = entry;
1065 kbd_buffer_store_event (&buf);
1067 /* Free memory used by owner-drawn and help-echo strings. */
1068 w32_free_menu_strings (FRAME_W32_WINDOW (f));
1069 f->output_data.w32->menu_command_in_progress = 0;
1070 f->output_data.w32->menubar_active = 0;
1071 return;
1073 i += MENU_ITEMS_ITEM_LENGTH;
1076 /* Free memory used by owner-drawn and help-echo strings. */
1077 w32_free_menu_strings (FRAME_W32_WINDOW (f));
1078 f->output_data.w32->menu_command_in_progress = 0;
1079 f->output_data.w32->menubar_active = 0;
1082 /* Allocate a widget_value, blocking input. */
1084 widget_value *
1085 xmalloc_widget_value ()
1087 widget_value *value;
1089 BLOCK_INPUT;
1090 value = malloc_widget_value ();
1091 UNBLOCK_INPUT;
1093 return value;
1096 /* This recursively calls free_widget_value on the tree of widgets.
1097 It must free all data that was malloc'ed for these widget_values.
1098 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1099 must be left alone. */
1101 void
1102 free_menubar_widget_value_tree (wv)
1103 widget_value *wv;
1105 if (! wv) return;
1107 wv->name = wv->value = wv->key = (char *) 0xDEADBEEF;
1109 if (wv->contents && (wv->contents != (widget_value*)1))
1111 free_menubar_widget_value_tree (wv->contents);
1112 wv->contents = (widget_value *) 0xDEADBEEF;
1114 if (wv->next)
1116 free_menubar_widget_value_tree (wv->next);
1117 wv->next = (widget_value *) 0xDEADBEEF;
1119 BLOCK_INPUT;
1120 free_widget_value (wv);
1121 UNBLOCK_INPUT;
1124 /* Set up data i menu_items for a menu bar item
1125 whose event type is ITEM_KEY (with string ITEM_NAME)
1126 and whose contents come from the list of keymaps MAPS. */
1128 static int
1129 parse_single_submenu (item_key, item_name, maps)
1130 Lisp_Object item_key, item_name, maps;
1132 Lisp_Object length;
1133 int len;
1134 Lisp_Object *mapvec;
1135 int i;
1136 int top_level_items = 0;
1138 length = Flength (maps);
1139 len = XINT (length);
1141 /* Convert the list MAPS into a vector MAPVEC. */
1142 mapvec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
1143 for (i = 0; i < len; i++)
1145 mapvec[i] = Fcar (maps);
1146 maps = Fcdr (maps);
1149 /* Loop over the given keymaps, making a pane for each map.
1150 But don't make a pane that is empty--ignore that map instead. */
1151 for (i = 0; i < len; i++)
1153 if (SYMBOLP (mapvec[i])
1154 || (CONSP (mapvec[i]) && !KEYMAPP (mapvec[i])))
1156 /* Here we have a command at top level in the menu bar
1157 as opposed to a submenu. */
1158 top_level_items = 1;
1159 push_menu_pane (Qnil, Qnil);
1160 push_menu_item (item_name, Qt, item_key, mapvec[i],
1161 Qnil, Qnil, Qnil, Qnil);
1163 else
1165 Lisp_Object prompt;
1166 prompt = Fkeymap_prompt (mapvec[i]);
1167 single_keymap_panes (mapvec[i],
1168 !NILP (prompt) ? prompt : item_name,
1169 item_key, 0, 10);
1173 return top_level_items;
1177 /* Create a tree of widget_value objects
1178 representing the panes and items
1179 in menu_items starting at index START, up to index END. */
1181 static widget_value *
1182 digest_single_submenu (start, end, top_level_items)
1183 int start, end, top_level_items;
1185 widget_value *wv, *prev_wv, *save_wv, *first_wv;
1186 int i;
1187 int submenu_depth = 0;
1188 widget_value **submenu_stack;
1190 submenu_stack
1191 = (widget_value **) alloca (menu_items_used * sizeof (widget_value *));
1192 wv = xmalloc_widget_value ();
1193 wv->name = "menu";
1194 wv->value = 0;
1195 wv->enabled = 1;
1196 wv->button_type = BUTTON_TYPE_NONE;
1197 wv->help = Qnil;
1198 first_wv = wv;
1199 save_wv = 0;
1200 prev_wv = 0;
1202 /* Loop over all panes and items made by the preceding call
1203 to parse_single_submenu and construct a tree of widget_value objects.
1204 Ignore the panes and items used by previous calls to
1205 digest_single_submenu, even though those are also in menu_items. */
1206 i = start;
1207 while (i < end)
1209 if (EQ (AREF (menu_items, i), Qnil))
1211 submenu_stack[submenu_depth++] = save_wv;
1212 save_wv = prev_wv;
1213 prev_wv = 0;
1214 i++;
1216 else if (EQ (AREF (menu_items, i), Qlambda))
1218 prev_wv = save_wv;
1219 save_wv = submenu_stack[--submenu_depth];
1220 i++;
1222 else if (EQ (AREF (menu_items, i), Qt)
1223 && submenu_depth != 0)
1224 i += MENU_ITEMS_PANE_LENGTH;
1225 /* Ignore a nil in the item list.
1226 It's meaningful only for dialog boxes. */
1227 else if (EQ (AREF (menu_items, i), Qquote))
1228 i += 1;
1229 else if (EQ (AREF (menu_items, i), Qt))
1231 /* Create a new pane. */
1232 Lisp_Object pane_name, prefix;
1233 char *pane_string;
1235 pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
1236 prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
1238 #ifndef HAVE_MULTILINGUAL_MENU
1239 if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
1241 pane_name = ENCODE_SYSTEM (pane_name);
1242 ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
1244 #endif
1245 pane_string = (NILP (pane_name)
1246 ? "" : (char *) SDATA (pane_name));
1247 /* If there is just one top-level pane, put all its items directly
1248 under the top-level menu. */
1249 if (menu_items_n_panes == 1)
1250 pane_string = "";
1252 /* If the pane has a meaningful name,
1253 make the pane a top-level menu item
1254 with its items as a submenu beneath it. */
1255 if (strcmp (pane_string, ""))
1257 wv = xmalloc_widget_value ();
1258 if (save_wv)
1259 save_wv->next = wv;
1260 else
1261 first_wv->contents = wv;
1262 wv->name = pane_string;
1263 /* Ignore the @ that means "separate pane".
1264 This is a kludge, but this isn't worth more time. */
1265 if (!NILP (prefix) && wv->name[0] == '@')
1266 wv->name++;
1267 wv->value = 0;
1268 wv->enabled = 1;
1269 wv->button_type = BUTTON_TYPE_NONE;
1270 wv->help = Qnil;
1272 save_wv = wv;
1273 prev_wv = 0;
1274 i += MENU_ITEMS_PANE_LENGTH;
1276 else
1278 /* Create a new item within current pane. */
1279 Lisp_Object item_name, enable, descrip, def, type, selected;
1280 Lisp_Object help;
1282 item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
1283 enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
1284 descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
1285 def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);
1286 type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);
1287 selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
1288 help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
1290 #ifndef HAVE_MULTILINGUAL_MENU
1291 if (STRING_MULTIBYTE (item_name))
1293 item_name = ENCODE_SYSTEM (item_name);
1294 ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
1297 if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
1299 descrip = ENCODE_SYSTEM (descrip);
1300 ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
1302 #endif /* not HAVE_MULTILINGUAL_MENU */
1304 wv = xmalloc_widget_value ();
1305 if (prev_wv)
1306 prev_wv->next = wv;
1307 else
1308 save_wv->contents = wv;
1310 wv->name = (char *) SDATA (item_name);
1311 if (!NILP (descrip))
1312 wv->key = (char *) SDATA (descrip);
1313 wv->value = 0;
1314 /* The EMACS_INT cast avoids a warning. There's no problem
1315 as long as pointers have enough bits to hold small integers. */
1316 wv->call_data = (!NILP (def) ? (void *) (EMACS_INT) i : 0);
1317 wv->enabled = !NILP (enable);
1319 if (NILP (type))
1320 wv->button_type = BUTTON_TYPE_NONE;
1321 else if (EQ (type, QCradio))
1322 wv->button_type = BUTTON_TYPE_RADIO;
1323 else if (EQ (type, QCtoggle))
1324 wv->button_type = BUTTON_TYPE_TOGGLE;
1325 else
1326 abort ();
1328 wv->selected = !NILP (selected);
1329 if (!STRINGP (help))
1330 help = Qnil;
1332 wv->help = help;
1334 prev_wv = wv;
1336 i += MENU_ITEMS_ITEM_LENGTH;
1340 /* If we have just one "menu item"
1341 that was originally a button, return it by itself. */
1342 if (top_level_items && first_wv->contents && first_wv->contents->next == 0)
1344 wv = first_wv->contents;
1345 free_widget_value (first_wv);
1346 return wv;
1349 return first_wv;
1352 /* Set the contents of the menubar widgets of frame F.
1353 The argument FIRST_TIME is currently ignored;
1354 it is set the first time this is called, from initialize_frame_menubar. */
1356 void
1357 set_frame_menubar (f, first_time, deep_p)
1358 FRAME_PTR f;
1359 int first_time;
1360 int deep_p;
1362 HMENU menubar_widget = f->output_data.w32->menubar_widget;
1363 Lisp_Object items;
1364 widget_value *wv, *first_wv, *prev_wv = 0;
1365 int i, last_i;
1366 int *submenu_start, *submenu_end;
1367 int *submenu_top_level_items, *submenu_n_panes;
1369 /* We must not change the menubar when actually in use. */
1370 if (f->output_data.w32->menubar_active)
1371 return;
1373 XSETFRAME (Vmenu_updating_frame, f);
1375 if (! menubar_widget)
1376 deep_p = 1;
1377 else if (pending_menu_activation && !deep_p)
1378 deep_p = 1;
1380 if (deep_p)
1382 /* Make a widget-value tree representing the entire menu trees. */
1384 struct buffer *prev = current_buffer;
1385 Lisp_Object buffer;
1386 int specpdl_count = SPECPDL_INDEX ();
1387 int previous_menu_items_used = f->menu_bar_items_used;
1388 Lisp_Object *previous_items
1389 = (Lisp_Object *) alloca (previous_menu_items_used
1390 * sizeof (Lisp_Object));
1392 /* If we are making a new widget, its contents are empty,
1393 do always reinitialize them. */
1394 if (! menubar_widget)
1395 previous_menu_items_used = 0;
1397 buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer;
1398 specbind (Qinhibit_quit, Qt);
1399 /* Don't let the debugger step into this code
1400 because it is not reentrant. */
1401 specbind (Qdebug_on_next_call, Qnil);
1403 record_unwind_protect (Fset_match_data, Fmatch_data (Qnil, Qnil));
1404 if (NILP (Voverriding_local_map_menu_flag))
1406 specbind (Qoverriding_terminal_local_map, Qnil);
1407 specbind (Qoverriding_local_map, Qnil);
1410 set_buffer_internal_1 (XBUFFER (buffer));
1412 /* Run the Lucid hook. */
1413 safe_run_hooks (Qactivate_menubar_hook);
1414 /* If it has changed current-menubar from previous value,
1415 really recompute the menubar from the value. */
1416 if (! NILP (Vlucid_menu_bar_dirty_flag))
1417 call0 (Qrecompute_lucid_menubar);
1418 safe_run_hooks (Qmenu_bar_update_hook);
1419 FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
1421 items = FRAME_MENU_BAR_ITEMS (f);
1423 /* Save the frame's previous menu bar contents data. */
1424 if (previous_menu_items_used)
1425 bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
1426 previous_menu_items_used * sizeof (Lisp_Object));
1428 /* Fill in menu_items with the current menu bar contents.
1429 This can evaluate Lisp code. */
1430 menu_items = f->menu_bar_vector;
1431 menu_items_allocated = VECTORP (menu_items) ? ASIZE (menu_items) : 0;
1432 submenu_start = (int *) alloca (XVECTOR (items)->size * sizeof (int *));
1433 submenu_end = (int *) alloca (XVECTOR (items)->size * sizeof (int *));
1434 submenu_n_panes = (int *) alloca (XVECTOR (items)->size * sizeof (int));
1435 submenu_top_level_items
1436 = (int *) alloca (XVECTOR (items)->size * sizeof (int *));
1437 init_menu_items ();
1438 for (i = 0; i < ASIZE (items); i += 4)
1440 Lisp_Object key, string, maps;
1442 last_i = i;
1444 key = AREF (items, i);
1445 string = AREF (items, i + 1);
1446 maps = AREF (items, i + 2);
1447 if (NILP (string))
1448 break;
1450 submenu_start[i] = menu_items_used;
1452 menu_items_n_panes = 0;
1453 submenu_top_level_items[i]
1454 = parse_single_submenu (key, string, maps);
1455 submenu_n_panes[i] = menu_items_n_panes;
1457 submenu_end[i] = menu_items_used;
1460 finish_menu_items ();
1462 /* Convert menu_items into widget_value trees
1463 to display the menu. This cannot evaluate Lisp code. */
1465 wv = xmalloc_widget_value ();
1466 wv->name = "menubar";
1467 wv->value = 0;
1468 wv->enabled = 1;
1469 wv->button_type = BUTTON_TYPE_NONE;
1470 wv->help = Qnil;
1471 first_wv = wv;
1473 for (i = 0; i < last_i; i += 4)
1475 menu_items_n_panes = submenu_n_panes[i];
1476 wv = digest_single_submenu (submenu_start[i], submenu_end[i],
1477 submenu_top_level_items[i]);
1478 if (prev_wv)
1479 prev_wv->next = wv;
1480 else
1481 first_wv->contents = wv;
1482 /* Don't set wv->name here; GC during the loop might relocate it. */
1483 wv->enabled = 1;
1484 wv->button_type = BUTTON_TYPE_NONE;
1485 prev_wv = wv;
1488 set_buffer_internal_1 (prev);
1489 unbind_to (specpdl_count, Qnil);
1491 /* If there has been no change in the Lisp-level contents
1492 of the menu bar, skip redisplaying it. Just exit. */
1494 for (i = 0; i < previous_menu_items_used; i++)
1495 if (menu_items_used == i
1496 || (!EQ (previous_items[i], AREF (menu_items, i))))
1497 break;
1498 if (i == menu_items_used && i == previous_menu_items_used && i != 0)
1500 free_menubar_widget_value_tree (first_wv);
1501 menu_items = Qnil;
1503 return;
1506 /* Now GC cannot happen during the lifetime of the widget_value,
1507 so it's safe to store data from a Lisp_String, as long as
1508 local copies are made when the actual menu is created.
1509 Windows takes care of this for normal string items, but
1510 not for owner-drawn items or additional item-info. */
1511 wv = first_wv->contents;
1512 for (i = 0; i < ASIZE (items); i += 4)
1514 Lisp_Object string;
1515 string = AREF (items, i + 1);
1516 if (NILP (string))
1517 break;
1518 wv->name = (char *) SDATA (string);
1519 wv = wv->next;
1522 f->menu_bar_vector = menu_items;
1523 f->menu_bar_items_used = menu_items_used;
1524 menu_items = Qnil;
1526 else
1528 /* Make a widget-value tree containing
1529 just the top level menu bar strings. */
1531 wv = xmalloc_widget_value ();
1532 wv->name = "menubar";
1533 wv->value = 0;
1534 wv->enabled = 1;
1535 wv->button_type = BUTTON_TYPE_NONE;
1536 wv->help = Qnil;
1537 first_wv = wv;
1539 items = FRAME_MENU_BAR_ITEMS (f);
1540 for (i = 0; i < ASIZE (items); i += 4)
1542 Lisp_Object string;
1544 string = AREF (items, i + 1);
1545 if (NILP (string))
1546 break;
1548 wv = xmalloc_widget_value ();
1549 wv->name = (char *) SDATA (string);
1550 wv->value = 0;
1551 wv->enabled = 1;
1552 wv->button_type = BUTTON_TYPE_NONE;
1553 wv->help = Qnil;
1554 /* This prevents lwlib from assuming this
1555 menu item is really supposed to be empty. */
1556 /* The EMACS_INT cast avoids a warning.
1557 This value just has to be different from small integers. */
1558 wv->call_data = (void *) (EMACS_INT) (-1);
1560 if (prev_wv)
1561 prev_wv->next = wv;
1562 else
1563 first_wv->contents = wv;
1564 prev_wv = wv;
1567 /* Forget what we thought we knew about what is in the
1568 detailed contents of the menu bar menus.
1569 Changing the top level always destroys the contents. */
1570 f->menu_bar_items_used = 0;
1573 /* Create or update the menu bar widget. */
1575 BLOCK_INPUT;
1577 if (menubar_widget)
1579 /* Empty current menubar, rather than creating a fresh one. */
1580 while (DeleteMenu (menubar_widget, 0, MF_BYPOSITION))
1583 else
1585 menubar_widget = CreateMenu ();
1587 fill_in_menu (menubar_widget, first_wv->contents);
1589 free_menubar_widget_value_tree (first_wv);
1592 HMENU old_widget = f->output_data.w32->menubar_widget;
1594 f->output_data.w32->menubar_widget = menubar_widget;
1595 SetMenu (FRAME_W32_WINDOW (f), f->output_data.w32->menubar_widget);
1596 /* Causes flicker when menu bar is updated
1597 DrawMenuBar (FRAME_W32_WINDOW (f)); */
1599 /* Force the window size to be recomputed so that the frame's text
1600 area remains the same, if menubar has just been created. */
1601 if (old_widget == NULL)
1602 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
1605 UNBLOCK_INPUT;
1608 /* Called from Fx_create_frame to create the initial menubar of a frame
1609 before it is mapped, so that the window is mapped with the menubar already
1610 there instead of us tacking it on later and thrashing the window after it
1611 is visible. */
1613 void
1614 initialize_frame_menubar (f)
1615 FRAME_PTR f;
1617 /* This function is called before the first chance to redisplay
1618 the frame. It has to be, so the frame will have the right size. */
1619 FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
1620 set_frame_menubar (f, 1, 1);
1623 /* Get rid of the menu bar of frame F, and free its storage.
1624 This is used when deleting a frame, and when turning off the menu bar. */
1626 void
1627 free_frame_menubar (f)
1628 FRAME_PTR f;
1630 BLOCK_INPUT;
1633 HMENU old = GetMenu (FRAME_W32_WINDOW (f));
1634 SetMenu (FRAME_W32_WINDOW (f), NULL);
1635 f->output_data.w32->menubar_widget = NULL;
1636 DestroyMenu (old);
1639 UNBLOCK_INPUT;
1643 /* w32_menu_show actually displays a menu using the panes and items in
1644 menu_items and returns the value selected from it; we assume input
1645 is blocked by the caller. */
1647 /* F is the frame the menu is for.
1648 X and Y are the frame-relative specified position,
1649 relative to the inside upper left corner of the frame F.
1650 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1651 KEYMAPS is 1 if this menu was specified with keymaps;
1652 in that case, we return a list containing the chosen item's value
1653 and perhaps also the pane's prefix.
1654 TITLE is the specified menu title.
1655 ERROR is a place to store an error message string in case of failure.
1656 (We return nil on failure, but the value doesn't actually matter.) */
1658 static Lisp_Object
1659 w32_menu_show (f, x, y, for_click, keymaps, title, error)
1660 FRAME_PTR f;
1661 int x;
1662 int y;
1663 int for_click;
1664 int keymaps;
1665 Lisp_Object title;
1666 char **error;
1668 int i;
1669 int menu_item_selection;
1670 HMENU menu;
1671 POINT pos;
1672 widget_value *wv, *save_wv = 0, *first_wv = 0, *prev_wv = 0;
1673 widget_value **submenu_stack
1674 = (widget_value **) alloca (menu_items_used * sizeof (widget_value *));
1675 Lisp_Object *subprefix_stack
1676 = (Lisp_Object *) alloca (menu_items_used * sizeof (Lisp_Object));
1677 int submenu_depth = 0;
1678 int first_pane;
1680 *error = NULL;
1682 if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)
1684 *error = "Empty menu";
1685 return Qnil;
1688 /* Create a tree of widget_value objects
1689 representing the panes and their items. */
1690 wv = xmalloc_widget_value ();
1691 wv->name = "menu";
1692 wv->value = 0;
1693 wv->enabled = 1;
1694 wv->button_type = BUTTON_TYPE_NONE;
1695 wv->help = Qnil;
1696 first_wv = wv;
1697 first_pane = 1;
1699 /* Loop over all panes and items, filling in the tree. */
1700 i = 0;
1701 while (i < menu_items_used)
1703 if (EQ (AREF (menu_items, i), Qnil))
1705 submenu_stack[submenu_depth++] = save_wv;
1706 save_wv = prev_wv;
1707 prev_wv = 0;
1708 first_pane = 1;
1709 i++;
1711 else if (EQ (AREF (menu_items, i), Qlambda))
1713 prev_wv = save_wv;
1714 save_wv = submenu_stack[--submenu_depth];
1715 first_pane = 0;
1716 i++;
1718 else if (EQ (AREF (menu_items, i), Qt)
1719 && submenu_depth != 0)
1720 i += MENU_ITEMS_PANE_LENGTH;
1721 /* Ignore a nil in the item list.
1722 It's meaningful only for dialog boxes. */
1723 else if (EQ (AREF (menu_items, i), Qquote))
1724 i += 1;
1725 else if (EQ (AREF (menu_items, i), Qt))
1727 /* Create a new pane. */
1728 Lisp_Object pane_name, prefix;
1729 char *pane_string;
1730 pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
1731 prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
1732 #ifndef HAVE_MULTILINGUAL_MENU
1733 if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
1735 pane_name = ENCODE_SYSTEM (pane_name);
1736 ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
1738 #endif
1739 pane_string = (NILP (pane_name)
1740 ? "" : (char *) SDATA (pane_name));
1741 /* If there is just one top-level pane, put all its items directly
1742 under the top-level menu. */
1743 if (menu_items_n_panes == 1)
1744 pane_string = "";
1746 /* If the pane has a meaningful name,
1747 make the pane a top-level menu item
1748 with its items as a submenu beneath it. */
1749 if (!keymaps && strcmp (pane_string, ""))
1751 wv = xmalloc_widget_value ();
1752 if (save_wv)
1753 save_wv->next = wv;
1754 else
1755 first_wv->contents = wv;
1756 wv->name = pane_string;
1757 if (keymaps && !NILP (prefix))
1758 wv->name++;
1759 wv->value = 0;
1760 wv->enabled = 1;
1761 wv->button_type = BUTTON_TYPE_NONE;
1762 wv->help = Qnil;
1763 save_wv = wv;
1764 prev_wv = 0;
1766 else if (first_pane)
1768 save_wv = wv;
1769 prev_wv = 0;
1771 first_pane = 0;
1772 i += MENU_ITEMS_PANE_LENGTH;
1774 else
1776 /* Create a new item within current pane. */
1777 Lisp_Object item_name, enable, descrip, def, type, selected, help;
1779 item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
1780 enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
1781 descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
1782 def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);
1783 type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);
1784 selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
1785 help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
1787 #ifndef HAVE_MULTILINGUAL_MENU
1788 if (STRINGP (item_name) && STRING_MULTIBYTE (item_name))
1790 item_name = ENCODE_SYSTEM (item_name);
1791 ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
1793 if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
1795 descrip = ENCODE_SYSTEM (descrip);
1796 ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
1798 #endif /* not HAVE_MULTILINGUAL_MENU */
1800 wv = xmalloc_widget_value ();
1801 if (prev_wv)
1802 prev_wv->next = wv;
1803 else
1804 save_wv->contents = wv;
1805 wv->name = (char *) SDATA (item_name);
1806 if (!NILP (descrip))
1807 wv->key = (char *) SDATA (descrip);
1808 wv->value = 0;
1809 /* Use the contents index as call_data, since we are
1810 restricted to 16-bits. */
1811 wv->call_data = !NILP (def) ? (void *) (EMACS_INT) i : 0;
1812 wv->enabled = !NILP (enable);
1814 if (NILP (type))
1815 wv->button_type = BUTTON_TYPE_NONE;
1816 else if (EQ (type, QCtoggle))
1817 wv->button_type = BUTTON_TYPE_TOGGLE;
1818 else if (EQ (type, QCradio))
1819 wv->button_type = BUTTON_TYPE_RADIO;
1820 else
1821 abort ();
1823 wv->selected = !NILP (selected);
1824 if (!STRINGP (help))
1825 help = Qnil;
1827 wv->help = help;
1829 prev_wv = wv;
1831 i += MENU_ITEMS_ITEM_LENGTH;
1835 /* Deal with the title, if it is non-nil. */
1836 if (!NILP (title))
1838 widget_value *wv_title = xmalloc_widget_value ();
1839 widget_value *wv_sep = xmalloc_widget_value ();
1841 /* Maybe replace this separator with a bitmap or owner-draw item
1842 so that it looks better. Having two separators looks odd. */
1843 wv_sep->name = "--";
1844 wv_sep->next = first_wv->contents;
1845 wv_sep->help = Qnil;
1847 #ifndef HAVE_MULTILINGUAL_MENU
1848 if (STRING_MULTIBYTE (title))
1849 title = ENCODE_SYSTEM (title);
1850 #endif
1851 wv_title->name = (char *) SDATA (title);
1852 wv_title->enabled = TRUE;
1853 wv_title->title = TRUE;
1854 wv_title->button_type = BUTTON_TYPE_NONE;
1855 wv_title->help = Qnil;
1856 wv_title->next = wv_sep;
1857 first_wv->contents = wv_title;
1860 /* Actually create the menu. */
1861 current_popup_menu = menu = CreatePopupMenu ();
1862 fill_in_menu (menu, first_wv->contents);
1864 /* Adjust coordinates to be root-window-relative. */
1865 pos.x = x;
1866 pos.y = y;
1867 ClientToScreen (FRAME_W32_WINDOW (f), &pos);
1869 /* No selection has been chosen yet. */
1870 menu_item_selection = 0;
1872 /* Display the menu. */
1873 menu_item_selection = SendMessage (FRAME_W32_WINDOW (f),
1874 WM_EMACS_TRACKPOPUPMENU,
1875 (WPARAM)menu, (LPARAM)&pos);
1877 /* Clean up extraneous mouse events which might have been generated
1878 during the call. */
1879 discard_mouse_events ();
1881 /* Free the widget_value objects we used to specify the contents. */
1882 free_menubar_widget_value_tree (first_wv);
1884 DestroyMenu (menu);
1886 /* Find the selected item, and its pane, to return
1887 the proper value. */
1888 if (menu_item_selection != 0)
1890 Lisp_Object prefix, entry;
1892 prefix = entry = Qnil;
1893 i = 0;
1894 while (i < menu_items_used)
1896 if (EQ (AREF (menu_items, i), Qnil))
1898 subprefix_stack[submenu_depth++] = prefix;
1899 prefix = entry;
1900 i++;
1902 else if (EQ (AREF (menu_items, i), Qlambda))
1904 prefix = subprefix_stack[--submenu_depth];
1905 i++;
1907 else if (EQ (AREF (menu_items, i), Qt))
1909 prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
1910 i += MENU_ITEMS_PANE_LENGTH;
1912 /* Ignore a nil in the item list.
1913 It's meaningful only for dialog boxes. */
1914 else if (EQ (AREF (menu_items, i), Qquote))
1915 i += 1;
1916 else
1918 entry = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
1919 if (menu_item_selection == i)
1921 if (keymaps != 0)
1923 int j;
1925 entry = Fcons (entry, Qnil);
1926 if (!NILP (prefix))
1927 entry = Fcons (prefix, entry);
1928 for (j = submenu_depth - 1; j >= 0; j--)
1929 if (!NILP (subprefix_stack[j]))
1930 entry = Fcons (subprefix_stack[j], entry);
1932 return entry;
1934 i += MENU_ITEMS_ITEM_LENGTH;
1939 return Qnil;
1943 #ifdef HAVE_DIALOGS
1944 static char * button_names [] = {
1945 "button1", "button2", "button3", "button4", "button5",
1946 "button6", "button7", "button8", "button9", "button10" };
1948 static Lisp_Object
1949 w32_dialog_show (f, keymaps, title, error)
1950 FRAME_PTR f;
1951 int keymaps;
1952 Lisp_Object title;
1953 char **error;
1955 int i, nb_buttons=0;
1956 char dialog_name[6];
1957 int menu_item_selection;
1959 widget_value *wv, *first_wv = 0, *prev_wv = 0;
1961 /* Number of elements seen so far, before boundary. */
1962 int left_count = 0;
1963 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
1964 int boundary_seen = 0;
1966 *error = NULL;
1968 if (menu_items_n_panes > 1)
1970 *error = "Multiple panes in dialog box";
1971 return Qnil;
1974 /* Create a tree of widget_value objects
1975 representing the text label and buttons. */
1977 Lisp_Object pane_name, prefix;
1978 char *pane_string;
1979 pane_name = AREF (menu_items, MENU_ITEMS_PANE_NAME);
1980 prefix = AREF (menu_items, MENU_ITEMS_PANE_PREFIX);
1981 pane_string = (NILP (pane_name)
1982 ? "" : (char *) SDATA (pane_name));
1983 prev_wv = xmalloc_widget_value ();
1984 prev_wv->value = pane_string;
1985 if (keymaps && !NILP (prefix))
1986 prev_wv->name++;
1987 prev_wv->enabled = 1;
1988 prev_wv->name = "message";
1989 prev_wv->help = Qnil;
1990 first_wv = prev_wv;
1992 /* Loop over all panes and items, filling in the tree. */
1993 i = MENU_ITEMS_PANE_LENGTH;
1994 while (i < menu_items_used)
1997 /* Create a new item within current pane. */
1998 Lisp_Object item_name, enable, descrip, help;
2000 item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
2001 enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
2002 descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
2003 help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
2005 if (NILP (item_name))
2007 free_menubar_widget_value_tree (first_wv);
2008 *error = "Submenu in dialog items";
2009 return Qnil;
2011 if (EQ (item_name, Qquote))
2013 /* This is the boundary between left-side elts
2014 and right-side elts. Stop incrementing right_count. */
2015 boundary_seen = 1;
2016 i++;
2017 continue;
2019 if (nb_buttons >= 9)
2021 free_menubar_widget_value_tree (first_wv);
2022 *error = "Too many dialog items";
2023 return Qnil;
2026 wv = xmalloc_widget_value ();
2027 prev_wv->next = wv;
2028 wv->name = (char *) button_names[nb_buttons];
2029 if (!NILP (descrip))
2030 wv->key = (char *) SDATA (descrip);
2031 wv->value = (char *) SDATA (item_name);
2032 wv->call_data = (void *) &AREF (menu_items, i);
2033 wv->enabled = !NILP (enable);
2034 wv->help = Qnil;
2035 prev_wv = wv;
2037 if (! boundary_seen)
2038 left_count++;
2040 nb_buttons++;
2041 i += MENU_ITEMS_ITEM_LENGTH;
2044 /* If the boundary was not specified,
2045 by default put half on the left and half on the right. */
2046 if (! boundary_seen)
2047 left_count = nb_buttons - nb_buttons / 2;
2049 wv = xmalloc_widget_value ();
2050 wv->name = dialog_name;
2051 wv->help = Qnil;
2053 /* Dialog boxes use a really stupid name encoding
2054 which specifies how many buttons to use
2055 and how many buttons are on the right.
2056 The Q means something also. */
2057 dialog_name[0] = 'Q';
2058 dialog_name[1] = '0' + nb_buttons;
2059 dialog_name[2] = 'B';
2060 dialog_name[3] = 'R';
2061 /* Number of buttons to put on the right. */
2062 dialog_name[4] = '0' + nb_buttons - left_count;
2063 dialog_name[5] = 0;
2064 wv->contents = first_wv;
2065 first_wv = wv;
2068 /* Actually create the dialog. */
2069 dialog_id = widget_id_tick++;
2070 menu = lw_create_widget (first_wv->name, "dialog", dialog_id, first_wv,
2071 f->output_data.w32->widget, 1, 0,
2072 dialog_selection_callback, 0);
2073 lw_modify_all_widgets (dialog_id, first_wv->contents, TRUE);
2075 /* Free the widget_value objects we used to specify the contents. */
2076 free_menubar_widget_value_tree (first_wv);
2078 /* No selection has been chosen yet. */
2079 menu_item_selection = 0;
2081 /* Display the menu. */
2082 lw_pop_up_all_widgets (dialog_id);
2083 popup_activated_flag = 1;
2085 /* Process events that apply to the menu. */
2086 popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f), dialog_id);
2088 lw_destroy_all_widgets (dialog_id);
2090 /* Find the selected item, and its pane, to return
2091 the proper value. */
2092 if (menu_item_selection != 0)
2094 Lisp_Object prefix;
2096 prefix = Qnil;
2097 i = 0;
2098 while (i < menu_items_used)
2100 Lisp_Object entry;
2102 if (EQ (AREF (menu_items, i), Qt))
2104 prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
2105 i += MENU_ITEMS_PANE_LENGTH;
2107 else
2109 entry = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
2110 if (menu_item_selection == i)
2112 if (keymaps != 0)
2114 entry = Fcons (entry, Qnil);
2115 if (!NILP (prefix))
2116 entry = Fcons (prefix, entry);
2118 return entry;
2120 i += MENU_ITEMS_ITEM_LENGTH;
2125 return Qnil;
2127 #endif /* HAVE_DIALOGS */
2130 /* Is this item a separator? */
2131 static int
2132 name_is_separator (name)
2133 char *name;
2135 char *start = name;
2137 /* Check if name string consists of only dashes ('-'). */
2138 while (*name == '-') name++;
2139 /* Separators can also be of the form "--:TripleSuperMegaEtched"
2140 or "--deep-shadow". We don't implement them yet, se we just treat
2141 them like normal separators. */
2142 return (*name == '\0' || start + 2 == name);
2146 /* Indicate boundary between left and right. */
2147 static int
2148 add_left_right_boundary (HMENU menu)
2150 return AppendMenu (menu, MF_MENUBARBREAK, 0, NULL);
2153 static int
2154 add_menu_item (HMENU menu, widget_value *wv, HMENU item)
2156 UINT fuFlags;
2157 char *out_string;
2158 int return_value;
2160 if (name_is_separator (wv->name))
2162 fuFlags = MF_SEPARATOR;
2163 out_string = NULL;
2165 else
2167 if (wv->enabled)
2168 fuFlags = MF_STRING;
2169 else
2170 fuFlags = MF_STRING | MF_GRAYED;
2172 if (wv->key != NULL)
2174 out_string = alloca (strlen (wv->name) + strlen (wv->key) + 2);
2175 strcpy (out_string, wv->name);
2176 strcat (out_string, "\t");
2177 strcat (out_string, wv->key);
2179 else
2180 out_string = wv->name;
2182 if (item != NULL)
2183 fuFlags = MF_POPUP;
2184 else if (wv->title || wv->call_data == 0)
2186 /* Only use MF_OWNERDRAW if GetMenuItemInfo is usable, since
2187 we can't deallocate the memory otherwise. */
2188 if (get_menu_item_info)
2190 out_string = (char *) local_alloc (strlen (wv->name) + 1);
2191 strcpy (out_string, wv->name);
2192 #ifdef MENU_DEBUG
2193 DebPrint ("Menu: allocing %ld for owner-draw", out_string);
2194 #endif
2195 fuFlags = MF_OWNERDRAW | MF_DISABLED;
2197 else
2198 fuFlags = MF_DISABLED;
2201 /* Draw radio buttons and tickboxes. */
2202 else if (wv->selected && (wv->button_type == BUTTON_TYPE_TOGGLE ||
2203 wv->button_type == BUTTON_TYPE_RADIO))
2204 fuFlags |= MF_CHECKED;
2205 else
2206 fuFlags |= MF_UNCHECKED;
2209 return_value =
2210 AppendMenu (menu,
2211 fuFlags,
2212 item != NULL ? (UINT) item : (UINT) wv->call_data,
2213 out_string );
2215 /* This must be done after the menu item is created. */
2216 if (!wv->title && wv->call_data != 0)
2218 if (set_menu_item_info)
2220 MENUITEMINFO info;
2221 bzero (&info, sizeof (info));
2222 info.cbSize = sizeof (info);
2223 info.fMask = MIIM_DATA;
2225 /* Set help string for menu item. Leave it as a Lisp_Object
2226 until it is ready to be displayed, since GC can happen while
2227 menus are active. */
2228 if (wv->help)
2229 info.dwItemData = (DWORD) wv->help;
2231 if (wv->button_type == BUTTON_TYPE_RADIO)
2233 /* CheckMenuRadioItem allows us to differentiate TOGGLE and
2234 RADIO items, but is not available on NT 3.51 and earlier. */
2235 info.fMask |= MIIM_TYPE | MIIM_STATE;
2236 info.fType = MFT_RADIOCHECK | MFT_STRING;
2237 info.dwTypeData = out_string;
2238 info.fState = wv->selected ? MFS_CHECKED : MFS_UNCHECKED;
2241 set_menu_item_info (menu,
2242 item != NULL ? (UINT) item : (UINT) wv->call_data,
2243 FALSE, &info);
2246 return return_value;
2249 /* Construct native Windows menu(bar) based on widget_value tree. */
2251 fill_in_menu (HMENU menu, widget_value *wv)
2253 int items_added = 0;
2255 for ( ; wv != NULL; wv = wv->next)
2257 if (wv->contents)
2259 HMENU sub_menu = CreatePopupMenu ();
2261 if (sub_menu == NULL)
2262 return 0;
2264 if (!fill_in_menu (sub_menu, wv->contents) ||
2265 !add_menu_item (menu, wv, sub_menu))
2267 DestroyMenu (sub_menu);
2268 return 0;
2271 else
2273 if (!add_menu_item (menu, wv, NULL))
2274 return 0;
2277 return 1;
2281 popup_activated ()
2283 /* popup_activated_flag not actually used on W32 */
2284 return 0;
2287 /* Display help string for currently pointed to menu item. Not
2288 supported on NT 3.51 and earlier, as GetMenuItemInfo is not
2289 available. */
2290 void
2291 w32_menu_display_help (HWND owner, HMENU menu, UINT item, UINT flags)
2293 if (get_menu_item_info)
2295 struct frame *f = x_window_to_frame (&one_w32_display_info, owner);
2296 Lisp_Object frame, help;
2298 // No help echo on owner-draw menu items.
2299 if (flags & MF_OWNERDRAW || flags & MF_POPUP)
2300 help = Qnil;
2301 else
2303 MENUITEMINFO info;
2305 bzero (&info, sizeof (info));
2306 info.cbSize = sizeof (info);
2307 info.fMask = MIIM_DATA;
2308 get_menu_item_info (menu, item, FALSE, &info);
2310 help = info.dwItemData ? (Lisp_Object) info.dwItemData : Qnil;
2313 /* Store the help echo in the keyboard buffer as the X toolkit
2314 version does, rather than directly showing it. This seems to
2315 solve the GC problems that were present when we based the
2316 Windows code on the non-toolkit version. */
2317 if (f)
2319 XSETFRAME (frame, f);
2320 kbd_buffer_store_help_event (frame, help);
2322 else
2323 /* X version has a loop through frames here, which doesn't
2324 appear to do anything, unless it has some side effect. */
2325 show_help_echo (help, Qnil, Qnil, Qnil, 1);
2329 /* Free memory used by owner-drawn strings. */
2330 static void
2331 w32_free_submenu_strings (menu)
2332 HMENU menu;
2334 int i, num = GetMenuItemCount (menu);
2335 for (i = 0; i < num; i++)
2337 MENUITEMINFO info;
2338 bzero (&info, sizeof (info));
2339 info.cbSize = sizeof (info);
2340 info.fMask = MIIM_DATA | MIIM_TYPE | MIIM_SUBMENU;
2342 get_menu_item_info (menu, i, TRUE, &info);
2344 /* Owner-drawn names are held in dwItemData. */
2345 if ((info.fType & MF_OWNERDRAW) && info.dwItemData)
2347 #ifdef MENU_DEBUG
2348 DebPrint ("Menu: freeing %ld for owner-draw", info.dwItemData);
2349 #endif
2350 local_free (info.dwItemData);
2353 /* Recurse down submenus. */
2354 if (info.hSubMenu)
2355 w32_free_submenu_strings (info.hSubMenu);
2359 void
2360 w32_free_menu_strings (hwnd)
2361 HWND hwnd;
2363 HMENU menu = current_popup_menu;
2365 if (get_menu_item_info)
2367 /* If there is no popup menu active, free the strings from the frame's
2368 menubar. */
2369 if (!menu)
2370 menu = GetMenu (hwnd);
2372 if (menu)
2373 w32_free_submenu_strings (menu);
2376 current_popup_menu = NULL;
2379 #endif /* HAVE_MENUS */
2381 void syms_of_w32menu ()
2383 globals_of_w32menu ();
2384 staticpro (&menu_items);
2385 menu_items = Qnil;
2387 current_popup_menu = NULL;
2389 Qdebug_on_next_call = intern ("debug-on-next-call");
2390 staticpro (&Qdebug_on_next_call);
2392 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame,
2393 doc: /* Frame for which we are updating a menu.
2394 The enable predicate for a menu command should check this variable. */);
2395 Vmenu_updating_frame = Qnil;
2397 defsubr (&Sx_popup_menu);
2398 #ifdef HAVE_MENUS
2399 defsubr (&Sx_popup_dialog);
2400 #endif
2404 globals_of_w32menu is used to initialize those global variables that
2405 must always be initialized on startup even when the global variable
2406 initialized is non zero (see the function main in emacs.c).
2407 globals_of_w32menu is called from syms_of_w32menu when the global
2408 variable initialized is 0 and directly from main when initialized
2409 is non zero.
2411 void globals_of_w32menu ()
2413 /* See if Get/SetMenuItemInfo functions are available. */
2414 HMODULE user32 = GetModuleHandle ("user32.dll");
2415 get_menu_item_info = (GetMenuItemInfoA_Proc) GetProcAddress (user32, "GetMenuItemInfoA");
2416 set_menu_item_info = (SetMenuItemInfoA_Proc) GetProcAddress (user32, "SetMenuItemInfoA");