1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* X pop-up deck-of-cards menu facility for GNU Emacs.
22 * Written by Jon Arnold and Roman Budzianowski
23 * Mods and rewrite by Robert Krawitz
27 /* Modified by Fred Pierresteguy on December 93
28 to make the popup menus and menubar use the Xt. */
30 /* Rewritten for clarity and GC protection by rms in Feb 94. */
34 #if 0 /* Why was this included? And without syssignal.h? */
35 /* On 4.3 this loses if it comes after xterm.h. */
46 #include "termhooks.h"
48 #include "blockinput.h"
52 #include "sysselect.h"
59 /* This may include sys/types.h, and that somehow loses
60 if this is not done before the other system files. */
64 /* Load sys/types.h if not already loaded.
65 In some systems loading it twice is suicidal. */
67 #include <sys/types.h>
70 #include "dispextern.h"
73 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
74 code accepts the Emacs internal encoding. */
75 #undef HAVE_MULTILINGUAL_MENU
79 #include <X11/IntrinsicP.h>
80 #include <X11/CoreP.h>
81 #include <X11/StringDefs.h>
82 #include <X11/Shell.h>
84 #include "xsettings.h"
85 #include "../lwlib/xlwmenu.h"
87 #include <X11/Xaw3d/Paned.h>
88 #else /* !HAVE_XAW3D */
89 #include <X11/Xaw/Paned.h>
90 #endif /* HAVE_XAW3D */
91 #endif /* USE_LUCID */
92 #else /* not USE_X_TOOLKIT */
94 #include "../oldXMenu/XMenu.h"
96 #endif /* not USE_X_TOOLKIT */
97 #endif /* HAVE_X_WINDOWS */
110 Lisp_Object Qdebug_on_next_call
;
112 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
113 static Lisp_Object
xdialog_show (FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
117 static int update_frame_menubar (struct frame
*);
119 /* Flag which when set indicates a dialog or menu has been posted by
120 Xt on behalf of one of the widget sets. */
121 static int popup_activated_flag
;
123 static int next_menubar_widget_id
;
128 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
130 static struct frame
*
131 menubar_id_to_frame (LWLIB_ID id
)
133 Lisp_Object tail
, frame
;
136 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
142 if (!FRAME_WINDOW_P (f
))
144 if (f
->output_data
.x
->id
== id
)
152 #ifdef HAVE_X_WINDOWS
153 /* Return the mouse position in *X and *Y. The coordinates are window
154 relative for the edit window in frame F.
155 This is for Fx_popup_menu. The mouse_position_hook can not
156 be used for X, as it returns window relative coordinates
157 for the window where the mouse is in. This could be the menu bar,
158 the scroll bar or the edit window. Fx_popup_menu needs to be
159 sure it is the edit window. */
161 mouse_position_for_popup (FRAME_PTR f
, int *x
, int *y
)
163 Window root
, dummy_window
;
171 XQueryPointer (FRAME_X_DISPLAY (f
),
172 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
174 /* The root window which contains the pointer. */
177 /* Window pointer is on, not used */
180 /* The position on that root window. */
183 /* x/y in dummy_window coordinates, not used. */
186 /* Modifier keys and pointer buttons, about which
188 (unsigned int *) &dummy
);
192 /* xmenu_show expects window coordinates, not root window
193 coordinates. Translate. */
194 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
195 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
198 #endif /* HAVE_X_WINDOWS */
202 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
203 doc
: /* Pop up a dialog box and return user's selection.
204 POSITION specifies which frame to use.
205 This is normally a mouse button event or a window or frame.
206 If POSITION is t, it means to use the frame the mouse is on.
207 The dialog box appears in the middle of the specified frame.
209 CONTENTS specifies the alternatives to display in the dialog box.
210 It is a list of the form (DIALOG ITEM1 ITEM2...).
211 Each ITEM is a cons cell (STRING . VALUE).
212 The return value is VALUE from the chosen item.
214 An ITEM may also be just a string--that makes a nonselectable item.
215 An ITEM may also be nil--that means to put all preceding items
216 on the left of the dialog box and all following items on the right.
217 \(By default, approximately half appear on each side.)
219 If HEADER is non-nil, the frame title for the box is "Information",
220 otherwise it is "Question".
222 If the user gets rid of the dialog box without making a valid choice,
223 for instance using the window manager, then this produces a quit and
224 `x-popup-dialog' does not return. */)
225 (Lisp_Object position
, Lisp_Object contents
, Lisp_Object header
)
232 /* Decode the first argument: find the window or frame to use. */
233 if (EQ (position
, Qt
)
234 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
235 || EQ (XCAR (position
), Qtool_bar
))))
237 #if 0 /* Using the frame the mouse is on may not be right. */
238 /* Use the mouse's current position. */
239 FRAME_PTR new_f
= SELECTED_FRAME ();
240 Lisp_Object bar_window
;
241 enum scroll_bar_part part
;
245 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
248 XSETFRAME (window
, new_f
);
250 window
= selected_window
;
252 window
= selected_window
;
254 else if (CONSP (position
))
257 tem
= Fcar (position
);
259 window
= Fcar (Fcdr (position
));
262 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
263 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
266 else if (WINDOWP (position
) || FRAMEP (position
))
271 /* Decode where to put the menu. */
275 else if (WINDOWP (window
))
277 CHECK_LIVE_WINDOW (window
);
278 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
281 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
282 but I don't want to make one now. */
283 CHECK_WINDOW (window
);
285 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
286 error ("Can not put X dialog on this terminal");
288 /* Force a redisplay before showing the dialog. If a frame is created
289 just before showing the dialog, its contents may not have been fully
290 drawn, as this depends on timing of events from the X server. Redisplay
291 is not done when a dialog is shown. If redisplay could be done in the
292 X event loop (i.e. the X event loop does not run in a signal handler)
293 this would not be needed.
295 Do this before creating the widget value that points to Lisp
296 string contents, because Fredisplay may GC and relocate them. */
299 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
300 /* Display a menu with these alternatives
301 in the middle of frame F. */
303 Lisp_Object x
, y
, frame
, newpos
;
304 XSETFRAME (frame
, f
);
305 XSETINT (x
, x_pixel_width (f
) / 2);
306 XSETINT (y
, x_pixel_height (f
) / 2);
307 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
309 return Fx_popup_menu (newpos
,
310 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
315 const char *error_name
;
316 Lisp_Object selection
;
317 int specpdl_count
= SPECPDL_INDEX ();
319 /* Decode the dialog items from what was specified. */
320 title
= Fcar (contents
);
321 CHECK_STRING (title
);
322 record_unwind_protect (unuse_menu_items
, Qnil
);
324 if (NILP (Fcar (Fcdr (contents
))))
325 /* No buttons specified, add an "Ok" button so users can pop down
326 the dialog. Also, the lesstif/motif version crashes if there are
328 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
330 list_of_panes (Fcons (contents
, Qnil
));
332 /* Display them in a dialog box. */
334 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
337 unbind_to (specpdl_count
, Qnil
);
338 discard_menu_items ();
340 if (error_name
) error (error_name
);
349 /* Set menu_items_inuse so no other popup menu or dialog is created. */
352 x_menu_set_in_use (int in_use
)
354 menu_items_inuse
= in_use
? Qt
: Qnil
;
355 popup_activated_flag
= in_use
;
357 if (popup_activated_flag
)
358 x_activate_timeout_atimer ();
362 /* Wait for an X event to arrive or for a timer to expire. */
365 x_menu_wait_for_event (void *data
)
367 /* Another way to do this is to register a timer callback, that can be
368 done in GTK and Xt. But we have to do it like this when using only X
369 anyway, and with callbacks we would have three variants for timer handling
370 instead of the small ifdefs below. */
374 ! XtAppPending (Xt_app_con
)
375 #elif defined USE_GTK
376 ! gtk_events_pending ()
378 ! XPending ((Display
*) data
)
382 EMACS_TIME next_time
= timer_check (1), *ntp
;
383 long secs
= EMACS_SECS (next_time
);
384 long usecs
= EMACS_USECS (next_time
);
385 SELECT_TYPE read_fds
;
386 struct x_display_info
*dpyinfo
;
390 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
392 int fd
= ConnectionNumber (dpyinfo
->display
);
393 FD_SET (fd
, &read_fds
);
395 XFlush (dpyinfo
->display
);
398 if (secs
< 0 && usecs
< 0)
403 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, ntp
);
409 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
413 /* Loop in Xt until the menu pulldown or dialog popup has been
414 popped down (deactivated). This is used for x-popup-menu
415 and x-popup-dialog; it is not used for the menu bar.
417 NOTE: All calls to popup_get_selection should be protected
418 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
421 popup_get_selection (XEvent
*initial_event
, struct x_display_info
*dpyinfo
, LWLIB_ID id
, int do_timers
)
425 while (popup_activated_flag
)
429 event
= *initial_event
;
434 if (do_timers
) x_menu_wait_for_event (0);
435 XtAppNextEvent (Xt_app_con
, &event
);
438 /* Make sure we don't consider buttons grabbed after menu goes.
439 And make sure to deactivate for any ButtonRelease,
440 even if XtDispatchEvent doesn't do that. */
441 if (event
.type
== ButtonRelease
442 && dpyinfo
->display
== event
.xbutton
.display
)
444 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
445 #ifdef USE_MOTIF /* Pretending that the event came from a
446 Btn1Down seems the only way to convince Motif to
447 activate its callbacks; setting the XmNmenuPost
448 isn't working. --marcus@sysc.pdx.edu. */
449 event
.xbutton
.button
= 1;
450 /* Motif only pops down menus when no Ctrl, Alt or Mod
451 key is pressed and the button is released. So reset key state
452 so Motif thinks this is the case. */
453 event
.xbutton
.state
= 0;
456 /* Pop down on C-g and Escape. */
457 else if (event
.type
== KeyPress
458 && dpyinfo
->display
== event
.xbutton
.display
)
460 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
462 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
463 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
464 popup_activated_flag
= 0;
467 x_dispatch_event (&event
, event
.xany
.display
);
471 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
472 doc
: /* Start key navigation of the menu bar in FRAME.
473 This initially opens the first menu bar item and you can then navigate with the
474 arrow keys, select a menu entry with the return key or cancel with the
475 escape key. If FRAME has no menu bar this function does nothing.
477 If FRAME is nil or not given, use the selected frame. */)
481 FRAME_PTR f
= check_x_frame (frame
);
485 if (FRAME_EXTERNAL_MENU_BAR (f
))
486 set_frame_menubar (f
, 0, 1);
488 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
494 x_catch_errors (FRAME_X_DISPLAY (f
));
495 memset (&ev
, 0, sizeof ev
);
496 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
497 ev
.xbutton
.window
= XtWindow (menubar
);
498 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
499 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
500 ev
.xbutton
.button
= Button1
;
501 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
502 ev
.xbutton
.same_screen
= True
;
509 XtSetArg (al
[0], XtNchildren
, &list
);
510 XtSetArg (al
[1], XtNnumChildren
, &nr
);
511 XtGetValues (menubar
, al
, 2);
512 ev
.xbutton
.window
= XtWindow (list
[0]);
516 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
517 /* From-window, to-window. */
518 ev
.xbutton
.window
, ev
.xbutton
.root
,
520 /* From-position, to-position. */
521 ev
.xbutton
.x
, ev
.xbutton
.y
,
522 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
526 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
531 ev
.type
= ButtonPress
;
532 ev
.xbutton
.state
= 0;
534 XtDispatchEvent (&ev
);
535 ev
.xbutton
.type
= ButtonRelease
;
536 ev
.xbutton
.state
= Button1Mask
;
537 XtDispatchEvent (&ev
);
545 #endif /* USE_X_TOOLKIT */
549 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
550 doc
: /* Start key navigation of the menu bar in FRAME.
551 This initially opens the first menu bar item and you can then navigate with the
552 arrow keys, select a menu entry with the return key or cancel with the
553 escape key. If FRAME has no menu bar this function does nothing.
555 If FRAME is nil or not given, use the selected frame. */)
561 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
565 f
= check_x_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 (FRAME_PTR f
)
625 if (!f
->output_data
.x
->saved_menu_event
->type
)
629 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
630 f
->output_data
.x
->saved_menu_event
->xany
.window
))
634 set_frame_menubar (f
, 0, 1);
636 popup_activated_flag
= 1;
638 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
639 f
->output_data
.x
->saved_menu_event
);
641 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
645 /* Ignore this if we get it a second time. */
646 f
->output_data
.x
->saved_menu_event
->type
= 0;
649 /* This callback is invoked when the user selects a menubar cascade
650 pushbutton, but before the pulldown menu is posted. */
654 popup_activate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
656 popup_activated_flag
= 1;
658 x_activate_timeout_atimer ();
663 /* This callback is invoked when a dialog or menu is finished being
664 used and has been unposted. */
668 popup_deactivate_callback (GtkWidget
*widget
, gpointer client_data
)
670 popup_activated_flag
= 0;
674 popup_deactivate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
676 popup_activated_flag
= 0;
681 /* Function that finds the frame for WIDGET and shows the HELP text
683 F is the frame if known, or NULL if not known. */
685 show_help_event (FRAME_PTR f
, xt_or_gtk_widget widget
, Lisp_Object help
)
691 XSETFRAME (frame
, f
);
692 kbd_buffer_store_help_event (frame
, help
);
696 #if 0 /* This code doesn't do anything useful. ++kfs */
697 /* WIDGET is the popup menu. It's parent is the frame's
698 widget. See which frame that is. */
699 xt_or_gtk_widget frame_widget
= XtParent (widget
);
702 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
706 && (f
= XFRAME (frame
),
707 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
711 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
715 /* Callback called when menu items are highlighted/unhighlighted
716 while moving the mouse over them. WIDGET is the menu bar or menu
717 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
718 the data structure for the menu item, or null in case of
723 menu_highlight_callback (GtkWidget
*widget
, gpointer call_data
)
725 xg_menu_item_cb_data
*cb_data
;
728 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
730 if (! cb_data
) return;
732 help
= call_data
? cb_data
->help
: Qnil
;
734 /* If popup_activated_flag is greater than 1 we are in a popup menu.
735 Don't show help for them, they won't appear before the
736 popup is popped down. */
737 if (popup_activated_flag
<= 1)
738 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
742 menu_highlight_callback (Widget widget
, LWLIB_ID id
, void *call_data
)
747 widget_value
*wv
= (widget_value
*) call_data
;
749 help
= wv
? wv
->help
: Qnil
;
751 /* Determine the frame for the help event. */
752 f
= menubar_id_to_frame (id
);
754 show_help_event (f
, widget
, help
);
759 /* Gtk calls callbacks just because we tell it what item should be
760 selected in a radio group. If this variable is set to a non-zero
761 value, we are creating menus and don't want callbacks right now.
763 static int xg_crazy_callback_abort
;
765 /* This callback is called from the menu bar pulldown menu
766 when the user makes a selection.
767 Figure out what the user chose
768 and put the appropriate events into the keyboard buffer. */
770 menubar_selection_callback (GtkWidget
*widget
, gpointer client_data
)
772 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
774 if (xg_crazy_callback_abort
)
777 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
780 /* For a group of radio buttons, GTK calls the selection callback first
781 for the item that was active before the selection and then for the one that
782 is active after the selection. For C-h k this means we get the help on
783 the deselected item and then the selected item is executed. Prevent that
784 by ignoring the non-active item. */
785 if (GTK_IS_RADIO_MENU_ITEM (widget
)
786 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
789 /* When a menu is popped down, X generates a focus event (i.e. focus
790 goes back to the frame below the menu). Since GTK buffers events,
791 we force it out here before the menu selection event. Otherwise
792 sit-for will exit at once if the focus event follows the menu selection
796 while (gtk_events_pending ())
797 gtk_main_iteration ();
800 find_and_call_menu_selection (cb_data
->cl_data
->f
,
801 cb_data
->cl_data
->menu_bar_items_used
,
802 cb_data
->cl_data
->menu_bar_vector
,
806 #else /* not USE_GTK */
808 /* This callback is called from the menu bar pulldown menu
809 when the user makes a selection.
810 Figure out what the user chose
811 and put the appropriate events into the keyboard buffer. */
813 menubar_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
817 f
= menubar_id_to_frame (id
);
820 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
821 f
->menu_bar_vector
, client_data
);
823 #endif /* not USE_GTK */
825 /* Recompute all the widgets of frame F, when the menu bar has been
826 changed. Value is non-zero if widgets were updated. */
829 update_frame_menubar (FRAME_PTR f
)
832 return xg_update_frame_menubar (f
);
840 x
= f
->output_data
.x
;
842 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
846 /* Save the size of the frame because the pane widget doesn't accept
847 to resize itself. So force it. */
848 columns
= FRAME_COLS (f
);
849 rows
= FRAME_LINES (f
);
851 /* Do the voodoo which means "I'm changing lots of things, don't try
852 to refigure sizes until I'm done." */
853 lw_refigure_widget (x
->column_widget
, False
);
855 /* The order in which children are managed is the top to bottom
856 order in which they are displayed in the paned window. First,
857 remove the text-area widget. */
858 XtUnmanageChild (x
->edit_widget
);
860 /* Remove the menubar that is there now, and put up the menubar that
862 XtManageChild (x
->menubar_widget
);
863 XtMapWidget (x
->menubar_widget
);
864 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
866 /* Re-manage the text-area widget, and then thrash the sizes. */
867 XtManageChild (x
->edit_widget
);
868 lw_refigure_widget (x
->column_widget
, True
);
870 /* Force the pane widget to resize itself with the right values. */
871 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
879 apply_systemfont_to_dialog (Widget w
)
881 const char *fn
= xsettings_get_system_normal_font ();
884 XrmDatabase db
= XtDatabase (XtDisplay (w
));
886 XrmPutStringResource (&db
, "*dialog.faceName", fn
);
891 apply_systemfont_to_menu (Widget w
)
893 const char *fn
= xsettings_get_system_normal_font ();
898 if (XtIsShell (w
)) /* popup menu */
900 Widget
*childs
= NULL
;
902 XtVaGetValues (w
, XtNchildren
, &childs
, NULL
);
903 if (*childs
) w
= *childs
;
906 /* Only use system font if the default is used for the menu. */
907 XtVaGetValues (w
, XtNdefaultFace
, &defflt
, NULL
);
909 XtVaSetValues (w
, XtNfaceName
, fn
, NULL
);
913 /* Set the contents of the menubar widgets of frame F.
914 The argument FIRST_TIME is currently ignored;
915 it is set the first time this is called, from initialize_frame_menubar. */
918 set_frame_menubar (FRAME_PTR f
, int first_time
, int deep_p
)
920 xt_or_gtk_widget menubar_widget
;
925 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
927 int *submenu_start
, *submenu_end
;
928 int *submenu_top_level_items
, *submenu_n_panes
;
933 menubar_widget
= f
->output_data
.x
->menubar_widget
;
935 XSETFRAME (Vmenu_updating_frame
, f
);
938 if (f
->output_data
.x
->id
== 0)
939 f
->output_data
.x
->id
= next_menubar_widget_id
++;
940 id
= f
->output_data
.x
->id
;
943 if (! menubar_widget
)
945 /* Make the first call for any given frame always go deep. */
946 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
949 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
950 f
->output_data
.x
->saved_menu_event
->type
= 0;
954 /* If we have detached menus, we must update deep so detached menus
955 also gets updated. */
956 deep_p
= deep_p
|| xg_have_tear_offs ();
961 /* Make a widget-value tree representing the entire menu trees. */
963 struct buffer
*prev
= current_buffer
;
965 int specpdl_count
= SPECPDL_INDEX ();
966 int previous_menu_items_used
= f
->menu_bar_items_used
;
967 Lisp_Object
*previous_items
968 = (Lisp_Object
*) alloca (previous_menu_items_used
969 * sizeof (Lisp_Object
));
971 /* If we are making a new widget, its contents are empty,
972 do always reinitialize them. */
973 if (! menubar_widget
)
974 previous_menu_items_used
= 0;
976 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
977 specbind (Qinhibit_quit
, Qt
);
978 /* Don't let the debugger step into this code
979 because it is not reentrant. */
980 specbind (Qdebug_on_next_call
, Qnil
);
982 record_unwind_save_match_data ();
983 if (NILP (Voverriding_local_map_menu_flag
))
985 specbind (Qoverriding_terminal_local_map
, Qnil
);
986 specbind (Qoverriding_local_map
, Qnil
);
989 set_buffer_internal_1 (XBUFFER (buffer
));
991 /* Run the Lucid hook. */
992 safe_run_hooks (Qactivate_menubar_hook
);
994 /* If it has changed current-menubar from previous value,
995 really recompute the menubar from the value. */
996 if (! NILP (Vlucid_menu_bar_dirty_flag
))
997 call0 (Qrecompute_lucid_menubar
);
998 safe_run_hooks (Qmenu_bar_update_hook
);
999 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1001 items
= FRAME_MENU_BAR_ITEMS (f
);
1003 /* Save the frame's previous menu bar contents data. */
1004 if (previous_menu_items_used
)
1005 memcpy (previous_items
, XVECTOR (f
->menu_bar_vector
)->contents
,
1006 previous_menu_items_used
* sizeof (Lisp_Object
));
1008 /* Fill in menu_items with the current menu bar contents.
1009 This can evaluate Lisp code. */
1012 menu_items
= f
->menu_bar_vector
;
1013 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1014 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1015 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1016 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1017 submenu_top_level_items
1018 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1020 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1022 Lisp_Object key
, string
, maps
;
1026 key
= XVECTOR (items
)->contents
[i
];
1027 string
= XVECTOR (items
)->contents
[i
+ 1];
1028 maps
= XVECTOR (items
)->contents
[i
+ 2];
1032 submenu_start
[i
] = menu_items_used
;
1034 menu_items_n_panes
= 0;
1035 submenu_top_level_items
[i
]
1036 = parse_single_submenu (key
, string
, maps
);
1037 submenu_n_panes
[i
] = menu_items_n_panes
;
1039 submenu_end
[i
] = menu_items_used
;
1042 finish_menu_items ();
1044 /* Convert menu_items into widget_value trees
1045 to display the menu. This cannot evaluate Lisp code. */
1047 wv
= xmalloc_widget_value ();
1048 wv
->name
= "menubar";
1051 wv
->button_type
= BUTTON_TYPE_NONE
;
1055 for (i
= 0; i
< last_i
; i
+= 4)
1057 menu_items_n_panes
= submenu_n_panes
[i
];
1058 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1059 submenu_top_level_items
[i
]);
1063 first_wv
->contents
= wv
;
1064 /* Don't set wv->name here; GC during the loop might relocate it. */
1066 wv
->button_type
= BUTTON_TYPE_NONE
;
1070 set_buffer_internal_1 (prev
);
1072 /* If there has been no change in the Lisp-level contents
1073 of the menu bar, skip redisplaying it. Just exit. */
1075 /* Compare the new menu items with the ones computed last time. */
1076 for (i
= 0; i
< previous_menu_items_used
; i
++)
1077 if (menu_items_used
== i
1078 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1080 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1082 /* The menu items have not changed. Don't bother updating
1083 the menus in any form, since it would be a no-op. */
1084 free_menubar_widget_value_tree (first_wv
);
1085 discard_menu_items ();
1086 unbind_to (specpdl_count
, Qnil
);
1090 /* The menu items are different, so store them in the frame. */
1091 f
->menu_bar_vector
= menu_items
;
1092 f
->menu_bar_items_used
= menu_items_used
;
1094 /* This undoes save_menu_items. */
1095 unbind_to (specpdl_count
, Qnil
);
1097 /* Now GC cannot happen during the lifetime of the widget_value,
1098 so it's safe to store data from a Lisp_String. */
1099 wv
= first_wv
->contents
;
1100 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1103 string
= XVECTOR (items
)->contents
[i
+ 1];
1106 wv
->name
= (char *) SDATA (string
);
1107 update_submenu_strings (wv
->contents
);
1114 /* Make a widget-value tree containing
1115 just the top level menu bar strings. */
1117 wv
= xmalloc_widget_value ();
1118 wv
->name
= "menubar";
1121 wv
->button_type
= BUTTON_TYPE_NONE
;
1125 items
= FRAME_MENU_BAR_ITEMS (f
);
1126 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1130 string
= XVECTOR (items
)->contents
[i
+ 1];
1134 wv
= xmalloc_widget_value ();
1135 wv
->name
= (char *) SDATA (string
);
1138 wv
->button_type
= BUTTON_TYPE_NONE
;
1140 /* This prevents lwlib from assuming this
1141 menu item is really supposed to be empty. */
1142 /* The EMACS_INT cast avoids a warning.
1143 This value just has to be different from small integers. */
1144 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1149 first_wv
->contents
= wv
;
1153 /* Forget what we thought we knew about what is in the
1154 detailed contents of the menu bar menus.
1155 Changing the top level always destroys the contents. */
1156 f
->menu_bar_items_used
= 0;
1159 /* Create or update the menu bar widget. */
1164 xg_crazy_callback_abort
= 1;
1167 /* The fourth arg is DEEP_P, which says to consider the entire
1168 menu trees we supply, rather than just the menu bar item names. */
1169 xg_modify_menubar_widgets (menubar_widget
,
1173 G_CALLBACK (menubar_selection_callback
),
1174 G_CALLBACK (popup_deactivate_callback
),
1175 G_CALLBACK (menu_highlight_callback
));
1179 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
1182 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
1183 G_CALLBACK (menubar_selection_callback
),
1184 G_CALLBACK (popup_deactivate_callback
),
1185 G_CALLBACK (menu_highlight_callback
));
1187 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1191 #else /* not USE_GTK */
1194 /* Disable resizing (done for Motif!) */
1195 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1197 /* The third arg is DEEP_P, which says to consider the entire
1198 menu trees we supply, rather than just the menu bar item names. */
1199 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1201 /* Re-enable the edit widget to resize. */
1202 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1206 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
1207 XtTranslations override
= XtParseTranslationTable (menuOverride
);
1209 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1210 f
->output_data
.x
->column_widget
,
1212 popup_activate_callback
,
1213 menubar_selection_callback
,
1214 popup_deactivate_callback
,
1215 menu_highlight_callback
);
1216 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1218 /* Make menu pop down on C-g. */
1219 XtOverrideTranslations (menubar_widget
, override
);
1221 apply_systemfont_to_menu (menubar_widget
);
1227 if (f
->output_data
.x
->menubar_widget
)
1228 XtRealizeWidget (f
->output_data
.x
->menubar_widget
);
1231 = (f
->output_data
.x
->menubar_widget
1232 ? (f
->output_data
.x
->menubar_widget
->core
.height
1233 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1236 #if 1 /* Experimentally, we now get the right results
1237 for -geometry -0-0 without this. 24 Aug 96, rms.
1238 Maybe so, but the menu bar size is missing the pixels so the
1239 WM size hints are off by these pixels. Jan D, oct 2009. */
1241 if (FRAME_EXTERNAL_MENU_BAR (f
))
1244 XtVaGetValues (f
->output_data
.x
->column_widget
,
1245 XtNinternalBorderWidth
, &ibw
, NULL
);
1246 menubar_size
+= ibw
;
1248 #endif /* USE_LUCID */
1251 f
->output_data
.x
->menubar_height
= menubar_size
;
1253 #endif /* not USE_GTK */
1255 free_menubar_widget_value_tree (first_wv
);
1256 update_frame_menubar (f
);
1259 xg_crazy_callback_abort
= 0;
1265 /* Called from Fx_create_frame to create the initial menubar of a frame
1266 before it is mapped, so that the window is mapped with the menubar already
1267 there instead of us tacking it on later and thrashing the window after it
1271 initialize_frame_menubar (FRAME_PTR f
)
1273 /* This function is called before the first chance to redisplay
1274 the frame. It has to be, so the frame will have the right size. */
1275 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1276 set_frame_menubar (f
, 1, 1);
1280 /* Get rid of the menu bar of frame F, and free its storage.
1281 This is used when deleting a frame, and when turning off the menu bar.
1282 For GTK this function is in gtkutil.c. */
1286 free_frame_menubar (FRAME_PTR f
)
1288 Widget menubar_widget
;
1290 if (! FRAME_X_P (f
))
1293 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1295 f
->output_data
.x
->menubar_height
= 0;
1300 /* Removing the menu bar magically changes the shell widget's x
1301 and y position of (0, 0) which, when the menu bar is turned
1302 on again, leads to pull-down menuss appearing in strange
1303 positions near the upper-left corner of the display. This
1304 happens only with some window managers like twm and ctwm,
1305 but not with other like Motif's mwm or kwm, because the
1306 latter generate ConfigureNotify events when the menu bar
1307 is switched off, which fixes the shell position. */
1308 Position x0
, y0
, x1
, y1
;
1314 if (f
->output_data
.x
->widget
)
1315 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1318 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1319 f
->output_data
.x
->menubar_widget
= NULL
;
1321 if (f
->output_data
.x
->widget
)
1324 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1325 if (x1
== 0 && y1
== 0)
1326 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1328 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1333 #endif /* not USE_GTK */
1335 #endif /* USE_X_TOOLKIT || USE_GTK */
1337 /* xmenu_show actually displays a menu using the panes and items in menu_items
1338 and returns the value selected from it.
1339 There are two versions of xmenu_show, one for Xt and one for Xlib.
1340 Both assume input is blocked by the caller. */
1342 /* F is the frame the menu is for.
1343 X and Y are the frame-relative specified position,
1344 relative to the inside upper left corner of the frame F.
1345 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1346 KEYMAPS is 1 if this menu was specified with keymaps;
1347 in that case, we return a list containing the chosen item's value
1348 and perhaps also the pane's prefix.
1349 TITLE is the specified menu title.
1350 ERROR is a place to store an error message string in case of failure.
1351 (We return nil on failure, but the value doesn't actually matter.) */
1353 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1355 /* The item selected in the popup menu. */
1356 static Lisp_Object
*volatile menu_item_selection
;
1360 /* Used when position a popup menu. See menu_position_func and
1361 create_and_show_popup_menu below. */
1362 struct next_popup_x_y
1369 /* The menu position function to use if we are not putting a popup
1370 menu where the pointer is.
1371 MENU is the menu to pop up.
1372 X and Y shall on exit contain x/y where the menu shall pop up.
1373 PUSH_IN is not documented in the GTK manual.
1374 USER_DATA is any data passed in when calling gtk_menu_popup.
1375 Here it points to a struct next_popup_x_y where the coordinates
1376 to store in *X and *Y are as well as the frame for the popup.
1378 Here only X and Y are used. */
1380 menu_position_func (GtkMenu
*menu
, gint
*x
, gint
*y
, gboolean
*push_in
, gpointer user_data
)
1382 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
1384 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (data
->f
);
1385 int disp_width
= x_display_pixel_width (dpyinfo
);
1386 int disp_height
= x_display_pixel_height (dpyinfo
);
1391 /* Check if there is room for the menu. If not, adjust x/y so that
1392 the menu is fully visible. */
1393 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
1394 if (data
->x
+ req
.width
> disp_width
)
1395 *x
-= data
->x
+ req
.width
- disp_width
;
1396 if (data
->y
+ req
.height
> disp_height
)
1397 *y
-= data
->y
+ req
.height
- disp_height
;
1401 popup_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1403 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1405 if (xg_crazy_callback_abort
) return;
1406 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
1410 pop_down_menu (Lisp_Object arg
)
1412 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1414 popup_activated_flag
= 0;
1416 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1421 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1423 menu_item_selection will be set to the selection. */
1425 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
, int x
, int y
, int for_click
, EMACS_UINT timestamp
)
1429 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
1430 struct next_popup_x_y popup_x_y
;
1431 int specpdl_count
= SPECPDL_INDEX ();
1433 if (! FRAME_X_P (f
))
1436 xg_crazy_callback_abort
= 1;
1437 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
1438 G_CALLBACK (popup_selection_callback
),
1439 G_CALLBACK (popup_deactivate_callback
),
1440 G_CALLBACK (menu_highlight_callback
));
1441 xg_crazy_callback_abort
= 0;
1445 /* Not invoked by a click. pop up at x/y. */
1446 pos_func
= menu_position_func
;
1448 /* Adjust coordinates to be root-window-relative. */
1449 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1450 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1456 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1460 for (i
= 0; i
< 5; i
++)
1461 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1465 /* Display the menu. */
1466 gtk_widget_show_all (menu
);
1468 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
,
1469 timestamp
> 0 ? timestamp
: gtk_get_current_event_time());
1471 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1473 if (gtk_widget_get_mapped (menu
))
1475 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1476 two. show_help_echo uses this to detect popup menus. */
1477 popup_activated_flag
= 1;
1478 /* Process events that apply to the menu. */
1479 popup_widget_loop (1, menu
);
1482 unbind_to (specpdl_count
, Qnil
);
1484 /* Must reset this manually because the button release event is not passed
1485 to Emacs event loop. */
1486 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1489 #else /* not USE_GTK */
1491 /* We need a unique id for each widget handled by the Lucid Widget
1494 For the main windows, and popup menus, we use this counter,
1495 which we increment each time after use. This starts from 1<<16.
1497 For menu bars, we use numbers starting at 0, counted in
1498 next_menubar_widget_id. */
1499 LWLIB_ID widget_id_tick
;
1502 popup_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1504 menu_item_selection
= (Lisp_Object
*) client_data
;
1507 /* ARG is the LWLIB ID of the dialog box, represented
1508 as a Lisp object as (HIGHPART . LOWPART). */
1511 pop_down_menu (Lisp_Object arg
)
1513 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
1514 | XINT (XCDR (arg
)));
1517 lw_destroy_all_widgets (id
);
1519 popup_activated_flag
= 0;
1524 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1526 menu_item_selection will be set to the selection. */
1528 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
,
1529 int x
, int y
, int for_click
, EMACS_UINT timestamp
)
1534 XButtonPressedEvent dummy
;
1538 if (! FRAME_X_P (f
))
1541 menu_id
= widget_id_tick
++;
1542 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1543 f
->output_data
.x
->widget
, 1, 0,
1544 popup_selection_callback
,
1545 popup_deactivate_callback
,
1546 menu_highlight_callback
);
1549 apply_systemfont_to_menu (menu
);
1552 dummy
.type
= ButtonPress
;
1554 dummy
.send_event
= 0;
1555 dummy
.display
= FRAME_X_DISPLAY (f
);
1556 dummy
.time
= CurrentTime
;
1557 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1558 dummy
.window
= dummy
.root
;
1559 dummy
.subwindow
= dummy
.root
;
1563 /* Adjust coordinates to be root-window-relative. */
1564 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1565 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1572 for (i
= 0; i
< 5; i
++)
1573 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1576 /* Don't allow any geometry request from the user. */
1577 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
1578 XtSetValues (menu
, av
, ac
);
1580 /* Display the menu. */
1581 lw_popup_menu (menu
, (XEvent
*) &dummy
);
1582 popup_activated_flag
= 1;
1583 x_activate_timeout_atimer ();
1586 int fact
= 4 * sizeof (LWLIB_ID
);
1587 int specpdl_count
= SPECPDL_INDEX ();
1588 record_unwind_protect (pop_down_menu
,
1589 Fcons (make_number (menu_id
>> (fact
)),
1590 make_number (menu_id
& ~(-1 << (fact
)))));
1592 /* Process events that apply to the menu. */
1593 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
1595 unbind_to (specpdl_count
, Qnil
);
1599 #endif /* not USE_GTK */
1602 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
1603 Lisp_Object title
, const char **error
, EMACS_UINT timestamp
)
1606 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1607 widget_value
**submenu_stack
1608 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1609 Lisp_Object
*subprefix_stack
1610 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1611 int submenu_depth
= 0;
1615 if (! FRAME_X_P (f
))
1620 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1622 *error
= "Empty menu";
1626 /* Create a tree of widget_value objects
1627 representing the panes and their items. */
1628 wv
= xmalloc_widget_value ();
1632 wv
->button_type
= BUTTON_TYPE_NONE
;
1637 /* Loop over all panes and items, filling in the tree. */
1639 while (i
< menu_items_used
)
1641 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1643 submenu_stack
[submenu_depth
++] = save_wv
;
1649 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1652 save_wv
= submenu_stack
[--submenu_depth
];
1656 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1657 && submenu_depth
!= 0)
1658 i
+= MENU_ITEMS_PANE_LENGTH
;
1659 /* Ignore a nil in the item list.
1660 It's meaningful only for dialog boxes. */
1661 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1663 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1665 /* Create a new pane. */
1666 Lisp_Object pane_name
, prefix
;
1667 const char *pane_string
;
1669 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1670 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1672 #ifndef HAVE_MULTILINGUAL_MENU
1673 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1675 pane_name
= ENCODE_MENU_STRING (pane_name
);
1676 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1679 pane_string
= (NILP (pane_name
)
1680 ? "" : (char *) SDATA (pane_name
));
1681 /* If there is just one top-level pane, put all its items directly
1682 under the top-level menu. */
1683 if (menu_items_n_panes
== 1)
1686 /* If the pane has a meaningful name,
1687 make the pane a top-level menu item
1688 with its items as a submenu beneath it. */
1689 if (!keymaps
&& strcmp (pane_string
, ""))
1691 wv
= xmalloc_widget_value ();
1695 first_wv
->contents
= wv
;
1696 wv
->name
= pane_string
;
1697 if (keymaps
&& !NILP (prefix
))
1701 wv
->button_type
= BUTTON_TYPE_NONE
;
1706 else if (first_pane
)
1712 i
+= MENU_ITEMS_PANE_LENGTH
;
1716 /* Create a new item within current pane. */
1717 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
1718 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1719 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1720 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1721 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1722 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1723 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1724 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1726 #ifndef HAVE_MULTILINGUAL_MENU
1727 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
1729 item_name
= ENCODE_MENU_STRING (item_name
);
1730 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1733 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1735 descrip
= ENCODE_MENU_STRING (descrip
);
1736 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1738 #endif /* not HAVE_MULTILINGUAL_MENU */
1740 wv
= xmalloc_widget_value ();
1744 save_wv
->contents
= wv
;
1745 wv
->name
= (char *) SDATA (item_name
);
1746 if (!NILP (descrip
))
1747 wv
->key
= (char *) SDATA (descrip
);
1749 /* If this item has a null value,
1750 make the call_data null so that it won't display a box
1751 when the mouse is on it. */
1753 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
1754 wv
->enabled
= !NILP (enable
);
1757 wv
->button_type
= BUTTON_TYPE_NONE
;
1758 else if (EQ (type
, QCtoggle
))
1759 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1760 else if (EQ (type
, QCradio
))
1761 wv
->button_type
= BUTTON_TYPE_RADIO
;
1765 wv
->selected
= !NILP (selected
);
1767 if (! STRINGP (help
))
1774 i
+= MENU_ITEMS_ITEM_LENGTH
;
1778 /* Deal with the title, if it is non-nil. */
1781 widget_value
*wv_title
= xmalloc_widget_value ();
1782 widget_value
*wv_sep1
= xmalloc_widget_value ();
1783 widget_value
*wv_sep2
= xmalloc_widget_value ();
1785 wv_sep2
->name
= "--";
1786 wv_sep2
->next
= first_wv
->contents
;
1787 wv_sep2
->help
= Qnil
;
1789 wv_sep1
->name
= "--";
1790 wv_sep1
->next
= wv_sep2
;
1791 wv_sep1
->help
= Qnil
;
1793 #ifndef HAVE_MULTILINGUAL_MENU
1794 if (STRING_MULTIBYTE (title
))
1795 title
= ENCODE_MENU_STRING (title
);
1798 wv_title
->name
= (char *) SDATA (title
);
1799 wv_title
->enabled
= TRUE
;
1800 wv_title
->button_type
= BUTTON_TYPE_NONE
;
1801 wv_title
->help
= Qnil
;
1802 wv_title
->next
= wv_sep1
;
1803 first_wv
->contents
= wv_title
;
1806 /* No selection has been chosen yet. */
1807 menu_item_selection
= 0;
1809 /* Actually create and show the menu until popped down. */
1810 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
, timestamp
);
1812 /* Free the widget_value objects we used to specify the contents. */
1813 free_menubar_widget_value_tree (first_wv
);
1815 /* Find the selected item, and its pane, to return
1816 the proper value. */
1817 if (menu_item_selection
!= 0)
1819 Lisp_Object prefix
, entry
;
1821 prefix
= entry
= Qnil
;
1823 while (i
< menu_items_used
)
1825 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1827 subprefix_stack
[submenu_depth
++] = prefix
;
1831 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1833 prefix
= subprefix_stack
[--submenu_depth
];
1836 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1839 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1840 i
+= MENU_ITEMS_PANE_LENGTH
;
1842 /* Ignore a nil in the item list.
1843 It's meaningful only for dialog boxes. */
1844 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1849 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1850 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
1856 entry
= Fcons (entry
, Qnil
);
1858 entry
= Fcons (prefix
, entry
);
1859 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1860 if (!NILP (subprefix_stack
[j
]))
1861 entry
= Fcons (subprefix_stack
[j
], entry
);
1865 i
+= MENU_ITEMS_ITEM_LENGTH
;
1869 else if (!for_click
)
1870 /* Make "Cancel" equivalent to C-g. */
1871 Fsignal (Qquit
, Qnil
);
1878 dialog_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1880 /* The EMACS_INT cast avoids a warning. There's no problem
1881 as long as pointers have enough bits to hold small integers. */
1882 if ((int) (EMACS_INT
) client_data
!= -1)
1883 menu_item_selection
= (Lisp_Object
*) client_data
;
1885 popup_activated_flag
= 0;
1888 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1890 menu_item_selection will be set to the selection. */
1892 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1896 if (! FRAME_X_P (f
))
1899 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
1900 G_CALLBACK (dialog_selection_callback
),
1901 G_CALLBACK (popup_deactivate_callback
),
1906 int specpdl_count
= SPECPDL_INDEX ();
1907 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1909 /* Display the menu. */
1910 gtk_widget_show_all (menu
);
1912 /* Process events that apply to the menu. */
1913 popup_widget_loop (1, menu
);
1915 unbind_to (specpdl_count
, Qnil
);
1919 #else /* not USE_GTK */
1921 dialog_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1923 /* The EMACS_INT cast avoids a warning. There's no problem
1924 as long as pointers have enough bits to hold small integers. */
1925 if ((int) (EMACS_INT
) client_data
!= -1)
1926 menu_item_selection
= (Lisp_Object
*) client_data
;
1929 lw_destroy_all_widgets (id
);
1931 popup_activated_flag
= 0;
1935 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1937 menu_item_selection will be set to the selection. */
1939 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1946 dialog_id
= widget_id_tick
++;
1948 apply_systemfont_to_dialog (f
->output_data
.x
->widget
);
1950 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1951 f
->output_data
.x
->widget
, 1, 0,
1952 dialog_selection_callback
, 0, 0);
1953 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1954 /* Display the dialog box. */
1955 lw_pop_up_all_widgets (dialog_id
);
1956 popup_activated_flag
= 1;
1957 x_activate_timeout_atimer ();
1959 /* Process events that apply to the dialog box.
1960 Also handle timers. */
1962 int count
= SPECPDL_INDEX ();
1963 int fact
= 4 * sizeof (LWLIB_ID
);
1965 /* xdialog_show_unwind is responsible for popping the dialog box down. */
1966 record_unwind_protect (pop_down_menu
,
1967 Fcons (make_number (dialog_id
>> (fact
)),
1968 make_number (dialog_id
& ~(-1 << (fact
)))));
1970 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
1973 unbind_to (count
, Qnil
);
1977 #endif /* not USE_GTK */
1979 static const char * button_names
[] = {
1980 "button1", "button2", "button3", "button4", "button5",
1981 "button6", "button7", "button8", "button9", "button10" };
1984 xdialog_show (FRAME_PTR f
,
1988 const char **error_name
)
1990 int i
, nb_buttons
=0;
1991 char dialog_name
[6];
1993 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
1995 /* Number of elements seen so far, before boundary. */
1997 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
1998 int boundary_seen
= 0;
2000 if (! FRAME_X_P (f
))
2005 if (menu_items_n_panes
> 1)
2007 *error_name
= "Multiple panes in dialog box";
2011 /* Create a tree of widget_value objects
2012 representing the text label and buttons. */
2014 Lisp_Object pane_name
, prefix
;
2015 const char *pane_string
;
2016 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2017 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2018 pane_string
= (NILP (pane_name
)
2019 ? "" : (char *) SDATA (pane_name
));
2020 prev_wv
= xmalloc_widget_value ();
2021 prev_wv
->value
= pane_string
;
2022 if (keymaps
&& !NILP (prefix
))
2024 prev_wv
->enabled
= 1;
2025 prev_wv
->name
= "message";
2026 prev_wv
->help
= Qnil
;
2029 /* Loop over all panes and items, filling in the tree. */
2030 i
= MENU_ITEMS_PANE_LENGTH
;
2031 while (i
< menu_items_used
)
2034 /* Create a new item within current pane. */
2035 Lisp_Object item_name
, enable
, descrip
;
2036 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2037 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2039 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2041 if (NILP (item_name
))
2043 free_menubar_widget_value_tree (first_wv
);
2044 *error_name
= "Submenu in dialog items";
2047 if (EQ (item_name
, Qquote
))
2049 /* This is the boundary between left-side elts
2050 and right-side elts. Stop incrementing right_count. */
2055 if (nb_buttons
>= 9)
2057 free_menubar_widget_value_tree (first_wv
);
2058 *error_name
= "Too many dialog items";
2062 wv
= xmalloc_widget_value ();
2064 wv
->name
= (char *) button_names
[nb_buttons
];
2065 if (!NILP (descrip
))
2066 wv
->key
= (char *) SDATA (descrip
);
2067 wv
->value
= (char *) SDATA (item_name
);
2068 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2069 wv
->enabled
= !NILP (enable
);
2073 if (! boundary_seen
)
2077 i
+= MENU_ITEMS_ITEM_LENGTH
;
2080 /* If the boundary was not specified,
2081 by default put half on the left and half on the right. */
2082 if (! boundary_seen
)
2083 left_count
= nb_buttons
- nb_buttons
/ 2;
2085 wv
= xmalloc_widget_value ();
2086 wv
->name
= dialog_name
;
2089 /* Frame title: 'Q' = Question, 'I' = Information.
2090 Can also have 'E' = Error if, one day, we want
2091 a popup for errors. */
2093 dialog_name
[0] = 'Q';
2095 dialog_name
[0] = 'I';
2097 /* Dialog boxes use a really stupid name encoding
2098 which specifies how many buttons to use
2099 and how many buttons are on the right. */
2100 dialog_name
[1] = '0' + nb_buttons
;
2101 dialog_name
[2] = 'B';
2102 dialog_name
[3] = 'R';
2103 /* Number of buttons to put on the right. */
2104 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2106 wv
->contents
= first_wv
;
2110 /* No selection has been chosen yet. */
2111 menu_item_selection
= 0;
2113 /* Actually create and show the dialog. */
2114 create_and_show_dialog (f
, first_wv
);
2116 /* Free the widget_value objects we used to specify the contents. */
2117 free_menubar_widget_value_tree (first_wv
);
2119 /* Find the selected item, and its pane, to return
2120 the proper value. */
2121 if (menu_item_selection
!= 0)
2127 while (i
< menu_items_used
)
2131 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2134 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2135 i
+= MENU_ITEMS_PANE_LENGTH
;
2137 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2139 /* This is the boundary between left-side elts and
2146 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2147 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2151 entry
= Fcons (entry
, Qnil
);
2153 entry
= Fcons (prefix
, entry
);
2157 i
+= MENU_ITEMS_ITEM_LENGTH
;
2162 /* Make "Cancel" equivalent to C-g. */
2163 Fsignal (Qquit
, Qnil
);
2168 #else /* not USE_X_TOOLKIT && not USE_GTK */
2170 /* The frame of the last activated non-toolkit menu bar.
2171 Used to generate menu help events. */
2173 static struct frame
*menu_help_frame
;
2176 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2178 PANE is the pane number, and ITEM is the menu item number in
2179 the menu (currently not used).
2181 This cannot be done with generating a HELP_EVENT because
2182 XMenuActivate contains a loop that doesn't let Emacs process
2186 menu_help_callback (char *help_string
, int pane
, int item
)
2188 Lisp_Object
*first_item
;
2189 Lisp_Object pane_name
;
2190 Lisp_Object menu_object
;
2192 first_item
= XVECTOR (menu_items
)->contents
;
2193 if (EQ (first_item
[0], Qt
))
2194 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2195 else if (EQ (first_item
[0], Qquote
))
2196 /* This shouldn't happen, see xmenu_show. */
2197 pane_name
= empty_unibyte_string
;
2199 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2201 /* (menu-item MENU-NAME PANE-NUMBER) */
2202 menu_object
= Fcons (Qmenu_item
,
2204 Fcons (make_number (pane
), Qnil
)));
2205 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2206 Qnil
, menu_object
, make_number (item
), 1);
2210 pop_down_menu (Lisp_Object arg
)
2212 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
2213 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
2215 FRAME_PTR f
= p1
->pointer
;
2216 XMenu
*menu
= p2
->pointer
;
2220 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
2221 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
2223 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2225 #ifdef HAVE_X_WINDOWS
2226 /* Assume the mouse has moved out of the X window.
2227 If it has actually moved in, we will get an EnterNotify. */
2228 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2230 /* State that no mouse buttons are now held.
2231 (The oldXMenu code doesn't track this info for us.)
2232 That is not necessarily true, but the fiction leads to reasonable
2233 results, and it is a pain to ask which are actually held now. */
2234 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2236 #endif /* HAVE_X_WINDOWS */
2245 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
2246 Lisp_Object title
, const char **error
, EMACS_UINT timestamp
)
2250 int pane
, selidx
, lpane
, status
;
2251 Lisp_Object entry
, pane_prefix
;
2253 int ulx
, uly
, width
, height
;
2254 int dispwidth
, dispheight
;
2255 int i
, j
, lines
, maxlines
;
2258 unsigned int dummy_uint
;
2259 int specpdl_count
= SPECPDL_INDEX ();
2261 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
2265 if (menu_items_n_panes
== 0)
2268 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2270 *error
= "Empty menu";
2274 /* Figure out which root window F is on. */
2275 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2276 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2277 &dummy_uint
, &dummy_uint
);
2279 /* Make the menu on that window. */
2280 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2283 *error
= "Can't create menu";
2287 /* Don't GC while we prepare and show the menu,
2288 because we give the oldxmenu library pointers to the
2289 contents of strings. */
2290 inhibit_garbage_collection ();
2292 #ifdef HAVE_X_WINDOWS
2293 /* Adjust coordinates to relative to the outer (window manager) window. */
2294 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
2295 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2296 #endif /* HAVE_X_WINDOWS */
2298 /* Adjust coordinates to be root-window-relative. */
2302 /* Create all the necessary panes and their items. */
2303 maxlines
= lines
= i
= 0;
2304 while (i
< menu_items_used
)
2306 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2308 /* Create a new pane. */
2309 Lisp_Object pane_name
, prefix
;
2312 maxlines
= max (maxlines
, lines
);
2314 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2315 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2316 pane_string
= (NILP (pane_name
)
2317 ? "" : (char *) SDATA (pane_name
));
2318 if (keymaps
&& !NILP (prefix
))
2321 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2322 if (lpane
== XM_FAILURE
)
2324 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2325 *error
= "Can't create pane";
2328 i
+= MENU_ITEMS_PANE_LENGTH
;
2330 /* Find the width of the widest item in this pane. */
2333 while (j
< menu_items_used
)
2336 item
= XVECTOR (menu_items
)->contents
[j
];
2344 width
= SBYTES (item
);
2345 if (width
> maxwidth
)
2348 j
+= MENU_ITEMS_ITEM_LENGTH
;
2351 /* Ignore a nil in the item list.
2352 It's meaningful only for dialog boxes. */
2353 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2357 /* Create a new item within current pane. */
2358 Lisp_Object item_name
, enable
, descrip
, help
;
2359 unsigned char *item_data
;
2362 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2363 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2365 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2366 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2367 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
2369 if (!NILP (descrip
))
2371 int gap
= maxwidth
- SBYTES (item_name
);
2372 /* if alloca is fast, use that to make the space,
2373 to reduce gc needs. */
2375 = (unsigned char *) alloca (maxwidth
2376 + SBYTES (descrip
) + 1);
2377 memcpy (item_data
, SDATA (item_name
), SBYTES (item_name
));
2378 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
2380 memcpy (item_data
+ j
, SDATA (descrip
), SBYTES (descrip
));
2381 item_data
[j
+ SBYTES (descrip
)] = 0;
2384 item_data
= SDATA (item_name
);
2386 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2387 menu
, lpane
, 0, item_data
,
2388 !NILP (enable
), help_string
)
2391 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2392 *error
= "Can't add selection to menu";
2395 i
+= MENU_ITEMS_ITEM_LENGTH
;
2400 maxlines
= max (maxlines
, lines
);
2402 /* All set and ready to fly. */
2403 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2404 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2405 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2406 x
= min (x
, dispwidth
);
2407 y
= min (y
, dispheight
);
2410 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2411 &ulx
, &uly
, &width
, &height
);
2412 if (ulx
+width
> dispwidth
)
2414 x
-= (ulx
+ width
) - dispwidth
;
2415 ulx
= dispwidth
- width
;
2417 if (uly
+height
> dispheight
)
2419 y
-= (uly
+ height
) - dispheight
;
2420 uly
= dispheight
- height
;
2422 #ifndef HAVE_X_WINDOWS
2423 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 1)
2425 /* Move the menu away of the echo area, to avoid overwriting the
2426 menu with help echo messages or vice versa. */
2427 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
2429 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2430 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2439 if (ulx
< 0) x
-= ulx
;
2440 if (uly
< 0) y
-= uly
;
2444 /* If position was not given by a mouse click, adjust so upper left
2445 corner of the menu as a whole ends up at given coordinates. This
2446 is what x-popup-menu says in its documentation. */
2448 y
+= 1.5*height
/(maxlines
+2);
2451 XMenuSetAEQ (menu
, TRUE
);
2452 XMenuSetFreeze (menu
, TRUE
);
2456 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
2459 record_unwind_protect (pop_down_menu
,
2460 Fcons (make_save_value (f
, 0),
2461 make_save_value (menu
, 0)));
2463 /* Help display under X won't work because XMenuActivate contains
2464 a loop that doesn't give Emacs a chance to process it. */
2465 menu_help_frame
= f
;
2466 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2467 x
, y
, ButtonReleaseMask
, &datap
,
2468 menu_help_callback
);
2474 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2477 /* Find the item number SELIDX in pane number PANE. */
2479 while (i
< menu_items_used
)
2481 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2485 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2487 i
+= MENU_ITEMS_PANE_LENGTH
;
2496 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2499 entry
= Fcons (entry
, Qnil
);
2500 if (!NILP (pane_prefix
))
2501 entry
= Fcons (pane_prefix
, entry
);
2507 i
+= MENU_ITEMS_ITEM_LENGTH
;
2513 *error
= "Can't activate menu";
2518 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2519 the menu was invoked with a mouse event as POSITION). */
2521 Fsignal (Qquit
, Qnil
);
2526 unbind_to (specpdl_count
, Qnil
);
2531 #endif /* not USE_X_TOOLKIT */
2533 #endif /* HAVE_MENUS */
2535 /* Detect if a dialog or menu has been posted. */
2538 popup_activated (void)
2540 return popup_activated_flag
;
2543 /* The following is used by delayed window autoselection. */
2545 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
2546 doc
: /* Return t if a menu or popup dialog is active. */)
2550 return (popup_activated ()) ? Qt
: Qnil
;
2553 #endif /* HAVE_MENUS */
2557 syms_of_xmenu (void)
2559 Qdebug_on_next_call
= intern_c_string ("debug-on-next-call");
2560 staticpro (&Qdebug_on_next_call
);
2562 #ifdef USE_X_TOOLKIT
2563 widget_id_tick
= (1<<16);
2564 next_menubar_widget_id
= 1;
2567 defsubr (&Smenu_or_popup_active_p
);
2569 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2570 defsubr (&Sx_menu_bar_open_internal
);
2571 Ffset (intern_c_string ("accelerate-menu"),
2572 intern_c_string (Sx_menu_bar_open_internal
.symbol_name
));
2576 defsubr (&Sx_popup_dialog
);
2580 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
2581 (do not change this comment) */