1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2012
4 Free Software Foundation, Inc.
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. */
35 #if 0 /* Why was this included? And without syssignal.h? */
36 /* On 4.3 this loses if it comes after xterm.h. */
47 #include "termhooks.h"
49 #include "blockinput.h"
50 #include "character.h"
54 #include "sysselect.h"
61 /* This may include sys/types.h, and that somehow loses
62 if this is not done before the other system files. */
66 /* Load sys/types.h if not already loaded.
67 In some systems loading it twice is suicidal. */
69 #include <sys/types.h>
72 #include "dispextern.h"
75 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
76 code accepts the Emacs internal encoding. */
77 #undef HAVE_MULTILINGUAL_MENU
81 #include <X11/IntrinsicP.h>
82 #include <X11/CoreP.h>
83 #include <X11/StringDefs.h>
84 #include <X11/Shell.h>
86 #include "xsettings.h"
87 #include "../lwlib/xlwmenu.h"
89 #include <X11/Xaw3d/Paned.h>
90 #else /* !HAVE_XAW3D */
91 #include <X11/Xaw/Paned.h>
92 #endif /* HAVE_XAW3D */
93 #endif /* USE_LUCID */
95 #include "../lwlib/lwlib.h"
97 #else /* not USE_X_TOOLKIT */
99 #include "../oldXMenu/XMenu.h"
101 #endif /* not USE_X_TOOLKIT */
102 #endif /* HAVE_X_WINDOWS */
107 #include "xgselect.h"
117 static Lisp_Object Qdebug_on_next_call
;
119 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
120 static Lisp_Object
xdialog_show (FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
124 /* Flag which when set indicates a dialog or menu has been posted by
125 Xt on behalf of one of the widget sets. */
126 static int popup_activated_flag
;
131 static int next_menubar_widget_id
;
133 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
135 static struct frame
*
136 menubar_id_to_frame (LWLIB_ID id
)
138 Lisp_Object tail
, frame
;
141 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
147 if (!FRAME_WINDOW_P (f
))
149 if (f
->output_data
.x
->id
== id
)
157 #ifdef HAVE_X_WINDOWS
158 /* Return the mouse position in *X and *Y. The coordinates are window
159 relative for the edit window in frame F.
160 This is for Fx_popup_menu. The mouse_position_hook can not
161 be used for X, as it returns window relative coordinates
162 for the window where the mouse is in. This could be the menu bar,
163 the scroll bar or the edit window. Fx_popup_menu needs to be
164 sure it is the edit window. */
166 mouse_position_for_popup (FRAME_PTR f
, int *x
, int *y
)
168 Window root
, dummy_window
;
176 XQueryPointer (FRAME_X_DISPLAY (f
),
177 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
179 /* The root window which contains the pointer. */
182 /* Window pointer is on, not used */
185 /* The position on that root window. */
188 /* x/y in dummy_window coordinates, not used. */
191 /* Modifier keys and pointer buttons, about which
193 (unsigned int *) &dummy
);
197 /* xmenu_show expects window coordinates, not root window
198 coordinates. Translate. */
199 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
200 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
203 #endif /* HAVE_X_WINDOWS */
207 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
208 doc
: /* Pop up a dialog box and return user's selection.
209 POSITION specifies which frame to use.
210 This is normally a mouse button event or a window or frame.
211 If POSITION is t, it means to use the frame the mouse is on.
212 The dialog box appears in the middle of the specified frame.
214 CONTENTS specifies the alternatives to display in the dialog box.
215 It is a list of the form (DIALOG ITEM1 ITEM2...).
216 Each ITEM is a cons cell (STRING . VALUE).
217 The return value is VALUE from the chosen item.
219 An ITEM may also be just a string--that makes a nonselectable item.
220 An ITEM may also be nil--that means to put all preceding items
221 on the left of the dialog box and all following items on the right.
222 \(By default, approximately half appear on each side.)
224 If HEADER is non-nil, the frame title for the box is "Information",
225 otherwise it is "Question".
227 If the user gets rid of the dialog box without making a valid choice,
228 for instance using the window manager, then this produces a quit and
229 `x-popup-dialog' does not return. */)
230 (Lisp_Object position
, Lisp_Object contents
, Lisp_Object header
)
237 /* Decode the first argument: find the window or frame to use. */
238 if (EQ (position
, Qt
)
239 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
240 || EQ (XCAR (position
), Qtool_bar
))))
242 #if 0 /* Using the frame the mouse is on may not be right. */
243 /* Use the mouse's current position. */
244 FRAME_PTR new_f
= SELECTED_FRAME ();
245 Lisp_Object bar_window
;
246 enum scroll_bar_part part
;
250 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
253 XSETFRAME (window
, new_f
);
255 window
= selected_window
;
257 window
= selected_window
;
259 else if (CONSP (position
))
261 Lisp_Object tem
= XCAR (position
);
263 window
= Fcar (Fcdr (position
));
266 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
267 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
270 else if (WINDOWP (position
) || FRAMEP (position
))
275 /* Decode where to put the menu. */
279 else if (WINDOWP (window
))
281 CHECK_LIVE_WINDOW (window
);
282 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
285 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
286 but I don't want to make one now. */
287 CHECK_WINDOW (window
);
289 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
290 error ("Can not put X dialog on this terminal");
292 /* Force a redisplay before showing the dialog. If a frame is created
293 just before showing the dialog, its contents may not have been fully
294 drawn, as this depends on timing of events from the X server. Redisplay
295 is not done when a dialog is shown. If redisplay could be done in the
296 X event loop (i.e. the X event loop does not run in a signal handler)
297 this would not be needed.
299 Do this before creating the widget value that points to Lisp
300 string contents, because Fredisplay may GC and relocate them. */
303 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
304 /* Display a menu with these alternatives
305 in the middle of frame F. */
307 Lisp_Object x
, y
, frame
, newpos
;
308 XSETFRAME (frame
, f
);
309 XSETINT (x
, x_pixel_width (f
) / 2);
310 XSETINT (y
, x_pixel_height (f
) / 2);
311 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
313 return Fx_popup_menu (newpos
,
314 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
319 const char *error_name
;
320 Lisp_Object selection
;
321 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
323 /* Decode the dialog items from what was specified. */
324 title
= Fcar (contents
);
325 CHECK_STRING (title
);
326 record_unwind_protect (unuse_menu_items
, Qnil
);
328 if (NILP (Fcar (Fcdr (contents
))))
329 /* No buttons specified, add an "Ok" button so users can pop down
330 the dialog. Also, the lesstif/motif version crashes if there are
332 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
334 list_of_panes (Fcons (contents
, Qnil
));
336 /* Display them in a dialog box. */
338 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
341 unbind_to (specpdl_count
, Qnil
);
342 discard_menu_items ();
344 if (error_name
) error ("%s", error_name
);
353 #if defined USE_GTK || defined USE_MOTIF
355 /* Set menu_items_inuse so no other popup menu or dialog is created. */
358 x_menu_set_in_use (int in_use
)
360 menu_items_inuse
= in_use
? Qt
: Qnil
;
361 popup_activated_flag
= in_use
;
363 if (popup_activated_flag
)
364 x_activate_timeout_atimer ();
370 /* Wait for an X event to arrive or for a timer to expire. */
376 x_menu_wait_for_event (void *data
)
378 /* Another way to do this is to register a timer callback, that can be
379 done in GTK and Xt. But we have to do it like this when using only X
380 anyway, and with callbacks we would have three variants for timer handling
381 instead of the small ifdefs below. */
385 ! XtAppPending (Xt_app_con
)
386 #elif defined USE_GTK
387 ! gtk_events_pending ()
389 ! XPending ((Display
*) data
)
393 EMACS_TIME next_time
= timer_check (), *ntp
;
394 SELECT_TYPE read_fds
;
395 struct x_display_info
*dpyinfo
;
399 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
401 int fd
= ConnectionNumber (dpyinfo
->display
);
402 FD_SET (fd
, &read_fds
);
404 XFlush (dpyinfo
->display
);
407 if (! EMACS_TIME_VALID_P (next_time
))
413 /* Gtk3 have arrows on menus when they don't fit. When the
414 pointer is over an arrow, a timeout scrolls it a bit. Use
415 xg_select so that timeout gets triggered. */
416 xg_select (n
+ 1, &read_fds
, NULL
, NULL
, ntp
, NULL
);
418 pselect (n
+ 1, &read_fds
, NULL
, NULL
, ntp
, NULL
);
425 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
429 /* Loop in Xt until the menu pulldown or dialog popup has been
430 popped down (deactivated). This is used for x-popup-menu
431 and x-popup-dialog; it is not used for the menu bar.
433 NOTE: All calls to popup_get_selection should be protected
434 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
437 popup_get_selection (XEvent
*initial_event
, struct x_display_info
*dpyinfo
, LWLIB_ID id
, int do_timers
)
441 while (popup_activated_flag
)
445 event
= *initial_event
;
450 if (do_timers
) x_menu_wait_for_event (0);
451 XtAppNextEvent (Xt_app_con
, &event
);
454 /* Make sure we don't consider buttons grabbed after menu goes.
455 And make sure to deactivate for any ButtonRelease,
456 even if XtDispatchEvent doesn't do that. */
457 if (event
.type
== ButtonRelease
458 && dpyinfo
->display
== event
.xbutton
.display
)
460 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
461 #ifdef USE_MOTIF /* Pretending that the event came from a
462 Btn1Down seems the only way to convince Motif to
463 activate its callbacks; setting the XmNmenuPost
464 isn't working. --marcus@sysc.pdx.edu. */
465 event
.xbutton
.button
= 1;
466 /* Motif only pops down menus when no Ctrl, Alt or Mod
467 key is pressed and the button is released. So reset key state
468 so Motif thinks this is the case. */
469 event
.xbutton
.state
= 0;
472 /* Pop down on C-g and Escape. */
473 else if (event
.type
== KeyPress
474 && dpyinfo
->display
== event
.xbutton
.display
)
476 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
478 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
479 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
480 popup_activated_flag
= 0;
483 x_dispatch_event (&event
, event
.xany
.display
);
487 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
488 doc
: /* Start key navigation of the menu bar in FRAME.
489 This initially opens the first menu bar item and you can then navigate with the
490 arrow keys, select a menu entry with the return key or cancel with the
491 escape key. If FRAME has no menu bar this function does nothing.
493 If FRAME is nil or not given, use the selected frame. */)
497 FRAME_PTR f
= check_x_frame (frame
);
501 if (FRAME_EXTERNAL_MENU_BAR (f
))
502 set_frame_menubar (f
, 0, 1);
504 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
510 x_catch_errors (FRAME_X_DISPLAY (f
));
511 memset (&ev
, 0, sizeof ev
);
512 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
513 ev
.xbutton
.window
= XtWindow (menubar
);
514 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
515 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
516 ev
.xbutton
.button
= Button1
;
517 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
518 ev
.xbutton
.same_screen
= True
;
525 XtSetArg (al
[0], XtNchildren
, &list
);
526 XtSetArg (al
[1], XtNnumChildren
, &nr
);
527 XtGetValues (menubar
, al
, 2);
528 ev
.xbutton
.window
= XtWindow (list
[0]);
532 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
533 /* From-window, to-window. */
534 ev
.xbutton
.window
, ev
.xbutton
.root
,
536 /* From-position, to-position. */
537 ev
.xbutton
.x
, ev
.xbutton
.y
,
538 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
542 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
547 ev
.type
= ButtonPress
;
548 ev
.xbutton
.state
= 0;
550 XtDispatchEvent (&ev
);
551 ev
.xbutton
.type
= ButtonRelease
;
552 ev
.xbutton
.state
= Button1Mask
;
553 XtDispatchEvent (&ev
);
561 #endif /* USE_X_TOOLKIT */
565 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
566 doc
: /* Start key navigation of the menu bar in FRAME.
567 This initially opens the first menu bar item and you can then navigate with the
568 arrow keys, select a menu entry with the return key or cancel with the
569 escape key. If FRAME has no menu bar this function does nothing.
571 If FRAME is nil or not given, use the selected frame. */)
577 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
581 f
= check_x_frame (frame
);
583 if (FRAME_EXTERNAL_MENU_BAR (f
))
584 set_frame_menubar (f
, 0, 1);
586 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
589 /* Activate the first menu. */
590 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
594 g_signal_emit_by_name (children
->data
, "activate_item");
595 popup_activated_flag
= 1;
596 g_list_free (children
);
604 /* Loop util popup_activated_flag is set to zero in a callback.
605 Used for popup menus and dialogs. */
608 popup_widget_loop (int do_timers
, GtkWidget
*widget
)
610 ++popup_activated_flag
;
612 /* Process events in the Gtk event loop until done. */
613 while (popup_activated_flag
)
615 if (do_timers
) x_menu_wait_for_event (0);
616 gtk_main_iteration ();
621 /* Activate the menu bar of frame F.
622 This is called from keyboard.c when it gets the
623 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
625 To activate the menu bar, we use the X button-press event
626 that was saved in saved_menu_event.
627 That makes the toolkit do its thing.
629 But first we recompute the menu bar contents (the whole tree).
631 The reason for saving the button event until here, instead of
632 passing it to the toolkit right away, is that we can safely
633 execute Lisp code. */
636 x_activate_menubar (FRAME_PTR f
)
641 if (!f
->output_data
.x
->saved_menu_event
->type
)
645 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
646 f
->output_data
.x
->saved_menu_event
->xany
.window
))
650 set_frame_menubar (f
, 0, 1);
652 popup_activated_flag
= 1;
654 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
655 f
->output_data
.x
->saved_menu_event
);
657 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
661 /* Ignore this if we get it a second time. */
662 f
->output_data
.x
->saved_menu_event
->type
= 0;
665 /* This callback is invoked when the user selects a menubar cascade
666 pushbutton, but before the pulldown menu is posted. */
670 popup_activate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
672 popup_activated_flag
= 1;
674 x_activate_timeout_atimer ();
679 /* This callback is invoked when a dialog or menu is finished being
680 used and has been unposted. */
684 popup_deactivate_callback (GtkWidget
*widget
, gpointer client_data
)
686 popup_activated_flag
= 0;
690 popup_deactivate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
692 popup_activated_flag
= 0;
697 /* Function that finds the frame for WIDGET and shows the HELP text
699 F is the frame if known, or NULL if not known. */
701 show_help_event (FRAME_PTR f
, xt_or_gtk_widget widget
, Lisp_Object help
)
707 XSETFRAME (frame
, f
);
708 kbd_buffer_store_help_event (frame
, help
);
712 #if 0 /* This code doesn't do anything useful. ++kfs */
713 /* WIDGET is the popup menu. It's parent is the frame's
714 widget. See which frame that is. */
715 xt_or_gtk_widget frame_widget
= XtParent (widget
);
718 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
722 && (f
= XFRAME (frame
),
723 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
727 show_help_echo (help
, Qnil
, Qnil
, Qnil
);
731 /* Callback called when menu items are highlighted/unhighlighted
732 while moving the mouse over them. WIDGET is the menu bar or menu
733 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
734 the data structure for the menu item, or null in case of
739 menu_highlight_callback (GtkWidget
*widget
, gpointer call_data
)
741 xg_menu_item_cb_data
*cb_data
;
744 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
746 if (! cb_data
) return;
748 help
= call_data
? cb_data
->help
: Qnil
;
750 /* If popup_activated_flag is greater than 1 we are in a popup menu.
751 Don't pass the frame to show_help_event for those.
752 Passing frame creates an Emacs event. As we are looping in
753 popup_widget_loop, it won't be handled. Passing NULL shows the tip
754 directly without using an Emacs event. This is what the Lucid code
756 show_help_event (popup_activated_flag
<= 1 ? cb_data
->cl_data
->f
: NULL
,
761 menu_highlight_callback (Widget widget
, LWLIB_ID id
, void *call_data
)
766 widget_value
*wv
= (widget_value
*) call_data
;
768 help
= wv
? wv
->help
: Qnil
;
770 /* Determine the frame for the help event. */
771 f
= menubar_id_to_frame (id
);
773 show_help_event (f
, widget
, help
);
778 /* Gtk calls callbacks just because we tell it what item should be
779 selected in a radio group. If this variable is set to a non-zero
780 value, we are creating menus and don't want callbacks right now.
782 static int xg_crazy_callback_abort
;
784 /* This callback is called from the menu bar pulldown menu
785 when the user makes a selection.
786 Figure out what the user chose
787 and put the appropriate events into the keyboard buffer. */
789 menubar_selection_callback (GtkWidget
*widget
, gpointer client_data
)
791 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
793 if (xg_crazy_callback_abort
)
796 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
799 /* For a group of radio buttons, GTK calls the selection callback first
800 for the item that was active before the selection and then for the one that
801 is active after the selection. For C-h k this means we get the help on
802 the deselected item and then the selected item is executed. Prevent that
803 by ignoring the non-active item. */
804 if (GTK_IS_RADIO_MENU_ITEM (widget
)
805 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
808 /* When a menu is popped down, X generates a focus event (i.e. focus
809 goes back to the frame below the menu). Since GTK buffers events,
810 we force it out here before the menu selection event. Otherwise
811 sit-for will exit at once if the focus event follows the menu selection
815 while (gtk_events_pending ())
816 gtk_main_iteration ();
819 find_and_call_menu_selection (cb_data
->cl_data
->f
,
820 cb_data
->cl_data
->menu_bar_items_used
,
821 cb_data
->cl_data
->menu_bar_vector
,
825 #else /* not USE_GTK */
827 /* This callback is called from the menu bar pulldown menu
828 when the user makes a selection.
829 Figure out what the user chose
830 and put the appropriate events into the keyboard buffer. */
832 menubar_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
836 f
= menubar_id_to_frame (id
);
839 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
840 f
->menu_bar_vector
, client_data
);
842 #endif /* not USE_GTK */
844 /* Recompute all the widgets of frame F, when the menu bar has been
845 changed. Value is non-zero if widgets were updated. */
848 update_frame_menubar (FRAME_PTR f
)
851 return xg_update_frame_menubar (f
);
859 x
= f
->output_data
.x
;
861 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
865 /* Save the size of the frame because the pane widget doesn't accept
866 to resize itself. So force it. */
867 columns
= FRAME_COLS (f
);
868 rows
= FRAME_LINES (f
);
870 /* Do the voodoo which means "I'm changing lots of things, don't try
871 to refigure sizes until I'm done." */
872 lw_refigure_widget (x
->column_widget
, False
);
874 /* The order in which children are managed is the top to bottom
875 order in which they are displayed in the paned window. First,
876 remove the text-area widget. */
877 XtUnmanageChild (x
->edit_widget
);
879 /* Remove the menubar that is there now, and put up the menubar that
881 XtManageChild (x
->menubar_widget
);
882 XtMapWidget (x
->menubar_widget
);
883 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
885 /* Re-manage the text-area widget, and then thrash the sizes. */
886 XtManageChild (x
->edit_widget
);
887 lw_refigure_widget (x
->column_widget
, True
);
889 /* Force the pane widget to resize itself with the right values. */
890 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
898 apply_systemfont_to_dialog (Widget w
)
900 const char *fn
= xsettings_get_system_normal_font ();
903 XrmDatabase db
= XtDatabase (XtDisplay (w
));
905 XrmPutStringResource (&db
, "*dialog.font", fn
);
910 apply_systemfont_to_menu (struct frame
*f
, Widget w
)
912 const char *fn
= xsettings_get_system_normal_font ();
916 XrmDatabase db
= XtDatabase (XtDisplay (w
));
919 XrmPutStringResource (&db
, "*menubar*font", fn
);
920 XrmPutStringResource (&db
, "*popup*font", fn
);
927 /* Set the contents of the menubar widgets of frame F.
928 The argument FIRST_TIME is currently ignored;
929 it is set the first time this is called, from initialize_frame_menubar. */
932 set_frame_menubar (FRAME_PTR f
, int first_time
, int deep_p
)
934 xt_or_gtk_widget menubar_widget
;
939 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
941 int *submenu_start
, *submenu_end
;
942 int *submenu_top_level_items
, *submenu_n_panes
;
947 menubar_widget
= f
->output_data
.x
->menubar_widget
;
949 XSETFRAME (Vmenu_updating_frame
, f
);
952 if (f
->output_data
.x
->id
== 0)
953 f
->output_data
.x
->id
= next_menubar_widget_id
++;
954 id
= f
->output_data
.x
->id
;
957 if (! menubar_widget
)
959 /* Make the first call for any given frame always go deep. */
960 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
963 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof (XEvent
));
964 f
->output_data
.x
->saved_menu_event
->type
= 0;
968 /* If we have detached menus, we must update deep so detached menus
969 also gets updated. */
970 deep_p
= deep_p
|| xg_have_tear_offs ();
975 /* Make a widget-value tree representing the entire menu trees. */
977 struct buffer
*prev
= current_buffer
;
979 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
980 int previous_menu_items_used
= f
->menu_bar_items_used
;
981 Lisp_Object
*previous_items
982 = alloca (previous_menu_items_used
* sizeof *previous_items
);
985 /* If we are making a new widget, its contents are empty,
986 do always reinitialize them. */
987 if (! menubar_widget
)
988 previous_menu_items_used
= 0;
990 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
991 specbind (Qinhibit_quit
, Qt
);
992 /* Don't let the debugger step into this code
993 because it is not reentrant. */
994 specbind (Qdebug_on_next_call
, Qnil
);
996 record_unwind_save_match_data ();
997 if (NILP (Voverriding_local_map_menu_flag
))
999 specbind (Qoverriding_terminal_local_map
, Qnil
);
1000 specbind (Qoverriding_local_map
, Qnil
);
1003 set_buffer_internal_1 (XBUFFER (buffer
));
1005 /* Run the Lucid hook. */
1006 safe_run_hooks (Qactivate_menubar_hook
);
1008 /* If it has changed current-menubar from previous value,
1009 really recompute the menubar from the value. */
1010 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1011 call0 (Qrecompute_lucid_menubar
);
1012 safe_run_hooks (Qmenu_bar_update_hook
);
1013 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1015 items
= FRAME_MENU_BAR_ITEMS (f
);
1017 /* Save the frame's previous menu bar contents data. */
1018 if (previous_menu_items_used
)
1019 memcpy (previous_items
, XVECTOR (f
->menu_bar_vector
)->contents
,
1020 previous_menu_items_used
* sizeof (Lisp_Object
));
1022 /* Fill in menu_items with the current menu bar contents.
1023 This can evaluate Lisp code. */
1026 menu_items
= f
->menu_bar_vector
;
1027 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1028 subitems
= ASIZE (items
) / 4;
1029 submenu_start
= alloca ((subitems
+ 1) * sizeof *submenu_start
);
1030 submenu_end
= alloca (subitems
* sizeof *submenu_end
);
1031 submenu_n_panes
= alloca (subitems
* sizeof *submenu_n_panes
);
1032 submenu_top_level_items
= alloca (subitems
1033 * sizeof *submenu_top_level_items
);
1035 for (i
= 0; i
< subitems
; i
++)
1037 Lisp_Object key
, string
, maps
;
1039 key
= AREF (items
, 4 * i
);
1040 string
= AREF (items
, 4 * i
+ 1);
1041 maps
= AREF (items
, 4 * i
+ 2);
1045 submenu_start
[i
] = menu_items_used
;
1047 menu_items_n_panes
= 0;
1048 submenu_top_level_items
[i
]
1049 = parse_single_submenu (key
, string
, maps
);
1050 submenu_n_panes
[i
] = menu_items_n_panes
;
1052 submenu_end
[i
] = menu_items_used
;
1055 submenu_start
[i
] = -1;
1056 finish_menu_items ();
1058 /* Convert menu_items into widget_value trees
1059 to display the menu. This cannot evaluate Lisp code. */
1061 wv
= xmalloc_widget_value ();
1062 wv
->name
= "menubar";
1065 wv
->button_type
= BUTTON_TYPE_NONE
;
1069 for (i
= 0; 0 <= submenu_start
[i
]; i
++)
1071 menu_items_n_panes
= submenu_n_panes
[i
];
1072 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1073 submenu_top_level_items
[i
]);
1077 first_wv
->contents
= wv
;
1078 /* Don't set wv->name here; GC during the loop might relocate it. */
1080 wv
->button_type
= BUTTON_TYPE_NONE
;
1084 set_buffer_internal_1 (prev
);
1086 /* If there has been no change in the Lisp-level contents
1087 of the menu bar, skip redisplaying it. Just exit. */
1089 /* Compare the new menu items with the ones computed last time. */
1090 for (i
= 0; i
< previous_menu_items_used
; i
++)
1091 if (menu_items_used
== i
1092 || (!EQ (previous_items
[i
], AREF (menu_items
, i
))))
1094 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1096 /* The menu items have not changed. Don't bother updating
1097 the menus in any form, since it would be a no-op. */
1098 free_menubar_widget_value_tree (first_wv
);
1099 discard_menu_items ();
1100 unbind_to (specpdl_count
, Qnil
);
1104 /* The menu items are different, so store them in the frame. */
1105 f
->menu_bar_vector
= menu_items
;
1106 f
->menu_bar_items_used
= menu_items_used
;
1108 /* This undoes save_menu_items. */
1109 unbind_to (specpdl_count
, Qnil
);
1111 /* Now GC cannot happen during the lifetime of the widget_value,
1112 so it's safe to store data from a Lisp_String. */
1113 wv
= first_wv
->contents
;
1114 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1117 string
= AREF (items
, i
+ 1);
1120 wv
->name
= SSDATA (string
);
1121 update_submenu_strings (wv
->contents
);
1128 /* Make a widget-value tree containing
1129 just the top level menu bar strings. */
1131 wv
= xmalloc_widget_value ();
1132 wv
->name
= "menubar";
1135 wv
->button_type
= BUTTON_TYPE_NONE
;
1139 items
= FRAME_MENU_BAR_ITEMS (f
);
1140 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1144 string
= AREF (items
, i
+ 1);
1148 wv
= xmalloc_widget_value ();
1149 wv
->name
= SSDATA (string
);
1152 wv
->button_type
= BUTTON_TYPE_NONE
;
1154 /* This prevents lwlib from assuming this
1155 menu item is really supposed to be empty. */
1156 /* The intptr_t cast avoids a warning.
1157 This value just has to be different from small integers. */
1158 wv
->call_data
= (void *) (intptr_t) (-1);
1163 first_wv
->contents
= wv
;
1167 /* Forget what we thought we knew about what is in the
1168 detailed contents of the menu bar menus.
1169 Changing the top level always destroys the contents. */
1170 f
->menu_bar_items_used
= 0;
1173 /* Create or update the menu bar widget. */
1178 xg_crazy_callback_abort
= 1;
1181 /* The fourth arg is DEEP_P, which says to consider the entire
1182 menu trees we supply, rather than just the menu bar item names. */
1183 xg_modify_menubar_widgets (menubar_widget
,
1187 G_CALLBACK (menubar_selection_callback
),
1188 G_CALLBACK (popup_deactivate_callback
),
1189 G_CALLBACK (menu_highlight_callback
));
1194 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
1195 G_CALLBACK (menubar_selection_callback
),
1196 G_CALLBACK (popup_deactivate_callback
),
1197 G_CALLBACK (menu_highlight_callback
));
1199 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1203 #else /* not USE_GTK */
1206 /* Disable resizing (done for Motif!) */
1207 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1209 /* The third arg is DEEP_P, which says to consider the entire
1210 menu trees we supply, rather than just the menu bar item names. */
1211 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1213 /* Re-enable the edit widget to resize. */
1214 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1218 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
1219 XtTranslations override
= XtParseTranslationTable (menuOverride
);
1222 apply_systemfont_to_menu (f
, f
->output_data
.x
->column_widget
);
1224 menubar_widget
= lw_create_widget ("menubar", "menubar", id
,
1226 f
->output_data
.x
->column_widget
,
1228 popup_activate_callback
,
1229 menubar_selection_callback
,
1230 popup_deactivate_callback
,
1231 menu_highlight_callback
);
1232 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1234 /* Make menu pop down on C-g. */
1235 XtOverrideTranslations (menubar_widget
, override
);
1240 if (f
->output_data
.x
->menubar_widget
)
1241 XtRealizeWidget (f
->output_data
.x
->menubar_widget
);
1244 = (f
->output_data
.x
->menubar_widget
1245 ? (f
->output_data
.x
->menubar_widget
->core
.height
1246 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1249 #if 1 /* Experimentally, we now get the right results
1250 for -geometry -0-0 without this. 24 Aug 96, rms.
1251 Maybe so, but the menu bar size is missing the pixels so the
1252 WM size hints are off by these pixels. Jan D, oct 2009. */
1254 if (FRAME_EXTERNAL_MENU_BAR (f
))
1257 XtVaGetValues (f
->output_data
.x
->column_widget
,
1258 XtNinternalBorderWidth
, &ibw
, NULL
);
1259 menubar_size
+= ibw
;
1261 #endif /* USE_LUCID */
1264 f
->output_data
.x
->menubar_height
= menubar_size
;
1266 #endif /* not USE_GTK */
1268 free_menubar_widget_value_tree (first_wv
);
1269 update_frame_menubar (f
);
1272 xg_crazy_callback_abort
= 0;
1278 /* Called from Fx_create_frame to create the initial menubar of a frame
1279 before it is mapped, so that the window is mapped with the menubar already
1280 there instead of us tacking it on later and thrashing the window after it
1284 initialize_frame_menubar (FRAME_PTR f
)
1286 /* This function is called before the first chance to redisplay
1287 the frame. It has to be, so the frame will have the right size. */
1288 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1289 set_frame_menubar (f
, 1, 1);
1293 /* Get rid of the menu bar of frame F, and free its storage.
1294 This is used when deleting a frame, and when turning off the menu bar.
1295 For GTK this function is in gtkutil.c. */
1299 free_frame_menubar (FRAME_PTR f
)
1301 Widget menubar_widget
;
1303 if (! FRAME_X_P (f
))
1306 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1308 f
->output_data
.x
->menubar_height
= 0;
1313 /* Removing the menu bar magically changes the shell widget's x
1314 and y position of (0, 0) which, when the menu bar is turned
1315 on again, leads to pull-down menus appearing in strange
1316 positions near the upper-left corner of the display. This
1317 happens only with some window managers like twm and ctwm,
1318 but not with other like Motif's mwm or kwm, because the
1319 latter generate ConfigureNotify events when the menu bar
1320 is switched off, which fixes the shell position. */
1321 Position x0
, y0
, x1
, y1
;
1327 if (f
->output_data
.x
->widget
)
1328 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1331 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1332 f
->output_data
.x
->menubar_widget
= NULL
;
1334 if (f
->output_data
.x
->widget
)
1337 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1338 if (x1
== 0 && y1
== 0)
1339 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1341 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1346 #endif /* not USE_GTK */
1348 #endif /* USE_X_TOOLKIT || USE_GTK */
1350 /* xmenu_show actually displays a menu using the panes and items in menu_items
1351 and returns the value selected from it.
1352 There are two versions of xmenu_show, one for Xt and one for Xlib.
1353 Both assume input is blocked by the caller. */
1355 /* F is the frame the menu is for.
1356 X and Y are the frame-relative specified position,
1357 relative to the inside upper left corner of the frame F.
1358 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1359 KEYMAPS is 1 if this menu was specified with keymaps;
1360 in that case, we return a list containing the chosen item's value
1361 and perhaps also the pane's prefix.
1362 TITLE is the specified menu title.
1363 ERROR is a place to store an error message string in case of failure.
1364 (We return nil on failure, but the value doesn't actually matter.) */
1366 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1368 /* The item selected in the popup menu. */
1369 static Lisp_Object
*volatile menu_item_selection
;
1373 /* Used when position a popup menu. See menu_position_func and
1374 create_and_show_popup_menu below. */
1375 struct next_popup_x_y
1382 /* The menu position function to use if we are not putting a popup
1383 menu where the pointer is.
1384 MENU is the menu to pop up.
1385 X and Y shall on exit contain x/y where the menu shall pop up.
1386 PUSH_IN is not documented in the GTK manual.
1387 USER_DATA is any data passed in when calling gtk_menu_popup.
1388 Here it points to a struct next_popup_x_y where the coordinates
1389 to store in *X and *Y are as well as the frame for the popup.
1391 Here only X and Y are used. */
1393 menu_position_func (GtkMenu
*menu
, gint
*x
, gint
*y
, gboolean
*push_in
, gpointer user_data
)
1395 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
1397 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (data
->f
);
1398 int disp_width
= x_display_pixel_width (dpyinfo
);
1399 int disp_height
= x_display_pixel_height (dpyinfo
);
1404 /* Check if there is room for the menu. If not, adjust x/y so that
1405 the menu is fully visible. */
1406 gtk_widget_get_preferred_size (GTK_WIDGET (menu
), NULL
, &req
);
1407 if (data
->x
+ req
.width
> disp_width
)
1408 *x
-= data
->x
+ req
.width
- disp_width
;
1409 if (data
->y
+ req
.height
> disp_height
)
1410 *y
-= data
->y
+ req
.height
- disp_height
;
1414 popup_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1416 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1418 if (xg_crazy_callback_abort
) return;
1419 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
1423 pop_down_menu (Lisp_Object arg
)
1425 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1427 popup_activated_flag
= 0;
1429 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1434 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1436 menu_item_selection will be set to the selection. */
1438 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
, int x
, int y
,
1439 int for_click
, Time timestamp
)
1443 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
1444 struct next_popup_x_y popup_x_y
;
1445 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1446 int use_pos_func
= ! for_click
;
1449 /* Always use position function for Gtk3. Otherwise menus may become
1450 too small to show anything. */
1454 if (! FRAME_X_P (f
))
1457 xg_crazy_callback_abort
= 1;
1458 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
1459 G_CALLBACK (popup_selection_callback
),
1460 G_CALLBACK (popup_deactivate_callback
),
1461 G_CALLBACK (menu_highlight_callback
));
1462 xg_crazy_callback_abort
= 0;
1466 /* Not invoked by a click. pop up at x/y. */
1467 pos_func
= menu_position_func
;
1469 /* Adjust coordinates to be root-window-relative. */
1470 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1471 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1477 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1482 for (i
= 0; i
< 5; i
++)
1483 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1487 /* Display the menu. */
1488 gtk_widget_show_all (menu
);
1490 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
,
1491 timestamp
? timestamp
: gtk_get_current_event_time ());
1493 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1495 if (gtk_widget_get_mapped (menu
))
1497 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1498 two. show_help_echo uses this to detect popup menus. */
1499 popup_activated_flag
= 1;
1500 /* Process events that apply to the menu. */
1501 popup_widget_loop (1, menu
);
1504 unbind_to (specpdl_count
, Qnil
);
1506 /* Must reset this manually because the button release event is not passed
1507 to Emacs event loop. */
1508 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1511 #else /* not USE_GTK */
1513 /* We need a unique id for each widget handled by the Lucid Widget
1516 For the main windows, and popup menus, we use this counter,
1517 which we increment each time after use. This starts from 1<<16.
1519 For menu bars, we use numbers starting at 0, counted in
1520 next_menubar_widget_id. */
1521 LWLIB_ID widget_id_tick
;
1524 popup_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1526 menu_item_selection
= (Lisp_Object
*) client_data
;
1529 /* ARG is the LWLIB ID of the dialog box, represented
1530 as a Lisp object as (HIGHPART . LOWPART). */
1533 pop_down_menu (Lisp_Object arg
)
1535 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
1536 | XINT (XCDR (arg
)));
1539 lw_destroy_all_widgets (id
);
1541 popup_activated_flag
= 0;
1546 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1548 menu_item_selection will be set to the selection. */
1550 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
,
1551 int x
, int y
, int for_click
, Time timestamp
)
1557 XButtonPressedEvent
*event
= &(dummy
.xbutton
);
1561 if (! FRAME_X_P (f
))
1565 apply_systemfont_to_menu (f
, f
->output_data
.x
->widget
);
1568 menu_id
= widget_id_tick
++;
1569 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1570 f
->output_data
.x
->widget
, 1, 0,
1571 popup_selection_callback
,
1572 popup_deactivate_callback
,
1573 menu_highlight_callback
);
1575 event
->type
= ButtonPress
;
1577 event
->send_event
= 0;
1578 event
->display
= FRAME_X_DISPLAY (f
);
1579 event
->time
= CurrentTime
;
1580 event
->root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1581 event
->window
= event
->subwindow
= event
->root
;
1585 /* Adjust coordinates to be root-window-relative. */
1586 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1587 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1594 for (i
= 0; i
< 5; i
++)
1595 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1598 /* Don't allow any geometry request from the user. */
1599 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
1600 XtSetValues (menu
, av
, ac
);
1602 /* Display the menu. */
1603 lw_popup_menu (menu
, &dummy
);
1604 popup_activated_flag
= 1;
1605 x_activate_timeout_atimer ();
1608 int fact
= 4 * sizeof (LWLIB_ID
);
1609 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1610 record_unwind_protect (pop_down_menu
,
1611 Fcons (make_number (menu_id
>> (fact
)),
1612 make_number (menu_id
& ~(-1 << (fact
)))));
1614 /* Process events that apply to the menu. */
1615 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
1617 unbind_to (specpdl_count
, Qnil
);
1621 #endif /* not USE_GTK */
1624 cleanup_widget_value_tree (Lisp_Object arg
)
1626 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1627 widget_value
*wv
= p
->pointer
;
1629 free_menubar_widget_value_tree (wv
);
1635 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
1636 Lisp_Object title
, const char **error_name
, Time timestamp
)
1639 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1640 widget_value
**submenu_stack
1641 = alloca (menu_items_used
* sizeof *submenu_stack
);
1642 Lisp_Object
*subprefix_stack
1643 = alloca (menu_items_used
* sizeof *subprefix_stack
);
1644 int submenu_depth
= 0;
1648 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1650 if (! FRAME_X_P (f
))
1655 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1657 *error_name
= "Empty menu";
1661 /* Create a tree of widget_value objects
1662 representing the panes and their items. */
1663 wv
= xmalloc_widget_value ();
1667 wv
->button_type
= BUTTON_TYPE_NONE
;
1672 /* Loop over all panes and items, filling in the tree. */
1674 while (i
< menu_items_used
)
1676 if (EQ (AREF (menu_items
, i
), Qnil
))
1678 submenu_stack
[submenu_depth
++] = save_wv
;
1684 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1687 save_wv
= submenu_stack
[--submenu_depth
];
1691 else if (EQ (AREF (menu_items
, i
), Qt
)
1692 && submenu_depth
!= 0)
1693 i
+= MENU_ITEMS_PANE_LENGTH
;
1694 /* Ignore a nil in the item list.
1695 It's meaningful only for dialog boxes. */
1696 else if (EQ (AREF (menu_items
, i
), Qquote
))
1698 else if (EQ (AREF (menu_items
, i
), Qt
))
1700 /* Create a new pane. */
1701 Lisp_Object pane_name
, prefix
;
1702 const char *pane_string
;
1704 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1705 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1707 #ifndef HAVE_MULTILINGUAL_MENU
1708 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1710 pane_name
= ENCODE_MENU_STRING (pane_name
);
1711 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1714 pane_string
= (NILP (pane_name
)
1715 ? "" : SSDATA (pane_name
));
1716 /* If there is just one top-level pane, put all its items directly
1717 under the top-level menu. */
1718 if (menu_items_n_panes
== 1)
1721 /* If the pane has a meaningful name,
1722 make the pane a top-level menu item
1723 with its items as a submenu beneath it. */
1724 if (!keymaps
&& strcmp (pane_string
, ""))
1726 wv
= xmalloc_widget_value ();
1730 first_wv
->contents
= wv
;
1731 wv
->name
= (char *) pane_string
;
1732 if (keymaps
&& !NILP (prefix
))
1736 wv
->button_type
= BUTTON_TYPE_NONE
;
1741 else if (first_pane
)
1747 i
+= MENU_ITEMS_PANE_LENGTH
;
1751 /* Create a new item within current pane. */
1752 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
1753 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1754 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1755 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1756 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1757 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1758 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1759 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1761 #ifndef HAVE_MULTILINGUAL_MENU
1762 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
1764 item_name
= ENCODE_MENU_STRING (item_name
);
1765 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1768 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1770 descrip
= ENCODE_MENU_STRING (descrip
);
1771 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1773 #endif /* not HAVE_MULTILINGUAL_MENU */
1775 wv
= xmalloc_widget_value ();
1779 save_wv
->contents
= wv
;
1780 wv
->name
= SSDATA (item_name
);
1781 if (!NILP (descrip
))
1782 wv
->key
= SSDATA (descrip
);
1784 /* If this item has a null value,
1785 make the call_data null so that it won't display a box
1786 when the mouse is on it. */
1788 = (!NILP (def
) ? (void *) &AREF (menu_items
, i
) : 0);
1789 wv
->enabled
= !NILP (enable
);
1792 wv
->button_type
= BUTTON_TYPE_NONE
;
1793 else if (EQ (type
, QCtoggle
))
1794 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1795 else if (EQ (type
, QCradio
))
1796 wv
->button_type
= BUTTON_TYPE_RADIO
;
1800 wv
->selected
= !NILP (selected
);
1802 if (! STRINGP (help
))
1809 i
+= MENU_ITEMS_ITEM_LENGTH
;
1813 /* Deal with the title, if it is non-nil. */
1816 widget_value
*wv_title
= xmalloc_widget_value ();
1817 widget_value
*wv_sep1
= xmalloc_widget_value ();
1818 widget_value
*wv_sep2
= xmalloc_widget_value ();
1820 wv_sep2
->name
= "--";
1821 wv_sep2
->next
= first_wv
->contents
;
1822 wv_sep2
->help
= Qnil
;
1824 wv_sep1
->name
= "--";
1825 wv_sep1
->next
= wv_sep2
;
1826 wv_sep1
->help
= Qnil
;
1828 #ifndef HAVE_MULTILINGUAL_MENU
1829 if (STRING_MULTIBYTE (title
))
1830 title
= ENCODE_MENU_STRING (title
);
1833 wv_title
->name
= SSDATA (title
);
1834 wv_title
->enabled
= TRUE
;
1835 wv_title
->button_type
= BUTTON_TYPE_NONE
;
1836 wv_title
->help
= Qnil
;
1837 wv_title
->next
= wv_sep1
;
1838 first_wv
->contents
= wv_title
;
1841 /* No selection has been chosen yet. */
1842 menu_item_selection
= 0;
1844 /* Make sure to free the widget_value objects we used to specify the
1845 contents even with longjmp. */
1846 record_unwind_protect (cleanup_widget_value_tree
,
1847 make_save_value (first_wv
, 0));
1849 /* Actually create and show the menu until popped down. */
1850 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
, timestamp
);
1852 unbind_to (specpdl_count
, Qnil
);
1854 /* Find the selected item, and its pane, to return
1855 the proper value. */
1856 if (menu_item_selection
!= 0)
1858 Lisp_Object prefix
, entry
;
1860 prefix
= entry
= Qnil
;
1862 while (i
< menu_items_used
)
1864 if (EQ (AREF (menu_items
, i
), Qnil
))
1866 subprefix_stack
[submenu_depth
++] = prefix
;
1870 else if (EQ (AREF (menu_items
, i
), Qlambda
))
1872 prefix
= subprefix_stack
[--submenu_depth
];
1875 else if (EQ (AREF (menu_items
, i
), Qt
))
1878 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1879 i
+= MENU_ITEMS_PANE_LENGTH
;
1881 /* Ignore a nil in the item list.
1882 It's meaningful only for dialog boxes. */
1883 else if (EQ (AREF (menu_items
, i
), Qquote
))
1888 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
1889 if (menu_item_selection
== &AREF (menu_items
, i
))
1895 entry
= Fcons (entry
, Qnil
);
1897 entry
= Fcons (prefix
, entry
);
1898 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1899 if (!NILP (subprefix_stack
[j
]))
1900 entry
= Fcons (subprefix_stack
[j
], entry
);
1904 i
+= MENU_ITEMS_ITEM_LENGTH
;
1908 else if (!for_click
)
1909 /* Make "Cancel" equivalent to C-g. */
1910 Fsignal (Qquit
, Qnil
);
1917 dialog_selection_callback (GtkWidget
*widget
, gpointer 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
= (Lisp_Object
*) client_data
;
1924 popup_activated_flag
= 0;
1927 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1929 menu_item_selection will be set to the selection. */
1931 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1935 if (! FRAME_X_P (f
))
1938 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
1939 G_CALLBACK (dialog_selection_callback
),
1940 G_CALLBACK (popup_deactivate_callback
),
1945 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
1946 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1948 /* Display the menu. */
1949 gtk_widget_show_all (menu
);
1951 /* Process events that apply to the menu. */
1952 popup_widget_loop (1, menu
);
1954 unbind_to (specpdl_count
, Qnil
);
1958 #else /* not USE_GTK */
1960 dialog_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1962 /* Treat the pointer as an integer. There's no problem
1963 as long as pointers have enough bits to hold small integers. */
1964 if ((intptr_t) client_data
!= -1)
1965 menu_item_selection
= (Lisp_Object
*) client_data
;
1968 lw_destroy_all_widgets (id
);
1970 popup_activated_flag
= 0;
1974 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1976 menu_item_selection will be set to the selection. */
1978 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1985 dialog_id
= widget_id_tick
++;
1987 apply_systemfont_to_dialog (f
->output_data
.x
->widget
);
1989 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1990 f
->output_data
.x
->widget
, 1, 0,
1991 dialog_selection_callback
, 0, 0);
1992 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1993 /* Display the dialog box. */
1994 lw_pop_up_all_widgets (dialog_id
);
1995 popup_activated_flag
= 1;
1996 x_activate_timeout_atimer ();
1998 /* Process events that apply to the dialog box.
1999 Also handle timers. */
2001 ptrdiff_t count
= SPECPDL_INDEX ();
2002 int fact
= 4 * sizeof (LWLIB_ID
);
2004 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2005 record_unwind_protect (pop_down_menu
,
2006 Fcons (make_number (dialog_id
>> (fact
)),
2007 make_number (dialog_id
& ~(-1 << (fact
)))));
2009 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
2012 unbind_to (count
, Qnil
);
2016 #endif /* not USE_GTK */
2018 static const char * button_names
[] = {
2019 "button1", "button2", "button3", "button4", "button5",
2020 "button6", "button7", "button8", "button9", "button10" };
2023 xdialog_show (FRAME_PTR f
,
2027 const char **error_name
)
2029 int i
, nb_buttons
=0;
2030 char dialog_name
[6];
2032 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2034 /* Number of elements seen so far, before boundary. */
2036 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2037 int boundary_seen
= 0;
2039 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
2041 if (! FRAME_X_P (f
))
2046 if (menu_items_n_panes
> 1)
2048 *error_name
= "Multiple panes in dialog box";
2052 /* Create a tree of widget_value objects
2053 representing the text label and buttons. */
2055 Lisp_Object pane_name
, prefix
;
2056 const char *pane_string
;
2057 pane_name
= AREF (menu_items
, MENU_ITEMS_PANE_NAME
);
2058 prefix
= AREF (menu_items
, MENU_ITEMS_PANE_PREFIX
);
2059 pane_string
= (NILP (pane_name
)
2060 ? "" : SSDATA (pane_name
));
2061 prev_wv
= xmalloc_widget_value ();
2062 prev_wv
->value
= (char *) pane_string
;
2063 if (keymaps
&& !NILP (prefix
))
2065 prev_wv
->enabled
= 1;
2066 prev_wv
->name
= "message";
2067 prev_wv
->help
= Qnil
;
2070 /* Loop over all panes and items, filling in the tree. */
2071 i
= MENU_ITEMS_PANE_LENGTH
;
2072 while (i
< menu_items_used
)
2075 /* Create a new item within current pane. */
2076 Lisp_Object item_name
, enable
, descrip
;
2077 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2078 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2080 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2082 if (NILP (item_name
))
2084 free_menubar_widget_value_tree (first_wv
);
2085 *error_name
= "Submenu in dialog items";
2088 if (EQ (item_name
, Qquote
))
2090 /* This is the boundary between left-side elts
2091 and right-side elts. Stop incrementing right_count. */
2096 if (nb_buttons
>= 9)
2098 free_menubar_widget_value_tree (first_wv
);
2099 *error_name
= "Too many dialog items";
2103 wv
= xmalloc_widget_value ();
2105 wv
->name
= (char *) button_names
[nb_buttons
];
2106 if (!NILP (descrip
))
2107 wv
->key
= SSDATA (descrip
);
2108 wv
->value
= SSDATA (item_name
);
2109 wv
->call_data
= (void *) &AREF (menu_items
, i
);
2110 wv
->enabled
= !NILP (enable
);
2114 if (! boundary_seen
)
2118 i
+= MENU_ITEMS_ITEM_LENGTH
;
2121 /* If the boundary was not specified,
2122 by default put half on the left and half on the right. */
2123 if (! boundary_seen
)
2124 left_count
= nb_buttons
- nb_buttons
/ 2;
2126 wv
= xmalloc_widget_value ();
2127 wv
->name
= dialog_name
;
2130 /* Frame title: 'Q' = Question, 'I' = Information.
2131 Can also have 'E' = Error if, one day, we want
2132 a popup for errors. */
2134 dialog_name
[0] = 'Q';
2136 dialog_name
[0] = 'I';
2138 /* Dialog boxes use a really stupid name encoding
2139 which specifies how many buttons to use
2140 and how many buttons are on the right. */
2141 dialog_name
[1] = '0' + nb_buttons
;
2142 dialog_name
[2] = 'B';
2143 dialog_name
[3] = 'R';
2144 /* Number of buttons to put on the right. */
2145 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2147 wv
->contents
= first_wv
;
2151 /* No selection has been chosen yet. */
2152 menu_item_selection
= 0;
2154 /* Make sure to free the widget_value objects we used to specify the
2155 contents even with longjmp. */
2156 record_unwind_protect (cleanup_widget_value_tree
,
2157 make_save_value (first_wv
, 0));
2159 /* Actually create and show the dialog. */
2160 create_and_show_dialog (f
, first_wv
);
2162 unbind_to (specpdl_count
, Qnil
);
2164 /* Find the selected item, and its pane, to return
2165 the proper value. */
2166 if (menu_item_selection
!= 0)
2172 while (i
< menu_items_used
)
2176 if (EQ (AREF (menu_items
, i
), Qt
))
2179 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2180 i
+= MENU_ITEMS_PANE_LENGTH
;
2182 else if (EQ (AREF (menu_items
, i
), Qquote
))
2184 /* This is the boundary between left-side elts and
2191 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
2192 if (menu_item_selection
== &AREF (menu_items
, i
))
2196 entry
= Fcons (entry
, Qnil
);
2198 entry
= Fcons (prefix
, entry
);
2202 i
+= MENU_ITEMS_ITEM_LENGTH
;
2207 /* Make "Cancel" equivalent to C-g. */
2208 Fsignal (Qquit
, Qnil
);
2213 #else /* not USE_X_TOOLKIT && not USE_GTK */
2215 /* The frame of the last activated non-toolkit menu bar.
2216 Used to generate menu help events. */
2218 static struct frame
*menu_help_frame
;
2221 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2223 PANE is the pane number, and ITEM is the menu item number in
2224 the menu (currently not used).
2226 This cannot be done with generating a HELP_EVENT because
2227 XMenuActivate contains a loop that doesn't let Emacs process
2231 menu_help_callback (char const *help_string
, int pane
, int item
)
2233 Lisp_Object
*first_item
;
2234 Lisp_Object pane_name
;
2235 Lisp_Object menu_object
;
2237 first_item
= XVECTOR (menu_items
)->contents
;
2238 if (EQ (first_item
[0], Qt
))
2239 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2240 else if (EQ (first_item
[0], Qquote
))
2241 /* This shouldn't happen, see xmenu_show. */
2242 pane_name
= empty_unibyte_string
;
2244 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2246 /* (menu-item MENU-NAME PANE-NUMBER) */
2247 menu_object
= Fcons (Qmenu_item
,
2249 Fcons (make_number (pane
), Qnil
)));
2250 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2251 Qnil
, menu_object
, make_number (item
));
2255 pop_down_menu (Lisp_Object arg
)
2257 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
2258 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
2260 FRAME_PTR f
= p1
->pointer
;
2261 XMenu
*menu
= p2
->pointer
;
2265 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
2266 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
2268 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2270 #ifdef HAVE_X_WINDOWS
2271 /* Assume the mouse has moved out of the X window.
2272 If it has actually moved in, we will get an EnterNotify. */
2273 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2275 /* State that no mouse buttons are now held.
2276 (The oldXMenu code doesn't track this info for us.)
2277 That is not necessarily true, but the fiction leads to reasonable
2278 results, and it is a pain to ask which are actually held now. */
2279 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2281 #endif /* HAVE_X_WINDOWS */
2290 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
2291 Lisp_Object title
, const char **error_name
, Time timestamp
)
2295 int pane
, selidx
, lpane
, status
;
2296 Lisp_Object entry
, pane_prefix
;
2298 int ulx
, uly
, width
, height
;
2299 int dispwidth
, dispheight
;
2300 int i
, j
, lines
, maxlines
;
2303 unsigned int dummy_uint
;
2304 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
2306 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
2310 if (menu_items_n_panes
== 0)
2313 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2315 *error_name
= "Empty menu";
2319 /* Figure out which root window F is on. */
2320 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2321 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2322 &dummy_uint
, &dummy_uint
);
2324 /* Make the menu on that window. */
2325 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2328 *error_name
= "Can't create menu";
2332 /* Don't GC while we prepare and show the menu,
2333 because we give the oldxmenu library pointers to the
2334 contents of strings. */
2335 inhibit_garbage_collection ();
2337 #ifdef HAVE_X_WINDOWS
2338 /* Adjust coordinates to relative to the outer (window manager) window. */
2339 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
2340 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2341 #endif /* HAVE_X_WINDOWS */
2343 /* Adjust coordinates to be root-window-relative. */
2347 /* Create all the necessary panes and their items. */
2348 maxwidth
= maxlines
= lines
= i
= 0;
2350 while (i
< menu_items_used
)
2352 if (EQ (AREF (menu_items
, i
), Qt
))
2354 /* Create a new pane. */
2355 Lisp_Object pane_name
, prefix
;
2356 const char *pane_string
;
2358 maxlines
= max (maxlines
, lines
);
2360 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2361 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2362 pane_string
= (NILP (pane_name
)
2363 ? "" : SSDATA (pane_name
));
2364 if (keymaps
&& !NILP (prefix
))
2367 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2368 if (lpane
== XM_FAILURE
)
2370 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2371 *error_name
= "Can't create pane";
2374 i
+= MENU_ITEMS_PANE_LENGTH
;
2376 /* Find the width of the widest item in this pane. */
2378 while (j
< menu_items_used
)
2381 item
= AREF (menu_items
, j
);
2389 width
= SBYTES (item
);
2390 if (width
> maxwidth
)
2393 j
+= MENU_ITEMS_ITEM_LENGTH
;
2396 /* Ignore a nil in the item list.
2397 It's meaningful only for dialog boxes. */
2398 else if (EQ (AREF (menu_items
, i
), Qquote
))
2402 /* Create a new item within current pane. */
2403 Lisp_Object item_name
, enable
, descrip
, help
;
2405 char const *help_string
;
2407 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2408 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2410 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2411 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2412 help_string
= STRINGP (help
) ? SSDATA (help
) : NULL
;
2414 if (!NILP (descrip
))
2416 /* if alloca is fast, use that to make the space,
2417 to reduce gc needs. */
2418 item_data
= alloca (maxwidth
+ SBYTES (descrip
) + 1);
2419 memcpy (item_data
, SSDATA (item_name
), SBYTES (item_name
));
2420 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
2422 memcpy (item_data
+ j
, SSDATA (descrip
), SBYTES (descrip
));
2423 item_data
[j
+ SBYTES (descrip
)] = 0;
2426 item_data
= SSDATA (item_name
);
2428 if (lpane
== XM_FAILURE
2429 || (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2430 menu
, lpane
, 0, item_data
,
2431 !NILP (enable
), help_string
)
2434 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2435 *error_name
= "Can't add selection to menu";
2438 i
+= MENU_ITEMS_ITEM_LENGTH
;
2443 maxlines
= max (maxlines
, lines
);
2445 /* All set and ready to fly. */
2446 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2447 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2448 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2449 x
= min (x
, dispwidth
);
2450 y
= min (y
, dispheight
);
2453 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2454 &ulx
, &uly
, &width
, &height
);
2455 if (ulx
+width
> dispwidth
)
2457 x
-= (ulx
+ width
) - dispwidth
;
2458 ulx
= dispwidth
- width
;
2460 if (uly
+height
> dispheight
)
2462 y
-= (uly
+ height
) - dispheight
;
2463 uly
= dispheight
- height
;
2465 #ifndef HAVE_X_WINDOWS
2466 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 1)
2468 /* Move the menu away of the echo area, to avoid overwriting the
2469 menu with help echo messages or vice versa. */
2470 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
2472 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2473 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2482 if (ulx
< 0) x
-= ulx
;
2483 if (uly
< 0) y
-= uly
;
2487 /* If position was not given by a mouse click, adjust so upper left
2488 corner of the menu as a whole ends up at given coordinates. This
2489 is what x-popup-menu says in its documentation. */
2491 y
+= 1.5*height
/(maxlines
+2);
2494 XMenuSetAEQ (menu
, TRUE
);
2495 XMenuSetFreeze (menu
, TRUE
);
2499 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
2502 record_unwind_protect (pop_down_menu
,
2503 Fcons (make_save_value (f
, 0),
2504 make_save_value (menu
, 0)));
2506 /* Help display under X won't work because XMenuActivate contains
2507 a loop that doesn't give Emacs a chance to process it. */
2508 menu_help_frame
= f
;
2509 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2510 x
, y
, ButtonReleaseMask
, &datap
,
2511 menu_help_callback
);
2512 entry
= pane_prefix
= Qnil
;
2518 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2521 /* Find the item number SELIDX in pane number PANE. */
2523 while (i
< menu_items_used
)
2525 if (EQ (AREF (menu_items
, i
), Qt
))
2529 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2531 i
+= MENU_ITEMS_PANE_LENGTH
;
2540 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
2543 entry
= Fcons (entry
, Qnil
);
2544 if (!NILP (pane_prefix
))
2545 entry
= Fcons (pane_prefix
, entry
);
2551 i
+= MENU_ITEMS_ITEM_LENGTH
;
2557 *error_name
= "Can't activate menu";
2561 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2562 the menu was invoked with a mouse event as POSITION). */
2564 Fsignal (Qquit
, Qnil
);
2568 unbind_to (specpdl_count
, Qnil
);
2573 #endif /* not USE_X_TOOLKIT */
2575 #endif /* HAVE_MENUS */
2578 /* Detect if a dialog or menu has been posted. MSDOS has its own
2579 implementation on msdos.c. */
2582 popup_activated (void)
2584 return popup_activated_flag
;
2586 #endif /* not MSDOS */
2588 /* The following is used by delayed window autoselection. */
2590 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
2591 doc
: /* Return t if a menu or popup dialog is active. */)
2595 return (popup_activated ()) ? Qt
: Qnil
;
2598 #endif /* HAVE_MENUS */
2602 syms_of_xmenu (void)
2604 DEFSYM (Qdebug_on_next_call
, "debug-on-next-call");
2606 #ifdef USE_X_TOOLKIT
2607 widget_id_tick
= (1<<16);
2608 next_menubar_widget_id
= 1;
2611 defsubr (&Smenu_or_popup_active_p
);
2613 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2614 defsubr (&Sx_menu_bar_open_internal
);
2615 Ffset (intern_c_string ("accelerate-menu"),
2616 intern_c_string (Sx_menu_bar_open_internal
.symbol_name
));
2620 defsubr (&Sx_popup_dialog
);