1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2013 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"
111 static Lisp_Object Qdebug_on_next_call
;
113 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
114 static Lisp_Object
xdialog_show (struct frame
*, bool, Lisp_Object
, Lisp_Object
,
118 /* Flag which when set indicates a dialog or menu has been posted by
119 Xt on behalf of one of the widget sets. */
120 static int popup_activated_flag
;
125 static int next_menubar_widget_id
;
127 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
129 static struct frame
*
130 menubar_id_to_frame (LWLIB_ID id
)
132 Lisp_Object tail
, frame
;
135 FOR_EACH_FRAME (tail
, frame
)
138 if (!FRAME_WINDOW_P (f
))
140 if (f
->output_data
.x
->id
== id
)
148 #ifdef HAVE_X_WINDOWS
149 /* Return the mouse position in *X and *Y. The coordinates are window
150 relative for the edit window in frame F.
151 This is for Fx_popup_menu. The mouse_position_hook can not
152 be used for X, as it returns window relative coordinates
153 for the window where the mouse is in. This could be the menu bar,
154 the scroll bar or the edit window. Fx_popup_menu needs to be
155 sure it is the edit window. */
157 mouse_position_for_popup (struct frame
*f
, int *x
, int *y
)
159 Window root
, dummy_window
;
162 eassert (FRAME_X_P (f
));
166 XQueryPointer (FRAME_X_DISPLAY (f
),
167 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
169 /* The root window which contains the pointer. */
172 /* Window pointer is on, not used */
175 /* The position on that root window. */
178 /* x/y in dummy_window coordinates, not used. */
181 /* Modifier keys and pointer buttons, about which
183 (unsigned int *) &dummy
);
187 /* xmenu_show expects window coordinates, not root window
188 coordinates. Translate. */
189 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
190 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
193 #endif /* HAVE_X_WINDOWS */
197 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
198 doc
: /* Pop up a dialog box and return user's selection.
199 POSITION specifies which frame to use.
200 This is normally a mouse button event or a window or frame.
201 If POSITION is t, it means to use the frame the mouse is on.
202 The dialog box appears in the middle of the specified frame.
204 CONTENTS specifies the alternatives to display in the dialog box.
205 It is a list of the form (DIALOG ITEM1 ITEM2...).
206 Each ITEM is a cons cell (STRING . VALUE).
207 The return value is VALUE from the chosen item.
209 An ITEM may also be just a string--that makes a nonselectable item.
210 An ITEM may also be nil--that means to put all preceding items
211 on the left of the dialog box and all following items on the right.
212 \(By default, approximately half appear on each side.)
214 If HEADER is non-nil, the frame title for the box is "Information",
215 otherwise it is "Question".
217 If the user gets rid of the dialog box without making a valid choice,
218 for instance using the window manager, then this produces a quit and
219 `x-popup-dialog' does not return. */)
220 (Lisp_Object position
, Lisp_Object contents
, Lisp_Object header
)
222 struct frame
*f
= NULL
;
225 /* Decode the first argument: find the window or frame to use. */
226 if (EQ (position
, Qt
)
227 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
228 || EQ (XCAR (position
), Qtool_bar
))))
230 #if 0 /* Using the frame the mouse is on may not be right. */
231 /* Use the mouse's current position. */
232 struct frame
*new_f
= SELECTED_FRAME ();
233 Lisp_Object bar_window
;
234 enum scroll_bar_part part
;
238 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
241 XSETFRAME (window
, new_f
);
243 window
= selected_window
;
245 window
= selected_window
;
247 else if (CONSP (position
))
249 Lisp_Object tem
= XCAR (position
);
251 window
= Fcar (XCDR (position
));
254 tem
= Fcar (XCDR (position
)); /* EVENT_START (position) */
255 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
258 else if (WINDOWP (position
) || FRAMEP (position
))
263 /* Decode where to put the menu. */
267 else if (WINDOWP (window
))
269 CHECK_LIVE_WINDOW (window
);
270 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
273 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
274 but I don't want to make one now. */
275 CHECK_WINDOW (window
);
277 check_window_system (f
);
279 /* Force a redisplay before showing the dialog. If a frame is created
280 just before showing the dialog, its contents may not have been fully
281 drawn, as this depends on timing of events from the X server. Redisplay
282 is not done when a dialog is shown. If redisplay could be done in the
283 X event loop (i.e. the X event loop does not run in a signal handler)
284 this would not be needed.
286 Do this before creating the widget value that points to Lisp
287 string contents, because Fredisplay may GC and relocate them. */
290 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
291 /* Display a menu with these alternatives
292 in the middle of frame F. */
294 Lisp_Object x
, y
, frame
, newpos
;
295 XSETFRAME (frame
, f
);
296 XSETINT (x
, FRAME_PIXEL_WIDTH (f
) / 2);
297 XSETINT (y
, FRAME_PIXEL_HEIGHT (f
) / 2);
298 newpos
= list2 (list2 (x
, y
), frame
);
300 return Fx_popup_menu (newpos
,
301 list2 (Fcar (contents
), contents
));
306 const char *error_name
;
307 Lisp_Object selection
;
308 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
310 /* Decode the dialog items from what was specified. */
311 title
= Fcar (contents
);
312 CHECK_STRING (title
);
313 record_unwind_protect_void (unuse_menu_items
);
315 if (NILP (Fcar (Fcdr (contents
))))
316 /* No buttons specified, add an "Ok" button so users can pop down
317 the dialog. Also, the lesstif/motif version crashes if there are
319 contents
= list2 (title
, Fcons (build_string ("Ok"), Qt
));
321 list_of_panes (list1 (contents
));
323 /* Display them in a dialog box. */
325 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
328 unbind_to (specpdl_count
, Qnil
);
329 discard_menu_items ();
331 if (error_name
) error ("%s", error_name
);
340 #if defined USE_GTK || defined USE_MOTIF
342 /* Set menu_items_inuse so no other popup menu or dialog is created. */
345 x_menu_set_in_use (int in_use
)
347 menu_items_inuse
= in_use
? Qt
: Qnil
;
348 popup_activated_flag
= in_use
;
350 if (popup_activated_flag
)
351 x_activate_timeout_atimer ();
357 /* Wait for an X event to arrive or for a timer to expire. */
363 x_menu_wait_for_event (void *data
)
365 /* Another way to do this is to register a timer callback, that can be
366 done in GTK and Xt. But we have to do it like this when using only X
367 anyway, and with callbacks we would have three variants for timer handling
368 instead of the small ifdefs below. */
372 ! XtAppPending (Xt_app_con
)
373 #elif defined USE_GTK
374 ! gtk_events_pending ()
380 struct timespec next_time
= timer_check (), *ntp
;
382 struct x_display_info
*dpyinfo
;
386 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
388 int fd
= ConnectionNumber (dpyinfo
->display
);
389 FD_SET (fd
, &read_fds
);
391 XFlush (dpyinfo
->display
);
394 if (! timespec_valid_p (next_time
))
399 #if defined USE_GTK && defined HAVE_GTK3
400 /* Gtk3 have arrows on menus when they don't fit. When the
401 pointer is over an arrow, a timeout scrolls it a bit. Use
402 xg_select so that timeout gets triggered. */
403 xg_select (n
+ 1, &read_fds
, NULL
, NULL
, ntp
, NULL
);
405 pselect (n
+ 1, &read_fds
, NULL
, NULL
, ntp
, NULL
);
412 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
416 /* Loop in Xt until the menu pulldown or dialog popup has been
417 popped down (deactivated). This is used for x-popup-menu
418 and x-popup-dialog; it is not used for the menu bar.
420 NOTE: All calls to popup_get_selection should be protected
421 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
424 popup_get_selection (XEvent
*initial_event
, struct x_display_info
*dpyinfo
, LWLIB_ID id
, int do_timers
)
428 while (popup_activated_flag
)
432 event
= *initial_event
;
437 if (do_timers
) x_menu_wait_for_event (0);
438 XtAppNextEvent (Xt_app_con
, &event
);
441 /* Make sure we don't consider buttons grabbed after menu goes.
442 And make sure to deactivate for any ButtonRelease,
443 even if XtDispatchEvent doesn't do that. */
444 if (event
.type
== ButtonRelease
445 && dpyinfo
->display
== event
.xbutton
.display
)
447 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
448 #ifdef USE_MOTIF /* Pretending that the event came from a
449 Btn1Down seems the only way to convince Motif to
450 activate its callbacks; setting the XmNmenuPost
451 isn't working. --marcus@sysc.pdx.edu. */
452 event
.xbutton
.button
= 1;
453 /* Motif only pops down menus when no Ctrl, Alt or Mod
454 key is pressed and the button is released. So reset key state
455 so Motif thinks this is the case. */
456 event
.xbutton
.state
= 0;
459 /* Pop down on C-g and Escape. */
460 else if (event
.type
== KeyPress
461 && dpyinfo
->display
== event
.xbutton
.display
)
463 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
465 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
466 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
467 popup_activated_flag
= 0;
470 x_dispatch_event (&event
, event
.xany
.display
);
474 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
475 doc
: /* Start key navigation of the menu bar in FRAME.
476 This initially opens the first menu bar item and you can then navigate with the
477 arrow keys, select a menu entry with the return key or cancel with the
478 escape key. If FRAME has no menu bar this function does nothing.
480 If FRAME is nil or not given, use the selected frame. */)
484 struct frame
*f
= decode_window_system_frame (frame
);
488 if (FRAME_EXTERNAL_MENU_BAR (f
))
489 set_frame_menubar (f
, 0, 1);
491 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
497 x_catch_errors (FRAME_X_DISPLAY (f
));
498 memset (&ev
, 0, sizeof ev
);
499 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
500 ev
.xbutton
.window
= XtWindow (menubar
);
501 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
502 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
503 ev
.xbutton
.button
= Button1
;
504 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
505 ev
.xbutton
.same_screen
= True
;
512 XtSetArg (al
[0], XtNchildren
, &list
);
513 XtSetArg (al
[1], XtNnumChildren
, &nr
);
514 XtGetValues (menubar
, al
, 2);
515 ev
.xbutton
.window
= XtWindow (list
[0]);
519 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
520 /* From-window, to-window. */
521 ev
.xbutton
.window
, ev
.xbutton
.root
,
523 /* From-position, to-position. */
524 ev
.xbutton
.x
, ev
.xbutton
.y
,
525 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
529 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
534 ev
.type
= ButtonPress
;
535 ev
.xbutton
.state
= 0;
537 XtDispatchEvent (&ev
);
538 ev
.xbutton
.type
= ButtonRelease
;
539 ev
.xbutton
.state
= Button1Mask
;
540 XtDispatchEvent (&ev
);
548 #endif /* USE_X_TOOLKIT */
552 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
553 doc
: /* Start key navigation of the menu bar in FRAME.
554 This initially opens the first menu bar item and you can then navigate with the
555 arrow keys, select a menu entry with the return key or cancel with the
556 escape key. If FRAME has no menu bar this function does nothing.
558 If FRAME is nil or not given, use the selected frame. */)
565 f
= decode_window_system_frame (frame
);
567 if (FRAME_EXTERNAL_MENU_BAR (f
))
568 set_frame_menubar (f
, 0, 1);
570 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
573 /* Activate the first menu. */
574 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
578 g_signal_emit_by_name (children
->data
, "activate_item");
579 popup_activated_flag
= 1;
580 g_list_free (children
);
588 /* Loop util popup_activated_flag is set to zero in a callback.
589 Used for popup menus and dialogs. */
592 popup_widget_loop (int do_timers
, GtkWidget
*widget
)
594 ++popup_activated_flag
;
596 /* Process events in the Gtk event loop until done. */
597 while (popup_activated_flag
)
599 if (do_timers
) x_menu_wait_for_event (0);
600 gtk_main_iteration ();
605 /* Activate the menu bar of frame F.
606 This is called from keyboard.c when it gets the
607 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
609 To activate the menu bar, we use the X button-press event
610 that was saved in saved_menu_event.
611 That makes the toolkit do its thing.
613 But first we recompute the menu bar contents (the whole tree).
615 The reason for saving the button event until here, instead of
616 passing it to the toolkit right away, is that we can safely
617 execute Lisp code. */
620 x_activate_menubar (struct frame
*f
)
622 eassert (FRAME_X_P (f
));
624 if (!f
->output_data
.x
->saved_menu_event
->type
)
628 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
629 f
->output_data
.x
->saved_menu_event
->xany
.window
))
633 set_frame_menubar (f
, 0, 1);
635 popup_activated_flag
= 1;
637 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
638 f
->output_data
.x
->saved_menu_event
);
640 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
644 /* Ignore this if we get it a second time. */
645 f
->output_data
.x
->saved_menu_event
->type
= 0;
648 /* This callback is invoked when the user selects a menubar cascade
649 pushbutton, but before the pulldown menu is posted. */
653 popup_activate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
655 popup_activated_flag
= 1;
657 x_activate_timeout_atimer ();
662 /* This callback is invoked when a dialog or menu is finished being
663 used and has been unposted. */
666 popup_deactivate_callback (
668 GtkWidget
*widget
, gpointer client_data
670 Widget widget
, LWLIB_ID id
, XtPointer client_data
674 popup_activated_flag
= 0;
678 /* Function that finds the frame for WIDGET and shows the HELP text
680 F is the frame if known, or NULL if not known. */
682 show_help_event (struct frame
*f
, xt_or_gtk_widget widget
, Lisp_Object help
)
688 XSETFRAME (frame
, f
);
689 kbd_buffer_store_help_event (frame
, help
);
693 #if 0 /* This code doesn't do anything useful. ++kfs */
694 /* WIDGET is the popup menu. It's parent is the frame's
695 widget. See which frame that is. */
696 xt_or_gtk_widget frame_widget
= XtParent (widget
);
699 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
703 && (f
= XFRAME (frame
),
704 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
708 show_help_echo (help
, Qnil
, Qnil
, Qnil
);
712 /* Callback called when menu items are highlighted/unhighlighted
713 while moving the mouse over them. WIDGET is the menu bar or menu
714 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
715 the data structure for the menu item, or null in case of
720 menu_highlight_callback (GtkWidget
*widget
, gpointer call_data
)
722 xg_menu_item_cb_data
*cb_data
;
725 cb_data
= g_object_get_data (G_OBJECT (widget
), XG_ITEM_DATA
);
726 if (! cb_data
) return;
728 help
= call_data
? cb_data
->help
: Qnil
;
730 /* If popup_activated_flag is greater than 1 we are in a popup menu.
731 Don't pass the frame to show_help_event for those.
732 Passing frame creates an Emacs event. As we are looping in
733 popup_widget_loop, it won't be handled. Passing NULL shows the tip
734 directly without using an Emacs event. This is what the Lucid code
736 show_help_event (popup_activated_flag
<= 1 ? cb_data
->cl_data
->f
: NULL
,
741 menu_highlight_callback (Widget widget
, LWLIB_ID id
, void *call_data
)
743 widget_value
*wv
= call_data
;
744 Lisp_Object help
= wv
? wv
->help
: Qnil
;
746 /* Determine the frame for the help event. */
747 struct frame
*f
= menubar_id_to_frame (id
);
749 show_help_event (f
, widget
, help
);
754 /* Gtk calls callbacks just because we tell it what item should be
755 selected in a radio group. If this variable is set to a non-zero
756 value, we are creating menus and don't want callbacks right now.
758 static int xg_crazy_callback_abort
;
760 /* This callback is called from the menu bar pulldown menu
761 when the user makes a selection.
762 Figure out what the user chose
763 and put the appropriate events into the keyboard buffer. */
765 menubar_selection_callback (GtkWidget
*widget
, gpointer client_data
)
767 xg_menu_item_cb_data
*cb_data
= client_data
;
769 if (xg_crazy_callback_abort
)
772 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
775 /* For a group of radio buttons, GTK calls the selection callback first
776 for the item that was active before the selection and then for the one that
777 is active after the selection. For C-h k this means we get the help on
778 the deselected item and then the selected item is executed. Prevent that
779 by ignoring the non-active item. */
780 if (GTK_IS_RADIO_MENU_ITEM (widget
)
781 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
784 /* When a menu is popped down, X generates a focus event (i.e. focus
785 goes back to the frame below the menu). Since GTK buffers events,
786 we force it out here before the menu selection event. Otherwise
787 sit-for will exit at once if the focus event follows the menu selection
791 while (gtk_events_pending ())
792 gtk_main_iteration ();
795 find_and_call_menu_selection (cb_data
->cl_data
->f
,
796 cb_data
->cl_data
->menu_bar_items_used
,
797 cb_data
->cl_data
->menu_bar_vector
,
801 #else /* not USE_GTK */
803 /* This callback is called from the menu bar pulldown menu
804 when the user makes a selection.
805 Figure out what the user chose
806 and put the appropriate events into the keyboard buffer. */
808 menubar_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
812 f
= menubar_id_to_frame (id
);
815 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
816 f
->menu_bar_vector
, client_data
);
818 #endif /* not USE_GTK */
820 /* Recompute all the widgets of frame F, when the menu bar has been
824 update_frame_menubar (struct frame
*f
)
827 xg_update_frame_menubar (f
);
832 eassert (FRAME_X_P (f
));
834 x
= f
->output_data
.x
;
836 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
840 /* Save the size of the frame because the pane widget doesn't accept
841 to resize itself. So force it. */
842 columns
= FRAME_COLS (f
);
843 rows
= FRAME_LINES (f
);
845 /* Do the voodoo which means "I'm changing lots of things, don't try
846 to refigure sizes until I'm done." */
847 lw_refigure_widget (x
->column_widget
, False
);
849 /* The order in which children are managed is the top to bottom
850 order in which they are displayed in the paned window. First,
851 remove the text-area widget. */
852 XtUnmanageChild (x
->edit_widget
);
854 /* Remove the menubar that is there now, and put up the menubar that
856 XtManageChild (x
->menubar_widget
);
857 XtMapWidget (x
->menubar_widget
);
858 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
860 /* Re-manage the text-area widget, and then thrash the sizes. */
861 XtManageChild (x
->edit_widget
);
862 lw_refigure_widget (x
->column_widget
, True
);
864 /* Force the pane widget to resize itself with the right values. */
865 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
872 apply_systemfont_to_dialog (Widget w
)
874 const char *fn
= xsettings_get_system_normal_font ();
877 XrmDatabase db
= XtDatabase (XtDisplay (w
));
879 XrmPutStringResource (&db
, "*dialog.font", fn
);
884 apply_systemfont_to_menu (struct frame
*f
, Widget w
)
886 const char *fn
= xsettings_get_system_normal_font ();
890 XrmDatabase db
= XtDatabase (XtDisplay (w
));
893 XrmPutStringResource (&db
, "*menubar*font", fn
);
894 XrmPutStringResource (&db
, "*popup*font", fn
);
901 /* Set the contents of the menubar widgets of frame F.
902 The argument FIRST_TIME is currently ignored;
903 it is set the first time this is called, from initialize_frame_menubar. */
906 set_frame_menubar (struct frame
*f
, bool first_time
, bool deep_p
)
908 xt_or_gtk_widget menubar_widget
;
913 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
915 int *submenu_start
, *submenu_end
;
916 bool *submenu_top_level_items
;
917 int *submenu_n_panes
;
919 eassert (FRAME_X_P (f
));
921 menubar_widget
= f
->output_data
.x
->menubar_widget
;
923 XSETFRAME (Vmenu_updating_frame
, f
);
926 if (f
->output_data
.x
->id
== 0)
927 f
->output_data
.x
->id
= next_menubar_widget_id
++;
928 id
= f
->output_data
.x
->id
;
931 if (! menubar_widget
)
933 /* Make the first call for any given frame always go deep. */
934 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
937 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof (XEvent
));
938 f
->output_data
.x
->saved_menu_event
->type
= 0;
942 /* If we have detached menus, we must update deep so detached menus
943 also gets updated. */
944 deep_p
= deep_p
|| xg_have_tear_offs ();
949 /* Make a widget-value tree representing the entire menu trees. */
951 struct buffer
*prev
= current_buffer
;
953 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
954 int previous_menu_items_used
= f
->menu_bar_items_used
;
955 Lisp_Object
*previous_items
956 = alloca (previous_menu_items_used
* sizeof *previous_items
);
959 /* If we are making a new widget, its contents are empty,
960 do always reinitialize them. */
961 if (! menubar_widget
)
962 previous_menu_items_used
= 0;
964 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->contents
;
965 specbind (Qinhibit_quit
, Qt
);
966 /* Don't let the debugger step into this code
967 because it is not reentrant. */
968 specbind (Qdebug_on_next_call
, Qnil
);
970 record_unwind_save_match_data ();
971 if (NILP (Voverriding_local_map_menu_flag
))
973 specbind (Qoverriding_terminal_local_map
, Qnil
);
974 specbind (Qoverriding_local_map
, Qnil
);
977 set_buffer_internal_1 (XBUFFER (buffer
));
979 /* Run the Lucid hook. */
980 safe_run_hooks (Qactivate_menubar_hook
);
982 /* If it has changed current-menubar from previous value,
983 really recompute the menubar from the value. */
984 if (! NILP (Vlucid_menu_bar_dirty_flag
))
985 call0 (Qrecompute_lucid_menubar
);
986 safe_run_hooks (Qmenu_bar_update_hook
);
987 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
989 items
= FRAME_MENU_BAR_ITEMS (f
);
991 /* Save the frame's previous menu bar contents data. */
992 if (previous_menu_items_used
)
993 memcpy (previous_items
, XVECTOR (f
->menu_bar_vector
)->contents
,
994 previous_menu_items_used
* word_size
);
996 /* Fill in menu_items with the current menu bar contents.
997 This can evaluate Lisp code. */
1000 menu_items
= f
->menu_bar_vector
;
1001 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1002 subitems
= ASIZE (items
) / 4;
1003 submenu_start
= alloca ((subitems
+ 1) * sizeof *submenu_start
);
1004 submenu_end
= alloca (subitems
* sizeof *submenu_end
);
1005 submenu_n_panes
= alloca (subitems
* sizeof *submenu_n_panes
);
1006 submenu_top_level_items
= alloca (subitems
1007 * sizeof *submenu_top_level_items
);
1009 for (i
= 0; i
< subitems
; i
++)
1011 Lisp_Object key
, string
, maps
;
1013 key
= AREF (items
, 4 * i
);
1014 string
= AREF (items
, 4 * i
+ 1);
1015 maps
= AREF (items
, 4 * i
+ 2);
1019 submenu_start
[i
] = menu_items_used
;
1021 menu_items_n_panes
= 0;
1022 submenu_top_level_items
[i
]
1023 = parse_single_submenu (key
, string
, maps
);
1024 submenu_n_panes
[i
] = menu_items_n_panes
;
1026 submenu_end
[i
] = menu_items_used
;
1029 submenu_start
[i
] = -1;
1030 finish_menu_items ();
1032 /* Convert menu_items into widget_value trees
1033 to display the menu. This cannot evaluate Lisp code. */
1035 wv
= xmalloc_widget_value ();
1036 wv
->name
= "menubar";
1039 wv
->button_type
= BUTTON_TYPE_NONE
;
1043 for (i
= 0; submenu_start
[i
] >= 0; i
++)
1045 menu_items_n_panes
= submenu_n_panes
[i
];
1046 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1047 submenu_top_level_items
[i
]);
1051 first_wv
->contents
= wv
;
1052 /* Don't set wv->name here; GC during the loop might relocate it. */
1054 wv
->button_type
= BUTTON_TYPE_NONE
;
1058 set_buffer_internal_1 (prev
);
1060 /* If there has been no change in the Lisp-level contents
1061 of the menu bar, skip redisplaying it. Just exit. */
1063 /* Compare the new menu items with the ones computed last time. */
1064 for (i
= 0; i
< previous_menu_items_used
; i
++)
1065 if (menu_items_used
== i
1066 || (!EQ (previous_items
[i
], AREF (menu_items
, i
))))
1068 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1070 /* The menu items have not changed. Don't bother updating
1071 the menus in any form, since it would be a no-op. */
1072 free_menubar_widget_value_tree (first_wv
);
1073 discard_menu_items ();
1074 unbind_to (specpdl_count
, Qnil
);
1078 /* The menu items are different, so store them in the frame. */
1079 fset_menu_bar_vector (f
, menu_items
);
1080 f
->menu_bar_items_used
= menu_items_used
;
1082 /* This undoes save_menu_items. */
1083 unbind_to (specpdl_count
, Qnil
);
1085 /* Now GC cannot happen during the lifetime of the widget_value,
1086 so it's safe to store data from a Lisp_String. */
1087 wv
= first_wv
->contents
;
1088 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1091 string
= AREF (items
, i
+ 1);
1094 wv
->name
= SSDATA (string
);
1095 update_submenu_strings (wv
->contents
);
1102 /* Make a widget-value tree containing
1103 just the top level menu bar strings. */
1105 wv
= xmalloc_widget_value ();
1106 wv
->name
= "menubar";
1109 wv
->button_type
= BUTTON_TYPE_NONE
;
1113 items
= FRAME_MENU_BAR_ITEMS (f
);
1114 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1118 string
= AREF (items
, i
+ 1);
1122 wv
= xmalloc_widget_value ();
1123 wv
->name
= SSDATA (string
);
1126 wv
->button_type
= BUTTON_TYPE_NONE
;
1128 /* This prevents lwlib from assuming this
1129 menu item is really supposed to be empty. */
1130 /* The intptr_t cast avoids a warning.
1131 This value just has to be different from small integers. */
1132 wv
->call_data
= (void *) (intptr_t) (-1);
1137 first_wv
->contents
= wv
;
1141 /* Forget what we thought we knew about what is in the
1142 detailed contents of the menu bar menus.
1143 Changing the top level always destroys the contents. */
1144 f
->menu_bar_items_used
= 0;
1147 /* Create or update the menu bar widget. */
1152 xg_crazy_callback_abort
= 1;
1155 /* The fourth arg is DEEP_P, which says to consider the entire
1156 menu trees we supply, rather than just the menu bar item names. */
1157 xg_modify_menubar_widgets (menubar_widget
,
1161 G_CALLBACK (menubar_selection_callback
),
1162 G_CALLBACK (popup_deactivate_callback
),
1163 G_CALLBACK (menu_highlight_callback
));
1168 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
1169 G_CALLBACK (menubar_selection_callback
),
1170 G_CALLBACK (popup_deactivate_callback
),
1171 G_CALLBACK (menu_highlight_callback
));
1173 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1177 #else /* not USE_GTK */
1180 /* Disable resizing (done for Motif!) */
1181 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1183 /* The third arg is DEEP_P, which says to consider the entire
1184 menu trees we supply, rather than just the menu bar item names. */
1185 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1187 /* Re-enable the edit widget to resize. */
1188 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1192 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
1193 XtTranslations override
= XtParseTranslationTable (menuOverride
);
1196 apply_systemfont_to_menu (f
, f
->output_data
.x
->column_widget
);
1198 menubar_widget
= lw_create_widget ("menubar", "menubar", id
,
1200 f
->output_data
.x
->column_widget
,
1202 popup_activate_callback
,
1203 menubar_selection_callback
,
1204 popup_deactivate_callback
,
1205 menu_highlight_callback
);
1206 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1208 /* Make menu pop down on C-g. */
1209 XtOverrideTranslations (menubar_widget
, override
);
1214 if (f
->output_data
.x
->menubar_widget
)
1215 XtRealizeWidget (f
->output_data
.x
->menubar_widget
);
1218 = (f
->output_data
.x
->menubar_widget
1219 ? (f
->output_data
.x
->menubar_widget
->core
.height
1220 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1223 #if 1 /* Experimentally, we now get the right results
1224 for -geometry -0-0 without this. 24 Aug 96, rms.
1225 Maybe so, but the menu bar size is missing the pixels so the
1226 WM size hints are off by these pixels. Jan D, oct 2009. */
1228 if (FRAME_EXTERNAL_MENU_BAR (f
))
1231 XtVaGetValues (f
->output_data
.x
->column_widget
,
1232 XtNinternalBorderWidth
, &ibw
, NULL
);
1233 menubar_size
+= ibw
;
1235 #endif /* USE_LUCID */
1238 f
->output_data
.x
->menubar_height
= menubar_size
;
1240 #endif /* not USE_GTK */
1242 free_menubar_widget_value_tree (first_wv
);
1243 update_frame_menubar (f
);
1246 xg_crazy_callback_abort
= 0;
1252 /* Called from Fx_create_frame to create the initial menubar of a frame
1253 before it is mapped, so that the window is mapped with the menubar already
1254 there instead of us tacking it on later and thrashing the window after it
1258 initialize_frame_menubar (struct frame
*f
)
1260 /* This function is called before the first chance to redisplay
1261 the frame. It has to be, so the frame will have the right size. */
1262 fset_menu_bar_items (f
, menu_bar_items (FRAME_MENU_BAR_ITEMS (f
)));
1263 set_frame_menubar (f
, 1, 1);
1267 /* Get rid of the menu bar of frame F, and free its storage.
1268 This is used when deleting a frame, and when turning off the menu bar.
1269 For GTK this function is in gtkutil.c. */
1273 free_frame_menubar (struct frame
*f
)
1275 Widget menubar_widget
;
1277 eassert (FRAME_X_P (f
));
1279 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1281 f
->output_data
.x
->menubar_height
= 0;
1286 /* Removing the menu bar magically changes the shell widget's x
1287 and y position of (0, 0) which, when the menu bar is turned
1288 on again, leads to pull-down menus appearing in strange
1289 positions near the upper-left corner of the display. This
1290 happens only with some window managers like twm and ctwm,
1291 but not with other like Motif's mwm or kwm, because the
1292 latter generate ConfigureNotify events when the menu bar
1293 is switched off, which fixes the shell position. */
1294 Position x0
, y0
, x1
, y1
;
1300 if (f
->output_data
.x
->widget
)
1301 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1304 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1305 f
->output_data
.x
->menubar_widget
= NULL
;
1307 if (f
->output_data
.x
->widget
)
1310 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1311 if (x1
== 0 && y1
== 0)
1312 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1314 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1319 #endif /* not USE_GTK */
1321 #endif /* USE_X_TOOLKIT || USE_GTK */
1323 /* xmenu_show actually displays a menu using the panes and items in menu_items
1324 and returns the value selected from it.
1325 There are two versions of xmenu_show, one for Xt and one for Xlib.
1326 Both assume input is blocked by the caller. */
1328 /* F is the frame the menu is for.
1329 X and Y are the frame-relative specified position,
1330 relative to the inside upper left corner of the frame F.
1331 FOR_CLICK is true if this menu was invoked for a mouse click.
1332 KEYMAPS is true if this menu was specified with keymaps;
1333 in that case, we return a list containing the chosen item's value
1334 and perhaps also the pane's prefix.
1335 TITLE is the specified menu title.
1336 ERROR is a place to store an error message string in case of failure.
1337 (We return nil on failure, but the value doesn't actually matter.) */
1339 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1341 /* The item selected in the popup menu. */
1342 static Lisp_Object
*volatile menu_item_selection
;
1346 /* Used when position a popup menu. See menu_position_func and
1347 create_and_show_popup_menu below. */
1348 struct next_popup_x_y
1355 /* The menu position function to use if we are not putting a popup
1356 menu where the pointer is.
1357 MENU is the menu to pop up.
1358 X and Y shall on exit contain x/y where the menu shall pop up.
1359 PUSH_IN is not documented in the GTK manual.
1360 USER_DATA is any data passed in when calling gtk_menu_popup.
1361 Here it points to a struct next_popup_x_y where the coordinates
1362 to store in *X and *Y are as well as the frame for the popup.
1364 Here only X and Y are used. */
1366 menu_position_func (GtkMenu
*menu
, gint
*x
, gint
*y
, gboolean
*push_in
, gpointer user_data
)
1368 struct next_popup_x_y
*data
= user_data
;
1370 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (data
->f
);
1371 int disp_width
= x_display_pixel_width (dpyinfo
);
1372 int disp_height
= x_display_pixel_height (dpyinfo
);
1377 /* Check if there is room for the menu. If not, adjust x/y so that
1378 the menu is fully visible. */
1379 gtk_widget_get_preferred_size (GTK_WIDGET (menu
), NULL
, &req
);
1380 if (data
->x
+ req
.width
> disp_width
)
1381 *x
-= data
->x
+ req
.width
- disp_width
;
1382 if (data
->y
+ req
.height
> disp_height
)
1383 *y
-= data
->y
+ req
.height
- disp_height
;
1387 popup_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1389 xg_menu_item_cb_data
*cb_data
= client_data
;
1391 if (xg_crazy_callback_abort
) return;
1392 if (cb_data
) menu_item_selection
= cb_data
->call_data
;
1396 pop_down_menu (void *arg
)
1398 popup_activated_flag
= 0;
1400 gtk_widget_destroy (GTK_WIDGET (arg
));
1404 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1406 menu_item_selection will be set to the selection. */
1408 create_and_show_popup_menu (struct frame
*f
, widget_value
*first_wv
, int x
, int y
,
1409 bool for_click
, Time timestamp
)
1413 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
1414 struct next_popup_x_y popup_x_y
;
1415 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1416 bool use_pos_func
= ! for_click
;
1419 /* Always use position function for Gtk3. Otherwise menus may become
1420 too small to show anything. */
1424 eassert (FRAME_X_P (f
));
1426 xg_crazy_callback_abort
= 1;
1427 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
1428 G_CALLBACK (popup_selection_callback
),
1429 G_CALLBACK (popup_deactivate_callback
),
1430 G_CALLBACK (menu_highlight_callback
));
1431 xg_crazy_callback_abort
= 0;
1435 /* Not invoked by a click. pop up at x/y. */
1436 pos_func
= menu_position_func
;
1438 /* Adjust coordinates to be root-window-relative. */
1439 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1440 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1446 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1451 for (i
= 0; i
< 5; i
++)
1452 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1456 /* Display the menu. */
1457 gtk_widget_show_all (menu
);
1459 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
,
1460 timestamp
? timestamp
: gtk_get_current_event_time ());
1462 record_unwind_protect_ptr (pop_down_menu
, menu
);
1464 if (gtk_widget_get_mapped (menu
))
1466 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1467 two. show_help_echo uses this to detect popup menus. */
1468 popup_activated_flag
= 1;
1469 /* Process events that apply to the menu. */
1470 popup_widget_loop (1, menu
);
1473 unbind_to (specpdl_count
, Qnil
);
1475 /* Must reset this manually because the button release event is not passed
1476 to Emacs event loop. */
1477 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1480 #else /* not USE_GTK */
1482 /* We need a unique id for each widget handled by the Lucid Widget
1485 For the main windows, and popup menus, we use this counter,
1486 which we increment each time after use. This starts from 1<<16.
1488 For menu bars, we use numbers starting at 0, counted in
1489 next_menubar_widget_id. */
1490 LWLIB_ID widget_id_tick
;
1493 popup_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1495 menu_item_selection
= client_data
;
1498 /* ARG is the LWLIB ID of the dialog box, represented
1499 as a Lisp object as (HIGHPART . LOWPART). */
1502 pop_down_menu (Lisp_Object arg
)
1504 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
1505 | XINT (XCDR (arg
)));
1508 lw_destroy_all_widgets (id
);
1510 popup_activated_flag
= 0;
1513 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1515 menu_item_selection will be set to the selection. */
1517 create_and_show_popup_menu (struct frame
*f
, widget_value
*first_wv
,
1518 int x
, int y
, bool for_click
, Time timestamp
)
1524 XButtonPressedEvent
*event
= &(dummy
.xbutton
);
1528 eassert (FRAME_X_P (f
));
1531 apply_systemfont_to_menu (f
, f
->output_data
.x
->widget
);
1534 menu_id
= widget_id_tick
++;
1535 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1536 f
->output_data
.x
->widget
, 1, 0,
1537 popup_selection_callback
,
1538 popup_deactivate_callback
,
1539 menu_highlight_callback
);
1541 event
->type
= ButtonPress
;
1543 event
->send_event
= 0;
1544 event
->display
= FRAME_X_DISPLAY (f
);
1545 event
->time
= CurrentTime
;
1546 event
->root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1547 event
->window
= event
->subwindow
= event
->root
;
1551 /* Adjust coordinates to be root-window-relative. */
1552 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1553 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1560 for (i
= 0; i
< 5; i
++)
1561 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1564 /* Don't allow any geometry request from the user. */
1565 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
1566 XtSetValues (menu
, av
, ac
);
1568 /* Display the menu. */
1569 lw_popup_menu (menu
, &dummy
);
1570 popup_activated_flag
= 1;
1571 x_activate_timeout_atimer ();
1574 int fact
= 4 * sizeof (LWLIB_ID
);
1575 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1576 record_unwind_protect (pop_down_menu
,
1577 Fcons (make_number (menu_id
>> (fact
)),
1578 make_number (menu_id
& ~(-1 << (fact
)))));
1580 /* Process events that apply to the menu. */
1581 popup_get_selection (0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
1583 unbind_to (specpdl_count
, Qnil
);
1587 #endif /* not USE_GTK */
1590 cleanup_widget_value_tree (void *arg
)
1592 free_menubar_widget_value_tree (arg
);
1596 xmenu_show (struct frame
*f
, int x
, int y
, bool for_click
, bool keymaps
,
1597 Lisp_Object title
, const char **error_name
, Time timestamp
)
1600 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1601 widget_value
**submenu_stack
1602 = alloca (menu_items_used
* sizeof *submenu_stack
);
1603 Lisp_Object
*subprefix_stack
1604 = alloca (menu_items_used
* sizeof *subprefix_stack
);
1605 int submenu_depth
= 0;
1609 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1611 eassert (FRAME_X_P (f
));
1615 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1617 *error_name
= "Empty menu";
1621 /* Create a tree of widget_value objects
1622 representing the panes and their items. */
1623 wv
= xmalloc_widget_value ();
1627 wv
->button_type
= BUTTON_TYPE_NONE
;
1632 /* Loop over all panes and items, filling in the tree. */
1634 while (i
< menu_items_used
)
1636 if (EQ (AREF (menu_items
, i
), Qnil
))
1638 submenu_stack
[submenu_depth
++] = save_wv
;
1644 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1647 save_wv
= submenu_stack
[--submenu_depth
];
1651 else if (EQ (AREF (menu_items
, i
), Qt
)
1652 && submenu_depth
!= 0)
1653 i
+= MENU_ITEMS_PANE_LENGTH
;
1654 /* Ignore a nil in the item list.
1655 It's meaningful only for dialog boxes. */
1656 else if (EQ (AREF (menu_items
, i
), Qquote
))
1658 else if (EQ (AREF (menu_items
, i
), Qt
))
1660 /* Create a new pane. */
1661 Lisp_Object pane_name
, prefix
;
1662 const char *pane_string
;
1664 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1665 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1667 #ifndef HAVE_MULTILINGUAL_MENU
1668 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1670 pane_name
= ENCODE_MENU_STRING (pane_name
);
1671 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1674 pane_string
= (NILP (pane_name
)
1675 ? "" : SSDATA (pane_name
));
1676 /* If there is just one top-level pane, put all its items directly
1677 under the top-level menu. */
1678 if (menu_items_n_panes
== 1)
1681 /* If the pane has a meaningful name,
1682 make the pane a top-level menu item
1683 with its items as a submenu beneath it. */
1684 if (!keymaps
&& strcmp (pane_string
, ""))
1686 wv
= xmalloc_widget_value ();
1690 first_wv
->contents
= wv
;
1691 wv
->name
= (char *) pane_string
;
1692 if (keymaps
&& !NILP (prefix
))
1696 wv
->button_type
= BUTTON_TYPE_NONE
;
1701 else if (first_pane
)
1707 i
+= MENU_ITEMS_PANE_LENGTH
;
1711 /* Create a new item within current pane. */
1712 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
1713 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1714 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1715 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1716 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1717 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1718 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1719 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1721 #ifndef HAVE_MULTILINGUAL_MENU
1722 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
1724 item_name
= ENCODE_MENU_STRING (item_name
);
1725 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1728 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1730 descrip
= ENCODE_MENU_STRING (descrip
);
1731 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1733 #endif /* not HAVE_MULTILINGUAL_MENU */
1735 wv
= xmalloc_widget_value ();
1739 save_wv
->contents
= wv
;
1740 wv
->name
= SSDATA (item_name
);
1741 if (!NILP (descrip
))
1742 wv
->key
= SSDATA (descrip
);
1744 /* If this item has a null value,
1745 make the call_data null so that it won't display a box
1746 when the mouse is on it. */
1747 wv
->call_data
= !NILP (def
) ? aref_addr (menu_items
, i
) : 0;
1748 wv
->enabled
= !NILP (enable
);
1751 wv
->button_type
= BUTTON_TYPE_NONE
;
1752 else if (EQ (type
, QCtoggle
))
1753 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1754 else if (EQ (type
, QCradio
))
1755 wv
->button_type
= BUTTON_TYPE_RADIO
;
1759 wv
->selected
= !NILP (selected
);
1761 if (! STRINGP (help
))
1768 i
+= MENU_ITEMS_ITEM_LENGTH
;
1772 /* Deal with the title, if it is non-nil. */
1775 widget_value
*wv_title
= xmalloc_widget_value ();
1776 widget_value
*wv_sep1
= xmalloc_widget_value ();
1777 widget_value
*wv_sep2
= xmalloc_widget_value ();
1779 wv_sep2
->name
= "--";
1780 wv_sep2
->next
= first_wv
->contents
;
1781 wv_sep2
->help
= Qnil
;
1783 wv_sep1
->name
= "--";
1784 wv_sep1
->next
= wv_sep2
;
1785 wv_sep1
->help
= Qnil
;
1787 #ifndef HAVE_MULTILINGUAL_MENU
1788 if (STRING_MULTIBYTE (title
))
1789 title
= ENCODE_MENU_STRING (title
);
1792 wv_title
->name
= SSDATA (title
);
1793 wv_title
->enabled
= TRUE
;
1794 wv_title
->button_type
= BUTTON_TYPE_NONE
;
1795 wv_title
->help
= Qnil
;
1796 wv_title
->next
= wv_sep1
;
1797 first_wv
->contents
= wv_title
;
1800 /* No selection has been chosen yet. */
1801 menu_item_selection
= 0;
1803 /* Make sure to free the widget_value objects we used to specify the
1804 contents even with longjmp. */
1805 record_unwind_protect_ptr (cleanup_widget_value_tree
, first_wv
);
1807 /* Actually create and show the menu until popped down. */
1808 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
, timestamp
);
1810 unbind_to (specpdl_count
, Qnil
);
1812 /* Find the selected item, and its pane, to return
1813 the proper value. */
1814 if (menu_item_selection
!= 0)
1816 Lisp_Object prefix
, entry
;
1818 prefix
= entry
= Qnil
;
1820 while (i
< menu_items_used
)
1822 if (EQ (AREF (menu_items
, i
), Qnil
))
1824 subprefix_stack
[submenu_depth
++] = prefix
;
1828 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1830 prefix
= subprefix_stack
[--submenu_depth
];
1833 else if (EQ (AREF (menu_items
, i
), Qt
))
1836 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1837 i
+= MENU_ITEMS_PANE_LENGTH
;
1839 /* Ignore a nil in the item list.
1840 It's meaningful only for dialog boxes. */
1841 else if (EQ (AREF (menu_items
, i
), Qquote
))
1846 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
1847 if (menu_item_selection
== aref_addr (menu_items
, i
))
1853 entry
= list1 (entry
);
1855 entry
= Fcons (prefix
, entry
);
1856 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1857 if (!NILP (subprefix_stack
[j
]))
1858 entry
= Fcons (subprefix_stack
[j
], entry
);
1862 i
+= MENU_ITEMS_ITEM_LENGTH
;
1866 else if (!for_click
)
1867 /* Make "Cancel" equivalent to C-g. */
1868 Fsignal (Qquit
, Qnil
);
1875 dialog_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1877 /* Treat the pointer as an integer. There's no problem
1878 as long as pointers have enough bits to hold small integers. */
1879 if ((intptr_t) client_data
!= -1)
1880 menu_item_selection
= client_data
;
1882 popup_activated_flag
= 0;
1885 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1887 menu_item_selection will be set to the selection. */
1889 create_and_show_dialog (struct frame
*f
, widget_value
*first_wv
)
1893 eassert (FRAME_X_P (f
));
1895 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
1896 G_CALLBACK (dialog_selection_callback
),
1897 G_CALLBACK (popup_deactivate_callback
),
1902 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1903 record_unwind_protect_ptr (pop_down_menu
, menu
);
1905 /* Display the menu. */
1906 gtk_widget_show_all (menu
);
1908 /* Process events that apply to the menu. */
1909 popup_widget_loop (1, menu
);
1911 unbind_to (specpdl_count
, Qnil
);
1915 #else /* not USE_GTK */
1917 dialog_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1919 /* Treat the pointer as an integer. There's no problem
1920 as long as pointers have enough bits to hold small integers. */
1921 if ((intptr_t) client_data
!= -1)
1922 menu_item_selection
= client_data
;
1925 lw_destroy_all_widgets (id
);
1927 popup_activated_flag
= 0;
1931 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1933 menu_item_selection will be set to the selection. */
1935 create_and_show_dialog (struct frame
*f
, widget_value
*first_wv
)
1939 eassert (FRAME_X_P (f
));
1941 dialog_id
= widget_id_tick
++;
1943 apply_systemfont_to_dialog (f
->output_data
.x
->widget
);
1945 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1946 f
->output_data
.x
->widget
, 1, 0,
1947 dialog_selection_callback
, 0, 0);
1948 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1949 /* Display the dialog box. */
1950 lw_pop_up_all_widgets (dialog_id
);
1951 popup_activated_flag
= 1;
1952 x_activate_timeout_atimer ();
1954 /* Process events that apply to the dialog box.
1955 Also handle timers. */
1957 ptrdiff_t count
= SPECPDL_INDEX ();
1958 int fact
= 4 * sizeof (LWLIB_ID
);
1960 /* xdialog_show_unwind is responsible for popping the dialog box down. */
1961 record_unwind_protect (pop_down_menu
,
1962 Fcons (make_number (dialog_id
>> (fact
)),
1963 make_number (dialog_id
& ~(-1 << (fact
)))));
1965 popup_get_selection (0, FRAME_X_DISPLAY_INFO (f
), dialog_id
, 1);
1967 unbind_to (count
, Qnil
);
1971 #endif /* not USE_GTK */
1973 static const char * button_names
[] = {
1974 "button1", "button2", "button3", "button4", "button5",
1975 "button6", "button7", "button8", "button9", "button10" };
1978 xdialog_show (struct frame
*f
,
1982 const char **error_name
)
1984 int i
, nb_buttons
=0;
1985 char dialog_name
[6];
1987 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
1989 /* Number of elements seen so far, before boundary. */
1991 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
1992 int boundary_seen
= 0;
1994 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1996 eassert (FRAME_X_P (f
));
2000 if (menu_items_n_panes
> 1)
2002 *error_name
= "Multiple panes in dialog box";
2006 /* Create a tree of widget_value objects
2007 representing the text label and buttons. */
2009 Lisp_Object pane_name
, prefix
;
2010 const char *pane_string
;
2011 pane_name
= AREF (menu_items
, MENU_ITEMS_PANE_NAME
);
2012 prefix
= AREF (menu_items
, MENU_ITEMS_PANE_PREFIX
);
2013 pane_string
= (NILP (pane_name
)
2014 ? "" : SSDATA (pane_name
));
2015 prev_wv
= xmalloc_widget_value ();
2016 prev_wv
->value
= (char *) pane_string
;
2017 if (keymaps
&& !NILP (prefix
))
2019 prev_wv
->enabled
= 1;
2020 prev_wv
->name
= "message";
2021 prev_wv
->help
= Qnil
;
2024 /* Loop over all panes and items, filling in the tree. */
2025 i
= MENU_ITEMS_PANE_LENGTH
;
2026 while (i
< menu_items_used
)
2029 /* Create a new item within current pane. */
2030 Lisp_Object item_name
, enable
, descrip
;
2031 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2032 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2034 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2036 if (NILP (item_name
))
2038 free_menubar_widget_value_tree (first_wv
);
2039 *error_name
= "Submenu in dialog items";
2042 if (EQ (item_name
, Qquote
))
2044 /* This is the boundary between left-side elts
2045 and right-side elts. Stop incrementing right_count. */
2050 if (nb_buttons
>= 9)
2052 free_menubar_widget_value_tree (first_wv
);
2053 *error_name
= "Too many dialog items";
2057 wv
= xmalloc_widget_value ();
2059 wv
->name
= (char *) button_names
[nb_buttons
];
2060 if (!NILP (descrip
))
2061 wv
->key
= SSDATA (descrip
);
2062 wv
->value
= SSDATA (item_name
);
2063 wv
->call_data
= aref_addr (menu_items
, i
);
2064 wv
->enabled
= !NILP (enable
);
2068 if (! boundary_seen
)
2072 i
+= MENU_ITEMS_ITEM_LENGTH
;
2075 /* If the boundary was not specified,
2076 by default put half on the left and half on the right. */
2077 if (! boundary_seen
)
2078 left_count
= nb_buttons
- nb_buttons
/ 2;
2080 wv
= xmalloc_widget_value ();
2081 wv
->name
= dialog_name
;
2084 /* Frame title: 'Q' = Question, 'I' = Information.
2085 Can also have 'E' = Error if, one day, we want
2086 a popup for errors. */
2088 dialog_name
[0] = 'Q';
2090 dialog_name
[0] = 'I';
2092 /* Dialog boxes use a really stupid name encoding
2093 which specifies how many buttons to use
2094 and how many buttons are on the right. */
2095 dialog_name
[1] = '0' + nb_buttons
;
2096 dialog_name
[2] = 'B';
2097 dialog_name
[3] = 'R';
2098 /* Number of buttons to put on the right. */
2099 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2101 wv
->contents
= first_wv
;
2105 /* No selection has been chosen yet. */
2106 menu_item_selection
= 0;
2108 /* Make sure to free the widget_value objects we used to specify the
2109 contents even with longjmp. */
2110 record_unwind_protect_ptr (cleanup_widget_value_tree
, first_wv
);
2112 /* Actually create and show the dialog. */
2113 create_and_show_dialog (f
, first_wv
);
2115 unbind_to (specpdl_count
, Qnil
);
2117 /* Find the selected item, and its pane, to return
2118 the proper value. */
2119 if (menu_item_selection
!= 0)
2125 while (i
< menu_items_used
)
2129 if (EQ (AREF (menu_items
, i
), Qt
))
2132 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2133 i
+= MENU_ITEMS_PANE_LENGTH
;
2135 else if (EQ (AREF (menu_items
, i
), Qquote
))
2137 /* This is the boundary between left-side elts and
2144 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
2145 if (menu_item_selection
== aref_addr (menu_items
, i
))
2149 entry
= list1 (entry
);
2151 entry
= Fcons (prefix
, entry
);
2155 i
+= MENU_ITEMS_ITEM_LENGTH
;
2160 /* Make "Cancel" equivalent to C-g. */
2161 Fsignal (Qquit
, Qnil
);
2166 #else /* not USE_X_TOOLKIT && not USE_GTK */
2168 /* The frame of the last activated non-toolkit menu bar.
2169 Used to generate menu help events. */
2171 static struct frame
*menu_help_frame
;
2174 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2176 PANE is the pane number, and ITEM is the menu item number in
2177 the menu (currently not used).
2179 This cannot be done with generating a HELP_EVENT because
2180 XMenuActivate contains a loop that doesn't let Emacs process
2184 menu_help_callback (char const *help_string
, int pane
, int item
)
2186 Lisp_Object
*first_item
;
2187 Lisp_Object pane_name
;
2188 Lisp_Object menu_object
;
2190 first_item
= XVECTOR (menu_items
)->contents
;
2191 if (EQ (first_item
[0], Qt
))
2192 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2193 else if (EQ (first_item
[0], Qquote
))
2194 /* This shouldn't happen, see xmenu_show. */
2195 pane_name
= empty_unibyte_string
;
2197 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2199 /* (menu-item MENU-NAME PANE-NUMBER) */
2200 menu_object
= list3 (Qmenu_item
, pane_name
, make_number (pane
));
2201 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2202 Qnil
, menu_object
, make_number (item
));
2206 pop_down_menu (Lisp_Object arg
)
2208 struct frame
*f
= XSAVE_POINTER (arg
, 0);
2209 XMenu
*menu
= XSAVE_POINTER (arg
, 1);
2213 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
2214 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
2216 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2218 #ifdef HAVE_X_WINDOWS
2219 /* Assume the mouse has moved out of the X window.
2220 If it has actually moved in, we will get an EnterNotify. */
2221 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2223 /* State that no mouse buttons are now held.
2224 (The oldXMenu code doesn't track this info for us.)
2225 That is not necessarily true, but the fiction leads to reasonable
2226 results, and it is a pain to ask which are actually held now. */
2227 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2229 #endif /* HAVE_X_WINDOWS */
2236 xmenu_show (struct frame
*f
, int x
, int y
, bool for_click
, bool keymaps
,
2237 Lisp_Object title
, const char **error_name
, Time timestamp
)
2241 int pane
, selidx
, lpane
, status
;
2242 Lisp_Object entry
, pane_prefix
;
2244 int ulx
, uly
, width
, height
;
2245 int dispwidth
, dispheight
;
2246 int i
, j
, lines
, maxlines
;
2249 unsigned int dummy_uint
;
2250 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
2252 eassert (FRAME_X_P (f
) || FRAME_MSDOS_P (f
));
2255 if (menu_items_n_panes
== 0)
2258 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2260 *error_name
= "Empty menu";
2264 /* Figure out which root window F is on. */
2265 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2266 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2267 &dummy_uint
, &dummy_uint
);
2269 /* Make the menu on that window. */
2270 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2273 *error_name
= "Can't create menu";
2277 /* Don't GC while we prepare and show the menu,
2278 because we give the oldxmenu library pointers to the
2279 contents of strings. */
2280 inhibit_garbage_collection ();
2282 #ifdef HAVE_X_WINDOWS
2283 /* Adjust coordinates to relative to the outer (window manager) window. */
2284 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
2285 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2286 #endif /* HAVE_X_WINDOWS */
2288 /* Adjust coordinates to be root-window-relative. */
2292 /* Create all the necessary panes and their items. */
2293 maxwidth
= maxlines
= lines
= i
= 0;
2295 while (i
< menu_items_used
)
2297 if (EQ (AREF (menu_items
, i
), Qt
))
2299 /* Create a new pane. */
2300 Lisp_Object pane_name
, prefix
;
2301 const char *pane_string
;
2303 maxlines
= max (maxlines
, lines
);
2305 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2306 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2307 pane_string
= (NILP (pane_name
)
2308 ? "" : SSDATA (pane_name
));
2309 if (keymaps
&& !NILP (prefix
))
2312 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2313 if (lpane
== XM_FAILURE
)
2315 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2316 *error_name
= "Can't create pane";
2319 i
+= MENU_ITEMS_PANE_LENGTH
;
2321 /* Find the width of the widest item in this pane. */
2323 while (j
< menu_items_used
)
2326 item
= AREF (menu_items
, j
);
2334 width
= SBYTES (item
);
2335 if (width
> maxwidth
)
2338 j
+= MENU_ITEMS_ITEM_LENGTH
;
2341 /* Ignore a nil in the item list.
2342 It's meaningful only for dialog boxes. */
2343 else if (EQ (AREF (menu_items
, i
), Qquote
))
2347 /* Create a new item within current pane. */
2348 Lisp_Object item_name
, enable
, descrip
, help
;
2350 char const *help_string
;
2352 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2353 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2355 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2356 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2357 help_string
= STRINGP (help
) ? SSDATA (help
) : NULL
;
2359 if (!NILP (descrip
))
2361 /* if alloca is fast, use that to make the space,
2362 to reduce gc needs. */
2363 item_data
= alloca (maxwidth
+ SBYTES (descrip
) + 1);
2364 memcpy (item_data
, SSDATA (item_name
), SBYTES (item_name
));
2365 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
2367 memcpy (item_data
+ j
, SSDATA (descrip
), SBYTES (descrip
));
2368 item_data
[j
+ SBYTES (descrip
)] = 0;
2371 item_data
= SSDATA (item_name
);
2373 if (lpane
== XM_FAILURE
2374 || (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2375 menu
, lpane
, 0, item_data
,
2376 !NILP (enable
), help_string
)
2379 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2380 *error_name
= "Can't add selection to menu";
2383 i
+= MENU_ITEMS_ITEM_LENGTH
;
2388 maxlines
= max (maxlines
, lines
);
2390 /* All set and ready to fly. */
2391 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2392 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2393 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2394 x
= min (x
, dispwidth
);
2395 y
= min (y
, dispheight
);
2398 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2399 &ulx
, &uly
, &width
, &height
);
2400 if (ulx
+width
> dispwidth
)
2402 x
-= (ulx
+ width
) - dispwidth
;
2403 ulx
= dispwidth
- width
;
2405 if (uly
+height
> dispheight
)
2407 y
-= (uly
+ height
) - dispheight
;
2408 uly
= dispheight
- height
;
2410 #ifndef HAVE_X_WINDOWS
2411 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 1)
2413 /* Move the menu away of the echo area, to avoid overwriting the
2414 menu with help echo messages or vice versa. */
2415 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
2417 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2418 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2427 if (ulx
< 0) x
-= ulx
;
2428 if (uly
< 0) y
-= uly
;
2432 /* If position was not given by a mouse click, adjust so upper left
2433 corner of the menu as a whole ends up at given coordinates. This
2434 is what x-popup-menu says in its documentation. */
2436 y
+= 1.5*height
/(maxlines
+2);
2439 XMenuSetAEQ (menu
, TRUE
);
2440 XMenuSetFreeze (menu
, TRUE
);
2444 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
2447 record_unwind_protect (pop_down_menu
, make_save_ptr_ptr (f
, menu
));
2449 /* Help display under X won't work because XMenuActivate contains
2450 a loop that doesn't give Emacs a chance to process it. */
2451 menu_help_frame
= f
;
2452 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2453 x
, y
, ButtonReleaseMask
, &datap
,
2454 menu_help_callback
);
2455 entry
= pane_prefix
= Qnil
;
2461 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2464 /* Find the item number SELIDX in pane number PANE. */
2466 while (i
< menu_items_used
)
2468 if (EQ (AREF (menu_items
, i
), Qt
))
2472 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2474 i
+= MENU_ITEMS_PANE_LENGTH
;
2483 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
2486 entry
= list1 (entry
);
2487 if (!NILP (pane_prefix
))
2488 entry
= Fcons (pane_prefix
, entry
);
2494 i
+= MENU_ITEMS_ITEM_LENGTH
;
2500 *error_name
= "Can't activate menu";
2504 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2505 the menu was invoked with a mouse event as POSITION). */
2507 Fsignal (Qquit
, Qnil
);
2511 unbind_to (specpdl_count
, Qnil
);
2516 #endif /* not USE_X_TOOLKIT */
2518 #endif /* HAVE_MENUS */
2521 /* Detect if a dialog or menu has been posted. MSDOS has its own
2522 implementation on msdos.c. */
2525 popup_activated (void)
2527 return popup_activated_flag
;
2529 #endif /* not MSDOS */
2531 /* The following is used by delayed window autoselection. */
2533 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
2534 doc
: /* Return t if a menu or popup dialog is active. */)
2538 return (popup_activated ()) ? Qt
: Qnil
;
2541 #endif /* HAVE_MENUS */
2545 syms_of_xmenu (void)
2547 DEFSYM (Qdebug_on_next_call
, "debug-on-next-call");
2549 #ifdef USE_X_TOOLKIT
2550 widget_id_tick
= (1<<16);
2551 next_menubar_widget_id
= 1;
2554 defsubr (&Smenu_or_popup_active_p
);
2556 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2557 defsubr (&Sx_menu_bar_open_internal
);
2558 Ffset (intern_c_string ("accelerate-menu"),
2559 intern_c_string (Sx_menu_bar_open_internal
.symbol_name
));
2563 defsubr (&Sx_popup_dialog
);