1 /* Implements an elisp-programmable menubar -- Win32
2 Copyright (C) 1993, 1994 Free Software Foundation, Inc.
3 Copyright (C) 1995 Tinker Systems and INS Engineering Corp.
4 Copyright (C) 1997 Kirill M. Katsnelson <kkm@kis.ru>
6 This file is part of XEmacs.
8 XEmacs is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with XEmacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Synched up with: Not in FSF. */
26 Initially written by kkm 12/24/97,
27 peeking into and copying stuff from menubar-x.c
30 /* Algorithm for handling menus is as follows. When window's menubar
31 * is created, current-menubar is not traversed in depth. Rather, only
32 * top level items, both items and pulldowns, are added to the
33 * menubar. Each pulldown is initially empty. When a pulldown is
34 * selected and about to open, corresponding element of
35 * current-menubar is found, and the newly open pulldown is
36 * populated. This is made again in the same non-recursive manner.
38 * This algorithm uses hash tables to find out element of the menu
39 * descriptor list given menu handle. The key is an opaque ptr data
40 * type, keeping menu handle, and the value is a list of strings
41 * representing the path from the root of the menu to the item
42 * descriptor. Each frame has an associated hash table.
44 * Leaf items are assigned a unique id based on item's hash. When an
45 * item is selected, Windows sends back the id. Unfortunately, only
46 * low 16 bit of the ID are sent, and there's no way to get the 32-bit
47 * value. Yes, Win32 is just a different set of bugs than X! Aside
48 * from this blame, another hashing mechanism is required to map menu
49 * ids to commands (which are actually Lisp_Object's). This mapping is
50 * performed in the same hash table, as the lifetime of both maps is
51 * exactly the same. This is unambigous, as menu handles are
52 * represented by lisp opaques, while command ids are by lisp
53 * integers. The additional advantage for this is that command forms
54 * are automatically GC-protected, which is important because these
55 * may be transient forms generated by :filter functions.
57 * The hash table is not allowed to grow too much; it is pruned
58 * whenever this is safe to do. This is done by re-creating the menu
59 * bar, and clearing and refilling the hash table from scratch.
61 * Popup menus are handled identically to pulldowns. A static hash
62 * table is used for popup menus, and lookup is made not in
63 * current-menubar but in a lisp form supplied to the `popup'
66 * Another Windows weirdness is that there's no way to tell that a
67 * popup has been dismissed without making selection. We need to know
68 * that to cleanup the popup menu hash table, but this is not honestly
69 * doable using *documented* sequence of messages. Sticking to
70 * particular knowledge is bad because this may break in Windows NT
71 * 5.0, or Windows 98, or other future version. Instead, I allow the
72 * hash tables to hang around, and not clear them, unless WM_COMMAND is
73 * received. This is worthy some memory but more safe. Hacks welcome,
84 #include "console-msw.h"
91 #include "menubar-msw.h"
96 #define REPLACE_ME_WITH_GLOBAL_VARIABLE_WHICH_CONTROLS_RIHGT_FLUSH 0
98 #define EMPTY_ITEM_ID ((UINT)LISP_TO_VOID (Qunbound))
99 #define EMPTY_ITEM_NAME "(empty)"
101 /* Current menu (bar or popup) descriptor. gcpro'ed */
102 static Lisp_Object current_menudesc;
104 /* Current menubar or popup hash table. gcpro'ed */
105 static Lisp_Object current_hash_table;
107 /* This is used to allocate unique ids to menu items.
108 Items ids are in MENU_ITEM_ID_MIN to MENU_ITEM_ID_MAX.
109 Allocation checks that the item is not already in
110 the TOP_LEVEL_MENU */
112 /* #### defines go to gui-msw.h, as the range is shared with toolbars
113 (If only toolbars will be implemented as common controls) */
114 #define MENU_ITEM_ID_MIN 0x8000
115 #define MENU_ITEM_ID_MAX 0xFFFF
116 #define MENU_ITEM_ID_BITS(x) (((x) & 0x7FFF) | 0x8000)
117 static HMENU top_level_menu;
119 #define MAX_MENUITEM_LENGTH 128
122 * This returns Windows-style menu item string:
123 * "Left Flush\tRight Flush"
126 displayable_menu_item (Lisp_Object gui_item, int bar_p)
128 /* We construct the name in a static buffer. That's fine, because
129 menu items longer than 128 chars are probably programming errors,
130 and better be caught than displayed! */
132 static char buf[MAX_MENUITEM_LENGTH+2];
136 /* Left flush part of the string */
137 ll = gui_item_display_flush_left (gui_item, buf, MAX_MENUITEM_LENGTH);
139 /* Escape '&' as '&&' */
141 while ((ptr=memchr (ptr, '&', ll-(ptr-buf))) != NULL)
143 if (ll+2 >= MAX_MENUITEM_LENGTH)
144 signal_simple_error ("Menu item produces too long displayable string",
145 XGUI_ITEM (gui_item)->name);
146 memmove (ptr+1, ptr, (ll-(ptr-buf))+1);
151 /* Replace XEmacs accelerator '%_' with Windows accelerator '&' */
153 while ((ptr=memchr (ptr, '%', ll-(ptr-buf))) != NULL)
158 memmove (ptr+1, ptr+2, ll-(ptr-buf+2));
164 /* Right flush part, unless we're at the top-level where it's not allowed */
167 assert (MAX_MENUITEM_LENGTH > ll + 1);
168 lr = gui_item_display_flush_right (gui_item, buf + ll + 1,
169 MAX_MENUITEM_LENGTH - ll - 1);
178 * hmenu_to_lisp_object() returns an opaque ptr given menu handle.
181 hmenu_to_lisp_object (HMENU hmenu)
183 return make_opaque_ptr (hmenu);
187 * Allocation tries a hash based on item's path and name first. This
188 * almost guarantees that the same item will override its old value in
189 * the hash table rather than abandon it.
192 allocate_menu_item_id (Lisp_Object path, Lisp_Object name, Lisp_Object suffix)
194 UINT id = MENU_ITEM_ID_BITS (HASH3 (internal_hash (path, 0),
195 internal_hash (name, 0),
196 internal_hash (suffix, 0)));
198 id = MENU_ITEM_ID_BITS (id + 1);
199 } while (GetMenuState (top_level_menu, id, MF_BYCOMMAND) != 0xFFFFFFFF);
200 return make_int (id);
204 create_empty_popup_menu (void)
206 return CreatePopupMenu ();
210 empty_menu (HMENU menu, int add_empty_p)
212 while (DeleteMenu (menu, 0, MF_BYPOSITION));
214 AppendMenu (menu, MF_STRING | MF_GRAYED, EMPTY_ITEM_ID, EMPTY_ITEM_NAME);
218 * The idea of checksumming is that we must hash minimal object
219 * which is necessarily changes when the item changes. For separator
220 * this is a constant, for grey strings and submenus these are hashes
221 * of names, since submenus are unpopulated until opened so always
222 * equal otherwise. For items, this is a full hash value of a callback,
223 * because a callback may me a form which can be changed only somewhere
227 checksum_menu_item (Lisp_Object item)
231 /* Separator or unselectable text - hash as a string + 13 */
232 if (separator_string_p (XSTRING_DATA (item)))
235 return internal_hash (item, 0) + 13;
237 else if (CONSP (item))
239 /* Submenu - hash by its string name + 0 */
240 return internal_hash (XCAR(item), 0);
242 else if (VECTORP (item))
244 /* An ordinary item - hash its name and callback form. */
245 return HASH2 (internal_hash (XVECTOR_DATA(item)[0], 0),
246 internal_hash (XVECTOR_DATA(item)[1], 0));
249 /* An error - will be caught later */
254 populate_menu_add_item (HMENU menu, Lisp_Object path,
255 Lisp_Object hash_tab, Lisp_Object item,
256 int flush_right, int bar_p)
258 MENUITEMINFO item_info;
260 item_info.cbSize = sizeof (item_info);
261 item_info.fMask = MIIM_TYPE | MIIM_STATE | MIIM_ID;
262 item_info.fState = 0;
268 /* Separator or unselectable text */
269 if (separator_string_p (XSTRING_DATA (item)))
270 item_info.fType = MFT_SEPARATOR;
273 item_info.fType = MFT_STRING;
274 item_info.fState = MFS_DISABLED;
275 item_info.dwTypeData = XSTRING_DATA (item);
278 else if (CONSP (item))
282 Lisp_Object gui_item = allocate_gui_item ();
283 struct Lisp_Gui_Item* pgui_item = XGUI_ITEM (gui_item);
288 menu_parse_submenu_keywords (item, gui_item);
290 if (!STRINGP (pgui_item->name))
291 signal_simple_error ("Menu name (first element) must be a string", item);
293 if (!gui_item_included_p (gui_item, Vmenubar_configuration))
296 if (!gui_item_active_p (gui_item))
297 item_info.fState = MFS_GRAYED;
298 /* Temptation is to put 'else' right here. Although, the
299 displayed item won't have an arrow indicating that it is a
300 popup. So we go ahead a little bit more and create a popup */
301 submenu = create_empty_popup_menu();
303 item_info.fMask |= MIIM_SUBMENU;
304 item_info.dwTypeData = displayable_menu_item (gui_item, bar_p);
305 item_info.hSubMenu = submenu;
307 if (!(item_info.fState & MFS_GRAYED))
309 /* Now add the full submenu path as a value to the hash table,
310 keyed by menu handle */
312 /* list1 cannot GC */
313 path = list1 (pgui_item->name);
318 arg[1] = list1 (pgui_item->name);
319 /* Fappend gcpro'es its arg */
320 path = Fappend (2, arg);
323 /* Fputhash GCPRO'es PATH */
324 Fputhash (hmenu_to_lisp_object (submenu), path, hash_tab);
326 UNGCPRO; /* gui_item */
328 else if (VECTORP (item))
330 /* An ordinary item */
331 Lisp_Object style, id;
332 Lisp_Object gui_item = gui_parse_item_keywords (item);
333 struct Lisp_Gui_Item* pgui_item = XGUI_ITEM (gui_item);
338 if (!gui_item_included_p (gui_item, Vmenubar_configuration))
341 if (!gui_item_active_p (gui_item))
342 item_info.fState = MFS_GRAYED;
344 style = (NILP (pgui_item->selected) || NILP (Feval (pgui_item->selected))
345 ? Qnil : pgui_item->style);
347 if (EQ (style, Qradio))
349 item_info.fType |= MFT_RADIOCHECK;
350 item_info.fState |= MFS_CHECKED;
352 else if (EQ (style, Qtoggle))
354 item_info.fState |= MFS_CHECKED;
357 id = allocate_menu_item_id (path, pgui_item->name,
359 Fputhash (id, pgui_item->callback, hash_tab);
361 item_info.wID = (UINT) XINT(id);
362 item_info.fType |= MFT_STRING;
363 item_info.dwTypeData = displayable_menu_item (gui_item, bar_p);
365 UNGCPRO; /* gui_item */
369 signal_simple_error ("Malformed menu item descriptor", item);
373 item_info.fType |= MFT_RIGHTJUSTIFY;
375 InsertMenuItem (menu, UINT_MAX, TRUE, &item_info);
379 * This function is called from populate_menu and checksum_menu.
380 * When called to populate, MENU is a menu handle, PATH is a
381 * list of strings representing menu path from root to this submenu,
382 * DESCRIPTOR is a menu descriptor, HASH_TAB is a hash table associated
383 * with root menu, BAR_P indicates whether this called for a menubar or
384 * a popup, and POPULATE_P is non-zero. Return value must be ignored.
385 * When called to checksum, DESCRIPTOR has the same meaning, POPULATE_P
386 * is zero, PATH must be Qnil, and the rest of parameters is ignored.
387 * Return value is the menu checksum.
390 populate_or_checksum_helper (HMENU menu, Lisp_Object path, Lisp_Object desc,
391 Lisp_Object hash_tab, int bar_p, int populate_p)
393 Lisp_Object item_desc;
394 int deep_p, flush_right;
396 unsigned long checksum;
397 Lisp_Object gui_item = allocate_gui_item ();
398 struct Lisp_Gui_Item* pgui_item = XGUI_ITEM (gui_item);
401 /* We are sometimes called with the menubar unchanged, and with changed
402 right flush. We have to update the menubar in this case,
403 so account for the compliance setting in the hash value */
404 checksum = REPLACE_ME_WITH_GLOBAL_VARIABLE_WHICH_CONTROLS_RIHGT_FLUSH;
406 /* Will initially contain only "(empty)" */
408 empty_menu (menu, 1);
410 /* PATH set to nil indicates top-level popup or menubar */
411 deep_p = !NILP (path);
413 /* Fetch keywords prepending the item list */
414 desc = menu_parse_submenu_keywords (desc, gui_item);
416 /* Check that menu name is specified when expected */
417 if (NILP (pgui_item->name) && deep_p)
418 signal_simple_error ("Menu must have a name", desc);
420 /* Apply filter if specified */
421 if (!NILP (pgui_item->filter))
422 desc = call1 (pgui_item->filter, desc);
424 /* Loop thru the desc's CDR and add items for each entry */
426 EXTERNAL_LIST_LOOP (item_desc, desc)
428 if (NILP (XCAR (item_desc)))
430 /* Do not flush right menubar items when MS style compliant */
431 if (bar_p && !REPLACE_ME_WITH_GLOBAL_VARIABLE_WHICH_CONTROLS_RIHGT_FLUSH)
434 checksum = HASH2 (checksum, LISP_HASH (Qnil));
437 populate_menu_add_item (menu, path, hash_tab,
438 XCAR (item_desc), flush_right, bar_p);
440 checksum = HASH2 (checksum,
441 checksum_menu_item (XCAR (item_desc)));
446 /* Remove the "(empty)" item, if there are other ones */
447 if (GetMenuItemCount (menu) > 1)
448 RemoveMenu (menu, EMPTY_ITEM_ID, MF_BYCOMMAND);
450 /* Add the header to the popup, if told so. The same as in X - an
451 insensitive item, and a separator (Seems to me, there were
452 two separators in X... In Windows this looks ugly, anyways. */
453 if (!bar_p && !deep_p && popup_menu_titles && !NILP(pgui_item->name))
455 CHECK_STRING (pgui_item->name);
456 InsertMenu (menu, 0, MF_BYPOSITION | MF_STRING | MF_DISABLED,
457 0, XSTRING_DATA(pgui_item->name));
458 InsertMenu (menu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
459 SetMenuDefaultItem (menu, 0, MF_BYPOSITION);
462 UNGCPRO; /* gui_item */
467 populate_menu (HMENU menu, Lisp_Object path, Lisp_Object desc,
468 Lisp_Object hash_tab, int bar_p)
470 populate_or_checksum_helper (menu, path, desc, hash_tab, bar_p, 1);
474 checksum_menu (Lisp_Object desc)
476 return populate_or_checksum_helper (NULL, Qnil, desc, Qunbound, 0, 0);
480 update_frame_menubar_maybe (struct frame* f)
482 HMENU menubar = GetMenu (FRAME_MSWINDOWS_HANDLE (f));
483 struct window *w = XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f));
484 Lisp_Object desc = (!NILP (w->menubar_visible_p)
485 ? symbol_value_in_buffer (Qcurrent_menubar, w->buffer)
488 top_level_menu = menubar;
490 if (NILP (desc) && menubar != NULL)
492 /* Menubar has gone */
493 FRAME_MSWINDOWS_MENU_HASH_TABLE(f) = Qnil;
494 SetMenu (FRAME_MSWINDOWS_HANDLE (f), NULL);
495 DestroyMenu (menubar);
496 DrawMenuBar (FRAME_MSWINDOWS_HANDLE (f));
500 if (!NILP (desc) && menubar == NULL)
502 /* Menubar has appeared */
503 menubar = CreateMenu ();
509 /* We did not have the bar and are not going to */
513 /* Now we bail out if the menubar has not changed */
514 if (FRAME_MSWINDOWS_MENU_CHECKSUM(f) == checksum_menu (desc))
518 /* Come with empty hash table */
519 if (NILP (FRAME_MSWINDOWS_MENU_HASH_TABLE(f)))
520 FRAME_MSWINDOWS_MENU_HASH_TABLE(f) =
521 make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
523 Fclrhash (FRAME_MSWINDOWS_MENU_HASH_TABLE(f));
525 Fputhash (hmenu_to_lisp_object (menubar), Qnil,
526 FRAME_MSWINDOWS_MENU_HASH_TABLE(f));
527 populate_menu (menubar, Qnil, desc,
528 FRAME_MSWINDOWS_MENU_HASH_TABLE(f), 1);
529 SetMenu (FRAME_MSWINDOWS_HANDLE (f), menubar);
530 DrawMenuBar (FRAME_MSWINDOWS_HANDLE (f));
532 FRAME_MSWINDOWS_MENU_CHECKSUM(f) = checksum_menu (desc);
536 prune_menubar (struct frame *f)
538 HMENU menubar = GetMenu (FRAME_MSWINDOWS_HANDLE (f));
539 Lisp_Object desc = current_frame_menubar (f);
543 /* #### If a filter function has set desc to Qnil, this abort()
544 triggers. To resolve, we must prevent filters explicitly from
545 mangling with the active menu. In apply_filter probably?
546 Is copy-tree on the whole menu too expensive? */
551 /* We do the trick by removing all items and re-populating top level */
552 empty_menu (menubar, 0);
554 assert (HASH_TABLEP (FRAME_MSWINDOWS_MENU_HASH_TABLE(f)));
555 Fclrhash (FRAME_MSWINDOWS_MENU_HASH_TABLE(f));
557 Fputhash (hmenu_to_lisp_object (menubar), Qnil,
558 FRAME_MSWINDOWS_MENU_HASH_TABLE(f));
559 populate_menu (menubar, Qnil, desc,
560 FRAME_MSWINDOWS_MENU_HASH_TABLE(f), 1);
564 * This is called when cleanup is possible. It is better not to
565 * clean things up at all than do it too early!
568 menu_cleanup (struct frame *f)
570 /* This function can GC */
571 current_menudesc = Qnil;
572 current_hash_table = Qnil;
577 /*------------------------------------------------------------------------*/
578 /* Message handlers */
579 /*------------------------------------------------------------------------*/
581 unsafe_handle_wm_initmenupopup_1 (HMENU menu, struct frame* f)
583 /* This function can call lisp, beat dogs and stick chewing gum to
586 Lisp_Object path, desc;
589 /* Find which guy is going to explode */
590 path = Fgethash (hmenu_to_lisp_object (menu), current_hash_table, Qunbound);
591 assert (!UNBOUNDP (path));
593 /* Allow to continue in a debugger after assert - not so fatal */
595 error ("internal menu error");
598 /* Now find a desc chunk for it. If none, then probably menu open
599 hook has played too much games around stuff */
600 desc = Fmenu_find_real_submenu (current_menudesc, path);
602 signal_simple_error ("This menu does not exist any more", path);
605 /* DESC may be generated by filter, so we have to gcpro it */
607 populate_menu (menu, path, desc, current_hash_table, 0);
613 unsafe_handle_wm_initmenu_1 (struct frame* f)
615 /* This function can call lisp */
617 /* NOTE: This is called for the bar only, WM_INITMENU
618 for popups is filtered out */
620 /* #### - this menubar update mechanism is expensively anti-social and
621 the activate-menubar-hook is now mostly obsolete. */
623 /* We simply ignore return value. In any case, we construct the bar
625 run_hook (Qactivate_menubar_hook);
627 update_frame_menubar_maybe (f);
629 current_menudesc = current_frame_menubar (f);
630 current_hash_table = FRAME_MSWINDOWS_MENU_HASH_TABLE(f);
631 assert (HASH_TABLEP (current_hash_table));
637 * Return value is Qt if we have dispatched the command,
638 * or Qnil if id has not been mapped to a callback.
639 * Window procedure may try other targets to route the
640 * command if we return nil
643 mswindows_handle_wm_command (struct frame* f, WORD id)
645 /* Try to map the command id through the proper hash table */
646 Lisp_Object data, fn, arg, frame;
649 if (NILP (current_hash_table))
652 data = Fgethash (make_int (id), current_hash_table, Qunbound);
660 /* Need to gcpro because the hash table may get destroyed by
661 menu_cleanup(), and will not gcpro the data any more */
665 /* Ok, this is our one. Enqueue it. */
666 get_gui_callback (data, &fn, &arg);
667 XSETFRAME (frame, f);
668 /* this used to call mswindows_enqueue_misc_user_event but that
669 breaks customize because the misc_event gets eval'ed in some
670 cicumstances. Don't change it back unless you can fix the
671 customize problem also.*/
672 enqueue_misc_user_event (frame, fn, arg);
673 mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
680 /*------------------------------------------------------------------------*/
681 /* Message handling proxies */
682 /*------------------------------------------------------------------------*/
684 static HMENU wm_initmenu_menu;
685 static struct frame* wm_initmenu_frame;
688 unsafe_handle_wm_initmenupopup (Lisp_Object u_n_u_s_e_d)
690 return unsafe_handle_wm_initmenupopup_1 (wm_initmenu_menu, wm_initmenu_frame);
694 unsafe_handle_wm_initmenu (Lisp_Object u_n_u_s_e_d)
696 return unsafe_handle_wm_initmenu_1 (wm_initmenu_frame);
700 mswindows_handle_wm_initmenupopup (HMENU hmenu, struct frame* frm)
702 /* We cannot pass hmenu as a lisp object. Use static var */
703 wm_initmenu_menu = hmenu;
704 wm_initmenu_frame = frm;
705 return mswindows_protect_modal_loop (unsafe_handle_wm_initmenupopup, Qnil);
709 mswindows_handle_wm_initmenu (HMENU hmenu, struct frame* f)
711 /* Handle only frame menubar, ignore if from popup or system menu */
712 if (GetMenu (FRAME_MSWINDOWS_HANDLE(f)) == hmenu)
714 wm_initmenu_frame = f;
715 return mswindows_protect_modal_loop (unsafe_handle_wm_initmenu, Qnil);
721 /*------------------------------------------------------------------------*/
723 /*------------------------------------------------------------------------*/
726 mswindows_update_frame_menubars (struct frame* f)
728 update_frame_menubar_maybe (f);
732 mswindows_free_frame_menubars (struct frame* f)
734 FRAME_MSWINDOWS_MENU_HASH_TABLE(f) = Qnil;
738 mswindows_popup_menu (Lisp_Object menu_desc, Lisp_Object event)
740 struct frame *f = selected_frame ();
741 struct Lisp_Event *eev = NULL;
748 CHECK_LIVE_EVENT (event);
749 eev = XEVENT (event);
750 if (eev->event_type != button_press_event
751 && eev->event_type != button_release_event)
752 wrong_type_argument (Qmouse_event_p, event);
754 else if (!NILP (Vthis_command_keys))
756 /* if an event wasn't passed, use the last event of the event sequence
757 currently being executed, if that event is a mouse event */
758 eev = XEVENT (Vthis_command_keys); /* last event first */
759 if (eev->event_type != button_press_event
760 && eev->event_type != button_release_event)
764 /* Default is to put the menu at the point (10, 10) in frame */
767 pt.x = eev->event.button.x;
768 pt.y = eev->event.button.y;
769 ClientToScreen (FRAME_MSWINDOWS_HANDLE (f), &pt);
774 if (SYMBOLP (menu_desc))
775 menu_desc = Fsymbol_value (menu_desc);
776 CHECK_CONS (menu_desc);
777 CHECK_STRING (XCAR (menu_desc));
779 current_menudesc = menu_desc;
781 make_lisp_hash_table (10, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
782 menu = create_empty_popup_menu();
783 Fputhash (hmenu_to_lisp_object (menu), Qnil, current_hash_table);
784 top_level_menu = menu;
786 /* see comments in menubar-x.c */
788 zmacs_region_stays = 1;
790 ok = TrackPopupMenu (menu,
791 TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
793 FRAME_MSWINDOWS_HANDLE (f), NULL);
797 /* Signal a signal if caught by Track...() modal loop */
798 mswindows_unmodalize_signal_maybe ();
800 /* This is probably the only real reason for failure */
803 signal_simple_error ("Cannot track popup menu while in menu",
809 /*------------------------------------------------------------------------*/
811 /*------------------------------------------------------------------------*/
813 syms_of_menubar_mswindows (void)
818 console_type_create_menubar_mswindows (void)
820 CONSOLE_HAS_METHOD (mswindows, update_frame_menubars);
821 CONSOLE_HAS_METHOD (mswindows, free_frame_menubars);
822 CONSOLE_HAS_METHOD (mswindows, popup_menu);
826 vars_of_menubar_mswindows (void)
828 current_menudesc = Qnil;
829 current_hash_table = Qnil;
831 staticpro (¤t_menudesc);
832 staticpro (¤t_hash_table);