1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2015 Free Software
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 /* X pop-up deck-of-cards menu facility for GNU Emacs.
23 * Written by Jon Arnold and Roman Budzianowski
24 * Mods and rewrite by Robert Krawitz
28 /* Modified by Fred Pierresteguy on December 93
29 to make the popup menus and menubar use the Xt. */
31 /* Rewritten for clarity and GC protection by rms in Feb 94. */
41 #include "termhooks.h"
43 #include "blockinput.h"
44 #include "character.h"
48 #include "sysselect.h"
55 /* This may include sys/types.h, and that somehow loses
56 if this is not done before the other system files. */
60 /* Load sys/types.h if not already loaded.
61 In some systems loading it twice is suicidal. */
63 #include <sys/types.h>
66 #include "dispextern.h"
69 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
70 code accepts the Emacs internal encoding. */
71 #undef HAVE_MULTILINGUAL_MENU
75 #include <X11/IntrinsicP.h>
76 #include <X11/CoreP.h>
77 #include <X11/StringDefs.h>
78 #include <X11/Shell.h>
80 #include "xsettings.h"
81 #include "../lwlib/xlwmenu.h"
83 #include <X11/Xaw3d/Paned.h>
84 #else /* !HAVE_XAW3D */
85 #include <X11/Xaw/Paned.h>
86 #endif /* HAVE_XAW3D */
87 #endif /* USE_LUCID */
89 #include "../lwlib/lwlib.h"
91 #else /* not USE_X_TOOLKIT */
93 #include "../oldXMenu/XMenu.h"
95 #endif /* not USE_X_TOOLKIT */
96 #endif /* HAVE_X_WINDOWS */
101 #include "xgselect.h"
108 /* Flag which when set indicates a dialog or menu has been posted by
109 Xt on behalf of one of the widget sets. */
110 static int popup_activated_flag
;
115 static LWLIB_ID next_menubar_widget_id
;
117 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
119 static struct frame
*
120 menubar_id_to_frame (LWLIB_ID id
)
122 Lisp_Object tail
, frame
;
125 FOR_EACH_FRAME (tail
, frame
)
128 if (!FRAME_WINDOW_P (f
))
130 if (f
->output_data
.x
->id
== id
)
140 #if defined USE_GTK || defined USE_MOTIF
142 /* Set menu_items_inuse so no other popup menu or dialog is created. */
145 x_menu_set_in_use (bool in_use
)
147 menu_items_inuse
= in_use
? Qt
: Qnil
;
148 popup_activated_flag
= in_use
;
150 if (popup_activated_flag
)
151 x_activate_timeout_atimer ();
157 /* Wait for an X event to arrive or for a timer to expire. */
160 x_menu_wait_for_event (void *data
)
162 /* Another way to do this is to register a timer callback, that can be
163 done in GTK and Xt. But we have to do it like this when using only X
164 anyway, and with callbacks we would have three variants for timer handling
165 instead of the small ifdefs below. */
169 ! XtAppPending (Xt_app_con
)
170 #elif defined USE_GTK
171 ! gtk_events_pending ()
177 struct timespec next_time
= timer_check (), *ntp
;
179 struct x_display_info
*dpyinfo
;
183 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
185 int fd
= ConnectionNumber (dpyinfo
->display
);
186 FD_SET (fd
, &read_fds
);
188 XFlush (dpyinfo
->display
);
191 if (! timespec_valid_p (next_time
))
196 #if defined USE_GTK && defined HAVE_GTK3
197 /* Gtk3 have arrows on menus when they don't fit. When the
198 pointer is over an arrow, a timeout scrolls it a bit. Use
199 xg_select so that timeout gets triggered. */
200 xg_select (n
+ 1, &read_fds
, NULL
, NULL
, ntp
, NULL
);
202 pselect (n
+ 1, &read_fds
, NULL
, NULL
, ntp
, NULL
);
209 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
213 /* Loop in Xt until the menu pulldown or dialog popup has been
214 popped down (deactivated). This is used for x-popup-menu
215 and x-popup-dialog; it is not used for the menu bar.
217 NOTE: All calls to popup_get_selection should be protected
218 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
221 popup_get_selection (XEvent
*initial_event
, struct x_display_info
*dpyinfo
,
222 LWLIB_ID id
, bool do_timers
)
226 while (popup_activated_flag
)
230 event
= *initial_event
;
235 if (do_timers
) x_menu_wait_for_event (0);
236 XtAppNextEvent (Xt_app_con
, &event
);
239 /* Make sure we don't consider buttons grabbed after menu goes.
240 And make sure to deactivate for any ButtonRelease,
241 even if XtDispatchEvent doesn't do that. */
242 if (event
.type
== ButtonRelease
243 && dpyinfo
->display
== event
.xbutton
.display
)
245 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
246 #ifdef USE_MOTIF /* Pretending that the event came from a
247 Btn1Down seems the only way to convince Motif to
248 activate its callbacks; setting the XmNmenuPost
249 isn't working. --marcus@sysc.pdx.edu. */
250 event
.xbutton
.button
= 1;
251 /* Motif only pops down menus when no Ctrl, Alt or Mod
252 key is pressed and the button is released. So reset key state
253 so Motif thinks this is the case. */
254 event
.xbutton
.state
= 0;
257 /* Pop down on C-g and Escape. */
258 else if (event
.type
== KeyPress
259 && dpyinfo
->display
== event
.xbutton
.display
)
261 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
263 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
264 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
265 popup_activated_flag
= 0;
268 x_dispatch_event (&event
, event
.xany
.display
);
272 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
273 doc
: /* Start key navigation of the menu bar in FRAME.
274 This initially opens the first menu bar item and you can then navigate with the
275 arrow keys, select a menu entry with the return key or cancel with the
276 escape key. If FRAME has no menu bar this function does nothing.
278 If FRAME is nil or not given, use the selected frame. */)
282 struct frame
*f
= decode_window_system_frame (frame
);
286 if (FRAME_EXTERNAL_MENU_BAR (f
))
287 set_frame_menubar (f
, false, true);
289 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
293 bool error_p
= false;
295 x_catch_errors (FRAME_X_DISPLAY (f
));
296 memset (&ev
, 0, sizeof ev
);
297 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
298 ev
.xbutton
.window
= XtWindow (menubar
);
299 ev
.xbutton
.root
= FRAME_DISPLAY_INFO (f
)->root_window
;
300 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
301 ev
.xbutton
.button
= Button1
;
302 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
303 ev
.xbutton
.same_screen
= True
;
310 XtSetArg (al
[0], XtNchildren
, &list
);
311 XtSetArg (al
[1], XtNnumChildren
, &nr
);
312 XtGetValues (menubar
, al
, 2);
313 ev
.xbutton
.window
= XtWindow (list
[0]);
317 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
318 /* From-window, to-window. */
319 ev
.xbutton
.window
, ev
.xbutton
.root
,
321 /* From-position, to-position. */
322 ev
.xbutton
.x
, ev
.xbutton
.y
,
323 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
327 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
332 ev
.type
= ButtonPress
;
333 ev
.xbutton
.state
= 0;
335 XtDispatchEvent (&ev
);
336 ev
.xbutton
.type
= ButtonRelease
;
337 ev
.xbutton
.state
= Button1Mask
;
338 XtDispatchEvent (&ev
);
346 #endif /* USE_X_TOOLKIT */
350 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
351 doc
: /* Start key navigation of the menu bar in FRAME.
352 This initially opens the first menu bar item and you can then navigate with the
353 arrow keys, select a menu entry with the return key or cancel with the
354 escape key. If FRAME has no menu bar this function does nothing.
356 If FRAME is nil or not given, use the selected frame. */)
363 f
= decode_window_system_frame (frame
);
365 if (FRAME_EXTERNAL_MENU_BAR (f
))
366 set_frame_menubar (f
, false, true);
368 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
371 /* Activate the first menu. */
372 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
376 g_signal_emit_by_name (children
->data
, "activate_item");
377 popup_activated_flag
= 1;
378 g_list_free (children
);
386 /* Loop util popup_activated_flag is set to zero in a callback.
387 Used for popup menus and dialogs. */
390 popup_widget_loop (bool do_timers
, GtkWidget
*widget
)
392 ++popup_activated_flag
;
394 /* Process events in the Gtk event loop until done. */
395 while (popup_activated_flag
)
397 if (do_timers
) x_menu_wait_for_event (0);
398 gtk_main_iteration ();
403 /* Activate the menu bar of frame F.
404 This is called from keyboard.c when it gets the
405 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
407 To activate the menu bar, we use the X button-press event
408 that was saved in saved_menu_event.
409 That makes the toolkit do its thing.
411 But first we recompute the menu bar contents (the whole tree).
413 The reason for saving the button event until here, instead of
414 passing it to the toolkit right away, is that we can safely
415 execute Lisp code. */
418 x_activate_menubar (struct frame
*f
)
420 eassert (FRAME_X_P (f
));
422 if (!f
->output_data
.x
->saved_menu_event
->type
)
426 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
427 f
->output_data
.x
->saved_menu_event
->xany
.window
))
431 set_frame_menubar (f
, false, true);
433 popup_activated_flag
= 1;
435 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
436 f
->output_data
.x
->saved_menu_event
);
438 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
442 /* Ignore this if we get it a second time. */
443 f
->output_data
.x
->saved_menu_event
->type
= 0;
446 /* This callback is invoked when the user selects a menubar cascade
447 pushbutton, but before the pulldown menu is posted. */
451 popup_activate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
453 popup_activated_flag
= 1;
454 x_activate_timeout_atimer ();
458 /* This callback is invoked when a dialog or menu is finished being
459 used and has been unposted. */
462 popup_deactivate_callback (
464 GtkWidget
*widget
, gpointer client_data
466 Widget widget
, LWLIB_ID id
, XtPointer client_data
470 popup_activated_flag
= 0;
474 /* Function that finds the frame for WIDGET and shows the HELP text
476 F is the frame if known, or NULL if not known. */
478 show_help_event (struct frame
*f
, xt_or_gtk_widget widget
, Lisp_Object help
)
484 XSETFRAME (frame
, f
);
485 kbd_buffer_store_help_event (frame
, help
);
488 show_help_echo (help
, Qnil
, Qnil
, Qnil
);
491 /* Callback called when menu items are highlighted/unhighlighted
492 while moving the mouse over them. WIDGET is the menu bar or menu
493 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
494 the data structure for the menu item, or null in case of
499 menu_highlight_callback (GtkWidget
*widget
, gpointer call_data
)
501 xg_menu_item_cb_data
*cb_data
;
504 cb_data
= g_object_get_data (G_OBJECT (widget
), XG_ITEM_DATA
);
505 if (! cb_data
) return;
507 help
= call_data
? cb_data
->help
: Qnil
;
509 /* If popup_activated_flag is greater than 1 we are in a popup menu.
510 Don't pass the frame to show_help_event for those.
511 Passing frame creates an Emacs event. As we are looping in
512 popup_widget_loop, it won't be handled. Passing NULL shows the tip
513 directly without using an Emacs event. This is what the Lucid code
515 show_help_event (popup_activated_flag
<= 1 ? cb_data
->cl_data
->f
: NULL
,
520 menu_highlight_callback (Widget widget
, LWLIB_ID id
, void *call_data
)
522 widget_value
*wv
= call_data
;
523 Lisp_Object help
= wv
? wv
->help
: Qnil
;
525 /* Determine the frame for the help event. */
526 struct frame
*f
= menubar_id_to_frame (id
);
528 show_help_event (f
, widget
, help
);
533 /* Gtk calls callbacks just because we tell it what item should be
534 selected in a radio group. If this variable is set to a non-zero
535 value, we are creating menus and don't want callbacks right now.
537 static bool xg_crazy_callback_abort
;
539 /* This callback is called from the menu bar pulldown menu
540 when the user makes a selection.
541 Figure out what the user chose
542 and put the appropriate events into the keyboard buffer. */
544 menubar_selection_callback (GtkWidget
*widget
, gpointer client_data
)
546 xg_menu_item_cb_data
*cb_data
= client_data
;
548 if (xg_crazy_callback_abort
)
551 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
554 /* For a group of radio buttons, GTK calls the selection callback first
555 for the item that was active before the selection and then for the one that
556 is active after the selection. For C-h k this means we get the help on
557 the deselected item and then the selected item is executed. Prevent that
558 by ignoring the non-active item. */
559 if (GTK_IS_RADIO_MENU_ITEM (widget
)
560 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
563 /* When a menu is popped down, X generates a focus event (i.e. focus
564 goes back to the frame below the menu). Since GTK buffers events,
565 we force it out here before the menu selection event. Otherwise
566 sit-for will exit at once if the focus event follows the menu selection
570 while (gtk_events_pending ())
571 gtk_main_iteration ();
574 find_and_call_menu_selection (cb_data
->cl_data
->f
,
575 cb_data
->cl_data
->menu_bar_items_used
,
576 cb_data
->cl_data
->menu_bar_vector
,
580 #else /* not USE_GTK */
582 /* This callback is called from the menu bar pulldown menu
583 when the user makes a selection.
584 Figure out what the user chose
585 and put the appropriate events into the keyboard buffer. */
587 menubar_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
591 f
= menubar_id_to_frame (id
);
594 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
595 f
->menu_bar_vector
, client_data
);
597 #endif /* not USE_GTK */
599 /* Recompute all the widgets of frame F, when the menu bar has been
603 update_frame_menubar (struct frame
*f
)
606 xg_update_frame_menubar (f
);
610 eassert (FRAME_X_P (f
));
612 x
= f
->output_data
.x
;
614 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
619 /* Do the voodoo which means "I'm changing lots of things, don't try
620 to refigure sizes until I'm done." */
621 lw_refigure_widget (x
->column_widget
, False
);
623 /* The order in which children are managed is the top to bottom
624 order in which they are displayed in the paned window. First,
625 remove the text-area widget. */
626 XtUnmanageChild (x
->edit_widget
);
628 /* Remove the menubar that is there now, and put up the menubar that
630 XtManageChild (x
->menubar_widget
);
631 XtMapWidget (x
->menubar_widget
);
632 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
634 /* Re-manage the text-area widget, and then thrash the sizes. */
635 XtManageChild (x
->edit_widget
);
636 lw_refigure_widget (x
->column_widget
, True
);
638 /* Force the pane widget to resize itself. */
641 /* For reasons I don't know Lucid wants to add one pixel to the frame
642 height when adding the menu bar. Compensate that here. */
643 new_height
= FRAME_TEXT_HEIGHT (f
) - 1;
644 #endif /* USE_LUCID */
645 adjust_frame_size (f
, -1, new_height
, 2, false, Qmenu_bar_lines
);
652 apply_systemfont_to_dialog (Widget w
)
654 const char *fn
= xsettings_get_system_normal_font ();
657 XrmDatabase db
= XtDatabase (XtDisplay (w
));
659 XrmPutStringResource (&db
, "*dialog.font", fn
);
664 apply_systemfont_to_menu (struct frame
*f
, Widget w
)
666 const char *fn
= xsettings_get_system_normal_font ();
670 XrmDatabase db
= XtDatabase (XtDisplay (w
));
673 XrmPutStringResource (&db
, "*menubar*font", fn
);
674 XrmPutStringResource (&db
, "*popup*font", fn
);
681 /* Set the contents of the menubar widgets of frame F.
682 The argument FIRST_TIME is currently ignored;
683 it is set the first time this is called, from initialize_frame_menubar. */
686 set_frame_menubar (struct frame
*f
, bool first_time
, bool deep_p
)
688 xt_or_gtk_widget menubar_widget
, old_widget
;
693 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
695 int *submenu_start
, *submenu_end
;
696 bool *submenu_top_level_items
;
697 int *submenu_n_panes
;
699 eassert (FRAME_X_P (f
));
701 menubar_widget
= old_widget
= f
->output_data
.x
->menubar_widget
;
703 XSETFRAME (Vmenu_updating_frame
, f
);
706 if (f
->output_data
.x
->id
== 0)
707 f
->output_data
.x
->id
= next_menubar_widget_id
++;
708 id
= f
->output_data
.x
->id
;
711 if (! menubar_widget
)
713 /* Make the first call for any given frame always go deep. */
714 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
717 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof (XEvent
));
718 f
->output_data
.x
->saved_menu_event
->type
= 0;
723 /* Make a widget-value tree representing the entire menu trees. */
725 struct buffer
*prev
= current_buffer
;
727 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
728 int previous_menu_items_used
= f
->menu_bar_items_used
;
729 Lisp_Object
*previous_items
730 = alloca (previous_menu_items_used
* sizeof *previous_items
);
733 /* If we are making a new widget, its contents are empty,
734 do always reinitialize them. */
735 if (! menubar_widget
)
736 previous_menu_items_used
= 0;
738 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->contents
;
739 specbind (Qinhibit_quit
, Qt
);
740 /* Don't let the debugger step into this code
741 because it is not reentrant. */
742 specbind (Qdebug_on_next_call
, Qnil
);
744 record_unwind_save_match_data ();
745 if (NILP (Voverriding_local_map_menu_flag
))
747 specbind (Qoverriding_terminal_local_map
, Qnil
);
748 specbind (Qoverriding_local_map
, Qnil
);
751 set_buffer_internal_1 (XBUFFER (buffer
));
753 /* Run the Lucid hook. */
754 safe_run_hooks (Qactivate_menubar_hook
);
756 /* If it has changed current-menubar from previous value,
757 really recompute the menubar from the value. */
758 if (! NILP (Vlucid_menu_bar_dirty_flag
))
759 call0 (Qrecompute_lucid_menubar
);
760 safe_run_hooks (Qmenu_bar_update_hook
);
761 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
763 items
= FRAME_MENU_BAR_ITEMS (f
);
765 /* Save the frame's previous menu bar contents data. */
766 if (previous_menu_items_used
)
767 memcpy (previous_items
, XVECTOR (f
->menu_bar_vector
)->contents
,
768 previous_menu_items_used
* word_size
);
770 /* Fill in menu_items with the current menu bar contents.
771 This can evaluate Lisp code. */
774 menu_items
= f
->menu_bar_vector
;
775 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
776 subitems
= ASIZE (items
) / 4;
777 submenu_start
= alloca ((subitems
+ 1) * sizeof *submenu_start
);
778 submenu_end
= alloca (subitems
* sizeof *submenu_end
);
779 submenu_n_panes
= alloca (subitems
* sizeof *submenu_n_panes
);
780 submenu_top_level_items
= alloca (subitems
781 * sizeof *submenu_top_level_items
);
783 for (i
= 0; i
< subitems
; i
++)
785 Lisp_Object key
, string
, maps
;
787 key
= AREF (items
, 4 * i
);
788 string
= AREF (items
, 4 * i
+ 1);
789 maps
= AREF (items
, 4 * i
+ 2);
793 submenu_start
[i
] = menu_items_used
;
795 menu_items_n_panes
= 0;
796 submenu_top_level_items
[i
]
797 = parse_single_submenu (key
, string
, maps
);
798 submenu_n_panes
[i
] = menu_items_n_panes
;
800 submenu_end
[i
] = menu_items_used
;
803 submenu_start
[i
] = -1;
804 finish_menu_items ();
806 /* Convert menu_items into widget_value trees
807 to display the menu. This cannot evaluate Lisp code. */
809 wv
= make_widget_value ("menubar", NULL
, true, Qnil
);
810 wv
->button_type
= BUTTON_TYPE_NONE
;
813 for (i
= 0; submenu_start
[i
] >= 0; i
++)
815 menu_items_n_panes
= submenu_n_panes
[i
];
816 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
817 submenu_top_level_items
[i
]);
821 first_wv
->contents
= wv
;
822 /* Don't set wv->name here; GC during the loop might relocate it. */
824 wv
->button_type
= BUTTON_TYPE_NONE
;
828 set_buffer_internal_1 (prev
);
830 /* If there has been no change in the Lisp-level contents
831 of the menu bar, skip redisplaying it. Just exit. */
833 /* Compare the new menu items with the ones computed last time. */
834 for (i
= 0; i
< previous_menu_items_used
; i
++)
835 if (menu_items_used
== i
836 || (!EQ (previous_items
[i
], AREF (menu_items
, i
))))
838 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
840 /* The menu items have not changed. Don't bother updating
841 the menus in any form, since it would be a no-op. */
842 free_menubar_widget_value_tree (first_wv
);
843 discard_menu_items ();
844 unbind_to (specpdl_count
, Qnil
);
848 /* The menu items are different, so store them in the frame. */
849 fset_menu_bar_vector (f
, menu_items
);
850 f
->menu_bar_items_used
= menu_items_used
;
852 /* This undoes save_menu_items. */
853 unbind_to (specpdl_count
, Qnil
);
855 /* Now GC cannot happen during the lifetime of the widget_value,
856 so it's safe to store data from a Lisp_String. */
857 wv
= first_wv
->contents
;
858 for (i
= 0; i
< ASIZE (items
); i
+= 4)
861 string
= AREF (items
, i
+ 1);
864 wv
->name
= SSDATA (string
);
865 update_submenu_strings (wv
->contents
);
872 /* Make a widget-value tree containing
873 just the top level menu bar strings. */
875 wv
= make_widget_value ("menubar", NULL
, true, Qnil
);
876 wv
->button_type
= BUTTON_TYPE_NONE
;
879 items
= FRAME_MENU_BAR_ITEMS (f
);
880 for (i
= 0; i
< ASIZE (items
); i
+= 4)
884 string
= AREF (items
, i
+ 1);
888 wv
= make_widget_value (SSDATA (string
), NULL
, true, Qnil
);
889 wv
->button_type
= BUTTON_TYPE_NONE
;
890 /* This prevents lwlib from assuming this
891 menu item is really supposed to be empty. */
892 /* The intptr_t cast avoids a warning.
893 This value just has to be different from small integers. */
894 wv
->call_data
= (void *) (intptr_t) (-1);
899 first_wv
->contents
= wv
;
903 /* Forget what we thought we knew about what is in the
904 detailed contents of the menu bar menus.
905 Changing the top level always destroys the contents. */
906 f
->menu_bar_items_used
= 0;
909 /* Create or update the menu bar widget. */
914 xg_crazy_callback_abort
= true;
917 /* The fourth arg is DEEP_P, which says to consider the entire
918 menu trees we supply, rather than just the menu bar item names. */
919 xg_modify_menubar_widgets (menubar_widget
,
923 G_CALLBACK (menubar_selection_callback
),
924 G_CALLBACK (popup_deactivate_callback
),
925 G_CALLBACK (menu_highlight_callback
));
930 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
931 G_CALLBACK (menubar_selection_callback
),
932 G_CALLBACK (popup_deactivate_callback
),
933 G_CALLBACK (menu_highlight_callback
));
935 f
->output_data
.x
->menubar_widget
= menubar_widget
;
939 #else /* not USE_GTK */
942 /* Disable resizing (done for Motif!) */
943 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
945 /* The third arg is DEEP_P, which says to consider the entire
946 menu trees we supply, rather than just the menu bar item names. */
947 lw_modify_all_widgets (id
, first_wv
, deep_p
);
949 /* Re-enable the edit widget to resize. */
950 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
954 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
955 XtTranslations override
= XtParseTranslationTable (menuOverride
);
958 apply_systemfont_to_menu (f
, f
->output_data
.x
->column_widget
);
960 menubar_widget
= lw_create_widget ("menubar", "menubar", id
,
962 f
->output_data
.x
->column_widget
,
964 popup_activate_callback
,
965 menubar_selection_callback
,
966 popup_deactivate_callback
,
967 menu_highlight_callback
);
968 f
->output_data
.x
->menubar_widget
= menubar_widget
;
970 /* Make menu pop down on C-g. */
971 XtOverrideTranslations (menubar_widget
, override
);
976 if (f
->output_data
.x
->menubar_widget
)
977 XtRealizeWidget (f
->output_data
.x
->menubar_widget
);
980 = (f
->output_data
.x
->menubar_widget
981 ? (f
->output_data
.x
->menubar_widget
->core
.height
982 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
986 /* Experimentally, we now get the right results
987 for -geometry -0-0 without this. 24 Aug 96, rms.
988 Maybe so, but the menu bar size is missing the pixels so the
989 WM size hints are off by these pixels. Jan D, oct 2009. */
990 if (FRAME_EXTERNAL_MENU_BAR (f
))
993 XtVaGetValues (f
->output_data
.x
->column_widget
,
994 XtNinternalBorderWidth
, &ibw
, NULL
);
997 #endif /* USE_LUCID */
999 FRAME_MENUBAR_HEIGHT (f
) = menubar_size
;
1001 #endif /* not USE_GTK */
1003 free_menubar_widget_value_tree (first_wv
);
1004 update_frame_menubar (f
);
1007 xg_crazy_callback_abort
= false;
1013 /* Called from Fx_create_frame to create the initial menubar of a frame
1014 before it is mapped, so that the window is mapped with the menubar already
1015 there instead of us tacking it on later and thrashing the window after it
1019 initialize_frame_menubar (struct frame
*f
)
1021 /* This function is called before the first chance to redisplay
1022 the frame. It has to be, so the frame will have the right size. */
1023 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
1024 set_frame_menubar (f
, true, true);
1028 /* Get rid of the menu bar of frame F, and free its storage.
1029 This is used when deleting a frame, and when turning off the menu bar.
1030 For GTK this function is in gtkutil.c. */
1034 free_frame_menubar (struct frame
*f
)
1036 Widget menubar_widget
;
1038 /* Motif automatically shrinks the frame in lw_destroy_all_widgets.
1039 If we want to preserve the old height, calculate it now so we can
1040 restore it below. */
1041 int old_height
= FRAME_TEXT_HEIGHT (f
) + FRAME_MENUBAR_HEIGHT (f
);
1044 eassert (FRAME_X_P (f
));
1046 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1048 FRAME_MENUBAR_HEIGHT (f
) = 0;
1053 /* Removing the menu bar magically changes the shell widget's x
1054 and y position of (0, 0) which, when the menu bar is turned
1055 on again, leads to pull-down menus appearing in strange
1056 positions near the upper-left corner of the display. This
1057 happens only with some window managers like twm and ctwm,
1058 but not with other like Motif's mwm or kwm, because the
1059 latter generate ConfigureNotify events when the menu bar
1060 is switched off, which fixes the shell position. */
1061 Position x0
, y0
, x1
, y1
;
1067 if (f
->output_data
.x
->widget
)
1068 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1071 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1072 f
->output_data
.x
->menubar_widget
= NULL
;
1074 if (f
->output_data
.x
->widget
)
1076 int new_height
= -1;
1078 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1079 if (x1
== 0 && y1
== 0)
1080 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1081 if (frame_inhibit_resize (f
, false, Qmenu_bar_lines
))
1082 new_height
= old_height
;
1083 #endif /* USE_MOTIF */
1084 adjust_frame_size (f
, -1, new_height
, 2, false, Qmenu_bar_lines
);
1089 if (frame_inhibit_resize (f
, false, Qmenu_bar_lines
))
1090 adjust_frame_size (f
, -1, old_height
, 1, false, Qmenu_bar_lines
);
1097 #endif /* not USE_GTK */
1099 #endif /* USE_X_TOOLKIT || USE_GTK */
1101 /* x_menu_show actually displays a menu using the panes and items in menu_items
1102 and returns the value selected from it.
1103 There are two versions of x_menu_show, one for Xt and one for Xlib.
1104 Both assume input is blocked by the caller. */
1106 /* F is the frame the menu is for.
1107 X and Y are the frame-relative specified position,
1108 relative to the inside upper left corner of the frame F.
1109 Bitfield MENUFLAGS bits are:
1110 MENU_FOR_CLICK is set if this menu was invoked for a mouse click.
1111 MENU_KEYMAPS is set if this menu was specified with keymaps;
1112 in that case, we return a list containing the chosen item's value
1113 and perhaps also the pane's prefix.
1114 TITLE is the specified menu title.
1115 ERROR is a place to store an error message string in case of failure.
1116 (We return nil on failure, but the value doesn't actually matter.) */
1118 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1120 /* The item selected in the popup menu. */
1121 static Lisp_Object
*volatile menu_item_selection
;
1125 /* Used when position a popup menu. See menu_position_func and
1126 create_and_show_popup_menu below. */
1127 struct next_popup_x_y
1134 /* The menu position function to use if we are not putting a popup
1135 menu where the pointer is.
1136 MENU is the menu to pop up.
1137 X and Y shall on exit contain x/y where the menu shall pop up.
1138 PUSH_IN is not documented in the GTK manual.
1139 USER_DATA is any data passed in when calling gtk_menu_popup.
1140 Here it points to a struct next_popup_x_y where the coordinates
1141 to store in *X and *Y are as well as the frame for the popup.
1143 Here only X and Y are used. */
1145 menu_position_func (GtkMenu
*menu
, gint
*x
, gint
*y
, gboolean
*push_in
, gpointer user_data
)
1147 struct next_popup_x_y
*data
= user_data
;
1149 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (data
->f
);
1150 int disp_width
= x_display_pixel_width (dpyinfo
);
1151 int disp_height
= x_display_pixel_height (dpyinfo
);
1156 /* Check if there is room for the menu. If not, adjust x/y so that
1157 the menu is fully visible. */
1158 gtk_widget_get_preferred_size (GTK_WIDGET (menu
), NULL
, &req
);
1159 if (data
->x
+ req
.width
> disp_width
)
1160 *x
-= data
->x
+ req
.width
- disp_width
;
1161 if (data
->y
+ req
.height
> disp_height
)
1162 *y
-= data
->y
+ req
.height
- disp_height
;
1166 popup_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1168 xg_menu_item_cb_data
*cb_data
= client_data
;
1170 if (xg_crazy_callback_abort
) return;
1171 if (cb_data
) menu_item_selection
= cb_data
->call_data
;
1175 pop_down_menu (void *arg
)
1177 popup_activated_flag
= 0;
1179 gtk_widget_destroy (GTK_WIDGET (arg
));
1183 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1185 menu_item_selection will be set to the selection. */
1187 create_and_show_popup_menu (struct frame
*f
, widget_value
*first_wv
,
1188 int x
, int y
, bool for_click
)
1192 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
1193 struct next_popup_x_y popup_x_y
;
1194 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1195 bool use_pos_func
= ! for_click
;
1198 /* Always use position function for Gtk3. Otherwise menus may become
1199 too small to show anything. */
1200 use_pos_func
= true;
1203 eassert (FRAME_X_P (f
));
1205 xg_crazy_callback_abort
= true;
1206 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
1207 G_CALLBACK (popup_selection_callback
),
1208 G_CALLBACK (popup_deactivate_callback
),
1209 G_CALLBACK (menu_highlight_callback
));
1210 xg_crazy_callback_abort
= false;
1214 Window dummy_window
;
1216 /* Not invoked by a click. pop up at x/y. */
1217 pos_func
= menu_position_func
;
1219 /* Adjust coordinates to be root-window-relative. */
1221 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
1223 /* From-window, to-window. */
1225 FRAME_DISPLAY_INFO (f
)->root_window
,
1227 /* From-position, to-position. */
1237 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1242 for (i
= 0; i
< 5; i
++)
1243 if (FRAME_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1245 /* If keys aren't grabbed (i.e., a mouse up event), use 0. */
1249 /* Display the menu. */
1250 gtk_widget_show_all (menu
);
1252 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
,
1253 FRAME_DISPLAY_INFO (f
)->last_user_time
);
1255 record_unwind_protect_ptr (pop_down_menu
, menu
);
1257 if (gtk_widget_get_mapped (menu
))
1259 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1260 two. show_help_echo uses this to detect popup menus. */
1261 popup_activated_flag
= 1;
1262 /* Process events that apply to the menu. */
1263 popup_widget_loop (true, menu
);
1266 unbind_to (specpdl_count
, Qnil
);
1268 /* Must reset this manually because the button release event is not passed
1269 to Emacs event loop. */
1270 FRAME_DISPLAY_INFO (f
)->grabbed
= 0;
1273 #else /* not USE_GTK */
1275 /* We need a unique id for each widget handled by the Lucid Widget
1278 For the main windows, and popup menus, we use this counter, which we
1279 increment each time after use. This starts from WIDGET_ID_TICK_START.
1281 For menu bars, we use numbers starting at 0, counted in
1282 next_menubar_widget_id. */
1283 LWLIB_ID widget_id_tick
;
1286 popup_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1288 menu_item_selection
= client_data
;
1291 /* ID is the LWLIB ID of the dialog box. */
1294 pop_down_menu (int id
)
1297 lw_destroy_all_widgets ((LWLIB_ID
) id
);
1299 popup_activated_flag
= 0;
1302 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1304 menu_item_selection will be set to the selection. */
1306 create_and_show_popup_menu (struct frame
*f
, widget_value
*first_wv
,
1307 int x
, int y
, bool for_click
)
1313 XButtonPressedEvent
*event
= &(dummy
.xbutton
);
1317 eassert (FRAME_X_P (f
));
1320 apply_systemfont_to_menu (f
, f
->output_data
.x
->widget
);
1323 menu_id
= widget_id_tick
++;
1324 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1325 f
->output_data
.x
->widget
, true, 0,
1326 popup_selection_callback
,
1327 popup_deactivate_callback
,
1328 menu_highlight_callback
);
1330 event
->type
= ButtonPress
;
1332 event
->send_event
= false;
1333 event
->display
= FRAME_X_DISPLAY (f
);
1334 event
->time
= CurrentTime
;
1335 event
->root
= FRAME_DISPLAY_INFO (f
)->root_window
;
1336 event
->window
= event
->subwindow
= event
->root
;
1340 /* Adjust coordinates to be root-window-relative. */
1341 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1342 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1349 for (i
= 0; i
< 5; i
++)
1350 if (FRAME_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1353 /* Don't allow any geometry request from the user. */
1354 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
1355 XtSetValues (menu
, av
, ac
);
1357 /* Display the menu. */
1358 lw_popup_menu (menu
, &dummy
);
1359 popup_activated_flag
= 1;
1360 x_activate_timeout_atimer ();
1363 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1365 record_unwind_protect_int (pop_down_menu
, (int) menu_id
);
1367 /* Process events that apply to the menu. */
1368 popup_get_selection (0, FRAME_DISPLAY_INFO (f
), menu_id
, true);
1370 unbind_to (specpdl_count
, Qnil
);
1374 #endif /* not USE_GTK */
1377 cleanup_widget_value_tree (void *arg
)
1379 free_menubar_widget_value_tree (arg
);
1383 x_menu_show (struct frame
*f
, int x
, int y
, int menuflags
,
1384 Lisp_Object title
, const char **error_name
)
1387 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1388 widget_value
**submenu_stack
1389 = alloca (menu_items_used
* sizeof *submenu_stack
);
1390 Lisp_Object
*subprefix_stack
1391 = alloca (menu_items_used
* sizeof *subprefix_stack
);
1392 int submenu_depth
= 0;
1394 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1396 eassert (FRAME_X_P (f
));
1400 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1402 *error_name
= "Empty menu";
1408 /* Create a tree of widget_value objects
1409 representing the panes and their items. */
1410 wv
= make_widget_value ("menu", NULL
, true, Qnil
);
1411 wv
->button_type
= BUTTON_TYPE_NONE
;
1413 bool first_pane
= true;
1415 /* Loop over all panes and items, filling in the tree. */
1417 while (i
< menu_items_used
)
1419 if (EQ (AREF (menu_items
, i
), Qnil
))
1421 submenu_stack
[submenu_depth
++] = save_wv
;
1427 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1430 save_wv
= submenu_stack
[--submenu_depth
];
1434 else if (EQ (AREF (menu_items
, i
), Qt
)
1435 && submenu_depth
!= 0)
1436 i
+= MENU_ITEMS_PANE_LENGTH
;
1437 /* Ignore a nil in the item list.
1438 It's meaningful only for dialog boxes. */
1439 else if (EQ (AREF (menu_items
, i
), Qquote
))
1441 else if (EQ (AREF (menu_items
, i
), Qt
))
1443 /* Create a new pane. */
1444 Lisp_Object pane_name
, prefix
;
1445 const char *pane_string
;
1447 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1448 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1450 #ifndef HAVE_MULTILINGUAL_MENU
1451 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1453 pane_name
= ENCODE_MENU_STRING (pane_name
);
1454 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1457 pane_string
= (NILP (pane_name
)
1458 ? "" : SSDATA (pane_name
));
1459 /* If there is just one top-level pane, put all its items directly
1460 under the top-level menu. */
1461 if (menu_items_n_panes
== 1)
1464 /* If the pane has a meaningful name,
1465 make the pane a top-level menu item
1466 with its items as a submenu beneath it. */
1467 if (!(menuflags
& MENU_KEYMAPS
) && strcmp (pane_string
, ""))
1469 wv
= make_widget_value (pane_string
, NULL
, true, Qnil
);
1473 first_wv
->contents
= wv
;
1474 if ((menuflags
& MENU_KEYMAPS
) && !NILP (prefix
))
1476 wv
->button_type
= BUTTON_TYPE_NONE
;
1480 else if (first_pane
)
1486 i
+= MENU_ITEMS_PANE_LENGTH
;
1490 /* Create a new item within current pane. */
1491 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
1492 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1493 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1494 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1495 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1496 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1497 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1498 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1500 #ifndef HAVE_MULTILINGUAL_MENU
1501 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
1503 item_name
= ENCODE_MENU_STRING (item_name
);
1504 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1507 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1509 descrip
= ENCODE_MENU_STRING (descrip
);
1510 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1512 #endif /* not HAVE_MULTILINGUAL_MENU */
1514 wv
= make_widget_value (SSDATA (item_name
), NULL
, !NILP (enable
),
1515 STRINGP (help
) ? help
: Qnil
);
1519 save_wv
->contents
= wv
;
1520 if (!NILP (descrip
))
1521 wv
->key
= SSDATA (descrip
);
1522 /* If this item has a null value,
1523 make the call_data null so that it won't display a box
1524 when the mouse is on it. */
1525 wv
->call_data
= !NILP (def
) ? aref_addr (menu_items
, i
) : 0;
1528 wv
->button_type
= BUTTON_TYPE_NONE
;
1529 else if (EQ (type
, QCtoggle
))
1530 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1531 else if (EQ (type
, QCradio
))
1532 wv
->button_type
= BUTTON_TYPE_RADIO
;
1536 wv
->selected
= !NILP (selected
);
1540 i
+= MENU_ITEMS_ITEM_LENGTH
;
1544 /* Deal with the title, if it is non-nil. */
1547 widget_value
*wv_title
;
1548 widget_value
*wv_sep1
= make_widget_value ("--", NULL
, false, Qnil
);
1549 widget_value
*wv_sep2
= make_widget_value ("--", NULL
, false, Qnil
);
1551 wv_sep2
->next
= first_wv
->contents
;
1552 wv_sep1
->next
= wv_sep2
;
1554 #ifndef HAVE_MULTILINGUAL_MENU
1555 if (STRING_MULTIBYTE (title
))
1556 title
= ENCODE_MENU_STRING (title
);
1559 wv_title
= make_widget_value (SSDATA (title
), NULL
, true, Qnil
);
1560 wv_title
->button_type
= BUTTON_TYPE_NONE
;
1561 wv_title
->next
= wv_sep1
;
1562 first_wv
->contents
= wv_title
;
1565 /* No selection has been chosen yet. */
1566 menu_item_selection
= 0;
1568 /* Make sure to free the widget_value objects we used to specify the
1569 contents even with longjmp. */
1570 record_unwind_protect_ptr (cleanup_widget_value_tree
, first_wv
);
1572 /* Actually create and show the menu until popped down. */
1573 create_and_show_popup_menu (f
, first_wv
, x
, y
,
1574 menuflags
& MENU_FOR_CLICK
);
1576 unbind_to (specpdl_count
, Qnil
);
1578 /* Find the selected item, and its pane, to return
1579 the proper value. */
1580 if (menu_item_selection
!= 0)
1582 Lisp_Object prefix
, entry
;
1584 prefix
= entry
= Qnil
;
1586 while (i
< menu_items_used
)
1588 if (EQ (AREF (menu_items
, i
), Qnil
))
1590 subprefix_stack
[submenu_depth
++] = prefix
;
1594 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1596 prefix
= subprefix_stack
[--submenu_depth
];
1599 else if (EQ (AREF (menu_items
, i
), Qt
))
1602 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1603 i
+= MENU_ITEMS_PANE_LENGTH
;
1605 /* Ignore a nil in the item list.
1606 It's meaningful only for dialog boxes. */
1607 else if (EQ (AREF (menu_items
, i
), Qquote
))
1612 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
1613 if (menu_item_selection
== aref_addr (menu_items
, i
))
1615 if (menuflags
& MENU_KEYMAPS
)
1619 entry
= list1 (entry
);
1621 entry
= Fcons (prefix
, entry
);
1622 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1623 if (!NILP (subprefix_stack
[j
]))
1624 entry
= Fcons (subprefix_stack
[j
], entry
);
1629 i
+= MENU_ITEMS_ITEM_LENGTH
;
1633 else if (!(menuflags
& MENU_FOR_CLICK
))
1636 /* Make "Cancel" equivalent to C-g. */
1637 Fsignal (Qquit
, Qnil
);
1646 dialog_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1648 /* Treat the pointer as an integer. There's no problem
1649 as long as pointers have enough bits to hold small integers. */
1650 if ((intptr_t) client_data
!= -1)
1651 menu_item_selection
= client_data
;
1653 popup_activated_flag
= 0;
1656 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1658 menu_item_selection will be set to the selection. */
1660 create_and_show_dialog (struct frame
*f
, widget_value
*first_wv
)
1664 eassert (FRAME_X_P (f
));
1666 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
1667 G_CALLBACK (dialog_selection_callback
),
1668 G_CALLBACK (popup_deactivate_callback
),
1673 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1674 record_unwind_protect_ptr (pop_down_menu
, menu
);
1676 /* Display the menu. */
1677 gtk_widget_show_all (menu
);
1679 /* Process events that apply to the menu. */
1680 popup_widget_loop (true, menu
);
1682 unbind_to (specpdl_count
, Qnil
);
1686 #else /* not USE_GTK */
1688 dialog_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1690 /* Treat the pointer as an integer. There's no problem
1691 as long as pointers have enough bits to hold small integers. */
1692 if ((intptr_t) client_data
!= -1)
1693 menu_item_selection
= client_data
;
1696 lw_destroy_all_widgets (id
);
1698 popup_activated_flag
= 0;
1702 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1704 menu_item_selection will be set to the selection. */
1706 create_and_show_dialog (struct frame
*f
, widget_value
*first_wv
)
1710 eassert (FRAME_X_P (f
));
1712 dialog_id
= widget_id_tick
++;
1714 apply_systemfont_to_dialog (f
->output_data
.x
->widget
);
1716 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1717 f
->output_data
.x
->widget
, true, 0,
1718 dialog_selection_callback
, 0, 0);
1719 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1720 /* Display the dialog box. */
1721 lw_pop_up_all_widgets (dialog_id
);
1722 popup_activated_flag
= 1;
1723 x_activate_timeout_atimer ();
1725 /* Process events that apply to the dialog box.
1726 Also handle timers. */
1728 ptrdiff_t count
= SPECPDL_INDEX ();
1730 /* xdialog_show_unwind is responsible for popping the dialog box down. */
1732 record_unwind_protect_int (pop_down_menu
, (int) dialog_id
);
1734 popup_get_selection (0, FRAME_DISPLAY_INFO (f
), dialog_id
, true);
1736 unbind_to (count
, Qnil
);
1740 #endif /* not USE_GTK */
1742 static const char * button_names
[] = {
1743 "button1", "button2", "button3", "button4", "button5",
1744 "button6", "button7", "button8", "button9", "button10" };
1747 x_dialog_show (struct frame
*f
, Lisp_Object title
,
1748 Lisp_Object header
, const char **error_name
)
1750 int i
, nb_buttons
=0;
1751 char dialog_name
[6];
1753 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
1755 /* Number of elements seen so far, before boundary. */
1757 /* Whether we've seen the boundary between left-hand elts and right-hand. */
1758 bool boundary_seen
= false;
1760 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1762 eassert (FRAME_X_P (f
));
1766 if (menu_items_n_panes
> 1)
1768 *error_name
= "Multiple panes in dialog box";
1772 /* Create a tree of widget_value objects
1773 representing the text label and buttons. */
1775 Lisp_Object pane_name
;
1776 const char *pane_string
;
1777 pane_name
= AREF (menu_items
, MENU_ITEMS_PANE_NAME
);
1778 pane_string
= (NILP (pane_name
)
1779 ? "" : SSDATA (pane_name
));
1780 prev_wv
= make_widget_value ("message", (char *) pane_string
, true, Qnil
);
1783 /* Loop over all panes and items, filling in the tree. */
1784 i
= MENU_ITEMS_PANE_LENGTH
;
1785 while (i
< menu_items_used
)
1788 /* Create a new item within current pane. */
1789 Lisp_Object item_name
, enable
, descrip
;
1790 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1791 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1793 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1795 if (NILP (item_name
))
1797 free_menubar_widget_value_tree (first_wv
);
1798 *error_name
= "Submenu in dialog items";
1801 if (EQ (item_name
, Qquote
))
1803 /* This is the boundary between left-side elts
1804 and right-side elts. Stop incrementing right_count. */
1805 boundary_seen
= true;
1809 if (nb_buttons
>= 9)
1811 free_menubar_widget_value_tree (first_wv
);
1812 *error_name
= "Too many dialog items";
1816 wv
= make_widget_value (button_names
[nb_buttons
],
1818 !NILP (enable
), Qnil
);
1820 if (!NILP (descrip
))
1821 wv
->key
= SSDATA (descrip
);
1822 wv
->call_data
= aref_addr (menu_items
, i
);
1825 if (! boundary_seen
)
1829 i
+= MENU_ITEMS_ITEM_LENGTH
;
1832 /* If the boundary was not specified,
1833 by default put half on the left and half on the right. */
1834 if (! boundary_seen
)
1835 left_count
= nb_buttons
- nb_buttons
/ 2;
1837 wv
= make_widget_value (dialog_name
, NULL
, false, Qnil
);
1839 /* Frame title: 'Q' = Question, 'I' = Information.
1840 Can also have 'E' = Error if, one day, we want
1841 a popup for errors. */
1843 dialog_name
[0] = 'Q';
1845 dialog_name
[0] = 'I';
1847 /* Dialog boxes use a really stupid name encoding
1848 which specifies how many buttons to use
1849 and how many buttons are on the right. */
1850 dialog_name
[1] = '0' + nb_buttons
;
1851 dialog_name
[2] = 'B';
1852 dialog_name
[3] = 'R';
1853 /* Number of buttons to put on the right. */
1854 dialog_name
[4] = '0' + nb_buttons
- left_count
;
1856 wv
->contents
= first_wv
;
1860 /* No selection has been chosen yet. */
1861 menu_item_selection
= 0;
1863 /* Make sure to free the widget_value objects we used to specify the
1864 contents even with longjmp. */
1865 record_unwind_protect_ptr (cleanup_widget_value_tree
, first_wv
);
1867 /* Actually create and show the dialog. */
1868 create_and_show_dialog (f
, first_wv
);
1870 unbind_to (specpdl_count
, Qnil
);
1872 /* Find the selected item, and its pane, to return
1873 the proper value. */
1874 if (menu_item_selection
!= 0)
1877 while (i
< menu_items_used
)
1881 if (EQ (AREF (menu_items
, i
), Qt
))
1882 i
+= MENU_ITEMS_PANE_LENGTH
;
1883 else if (EQ (AREF (menu_items
, i
), Qquote
))
1885 /* This is the boundary between left-side elts and
1892 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
1893 if (menu_item_selection
== aref_addr (menu_items
, i
))
1895 i
+= MENU_ITEMS_ITEM_LENGTH
;
1900 /* Make "Cancel" equivalent to C-g. */
1901 Fsignal (Qquit
, Qnil
);
1907 xw_popup_dialog (struct frame
*f
, Lisp_Object header
, Lisp_Object contents
)
1910 const char *error_name
;
1911 Lisp_Object selection
;
1912 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1914 check_window_system (f
);
1916 /* Decode the dialog items from what was specified. */
1917 title
= Fcar (contents
);
1918 CHECK_STRING (title
);
1919 record_unwind_protect_void (unuse_menu_items
);
1921 if (NILP (Fcar (Fcdr (contents
))))
1922 /* No buttons specified, add an "Ok" button so users can pop down
1923 the dialog. Also, the lesstif/motif version crashes if there are
1925 contents
= list2 (title
, Fcons (build_string ("Ok"), Qt
));
1927 list_of_panes (list1 (contents
));
1929 /* Display them in a dialog box. */
1931 selection
= x_dialog_show (f
, title
, header
, &error_name
);
1934 unbind_to (specpdl_count
, Qnil
);
1935 discard_menu_items ();
1937 if (error_name
) error ("%s", error_name
);
1941 #else /* not USE_X_TOOLKIT && not USE_GTK */
1943 /* The frame of the last activated non-toolkit menu bar.
1944 Used to generate menu help events. */
1946 static struct frame
*menu_help_frame
;
1949 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
1951 PANE is the pane number, and ITEM is the menu item number in
1952 the menu (currently not used).
1954 This cannot be done with generating a HELP_EVENT because
1955 XMenuActivate contains a loop that doesn't let Emacs process
1959 menu_help_callback (char const *help_string
, int pane
, int item
)
1961 Lisp_Object
*first_item
;
1962 Lisp_Object pane_name
;
1963 Lisp_Object menu_object
;
1965 first_item
= XVECTOR (menu_items
)->contents
;
1966 if (EQ (first_item
[0], Qt
))
1967 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
1968 else if (EQ (first_item
[0], Qquote
))
1969 /* This shouldn't happen, see x_menu_show. */
1970 pane_name
= empty_unibyte_string
;
1972 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
1974 /* (menu-item MENU-NAME PANE-NUMBER) */
1975 menu_object
= list3 (Qmenu_item
, pane_name
, make_number (pane
));
1976 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
1977 Qnil
, menu_object
, make_number (item
));
1981 pop_down_menu (Lisp_Object arg
)
1983 struct frame
*f
= XSAVE_POINTER (arg
, 0);
1984 XMenu
*menu
= XSAVE_POINTER (arg
, 1);
1988 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
1989 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
1991 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
1993 #ifdef HAVE_X_WINDOWS
1994 /* Assume the mouse has moved out of the X window.
1995 If it has actually moved in, we will get an EnterNotify. */
1996 x_mouse_leave (FRAME_DISPLAY_INFO (f
));
1998 /* State that no mouse buttons are now held.
1999 (The oldXMenu code doesn't track this info for us.)
2000 That is not necessarily true, but the fiction leads to reasonable
2001 results, and it is a pain to ask which are actually held now. */
2002 FRAME_DISPLAY_INFO (f
)->grabbed
= 0;
2004 #endif /* HAVE_X_WINDOWS */
2011 x_menu_show (struct frame
*f
, int x
, int y
, int menuflags
,
2012 Lisp_Object title
, const char **error_name
)
2016 int pane
, selidx
, lpane
, status
;
2017 Lisp_Object entry
= Qnil
;
2018 Lisp_Object pane_prefix
;
2020 int ulx
, uly
, width
, height
;
2021 int dispwidth
, dispheight
;
2022 int i
, j
, lines
, maxlines
;
2025 unsigned int dummy_uint
;
2026 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
2028 eassert (FRAME_X_P (f
) || FRAME_MSDOS_P (f
));
2031 if (menu_items_n_panes
== 0)
2034 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2036 *error_name
= "Empty menu";
2043 /* Figure out which root window F is on. */
2044 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2045 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2046 &dummy_uint
, &dummy_uint
);
2048 /* Make the menu on that window. */
2049 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2052 *error_name
= "Can't create menu";
2056 /* Don't GC while we prepare and show the menu,
2057 because we give the oldxmenu library pointers to the
2058 contents of strings. */
2059 inhibit_garbage_collection ();
2061 #ifdef HAVE_X_WINDOWS
2062 /* Adjust coordinates to relative to the outer (window manager) window. */
2063 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
2064 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2065 #endif /* HAVE_X_WINDOWS */
2067 /* Adjust coordinates to be root-window-relative. */
2071 /* Create all the necessary panes and their items. */
2072 maxwidth
= maxlines
= lines
= i
= 0;
2074 while (i
< menu_items_used
)
2076 if (EQ (AREF (menu_items
, i
), Qt
))
2078 /* Create a new pane. */
2079 Lisp_Object pane_name
, prefix
;
2080 const char *pane_string
;
2082 maxlines
= max (maxlines
, lines
);
2084 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2085 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2086 pane_string
= (NILP (pane_name
)
2087 ? "" : SSDATA (pane_name
));
2088 if ((menuflags
& MENU_KEYMAPS
) && !NILP (prefix
))
2091 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, true);
2092 if (lpane
== XM_FAILURE
)
2094 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2095 *error_name
= "Can't create pane";
2098 i
+= MENU_ITEMS_PANE_LENGTH
;
2100 /* Find the width of the widest item in this pane. */
2102 while (j
< menu_items_used
)
2105 item
= AREF (menu_items
, j
);
2113 width
= SBYTES (item
);
2114 if (width
> maxwidth
)
2117 j
+= MENU_ITEMS_ITEM_LENGTH
;
2120 /* Ignore a nil in the item list.
2121 It's meaningful only for dialog boxes. */
2122 else if (EQ (AREF (menu_items
, i
), Qquote
))
2126 /* Create a new item within current pane. */
2127 Lisp_Object item_name
, enable
, descrip
, help
;
2129 char const *help_string
;
2131 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2132 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2134 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2135 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2136 help_string
= STRINGP (help
) ? SSDATA (help
) : NULL
;
2138 if (!NILP (descrip
))
2140 item_data
= SAFE_ALLOCA (maxwidth
+ SBYTES (descrip
) + 1);
2141 memcpy (item_data
, SSDATA (item_name
), SBYTES (item_name
));
2142 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
2144 memcpy (item_data
+ j
, SSDATA (descrip
), SBYTES (descrip
));
2145 item_data
[j
+ SBYTES (descrip
)] = 0;
2148 item_data
= SSDATA (item_name
);
2150 if (lpane
== XM_FAILURE
2151 || (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2152 menu
, lpane
, 0, item_data
,
2153 !NILP (enable
), help_string
)
2156 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2157 *error_name
= "Can't add selection to menu";
2160 i
+= MENU_ITEMS_ITEM_LENGTH
;
2165 maxlines
= max (maxlines
, lines
);
2167 /* All set and ready to fly. */
2168 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2169 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2170 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2171 x
= min (x
, dispwidth
);
2172 y
= min (y
, dispheight
);
2175 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2176 &ulx
, &uly
, &width
, &height
);
2177 if (ulx
+width
> dispwidth
)
2179 x
-= (ulx
+ width
) - dispwidth
;
2180 ulx
= dispwidth
- width
;
2182 if (uly
+height
> dispheight
)
2184 y
-= (uly
+ height
) - dispheight
;
2185 uly
= dispheight
- height
;
2187 #ifndef HAVE_X_WINDOWS
2188 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 1)
2190 /* Move the menu away of the echo area, to avoid overwriting the
2191 menu with help echo messages or vice versa. */
2192 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
2194 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2195 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2204 if (ulx
< 0) x
-= ulx
;
2205 if (uly
< 0) y
-= uly
;
2207 if (!(menuflags
& MENU_FOR_CLICK
))
2209 /* If position was not given by a mouse click, adjust so upper left
2210 corner of the menu as a whole ends up at given coordinates. This
2211 is what x-popup-menu says in its documentation. */
2213 y
+= 1.5*height
/(maxlines
+2);
2216 XMenuSetAEQ (menu
, true);
2217 XMenuSetFreeze (menu
, true);
2221 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
2224 record_unwind_protect (pop_down_menu
, make_save_ptr_ptr (f
, menu
));
2226 /* Help display under X won't work because XMenuActivate contains
2227 a loop that doesn't give Emacs a chance to process it. */
2228 menu_help_frame
= f
;
2229 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2230 x
, y
, ButtonReleaseMask
, &datap
,
2231 menu_help_callback
);
2238 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2241 /* Find the item number SELIDX in pane number PANE. */
2243 while (i
< menu_items_used
)
2245 if (EQ (AREF (menu_items
, i
), Qt
))
2249 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2251 i
+= MENU_ITEMS_PANE_LENGTH
;
2260 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
2261 if (menuflags
& MENU_KEYMAPS
)
2263 entry
= list1 (entry
);
2264 if (!NILP (pane_prefix
))
2265 entry
= Fcons (pane_prefix
, entry
);
2271 i
+= MENU_ITEMS_ITEM_LENGTH
;
2277 *error_name
= "Can't activate menu";
2281 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2282 the menu was invoked with a mouse event as POSITION). */
2283 if (!(menuflags
& MENU_FOR_CLICK
))
2286 Fsignal (Qquit
, Qnil
);
2294 return unbind_to (specpdl_count
, entry
);
2297 #endif /* not USE_X_TOOLKIT */
2300 /* Detect if a dialog or menu has been posted. MSDOS has its own
2301 implementation on msdos.c. */
2304 popup_activated (void)
2306 return popup_activated_flag
;
2308 #endif /* not MSDOS */
2310 /* The following is used by delayed window autoselection. */
2312 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
2313 doc
: /* Return t if a menu or popup dialog is active. */)
2316 return (popup_activated ()) ? Qt
: Qnil
;
2320 syms_of_xmenu (void)
2322 #ifdef USE_X_TOOLKIT
2323 enum { WIDGET_ID_TICK_START
= 1 << 16 };
2324 widget_id_tick
= WIDGET_ID_TICK_START
;
2325 next_menubar_widget_id
= 1;
2328 DEFSYM (Qdebug_on_next_call
, "debug-on-next-call");
2329 defsubr (&Smenu_or_popup_active_p
);
2331 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2332 defsubr (&Sx_menu_bar_open_internal
);
2333 Ffset (intern_c_string ("accelerate-menu"),
2334 intern_c_string (Sx_menu_bar_open_internal
.symbol_name
));