1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19 /* X pop-up deck-of-cards menu facility for GNU Emacs.
21 * Written by Jon Arnold and Roman Budzianowski
22 * Mods and rewrite by Robert Krawitz
26 /* Modified by Fred Pierresteguy on December 93
27 to make the popup menus and menubar use the Xt. */
29 /* Rewritten for clarity and GC protection by rms in Feb 94. */
33 #if 0 /* Why was this included? And without syssignal.h? */
34 /* On 4.3 this loses if it comes after xterm.h. */
45 #include "termhooks.h"
47 #include "blockinput.h"
51 #include "sysselect.h"
58 /* This may include sys/types.h, and that somehow loses
59 if this is not done before the other system files. */
63 /* Load sys/types.h if not already loaded.
64 In some systems loading it twice is suicidal. */
66 #include <sys/types.h>
69 #include "dispextern.h"
72 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
73 code accepts the Emacs internal encoding. */
74 #undef HAVE_MULTILINGUAL_MENU
78 #include <X11/IntrinsicP.h>
79 #include <X11/CoreP.h>
80 #include <X11/StringDefs.h>
81 #include <X11/Shell.h>
83 #include "xsettings.h"
84 #include "../lwlib/xlwmenu.h"
86 #include <X11/Xaw3d/Paned.h>
87 #else /* !HAVE_XAW3D */
88 #include <X11/Xaw/Paned.h>
89 #endif /* HAVE_XAW3D */
90 #endif /* USE_LUCID */
92 #include "../lwlib/lwlib.h"
94 #else /* not USE_X_TOOLKIT */
96 #include "../oldXMenu/XMenu.h"
98 #endif /* not USE_X_TOOLKIT */
99 #endif /* HAVE_X_WINDOWS */
112 Lisp_Object Qdebug_on_next_call
;
114 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
115 static Lisp_Object
xdialog_show (FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
119 static int update_frame_menubar (struct frame
*);
121 /* Flag which when set indicates a dialog or menu has been posted by
122 Xt on behalf of one of the widget sets. */
123 static int popup_activated_flag
;
125 static int next_menubar_widget_id
;
130 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
132 static struct frame
*
133 menubar_id_to_frame (LWLIB_ID id
)
135 Lisp_Object tail
, frame
;
138 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
144 if (!FRAME_WINDOW_P (f
))
146 if (f
->output_data
.x
->id
== id
)
154 #ifdef HAVE_X_WINDOWS
155 /* Return the mouse position in *X and *Y. The coordinates are window
156 relative for the edit window in frame F.
157 This is for Fx_popup_menu. The mouse_position_hook can not
158 be used for X, as it returns window relative coordinates
159 for the window where the mouse is in. This could be the menu bar,
160 the scroll bar or the edit window. Fx_popup_menu needs to be
161 sure it is the edit window. */
163 mouse_position_for_popup (FRAME_PTR f
, int *x
, int *y
)
165 Window root
, dummy_window
;
173 XQueryPointer (FRAME_X_DISPLAY (f
),
174 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
176 /* The root window which contains the pointer. */
179 /* Window pointer is on, not used */
182 /* The position on that root window. */
185 /* x/y in dummy_window coordinates, not used. */
188 /* Modifier keys and pointer buttons, about which
190 (unsigned int *) &dummy
);
194 /* xmenu_show expects window coordinates, not root window
195 coordinates. Translate. */
196 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
197 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
200 #endif /* HAVE_X_WINDOWS */
204 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
205 doc
: /* Pop up a dialog box and return user's selection.
206 POSITION specifies which frame to use.
207 This is normally a mouse button event or a window or frame.
208 If POSITION is t, it means to use the frame the mouse is on.
209 The dialog box appears in the middle of the specified frame.
211 CONTENTS specifies the alternatives to display in the dialog box.
212 It is a list of the form (DIALOG ITEM1 ITEM2...).
213 Each ITEM is a cons cell (STRING . VALUE).
214 The return value is VALUE from the chosen item.
216 An ITEM may also be just a string--that makes a nonselectable item.
217 An ITEM may also be nil--that means to put all preceding items
218 on the left of the dialog box and all following items on the right.
219 \(By default, approximately half appear on each side.)
221 If HEADER is non-nil, the frame title for the box is "Information",
222 otherwise it is "Question".
224 If the user gets rid of the dialog box without making a valid choice,
225 for instance using the window manager, then this produces a quit and
226 `x-popup-dialog' does not return. */)
227 (Lisp_Object position
, Lisp_Object contents
, Lisp_Object header
)
234 /* Decode the first argument: find the window or frame to use. */
235 if (EQ (position
, Qt
)
236 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
237 || EQ (XCAR (position
), Qtool_bar
))))
239 #if 0 /* Using the frame the mouse is on may not be right. */
240 /* Use the mouse's current position. */
241 FRAME_PTR new_f
= SELECTED_FRAME ();
242 Lisp_Object bar_window
;
243 enum scroll_bar_part part
;
247 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
250 XSETFRAME (window
, new_f
);
252 window
= selected_window
;
254 window
= selected_window
;
256 else if (CONSP (position
))
259 tem
= Fcar (position
);
261 window
= Fcar (Fcdr (position
));
264 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
265 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
268 else if (WINDOWP (position
) || FRAMEP (position
))
273 /* Decode where to put the menu. */
277 else if (WINDOWP (window
))
279 CHECK_LIVE_WINDOW (window
);
280 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
283 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
284 but I don't want to make one now. */
285 CHECK_WINDOW (window
);
287 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
288 error ("Can not put X dialog on this terminal");
290 /* Force a redisplay before showing the dialog. If a frame is created
291 just before showing the dialog, its contents may not have been fully
292 drawn, as this depends on timing of events from the X server. Redisplay
293 is not done when a dialog is shown. If redisplay could be done in the
294 X event loop (i.e. the X event loop does not run in a signal handler)
295 this would not be needed.
297 Do this before creating the widget value that points to Lisp
298 string contents, because Fredisplay may GC and relocate them. */
301 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
302 /* Display a menu with these alternatives
303 in the middle of frame F. */
305 Lisp_Object x
, y
, frame
, newpos
;
306 XSETFRAME (frame
, f
);
307 XSETINT (x
, x_pixel_width (f
) / 2);
308 XSETINT (y
, x_pixel_height (f
) / 2);
309 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
311 return Fx_popup_menu (newpos
,
312 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
317 const char *error_name
;
318 Lisp_Object selection
;
319 int specpdl_count
= SPECPDL_INDEX ();
321 /* Decode the dialog items from what was specified. */
322 title
= Fcar (contents
);
323 CHECK_STRING (title
);
324 record_unwind_protect (unuse_menu_items
, Qnil
);
326 if (NILP (Fcar (Fcdr (contents
))))
327 /* No buttons specified, add an "Ok" button so users can pop down
328 the dialog. Also, the lesstif/motif version crashes if there are
330 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
332 list_of_panes (Fcons (contents
, Qnil
));
334 /* Display them in a dialog box. */
336 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
339 unbind_to (specpdl_count
, Qnil
);
340 discard_menu_items ();
342 if (error_name
) error (error_name
);
351 /* Set menu_items_inuse so no other popup menu or dialog is created. */
354 x_menu_set_in_use (int in_use
)
356 menu_items_inuse
= in_use
? Qt
: Qnil
;
357 popup_activated_flag
= in_use
;
359 if (popup_activated_flag
)
360 x_activate_timeout_atimer ();
364 /* Wait for an X event to arrive or for a timer to expire. */
367 x_menu_wait_for_event (void *data
)
369 /* Another way to do this is to register a timer callback, that can be
370 done in GTK and Xt. But we have to do it like this when using only X
371 anyway, and with callbacks we would have three variants for timer handling
372 instead of the small ifdefs below. */
376 ! XtAppPending (Xt_app_con
)
377 #elif defined USE_GTK
378 ! gtk_events_pending ()
380 ! XPending ((Display
*) data
)
384 EMACS_TIME next_time
= timer_check (1), *ntp
;
385 long secs
= EMACS_SECS (next_time
);
386 long usecs
= EMACS_USECS (next_time
);
387 SELECT_TYPE read_fds
;
388 struct x_display_info
*dpyinfo
;
392 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
394 int fd
= ConnectionNumber (dpyinfo
->display
);
395 FD_SET (fd
, &read_fds
);
397 XFlush (dpyinfo
->display
);
400 if (secs
< 0 && usecs
< 0)
405 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, ntp
);
411 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
415 /* Loop in Xt until the menu pulldown or dialog popup has been
416 popped down (deactivated). This is used for x-popup-menu
417 and x-popup-dialog; it is not used for the menu bar.
419 NOTE: All calls to popup_get_selection should be protected
420 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
423 popup_get_selection (XEvent
*initial_event
, struct x_display_info
*dpyinfo
, LWLIB_ID id
, int do_timers
)
427 while (popup_activated_flag
)
431 event
= *initial_event
;
436 if (do_timers
) x_menu_wait_for_event (0);
437 XtAppNextEvent (Xt_app_con
, &event
);
440 /* Make sure we don't consider buttons grabbed after menu goes.
441 And make sure to deactivate for any ButtonRelease,
442 even if XtDispatchEvent doesn't do that. */
443 if (event
.type
== ButtonRelease
444 && dpyinfo
->display
== event
.xbutton
.display
)
446 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
447 #ifdef USE_MOTIF /* Pretending that the event came from a
448 Btn1Down seems the only way to convince Motif to
449 activate its callbacks; setting the XmNmenuPost
450 isn't working. --marcus@sysc.pdx.edu. */
451 event
.xbutton
.button
= 1;
452 /* Motif only pops down menus when no Ctrl, Alt or Mod
453 key is pressed and the button is released. So reset key state
454 so Motif thinks this is the case. */
455 event
.xbutton
.state
= 0;
458 /* Pop down on C-g and Escape. */
459 else if (event
.type
== KeyPress
460 && dpyinfo
->display
== event
.xbutton
.display
)
462 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
464 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
465 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
466 popup_activated_flag
= 0;
469 x_dispatch_event (&event
, event
.xany
.display
);
473 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
474 doc
: /* Start key navigation of the menu bar in FRAME.
475 This initially opens the first menu bar item and you can then navigate with the
476 arrow keys, select a menu entry with the return key or cancel with the
477 escape key. If FRAME has no menu bar this function does nothing.
479 If FRAME is nil or not given, use the selected frame. */)
483 FRAME_PTR f
= check_x_frame (frame
);
487 if (FRAME_EXTERNAL_MENU_BAR (f
))
488 set_frame_menubar (f
, 0, 1);
490 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
496 x_catch_errors (FRAME_X_DISPLAY (f
));
497 memset (&ev
, 0, sizeof ev
);
498 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
499 ev
.xbutton
.window
= XtWindow (menubar
);
500 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
501 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
502 ev
.xbutton
.button
= Button1
;
503 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
504 ev
.xbutton
.same_screen
= True
;
511 XtSetArg (al
[0], XtNchildren
, &list
);
512 XtSetArg (al
[1], XtNnumChildren
, &nr
);
513 XtGetValues (menubar
, al
, 2);
514 ev
.xbutton
.window
= XtWindow (list
[0]);
518 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
519 /* From-window, to-window. */
520 ev
.xbutton
.window
, ev
.xbutton
.root
,
522 /* From-position, to-position. */
523 ev
.xbutton
.x
, ev
.xbutton
.y
,
524 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
528 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
533 ev
.type
= ButtonPress
;
534 ev
.xbutton
.state
= 0;
536 XtDispatchEvent (&ev
);
537 ev
.xbutton
.type
= ButtonRelease
;
538 ev
.xbutton
.state
= Button1Mask
;
539 XtDispatchEvent (&ev
);
547 #endif /* USE_X_TOOLKIT */
551 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
552 doc
: /* Start key navigation of the menu bar in FRAME.
553 This initially opens the first menu bar item and you can then navigate with the
554 arrow keys, select a menu entry with the return key or cancel with the
555 escape key. If FRAME has no menu bar this function does nothing.
557 If FRAME is nil or not given, use the selected frame. */)
563 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
567 f
= check_x_frame (frame
);
569 if (FRAME_EXTERNAL_MENU_BAR (f
))
570 set_frame_menubar (f
, 0, 1);
572 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
575 /* Activate the first menu. */
576 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
580 g_signal_emit_by_name (children
->data
, "activate_item");
581 popup_activated_flag
= 1;
582 g_list_free (children
);
590 /* Loop util popup_activated_flag is set to zero in a callback.
591 Used for popup menus and dialogs. */
594 popup_widget_loop (int do_timers
, GtkWidget
*widget
)
596 ++popup_activated_flag
;
598 /* Process events in the Gtk event loop until done. */
599 while (popup_activated_flag
)
601 if (do_timers
) x_menu_wait_for_event (0);
602 gtk_main_iteration ();
607 /* Activate the menu bar of frame F.
608 This is called from keyboard.c when it gets the
609 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
611 To activate the menu bar, we use the X button-press event
612 that was saved in saved_menu_event.
613 That makes the toolkit do its thing.
615 But first we recompute the menu bar contents (the whole tree).
617 The reason for saving the button event until here, instead of
618 passing it to the toolkit right away, is that we can safely
619 execute Lisp code. */
622 x_activate_menubar (FRAME_PTR f
)
627 if (!f
->output_data
.x
->saved_menu_event
->type
)
631 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
632 f
->output_data
.x
->saved_menu_event
->xany
.window
))
636 set_frame_menubar (f
, 0, 1);
638 popup_activated_flag
= 1;
640 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
641 f
->output_data
.x
->saved_menu_event
);
643 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
647 /* Ignore this if we get it a second time. */
648 f
->output_data
.x
->saved_menu_event
->type
= 0;
651 /* This callback is invoked when the user selects a menubar cascade
652 pushbutton, but before the pulldown menu is posted. */
656 popup_activate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
658 popup_activated_flag
= 1;
660 x_activate_timeout_atimer ();
665 /* This callback is invoked when a dialog or menu is finished being
666 used and has been unposted. */
670 popup_deactivate_callback (GtkWidget
*widget
, gpointer client_data
)
672 popup_activated_flag
= 0;
676 popup_deactivate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
678 popup_activated_flag
= 0;
683 /* Function that finds the frame for WIDGET and shows the HELP text
685 F is the frame if known, or NULL if not known. */
687 show_help_event (FRAME_PTR f
, xt_or_gtk_widget widget
, Lisp_Object help
)
693 XSETFRAME (frame
, f
);
694 kbd_buffer_store_help_event (frame
, help
);
698 #if 0 /* This code doesn't do anything useful. ++kfs */
699 /* WIDGET is the popup menu. It's parent is the frame's
700 widget. See which frame that is. */
701 xt_or_gtk_widget frame_widget
= XtParent (widget
);
704 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
708 && (f
= XFRAME (frame
),
709 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
713 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
717 /* Callback called when menu items are highlighted/unhighlighted
718 while moving the mouse over them. WIDGET is the menu bar or menu
719 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
720 the data structure for the menu item, or null in case of
725 menu_highlight_callback (GtkWidget
*widget
, gpointer call_data
)
727 xg_menu_item_cb_data
*cb_data
;
730 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
732 if (! cb_data
) return;
734 help
= call_data
? cb_data
->help
: Qnil
;
736 /* If popup_activated_flag is greater than 1 we are in a popup menu.
737 Don't show help for them, they won't appear before the
738 popup is popped down. */
739 if (popup_activated_flag
<= 1)
740 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
744 menu_highlight_callback (Widget widget
, LWLIB_ID id
, void *call_data
)
749 widget_value
*wv
= (widget_value
*) call_data
;
751 help
= wv
? wv
->help
: Qnil
;
753 /* Determine the frame for the help event. */
754 f
= menubar_id_to_frame (id
);
756 show_help_event (f
, widget
, help
);
761 /* Gtk calls callbacks just because we tell it what item should be
762 selected in a radio group. If this variable is set to a non-zero
763 value, we are creating menus and don't want callbacks right now.
765 static int xg_crazy_callback_abort
;
767 /* This callback is called from the menu bar pulldown menu
768 when the user makes a selection.
769 Figure out what the user chose
770 and put the appropriate events into the keyboard buffer. */
772 menubar_selection_callback (GtkWidget
*widget
, gpointer client_data
)
774 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
776 if (xg_crazy_callback_abort
)
779 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
782 /* For a group of radio buttons, GTK calls the selection callback first
783 for the item that was active before the selection and then for the one that
784 is active after the selection. For C-h k this means we get the help on
785 the deselected item and then the selected item is executed. Prevent that
786 by ignoring the non-active item. */
787 if (GTK_IS_RADIO_MENU_ITEM (widget
)
788 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
791 /* When a menu is popped down, X generates a focus event (i.e. focus
792 goes back to the frame below the menu). Since GTK buffers events,
793 we force it out here before the menu selection event. Otherwise
794 sit-for will exit at once if the focus event follows the menu selection
798 while (gtk_events_pending ())
799 gtk_main_iteration ();
802 find_and_call_menu_selection (cb_data
->cl_data
->f
,
803 cb_data
->cl_data
->menu_bar_items_used
,
804 cb_data
->cl_data
->menu_bar_vector
,
808 #else /* not USE_GTK */
810 /* This callback is called from the menu bar pulldown menu
811 when the user makes a selection.
812 Figure out what the user chose
813 and put the appropriate events into the keyboard buffer. */
815 menubar_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
819 f
= menubar_id_to_frame (id
);
822 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
823 f
->menu_bar_vector
, client_data
);
825 #endif /* not USE_GTK */
827 /* Recompute all the widgets of frame F, when the menu bar has been
828 changed. Value is non-zero if widgets were updated. */
831 update_frame_menubar (FRAME_PTR f
)
834 return xg_update_frame_menubar (f
);
842 x
= f
->output_data
.x
;
844 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
848 /* Save the size of the frame because the pane widget doesn't accept
849 to resize itself. So force it. */
850 columns
= FRAME_COLS (f
);
851 rows
= FRAME_LINES (f
);
853 /* Do the voodoo which means "I'm changing lots of things, don't try
854 to refigure sizes until I'm done." */
855 lw_refigure_widget (x
->column_widget
, False
);
857 /* The order in which children are managed is the top to bottom
858 order in which they are displayed in the paned window. First,
859 remove the text-area widget. */
860 XtUnmanageChild (x
->edit_widget
);
862 /* Remove the menubar that is there now, and put up the menubar that
864 XtManageChild (x
->menubar_widget
);
865 XtMapWidget (x
->menubar_widget
);
866 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
868 /* Re-manage the text-area widget, and then thrash the sizes. */
869 XtManageChild (x
->edit_widget
);
870 lw_refigure_widget (x
->column_widget
, True
);
872 /* Force the pane widget to resize itself with the right values. */
873 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
881 apply_systemfont_to_dialog (Widget w
)
883 const char *fn
= xsettings_get_system_normal_font ();
886 XrmDatabase db
= XtDatabase (XtDisplay (w
));
888 XrmPutStringResource (&db
, "*dialog.faceName", fn
);
893 apply_systemfont_to_menu (Widget w
)
895 const char *fn
= xsettings_get_system_normal_font ();
900 if (XtIsShell (w
)) /* popup menu */
902 Widget
*childs
= NULL
;
904 XtVaGetValues (w
, XtNchildren
, &childs
, NULL
);
905 if (*childs
) w
= *childs
;
908 /* Only use system font if the default is used for the menu. */
909 XtVaGetValues (w
, XtNdefaultFace
, &defflt
, NULL
);
911 XtVaSetValues (w
, XtNfaceName
, fn
, NULL
);
915 /* Set the contents of the menubar widgets of frame F.
916 The argument FIRST_TIME is currently ignored;
917 it is set the first time this is called, from initialize_frame_menubar. */
920 set_frame_menubar (FRAME_PTR f
, int first_time
, int deep_p
)
922 xt_or_gtk_widget menubar_widget
;
927 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
929 int *submenu_start
, *submenu_end
;
930 int *submenu_top_level_items
, *submenu_n_panes
;
935 menubar_widget
= f
->output_data
.x
->menubar_widget
;
937 XSETFRAME (Vmenu_updating_frame
, f
);
940 if (f
->output_data
.x
->id
== 0)
941 f
->output_data
.x
->id
= next_menubar_widget_id
++;
942 id
= f
->output_data
.x
->id
;
945 if (! menubar_widget
)
947 /* Make the first call for any given frame always go deep. */
948 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
951 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
952 f
->output_data
.x
->saved_menu_event
->type
= 0;
956 /* If we have detached menus, we must update deep so detached menus
957 also gets updated. */
958 deep_p
= deep_p
|| xg_have_tear_offs ();
963 /* Make a widget-value tree representing the entire menu trees. */
965 struct buffer
*prev
= current_buffer
;
967 int specpdl_count
= SPECPDL_INDEX ();
968 int previous_menu_items_used
= f
->menu_bar_items_used
;
969 Lisp_Object
*previous_items
970 = (Lisp_Object
*) alloca (previous_menu_items_used
971 * sizeof (Lisp_Object
));
973 /* If we are making a new widget, its contents are empty,
974 do always reinitialize them. */
975 if (! menubar_widget
)
976 previous_menu_items_used
= 0;
978 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
979 specbind (Qinhibit_quit
, Qt
);
980 /* Don't let the debugger step into this code
981 because it is not reentrant. */
982 specbind (Qdebug_on_next_call
, Qnil
);
984 record_unwind_save_match_data ();
985 if (NILP (Voverriding_local_map_menu_flag
))
987 specbind (Qoverriding_terminal_local_map
, Qnil
);
988 specbind (Qoverriding_local_map
, Qnil
);
991 set_buffer_internal_1 (XBUFFER (buffer
));
993 /* Run the Lucid hook. */
994 safe_run_hooks (Qactivate_menubar_hook
);
996 /* If it has changed current-menubar from previous value,
997 really recompute the menubar from the value. */
998 if (! NILP (Vlucid_menu_bar_dirty_flag
))
999 call0 (Qrecompute_lucid_menubar
);
1000 safe_run_hooks (Qmenu_bar_update_hook
);
1001 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1003 items
= FRAME_MENU_BAR_ITEMS (f
);
1005 /* Save the frame's previous menu bar contents data. */
1006 if (previous_menu_items_used
)
1007 memcpy (previous_items
, XVECTOR (f
->menu_bar_vector
)->contents
,
1008 previous_menu_items_used
* sizeof (Lisp_Object
));
1010 /* Fill in menu_items with the current menu bar contents.
1011 This can evaluate Lisp code. */
1014 menu_items
= f
->menu_bar_vector
;
1015 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1016 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1017 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1018 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1019 submenu_top_level_items
1020 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1022 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1024 Lisp_Object key
, string
, maps
;
1028 key
= XVECTOR (items
)->contents
[i
];
1029 string
= XVECTOR (items
)->contents
[i
+ 1];
1030 maps
= XVECTOR (items
)->contents
[i
+ 2];
1034 submenu_start
[i
] = menu_items_used
;
1036 menu_items_n_panes
= 0;
1037 submenu_top_level_items
[i
]
1038 = parse_single_submenu (key
, string
, maps
);
1039 submenu_n_panes
[i
] = menu_items_n_panes
;
1041 submenu_end
[i
] = menu_items_used
;
1044 finish_menu_items ();
1046 /* Convert menu_items into widget_value trees
1047 to display the menu. This cannot evaluate Lisp code. */
1049 wv
= xmalloc_widget_value ();
1050 wv
->name
= "menubar";
1053 wv
->button_type
= BUTTON_TYPE_NONE
;
1057 for (i
= 0; i
< last_i
; i
+= 4)
1059 menu_items_n_panes
= submenu_n_panes
[i
];
1060 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1061 submenu_top_level_items
[i
]);
1065 first_wv
->contents
= wv
;
1066 /* Don't set wv->name here; GC during the loop might relocate it. */
1068 wv
->button_type
= BUTTON_TYPE_NONE
;
1072 set_buffer_internal_1 (prev
);
1074 /* If there has been no change in the Lisp-level contents
1075 of the menu bar, skip redisplaying it. Just exit. */
1077 /* Compare the new menu items with the ones computed last time. */
1078 for (i
= 0; i
< previous_menu_items_used
; i
++)
1079 if (menu_items_used
== i
1080 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1082 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1084 /* The menu items have not changed. Don't bother updating
1085 the menus in any form, since it would be a no-op. */
1086 free_menubar_widget_value_tree (first_wv
);
1087 discard_menu_items ();
1088 unbind_to (specpdl_count
, Qnil
);
1092 /* The menu items are different, so store them in the frame. */
1093 f
->menu_bar_vector
= menu_items
;
1094 f
->menu_bar_items_used
= menu_items_used
;
1096 /* This undoes save_menu_items. */
1097 unbind_to (specpdl_count
, Qnil
);
1099 /* Now GC cannot happen during the lifetime of the widget_value,
1100 so it's safe to store data from a Lisp_String. */
1101 wv
= first_wv
->contents
;
1102 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1105 string
= XVECTOR (items
)->contents
[i
+ 1];
1108 wv
->name
= SSDATA (string
);
1109 update_submenu_strings (wv
->contents
);
1116 /* Make a widget-value tree containing
1117 just the top level menu bar strings. */
1119 wv
= xmalloc_widget_value ();
1120 wv
->name
= "menubar";
1123 wv
->button_type
= BUTTON_TYPE_NONE
;
1127 items
= FRAME_MENU_BAR_ITEMS (f
);
1128 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1132 string
= XVECTOR (items
)->contents
[i
+ 1];
1136 wv
= xmalloc_widget_value ();
1137 wv
->name
= SSDATA (string
);
1140 wv
->button_type
= BUTTON_TYPE_NONE
;
1142 /* This prevents lwlib from assuming this
1143 menu item is really supposed to be empty. */
1144 /* The EMACS_INT cast avoids a warning.
1145 This value just has to be different from small integers. */
1146 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1151 first_wv
->contents
= wv
;
1155 /* Forget what we thought we knew about what is in the
1156 detailed contents of the menu bar menus.
1157 Changing the top level always destroys the contents. */
1158 f
->menu_bar_items_used
= 0;
1161 /* Create or update the menu bar widget. */
1166 xg_crazy_callback_abort
= 1;
1169 /* The fourth arg is DEEP_P, which says to consider the entire
1170 menu trees we supply, rather than just the menu bar item names. */
1171 xg_modify_menubar_widgets (menubar_widget
,
1175 G_CALLBACK (menubar_selection_callback
),
1176 G_CALLBACK (popup_deactivate_callback
),
1177 G_CALLBACK (menu_highlight_callback
));
1181 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
1184 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
1185 G_CALLBACK (menubar_selection_callback
),
1186 G_CALLBACK (popup_deactivate_callback
),
1187 G_CALLBACK (menu_highlight_callback
));
1189 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1193 #else /* not USE_GTK */
1196 /* Disable resizing (done for Motif!) */
1197 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1199 /* The third arg is DEEP_P, which says to consider the entire
1200 menu trees we supply, rather than just the menu bar item names. */
1201 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1203 /* Re-enable the edit widget to resize. */
1204 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1208 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
1209 XtTranslations override
= XtParseTranslationTable (menuOverride
);
1211 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1212 f
->output_data
.x
->column_widget
,
1214 popup_activate_callback
,
1215 menubar_selection_callback
,
1216 popup_deactivate_callback
,
1217 menu_highlight_callback
);
1218 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1220 /* Make menu pop down on C-g. */
1221 XtOverrideTranslations (menubar_widget
, override
);
1223 apply_systemfont_to_menu (menubar_widget
);
1229 if (f
->output_data
.x
->menubar_widget
)
1230 XtRealizeWidget (f
->output_data
.x
->menubar_widget
);
1233 = (f
->output_data
.x
->menubar_widget
1234 ? (f
->output_data
.x
->menubar_widget
->core
.height
1235 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1238 #if 1 /* Experimentally, we now get the right results
1239 for -geometry -0-0 without this. 24 Aug 96, rms.
1240 Maybe so, but the menu bar size is missing the pixels so the
1241 WM size hints are off by these pixels. Jan D, oct 2009. */
1243 if (FRAME_EXTERNAL_MENU_BAR (f
))
1246 XtVaGetValues (f
->output_data
.x
->column_widget
,
1247 XtNinternalBorderWidth
, &ibw
, NULL
);
1248 menubar_size
+= ibw
;
1250 #endif /* USE_LUCID */
1253 f
->output_data
.x
->menubar_height
= menubar_size
;
1255 #endif /* not USE_GTK */
1257 free_menubar_widget_value_tree (first_wv
);
1258 update_frame_menubar (f
);
1261 xg_crazy_callback_abort
= 0;
1267 /* Called from Fx_create_frame to create the initial menubar of a frame
1268 before it is mapped, so that the window is mapped with the menubar already
1269 there instead of us tacking it on later and thrashing the window after it
1273 initialize_frame_menubar (FRAME_PTR f
)
1275 /* This function is called before the first chance to redisplay
1276 the frame. It has to be, so the frame will have the right size. */
1277 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1278 set_frame_menubar (f
, 1, 1);
1282 /* Get rid of the menu bar of frame F, and free its storage.
1283 This is used when deleting a frame, and when turning off the menu bar.
1284 For GTK this function is in gtkutil.c. */
1288 free_frame_menubar (FRAME_PTR f
)
1290 Widget menubar_widget
;
1292 if (! FRAME_X_P (f
))
1295 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1297 f
->output_data
.x
->menubar_height
= 0;
1302 /* Removing the menu bar magically changes the shell widget's x
1303 and y position of (0, 0) which, when the menu bar is turned
1304 on again, leads to pull-down menuss appearing in strange
1305 positions near the upper-left corner of the display. This
1306 happens only with some window managers like twm and ctwm,
1307 but not with other like Motif's mwm or kwm, because the
1308 latter generate ConfigureNotify events when the menu bar
1309 is switched off, which fixes the shell position. */
1310 Position x0
, y0
, x1
, y1
;
1316 if (f
->output_data
.x
->widget
)
1317 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1320 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1321 f
->output_data
.x
->menubar_widget
= NULL
;
1323 if (f
->output_data
.x
->widget
)
1326 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1327 if (x1
== 0 && y1
== 0)
1328 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1330 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1335 #endif /* not USE_GTK */
1337 #endif /* USE_X_TOOLKIT || USE_GTK */
1339 /* xmenu_show actually displays a menu using the panes and items in menu_items
1340 and returns the value selected from it.
1341 There are two versions of xmenu_show, one for Xt and one for Xlib.
1342 Both assume input is blocked by the caller. */
1344 /* F is the frame the menu is for.
1345 X and Y are the frame-relative specified position,
1346 relative to the inside upper left corner of the frame F.
1347 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1348 KEYMAPS is 1 if this menu was specified with keymaps;
1349 in that case, we return a list containing the chosen item's value
1350 and perhaps also the pane's prefix.
1351 TITLE is the specified menu title.
1352 ERROR is a place to store an error message string in case of failure.
1353 (We return nil on failure, but the value doesn't actually matter.) */
1355 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1357 /* The item selected in the popup menu. */
1358 static Lisp_Object
*volatile menu_item_selection
;
1362 /* Used when position a popup menu. See menu_position_func and
1363 create_and_show_popup_menu below. */
1364 struct next_popup_x_y
1371 /* The menu position function to use if we are not putting a popup
1372 menu where the pointer is.
1373 MENU is the menu to pop up.
1374 X and Y shall on exit contain x/y where the menu shall pop up.
1375 PUSH_IN is not documented in the GTK manual.
1376 USER_DATA is any data passed in when calling gtk_menu_popup.
1377 Here it points to a struct next_popup_x_y where the coordinates
1378 to store in *X and *Y are as well as the frame for the popup.
1380 Here only X and Y are used. */
1382 menu_position_func (GtkMenu
*menu
, gint
*x
, gint
*y
, gboolean
*push_in
, gpointer user_data
)
1384 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
1386 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (data
->f
);
1387 int disp_width
= x_display_pixel_width (dpyinfo
);
1388 int disp_height
= x_display_pixel_height (dpyinfo
);
1393 /* Check if there is room for the menu. If not, adjust x/y so that
1394 the menu is fully visible. */
1395 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
1396 if (data
->x
+ req
.width
> disp_width
)
1397 *x
-= data
->x
+ req
.width
- disp_width
;
1398 if (data
->y
+ req
.height
> disp_height
)
1399 *y
-= data
->y
+ req
.height
- disp_height
;
1403 popup_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1405 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1407 if (xg_crazy_callback_abort
) return;
1408 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
1412 pop_down_menu (Lisp_Object arg
)
1414 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1416 popup_activated_flag
= 0;
1418 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1423 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1425 menu_item_selection will be set to the selection. */
1427 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
, int x
, int y
, int for_click
, EMACS_UINT timestamp
)
1431 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
1432 struct next_popup_x_y popup_x_y
;
1433 int specpdl_count
= SPECPDL_INDEX ();
1435 if (! FRAME_X_P (f
))
1438 xg_crazy_callback_abort
= 1;
1439 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
1440 G_CALLBACK (popup_selection_callback
),
1441 G_CALLBACK (popup_deactivate_callback
),
1442 G_CALLBACK (menu_highlight_callback
));
1443 xg_crazy_callback_abort
= 0;
1447 /* Not invoked by a click. pop up at x/y. */
1448 pos_func
= menu_position_func
;
1450 /* Adjust coordinates to be root-window-relative. */
1451 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1452 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1458 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1462 for (i
= 0; i
< 5; i
++)
1463 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1467 /* Display the menu. */
1468 gtk_widget_show_all (menu
);
1470 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
,
1471 timestamp
> 0 ? timestamp
: gtk_get_current_event_time());
1473 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1475 if (gtk_widget_get_mapped (menu
))
1477 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1478 two. show_help_echo uses this to detect popup menus. */
1479 popup_activated_flag
= 1;
1480 /* Process events that apply to the menu. */
1481 popup_widget_loop (1, menu
);
1484 unbind_to (specpdl_count
, Qnil
);
1486 /* Must reset this manually because the button release event is not passed
1487 to Emacs event loop. */
1488 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1491 #else /* not USE_GTK */
1493 /* We need a unique id for each widget handled by the Lucid Widget
1496 For the main windows, and popup menus, we use this counter,
1497 which we increment each time after use. This starts from 1<<16.
1499 For menu bars, we use numbers starting at 0, counted in
1500 next_menubar_widget_id. */
1501 LWLIB_ID widget_id_tick
;
1504 popup_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1506 menu_item_selection
= (Lisp_Object
*) client_data
;
1509 /* ARG is the LWLIB ID of the dialog box, represented
1510 as a Lisp object as (HIGHPART . LOWPART). */
1513 pop_down_menu (Lisp_Object arg
)
1515 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
1516 | XINT (XCDR (arg
)));
1519 lw_destroy_all_widgets (id
);
1521 popup_activated_flag
= 0;
1526 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1528 menu_item_selection will be set to the selection. */
1530 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
,
1531 int x
, int y
, int for_click
, EMACS_UINT timestamp
)
1536 XButtonPressedEvent dummy
;
1540 if (! FRAME_X_P (f
))
1543 menu_id
= widget_id_tick
++;
1544 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1545 f
->output_data
.x
->widget
, 1, 0,
1546 popup_selection_callback
,
1547 popup_deactivate_callback
,
1548 menu_highlight_callback
);
1551 apply_systemfont_to_menu (menu
);
1554 dummy
.type
= ButtonPress
;
1556 dummy
.send_event
= 0;
1557 dummy
.display
= FRAME_X_DISPLAY (f
);
1558 dummy
.time
= CurrentTime
;
1559 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1560 dummy
.window
= dummy
.root
;
1561 dummy
.subwindow
= dummy
.root
;
1565 /* Adjust coordinates to be root-window-relative. */
1566 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1567 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1574 for (i
= 0; i
< 5; i
++)
1575 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1578 /* Don't allow any geometry request from the user. */
1579 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
1580 XtSetValues (menu
, av
, ac
);
1582 /* Display the menu. */
1583 lw_popup_menu (menu
, (XEvent
*) &dummy
);
1584 popup_activated_flag
= 1;
1585 x_activate_timeout_atimer ();
1588 int fact
= 4 * sizeof (LWLIB_ID
);
1589 int specpdl_count
= SPECPDL_INDEX ();
1590 record_unwind_protect (pop_down_menu
,
1591 Fcons (make_number (menu_id
>> (fact
)),
1592 make_number (menu_id
& ~(-1 << (fact
)))));
1594 /* Process events that apply to the menu. */
1595 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
1597 unbind_to (specpdl_count
, Qnil
);
1601 #endif /* not USE_GTK */
1604 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
1605 Lisp_Object title
, const char **error
, EMACS_UINT timestamp
)
1608 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1609 widget_value
**submenu_stack
1610 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1611 Lisp_Object
*subprefix_stack
1612 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1613 int submenu_depth
= 0;
1617 if (! FRAME_X_P (f
))
1622 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1624 *error
= "Empty menu";
1628 /* Create a tree of widget_value objects
1629 representing the panes and their items. */
1630 wv
= xmalloc_widget_value ();
1634 wv
->button_type
= BUTTON_TYPE_NONE
;
1639 /* Loop over all panes and items, filling in the tree. */
1641 while (i
< menu_items_used
)
1643 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1645 submenu_stack
[submenu_depth
++] = save_wv
;
1651 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1654 save_wv
= submenu_stack
[--submenu_depth
];
1658 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1659 && submenu_depth
!= 0)
1660 i
+= MENU_ITEMS_PANE_LENGTH
;
1661 /* Ignore a nil in the item list.
1662 It's meaningful only for dialog boxes. */
1663 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1665 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1667 /* Create a new pane. */
1668 Lisp_Object pane_name
, prefix
;
1669 const char *pane_string
;
1671 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1672 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1674 #ifndef HAVE_MULTILINGUAL_MENU
1675 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1677 pane_name
= ENCODE_MENU_STRING (pane_name
);
1678 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1681 pane_string
= (NILP (pane_name
)
1682 ? "" : SSDATA (pane_name
));
1683 /* If there is just one top-level pane, put all its items directly
1684 under the top-level menu. */
1685 if (menu_items_n_panes
== 1)
1688 /* If the pane has a meaningful name,
1689 make the pane a top-level menu item
1690 with its items as a submenu beneath it. */
1691 if (!keymaps
&& strcmp (pane_string
, ""))
1693 wv
= xmalloc_widget_value ();
1697 first_wv
->contents
= wv
;
1698 wv
->name
= pane_string
;
1699 if (keymaps
&& !NILP (prefix
))
1703 wv
->button_type
= BUTTON_TYPE_NONE
;
1708 else if (first_pane
)
1714 i
+= MENU_ITEMS_PANE_LENGTH
;
1718 /* Create a new item within current pane. */
1719 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
1720 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1721 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1722 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1723 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1724 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1725 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1726 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1728 #ifndef HAVE_MULTILINGUAL_MENU
1729 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
1731 item_name
= ENCODE_MENU_STRING (item_name
);
1732 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1735 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1737 descrip
= ENCODE_MENU_STRING (descrip
);
1738 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1740 #endif /* not HAVE_MULTILINGUAL_MENU */
1742 wv
= xmalloc_widget_value ();
1746 save_wv
->contents
= wv
;
1747 wv
->name
= SSDATA (item_name
);
1748 if (!NILP (descrip
))
1749 wv
->key
= SSDATA (descrip
);
1751 /* If this item has a null value,
1752 make the call_data null so that it won't display a box
1753 when the mouse is on it. */
1755 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
1756 wv
->enabled
= !NILP (enable
);
1759 wv
->button_type
= BUTTON_TYPE_NONE
;
1760 else if (EQ (type
, QCtoggle
))
1761 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1762 else if (EQ (type
, QCradio
))
1763 wv
->button_type
= BUTTON_TYPE_RADIO
;
1767 wv
->selected
= !NILP (selected
);
1769 if (! STRINGP (help
))
1776 i
+= MENU_ITEMS_ITEM_LENGTH
;
1780 /* Deal with the title, if it is non-nil. */
1783 widget_value
*wv_title
= xmalloc_widget_value ();
1784 widget_value
*wv_sep1
= xmalloc_widget_value ();
1785 widget_value
*wv_sep2
= xmalloc_widget_value ();
1787 wv_sep2
->name
= "--";
1788 wv_sep2
->next
= first_wv
->contents
;
1789 wv_sep2
->help
= Qnil
;
1791 wv_sep1
->name
= "--";
1792 wv_sep1
->next
= wv_sep2
;
1793 wv_sep1
->help
= Qnil
;
1795 #ifndef HAVE_MULTILINGUAL_MENU
1796 if (STRING_MULTIBYTE (title
))
1797 title
= ENCODE_MENU_STRING (title
);
1800 wv_title
->name
= SSDATA (title
);
1801 wv_title
->enabled
= TRUE
;
1802 wv_title
->button_type
= BUTTON_TYPE_NONE
;
1803 wv_title
->help
= Qnil
;
1804 wv_title
->next
= wv_sep1
;
1805 first_wv
->contents
= wv_title
;
1808 /* No selection has been chosen yet. */
1809 menu_item_selection
= 0;
1811 /* Actually create and show the menu until popped down. */
1812 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
, timestamp
);
1814 /* Free the widget_value objects we used to specify the contents. */
1815 free_menubar_widget_value_tree (first_wv
);
1817 /* Find the selected item, and its pane, to return
1818 the proper value. */
1819 if (menu_item_selection
!= 0)
1821 Lisp_Object prefix
, entry
;
1823 prefix
= entry
= Qnil
;
1825 while (i
< menu_items_used
)
1827 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1829 subprefix_stack
[submenu_depth
++] = prefix
;
1833 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1835 prefix
= subprefix_stack
[--submenu_depth
];
1838 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1841 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1842 i
+= MENU_ITEMS_PANE_LENGTH
;
1844 /* Ignore a nil in the item list.
1845 It's meaningful only for dialog boxes. */
1846 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1851 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1852 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
1858 entry
= Fcons (entry
, Qnil
);
1860 entry
= Fcons (prefix
, entry
);
1861 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1862 if (!NILP (subprefix_stack
[j
]))
1863 entry
= Fcons (subprefix_stack
[j
], entry
);
1867 i
+= MENU_ITEMS_ITEM_LENGTH
;
1871 else if (!for_click
)
1872 /* Make "Cancel" equivalent to C-g. */
1873 Fsignal (Qquit
, Qnil
);
1880 dialog_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1882 /* The EMACS_INT cast avoids a warning. There's no problem
1883 as long as pointers have enough bits to hold small integers. */
1884 if ((int) (EMACS_INT
) client_data
!= -1)
1885 menu_item_selection
= (Lisp_Object
*) client_data
;
1887 popup_activated_flag
= 0;
1890 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1892 menu_item_selection will be set to the selection. */
1894 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1898 if (! FRAME_X_P (f
))
1901 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
1902 G_CALLBACK (dialog_selection_callback
),
1903 G_CALLBACK (popup_deactivate_callback
),
1908 int specpdl_count
= SPECPDL_INDEX ();
1909 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1911 /* Display the menu. */
1912 gtk_widget_show_all (menu
);
1914 /* Process events that apply to the menu. */
1915 popup_widget_loop (1, menu
);
1917 unbind_to (specpdl_count
, Qnil
);
1921 #else /* not USE_GTK */
1923 dialog_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1925 /* The EMACS_INT cast avoids a warning. There's no problem
1926 as long as pointers have enough bits to hold small integers. */
1927 if ((int) (EMACS_INT
) client_data
!= -1)
1928 menu_item_selection
= (Lisp_Object
*) client_data
;
1931 lw_destroy_all_widgets (id
);
1933 popup_activated_flag
= 0;
1937 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1939 menu_item_selection will be set to the selection. */
1941 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1948 dialog_id
= widget_id_tick
++;
1950 apply_systemfont_to_dialog (f
->output_data
.x
->widget
);
1952 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1953 f
->output_data
.x
->widget
, 1, 0,
1954 dialog_selection_callback
, 0, 0);
1955 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1956 /* Display the dialog box. */
1957 lw_pop_up_all_widgets (dialog_id
);
1958 popup_activated_flag
= 1;
1959 x_activate_timeout_atimer ();
1961 /* Process events that apply to the dialog box.
1962 Also handle timers. */
1964 int count
= SPECPDL_INDEX ();
1965 int fact
= 4 * sizeof (LWLIB_ID
);
1967 /* xdialog_show_unwind is responsible for popping the dialog box down. */
1968 record_unwind_protect (pop_down_menu
,
1969 Fcons (make_number (dialog_id
>> (fact
)),
1970 make_number (dialog_id
& ~(-1 << (fact
)))));
1972 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
1975 unbind_to (count
, Qnil
);
1979 #endif /* not USE_GTK */
1981 static const char * button_names
[] = {
1982 "button1", "button2", "button3", "button4", "button5",
1983 "button6", "button7", "button8", "button9", "button10" };
1986 xdialog_show (FRAME_PTR f
,
1990 const char **error_name
)
1992 int i
, nb_buttons
=0;
1993 char dialog_name
[6];
1995 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
1997 /* Number of elements seen so far, before boundary. */
1999 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2000 int boundary_seen
= 0;
2002 if (! FRAME_X_P (f
))
2007 if (menu_items_n_panes
> 1)
2009 *error_name
= "Multiple panes in dialog box";
2013 /* Create a tree of widget_value objects
2014 representing the text label and buttons. */
2016 Lisp_Object pane_name
, prefix
;
2017 const char *pane_string
;
2018 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2019 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2020 pane_string
= (NILP (pane_name
)
2021 ? "" : SSDATA (pane_name
));
2022 prev_wv
= xmalloc_widget_value ();
2023 prev_wv
->value
= pane_string
;
2024 if (keymaps
&& !NILP (prefix
))
2026 prev_wv
->enabled
= 1;
2027 prev_wv
->name
= "message";
2028 prev_wv
->help
= Qnil
;
2031 /* Loop over all panes and items, filling in the tree. */
2032 i
= MENU_ITEMS_PANE_LENGTH
;
2033 while (i
< menu_items_used
)
2036 /* Create a new item within current pane. */
2037 Lisp_Object item_name
, enable
, descrip
;
2038 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2039 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2041 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2043 if (NILP (item_name
))
2045 free_menubar_widget_value_tree (first_wv
);
2046 *error_name
= "Submenu in dialog items";
2049 if (EQ (item_name
, Qquote
))
2051 /* This is the boundary between left-side elts
2052 and right-side elts. Stop incrementing right_count. */
2057 if (nb_buttons
>= 9)
2059 free_menubar_widget_value_tree (first_wv
);
2060 *error_name
= "Too many dialog items";
2064 wv
= xmalloc_widget_value ();
2066 wv
->name
= (char *) button_names
[nb_buttons
];
2067 if (!NILP (descrip
))
2068 wv
->key
= SSDATA (descrip
);
2069 wv
->value
= SSDATA (item_name
);
2070 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2071 wv
->enabled
= !NILP (enable
);
2075 if (! boundary_seen
)
2079 i
+= MENU_ITEMS_ITEM_LENGTH
;
2082 /* If the boundary was not specified,
2083 by default put half on the left and half on the right. */
2084 if (! boundary_seen
)
2085 left_count
= nb_buttons
- nb_buttons
/ 2;
2087 wv
= xmalloc_widget_value ();
2088 wv
->name
= dialog_name
;
2091 /* Frame title: 'Q' = Question, 'I' = Information.
2092 Can also have 'E' = Error if, one day, we want
2093 a popup for errors. */
2095 dialog_name
[0] = 'Q';
2097 dialog_name
[0] = 'I';
2099 /* Dialog boxes use a really stupid name encoding
2100 which specifies how many buttons to use
2101 and how many buttons are on the right. */
2102 dialog_name
[1] = '0' + nb_buttons
;
2103 dialog_name
[2] = 'B';
2104 dialog_name
[3] = 'R';
2105 /* Number of buttons to put on the right. */
2106 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2108 wv
->contents
= first_wv
;
2112 /* No selection has been chosen yet. */
2113 menu_item_selection
= 0;
2115 /* Actually create and show the dialog. */
2116 create_and_show_dialog (f
, first_wv
);
2118 /* Free the widget_value objects we used to specify the contents. */
2119 free_menubar_widget_value_tree (first_wv
);
2121 /* Find the selected item, and its pane, to return
2122 the proper value. */
2123 if (menu_item_selection
!= 0)
2129 while (i
< menu_items_used
)
2133 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2136 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2137 i
+= MENU_ITEMS_PANE_LENGTH
;
2139 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2141 /* This is the boundary between left-side elts and
2148 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2149 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2153 entry
= Fcons (entry
, Qnil
);
2155 entry
= Fcons (prefix
, entry
);
2159 i
+= MENU_ITEMS_ITEM_LENGTH
;
2164 /* Make "Cancel" equivalent to C-g. */
2165 Fsignal (Qquit
, Qnil
);
2170 #else /* not USE_X_TOOLKIT && not USE_GTK */
2172 /* The frame of the last activated non-toolkit menu bar.
2173 Used to generate menu help events. */
2175 static struct frame
*menu_help_frame
;
2178 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2180 PANE is the pane number, and ITEM is the menu item number in
2181 the menu (currently not used).
2183 This cannot be done with generating a HELP_EVENT because
2184 XMenuActivate contains a loop that doesn't let Emacs process
2188 menu_help_callback (char *help_string
, int pane
, int item
)
2190 Lisp_Object
*first_item
;
2191 Lisp_Object pane_name
;
2192 Lisp_Object menu_object
;
2194 first_item
= XVECTOR (menu_items
)->contents
;
2195 if (EQ (first_item
[0], Qt
))
2196 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2197 else if (EQ (first_item
[0], Qquote
))
2198 /* This shouldn't happen, see xmenu_show. */
2199 pane_name
= empty_unibyte_string
;
2201 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2203 /* (menu-item MENU-NAME PANE-NUMBER) */
2204 menu_object
= Fcons (Qmenu_item
,
2206 Fcons (make_number (pane
), Qnil
)));
2207 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2208 Qnil
, menu_object
, make_number (item
), 1);
2212 pop_down_menu (Lisp_Object arg
)
2214 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
2215 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
2217 FRAME_PTR f
= p1
->pointer
;
2218 XMenu
*menu
= p2
->pointer
;
2222 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
2223 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
2225 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2227 #ifdef HAVE_X_WINDOWS
2228 /* Assume the mouse has moved out of the X window.
2229 If it has actually moved in, we will get an EnterNotify. */
2230 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2232 /* State that no mouse buttons are now held.
2233 (The oldXMenu code doesn't track this info for us.)
2234 That is not necessarily true, but the fiction leads to reasonable
2235 results, and it is a pain to ask which are actually held now. */
2236 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2238 #endif /* HAVE_X_WINDOWS */
2247 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
2248 Lisp_Object title
, const char **error
, EMACS_UINT timestamp
)
2252 int pane
, selidx
, lpane
, status
;
2253 Lisp_Object entry
, pane_prefix
;
2255 int ulx
, uly
, width
, height
;
2256 int dispwidth
, dispheight
;
2257 int i
, j
, lines
, maxlines
;
2260 unsigned int dummy_uint
;
2261 int specpdl_count
= SPECPDL_INDEX ();
2263 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
2267 if (menu_items_n_panes
== 0)
2270 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2272 *error
= "Empty menu";
2276 /* Figure out which root window F is on. */
2277 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2278 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2279 &dummy_uint
, &dummy_uint
);
2281 /* Make the menu on that window. */
2282 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2285 *error
= "Can't create menu";
2289 /* Don't GC while we prepare and show the menu,
2290 because we give the oldxmenu library pointers to the
2291 contents of strings. */
2292 inhibit_garbage_collection ();
2294 #ifdef HAVE_X_WINDOWS
2295 /* Adjust coordinates to relative to the outer (window manager) window. */
2296 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
2297 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2298 #endif /* HAVE_X_WINDOWS */
2300 /* Adjust coordinates to be root-window-relative. */
2304 /* Create all the necessary panes and their items. */
2305 maxlines
= lines
= i
= 0;
2306 while (i
< menu_items_used
)
2308 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2310 /* Create a new pane. */
2311 Lisp_Object pane_name
, prefix
;
2314 maxlines
= max (maxlines
, lines
);
2316 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2317 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2318 pane_string
= (NILP (pane_name
)
2319 ? "" : SSDATA (pane_name
));
2320 if (keymaps
&& !NILP (prefix
))
2323 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2324 if (lpane
== XM_FAILURE
)
2326 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2327 *error
= "Can't create pane";
2330 i
+= MENU_ITEMS_PANE_LENGTH
;
2332 /* Find the width of the widest item in this pane. */
2335 while (j
< menu_items_used
)
2338 item
= XVECTOR (menu_items
)->contents
[j
];
2346 width
= SBYTES (item
);
2347 if (width
> maxwidth
)
2350 j
+= MENU_ITEMS_ITEM_LENGTH
;
2353 /* Ignore a nil in the item list.
2354 It's meaningful only for dialog boxes. */
2355 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2359 /* Create a new item within current pane. */
2360 Lisp_Object item_name
, enable
, descrip
, help
;
2361 unsigned char *item_data
;
2364 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2365 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2367 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2368 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2369 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
2371 if (!NILP (descrip
))
2373 int gap
= maxwidth
- SBYTES (item_name
);
2374 /* if alloca is fast, use that to make the space,
2375 to reduce gc needs. */
2377 = (unsigned char *) alloca (maxwidth
2378 + SBYTES (descrip
) + 1);
2379 memcpy (item_data
, SDATA (item_name
), SBYTES (item_name
));
2380 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
2382 memcpy (item_data
+ j
, SDATA (descrip
), SBYTES (descrip
));
2383 item_data
[j
+ SBYTES (descrip
)] = 0;
2386 item_data
= SDATA (item_name
);
2388 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2389 menu
, lpane
, 0, item_data
,
2390 !NILP (enable
), help_string
)
2393 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2394 *error
= "Can't add selection to menu";
2397 i
+= MENU_ITEMS_ITEM_LENGTH
;
2402 maxlines
= max (maxlines
, lines
);
2404 /* All set and ready to fly. */
2405 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2406 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2407 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2408 x
= min (x
, dispwidth
);
2409 y
= min (y
, dispheight
);
2412 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2413 &ulx
, &uly
, &width
, &height
);
2414 if (ulx
+width
> dispwidth
)
2416 x
-= (ulx
+ width
) - dispwidth
;
2417 ulx
= dispwidth
- width
;
2419 if (uly
+height
> dispheight
)
2421 y
-= (uly
+ height
) - dispheight
;
2422 uly
= dispheight
- height
;
2424 #ifndef HAVE_X_WINDOWS
2425 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 1)
2427 /* Move the menu away of the echo area, to avoid overwriting the
2428 menu with help echo messages or vice versa. */
2429 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
2431 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2432 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2441 if (ulx
< 0) x
-= ulx
;
2442 if (uly
< 0) y
-= uly
;
2446 /* If position was not given by a mouse click, adjust so upper left
2447 corner of the menu as a whole ends up at given coordinates. This
2448 is what x-popup-menu says in its documentation. */
2450 y
+= 1.5*height
/(maxlines
+2);
2453 XMenuSetAEQ (menu
, TRUE
);
2454 XMenuSetFreeze (menu
, TRUE
);
2458 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
2461 record_unwind_protect (pop_down_menu
,
2462 Fcons (make_save_value (f
, 0),
2463 make_save_value (menu
, 0)));
2465 /* Help display under X won't work because XMenuActivate contains
2466 a loop that doesn't give Emacs a chance to process it. */
2467 menu_help_frame
= f
;
2468 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2469 x
, y
, ButtonReleaseMask
, &datap
,
2470 menu_help_callback
);
2476 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2479 /* Find the item number SELIDX in pane number PANE. */
2481 while (i
< menu_items_used
)
2483 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2487 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2489 i
+= MENU_ITEMS_PANE_LENGTH
;
2498 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2501 entry
= Fcons (entry
, Qnil
);
2502 if (!NILP (pane_prefix
))
2503 entry
= Fcons (pane_prefix
, entry
);
2509 i
+= MENU_ITEMS_ITEM_LENGTH
;
2515 *error
= "Can't activate menu";
2520 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2521 the menu was invoked with a mouse event as POSITION). */
2523 Fsignal (Qquit
, Qnil
);
2528 unbind_to (specpdl_count
, Qnil
);
2533 #endif /* not USE_X_TOOLKIT */
2535 #endif /* HAVE_MENUS */
2538 /* Detect if a dialog or menu has been posted. MSDOS has its own
2539 implementation on msdos.c. */
2542 popup_activated (void)
2544 return popup_activated_flag
;
2546 #endif /* not MSDOS */
2548 /* The following is used by delayed window autoselection. */
2550 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
2551 doc
: /* Return t if a menu or popup dialog is active. */)
2555 return (popup_activated ()) ? Qt
: Qnil
;
2558 #endif /* HAVE_MENUS */
2562 syms_of_xmenu (void)
2564 Qdebug_on_next_call
= intern_c_string ("debug-on-next-call");
2565 staticpro (&Qdebug_on_next_call
);
2567 #ifdef USE_X_TOOLKIT
2568 widget_id_tick
= (1<<16);
2569 next_menubar_widget_id
= 1;
2572 defsubr (&Smenu_or_popup_active_p
);
2574 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2575 defsubr (&Sx_menu_bar_open_internal
);
2576 Ffset (intern_c_string ("accelerate-menu"),
2577 intern_c_string (Sx_menu_bar_open_internal
.symbol_name
));
2581 defsubr (&Sx_popup_dialog
);