1 /* Menu support for GNU Emacs on the Microsoft W32 API.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1998, 1999, 2002, 2003,
3 2004, 2005, 2006 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
27 #include "termhooks.h"
32 #include "blockinput.h"
37 /* This may include sys/types.h, and that somehow loses
38 if this is not done before the other system files. */
41 /* Load sys/types.h if not already loaded.
42 In some systems loading it twice is suicidal. */
44 #include <sys/types.h>
47 #include "dispextern.h"
49 #undef HAVE_DIALOGS /* TODO: Implement native dialogs. */
51 /******************************************************************/
52 /* Definitions copied from lwlib.h */
54 typedef void * XtPointer
;
64 /* This structure is based on the one in ../lwlib/lwlib.h, modified
66 typedef struct _widget_value
71 /* value (meaning depend on widget type) */
73 /* keyboard equivalent. no implications for XtTranslations */
76 /* Help string or nil if none.
77 GC finds this string through the frame's menu_bar_vector
78 or through menu_items. */
82 /* true if selected */
84 /* The type of a button. */
85 enum button_type button_type
;
86 /* true if menu title */
89 /* true if was edited (maintained by get_value) */
91 /* true if has changed (maintained by lw library) */
93 /* true if this widget itself has changed,
94 but not counting the other widgets found in the `next' field. */
95 change_type this_one_change
;
97 /* Contents of the sub-widgets, also selected slot for checkbox */
98 struct _widget_value
* contents
;
99 /* data passed to callback */
101 /* next one in the list */
102 struct _widget_value
* next
;
104 /* slot for the toolkit dependent part. Always initialize to NULL. */
106 /* tell us if we should free the toolkit data slot when freeing the
107 widget_value itself. */
108 Boolean free_toolkit_data
;
110 /* we resource the widget_value structures; this points to the next
111 one on the free list if this one has been deallocated.
113 struct _widget_value
*free_list
;
117 /* Local memory management */
118 #define local_heap (GetProcessHeap ())
119 #define local_alloc(n) (HeapAlloc (local_heap, HEAP_ZERO_MEMORY, (n)))
120 #define local_free(p) (HeapFree (local_heap, 0, ((LPVOID) (p))))
122 #define malloc_widget_value() ((widget_value *) local_alloc (sizeof (widget_value)))
123 #define free_widget_value(wv) (local_free ((wv)))
125 /******************************************************************/
132 static HMENU current_popup_menu
;
134 void syms_of_w32menu ();
135 void globals_of_w32menu ();
137 typedef BOOL (WINAPI
* GetMenuItemInfoA_Proc
) (
141 IN OUT LPMENUITEMINFOA
);
142 typedef BOOL (WINAPI
* SetMenuItemInfoA_Proc
) (
146 IN LPCMENUITEMINFOA
);
148 GetMenuItemInfoA_Proc get_menu_item_info
= NULL
;
149 SetMenuItemInfoA_Proc set_menu_item_info
= NULL
;
150 AppendMenuW_Proc unicode_append_menu
= NULL
;
152 Lisp_Object Vmenu_updating_frame
;
154 Lisp_Object Qdebug_on_next_call
;
156 extern Lisp_Object Qmenu_bar
;
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
));
173 static Lisp_Object
w32_dialog_show ();
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
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
257 static struct frame
*
258 menubar_id_to_frame (id
)
261 Lisp_Object tail
, frame
;
264 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
267 if (!GC_FRAMEP (frame
))
270 if (!FRAME_WINDOW_P (f
))
272 if (f
->output_data
.w32
->menubar_widget
== id
)
278 /* Initialize the menu_items structure if we haven't already done so.
279 Also mark it as currently empty. */
284 if (NILP (menu_items
))
286 menu_items_allocated
= 60;
287 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
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. */
303 /* Call when finished using the data for the current menu
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)
314 menu_items_allocated
= 0;
318 /* Make the menu_items vector twice as large. */
324 int old_size
= menu_items_allocated
;
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. */
336 push_submenu_start ()
338 if (menu_items_used
+ 1 > menu_items_allocated
)
341 ASET (menu_items
, menu_items_used
++, Qnil
);
342 menu_items_submenu_depth
++;
350 if (menu_items_used
+ 1 > menu_items_allocated
)
353 ASET (menu_items
, menu_items_used
++, Qlambda
);
354 menu_items_submenu_depth
--;
357 /* Indicate boundary between left and right. */
360 push_left_right_boundary ()
362 if (menu_items_used
+ 1 > menu_items_allocated
)
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. */
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
)
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'. */
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
)
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. */
416 keymap_panes (keymaps
, nmaps
, notreal
)
417 Lisp_Object
*keymaps
;
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. */
445 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
447 Lisp_Object pane_name
;
452 Lisp_Object pending_maps
= Qnil
;
453 Lisp_Object tail
, item
;
454 struct gcpro gcpro1
, gcpro2
;
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
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
);
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
);
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
);
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
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
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. */
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
;
520 /* Parse the menu item and leave the result in item_properties. */
522 res
= parse_menu_item (item
, notreal
, 0);
525 return; /* Not a menu item. */
527 map
= AREF (item_properties
, ITEM_PROPERTY_MAP
);
531 /* We don't want to make a menu, just traverse the keymaps to
532 precompute equivalent key bindings. */
534 single_keymap_panes (map
, Qnil
, key
, 1, maxdepth
- 1);
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) == '@')
544 /* An enabled separate pane. Remember this to handle it later. */
545 *pending_maps_ptr
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
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);
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. */
578 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
580 Lisp_Object elt
, pane_name
, pane_data
;
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. */
599 Lisp_Object tail
, item
, item1
;
601 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
605 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
606 else if (NILP (item
))
607 push_left_right_boundary ();
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. */)
651 Lisp_Object position
, menu
;
653 Lisp_Object keymap
, tem
;
654 int xpos
= 0, ypos
= 0;
657 Lisp_Object selection
;
659 Lisp_Object x
, y
, window
;
665 if (! NILP (position
))
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
;
680 if (mouse_position_hook
)
681 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
682 &part
, &x
, &y
, &time
);
684 XSETFRAME (window
, new_f
);
687 window
= selected_window
;
694 tem
= Fcar (position
);
697 window
= Fcar (Fcdr (position
));
699 y
= Fcar (Fcdr (tem
));
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) */
715 /* Decode where to put the menu. */
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
));
732 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
733 but I don't want to make one now. */
734 CHECK_WINDOW (window
);
739 XSETFRAME (Vmenu_updating_frame
, f
);
742 Vmenu_updating_frame
= Qnil
;
743 #endif /* HAVE_MENUS */
748 /* Decode the menu items from what was specified. */
750 keymap
= get_keymap (menu
, 0, 0);
753 /* We were given a keymap. Extract menu info from the keymap. */
756 /* Extract the detailed info to make one pane. */
757 keymap_panes (&menu
, 1, NILP (position
));
759 /* Search for a string appearing directly as an element of the keymap.
760 That string is the title of the menu. */
761 prompt
= Fkeymap_prompt (keymap
);
762 if (NILP (title
) && !NILP (prompt
))
765 /* Make that be the pane title of the first pane. */
766 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
767 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, prompt
);
771 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
773 /* We were given a list of keymaps. */
774 int nmaps
= XFASTINT (Flength (menu
));
776 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
781 /* The first keymap that has a prompt string
782 supplies the menu title. */
783 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
787 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
789 prompt
= Fkeymap_prompt (keymap
);
790 if (NILP (title
) && !NILP (prompt
))
794 /* Extract the detailed info to make one pane. */
795 keymap_panes (maps
, nmaps
, NILP (position
));
797 /* Make the title be the pane title of the first pane. */
798 if (!NILP (title
) && menu_items_n_panes
>= 0)
799 ASET (menu_items
, MENU_ITEMS_PANE_NAME
, title
);
805 /* We were given an old-fashioned menu. */
807 CHECK_STRING (title
);
809 list_of_panes (Fcdr (menu
));
816 discard_menu_items ();
822 /* If resources from a previous popup menu still exist, does nothing
823 until the `menu_free_timer' has freed them (see w32fns.c). This
824 can occur if you press ESC or click outside a menu without selecting
827 if (current_popup_menu
)
829 discard_menu_items ();
834 /* Display them in a menu. */
837 selection
= w32_menu_show (f
, xpos
, ypos
, for_click
,
838 keymaps
, title
, &error_name
);
841 discard_menu_items ();
842 w32_free_menu_strings (FRAME_W32_WINDOW (f
));
844 #endif /* HAVE_MENUS */
848 if (error_name
) error (error_name
);
854 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
855 doc
: /* Pop up a dialog box and return user's selection.
856 POSITION specifies which frame to use.
857 This is normally a mouse button event or a window or frame.
858 If POSITION is t, it means to use the frame the mouse is on.
859 The dialog box appears in the middle of the specified frame.
861 CONTENTS specifies the alternatives to display in the dialog box.
862 It is a list of the form (TITLE ITEM1 ITEM2...).
863 Each ITEM is a cons cell (STRING . VALUE).
864 The return value is VALUE from the chosen item.
866 An ITEM may also be just a string--that makes a nonselectable item.
867 An ITEM may also be nil--that means to put all preceding items
868 on the left of the dialog box and all following items on the right.
869 \(By default, approximately half appear on each side.)
871 If HEADER is non-nil, the frame title for the box is "Information",
872 otherwise it is "Question". */)
873 (position
, contents
, header
)
874 Lisp_Object position
, contents
, header
;
881 /* Decode the first argument: find the window or frame to use. */
882 if (EQ (position
, Qt
)
883 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
884 || EQ (XCAR (position
), Qtool_bar
))))
886 #if 0 /* Using the frame the mouse is on may not be right. */
887 /* Use the mouse's current position. */
888 FRAME_PTR new_f
= SELECTED_FRAME ();
889 Lisp_Object bar_window
;
890 enum scroll_bar_part part
;
894 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
897 XSETFRAME (window
, new_f
);
899 window
= selected_window
;
901 window
= selected_window
;
903 else if (CONSP (position
))
906 tem
= Fcar (position
);
908 window
= Fcar (Fcdr (position
));
911 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
912 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
915 else if (WINDOWP (position
) || FRAMEP (position
))
920 /* Decode where to put the menu. */
924 else if (WINDOWP (window
))
926 CHECK_LIVE_WINDOW (window
);
927 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
930 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
931 but I don't want to make one now. */
932 CHECK_WINDOW (window
);
935 /* Display a menu with these alternatives
936 in the middle of frame F. */
938 Lisp_Object x
, y
, frame
, newpos
;
939 XSETFRAME (frame
, f
);
940 XSETINT (x
, x_pixel_width (f
) / 2);
941 XSETINT (y
, x_pixel_height (f
) / 2);
942 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
944 return Fx_popup_menu (newpos
,
945 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
947 #else /* HAVE_DIALOGS */
951 Lisp_Object selection
;
953 /* Decode the dialog items from what was specified. */
954 title
= Fcar (contents
);
955 CHECK_STRING (title
);
957 list_of_panes (Fcons (contents
, Qnil
));
959 /* Display them in a dialog box. */
961 selection
= w32_dialog_show (f
, 0, title
, header
, &error_name
);
964 discard_menu_items ();
966 if (error_name
) error (error_name
);
969 #endif /* HAVE_DIALOGS */
972 /* Activate the menu bar of frame F.
973 This is called from keyboard.c when it gets the
974 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
976 To activate the menu bar, we signal to the input thread that it can
977 return from the WM_INITMENU message, allowing the normal Windows
978 processing of the menus.
980 But first we recompute the menu bar contents (the whole tree).
982 This way we can safely execute Lisp code. */
985 x_activate_menubar (f
)
988 set_frame_menubar (f
, 0, 1);
990 /* Lock out further menubar changes while active. */
991 f
->output_data
.w32
->menubar_active
= 1;
993 /* Signal input thread to return from WM_INITMENU. */
994 complete_deferred_msg (FRAME_W32_WINDOW (f
), WM_INITMENU
, 0);
997 /* This callback is called from the menu bar pulldown menu
998 when the user makes a selection.
999 Figure out what the user chose
1000 and put the appropriate events into the keyboard buffer. */
1003 menubar_selection_callback (FRAME_PTR f
, void * client_data
)
1005 Lisp_Object prefix
, entry
;
1007 Lisp_Object
*subprefix_stack
;
1008 int submenu_depth
= 0;
1014 subprefix_stack
= (Lisp_Object
*) alloca (f
->menu_bar_items_used
* sizeof (Lisp_Object
));
1015 vector
= f
->menu_bar_vector
;
1018 while (i
< f
->menu_bar_items_used
)
1020 if (EQ (AREF (vector
, i
), Qnil
))
1022 subprefix_stack
[submenu_depth
++] = prefix
;
1026 else if (EQ (AREF (vector
, i
), Qlambda
))
1028 prefix
= subprefix_stack
[--submenu_depth
];
1031 else if (EQ (AREF (vector
, i
), Qt
))
1033 prefix
= AREF (vector
, i
+ MENU_ITEMS_PANE_PREFIX
);
1034 i
+= MENU_ITEMS_PANE_LENGTH
;
1038 entry
= AREF (vector
, i
+ MENU_ITEMS_ITEM_VALUE
);
1039 /* The EMACS_INT cast avoids a warning. There's no problem
1040 as long as pointers have enough bits to hold small integers. */
1041 if ((int) (EMACS_INT
) client_data
== i
)
1044 struct input_event buf
;
1048 XSETFRAME (frame
, f
);
1049 buf
.kind
= MENU_BAR_EVENT
;
1050 buf
.frame_or_window
= frame
;
1052 kbd_buffer_store_event (&buf
);
1054 for (j
= 0; j
< submenu_depth
; j
++)
1055 if (!NILP (subprefix_stack
[j
]))
1057 buf
.kind
= MENU_BAR_EVENT
;
1058 buf
.frame_or_window
= frame
;
1059 buf
.arg
= subprefix_stack
[j
];
1060 kbd_buffer_store_event (&buf
);
1065 buf
.kind
= MENU_BAR_EVENT
;
1066 buf
.frame_or_window
= frame
;
1068 kbd_buffer_store_event (&buf
);
1071 buf
.kind
= MENU_BAR_EVENT
;
1072 buf
.frame_or_window
= frame
;
1074 kbd_buffer_store_event (&buf
);
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 i
+= MENU_ITEMS_ITEM_LENGTH
;
1085 /* Free memory used by owner-drawn and help-echo strings. */
1086 w32_free_menu_strings (FRAME_W32_WINDOW (f
));
1087 f
->output_data
.w32
->menu_command_in_progress
= 0;
1088 f
->output_data
.w32
->menubar_active
= 0;
1091 /* Allocate a widget_value, blocking input. */
1094 xmalloc_widget_value ()
1096 widget_value
*value
;
1099 value
= malloc_widget_value ();
1105 /* This recursively calls free_widget_value on the tree of widgets.
1106 It must free all data that was malloc'ed for these widget_values.
1107 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1108 must be left alone. */
1111 free_menubar_widget_value_tree (wv
)
1116 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1118 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1120 free_menubar_widget_value_tree (wv
->contents
);
1121 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1125 free_menubar_widget_value_tree (wv
->next
);
1126 wv
->next
= (widget_value
*) 0xDEADBEEF;
1129 free_widget_value (wv
);
1133 /* Set up data i menu_items for a menu bar item
1134 whose event type is ITEM_KEY (with string ITEM_NAME)
1135 and whose contents come from the list of keymaps MAPS. */
1138 parse_single_submenu (item_key
, item_name
, maps
)
1139 Lisp_Object item_key
, item_name
, maps
;
1143 Lisp_Object
*mapvec
;
1145 int top_level_items
= 0;
1147 length
= Flength (maps
);
1148 len
= XINT (length
);
1150 /* Convert the list MAPS into a vector MAPVEC. */
1151 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1152 for (i
= 0; i
< len
; i
++)
1154 mapvec
[i
] = Fcar (maps
);
1158 /* Loop over the given keymaps, making a pane for each map.
1159 But don't make a pane that is empty--ignore that map instead. */
1160 for (i
= 0; i
< len
; i
++)
1162 if (SYMBOLP (mapvec
[i
])
1163 || (CONSP (mapvec
[i
]) && !KEYMAPP (mapvec
[i
])))
1165 /* Here we have a command at top level in the menu bar
1166 as opposed to a submenu. */
1167 top_level_items
= 1;
1168 push_menu_pane (Qnil
, Qnil
);
1169 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1170 Qnil
, Qnil
, Qnil
, Qnil
);
1175 prompt
= Fkeymap_prompt (mapvec
[i
]);
1176 single_keymap_panes (mapvec
[i
],
1177 !NILP (prompt
) ? prompt
: item_name
,
1182 return top_level_items
;
1186 /* Create a tree of widget_value objects
1187 representing the panes and items
1188 in menu_items starting at index START, up to index END. */
1190 static widget_value
*
1191 digest_single_submenu (start
, end
, top_level_items
)
1192 int start
, end
, top_level_items
;
1194 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1196 int submenu_depth
= 0;
1197 widget_value
**submenu_stack
;
1200 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1201 wv
= xmalloc_widget_value ();
1205 wv
->button_type
= BUTTON_TYPE_NONE
;
1211 /* Loop over all panes and items made by the preceding call
1212 to parse_single_submenu and construct a tree of widget_value objects.
1213 Ignore the panes and items used by previous calls to
1214 digest_single_submenu, even though those are also in menu_items. */
1218 if (EQ (AREF (menu_items
, i
), Qnil
))
1220 submenu_stack
[submenu_depth
++] = save_wv
;
1225 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1228 save_wv
= submenu_stack
[--submenu_depth
];
1231 else if (EQ (AREF (menu_items
, i
), Qt
)
1232 && submenu_depth
!= 0)
1233 i
+= MENU_ITEMS_PANE_LENGTH
;
1234 /* Ignore a nil in the item list.
1235 It's meaningful only for dialog boxes. */
1236 else if (EQ (AREF (menu_items
, i
), Qquote
))
1238 else if (EQ (AREF (menu_items
, i
), Qt
))
1240 /* Create a new pane. */
1241 Lisp_Object pane_name
, prefix
;
1244 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1245 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1247 if (STRINGP (pane_name
))
1249 if (unicode_append_menu
)
1250 /* Encode as UTF-8 for now. */
1251 pane_name
= ENCODE_UTF_8 (pane_name
);
1252 else if (STRING_MULTIBYTE (pane_name
))
1253 pane_name
= ENCODE_SYSTEM (pane_name
);
1255 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1258 pane_string
= (NILP (pane_name
)
1259 ? "" : (char *) SDATA (pane_name
));
1260 /* If there is just one top-level pane, put all its items directly
1261 under the top-level menu. */
1262 if (menu_items_n_panes
== 1)
1265 /* If the pane has a meaningful name,
1266 make the pane a top-level menu item
1267 with its items as a submenu beneath it. */
1268 if (strcmp (pane_string
, ""))
1270 wv
= xmalloc_widget_value ();
1274 first_wv
->contents
= wv
;
1275 wv
->lname
= pane_name
;
1276 /* Set value to 1 so update_submenu_strings can handle '@' */
1277 wv
->value
= (char *) 1;
1279 wv
->button_type
= BUTTON_TYPE_NONE
;
1284 i
+= MENU_ITEMS_PANE_LENGTH
;
1288 /* Create a new item within current pane. */
1289 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1292 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1293 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1294 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1295 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1296 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1297 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1298 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1300 if (STRINGP (item_name
))
1302 if (unicode_append_menu
)
1303 item_name
= ENCODE_UTF_8 (item_name
);
1304 else if (STRING_MULTIBYTE (item_name
))
1305 item_name
= ENCODE_SYSTEM (item_name
);
1307 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1310 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1312 descrip
= ENCODE_SYSTEM (descrip
);
1313 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1316 wv
= xmalloc_widget_value ();
1320 save_wv
->contents
= wv
;
1322 wv
->lname
= item_name
;
1323 if (!NILP (descrip
))
1326 /* The EMACS_INT cast avoids a warning. There's no problem
1327 as long as pointers have enough bits to hold small integers. */
1328 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1329 wv
->enabled
= !NILP (enable
);
1332 wv
->button_type
= BUTTON_TYPE_NONE
;
1333 else if (EQ (type
, QCradio
))
1334 wv
->button_type
= BUTTON_TYPE_RADIO
;
1335 else if (EQ (type
, QCtoggle
))
1336 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1340 wv
->selected
= !NILP (selected
);
1341 if (!STRINGP (help
))
1348 i
+= MENU_ITEMS_ITEM_LENGTH
;
1352 /* If we have just one "menu item"
1353 that was originally a button, return it by itself. */
1354 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1356 wv
= first_wv
->contents
;
1357 free_widget_value (first_wv
);
1365 /* Walk through the widget_value tree starting at FIRST_WV and update
1366 the char * pointers from the corresponding lisp values.
1367 We do this after building the whole tree, since GC may happen while the
1368 tree is constructed, and small strings are relocated. So we must wait
1369 until no GC can happen before storing pointers into lisp values. */
1371 update_submenu_strings (first_wv
)
1372 widget_value
*first_wv
;
1376 for (wv
= first_wv
; wv
; wv
= wv
->next
)
1378 if (wv
->lname
&& ! NILP (wv
->lname
))
1380 wv
->name
= SDATA (wv
->lname
);
1382 /* Ignore the @ that means "separate pane".
1383 This is a kludge, but this isn't worth more time. */
1384 if (wv
->value
== (char *)1)
1386 if (wv
->name
[0] == '@')
1392 if (wv
->lkey
&& ! NILP (wv
->lkey
))
1393 wv
->key
= SDATA (wv
->lkey
);
1396 update_submenu_strings (wv
->contents
);
1401 /* Set the contents of the menubar widgets of frame F.
1402 The argument FIRST_TIME is currently ignored;
1403 it is set the first time this is called, from initialize_frame_menubar. */
1406 set_frame_menubar (f
, first_time
, deep_p
)
1411 HMENU menubar_widget
= f
->output_data
.w32
->menubar_widget
;
1413 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1415 int *submenu_start
, *submenu_end
;
1416 int *submenu_top_level_items
, *submenu_n_panes
;
1418 /* We must not change the menubar when actually in use. */
1419 if (f
->output_data
.w32
->menubar_active
)
1422 XSETFRAME (Vmenu_updating_frame
, f
);
1424 if (! menubar_widget
)
1426 else if (pending_menu_activation
&& !deep_p
)
1431 /* Make a widget-value tree representing the entire menu trees. */
1433 struct buffer
*prev
= current_buffer
;
1435 int specpdl_count
= SPECPDL_INDEX ();
1436 int previous_menu_items_used
= f
->menu_bar_items_used
;
1437 Lisp_Object
*previous_items
1438 = (Lisp_Object
*) alloca (previous_menu_items_used
1439 * sizeof (Lisp_Object
));
1441 /* If we are making a new widget, its contents are empty,
1442 do always reinitialize them. */
1443 if (! menubar_widget
)
1444 previous_menu_items_used
= 0;
1446 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1447 specbind (Qinhibit_quit
, Qt
);
1448 /* Don't let the debugger step into this code
1449 because it is not reentrant. */
1450 specbind (Qdebug_on_next_call
, Qnil
);
1452 record_unwind_save_match_data ();
1454 if (NILP (Voverriding_local_map_menu_flag
))
1456 specbind (Qoverriding_terminal_local_map
, Qnil
);
1457 specbind (Qoverriding_local_map
, Qnil
);
1460 set_buffer_internal_1 (XBUFFER (buffer
));
1462 /* Run the Lucid hook. */
1463 safe_run_hooks (Qactivate_menubar_hook
);
1464 /* If it has changed current-menubar from previous value,
1465 really recompute the menubar from the value. */
1466 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1467 call0 (Qrecompute_lucid_menubar
);
1468 safe_run_hooks (Qmenu_bar_update_hook
);
1469 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1471 items
= FRAME_MENU_BAR_ITEMS (f
);
1473 /* Save the frame's previous menu bar contents data. */
1474 if (previous_menu_items_used
)
1475 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1476 previous_menu_items_used
* sizeof (Lisp_Object
));
1478 /* Fill in menu_items with the current menu bar contents.
1479 This can evaluate Lisp code. */
1480 menu_items
= f
->menu_bar_vector
;
1481 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1482 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1483 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1484 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1485 submenu_top_level_items
1486 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1488 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1490 Lisp_Object key
, string
, maps
;
1494 key
= AREF (items
, i
);
1495 string
= AREF (items
, i
+ 1);
1496 maps
= AREF (items
, i
+ 2);
1500 submenu_start
[i
] = menu_items_used
;
1502 menu_items_n_panes
= 0;
1503 submenu_top_level_items
[i
]
1504 = parse_single_submenu (key
, string
, maps
);
1505 submenu_n_panes
[i
] = menu_items_n_panes
;
1507 submenu_end
[i
] = menu_items_used
;
1510 finish_menu_items ();
1512 /* Convert menu_items into widget_value trees
1513 to display the menu. This cannot evaluate Lisp code. */
1515 wv
= xmalloc_widget_value ();
1516 wv
->name
= "menubar";
1519 wv
->button_type
= BUTTON_TYPE_NONE
;
1523 for (i
= 0; i
< last_i
; i
+= 4)
1525 menu_items_n_panes
= submenu_n_panes
[i
];
1526 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1527 submenu_top_level_items
[i
]);
1531 first_wv
->contents
= wv
;
1532 /* Don't set wv->name here; GC during the loop might relocate it. */
1534 wv
->button_type
= BUTTON_TYPE_NONE
;
1538 set_buffer_internal_1 (prev
);
1539 unbind_to (specpdl_count
, Qnil
);
1541 /* If there has been no change in the Lisp-level contents
1542 of the menu bar, skip redisplaying it. Just exit. */
1544 for (i
= 0; i
< previous_menu_items_used
; i
++)
1545 if (menu_items_used
== i
1546 || (!EQ (previous_items
[i
], AREF (menu_items
, i
))))
1548 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1550 free_menubar_widget_value_tree (first_wv
);
1556 /* Now GC cannot happen during the lifetime of the widget_value,
1557 so it's safe to store data from a Lisp_String, as long as
1558 local copies are made when the actual menu is created.
1559 Windows takes care of this for normal string items, but
1560 not for owner-drawn items or additional item-info. */
1561 wv
= first_wv
->contents
;
1562 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1565 string
= AREF (items
, i
+ 1);
1568 wv
->name
= (char *) SDATA (string
);
1569 update_submenu_strings (wv
->contents
);
1573 f
->menu_bar_vector
= menu_items
;
1574 f
->menu_bar_items_used
= menu_items_used
;
1579 /* Make a widget-value tree containing
1580 just the top level menu bar strings. */
1582 wv
= xmalloc_widget_value ();
1583 wv
->name
= "menubar";
1586 wv
->button_type
= BUTTON_TYPE_NONE
;
1590 items
= FRAME_MENU_BAR_ITEMS (f
);
1591 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1595 string
= AREF (items
, i
+ 1);
1599 wv
= xmalloc_widget_value ();
1600 wv
->name
= (char *) SDATA (string
);
1603 wv
->button_type
= BUTTON_TYPE_NONE
;
1605 /* This prevents lwlib from assuming this
1606 menu item is really supposed to be empty. */
1607 /* The EMACS_INT cast avoids a warning.
1608 This value just has to be different from small integers. */
1609 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1614 first_wv
->contents
= wv
;
1618 /* Forget what we thought we knew about what is in the
1619 detailed contents of the menu bar menus.
1620 Changing the top level always destroys the contents. */
1621 f
->menu_bar_items_used
= 0;
1624 /* Create or update the menu bar widget. */
1630 /* Empty current menubar, rather than creating a fresh one. */
1631 while (DeleteMenu (menubar_widget
, 0, MF_BYPOSITION
))
1636 menubar_widget
= CreateMenu ();
1638 fill_in_menu (menubar_widget
, first_wv
->contents
);
1640 free_menubar_widget_value_tree (first_wv
);
1643 HMENU old_widget
= f
->output_data
.w32
->menubar_widget
;
1645 f
->output_data
.w32
->menubar_widget
= menubar_widget
;
1646 SetMenu (FRAME_W32_WINDOW (f
), f
->output_data
.w32
->menubar_widget
);
1647 /* Causes flicker when menu bar is updated
1648 DrawMenuBar (FRAME_W32_WINDOW (f)); */
1650 /* Force the window size to be recomputed so that the frame's text
1651 area remains the same, if menubar has just been created. */
1652 if (old_widget
== NULL
)
1653 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1659 /* Called from Fx_create_frame to create the initial menubar of a frame
1660 before it is mapped, so that the window is mapped with the menubar already
1661 there instead of us tacking it on later and thrashing the window after it
1665 initialize_frame_menubar (f
)
1668 /* This function is called before the first chance to redisplay
1669 the frame. It has to be, so the frame will have the right size. */
1670 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1671 set_frame_menubar (f
, 1, 1);
1674 /* Get rid of the menu bar of frame F, and free its storage.
1675 This is used when deleting a frame, and when turning off the menu bar. */
1678 free_frame_menubar (f
)
1684 HMENU old
= GetMenu (FRAME_W32_WINDOW (f
));
1685 SetMenu (FRAME_W32_WINDOW (f
), NULL
);
1686 f
->output_data
.w32
->menubar_widget
= NULL
;
1694 /* w32_menu_show actually displays a menu using the panes and items in
1695 menu_items and returns the value selected from it; we assume input
1696 is blocked by the caller. */
1698 /* F is the frame the menu is for.
1699 X and Y are the frame-relative specified position,
1700 relative to the inside upper left corner of the frame F.
1701 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1702 KEYMAPS is 1 if this menu was specified with keymaps;
1703 in that case, we return a list containing the chosen item's value
1704 and perhaps also the pane's prefix.
1705 TITLE is the specified menu title.
1706 ERROR is a place to store an error message string in case of failure.
1707 (We return nil on failure, but the value doesn't actually matter.) */
1710 w32_menu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
1720 int menu_item_selection
;
1723 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1724 widget_value
**submenu_stack
1725 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1726 Lisp_Object
*subprefix_stack
1727 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1728 int submenu_depth
= 0;
1733 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1735 *error
= "Empty menu";
1739 /* Create a tree of widget_value objects
1740 representing the panes and their items. */
1741 wv
= xmalloc_widget_value ();
1745 wv
->button_type
= BUTTON_TYPE_NONE
;
1750 /* Loop over all panes and items, filling in the tree. */
1752 while (i
< menu_items_used
)
1754 if (EQ (AREF (menu_items
, i
), Qnil
))
1756 submenu_stack
[submenu_depth
++] = save_wv
;
1762 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1765 save_wv
= submenu_stack
[--submenu_depth
];
1769 else if (EQ (AREF (menu_items
, i
), Qt
)
1770 && submenu_depth
!= 0)
1771 i
+= MENU_ITEMS_PANE_LENGTH
;
1772 /* Ignore a nil in the item list.
1773 It's meaningful only for dialog boxes. */
1774 else if (EQ (AREF (menu_items
, i
), Qquote
))
1776 else if (EQ (AREF (menu_items
, i
), Qt
))
1778 /* Create a new pane. */
1779 Lisp_Object pane_name
, prefix
;
1781 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1782 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1784 if (STRINGP (pane_name
))
1786 if (unicode_append_menu
)
1787 pane_name
= ENCODE_UTF_8 (pane_name
);
1788 else if (STRING_MULTIBYTE (pane_name
))
1789 pane_name
= ENCODE_SYSTEM (pane_name
);
1791 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1794 pane_string
= (NILP (pane_name
)
1795 ? "" : (char *) SDATA (pane_name
));
1796 /* If there is just one top-level pane, put all its items directly
1797 under the top-level menu. */
1798 if (menu_items_n_panes
== 1)
1801 /* If the pane has a meaningful name,
1802 make the pane a top-level menu item
1803 with its items as a submenu beneath it. */
1804 if (!keymaps
&& strcmp (pane_string
, ""))
1806 wv
= xmalloc_widget_value ();
1810 first_wv
->contents
= wv
;
1811 wv
->name
= pane_string
;
1812 if (keymaps
&& !NILP (prefix
))
1816 wv
->button_type
= BUTTON_TYPE_NONE
;
1821 else if (first_pane
)
1827 i
+= MENU_ITEMS_PANE_LENGTH
;
1831 /* Create a new item within current pane. */
1832 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
1834 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1835 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1836 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1837 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1838 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1839 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1840 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1842 if (STRINGP (item_name
))
1844 if (unicode_append_menu
)
1845 item_name
= ENCODE_UTF_8 (item_name
);
1846 else if (STRING_MULTIBYTE (item_name
))
1847 item_name
= ENCODE_SYSTEM (item_name
);
1849 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1852 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1854 descrip
= ENCODE_SYSTEM (descrip
);
1855 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1858 wv
= xmalloc_widget_value ();
1862 save_wv
->contents
= wv
;
1863 wv
->name
= (char *) SDATA (item_name
);
1864 if (!NILP (descrip
))
1865 wv
->key
= (char *) SDATA (descrip
);
1867 /* Use the contents index as call_data, since we are
1868 restricted to 16-bits. */
1869 wv
->call_data
= !NILP (def
) ? (void *) (EMACS_INT
) i
: 0;
1870 wv
->enabled
= !NILP (enable
);
1873 wv
->button_type
= BUTTON_TYPE_NONE
;
1874 else if (EQ (type
, QCtoggle
))
1875 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1876 else if (EQ (type
, QCradio
))
1877 wv
->button_type
= BUTTON_TYPE_RADIO
;
1881 wv
->selected
= !NILP (selected
);
1882 if (!STRINGP (help
))
1889 i
+= MENU_ITEMS_ITEM_LENGTH
;
1893 /* Deal with the title, if it is non-nil. */
1896 widget_value
*wv_title
= xmalloc_widget_value ();
1897 widget_value
*wv_sep
= xmalloc_widget_value ();
1899 /* Maybe replace this separator with a bitmap or owner-draw item
1900 so that it looks better. Having two separators looks odd. */
1901 wv_sep
->name
= "--";
1902 wv_sep
->next
= first_wv
->contents
;
1903 wv_sep
->help
= Qnil
;
1905 if (unicode_append_menu
)
1906 title
= ENCODE_UTF_8 (title
);
1907 else if (STRING_MULTIBYTE (title
))
1908 title
= ENCODE_SYSTEM (title
);
1910 wv_title
->name
= (char *) SDATA (title
);
1911 wv_title
->enabled
= TRUE
;
1912 wv_title
->title
= TRUE
;
1913 wv_title
->button_type
= BUTTON_TYPE_NONE
;
1914 wv_title
->help
= Qnil
;
1915 wv_title
->next
= wv_sep
;
1916 first_wv
->contents
= wv_title
;
1919 /* Actually create the menu. */
1920 current_popup_menu
= menu
= CreatePopupMenu ();
1921 fill_in_menu (menu
, first_wv
->contents
);
1923 /* Adjust coordinates to be root-window-relative. */
1926 ClientToScreen (FRAME_W32_WINDOW (f
), &pos
);
1928 /* No selection has been chosen yet. */
1929 menu_item_selection
= 0;
1931 /* Display the menu. */
1932 menu_item_selection
= SendMessage (FRAME_W32_WINDOW (f
),
1933 WM_EMACS_TRACKPOPUPMENU
,
1934 (WPARAM
)menu
, (LPARAM
)&pos
);
1936 /* Clean up extraneous mouse events which might have been generated
1938 discard_mouse_events ();
1940 /* Free the widget_value objects we used to specify the contents. */
1941 free_menubar_widget_value_tree (first_wv
);
1945 /* Find the selected item, and its pane, to return
1946 the proper value. */
1947 if (menu_item_selection
!= 0)
1949 Lisp_Object prefix
, entry
;
1951 prefix
= entry
= Qnil
;
1953 while (i
< menu_items_used
)
1955 if (EQ (AREF (menu_items
, i
), Qnil
))
1957 subprefix_stack
[submenu_depth
++] = prefix
;
1961 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1963 prefix
= subprefix_stack
[--submenu_depth
];
1966 else if (EQ (AREF (menu_items
, i
), Qt
))
1968 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1969 i
+= MENU_ITEMS_PANE_LENGTH
;
1971 /* Ignore a nil in the item list.
1972 It's meaningful only for dialog boxes. */
1973 else if (EQ (AREF (menu_items
, i
), Qquote
))
1977 entry
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
1978 if (menu_item_selection
== i
)
1984 entry
= Fcons (entry
, Qnil
);
1986 entry
= Fcons (prefix
, entry
);
1987 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1988 if (!NILP (subprefix_stack
[j
]))
1989 entry
= Fcons (subprefix_stack
[j
], entry
);
1993 i
+= MENU_ITEMS_ITEM_LENGTH
;
1997 else if (!for_click
)
1998 /* Make "Cancel" equivalent to C-g. */
1999 Fsignal (Qquit
, Qnil
);
2006 static char * button_names
[] = {
2007 "button1", "button2", "button3", "button4", "button5",
2008 "button6", "button7", "button8", "button9", "button10" };
2011 w32_dialog_show (f
, keymaps
, title
, header
, error
)
2014 Lisp_Object title
, header
;
2017 int i
, nb_buttons
=0;
2018 char dialog_name
[6];
2019 int menu_item_selection
;
2021 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2023 /* Number of elements seen so far, before boundary. */
2025 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2026 int boundary_seen
= 0;
2030 if (menu_items_n_panes
> 1)
2032 *error
= "Multiple panes in dialog box";
2036 /* Create a tree of widget_value objects
2037 representing the text label and buttons. */
2039 Lisp_Object pane_name
, prefix
;
2041 pane_name
= AREF (menu_items
, MENU_ITEMS_PANE_NAME
);
2042 prefix
= AREF (menu_items
, MENU_ITEMS_PANE_PREFIX
);
2043 pane_string
= (NILP (pane_name
)
2044 ? "" : (char *) SDATA (pane_name
));
2045 prev_wv
= xmalloc_widget_value ();
2046 prev_wv
->value
= pane_string
;
2047 if (keymaps
&& !NILP (prefix
))
2049 prev_wv
->enabled
= 1;
2050 prev_wv
->name
= "message";
2051 prev_wv
->help
= Qnil
;
2054 /* Loop over all panes and items, filling in the tree. */
2055 i
= MENU_ITEMS_PANE_LENGTH
;
2056 while (i
< menu_items_used
)
2059 /* Create a new item within current pane. */
2060 Lisp_Object item_name
, enable
, descrip
, help
;
2062 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2063 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2064 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2065 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2067 if (NILP (item_name
))
2069 free_menubar_widget_value_tree (first_wv
);
2070 *error
= "Submenu in dialog items";
2073 if (EQ (item_name
, Qquote
))
2075 /* This is the boundary between left-side elts
2076 and right-side elts. Stop incrementing right_count. */
2081 if (nb_buttons
>= 9)
2083 free_menubar_widget_value_tree (first_wv
);
2084 *error
= "Too many dialog items";
2088 wv
= xmalloc_widget_value ();
2090 wv
->name
= (char *) button_names
[nb_buttons
];
2091 if (!NILP (descrip
))
2092 wv
->key
= (char *) SDATA (descrip
);
2093 wv
->value
= (char *) SDATA (item_name
);
2094 wv
->call_data
= (void *) &AREF (menu_items
, i
);
2095 wv
->enabled
= !NILP (enable
);
2099 if (! boundary_seen
)
2103 i
+= MENU_ITEMS_ITEM_LENGTH
;
2106 /* If the boundary was not specified,
2107 by default put half on the left and half on the right. */
2108 if (! boundary_seen
)
2109 left_count
= nb_buttons
- nb_buttons
/ 2;
2111 wv
= xmalloc_widget_value ();
2112 wv
->name
= dialog_name
;
2115 /* Frame title: 'Q' = Question, 'I' = Information.
2116 Can also have 'E' = Error if, one day, we want
2117 a popup for errors. */
2119 dialog_name
[0] = 'Q';
2121 dialog_name
[0] = 'I';
2123 /* Dialog boxes use a really stupid name encoding
2124 which specifies how many buttons to use
2125 and how many buttons are on the right. */
2126 dialog_name
[1] = '0' + nb_buttons
;
2127 dialog_name
[2] = 'B';
2128 dialog_name
[3] = 'R';
2129 /* Number of buttons to put on the right. */
2130 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2132 wv
->contents
= first_wv
;
2136 /* Actually create the dialog. */
2137 dialog_id
= widget_id_tick
++;
2138 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2139 f
->output_data
.w32
->widget
, 1, 0,
2140 dialog_selection_callback
, 0);
2141 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, TRUE
);
2143 /* Free the widget_value objects we used to specify the contents. */
2144 free_menubar_widget_value_tree (first_wv
);
2146 /* No selection has been chosen yet. */
2147 menu_item_selection
= 0;
2149 /* Display the menu. */
2150 lw_pop_up_all_widgets (dialog_id
);
2151 popup_activated_flag
= 1;
2153 /* Process events that apply to the menu. */
2154 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
);
2156 lw_destroy_all_widgets (dialog_id
);
2158 /* Find the selected item, and its pane, to return
2159 the proper value. */
2160 if (menu_item_selection
!= 0)
2166 while (i
< menu_items_used
)
2170 if (EQ (AREF (menu_items
, i
), Qt
))
2172 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2173 i
+= MENU_ITEMS_PANE_LENGTH
;
2177 entry
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
2178 if (menu_item_selection
== i
)
2182 entry
= Fcons (entry
, Qnil
);
2184 entry
= Fcons (prefix
, entry
);
2188 i
+= MENU_ITEMS_ITEM_LENGTH
;
2193 /* Make "Cancel" equivalent to C-g. */
2194 Fsignal (Qquit
, Qnil
);
2198 #endif /* HAVE_DIALOGS */
2201 /* Is this item a separator? */
2203 name_is_separator (name
)
2208 /* Check if name string consists of only dashes ('-'). */
2209 while (*name
== '-') name
++;
2210 /* Separators can also be of the form "--:TripleSuperMegaEtched"
2211 or "--deep-shadow". We don't implement them yet, se we just treat
2212 them like normal separators. */
2213 return (*name
== '\0' || start
+ 2 == name
);
2217 /* Indicate boundary between left and right. */
2219 add_left_right_boundary (HMENU menu
)
2221 return AppendMenu (menu
, MF_MENUBARBREAK
, 0, NULL
);
2224 /* UTF8: 0xxxxxxx, 110xxxxx 10xxxxxx, 1110xxxx, 10xxxxxx, 10xxxxxx */
2226 utf8to16 (unsigned char * src
, int len
, WCHAR
* dest
)
2233 *dest
= (WCHAR
) *src
;
2234 dest
++; src
++; len
--;
2236 /* Since we might get >3 byte sequences which we don't handle, ignore the extra parts. */
2237 else if (*src
< 0xC0)
2241 /* 2 char UTF-8 sequence. */
2242 else if (*src
< 0xE0)
2244 *dest
= (WCHAR
) (((*src
& 0x1f) << 6)
2245 | (*(src
+ 1) & 0x3f));
2246 src
+= 2; len
-= 2; dest
++;
2248 else if (*src
< 0xF0)
2250 *dest
= (WCHAR
) (((*src
& 0x0f) << 12)
2251 | ((*(src
+ 1) & 0x3f) << 6)
2252 | (*(src
+ 2) & 0x3f));
2253 src
+= 3; len
-= 3; dest
++;
2255 else /* Not encodable. Insert Unicode Substitution char. */
2257 *dest
= (WCHAR
) 0xfffd;
2258 src
++; len
--; dest
++;
2265 add_menu_item (HMENU menu
, widget_value
*wv
, HMENU item
)
2271 if (name_is_separator (wv
->name
))
2273 fuFlags
= MF_SEPARATOR
;
2279 fuFlags
= MF_STRING
;
2281 fuFlags
= MF_STRING
| MF_GRAYED
;
2283 if (wv
->key
!= NULL
)
2285 out_string
= alloca (strlen (wv
->name
) + strlen (wv
->key
) + 2);
2286 strcpy (out_string
, wv
->name
);
2287 strcat (out_string
, "\t");
2288 strcat (out_string
, wv
->key
);
2291 out_string
= wv
->name
;
2295 else if (wv
->title
|| wv
->call_data
== 0)
2297 /* Only use MF_OWNERDRAW if GetMenuItemInfo is usable, since
2298 we can't deallocate the memory otherwise. */
2299 if (get_menu_item_info
)
2301 out_string
= (char *) local_alloc (strlen (wv
->name
) + 1);
2302 strcpy (out_string
, wv
->name
);
2304 DebPrint ("Menu: allocing %ld for owner-draw", out_string
);
2306 fuFlags
= MF_OWNERDRAW
| MF_DISABLED
;
2309 fuFlags
= MF_DISABLED
;
2312 /* Draw radio buttons and tickboxes. */
2313 else if (wv
->selected
&& (wv
->button_type
== BUTTON_TYPE_TOGGLE
||
2314 wv
->button_type
== BUTTON_TYPE_RADIO
))
2315 fuFlags
|= MF_CHECKED
;
2317 fuFlags
|= MF_UNCHECKED
;
2320 if (unicode_append_menu
&& out_string
)
2322 /* Convert out_string from UTF-8 to UTF-16-LE. */
2323 int utf8_len
= strlen (out_string
);
2324 WCHAR
* utf16_string
;
2325 if (fuFlags
& MF_OWNERDRAW
)
2326 utf16_string
= local_alloc ((utf8_len
+ 1) * sizeof (WCHAR
));
2328 utf16_string
= alloca ((utf8_len
+ 1) * sizeof (WCHAR
));
2330 utf8to16 (out_string
, utf8_len
, utf16_string
);
2331 return_value
= unicode_append_menu (menu
, fuFlags
,
2332 item
!= NULL
? (UINT
) item
2333 : (UINT
) wv
->call_data
,
2337 /* On W9x/ME, unicode menus are not supported, though AppendMenuW
2338 apparently does exist at least in some cases and appears to be
2339 stubbed out to do nothing. out_string is UTF-8, but since
2340 our standard menus are in English and this is only going to
2341 happen the first time a menu is used, the encoding is
2342 of minor importance compared with menus not working at all. */
2344 AppendMenu (menu
, fuFlags
,
2345 item
!= NULL
? (UINT
) item
: (UINT
) wv
->call_data
,
2347 /* Don't use unicode menus in future. */
2348 unicode_append_menu
= NULL
;
2351 if (unicode_append_menu
&& (fuFlags
& MF_OWNERDRAW
))
2352 local_free (out_string
);
2359 item
!= NULL
? (UINT
) item
: (UINT
) wv
->call_data
,
2363 /* This must be done after the menu item is created. */
2364 if (!wv
->title
&& wv
->call_data
!= 0)
2366 if (set_menu_item_info
)
2369 bzero (&info
, sizeof (info
));
2370 info
.cbSize
= sizeof (info
);
2371 info
.fMask
= MIIM_DATA
;
2373 /* Set help string for menu item. Leave it as a Lisp_Object
2374 until it is ready to be displayed, since GC can happen while
2375 menus are active. */
2376 if (!NILP (wv
->help
))
2377 #ifdef USE_LISP_UNION_TYPE
2378 info
.dwItemData
= (DWORD
) (wv
->help
).i
;
2380 info
.dwItemData
= (DWORD
) (wv
->help
);
2382 if (wv
->button_type
== BUTTON_TYPE_RADIO
)
2384 /* CheckMenuRadioItem allows us to differentiate TOGGLE and
2385 RADIO items, but is not available on NT 3.51 and earlier. */
2386 info
.fMask
|= MIIM_TYPE
| MIIM_STATE
;
2387 info
.fType
= MFT_RADIOCHECK
| MFT_STRING
;
2388 info
.dwTypeData
= out_string
;
2389 info
.fState
= wv
->selected
? MFS_CHECKED
: MFS_UNCHECKED
;
2392 set_menu_item_info (menu
,
2393 item
!= NULL
? (UINT
) item
: (UINT
) wv
->call_data
,
2397 return return_value
;
2400 /* Construct native Windows menu(bar) based on widget_value tree. */
2402 fill_in_menu (HMENU menu
, widget_value
*wv
)
2404 int items_added
= 0;
2406 for ( ; wv
!= NULL
; wv
= wv
->next
)
2410 HMENU sub_menu
= CreatePopupMenu ();
2412 if (sub_menu
== NULL
)
2415 if (!fill_in_menu (sub_menu
, wv
->contents
) ||
2416 !add_menu_item (menu
, wv
, sub_menu
))
2418 DestroyMenu (sub_menu
);
2424 if (!add_menu_item (menu
, wv
, NULL
))
2434 /* popup_activated_flag not actually used on W32 */
2438 /* Display help string for currently pointed to menu item. Not
2439 supported on NT 3.51 and earlier, as GetMenuItemInfo is not
2442 w32_menu_display_help (HWND owner
, HMENU menu
, UINT item
, UINT flags
)
2444 if (get_menu_item_info
)
2446 struct frame
*f
= x_window_to_frame (&one_w32_display_info
, owner
);
2447 Lisp_Object frame
, help
;
2449 /* No help echo on owner-draw menu items, or when the keyboard is used
2450 to navigate the menus, since tooltips are distracting if they pop
2452 if (flags
& MF_OWNERDRAW
|| flags
& MF_POPUP
2453 || !(flags
& MF_MOUSESELECT
))
2459 bzero (&info
, sizeof (info
));
2460 info
.cbSize
= sizeof (info
);
2461 info
.fMask
= MIIM_DATA
;
2462 get_menu_item_info (menu
, item
, FALSE
, &info
);
2464 #ifdef USE_LISP_UNION_TYPE
2465 help
= info
.dwItemData
? (Lisp_Object
) ((EMACS_INT
) info
.dwItemData
)
2468 help
= info
.dwItemData
? (Lisp_Object
) info
.dwItemData
: Qnil
;
2472 /* Store the help echo in the keyboard buffer as the X toolkit
2473 version does, rather than directly showing it. This seems to
2474 solve the GC problems that were present when we based the
2475 Windows code on the non-toolkit version. */
2478 XSETFRAME (frame
, f
);
2479 kbd_buffer_store_help_event (frame
, help
);
2482 /* X version has a loop through frames here, which doesn't
2483 appear to do anything, unless it has some side effect. */
2484 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
2488 /* Free memory used by owner-drawn strings. */
2490 w32_free_submenu_strings (menu
)
2493 int i
, num
= GetMenuItemCount (menu
);
2494 for (i
= 0; i
< num
; i
++)
2497 bzero (&info
, sizeof (info
));
2498 info
.cbSize
= sizeof (info
);
2499 info
.fMask
= MIIM_DATA
| MIIM_TYPE
| MIIM_SUBMENU
;
2501 get_menu_item_info (menu
, i
, TRUE
, &info
);
2503 /* Owner-drawn names are held in dwItemData. */
2504 if ((info
.fType
& MF_OWNERDRAW
) && info
.dwItemData
)
2507 DebPrint ("Menu: freeing %ld for owner-draw", info
.dwItemData
);
2509 local_free (info
.dwItemData
);
2512 /* Recurse down submenus. */
2514 w32_free_submenu_strings (info
.hSubMenu
);
2519 w32_free_menu_strings (hwnd
)
2522 HMENU menu
= current_popup_menu
;
2524 if (get_menu_item_info
)
2526 /* If there is no popup menu active, free the strings from the frame's
2529 menu
= GetMenu (hwnd
);
2532 w32_free_submenu_strings (menu
);
2535 current_popup_menu
= NULL
;
2538 #endif /* HAVE_MENUS */
2540 void syms_of_w32menu ()
2542 globals_of_w32menu ();
2543 staticpro (&menu_items
);
2546 current_popup_menu
= NULL
;
2548 Qdebug_on_next_call
= intern ("debug-on-next-call");
2549 staticpro (&Qdebug_on_next_call
);
2551 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
2552 doc
: /* Frame for which we are updating a menu.
2553 The enable predicate for a menu command should check this variable. */);
2554 Vmenu_updating_frame
= Qnil
;
2556 defsubr (&Sx_popup_menu
);
2558 defsubr (&Sx_popup_dialog
);
2563 globals_of_w32menu is used to initialize those global variables that
2564 must always be initialized on startup even when the global variable
2565 initialized is non zero (see the function main in emacs.c).
2566 globals_of_w32menu is called from syms_of_w32menu when the global
2567 variable initialized is 0 and directly from main when initialized
2570 void globals_of_w32menu ()
2572 /* See if Get/SetMenuItemInfo functions are available. */
2573 HMODULE user32
= GetModuleHandle ("user32.dll");
2574 get_menu_item_info
= (GetMenuItemInfoA_Proc
) GetProcAddress (user32
, "GetMenuItemInfoA");
2575 set_menu_item_info
= (SetMenuItemInfoA_Proc
) GetProcAddress (user32
, "SetMenuItemInfoA");
2576 unicode_append_menu
= (AppendMenuW_Proc
) GetProcAddress (user32
, "AppendMenuW");
2579 /* arch-tag: 0eaed431-bb4e-4aac-a527-95a1b4f1fed0
2580 (do not change this comment) */