1 /* Menu support for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1986, 1988, 1993-1994, 1996, 1998-1999, 2001-2014 Free
3 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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
30 #include "termhooks.h"
32 #include "blockinput.h"
33 #include "character.h"
39 /* This may include sys/types.h, and that somehow loses
40 if this is not done before the other system files. */
43 /* Cygwin does not support the multibyte string functions declared in
44 * mbstring.h below --- but that's okay: because Cygwin is
45 * UNICODE-only, we don't need to use these functions anyway. */
49 #endif /* !NTGUI_UNICODE */
51 /* Load sys/types.h if not already loaded.
52 In some systems loading it twice is suicidal. */
54 #include <sys/types.h>
57 #include "dispextern.h"
59 #include "w32common.h" /* for osinfo_cache */
61 #undef HAVE_DIALOGS /* TODO: Implement native dialogs. */
68 HMENU current_popup_menu
;
70 void syms_of_w32menu (void);
71 void globals_of_w32menu (void);
73 typedef BOOL (WINAPI
* GetMenuItemInfoA_Proc
) (
77 IN OUT LPMENUITEMINFOA
);
78 typedef BOOL (WINAPI
* SetMenuItemInfoA_Proc
) (
83 typedef int (WINAPI
* MessageBoxW_Proc
) (
86 IN
const WCHAR
*caption
,
90 #define get_menu_item_info GetMenuItemInfoA
91 #define set_menu_item_info SetMenuItemInfoA
92 #define unicode_append_menu AppendMenuW
93 #define unicode_message_box MessageBoxW
94 #else /* !NTGUI_UNICODE */
95 GetMenuItemInfoA_Proc get_menu_item_info
= NULL
;
96 SetMenuItemInfoA_Proc set_menu_item_info
= NULL
;
97 AppendMenuW_Proc unicode_append_menu
= NULL
;
98 MessageBoxW_Proc unicode_message_box
= NULL
;
99 #endif /* NTGUI_UNICODE */
101 Lisp_Object Qdebug_on_next_call
, Qunsupported__w32_dialog
;
103 void set_frame_menubar (struct frame
*, bool, bool);
106 static Lisp_Object
w32_dialog_show (struct frame
*, Lisp_Object
, Lisp_Object
, char **);
108 static int is_simple_dialog (Lisp_Object
);
109 static Lisp_Object
simple_dialog_show (struct frame
*, Lisp_Object
, Lisp_Object
);
112 static void utf8to16 (unsigned char *, int, WCHAR
*);
113 static int fill_in_menu (HMENU
, widget_value
*);
115 void w32_free_menu_strings (HWND
);
118 w32_popup_dialog (struct frame
*f
, Lisp_Object header
, Lisp_Object contents
)
121 check_window_system (f
);
125 /* Handle simple Yes/No choices as MessageBox popups. */
126 if (is_simple_dialog (contents
))
127 return simple_dialog_show (f
, contents
, header
);
129 return Qunsupported__w32_dialog
;
130 #else /* HAVE_DIALOGS */
134 Lisp_Object selection
;
136 /* Decode the dialog items from what was specified. */
137 title
= Fcar (contents
);
138 CHECK_STRING (title
);
140 list_of_panes (Fcons (contents
, Qnil
));
142 /* Display them in a dialog box. */
144 selection
= w32_dialog_show (f
, title
, header
, &error_name
);
147 discard_menu_items ();
148 FRAME_DISPLAY_INFO (f
)->grabbed
= 0;
150 if (error_name
) error (error_name
);
153 #endif /* HAVE_DIALOGS */
156 /* Activate the menu bar of frame F.
157 This is called from keyboard.c when it gets the
158 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
160 To activate the menu bar, we signal to the input thread that it can
161 return from the WM_INITMENU message, allowing the normal Windows
162 processing of the menus.
164 But first we recompute the menu bar contents (the whole tree).
166 This way we can safely execute Lisp code. */
169 x_activate_menubar (struct frame
*f
)
171 set_frame_menubar (f
, 0, 1);
173 /* Lock out further menubar changes while active. */
174 f
->output_data
.w32
->menubar_active
= 1;
176 /* Signal input thread to return from WM_INITMENU. */
177 complete_deferred_msg (FRAME_W32_WINDOW (f
), WM_INITMENU
, 0);
180 /* This callback is called from the menu bar pulldown menu
181 when the user makes a selection.
182 Figure out what the user chose
183 and put the appropriate events into the keyboard buffer. */
186 menubar_selection_callback (struct frame
*f
, void * client_data
)
188 Lisp_Object prefix
, entry
;
190 Lisp_Object
*subprefix_stack
;
191 int submenu_depth
= 0;
197 subprefix_stack
= (Lisp_Object
*) alloca (f
->menu_bar_items_used
* word_size
);
198 vector
= f
->menu_bar_vector
;
201 while (i
< f
->menu_bar_items_used
)
203 if (EQ (AREF (vector
, i
), Qnil
))
205 subprefix_stack
[submenu_depth
++] = prefix
;
209 else if (EQ (AREF (vector
, i
), Qlambda
))
211 prefix
= subprefix_stack
[--submenu_depth
];
214 else if (EQ (AREF (vector
, i
), Qt
))
216 prefix
= AREF (vector
, i
+ MENU_ITEMS_PANE_PREFIX
);
217 i
+= MENU_ITEMS_PANE_LENGTH
;
221 entry
= AREF (vector
, i
+ MENU_ITEMS_ITEM_VALUE
);
222 /* The EMACS_INT cast avoids a warning. There's no problem
223 as long as pointers have enough bits to hold small integers. */
224 if ((int) (EMACS_INT
) client_data
== i
)
227 struct input_event buf
;
231 XSETFRAME (frame
, f
);
232 buf
.kind
= MENU_BAR_EVENT
;
233 buf
.frame_or_window
= frame
;
235 kbd_buffer_store_event (&buf
);
237 for (j
= 0; j
< submenu_depth
; j
++)
238 if (!NILP (subprefix_stack
[j
]))
240 buf
.kind
= MENU_BAR_EVENT
;
241 buf
.frame_or_window
= frame
;
242 buf
.arg
= subprefix_stack
[j
];
243 kbd_buffer_store_event (&buf
);
248 buf
.kind
= MENU_BAR_EVENT
;
249 buf
.frame_or_window
= frame
;
251 kbd_buffer_store_event (&buf
);
254 buf
.kind
= MENU_BAR_EVENT
;
255 buf
.frame_or_window
= frame
;
257 /* Free memory used by owner-drawn and help-echo strings. */
258 w32_free_menu_strings (FRAME_W32_WINDOW (f
));
259 kbd_buffer_store_event (&buf
);
261 f
->output_data
.w32
->menubar_active
= 0;
264 i
+= MENU_ITEMS_ITEM_LENGTH
;
267 /* Free memory used by owner-drawn and help-echo strings. */
268 w32_free_menu_strings (FRAME_W32_WINDOW (f
));
269 f
->output_data
.w32
->menubar_active
= 0;
273 /* Set the contents of the menubar widgets of frame F.
274 The argument FIRST_TIME is currently ignored;
275 it is set the first time this is called, from initialize_frame_menubar. */
278 set_frame_menubar (struct frame
*f
, bool first_time
, bool deep_p
)
280 HMENU menubar_widget
= f
->output_data
.w32
->menubar_widget
;
282 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
284 int *submenu_start
, *submenu_end
;
285 int *submenu_top_level_items
, *submenu_n_panes
;
287 /* We must not change the menubar when actually in use. */
288 if (f
->output_data
.w32
->menubar_active
)
291 XSETFRAME (Vmenu_updating_frame
, f
);
293 if (! menubar_widget
)
298 /* Make a widget-value tree representing the entire menu trees. */
300 struct buffer
*prev
= current_buffer
;
302 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
303 int previous_menu_items_used
= f
->menu_bar_items_used
;
304 Lisp_Object
*previous_items
305 = (Lisp_Object
*) alloca (previous_menu_items_used
308 /* If we are making a new widget, its contents are empty,
309 do always reinitialize them. */
310 if (! menubar_widget
)
311 previous_menu_items_used
= 0;
313 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->contents
;
314 specbind (Qinhibit_quit
, Qt
);
315 /* Don't let the debugger step into this code
316 because it is not reentrant. */
317 specbind (Qdebug_on_next_call
, Qnil
);
319 record_unwind_save_match_data ();
321 if (NILP (Voverriding_local_map_menu_flag
))
323 specbind (Qoverriding_terminal_local_map
, Qnil
);
324 specbind (Qoverriding_local_map
, Qnil
);
327 set_buffer_internal_1 (XBUFFER (buffer
));
330 safe_run_hooks (Qactivate_menubar_hook
);
331 safe_run_hooks (Qmenu_bar_update_hook
);
332 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
334 items
= FRAME_MENU_BAR_ITEMS (f
);
336 /* Save the frame's previous menu bar contents data. */
337 if (previous_menu_items_used
)
338 memcpy (previous_items
, XVECTOR (f
->menu_bar_vector
)->contents
,
339 previous_menu_items_used
* word_size
);
341 /* Fill in menu_items with the current menu bar contents.
342 This can evaluate Lisp code. */
345 menu_items
= f
->menu_bar_vector
;
346 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
347 submenu_start
= (int *) alloca (ASIZE (items
) * sizeof (int));
348 submenu_end
= (int *) alloca (ASIZE (items
) * sizeof (int));
349 submenu_n_panes
= (int *) alloca (ASIZE (items
) * sizeof (int));
350 submenu_top_level_items
= (int *) alloca (ASIZE (items
) * sizeof (int));
352 for (i
= 0; i
< ASIZE (items
); i
+= 4)
354 Lisp_Object key
, string
, maps
;
358 key
= AREF (items
, i
);
359 string
= AREF (items
, i
+ 1);
360 maps
= AREF (items
, i
+ 2);
364 submenu_start
[i
] = menu_items_used
;
366 menu_items_n_panes
= 0;
367 submenu_top_level_items
[i
]
368 = parse_single_submenu (key
, string
, maps
);
369 submenu_n_panes
[i
] = menu_items_n_panes
;
371 submenu_end
[i
] = menu_items_used
;
374 finish_menu_items ();
376 /* Convert menu_items into widget_value trees
377 to display the menu. This cannot evaluate Lisp code. */
379 wv
= make_widget_value ("menubar", NULL
, true, Qnil
);
380 wv
->button_type
= BUTTON_TYPE_NONE
;
383 for (i
= 0; i
< last_i
; i
+= 4)
385 menu_items_n_panes
= submenu_n_panes
[i
];
386 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
387 submenu_top_level_items
[i
]);
391 first_wv
->contents
= wv
;
392 /* Don't set wv->name here; GC during the loop might relocate it. */
394 wv
->button_type
= BUTTON_TYPE_NONE
;
398 set_buffer_internal_1 (prev
);
400 /* If there has been no change in the Lisp-level contents
401 of the menu bar, skip redisplaying it. Just exit. */
403 for (i
= 0; i
< previous_menu_items_used
; i
++)
404 if (menu_items_used
== i
405 || (!EQ (previous_items
[i
], AREF (menu_items
, i
))))
407 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
409 free_menubar_widget_value_tree (first_wv
);
410 discard_menu_items ();
411 unbind_to (specpdl_count
, Qnil
);
415 fset_menu_bar_vector (f
, menu_items
);
416 f
->menu_bar_items_used
= menu_items_used
;
418 /* This undoes save_menu_items. */
419 unbind_to (specpdl_count
, Qnil
);
421 /* Now GC cannot happen during the lifetime of the widget_value,
422 so it's safe to store data from a Lisp_String, as long as
423 local copies are made when the actual menu is created.
424 Windows takes care of this for normal string items, but
425 not for owner-drawn items or additional item-info. */
426 wv
= first_wv
->contents
;
427 for (i
= 0; i
< ASIZE (items
); i
+= 4)
430 string
= AREF (items
, i
+ 1);
433 wv
->name
= SSDATA (string
);
434 update_submenu_strings (wv
->contents
);
440 /* Make a widget-value tree containing
441 just the top level menu bar strings. */
443 wv
= make_widget_value ("menubar", NULL
, true, Qnil
);
444 wv
->button_type
= BUTTON_TYPE_NONE
;
447 items
= FRAME_MENU_BAR_ITEMS (f
);
448 for (i
= 0; i
< ASIZE (items
); i
+= 4)
452 string
= AREF (items
, i
+ 1);
456 wv
= make_widget_value (SSDATA (string
), NULL
, true, Qnil
);
457 wv
->button_type
= BUTTON_TYPE_NONE
;
458 /* This prevents lwlib from assuming this
459 menu item is really supposed to be empty. */
460 /* The EMACS_INT cast avoids a warning.
461 This value just has to be different from small integers. */
462 wv
->call_data
= (void *) (EMACS_INT
) (-1);
467 first_wv
->contents
= wv
;
471 /* Forget what we thought we knew about what is in the
472 detailed contents of the menu bar menus.
473 Changing the top level always destroys the contents. */
474 f
->menu_bar_items_used
= 0;
477 /* Create or update the menu bar widget. */
483 /* Empty current menubar, rather than creating a fresh one. */
484 while (DeleteMenu (menubar_widget
, 0, MF_BYPOSITION
))
489 menubar_widget
= CreateMenu ();
491 fill_in_menu (menubar_widget
, first_wv
->contents
);
493 free_menubar_widget_value_tree (first_wv
);
496 HMENU old_widget
= f
->output_data
.w32
->menubar_widget
;
498 f
->output_data
.w32
->menubar_widget
= menubar_widget
;
499 SetMenu (FRAME_W32_WINDOW (f
), f
->output_data
.w32
->menubar_widget
);
500 /* Causes flicker when menu bar is updated
501 DrawMenuBar (FRAME_W32_WINDOW (f)); */
503 /* Force the window size to be recomputed so that the frame's text
504 area remains the same, if menubar has just been created. */
505 if (old_widget
== NULL
)
506 x_set_window_size (f
, 0, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
), 1);
512 /* Called from Fx_create_frame to create the initial menubar of a frame
513 before it is mapped, so that the window is mapped with the menubar already
514 there instead of us tacking it on later and thrashing the window after it
518 initialize_frame_menubar (struct frame
*f
)
520 /* This function is called before the first chance to redisplay
521 the frame. It has to be, so the frame will have the right size. */
522 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
523 set_frame_menubar (f
, 1, 1);
526 /* Get rid of the menu bar of frame F, and free its storage.
527 This is used when deleting a frame, and when turning off the menu bar. */
530 free_frame_menubar (struct frame
*f
)
535 HMENU old
= GetMenu (FRAME_W32_WINDOW (f
));
536 SetMenu (FRAME_W32_WINDOW (f
), NULL
);
537 f
->output_data
.w32
->menubar_widget
= NULL
;
545 /* w32_menu_show actually displays a menu using the panes and items in
546 menu_items and returns the value selected from it; we assume input
547 is blocked by the caller. */
549 /* F is the frame the menu is for.
550 X and Y are the frame-relative specified position,
551 relative to the inside upper left corner of the frame F.
552 Bitfield MENUFLAGS bits are:
553 MENU_FOR_CLICK is set if this menu was invoked for a mouse click.
554 MENU_KEYMAPS is set if this menu was specified with keymaps;
555 in that case, we return a list containing the chosen item's value
556 and perhaps also the pane's prefix.
557 TITLE is the specified menu title.
558 ERROR is a place to store an error message string in case of failure.
559 (We return nil on failure, but the value doesn't actually matter.) */
562 w32_menu_show (struct frame
*f
, int x
, int y
, int menuflags
,
563 Lisp_Object title
, const char **error
)
566 int menu_item_selection
;
569 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
570 widget_value
**submenu_stack
571 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
572 Lisp_Object
*subprefix_stack
573 = (Lisp_Object
*) alloca (menu_items_used
* word_size
);
574 int submenu_depth
= 0;
579 if (menu_items_n_panes
== 0)
582 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
584 *error
= "Empty menu";
590 /* Create a tree of widget_value objects
591 representing the panes and their items. */
592 wv
= make_widget_value ("menu", NULL
, true, Qnil
);
593 wv
->button_type
= BUTTON_TYPE_NONE
;
597 /* Loop over all panes and items, filling in the tree. */
599 while (i
< menu_items_used
)
601 if (EQ (AREF (menu_items
, i
), Qnil
))
603 submenu_stack
[submenu_depth
++] = save_wv
;
609 else if (EQ (AREF (menu_items
, i
), Qlambda
))
612 save_wv
= submenu_stack
[--submenu_depth
];
616 else if (EQ (AREF (menu_items
, i
), Qt
)
617 && submenu_depth
!= 0)
618 i
+= MENU_ITEMS_PANE_LENGTH
;
619 /* Ignore a nil in the item list.
620 It's meaningful only for dialog boxes. */
621 else if (EQ (AREF (menu_items
, i
), Qquote
))
623 else if (EQ (AREF (menu_items
, i
), Qt
))
625 /* Create a new pane. */
626 Lisp_Object pane_name
, prefix
;
627 const char *pane_string
;
628 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
629 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
631 if (STRINGP (pane_name
))
633 if (unicode_append_menu
)
634 pane_name
= ENCODE_UTF_8 (pane_name
);
635 else if (STRING_MULTIBYTE (pane_name
))
636 pane_name
= ENCODE_SYSTEM (pane_name
);
638 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
641 pane_string
= (NILP (pane_name
)
642 ? "" : SSDATA (pane_name
));
643 /* If there is just one top-level pane, put all its items directly
644 under the top-level menu. */
645 if (menu_items_n_panes
== 1)
648 /* If the pane has a meaningful name,
649 make the pane a top-level menu item
650 with its items as a submenu beneath it. */
651 if (!(menuflags
& MENU_KEYMAPS
) && strcmp (pane_string
, ""))
653 wv
= make_widget_value (pane_string
, NULL
, true, Qnil
);
657 first_wv
->contents
= wv
;
658 if ((menuflags
& MENU_KEYMAPS
) && !NILP (prefix
))
660 wv
->button_type
= BUTTON_TYPE_NONE
;
670 i
+= MENU_ITEMS_PANE_LENGTH
;
674 /* Create a new item within current pane. */
675 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
677 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
678 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
679 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
680 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
681 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
682 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
683 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
685 if (STRINGP (item_name
))
687 if (unicode_append_menu
)
688 item_name
= ENCODE_UTF_8 (item_name
);
689 else if (STRING_MULTIBYTE (item_name
))
690 item_name
= ENCODE_SYSTEM (item_name
);
692 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
695 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
697 descrip
= ENCODE_SYSTEM (descrip
);
698 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
701 wv
= make_widget_value (SSDATA (item_name
), NULL
, !NILP (enable
),
702 STRINGP (help
) ? help
: Qnil
);
706 save_wv
->contents
= wv
;
708 wv
->key
= SSDATA (descrip
);
709 /* Use the contents index as call_data, since we are
710 restricted to 16-bits. */
711 wv
->call_data
= !NILP (def
) ? (void *) (EMACS_INT
) i
: 0;
714 wv
->button_type
= BUTTON_TYPE_NONE
;
715 else if (EQ (type
, QCtoggle
))
716 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
717 else if (EQ (type
, QCradio
))
718 wv
->button_type
= BUTTON_TYPE_RADIO
;
722 wv
->selected
= !NILP (selected
);
726 i
+= MENU_ITEMS_ITEM_LENGTH
;
730 /* Deal with the title, if it is non-nil. */
733 widget_value
*wv_title
;
734 widget_value
*wv_sep
= make_widget_value ("--", NULL
, false, Qnil
);
736 /* Maybe replace this separator with a bitmap or owner-draw item
737 so that it looks better. Having two separators looks odd. */
738 wv_sep
->next
= first_wv
->contents
;
740 if (unicode_append_menu
)
741 title
= ENCODE_UTF_8 (title
);
742 else if (STRING_MULTIBYTE (title
))
743 title
= ENCODE_SYSTEM (title
);
745 wv_title
= make_widget_value (SSDATA (title
), NULL
, true, Qnil
);
746 wv_title
->title
= TRUE
;
747 wv_title
->button_type
= BUTTON_TYPE_NONE
;
748 wv_title
->next
= wv_sep
;
749 first_wv
->contents
= wv_title
;
752 /* No selection has been chosen yet. */
753 menu_item_selection
= 0;
755 /* Actually create the menu. */
756 current_popup_menu
= menu
= CreatePopupMenu ();
757 fill_in_menu (menu
, first_wv
->contents
);
759 /* Adjust coordinates to be root-window-relative. */
762 ClientToScreen (FRAME_W32_WINDOW (f
), &pos
);
764 /* Display the menu. */
765 menu_item_selection
= SendMessage (FRAME_W32_WINDOW (f
),
766 WM_EMACS_TRACKPOPUPMENU
,
767 (WPARAM
)menu
, (LPARAM
)&pos
);
769 /* Clean up extraneous mouse events which might have been generated
771 discard_mouse_events ();
772 FRAME_DISPLAY_INFO (f
)->grabbed
= 0;
774 /* Free the widget_value objects we used to specify the contents. */
775 free_menubar_widget_value_tree (first_wv
);
779 /* Free the owner-drawn and help-echo menu strings. */
780 w32_free_menu_strings (FRAME_W32_WINDOW (f
));
781 f
->output_data
.w32
->menubar_active
= 0;
783 /* Find the selected item, and its pane, to return
785 if (menu_item_selection
!= 0)
787 Lisp_Object prefix
, entry
;
789 prefix
= entry
= Qnil
;
791 while (i
< menu_items_used
)
793 if (EQ (AREF (menu_items
, i
), Qnil
))
795 subprefix_stack
[submenu_depth
++] = prefix
;
799 else if (EQ (AREF (menu_items
, i
), Qlambda
))
801 prefix
= subprefix_stack
[--submenu_depth
];
804 else if (EQ (AREF (menu_items
, i
), Qt
))
806 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
807 i
+= MENU_ITEMS_PANE_LENGTH
;
809 /* Ignore a nil in the item list.
810 It's meaningful only for dialog boxes. */
811 else if (EQ (AREF (menu_items
, i
), Qquote
))
815 entry
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
816 if (menu_item_selection
== i
)
818 if (menuflags
& MENU_KEYMAPS
)
822 entry
= Fcons (entry
, Qnil
);
824 entry
= Fcons (prefix
, entry
);
825 for (j
= submenu_depth
- 1; j
>= 0; j
--)
826 if (!NILP (subprefix_stack
[j
]))
827 entry
= Fcons (subprefix_stack
[j
], entry
);
832 i
+= MENU_ITEMS_ITEM_LENGTH
;
836 else if (!(menuflags
& MENU_FOR_CLICK
))
839 /* Make "Cancel" equivalent to C-g. */
840 Fsignal (Qquit
, Qnil
);
849 /* TODO: On Windows, there are two ways of defining a dialog.
851 1. Create a predefined dialog resource and include it in nt/emacs.rc.
852 Using this method, we could then set the titles and make unneeded
853 buttons invisible before displaying the dialog. Everything would
854 be a fixed size though, so there is a risk that text does not
856 2. Create the dialog template in memory on the fly. This allows us
857 to size the dialog and buttons dynamically, probably giving more
858 natural looking results for dialogs with few buttons, and eliminating
859 the problem of text overflowing the buttons. But the API for this is
860 quite complex - structures have to be allocated in particular ways,
861 text content is tacked onto the end of structures in variable length
862 arrays with further structures tacked on after these, there are
863 certain alignment requirements for all this, and we have to
864 measure all the text and convert to "dialog coordinates" to figure
865 out how big to make everything.
867 For now, we'll just stick with menus for dialogs that are more
868 complicated than simple yes/no type questions for which we can use
869 the MessageBox function.
872 static char * button_names
[] = {
873 "button1", "button2", "button3", "button4", "button5",
874 "button6", "button7", "button8", "button9", "button10" };
877 w32_dialog_show (struct frame
*f
, Lisp_Object title
,
878 Lisp_Object header
, char **error
)
880 int i
, nb_buttons
= 0;
882 int menu_item_selection
;
884 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
886 /* Number of elements seen so far, before boundary. */
888 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
889 int boundary_seen
= 0;
893 if (menu_items_n_panes
> 1)
895 *error
= "Multiple panes in dialog box";
899 /* Create a tree of widget_value objects
900 representing the text label and buttons. */
902 Lisp_Object pane_name
;
904 pane_name
= AREF (menu_items
, MENU_ITEMS_PANE_NAME
);
905 pane_string
= (NILP (pane_name
)
906 ? "" : SSDATA (pane_name
));
907 prev_wv
= make_widget_value ("message", pane_string
, true, Qnil
);
910 /* Loop over all panes and items, filling in the tree. */
911 i
= MENU_ITEMS_PANE_LENGTH
;
912 while (i
< menu_items_used
)
915 /* Create a new item within current pane. */
916 Lisp_Object item_name
, enable
, descrip
, help
;
918 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
919 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
920 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
921 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
923 if (NILP (item_name
))
925 free_menubar_widget_value_tree (first_wv
);
926 *error
= "Submenu in dialog items";
929 if (EQ (item_name
, Qquote
))
931 /* This is the boundary between left-side elts
932 and right-side elts. Stop incrementing right_count. */
939 free_menubar_widget_value_tree (first_wv
);
940 *error
= "Too many dialog items";
944 wv
= make_widget_value (button_names
[nb_buttons
],
946 !NILP (enable
), Qnil
);
949 wv
->key
= SSDATA (descrip
);
950 wv
->call_data
= aref_addr (menu_items
, i
);
957 i
+= MENU_ITEMS_ITEM_LENGTH
;
960 /* If the boundary was not specified,
961 by default put half on the left and half on the right. */
963 left_count
= nb_buttons
- nb_buttons
/ 2;
965 wv
= make_widget_value (dialog_name
, NULL
, false, Qnil
);
967 /* Frame title: 'Q' = Question, 'I' = Information.
968 Can also have 'E' = Error if, one day, we want
969 a popup for errors. */
971 dialog_name
[0] = 'Q';
973 dialog_name
[0] = 'I';
975 /* Dialog boxes use a really stupid name encoding
976 which specifies how many buttons to use
977 and how many buttons are on the right. */
978 dialog_name
[1] = '0' + nb_buttons
;
979 dialog_name
[2] = 'B';
980 dialog_name
[3] = 'R';
981 /* Number of buttons to put on the right. */
982 dialog_name
[4] = '0' + nb_buttons
- left_count
;
984 wv
->contents
= first_wv
;
988 /* Actually create the dialog. */
989 dialog_id
= widget_id_tick
++;
990 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
991 f
->output_data
.w32
->widget
, 1, 0,
992 dialog_selection_callback
, 0);
993 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, TRUE
);
995 /* Free the widget_value objects we used to specify the contents. */
996 free_menubar_widget_value_tree (first_wv
);
998 /* No selection has been chosen yet. */
999 menu_item_selection
= 0;
1001 /* Display the menu. */
1002 lw_pop_up_all_widgets (dialog_id
);
1004 /* Process events that apply to the menu. */
1005 popup_get_selection ((XEvent
*) 0, FRAME_DISPLAY_INFO (f
), dialog_id
);
1007 lw_destroy_all_widgets (dialog_id
);
1009 /* Find the selected item, and its pane, to return
1010 the proper value. */
1011 if (menu_item_selection
!= 0)
1014 while (i
< menu_items_used
)
1018 if (EQ (AREF (menu_items
, i
), Qt
))
1019 i
+= MENU_ITEMS_PANE_LENGTH
;
1022 entry
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
1023 if (menu_item_selection
== i
)
1025 i
+= MENU_ITEMS_ITEM_LENGTH
;
1030 /* Make "Cancel" equivalent to C-g. */
1031 Fsignal (Qquit
, Qnil
);
1035 #else /* !HAVE_DIALOGS */
1037 /* Currently we only handle Yes No dialogs (y-or-n-p and yes-or-no-p) as
1038 simple dialogs. We could handle a few more, but I'm not aware of
1039 anywhere in Emacs that uses the other specific dialog choices that
1040 MessageBox provides. */
1043 is_simple_dialog (Lisp_Object contents
)
1045 Lisp_Object options
;
1046 Lisp_Object name
, yes
, no
, other
;
1048 if (!CONSP (contents
))
1050 options
= XCDR (contents
);
1052 yes
= build_string ("Yes");
1053 no
= build_string ("No");
1055 if (!CONSP (options
))
1058 name
= XCAR (options
);
1063 if (!NILP (Fstring_equal (name
, yes
)))
1065 else if (!NILP (Fstring_equal (name
, no
)))
1070 options
= XCDR (options
);
1071 if (!CONSP (options
))
1074 name
= XCAR (options
);
1078 if (NILP (Fstring_equal (name
, other
)))
1081 /* Check there are no more options. */
1082 options
= XCDR (options
);
1083 return !(CONSP (options
));
1087 simple_dialog_show (struct frame
*f
, Lisp_Object contents
, Lisp_Object header
)
1091 Lisp_Object lispy_answer
= Qnil
, temp
= XCAR (contents
);
1095 /* Since we only handle Yes/No dialogs, and we already checked
1096 is_simple_dialog, we don't need to worry about checking contents
1097 to see what type of dialog to use. */
1099 /* Use Unicode if possible, so any language can be displayed. */
1100 if (unicode_message_box
)
1108 char *utf8_text
= SDATA (ENCODE_UTF_8 (temp
));
1109 /* Be pessimistic about the number of characters needed.
1110 Remember characters outside the BMP will take more than
1111 one utf16 word, so we cannot simply use the character
1113 int utf8_len
= strlen (utf8_text
);
1114 text
= SAFE_ALLOCA ((utf8_len
+ 1) * sizeof (WCHAR
));
1115 utf8to16 (utf8_text
, utf8_len
, text
);
1124 title
= L
"Question";
1125 type
|= MB_ICONQUESTION
;
1129 title
= L
"Information";
1130 type
|= MB_ICONINFORMATION
;
1133 answer
= unicode_message_box (FRAME_W32_WINDOW (f
), text
, title
, type
);
1138 const char *text
, *title
;
1140 /* Fall back on ANSI message box, but at least use system
1141 encoding so questions representable by the system codepage
1142 are encoded properly. */
1144 text
= SDATA (ENCODE_SYSTEM (temp
));
1151 type
|= MB_ICONQUESTION
;
1155 title
= "Information";
1156 type
|= MB_ICONINFORMATION
;
1159 answer
= MessageBox (FRAME_W32_WINDOW (f
), text
, title
, type
);
1162 if (answer
== IDYES
)
1163 lispy_answer
= build_string ("Yes");
1164 else if (answer
== IDNO
)
1165 lispy_answer
= build_string ("No");
1167 Fsignal (Qquit
, Qnil
);
1169 for (temp
= XCDR (contents
); CONSP (temp
); temp
= XCDR (temp
))
1171 Lisp_Object item
, name
, value
;
1176 value
= XCDR (item
);
1184 if (!NILP (Fstring_equal (name
, lispy_answer
)))
1189 Fsignal (Qquit
, Qnil
);
1192 #endif /* !HAVE_DIALOGS */
1195 /* UTF8: 0xxxxxxx, 110xxxxx 10xxxxxx, 1110xxxx, 10xxxxxx, 10xxxxxx */
1197 utf8to16 (unsigned char * src
, int len
, WCHAR
* dest
)
1203 *dest
= (WCHAR
) *src
;
1204 dest
++; src
++; len
--;
1206 /* Since we might get >3 byte sequences which we don't handle, ignore the extra parts. */
1207 else if (*src
< 0xC0)
1211 /* 2 char UTF-8 sequence. */
1212 else if (*src
< 0xE0)
1214 *dest
= (WCHAR
) (((*src
& 0x1f) << 6)
1215 | (*(src
+ 1) & 0x3f));
1216 src
+= 2; len
-= 2; dest
++;
1218 else if (*src
< 0xF0)
1220 *dest
= (WCHAR
) (((*src
& 0x0f) << 12)
1221 | ((*(src
+ 1) & 0x3f) << 6)
1222 | (*(src
+ 2) & 0x3f));
1223 src
+= 3; len
-= 3; dest
++;
1225 else /* Not encodable. Insert Unicode Substitution char. */
1227 *dest
= (WCHAR
) 0xfffd;
1228 src
++; len
--; dest
++;
1235 add_menu_item (HMENU menu
, widget_value
*wv
, HMENU item
)
1238 char *out_string
, *p
, *q
;
1240 size_t nlen
, orig_len
;
1243 if (menu_separator_name_p (wv
->name
))
1245 fuFlags
= MF_SEPARATOR
;
1251 fuFlags
= MF_STRING
;
1253 fuFlags
= MF_STRING
| MF_GRAYED
;
1255 if (wv
->key
!= NULL
)
1257 out_string
= SAFE_ALLOCA (strlen (wv
->name
) + strlen (wv
->key
) + 2);
1258 strcpy (out_string
, wv
->name
);
1259 strcat (out_string
, "\t");
1260 strcat (out_string
, wv
->key
);
1263 out_string
= (char *)wv
->name
;
1265 /* Quote any special characters within the menu item's text and
1267 nlen
= orig_len
= strlen (out_string
);
1268 if (unicode_append_menu
)
1270 /* With UTF-8, & cannot be part of a multibyte character. */
1271 for (p
= out_string
; *p
; p
++)
1277 #ifndef NTGUI_UNICODE
1280 /* If encoded with the system codepage, use multibyte string
1281 functions in case of multibyte characters that contain '&'. */
1282 for (p
= out_string
; *p
; p
= _mbsinc (p
))
1284 if (_mbsnextc (p
) == '&')
1288 #endif /* !NTGUI_UNICODE */
1290 if (nlen
> orig_len
)
1293 out_string
= SAFE_ALLOCA (nlen
+ 1);
1297 if (unicode_append_menu
)
1303 #ifndef NTGUI_UNICODE
1306 if (_mbsnextc (p
) == '&')
1315 #endif /* !NTGUI_UNICODE */
1322 else if (wv
->title
|| wv
->call_data
== 0)
1324 /* Only use MF_OWNERDRAW if GetMenuItemInfo is usable, since
1325 we can't deallocate the memory otherwise. */
1326 if (get_menu_item_info
)
1328 out_string
= (char *) local_alloc (strlen (wv
->name
) + 1);
1329 strcpy (out_string
, wv
->name
);
1331 DebPrint ("Menu: allocating %ld for owner-draw", out_string
);
1333 fuFlags
= MF_OWNERDRAW
| MF_DISABLED
;
1336 fuFlags
= MF_DISABLED
;
1339 /* Draw radio buttons and tickboxes. */
1340 else if (wv
->selected
&& (wv
->button_type
== BUTTON_TYPE_TOGGLE
||
1341 wv
->button_type
== BUTTON_TYPE_RADIO
))
1342 fuFlags
|= MF_CHECKED
;
1344 fuFlags
|= MF_UNCHECKED
;
1347 if (unicode_append_menu
&& out_string
)
1349 /* Convert out_string from UTF-8 to UTF-16-LE. */
1350 int utf8_len
= strlen (out_string
);
1351 WCHAR
* utf16_string
;
1352 if (fuFlags
& MF_OWNERDRAW
)
1353 utf16_string
= local_alloc ((utf8_len
+ 1) * sizeof (WCHAR
));
1355 utf16_string
= SAFE_ALLOCA ((utf8_len
+ 1) * sizeof (WCHAR
));
1357 utf8to16 (out_string
, utf8_len
, utf16_string
);
1358 return_value
= unicode_append_menu (menu
, fuFlags
,
1359 item
!= NULL
? (UINT_PTR
) item
1360 : (UINT_PTR
) wv
->call_data
,
1363 #ifndef NTGUI_UNICODE /* Fallback does not apply when always UNICODE */
1366 /* On W9x/ME, Unicode menus are not supported, though AppendMenuW
1367 apparently does exist at least in some cases and appears to be
1368 stubbed out to do nothing. out_string is UTF-8, but since
1369 our standard menus are in English and this is only going to
1370 happen the first time a menu is used, the encoding is
1371 of minor importance compared with menus not working at all. */
1373 AppendMenu (menu
, fuFlags
,
1374 item
!= NULL
? (UINT_PTR
) item
: (UINT_PTR
) wv
->call_data
,
1376 /* Don't use Unicode menus in future, unless this is Windows
1377 NT or later, where a failure of AppendMenuW does NOT mean
1378 Unicode menus are unsupported. */
1379 if (osinfo_cache
.dwPlatformId
!= VER_PLATFORM_WIN32_NT
)
1380 unicode_append_menu
= NULL
;
1382 #endif /* NTGUI_UNICODE */
1384 if (unicode_append_menu
&& (fuFlags
& MF_OWNERDRAW
))
1385 local_free (out_string
);
1392 item
!= NULL
? (UINT_PTR
) item
: (UINT_PTR
) wv
->call_data
,
1396 /* This must be done after the menu item is created. */
1397 if (!wv
->title
&& wv
->call_data
!= 0)
1399 if (set_menu_item_info
)
1402 memset (&info
, 0, sizeof (info
));
1403 info
.cbSize
= sizeof (info
);
1404 info
.fMask
= MIIM_DATA
;
1406 /* Set help string for menu item. Leave it as a Lisp_Object
1407 until it is ready to be displayed, since GC can happen while
1408 menus are active. */
1409 if (!NILP (wv
->help
))
1411 /* As of Jul-2012, w32api headers say that dwItemData
1412 has DWORD type, but that's a bug: it should actually
1413 be ULONG_PTR, which is correct for 32-bit and 64-bit
1414 Windows alike. MSVC headers get it right; hopefully,
1415 MinGW headers will, too. */
1416 info
.dwItemData
= (ULONG_PTR
) XLI (wv
->help
);
1418 if (wv
->button_type
== BUTTON_TYPE_RADIO
)
1420 /* CheckMenuRadioItem allows us to differentiate TOGGLE and
1421 RADIO items, but is not available on NT 3.51 and earlier. */
1422 info
.fMask
|= MIIM_TYPE
| MIIM_STATE
;
1423 info
.fType
= MFT_RADIOCHECK
| MFT_STRING
;
1424 info
.dwTypeData
= out_string
;
1425 info
.fState
= wv
->selected
? MFS_CHECKED
: MFS_UNCHECKED
;
1428 set_menu_item_info (menu
,
1429 item
!= NULL
? (UINT_PTR
) item
: (UINT_PTR
) wv
->call_data
,
1434 return return_value
;
1437 /* Construct native Windows menu(bar) based on widget_value tree. */
1439 fill_in_menu (HMENU menu
, widget_value
*wv
)
1441 for ( ; wv
!= NULL
; wv
= wv
->next
)
1445 HMENU sub_menu
= CreatePopupMenu ();
1447 if (sub_menu
== NULL
)
1450 if (!fill_in_menu (sub_menu
, wv
->contents
) ||
1451 !add_menu_item (menu
, wv
, sub_menu
))
1453 DestroyMenu (sub_menu
);
1459 if (!add_menu_item (menu
, wv
, NULL
))
1466 /* Display help string for currently pointed to menu item. Not
1467 supported on NT 3.51 and earlier, as GetMenuItemInfo is not
1470 w32_menu_display_help (HWND owner
, HMENU menu
, UINT item
, UINT flags
)
1472 if (get_menu_item_info
)
1474 struct frame
*f
= x_window_to_frame (&one_w32_display_info
, owner
);
1475 Lisp_Object frame
, help
;
1477 /* No help echo on owner-draw menu items, or when the keyboard is used
1478 to navigate the menus, since tooltips are distracting if they pop
1480 if (flags
& MF_OWNERDRAW
|| flags
& MF_POPUP
1481 || !(flags
& MF_MOUSESELECT
))
1487 memset (&info
, 0, sizeof (info
));
1488 info
.cbSize
= sizeof (info
);
1489 info
.fMask
= MIIM_DATA
;
1490 get_menu_item_info (menu
, item
, FALSE
, &info
);
1492 help
= info
.dwItemData
? XIL (info
.dwItemData
) : Qnil
;
1495 /* Store the help echo in the keyboard buffer as the X toolkit
1496 version does, rather than directly showing it. This seems to
1497 solve the GC problems that were present when we based the
1498 Windows code on the non-toolkit version. */
1501 XSETFRAME (frame
, f
);
1502 kbd_buffer_store_help_event (frame
, help
);
1505 /* X version has a loop through frames here, which doesn't
1506 appear to do anything, unless it has some side effect. */
1507 show_help_echo (help
, Qnil
, Qnil
, Qnil
);
1511 /* Free memory used by owner-drawn strings. */
1513 w32_free_submenu_strings (HMENU menu
)
1515 int i
, num
= GetMenuItemCount (menu
);
1516 for (i
= 0; i
< num
; i
++)
1519 memset (&info
, 0, sizeof (info
));
1520 info
.cbSize
= sizeof (info
);
1521 info
.fMask
= MIIM_DATA
| MIIM_TYPE
| MIIM_SUBMENU
;
1523 get_menu_item_info (menu
, i
, TRUE
, &info
);
1525 /* Owner-drawn names are held in dwItemData. */
1526 if ((info
.fType
& MF_OWNERDRAW
) && info
.dwItemData
)
1529 DebPrint ("Menu: freeing %ld for owner-draw", info
.dwItemData
);
1531 local_free (info
.dwItemData
);
1534 /* Recurse down submenus. */
1536 w32_free_submenu_strings (info
.hSubMenu
);
1541 w32_free_menu_strings (HWND hwnd
)
1543 HMENU menu
= current_popup_menu
;
1545 if (get_menu_item_info
)
1547 /* If there is no popup menu active, free the strings from the frame's
1550 menu
= GetMenu (hwnd
);
1553 w32_free_submenu_strings (menu
);
1556 current_popup_menu
= NULL
;
1559 /* The following is used by delayed window autoselection. */
1561 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
1562 doc
: /* Return t if a menu or popup dialog is active on selected frame. */)
1566 f
= SELECTED_FRAME ();
1567 return (f
->output_data
.w32
->menubar_active
> 0) ? Qt
: Qnil
;
1571 syms_of_w32menu (void)
1573 globals_of_w32menu ();
1575 current_popup_menu
= NULL
;
1577 DEFSYM (Qdebug_on_next_call
, "debug-on-next-call");
1578 DEFSYM (Qunsupported__w32_dialog
, "unsupported--w32-dialog");
1580 defsubr (&Smenu_or_popup_active_p
);
1584 globals_of_w32menu is used to initialize those global variables that
1585 must always be initialized on startup even when the global variable
1586 initialized is non zero (see the function main in emacs.c).
1587 globals_of_w32menu is called from syms_of_w32menu when the global
1588 variable initialized is 0 and directly from main when initialized
1592 globals_of_w32menu (void)
1594 #ifndef NTGUI_UNICODE
1595 /* See if Get/SetMenuItemInfo functions are available. */
1596 HMODULE user32
= GetModuleHandle ("user32.dll");
1597 get_menu_item_info
= (GetMenuItemInfoA_Proc
) GetProcAddress (user32
, "GetMenuItemInfoA");
1598 set_menu_item_info
= (SetMenuItemInfoA_Proc
) GetProcAddress (user32
, "SetMenuItemInfoA");
1599 unicode_append_menu
= (AppendMenuW_Proc
) GetProcAddress (user32
, "AppendMenuW");
1600 unicode_message_box
= (MessageBoxW_Proc
) GetProcAddress (user32
, "MessageBoxW");
1601 #endif /* !NTGUI_UNICODE */