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>.
5 Copyright (C) 2000 Ben Wing.
7 This file is part of XEmacs.
9 XEmacs is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with XEmacs; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Synched up with: Not in FSF. */
27 Initially written by kkm 12/24/97,
28 peeking into and copying stuff from menubar-x.c
31 /* Algorithm for handling menus is as follows. When window's menubar
32 * is created, current-menubar is not traversed in depth. Rather, only
33 * top level items, both items and pulldowns, are added to the
34 * menubar. Each pulldown is initially empty. When a pulldown is
35 * selected and about to open, corresponding element of
36 * current-menubar is found, and the newly open pulldown is
37 * populated. This is made again in the same non-recursive manner.
39 * This algorithm uses hash tables to find out element of the menu
40 * descriptor list given menu handle. The key is an opaque ptr data
41 * type, keeping menu handle, and the value is a list of strings
42 * representing the path from the root of the menu to the item
43 * descriptor. Each frame has an associated hash table.
45 * Leaf items are assigned a unique id based on item's hash. When an
46 * item is selected, Windows sends back the id. Unfortunately, only
47 * low 16 bit of the ID are sent, and there's no way to get the 32-bit
48 * value. Yes, Win32 is just a different set of bugs than X! Aside
49 * from this blame, another hashing mechanism is required to map menu
50 * ids to commands (which are actually Lisp_Object's). This mapping is
51 * performed in the same hash table, as the lifetime of both maps is
52 * exactly the same. This is unambigous, as menu handles are
53 * represented by lisp opaques, while command ids are by lisp
54 * integers. The additional advantage for this is that command forms
55 * are automatically GC-protected, which is important because these
56 * may be transient forms generated by :filter functions.
58 * The hash table is not allowed to grow too much; it is pruned
59 * whenever this is safe to do. This is done by re-creating the menu
60 * bar, and clearing and refilling the hash table from scratch.
62 * Popup menus are handled identically to pulldowns. A static hash
63 * table is used for popup menus, and lookup is made not in
64 * current-menubar but in a lisp form supplied to the `popup'
67 * Another Windows weirdness is that there's no way to tell that a
68 * popup has been dismissed without making selection. We need to know
69 * that to cleanup the popup menu hash table, but this is not honestly
70 * doable using *documented* sequence of messages. Sticking to
71 * particular knowledge is bad because this may break in Windows NT
72 * 5.0, or Windows 98, or other future version. Instead, I allow the
73 * hash tables to hang around, and not clear them, unless WM_COMMAND is
74 * received. This is worth 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_RIGHT_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 /* Translate (in place) %_ to &, %% to %.
120 Return new length, and (through accel) the accelerator character.
121 (If there is no accelerator, it will be added on the first character.)
122 len = number of bytes (not including zero terminator).
123 maxlen = size of buffer.
124 We assume and maintain zero-termination. To be absolutely sure
125 of not hitting an error, maxlen should be >= 2*len + 3. */
128 mswindows_translate_menu_or_dialog_item (Bufbyte *item, Bytecount len,
129 Bytecount maxlen, Emchar *accel,
130 Lisp_Object error_name)
136 /* Escape '&' as '&&' */
139 while ((ptr = (Bufbyte *) memchr (ptr, '&', len - (ptr - item))) != NULL)
141 if (len + 2 > maxlen)
142 signal_simple_error ("Menu item produces too long displayable string",
144 memmove (ptr + 1, ptr, (len - (ptr - item)) + 1);
149 /* Replace XEmacs accelerator '%_' with Windows accelerator '&'
150 and `%%' with `%'. */
152 while ((ptr = memchr (ptr, '%', len - (ptr - item))) != NULL)
154 if (*(ptr + 1) == '_')
158 /* #### urk ! We need a reference translation table for
159 case changes that aren't buffer-specific. */
160 *accel = DOWNCASE (current_buffer, charptr_emchar (ptr + 2));
161 memmove (ptr + 1, ptr + 2, len - (ptr - item + 2) + 1);
164 else if (*(ptr + 1) == '%')
166 memmove (ptr + 1, ptr + 2, len - (ptr - item + 2) + 1);
174 if (len + 2 > maxlen)
175 signal_simple_error ("Menu item produces too long displayable string",
178 memmove (ptr + 1, ptr, len + 1);
179 /* #### urk ! We need a reference translation table for
180 case changes that aren't buffer-specific. */
181 *accel = DOWNCASE (current_buffer, charptr_emchar (ptr + 1));
191 * This returns Windows-style menu item string:
192 * "Left Flush\tRight Flush"
195 /* #### This is junk. Need correct handling of sizes. Use a Bufbyte_dynarr,
196 not a static buffer. */
198 displayable_menu_item (Lisp_Object gui_item, int bar_p, Emchar *accel)
202 /* We construct the name in a static buffer. That's fine, because
203 menu items longer than 128 chars are probably programming errors,
204 and better be caught than displayed! */
206 static char buf[MAX_MENUITEM_LENGTH+2];
208 /* Left flush part of the string */
209 ll = gui_item_display_flush_left (gui_item, buf, MAX_MENUITEM_LENGTH);
211 ll = mswindows_translate_menu_or_dialog_item ((Bufbyte *) buf, ll,
212 MAX_MENUITEM_LENGTH, accel,
213 XGUI_ITEM (gui_item)->name);
215 /* Right flush part, unless we're at the top-level where it's not allowed */
220 assert (MAX_MENUITEM_LENGTH > ll + 1);
221 lr = gui_item_display_flush_right (gui_item, buf + ll + 1,
222 MAX_MENUITEM_LENGTH - ll - 1);
231 * hmenu_to_lisp_object() returns an opaque ptr given menu handle.
234 hmenu_to_lisp_object (HMENU hmenu)
236 return make_opaque_ptr (hmenu);
240 * Allocation tries a hash based on item's path and name first. This
241 * almost guarantees that the same item will override its old value in
242 * the hash table rather than abandon it.
245 allocate_menu_item_id (Lisp_Object path, Lisp_Object name, Lisp_Object suffix)
247 UINT id = MENU_ITEM_ID_BITS (HASH3 (internal_hash (path, 0),
248 internal_hash (name, 0),
249 internal_hash (suffix, 0)));
251 id = MENU_ITEM_ID_BITS (id + 1);
252 } while (GetMenuState (top_level_menu, id, MF_BYCOMMAND) != 0xFFFFFFFF);
253 return make_int (id);
257 create_empty_popup_menu (void)
259 return CreatePopupMenu ();
263 empty_menu (HMENU menu, int add_empty_p)
265 while (DeleteMenu (menu, 0, MF_BYPOSITION));
267 AppendMenu (menu, MF_STRING | MF_GRAYED, EMPTY_ITEM_ID, EMPTY_ITEM_NAME);
271 * The idea of checksumming is that we must hash minimal object
272 * which is necessarily changes when the item changes. For separator
273 * this is a constant, for grey strings and submenus these are hashes
274 * of names, since submenus are unpopulated until opened so always
275 * equal otherwise. For items, this is a full hash value of a callback,
276 * because a callback may me a form which can be changed only somewhere
280 checksum_menu_item (Lisp_Object item)
284 /* Separator or unselectable text - hash as a string + 13 */
285 if (separator_string_p (XSTRING_DATA (item)))
288 return internal_hash (item, 0) + 13;
290 else if (CONSP (item))
292 /* Submenu - hash by its string name + 0 */
293 return internal_hash (XCAR(item), 0);
295 else if (VECTORP (item))
297 /* An ordinary item - hash its name and callback form. */
298 return HASH2 (internal_hash (XVECTOR_DATA(item)[0], 0),
299 internal_hash (XVECTOR_DATA(item)[1], 0));
302 /* An error - will be caught later */
307 populate_menu_add_item (HMENU menu, Lisp_Object path,
308 Lisp_Object hash_tab, Lisp_Object item,
309 Lisp_Object *accel_list,
310 int flush_right, int bar_p)
312 MENUITEMINFO item_info;
314 item_info.cbSize = sizeof (item_info);
315 item_info.fMask = MIIM_TYPE | MIIM_STATE | MIIM_ID;
316 item_info.fState = 0;
322 /* Separator or unselectable text */
323 if (separator_string_p (XSTRING_DATA (item)))
324 item_info.fType = MFT_SEPARATOR;
327 item_info.fType = MFT_STRING;
328 item_info.fState = MFS_DISABLED;
329 item_info.dwTypeData = XSTRING_DATA (item);
332 else if (CONSP (item))
336 Lisp_Object gui_item = allocate_gui_item ();
337 Lisp_Gui_Item *pgui_item = XGUI_ITEM (gui_item);
338 struct gcpro gcpro1, gcpro2, gcpro3;
341 GCPRO3 (gui_item, path, *accel_list);
343 menu_parse_submenu_keywords (item, gui_item);
345 if (!STRINGP (pgui_item->name))
346 signal_simple_error ("Menu name (first element) must be a string",
349 if (!gui_item_included_p (gui_item, Vmenubar_configuration))
355 if (!gui_item_active_p (gui_item))
356 item_info.fState = MFS_GRAYED;
357 /* Temptation is to put 'else' right here. Although, the
358 displayed item won't have an arrow indicating that it is a
359 popup. So we go ahead a little bit more and create a popup */
360 submenu = create_empty_popup_menu ();
362 item_info.fMask |= MIIM_SUBMENU;
363 item_info.dwTypeData = displayable_menu_item (gui_item, bar_p, &accel);
364 item_info.hSubMenu = submenu;
367 *accel_list = Fcons (make_char (accel), *accel_list);
369 if (!(item_info.fState & MFS_GRAYED))
371 /* Now add the full submenu path as a value to the hash table,
372 keyed by menu handle */
374 path = list1 (pgui_item->name);
379 arg[1] = list1 (pgui_item->name);
380 path = Fappend (2, arg);
383 Fputhash (hmenu_to_lisp_object (submenu), path, hash_tab);
387 else if (VECTORP (item))
389 /* An ordinary item */
390 Lisp_Object style, id;
391 Lisp_Object gui_item = gui_parse_item_keywords (item);
392 Lisp_Gui_Item *pgui_item = XGUI_ITEM (gui_item);
393 struct gcpro gcpro1, gcpro2;
396 GCPRO2 (gui_item, *accel_list);
398 if (!gui_item_included_p (gui_item, Vmenubar_configuration))
404 if (!STRINGP (pgui_item->name))
405 pgui_item->name = Feval (pgui_item->name);
407 if (!gui_item_active_p (gui_item))
408 item_info.fState = MFS_GRAYED;
410 style = (NILP (pgui_item->selected) || NILP (Feval (pgui_item->selected))
411 ? Qnil : pgui_item->style);
413 if (EQ (style, Qradio))
415 item_info.fType |= MFT_RADIOCHECK;
416 item_info.fState |= MFS_CHECKED;
418 else if (EQ (style, Qtoggle))
420 item_info.fState |= MFS_CHECKED;
423 id = allocate_menu_item_id (path, pgui_item->name,
425 Fputhash (id, pgui_item->callback, hash_tab);
427 item_info.wID = (UINT) XINT (id);
428 item_info.fType |= MFT_STRING;
429 item_info.dwTypeData = displayable_menu_item (gui_item, bar_p, &accel);
432 *accel_list = Fcons (make_char (accel), *accel_list);
438 signal_simple_error ("Malformed menu item descriptor", item);
442 item_info.fType |= MFT_RIGHTJUSTIFY;
444 InsertMenuItem (menu, UINT_MAX, TRUE, &item_info);
450 * This function is called from populate_menu and checksum_menu.
451 * When called to populate, MENU is a menu handle, PATH is a
452 * list of strings representing menu path from root to this submenu,
453 * DESCRIPTOR is a menu descriptor, HASH_TAB is a hash table associated
454 * with root menu, BAR_P indicates whether this called for a menubar or
455 * a popup, and POPULATE_P is non-zero. Return value must be ignored.
456 * When called to checksum, DESCRIPTOR has the same meaning, POPULATE_P
457 * is zero, PATH must be Qnil, and the rest of parameters is ignored.
458 * Return value is the menu checksum.
461 populate_or_checksum_helper (HMENU menu, Lisp_Object path, Lisp_Object desc,
462 Lisp_Object hash_tab, int bar_p, int populate_p)
464 Lisp_Object item_desc;
465 int deep_p, flush_right;
466 struct gcpro gcpro1, gcpro2, gcpro3;
467 unsigned long checksum;
468 Lisp_Object gui_item = allocate_gui_item ();
469 Lisp_Object accel_list = Qnil;
470 Lisp_Gui_Item *pgui_item = XGUI_ITEM (gui_item);
472 GCPRO3 (gui_item, accel_list, desc);
474 /* We are sometimes called with the menubar unchanged, and with changed
475 right flush. We have to update the menubar in this case,
476 so account for the compliance setting in the hash value */
477 checksum = REPLACE_ME_WITH_GLOBAL_VARIABLE_WHICH_CONTROLS_RIGHT_FLUSH;
479 /* Will initially contain only "(empty)" */
481 empty_menu (menu, 1);
483 /* PATH set to nil indicates top-level popup or menubar */
484 deep_p = !NILP (path);
486 /* Fetch keywords prepending the item list */
487 desc = menu_parse_submenu_keywords (desc, gui_item);
489 /* Check that menu name is specified when expected */
490 if (NILP (pgui_item->name) && deep_p)
491 signal_simple_error ("Menu must have a name", desc);
493 /* Apply filter if specified */
494 if (!NILP (pgui_item->filter))
495 desc = call1 (pgui_item->filter, desc);
497 /* Loop thru the desc's CDR and add items for each entry */
499 EXTERNAL_LIST_LOOP (item_desc, desc)
501 if (NILP (XCAR (item_desc)))
503 /* Do not flush right menubar items when MS style compliant */
504 if (bar_p && !REPLACE_ME_WITH_GLOBAL_VARIABLE_WHICH_CONTROLS_RIGHT_FLUSH)
507 checksum = HASH2 (checksum, LISP_HASH (Qnil));
510 populate_menu_add_item (menu, path, hash_tab,
511 XCAR (item_desc), &accel_list,
514 checksum = HASH2 (checksum,
515 checksum_menu_item (XCAR (item_desc)));
520 /* Remove the "(empty)" item, if there are other ones */
521 if (GetMenuItemCount (menu) > 1)
522 RemoveMenu (menu, EMPTY_ITEM_ID, MF_BYCOMMAND);
524 /* Add the header to the popup, if told so. The same as in X - an
525 insensitive item, and a separator (Seems to me, there were
526 two separators in X... In Windows this looks ugly, anyways.) */
527 if (!bar_p && !deep_p && popup_menu_titles && !NILP (pgui_item->name))
529 CHECK_STRING (pgui_item->name);
530 InsertMenu (menu, 0, MF_BYPOSITION | MF_STRING | MF_DISABLED,
531 0, XSTRING_DATA(pgui_item->name));
532 InsertMenu (menu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
533 SetMenuDefaultItem (menu, 0, MF_BYPOSITION);
538 Fputhash (Qt, accel_list, hash_tab);
545 populate_menu (HMENU menu, Lisp_Object path, Lisp_Object desc,
546 Lisp_Object hash_tab, int bar_p)
548 populate_or_checksum_helper (menu, path, desc, hash_tab, bar_p, 1);
552 checksum_menu (Lisp_Object desc)
554 return populate_or_checksum_helper (NULL, Qnil, desc, Qunbound, 0, 0);
558 update_frame_menubar_maybe (struct frame *f)
560 HMENU menubar = GetMenu (FRAME_MSWINDOWS_HANDLE (f));
561 struct window *w = XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f));
562 Lisp_Object desc = (!NILP (w->menubar_visible_p)
563 ? symbol_value_in_buffer (Qcurrent_menubar, w->buffer)
567 GCPRO1 (desc); /* it's safest to do this, just in case some filter
568 or something changes the value of current-menubar */
570 top_level_menu = menubar;
572 if (NILP (desc) && menubar != NULL)
574 /* Menubar has gone */
575 FRAME_MSWINDOWS_MENU_HASH_TABLE (f) = Qnil;
576 SetMenu (FRAME_MSWINDOWS_HANDLE (f), NULL);
577 DestroyMenu (menubar);
578 DrawMenuBar (FRAME_MSWINDOWS_HANDLE (f));
583 if (!NILP (desc) && menubar == NULL)
585 /* Menubar has appeared */
586 menubar = CreateMenu ();
592 /* We did not have the bar and are not going to */
597 /* Now we bail out if the menubar has not changed */
598 if (FRAME_MSWINDOWS_MENU_CHECKSUM (f) == checksum_menu (desc))
605 /* Come with empty hash table */
606 if (NILP (FRAME_MSWINDOWS_MENU_HASH_TABLE (f)))
607 FRAME_MSWINDOWS_MENU_HASH_TABLE (f) =
608 make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
610 Fclrhash (FRAME_MSWINDOWS_MENU_HASH_TABLE (f));
612 Fputhash (hmenu_to_lisp_object (menubar), Qnil,
613 FRAME_MSWINDOWS_MENU_HASH_TABLE (f));
614 populate_menu (menubar, Qnil, desc,
615 FRAME_MSWINDOWS_MENU_HASH_TABLE (f), 1);
616 SetMenu (FRAME_MSWINDOWS_HANDLE (f), menubar);
617 DrawMenuBar (FRAME_MSWINDOWS_HANDLE (f));
619 FRAME_MSWINDOWS_MENU_CHECKSUM (f) = checksum_menu (desc);
625 prune_menubar (struct frame *f)
627 HMENU menubar = GetMenu (FRAME_MSWINDOWS_HANDLE (f));
628 Lisp_Object desc = current_frame_menubar (f);
634 /* #### If a filter function has set desc to Qnil, this abort()
635 triggers. To resolve, we must prevent filters explicitly from
636 mangling with the active menu. In apply_filter probably?
637 Is copy-tree on the whole menu too expensive? */
642 GCPRO1 (desc); /* just to be safe -- see above */
643 /* We do the trick by removing all items and re-populating top level */
644 empty_menu (menubar, 0);
646 assert (HASH_TABLEP (FRAME_MSWINDOWS_MENU_HASH_TABLE (f)));
647 Fclrhash (FRAME_MSWINDOWS_MENU_HASH_TABLE (f));
649 Fputhash (hmenu_to_lisp_object (menubar), Qnil,
650 FRAME_MSWINDOWS_MENU_HASH_TABLE (f));
651 populate_menu (menubar, Qnil, desc,
652 FRAME_MSWINDOWS_MENU_HASH_TABLE (f), 1);
657 * This is called when cleanup is possible. It is better not to
658 * clean things up at all than do it too early!
661 menu_cleanup (struct frame *f)
663 /* This function can GC */
664 current_menudesc = Qnil;
665 current_hash_table = Qnil;
670 mswindows_char_is_accelerator (struct frame *f, Emchar ch)
672 Lisp_Object hash = FRAME_MSWINDOWS_MENU_HASH_TABLE (f);
674 assert (HASH_TABLEP (hash));
675 /* !!#### not Mule-ized */
676 return !NILP (memq_no_quit (make_char (tolower (ch)),
677 Fgethash (Qt, hash, Qnil)));
681 /*------------------------------------------------------------------------*/
682 /* Message handlers */
683 /*------------------------------------------------------------------------*/
685 unsafe_handle_wm_initmenupopup_1 (HMENU menu, struct frame *f)
687 /* This function can call lisp, beat dogs and stick chewing gum to
690 Lisp_Object path, desc;
693 /* Find which guy is going to explode */
694 path = Fgethash (hmenu_to_lisp_object (menu), current_hash_table, Qunbound);
695 assert (!UNBOUNDP (path));
697 /* Allow to continue in a debugger after assert - not so fatal */
699 error ("internal menu error");
702 /* Now find a desc chunk for it. If none, then probably menu open
703 hook has played too much games around stuff */
704 desc = Fmenu_find_real_submenu (current_menudesc, path);
706 signal_simple_error ("This menu does not exist any more", path);
709 /* DESC may be generated by filter, so we have to gcpro it */
711 populate_menu (menu, path, desc, current_hash_table, 0);
717 unsafe_handle_wm_initmenu_1 (struct frame *f)
719 /* This function can call lisp */
721 /* NOTE: This is called for the bar only, WM_INITMENU
722 for popups is filtered out */
724 /* #### - this menubar update mechanism is expensively anti-social and
725 the activate-menubar-hook is now mostly obsolete. */
727 /* We simply ignore return value. In any case, we construct the bar
729 run_hook (Qactivate_menubar_hook);
731 update_frame_menubar_maybe (f);
733 current_menudesc = current_frame_menubar (f);
734 current_hash_table = FRAME_MSWINDOWS_MENU_HASH_TABLE (f);
735 assert (HASH_TABLEP (current_hash_table));
741 * Return value is Qt if we have dispatched the command,
742 * or Qnil if id has not been mapped to a callback.
743 * Window procedure may try other targets to route the
744 * command if we return nil
747 mswindows_handle_wm_command (struct frame *f, WORD id)
749 /* Try to map the command id through the proper hash table */
750 Lisp_Object data, fn, arg, frame;
753 if (NILP (current_hash_table))
756 data = Fgethash (make_int (id), current_hash_table, Qunbound);
764 /* Need to gcpro because the hash table may get destroyed by
765 menu_cleanup(), and will not gcpro the data any more */
769 /* Ok, this is our one. Enqueue it. */
770 get_gui_callback (data, &fn, &arg);
771 XSETFRAME (frame, f);
772 /* this used to call mswindows_enqueue_misc_user_event but that
773 breaks customize because the misc_event gets eval'ed in some
774 cicumstances. Don't change it back unless you can fix the
775 customize problem also.*/
776 enqueue_misc_user_event (frame, fn, arg);
777 mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE);
784 /*------------------------------------------------------------------------*/
785 /* Message handling proxies */
786 /*------------------------------------------------------------------------*/
788 static HMENU wm_initmenu_menu;
789 static struct frame *wm_initmenu_frame;
792 unsafe_handle_wm_initmenupopup (Lisp_Object u_n_u_s_e_d)
794 return unsafe_handle_wm_initmenupopup_1 (wm_initmenu_menu, wm_initmenu_frame);
798 unsafe_handle_wm_initmenu (Lisp_Object u_n_u_s_e_d)
800 return unsafe_handle_wm_initmenu_1 (wm_initmenu_frame);
804 mswindows_handle_wm_initmenupopup (HMENU hmenu, struct frame *frm)
806 /* We cannot pass hmenu as a lisp object. Use static var */
807 wm_initmenu_menu = hmenu;
808 wm_initmenu_frame = frm;
809 return mswindows_protect_modal_loop (unsafe_handle_wm_initmenupopup, Qnil);
813 mswindows_handle_wm_initmenu (HMENU hmenu, struct frame *f)
815 /* Handle only frame menubar, ignore if from popup or system menu */
816 if (GetMenu (FRAME_MSWINDOWS_HANDLE (f)) == hmenu)
818 wm_initmenu_frame = f;
819 return mswindows_protect_modal_loop (unsafe_handle_wm_initmenu, Qnil);
825 /*------------------------------------------------------------------------*/
827 /*------------------------------------------------------------------------*/
830 mswindows_update_frame_menubars (struct frame *f)
832 update_frame_menubar_maybe (f);
836 mswindows_free_frame_menubars (struct frame *f)
838 FRAME_MSWINDOWS_MENU_HASH_TABLE (f) = Qnil;
842 mswindows_popup_menu (Lisp_Object menu_desc, Lisp_Object event)
844 struct frame *f = selected_frame ();
845 Lisp_Event *eev = NULL;
851 GCPRO1 (menu_desc); /* to be safe -- see above */
855 CHECK_LIVE_EVENT (event);
856 eev = XEVENT (event);
857 if (eev->event_type != button_press_event
858 && eev->event_type != button_release_event)
859 wrong_type_argument (Qmouse_event_p, event);
861 else if (!NILP (Vthis_command_keys))
863 /* if an event wasn't passed, use the last event of the event sequence
864 currently being executed, if that event is a mouse event */
865 eev = XEVENT (Vthis_command_keys); /* last event first */
866 if (eev->event_type != button_press_event
867 && eev->event_type != button_release_event)
871 /* Default is to put the menu at the point (10, 10) in frame */
874 pt.x = eev->event.button.x;
875 pt.y = eev->event.button.y;
876 ClientToScreen (FRAME_MSWINDOWS_HANDLE (f), &pt);
881 if (SYMBOLP (menu_desc))
882 menu_desc = Fsymbol_value (menu_desc);
883 CHECK_CONS (menu_desc);
884 CHECK_STRING (XCAR (menu_desc));
886 current_menudesc = menu_desc;
888 make_lisp_hash_table (10, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
889 menu = create_empty_popup_menu ();
890 Fputhash (hmenu_to_lisp_object (menu), Qnil, current_hash_table);
891 top_level_menu = menu;
893 /* see comments in menubar-x.c */
895 zmacs_region_stays = 1;
897 ok = TrackPopupMenu (menu,
898 TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
900 FRAME_MSWINDOWS_HANDLE (f), NULL);
904 /* Signal a signal if caught by Track...() modal loop */
905 mswindows_unmodalize_signal_maybe ();
907 /* This is probably the only real reason for failure */
911 signal_simple_error ("Cannot track popup menu while in menu",
918 /*------------------------------------------------------------------------*/
920 /*------------------------------------------------------------------------*/
922 syms_of_menubar_mswindows (void)
927 console_type_create_menubar_mswindows (void)
929 CONSOLE_HAS_METHOD (mswindows, update_frame_menubars);
930 CONSOLE_HAS_METHOD (mswindows, free_frame_menubars);
931 CONSOLE_HAS_METHOD (mswindows, popup_menu);
935 vars_of_menubar_mswindows (void)
937 current_menudesc = Qnil;
938 current_hash_table = Qnil;
940 staticpro (¤t_menudesc);
941 staticpro (¤t_hash_table);