1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2011
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"
53 #include "sysselect.h"
60 /* This may include sys/types.h, and that somehow loses
61 if this is not done before the other system files. */
65 /* Load sys/types.h if not already loaded.
66 In some systems loading it twice is suicidal. */
68 #include <sys/types.h>
71 #include "dispextern.h"
74 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
75 code accepts the Emacs internal encoding. */
76 #undef HAVE_MULTILINGUAL_MENU
80 #include <X11/IntrinsicP.h>
81 #include <X11/CoreP.h>
82 #include <X11/StringDefs.h>
83 #include <X11/Shell.h>
85 #include "xsettings.h"
86 #include "../lwlib/xlwmenu.h"
88 #include <X11/Xaw3d/Paned.h>
89 #else /* !HAVE_XAW3D */
90 #include <X11/Xaw/Paned.h>
91 #endif /* HAVE_XAW3D */
92 #endif /* USE_LUCID */
94 #include "../lwlib/lwlib.h"
96 #else /* not USE_X_TOOLKIT */
98 #include "../oldXMenu/XMenu.h"
100 #endif /* not USE_X_TOOLKIT */
101 #endif /* HAVE_X_WINDOWS */
113 static Lisp_Object Qdebug_on_next_call
;
115 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
116 static Lisp_Object
xdialog_show (FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
120 /* Flag which when set indicates a dialog or menu has been posted by
121 Xt on behalf of one of the widget sets. */
122 static int popup_activated_flag
;
127 static int next_menubar_widget_id
;
129 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
131 static struct frame
*
132 menubar_id_to_frame (LWLIB_ID id
)
134 Lisp_Object tail
, frame
;
137 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
143 if (!FRAME_WINDOW_P (f
))
145 if (f
->output_data
.x
->id
== id
)
153 #ifdef HAVE_X_WINDOWS
154 /* Return the mouse position in *X and *Y. The coordinates are window
155 relative for the edit window in frame F.
156 This is for Fx_popup_menu. The mouse_position_hook can not
157 be used for X, as it returns window relative coordinates
158 for the window where the mouse is in. This could be the menu bar,
159 the scroll bar or the edit window. Fx_popup_menu needs to be
160 sure it is the edit window. */
162 mouse_position_for_popup (FRAME_PTR f
, int *x
, int *y
)
164 Window root
, dummy_window
;
172 XQueryPointer (FRAME_X_DISPLAY (f
),
173 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
175 /* The root window which contains the pointer. */
178 /* Window pointer is on, not used */
181 /* The position on that root window. */
184 /* x/y in dummy_window coordinates, not used. */
187 /* Modifier keys and pointer buttons, about which
189 (unsigned int *) &dummy
);
193 /* xmenu_show expects window coordinates, not root window
194 coordinates. Translate. */
195 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
196 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
199 #endif /* HAVE_X_WINDOWS */
203 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
204 doc
: /* Pop up a dialog box and return user's selection.
205 POSITION specifies which frame to use.
206 This is normally a mouse button event or a window or frame.
207 If POSITION is t, it means to use the frame the mouse is on.
208 The dialog box appears in the middle of the specified frame.
210 CONTENTS specifies the alternatives to display in the dialog box.
211 It is a list of the form (DIALOG ITEM1 ITEM2...).
212 Each ITEM is a cons cell (STRING . VALUE).
213 The return value is VALUE from the chosen item.
215 An ITEM may also be just a string--that makes a nonselectable item.
216 An ITEM may also be nil--that means to put all preceding items
217 on the left of the dialog box and all following items on the right.
218 \(By default, approximately half appear on each side.)
220 If HEADER is non-nil, the frame title for the box is "Information",
221 otherwise it is "Question".
223 If the user gets rid of the dialog box without making a valid choice,
224 for instance using the window manager, then this produces a quit and
225 `x-popup-dialog' does not return. */)
226 (Lisp_Object position
, Lisp_Object contents
, Lisp_Object header
)
233 /* Decode the first argument: find the window or frame to use. */
234 if (EQ (position
, Qt
)
235 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
236 || EQ (XCAR (position
), Qtool_bar
))))
238 #if 0 /* Using the frame the mouse is on may not be right. */
239 /* Use the mouse's current position. */
240 FRAME_PTR new_f
= SELECTED_FRAME ();
241 Lisp_Object bar_window
;
242 enum scroll_bar_part part
;
246 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
249 XSETFRAME (window
, new_f
);
251 window
= selected_window
;
253 window
= selected_window
;
255 else if (CONSP (position
))
258 tem
= Fcar (position
);
260 window
= Fcar (Fcdr (position
));
263 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
264 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
267 else if (WINDOWP (position
) || FRAMEP (position
))
272 /* Decode where to put the menu. */
276 else if (WINDOWP (window
))
278 CHECK_LIVE_WINDOW (window
);
279 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
282 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
283 but I don't want to make one now. */
284 CHECK_WINDOW (window
);
286 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
287 error ("Can not put X dialog on this terminal");
289 /* Force a redisplay before showing the dialog. If a frame is created
290 just before showing the dialog, its contents may not have been fully
291 drawn, as this depends on timing of events from the X server. Redisplay
292 is not done when a dialog is shown. If redisplay could be done in the
293 X event loop (i.e. the X event loop does not run in a signal handler)
294 this would not be needed.
296 Do this before creating the widget value that points to Lisp
297 string contents, because Fredisplay may GC and relocate them. */
300 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
301 /* Display a menu with these alternatives
302 in the middle of frame F. */
304 Lisp_Object x
, y
, frame
, newpos
;
305 XSETFRAME (frame
, f
);
306 XSETINT (x
, x_pixel_width (f
) / 2);
307 XSETINT (y
, x_pixel_height (f
) / 2);
308 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
310 return Fx_popup_menu (newpos
,
311 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
316 const char *error_name
;
317 Lisp_Object selection
;
318 int specpdl_count
= SPECPDL_INDEX ();
320 /* Decode the dialog items from what was specified. */
321 title
= Fcar (contents
);
322 CHECK_STRING (title
);
323 record_unwind_protect (unuse_menu_items
, Qnil
);
325 if (NILP (Fcar (Fcdr (contents
))))
326 /* No buttons specified, add an "Ok" button so users can pop down
327 the dialog. Also, the lesstif/motif version crashes if there are
329 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
331 list_of_panes (Fcons (contents
, Qnil
));
333 /* Display them in a dialog box. */
335 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
338 unbind_to (specpdl_count
, Qnil
);
339 discard_menu_items ();
341 if (error_name
) error ("%s", error_name
);
350 /* Set menu_items_inuse so no other popup menu or dialog is created. */
353 x_menu_set_in_use (int in_use
)
355 menu_items_inuse
= in_use
? Qt
: Qnil
;
356 popup_activated_flag
= in_use
;
358 if (popup_activated_flag
)
359 x_activate_timeout_atimer ();
363 /* Wait for an X event to arrive or for a timer to expire. */
369 x_menu_wait_for_event (void *data
)
371 /* Another way to do this is to register a timer callback, that can be
372 done in GTK and Xt. But we have to do it like this when using only X
373 anyway, and with callbacks we would have three variants for timer handling
374 instead of the small ifdefs below. */
378 ! XtAppPending (Xt_app_con
)
379 #elif defined USE_GTK
380 ! gtk_events_pending ()
382 ! XPending ((Display
*) data
)
386 EMACS_TIME next_time
= timer_check (), *ntp
;
387 long secs
= EMACS_SECS (next_time
);
388 long usecs
= EMACS_USECS (next_time
);
389 SELECT_TYPE read_fds
;
390 struct x_display_info
*dpyinfo
;
394 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
396 int fd
= ConnectionNumber (dpyinfo
->display
);
397 FD_SET (fd
, &read_fds
);
399 XFlush (dpyinfo
->display
);
402 if (secs
< 0 && usecs
< 0)
407 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, ntp
);
413 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
417 /* Loop in Xt until the menu pulldown or dialog popup has been
418 popped down (deactivated). This is used for x-popup-menu
419 and x-popup-dialog; it is not used for the menu bar.
421 NOTE: All calls to popup_get_selection should be protected
422 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
425 popup_get_selection (XEvent
*initial_event
, struct x_display_info
*dpyinfo
, LWLIB_ID id
, int do_timers
)
429 while (popup_activated_flag
)
433 event
= *initial_event
;
438 if (do_timers
) x_menu_wait_for_event (0);
439 XtAppNextEvent (Xt_app_con
, &event
);
442 /* Make sure we don't consider buttons grabbed after menu goes.
443 And make sure to deactivate for any ButtonRelease,
444 even if XtDispatchEvent doesn't do that. */
445 if (event
.type
== ButtonRelease
446 && dpyinfo
->display
== event
.xbutton
.display
)
448 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
449 #ifdef USE_MOTIF /* Pretending that the event came from a
450 Btn1Down seems the only way to convince Motif to
451 activate its callbacks; setting the XmNmenuPost
452 isn't working. --marcus@sysc.pdx.edu. */
453 event
.xbutton
.button
= 1;
454 /* Motif only pops down menus when no Ctrl, Alt or Mod
455 key is pressed and the button is released. So reset key state
456 so Motif thinks this is the case. */
457 event
.xbutton
.state
= 0;
460 /* Pop down on C-g and Escape. */
461 else if (event
.type
== KeyPress
462 && dpyinfo
->display
== event
.xbutton
.display
)
464 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
466 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
467 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
468 popup_activated_flag
= 0;
471 x_dispatch_event (&event
, event
.xany
.display
);
475 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
476 doc
: /* Start key navigation of the menu bar in FRAME.
477 This initially opens the first menu bar item and you can then navigate with the
478 arrow keys, select a menu entry with the return key or cancel with the
479 escape key. If FRAME has no menu bar this function does nothing.
481 If FRAME is nil or not given, use the selected frame. */)
485 FRAME_PTR f
= check_x_frame (frame
);
489 if (FRAME_EXTERNAL_MENU_BAR (f
))
490 set_frame_menubar (f
, 0, 1);
492 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
498 x_catch_errors (FRAME_X_DISPLAY (f
));
499 memset (&ev
, 0, sizeof ev
);
500 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
501 ev
.xbutton
.window
= XtWindow (menubar
);
502 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
503 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
504 ev
.xbutton
.button
= Button1
;
505 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
506 ev
.xbutton
.same_screen
= True
;
513 XtSetArg (al
[0], XtNchildren
, &list
);
514 XtSetArg (al
[1], XtNnumChildren
, &nr
);
515 XtGetValues (menubar
, al
, 2);
516 ev
.xbutton
.window
= XtWindow (list
[0]);
520 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
521 /* From-window, to-window. */
522 ev
.xbutton
.window
, ev
.xbutton
.root
,
524 /* From-position, to-position. */
525 ev
.xbutton
.x
, ev
.xbutton
.y
,
526 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
530 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
535 ev
.type
= ButtonPress
;
536 ev
.xbutton
.state
= 0;
538 XtDispatchEvent (&ev
);
539 ev
.xbutton
.type
= ButtonRelease
;
540 ev
.xbutton
.state
= Button1Mask
;
541 XtDispatchEvent (&ev
);
549 #endif /* USE_X_TOOLKIT */
553 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
554 doc
: /* Start key navigation of the menu bar in FRAME.
555 This initially opens the first menu bar item and you can then navigate with the
556 arrow keys, select a menu entry with the return key or cancel with the
557 escape key. If FRAME has no menu bar this function does nothing.
559 If FRAME is nil or not given, use the selected frame. */)
565 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
569 f
= check_x_frame (frame
);
571 if (FRAME_EXTERNAL_MENU_BAR (f
))
572 set_frame_menubar (f
, 0, 1);
574 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
577 /* Activate the first menu. */
578 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
582 g_signal_emit_by_name (children
->data
, "activate_item");
583 popup_activated_flag
= 1;
584 g_list_free (children
);
592 /* Loop util popup_activated_flag is set to zero in a callback.
593 Used for popup menus and dialogs. */
596 popup_widget_loop (int do_timers
, GtkWidget
*widget
)
598 ++popup_activated_flag
;
600 /* Process events in the Gtk event loop until done. */
601 while (popup_activated_flag
)
603 if (do_timers
) x_menu_wait_for_event (0);
604 gtk_main_iteration ();
609 /* Activate the menu bar of frame F.
610 This is called from keyboard.c when it gets the
611 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
613 To activate the menu bar, we use the X button-press event
614 that was saved in saved_menu_event.
615 That makes the toolkit do its thing.
617 But first we recompute the menu bar contents (the whole tree).
619 The reason for saving the button event until here, instead of
620 passing it to the toolkit right away, is that we can safely
621 execute Lisp code. */
624 x_activate_menubar (FRAME_PTR f
)
629 if (!f
->output_data
.x
->saved_menu_event
->type
)
633 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
634 f
->output_data
.x
->saved_menu_event
->xany
.window
))
638 set_frame_menubar (f
, 0, 1);
640 popup_activated_flag
= 1;
642 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
643 f
->output_data
.x
->saved_menu_event
);
645 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
649 /* Ignore this if we get it a second time. */
650 f
->output_data
.x
->saved_menu_event
->type
= 0;
653 /* This callback is invoked when the user selects a menubar cascade
654 pushbutton, but before the pulldown menu is posted. */
658 popup_activate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
660 popup_activated_flag
= 1;
662 x_activate_timeout_atimer ();
667 /* This callback is invoked when a dialog or menu is finished being
668 used and has been unposted. */
672 popup_deactivate_callback (GtkWidget
*widget
, gpointer client_data
)
674 popup_activated_flag
= 0;
678 popup_deactivate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
680 popup_activated_flag
= 0;
685 /* Function that finds the frame for WIDGET and shows the HELP text
687 F is the frame if known, or NULL if not known. */
689 show_help_event (FRAME_PTR f
, xt_or_gtk_widget widget
, Lisp_Object help
)
695 XSETFRAME (frame
, f
);
696 kbd_buffer_store_help_event (frame
, help
);
700 #if 0 /* This code doesn't do anything useful. ++kfs */
701 /* WIDGET is the popup menu. It's parent is the frame's
702 widget. See which frame that is. */
703 xt_or_gtk_widget frame_widget
= XtParent (widget
);
706 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
710 && (f
= XFRAME (frame
),
711 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
715 show_help_echo (help
, Qnil
, Qnil
, Qnil
);
719 /* Callback called when menu items are highlighted/unhighlighted
720 while moving the mouse over them. WIDGET is the menu bar or menu
721 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
722 the data structure for the menu item, or null in case of
727 menu_highlight_callback (GtkWidget
*widget
, gpointer call_data
)
729 xg_menu_item_cb_data
*cb_data
;
732 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
734 if (! cb_data
) return;
736 help
= call_data
? cb_data
->help
: Qnil
;
738 /* If popup_activated_flag is greater than 1 we are in a popup menu.
739 Don't show help for them, they won't appear before the
740 popup is popped down. */
741 if (popup_activated_flag
<= 1)
742 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
746 menu_highlight_callback (Widget widget
, LWLIB_ID id
, void *call_data
)
751 widget_value
*wv
= (widget_value
*) call_data
;
753 help
= wv
? wv
->help
: Qnil
;
755 /* Determine the frame for the help event. */
756 f
= menubar_id_to_frame (id
);
758 show_help_event (f
, widget
, help
);
763 /* Gtk calls callbacks just because we tell it what item should be
764 selected in a radio group. If this variable is set to a non-zero
765 value, we are creating menus and don't want callbacks right now.
767 static int xg_crazy_callback_abort
;
769 /* This callback is called from the menu bar pulldown menu
770 when the user makes a selection.
771 Figure out what the user chose
772 and put the appropriate events into the keyboard buffer. */
774 menubar_selection_callback (GtkWidget
*widget
, gpointer client_data
)
776 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
778 if (xg_crazy_callback_abort
)
781 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
784 /* For a group of radio buttons, GTK calls the selection callback first
785 for the item that was active before the selection and then for the one that
786 is active after the selection. For C-h k this means we get the help on
787 the deselected item and then the selected item is executed. Prevent that
788 by ignoring the non-active item. */
789 if (GTK_IS_RADIO_MENU_ITEM (widget
)
790 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
793 /* When a menu is popped down, X generates a focus event (i.e. focus
794 goes back to the frame below the menu). Since GTK buffers events,
795 we force it out here before the menu selection event. Otherwise
796 sit-for will exit at once if the focus event follows the menu selection
800 while (gtk_events_pending ())
801 gtk_main_iteration ();
804 find_and_call_menu_selection (cb_data
->cl_data
->f
,
805 cb_data
->cl_data
->menu_bar_items_used
,
806 cb_data
->cl_data
->menu_bar_vector
,
810 #else /* not USE_GTK */
812 /* This callback is called from the menu bar pulldown menu
813 when the user makes a selection.
814 Figure out what the user chose
815 and put the appropriate events into the keyboard buffer. */
817 menubar_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
821 f
= menubar_id_to_frame (id
);
824 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
825 f
->menu_bar_vector
, client_data
);
827 #endif /* not USE_GTK */
829 /* Recompute all the widgets of frame F, when the menu bar has been
830 changed. Value is non-zero if widgets were updated. */
833 update_frame_menubar (FRAME_PTR f
)
836 return xg_update_frame_menubar (f
);
844 x
= f
->output_data
.x
;
846 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
850 /* Save the size of the frame because the pane widget doesn't accept
851 to resize itself. So force it. */
852 columns
= FRAME_COLS (f
);
853 rows
= FRAME_LINES (f
);
855 /* Do the voodoo which means "I'm changing lots of things, don't try
856 to refigure sizes until I'm done." */
857 lw_refigure_widget (x
->column_widget
, False
);
859 /* The order in which children are managed is the top to bottom
860 order in which they are displayed in the paned window. First,
861 remove the text-area widget. */
862 XtUnmanageChild (x
->edit_widget
);
864 /* Remove the menubar that is there now, and put up the menubar that
866 XtManageChild (x
->menubar_widget
);
867 XtMapWidget (x
->menubar_widget
);
868 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
870 /* Re-manage the text-area widget, and then thrash the sizes. */
871 XtManageChild (x
->edit_widget
);
872 lw_refigure_widget (x
->column_widget
, True
);
874 /* Force the pane widget to resize itself with the right values. */
875 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
883 apply_systemfont_to_dialog (Widget w
)
885 const char *fn
= xsettings_get_system_normal_font ();
888 XrmDatabase db
= XtDatabase (XtDisplay (w
));
890 XrmPutStringResource (&db
, "*dialog.font", fn
);
895 apply_systemfont_to_menu (struct frame
*f
, Widget w
)
897 const char *fn
= xsettings_get_system_normal_font ();
901 XrmDatabase db
= XtDatabase (XtDisplay (w
));
904 XrmPutStringResource (&db
, "*menubar*font", fn
);
905 XrmPutStringResource (&db
, "*popup*font", fn
);
912 /* Set the contents of the menubar widgets of frame F.
913 The argument FIRST_TIME is currently ignored;
914 it is set the first time this is called, from initialize_frame_menubar. */
917 set_frame_menubar (FRAME_PTR f
, int first_time
, int deep_p
)
919 xt_or_gtk_widget menubar_widget
;
924 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
926 int *submenu_start
, *submenu_end
;
927 int *submenu_top_level_items
, *submenu_n_panes
;
932 menubar_widget
= f
->output_data
.x
->menubar_widget
;
934 XSETFRAME (Vmenu_updating_frame
, f
);
937 if (f
->output_data
.x
->id
== 0)
938 f
->output_data
.x
->id
= next_menubar_widget_id
++;
939 id
= f
->output_data
.x
->id
;
942 if (! menubar_widget
)
944 /* Make the first call for any given frame always go deep. */
945 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
948 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
949 f
->output_data
.x
->saved_menu_event
->type
= 0;
953 /* If we have detached menus, we must update deep so detached menus
954 also gets updated. */
955 deep_p
= deep_p
|| xg_have_tear_offs ();
960 /* Make a widget-value tree representing the entire menu trees. */
962 struct buffer
*prev
= current_buffer
;
964 int specpdl_count
= SPECPDL_INDEX ();
965 int previous_menu_items_used
= f
->menu_bar_items_used
;
966 Lisp_Object
*previous_items
967 = (Lisp_Object
*) alloca (previous_menu_items_used
968 * sizeof (Lisp_Object
));
971 /* If we are making a new widget, its contents are empty,
972 do always reinitialize them. */
973 if (! menubar_widget
)
974 previous_menu_items_used
= 0;
976 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
977 specbind (Qinhibit_quit
, Qt
);
978 /* Don't let the debugger step into this code
979 because it is not reentrant. */
980 specbind (Qdebug_on_next_call
, Qnil
);
982 record_unwind_save_match_data ();
983 if (NILP (Voverriding_local_map_menu_flag
))
985 specbind (Qoverriding_terminal_local_map
, Qnil
);
986 specbind (Qoverriding_local_map
, Qnil
);
989 set_buffer_internal_1 (XBUFFER (buffer
));
991 /* Run the Lucid hook. */
992 safe_run_hooks (Qactivate_menubar_hook
);
994 /* If it has changed current-menubar from previous value,
995 really recompute the menubar from the value. */
996 if (! NILP (Vlucid_menu_bar_dirty_flag
))
997 call0 (Qrecompute_lucid_menubar
);
998 safe_run_hooks (Qmenu_bar_update_hook
);
999 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1001 items
= FRAME_MENU_BAR_ITEMS (f
);
1003 /* Save the frame's previous menu bar contents data. */
1004 if (previous_menu_items_used
)
1005 memcpy (previous_items
, XVECTOR (f
->menu_bar_vector
)->contents
,
1006 previous_menu_items_used
* sizeof (Lisp_Object
));
1008 /* Fill in menu_items with the current menu bar contents.
1009 This can evaluate Lisp code. */
1012 menu_items
= f
->menu_bar_vector
;
1013 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1014 subitems
= ASIZE (items
) / 4;
1015 submenu_start
= (int *) alloca ((subitems
+ 1) * sizeof (int));
1016 submenu_end
= (int *) alloca (subitems
* sizeof (int));
1017 submenu_n_panes
= (int *) alloca (subitems
* sizeof (int));
1018 submenu_top_level_items
= (int *) alloca (subitems
* sizeof (int));
1020 for (i
= 0; i
< subitems
; i
++)
1022 Lisp_Object key
, string
, maps
;
1024 key
= XVECTOR (items
)->contents
[4 * i
];
1025 string
= XVECTOR (items
)->contents
[4 * i
+ 1];
1026 maps
= XVECTOR (items
)->contents
[4 * i
+ 2];
1030 submenu_start
[i
] = menu_items_used
;
1032 menu_items_n_panes
= 0;
1033 submenu_top_level_items
[i
]
1034 = parse_single_submenu (key
, string
, maps
);
1035 submenu_n_panes
[i
] = menu_items_n_panes
;
1037 submenu_end
[i
] = menu_items_used
;
1040 submenu_start
[i
] = -1;
1041 finish_menu_items ();
1043 /* Convert menu_items into widget_value trees
1044 to display the menu. This cannot evaluate Lisp code. */
1046 wv
= xmalloc_widget_value ();
1047 wv
->name
= "menubar";
1050 wv
->button_type
= BUTTON_TYPE_NONE
;
1054 for (i
= 0; 0 <= submenu_start
[i
]; i
++)
1056 menu_items_n_panes
= submenu_n_panes
[i
];
1057 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1058 submenu_top_level_items
[i
]);
1062 first_wv
->contents
= wv
;
1063 /* Don't set wv->name here; GC during the loop might relocate it. */
1065 wv
->button_type
= BUTTON_TYPE_NONE
;
1069 set_buffer_internal_1 (prev
);
1071 /* If there has been no change in the Lisp-level contents
1072 of the menu bar, skip redisplaying it. Just exit. */
1074 /* Compare the new menu items with the ones computed last time. */
1075 for (i
= 0; i
< previous_menu_items_used
; i
++)
1076 if (menu_items_used
== i
1077 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1079 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1081 /* The menu items have not changed. Don't bother updating
1082 the menus in any form, since it would be a no-op. */
1083 free_menubar_widget_value_tree (first_wv
);
1084 discard_menu_items ();
1085 unbind_to (specpdl_count
, Qnil
);
1089 /* The menu items are different, so store them in the frame. */
1090 f
->menu_bar_vector
= menu_items
;
1091 f
->menu_bar_items_used
= menu_items_used
;
1093 /* This undoes save_menu_items. */
1094 unbind_to (specpdl_count
, Qnil
);
1096 /* Now GC cannot happen during the lifetime of the widget_value,
1097 so it's safe to store data from a Lisp_String. */
1098 wv
= first_wv
->contents
;
1099 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1102 string
= XVECTOR (items
)->contents
[i
+ 1];
1105 wv
->name
= SSDATA (string
);
1106 update_submenu_strings (wv
->contents
);
1113 /* Make a widget-value tree containing
1114 just the top level menu bar strings. */
1116 wv
= xmalloc_widget_value ();
1117 wv
->name
= "menubar";
1120 wv
->button_type
= BUTTON_TYPE_NONE
;
1124 items
= FRAME_MENU_BAR_ITEMS (f
);
1125 for (i
= 0; i
< ASIZE (items
); i
+= 4)
1129 string
= XVECTOR (items
)->contents
[i
+ 1];
1133 wv
= xmalloc_widget_value ();
1134 wv
->name
= SSDATA (string
);
1137 wv
->button_type
= BUTTON_TYPE_NONE
;
1139 /* This prevents lwlib from assuming this
1140 menu item is really supposed to be empty. */
1141 /* The intptr_t cast avoids a warning.
1142 This value just has to be different from small integers. */
1143 wv
->call_data
= (void *) (intptr_t) (-1);
1148 first_wv
->contents
= wv
;
1152 /* Forget what we thought we knew about what is in the
1153 detailed contents of the menu bar menus.
1154 Changing the top level always destroys the contents. */
1155 f
->menu_bar_items_used
= 0;
1158 /* Create or update the menu bar widget. */
1163 xg_crazy_callback_abort
= 1;
1166 /* The fourth arg is DEEP_P, which says to consider the entire
1167 menu trees we supply, rather than just the menu bar item names. */
1168 xg_modify_menubar_widgets (menubar_widget
,
1172 G_CALLBACK (menubar_selection_callback
),
1173 G_CALLBACK (popup_deactivate_callback
),
1174 G_CALLBACK (menu_highlight_callback
));
1179 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
1180 G_CALLBACK (menubar_selection_callback
),
1181 G_CALLBACK (popup_deactivate_callback
),
1182 G_CALLBACK (menu_highlight_callback
));
1184 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1188 #else /* not USE_GTK */
1191 /* Disable resizing (done for Motif!) */
1192 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1194 /* The third arg is DEEP_P, which says to consider the entire
1195 menu trees we supply, rather than just the menu bar item names. */
1196 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1198 /* Re-enable the edit widget to resize. */
1199 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1203 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
1204 XtTranslations override
= XtParseTranslationTable (menuOverride
);
1207 apply_systemfont_to_menu (f
, f
->output_data
.x
->column_widget
);
1209 menubar_widget
= lw_create_widget ("menubar", "menubar", id
,
1211 f
->output_data
.x
->column_widget
,
1213 popup_activate_callback
,
1214 menubar_selection_callback
,
1215 popup_deactivate_callback
,
1216 menu_highlight_callback
);
1217 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1219 /* Make menu pop down on C-g. */
1220 XtOverrideTranslations (menubar_widget
, override
);
1225 if (f
->output_data
.x
->menubar_widget
)
1226 XtRealizeWidget (f
->output_data
.x
->menubar_widget
);
1229 = (f
->output_data
.x
->menubar_widget
1230 ? (f
->output_data
.x
->menubar_widget
->core
.height
1231 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1234 #if 1 /* Experimentally, we now get the right results
1235 for -geometry -0-0 without this. 24 Aug 96, rms.
1236 Maybe so, but the menu bar size is missing the pixels so the
1237 WM size hints are off by these pixels. Jan D, oct 2009. */
1239 if (FRAME_EXTERNAL_MENU_BAR (f
))
1242 XtVaGetValues (f
->output_data
.x
->column_widget
,
1243 XtNinternalBorderWidth
, &ibw
, NULL
);
1244 menubar_size
+= ibw
;
1246 #endif /* USE_LUCID */
1249 f
->output_data
.x
->menubar_height
= menubar_size
;
1251 #endif /* not USE_GTK */
1253 free_menubar_widget_value_tree (first_wv
);
1254 update_frame_menubar (f
);
1257 xg_crazy_callback_abort
= 0;
1263 /* Called from Fx_create_frame to create the initial menubar of a frame
1264 before it is mapped, so that the window is mapped with the menubar already
1265 there instead of us tacking it on later and thrashing the window after it
1269 initialize_frame_menubar (FRAME_PTR f
)
1271 /* This function is called before the first chance to redisplay
1272 the frame. It has to be, so the frame will have the right size. */
1273 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1274 set_frame_menubar (f
, 1, 1);
1278 /* Get rid of the menu bar of frame F, and free its storage.
1279 This is used when deleting a frame, and when turning off the menu bar.
1280 For GTK this function is in gtkutil.c. */
1284 free_frame_menubar (FRAME_PTR f
)
1286 Widget menubar_widget
;
1288 if (! FRAME_X_P (f
))
1291 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1293 f
->output_data
.x
->menubar_height
= 0;
1298 /* Removing the menu bar magically changes the shell widget's x
1299 and y position of (0, 0) which, when the menu bar is turned
1300 on again, leads to pull-down menuss appearing in strange
1301 positions near the upper-left corner of the display. This
1302 happens only with some window managers like twm and ctwm,
1303 but not with other like Motif's mwm or kwm, because the
1304 latter generate ConfigureNotify events when the menu bar
1305 is switched off, which fixes the shell position. */
1306 Position x0
, y0
, x1
, y1
;
1312 if (f
->output_data
.x
->widget
)
1313 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1316 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1317 f
->output_data
.x
->menubar_widget
= NULL
;
1319 if (f
->output_data
.x
->widget
)
1322 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1323 if (x1
== 0 && y1
== 0)
1324 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1326 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1331 #endif /* not USE_GTK */
1333 #endif /* USE_X_TOOLKIT || USE_GTK */
1335 /* xmenu_show actually displays a menu using the panes and items in menu_items
1336 and returns the value selected from it.
1337 There are two versions of xmenu_show, one for Xt and one for Xlib.
1338 Both assume input is blocked by the caller. */
1340 /* F is the frame the menu is for.
1341 X and Y are the frame-relative specified position,
1342 relative to the inside upper left corner of the frame F.
1343 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1344 KEYMAPS is 1 if this menu was specified with keymaps;
1345 in that case, we return a list containing the chosen item's value
1346 and perhaps also the pane's prefix.
1347 TITLE is the specified menu title.
1348 ERROR is a place to store an error message string in case of failure.
1349 (We return nil on failure, but the value doesn't actually matter.) */
1351 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1353 /* The item selected in the popup menu. */
1354 static Lisp_Object
*volatile menu_item_selection
;
1358 /* Used when position a popup menu. See menu_position_func and
1359 create_and_show_popup_menu below. */
1360 struct next_popup_x_y
1367 /* The menu position function to use if we are not putting a popup
1368 menu where the pointer is.
1369 MENU is the menu to pop up.
1370 X and Y shall on exit contain x/y where the menu shall pop up.
1371 PUSH_IN is not documented in the GTK manual.
1372 USER_DATA is any data passed in when calling gtk_menu_popup.
1373 Here it points to a struct next_popup_x_y where the coordinates
1374 to store in *X and *Y are as well as the frame for the popup.
1376 Here only X and Y are used. */
1378 menu_position_func (GtkMenu
*menu
, gint
*x
, gint
*y
, gboolean
*push_in
, gpointer user_data
)
1380 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
1382 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (data
->f
);
1383 int disp_width
= x_display_pixel_width (dpyinfo
);
1384 int disp_height
= x_display_pixel_height (dpyinfo
);
1389 /* Check if there is room for the menu. If not, adjust x/y so that
1390 the menu is fully visible. */
1391 gtk_widget_get_preferred_size (GTK_WIDGET (menu
), NULL
, &req
);
1392 if (data
->x
+ req
.width
> disp_width
)
1393 *x
-= data
->x
+ req
.width
- disp_width
;
1394 if (data
->y
+ req
.height
> disp_height
)
1395 *y
-= data
->y
+ req
.height
- disp_height
;
1399 popup_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1401 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1403 if (xg_crazy_callback_abort
) return;
1404 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
1408 pop_down_menu (Lisp_Object arg
)
1410 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1412 popup_activated_flag
= 0;
1414 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1419 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1421 menu_item_selection will be set to the selection. */
1423 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
, int x
, int y
,
1424 int for_click
, Time timestamp
)
1428 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
1429 struct next_popup_x_y popup_x_y
;
1430 int specpdl_count
= SPECPDL_INDEX ();
1432 if (! FRAME_X_P (f
))
1435 xg_crazy_callback_abort
= 1;
1436 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
1437 G_CALLBACK (popup_selection_callback
),
1438 G_CALLBACK (popup_deactivate_callback
),
1439 G_CALLBACK (menu_highlight_callback
));
1440 xg_crazy_callback_abort
= 0;
1444 /* Not invoked by a click. pop up at x/y. */
1445 pos_func
= menu_position_func
;
1447 /* Adjust coordinates to be root-window-relative. */
1448 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1449 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1455 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1459 for (i
= 0; i
< 5; i
++)
1460 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1464 /* Display the menu. */
1465 gtk_widget_show_all (menu
);
1467 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
,
1468 timestamp
? timestamp
: gtk_get_current_event_time ());
1470 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1472 if (gtk_widget_get_mapped (menu
))
1474 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1475 two. show_help_echo uses this to detect popup menus. */
1476 popup_activated_flag
= 1;
1477 /* Process events that apply to the menu. */
1478 popup_widget_loop (1, menu
);
1481 unbind_to (specpdl_count
, Qnil
);
1483 /* Must reset this manually because the button release event is not passed
1484 to Emacs event loop. */
1485 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1488 #else /* not USE_GTK */
1490 /* We need a unique id for each widget handled by the Lucid Widget
1493 For the main windows, and popup menus, we use this counter,
1494 which we increment each time after use. This starts from 1<<16.
1496 For menu bars, we use numbers starting at 0, counted in
1497 next_menubar_widget_id. */
1498 LWLIB_ID widget_id_tick
;
1501 popup_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1503 menu_item_selection
= (Lisp_Object
*) client_data
;
1506 /* ARG is the LWLIB ID of the dialog box, represented
1507 as a Lisp object as (HIGHPART . LOWPART). */
1510 pop_down_menu (Lisp_Object arg
)
1512 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
1513 | XINT (XCDR (arg
)));
1516 lw_destroy_all_widgets (id
);
1518 popup_activated_flag
= 0;
1523 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1525 menu_item_selection will be set to the selection. */
1527 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
,
1528 int x
, int y
, int for_click
, Time timestamp
)
1534 XButtonPressedEvent
*event
= &(dummy
.xbutton
);
1538 if (! FRAME_X_P (f
))
1542 apply_systemfont_to_menu (f
, f
->output_data
.x
->widget
);
1545 menu_id
= widget_id_tick
++;
1546 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1547 f
->output_data
.x
->widget
, 1, 0,
1548 popup_selection_callback
,
1549 popup_deactivate_callback
,
1550 menu_highlight_callback
);
1552 event
->type
= ButtonPress
;
1554 event
->send_event
= 0;
1555 event
->display
= FRAME_X_DISPLAY (f
);
1556 event
->time
= CurrentTime
;
1557 event
->root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1558 event
->window
= event
->subwindow
= event
->root
;
1562 /* Adjust coordinates to be root-window-relative. */
1563 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1564 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1571 for (i
= 0; i
< 5; i
++)
1572 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1575 /* Don't allow any geometry request from the user. */
1576 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
1577 XtSetValues (menu
, av
, ac
);
1579 /* Display the menu. */
1580 lw_popup_menu (menu
, &dummy
);
1581 popup_activated_flag
= 1;
1582 x_activate_timeout_atimer ();
1585 int fact
= 4 * sizeof (LWLIB_ID
);
1586 int specpdl_count
= SPECPDL_INDEX ();
1587 record_unwind_protect (pop_down_menu
,
1588 Fcons (make_number (menu_id
>> (fact
)),
1589 make_number (menu_id
& ~(-1 << (fact
)))));
1591 /* Process events that apply to the menu. */
1592 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
1594 unbind_to (specpdl_count
, Qnil
);
1598 #endif /* not USE_GTK */
1601 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
1602 Lisp_Object title
, const char **error_name
, Time timestamp
)
1605 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1606 widget_value
**submenu_stack
1607 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1608 Lisp_Object
*subprefix_stack
1609 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1610 int submenu_depth
= 0;
1614 if (! FRAME_X_P (f
))
1619 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1621 *error_name
= "Empty menu";
1625 /* Create a tree of widget_value objects
1626 representing the panes and their items. */
1627 wv
= xmalloc_widget_value ();
1631 wv
->button_type
= BUTTON_TYPE_NONE
;
1636 /* Loop over all panes and items, filling in the tree. */
1638 while (i
< menu_items_used
)
1640 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1642 submenu_stack
[submenu_depth
++] = save_wv
;
1648 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1651 save_wv
= submenu_stack
[--submenu_depth
];
1655 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1656 && submenu_depth
!= 0)
1657 i
+= MENU_ITEMS_PANE_LENGTH
;
1658 /* Ignore a nil in the item list.
1659 It's meaningful only for dialog boxes. */
1660 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1662 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1664 /* Create a new pane. */
1665 Lisp_Object pane_name
, prefix
;
1666 const char *pane_string
;
1668 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1669 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1671 #ifndef HAVE_MULTILINGUAL_MENU
1672 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1674 pane_name
= ENCODE_MENU_STRING (pane_name
);
1675 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1678 pane_string
= (NILP (pane_name
)
1679 ? "" : SSDATA (pane_name
));
1680 /* If there is just one top-level pane, put all its items directly
1681 under the top-level menu. */
1682 if (menu_items_n_panes
== 1)
1685 /* If the pane has a meaningful name,
1686 make the pane a top-level menu item
1687 with its items as a submenu beneath it. */
1688 if (!keymaps
&& strcmp (pane_string
, ""))
1690 wv
= xmalloc_widget_value ();
1694 first_wv
->contents
= wv
;
1695 wv
->name
= pane_string
;
1696 if (keymaps
&& !NILP (prefix
))
1700 wv
->button_type
= BUTTON_TYPE_NONE
;
1705 else if (first_pane
)
1711 i
+= MENU_ITEMS_PANE_LENGTH
;
1715 /* Create a new item within current pane. */
1716 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
1717 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1718 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1719 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1720 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1721 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1722 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1723 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1725 #ifndef HAVE_MULTILINGUAL_MENU
1726 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
1728 item_name
= ENCODE_MENU_STRING (item_name
);
1729 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1732 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1734 descrip
= ENCODE_MENU_STRING (descrip
);
1735 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1737 #endif /* not HAVE_MULTILINGUAL_MENU */
1739 wv
= xmalloc_widget_value ();
1743 save_wv
->contents
= wv
;
1744 wv
->name
= SSDATA (item_name
);
1745 if (!NILP (descrip
))
1746 wv
->key
= SSDATA (descrip
);
1748 /* If this item has a null value,
1749 make the call_data null so that it won't display a box
1750 when the mouse is on it. */
1752 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
1753 wv
->enabled
= !NILP (enable
);
1756 wv
->button_type
= BUTTON_TYPE_NONE
;
1757 else if (EQ (type
, QCtoggle
))
1758 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1759 else if (EQ (type
, QCradio
))
1760 wv
->button_type
= BUTTON_TYPE_RADIO
;
1764 wv
->selected
= !NILP (selected
);
1766 if (! STRINGP (help
))
1773 i
+= MENU_ITEMS_ITEM_LENGTH
;
1777 /* Deal with the title, if it is non-nil. */
1780 widget_value
*wv_title
= xmalloc_widget_value ();
1781 widget_value
*wv_sep1
= xmalloc_widget_value ();
1782 widget_value
*wv_sep2
= xmalloc_widget_value ();
1784 wv_sep2
->name
= "--";
1785 wv_sep2
->next
= first_wv
->contents
;
1786 wv_sep2
->help
= Qnil
;
1788 wv_sep1
->name
= "--";
1789 wv_sep1
->next
= wv_sep2
;
1790 wv_sep1
->help
= Qnil
;
1792 #ifndef HAVE_MULTILINGUAL_MENU
1793 if (STRING_MULTIBYTE (title
))
1794 title
= ENCODE_MENU_STRING (title
);
1797 wv_title
->name
= SSDATA (title
);
1798 wv_title
->enabled
= TRUE
;
1799 wv_title
->button_type
= BUTTON_TYPE_NONE
;
1800 wv_title
->help
= Qnil
;
1801 wv_title
->next
= wv_sep1
;
1802 first_wv
->contents
= wv_title
;
1805 /* No selection has been chosen yet. */
1806 menu_item_selection
= 0;
1808 /* Actually create and show the menu until popped down. */
1809 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
, timestamp
);
1811 /* Free the widget_value objects we used to specify the contents. */
1812 free_menubar_widget_value_tree (first_wv
);
1814 /* Find the selected item, and its pane, to return
1815 the proper value. */
1816 if (menu_item_selection
!= 0)
1818 Lisp_Object prefix
, entry
;
1820 prefix
= entry
= Qnil
;
1822 while (i
< menu_items_used
)
1824 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1826 subprefix_stack
[submenu_depth
++] = prefix
;
1830 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1832 prefix
= subprefix_stack
[--submenu_depth
];
1835 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1838 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1839 i
+= MENU_ITEMS_PANE_LENGTH
;
1841 /* Ignore a nil in the item list.
1842 It's meaningful only for dialog boxes. */
1843 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1848 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1849 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
1855 entry
= Fcons (entry
, Qnil
);
1857 entry
= Fcons (prefix
, entry
);
1858 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1859 if (!NILP (subprefix_stack
[j
]))
1860 entry
= Fcons (subprefix_stack
[j
], entry
);
1864 i
+= MENU_ITEMS_ITEM_LENGTH
;
1868 else if (!for_click
)
1869 /* Make "Cancel" equivalent to C-g. */
1870 Fsignal (Qquit
, Qnil
);
1877 dialog_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1879 /* Treat the pointer as an integer. There's no problem
1880 as long as pointers have enough bits to hold small integers. */
1881 if ((intptr_t) client_data
!= -1)
1882 menu_item_selection
= (Lisp_Object
*) client_data
;
1884 popup_activated_flag
= 0;
1887 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1889 menu_item_selection will be set to the selection. */
1891 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1895 if (! FRAME_X_P (f
))
1898 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
1899 G_CALLBACK (dialog_selection_callback
),
1900 G_CALLBACK (popup_deactivate_callback
),
1905 int specpdl_count
= SPECPDL_INDEX ();
1906 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1908 /* Display the menu. */
1909 gtk_widget_show_all (menu
);
1911 /* Process events that apply to the menu. */
1912 popup_widget_loop (1, menu
);
1914 unbind_to (specpdl_count
, Qnil
);
1918 #else /* not USE_GTK */
1920 dialog_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1922 /* The EMACS_INT cast avoids a warning. There's no problem
1923 as long as pointers have enough bits to hold small integers. */
1924 if ((int) (EMACS_INT
) client_data
!= -1)
1925 menu_item_selection
= (Lisp_Object
*) client_data
;
1928 lw_destroy_all_widgets (id
);
1930 popup_activated_flag
= 0;
1934 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1936 menu_item_selection will be set to the selection. */
1938 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1945 dialog_id
= widget_id_tick
++;
1947 apply_systemfont_to_dialog (f
->output_data
.x
->widget
);
1949 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1950 f
->output_data
.x
->widget
, 1, 0,
1951 dialog_selection_callback
, 0, 0);
1952 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1953 /* Display the dialog box. */
1954 lw_pop_up_all_widgets (dialog_id
);
1955 popup_activated_flag
= 1;
1956 x_activate_timeout_atimer ();
1958 /* Process events that apply to the dialog box.
1959 Also handle timers. */
1961 int count
= SPECPDL_INDEX ();
1962 int fact
= 4 * sizeof (LWLIB_ID
);
1964 /* xdialog_show_unwind is responsible for popping the dialog box down. */
1965 record_unwind_protect (pop_down_menu
,
1966 Fcons (make_number (dialog_id
>> (fact
)),
1967 make_number (dialog_id
& ~(-1 << (fact
)))));
1969 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
1972 unbind_to (count
, Qnil
);
1976 #endif /* not USE_GTK */
1978 static const char * button_names
[] = {
1979 "button1", "button2", "button3", "button4", "button5",
1980 "button6", "button7", "button8", "button9", "button10" };
1983 xdialog_show (FRAME_PTR f
,
1987 const char **error_name
)
1989 int i
, nb_buttons
=0;
1990 char dialog_name
[6];
1992 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
1994 /* Number of elements seen so far, before boundary. */
1996 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
1997 int boundary_seen
= 0;
1999 if (! FRAME_X_P (f
))
2004 if (menu_items_n_panes
> 1)
2006 *error_name
= "Multiple panes in dialog box";
2010 /* Create a tree of widget_value objects
2011 representing the text label and buttons. */
2013 Lisp_Object pane_name
, prefix
;
2014 const char *pane_string
;
2015 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2016 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2017 pane_string
= (NILP (pane_name
)
2018 ? "" : SSDATA (pane_name
));
2019 prev_wv
= xmalloc_widget_value ();
2020 prev_wv
->value
= pane_string
;
2021 if (keymaps
&& !NILP (prefix
))
2023 prev_wv
->enabled
= 1;
2024 prev_wv
->name
= "message";
2025 prev_wv
->help
= Qnil
;
2028 /* Loop over all panes and items, filling in the tree. */
2029 i
= MENU_ITEMS_PANE_LENGTH
;
2030 while (i
< menu_items_used
)
2033 /* Create a new item within current pane. */
2034 Lisp_Object item_name
, enable
, descrip
;
2035 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2036 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2038 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2040 if (NILP (item_name
))
2042 free_menubar_widget_value_tree (first_wv
);
2043 *error_name
= "Submenu in dialog items";
2046 if (EQ (item_name
, Qquote
))
2048 /* This is the boundary between left-side elts
2049 and right-side elts. Stop incrementing right_count. */
2054 if (nb_buttons
>= 9)
2056 free_menubar_widget_value_tree (first_wv
);
2057 *error_name
= "Too many dialog items";
2061 wv
= xmalloc_widget_value ();
2063 wv
->name
= (char *) button_names
[nb_buttons
];
2064 if (!NILP (descrip
))
2065 wv
->key
= SSDATA (descrip
);
2066 wv
->value
= SSDATA (item_name
);
2067 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2068 wv
->enabled
= !NILP (enable
);
2072 if (! boundary_seen
)
2076 i
+= MENU_ITEMS_ITEM_LENGTH
;
2079 /* If the boundary was not specified,
2080 by default put half on the left and half on the right. */
2081 if (! boundary_seen
)
2082 left_count
= nb_buttons
- nb_buttons
/ 2;
2084 wv
= xmalloc_widget_value ();
2085 wv
->name
= dialog_name
;
2088 /* Frame title: 'Q' = Question, 'I' = Information.
2089 Can also have 'E' = Error if, one day, we want
2090 a popup for errors. */
2092 dialog_name
[0] = 'Q';
2094 dialog_name
[0] = 'I';
2096 /* Dialog boxes use a really stupid name encoding
2097 which specifies how many buttons to use
2098 and how many buttons are on the right. */
2099 dialog_name
[1] = '0' + nb_buttons
;
2100 dialog_name
[2] = 'B';
2101 dialog_name
[3] = 'R';
2102 /* Number of buttons to put on the right. */
2103 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2105 wv
->contents
= first_wv
;
2109 /* No selection has been chosen yet. */
2110 menu_item_selection
= 0;
2112 /* Actually create and show the dialog. */
2113 create_and_show_dialog (f
, first_wv
);
2115 /* Free the widget_value objects we used to specify the contents. */
2116 free_menubar_widget_value_tree (first_wv
);
2118 /* Find the selected item, and its pane, to return
2119 the proper value. */
2120 if (menu_item_selection
!= 0)
2126 while (i
< menu_items_used
)
2130 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2133 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2134 i
+= MENU_ITEMS_PANE_LENGTH
;
2136 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2138 /* This is the boundary between left-side elts and
2145 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2146 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2150 entry
= Fcons (entry
, Qnil
);
2152 entry
= Fcons (prefix
, entry
);
2156 i
+= MENU_ITEMS_ITEM_LENGTH
;
2161 /* Make "Cancel" equivalent to C-g. */
2162 Fsignal (Qquit
, Qnil
);
2167 #else /* not USE_X_TOOLKIT && not USE_GTK */
2169 /* The frame of the last activated non-toolkit menu bar.
2170 Used to generate menu help events. */
2172 static struct frame
*menu_help_frame
;
2175 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2177 PANE is the pane number, and ITEM is the menu item number in
2178 the menu (currently not used).
2180 This cannot be done with generating a HELP_EVENT because
2181 XMenuActivate contains a loop that doesn't let Emacs process
2185 menu_help_callback (char const *help_string
, int pane
, int item
)
2187 Lisp_Object
*first_item
;
2188 Lisp_Object pane_name
;
2189 Lisp_Object menu_object
;
2191 first_item
= XVECTOR (menu_items
)->contents
;
2192 if (EQ (first_item
[0], Qt
))
2193 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2194 else if (EQ (first_item
[0], Qquote
))
2195 /* This shouldn't happen, see xmenu_show. */
2196 pane_name
= empty_unibyte_string
;
2198 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2200 /* (menu-item MENU-NAME PANE-NUMBER) */
2201 menu_object
= Fcons (Qmenu_item
,
2203 Fcons (make_number (pane
), Qnil
)));
2204 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2205 Qnil
, menu_object
, make_number (item
));
2209 pop_down_menu (Lisp_Object arg
)
2211 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
2212 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
2214 FRAME_PTR f
= p1
->pointer
;
2215 XMenu
*menu
= p2
->pointer
;
2219 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
2220 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
2222 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2224 #ifdef HAVE_X_WINDOWS
2225 /* Assume the mouse has moved out of the X window.
2226 If it has actually moved in, we will get an EnterNotify. */
2227 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2229 /* State that no mouse buttons are now held.
2230 (The oldXMenu code doesn't track this info for us.)
2231 That is not necessarily true, but the fiction leads to reasonable
2232 results, and it is a pain to ask which are actually held now. */
2233 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2235 #endif /* HAVE_X_WINDOWS */
2244 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
2245 Lisp_Object title
, const char **error_name
, Time timestamp
)
2249 int pane
, selidx
, lpane
, status
;
2250 Lisp_Object entry
, pane_prefix
;
2252 int ulx
, uly
, width
, height
;
2253 int dispwidth
, dispheight
;
2254 int i
, j
, lines
, maxlines
;
2257 unsigned int dummy_uint
;
2258 int specpdl_count
= SPECPDL_INDEX ();
2260 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
2264 if (menu_items_n_panes
== 0)
2267 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2269 *error_name
= "Empty menu";
2273 /* Figure out which root window F is on. */
2274 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2275 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2276 &dummy_uint
, &dummy_uint
);
2278 /* Make the menu on that window. */
2279 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2282 *error_name
= "Can't create menu";
2286 /* Don't GC while we prepare and show the menu,
2287 because we give the oldxmenu library pointers to the
2288 contents of strings. */
2289 inhibit_garbage_collection ();
2291 #ifdef HAVE_X_WINDOWS
2292 /* Adjust coordinates to relative to the outer (window manager) window. */
2293 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
2294 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2295 #endif /* HAVE_X_WINDOWS */
2297 /* Adjust coordinates to be root-window-relative. */
2301 /* Create all the necessary panes and their items. */
2302 maxwidth
= maxlines
= lines
= i
= 0;
2304 while (i
< menu_items_used
)
2306 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2308 /* Create a new pane. */
2309 Lisp_Object pane_name
, prefix
;
2310 const char *pane_string
;
2312 maxlines
= max (maxlines
, lines
);
2314 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2315 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2316 pane_string
= (NILP (pane_name
)
2317 ? "" : SSDATA (pane_name
));
2318 if (keymaps
&& !NILP (prefix
))
2321 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2322 if (lpane
== XM_FAILURE
)
2324 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2325 *error_name
= "Can't create pane";
2328 i
+= MENU_ITEMS_PANE_LENGTH
;
2330 /* Find the width of the widest item in this pane. */
2332 while (j
< menu_items_used
)
2335 item
= XVECTOR (menu_items
)->contents
[j
];
2343 width
= SBYTES (item
);
2344 if (width
> maxwidth
)
2347 j
+= MENU_ITEMS_ITEM_LENGTH
;
2350 /* Ignore a nil in the item list.
2351 It's meaningful only for dialog boxes. */
2352 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2356 /* Create a new item within current pane. */
2357 Lisp_Object item_name
, enable
, descrip
, help
;
2359 char const *help_string
;
2361 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2362 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2364 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2365 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2366 help_string
= STRINGP (help
) ? SSDATA (help
) : NULL
;
2368 if (!NILP (descrip
))
2370 /* if alloca is fast, use that to make the space,
2371 to reduce gc needs. */
2372 item_data
= (char *) alloca (maxwidth
+ SBYTES (descrip
) + 1);
2373 memcpy (item_data
, SSDATA (item_name
), SBYTES (item_name
));
2374 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
2376 memcpy (item_data
+ j
, SSDATA (descrip
), SBYTES (descrip
));
2377 item_data
[j
+ SBYTES (descrip
)] = 0;
2380 item_data
= SSDATA (item_name
);
2382 if (lpane
== XM_FAILURE
2383 || (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2384 menu
, lpane
, 0, item_data
,
2385 !NILP (enable
), help_string
)
2388 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2389 *error_name
= "Can't add selection to menu";
2392 i
+= MENU_ITEMS_ITEM_LENGTH
;
2397 maxlines
= max (maxlines
, lines
);
2399 /* All set and ready to fly. */
2400 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2401 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2402 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2403 x
= min (x
, dispwidth
);
2404 y
= min (y
, dispheight
);
2407 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2408 &ulx
, &uly
, &width
, &height
);
2409 if (ulx
+width
> dispwidth
)
2411 x
-= (ulx
+ width
) - dispwidth
;
2412 ulx
= dispwidth
- width
;
2414 if (uly
+height
> dispheight
)
2416 y
-= (uly
+ height
) - dispheight
;
2417 uly
= dispheight
- height
;
2419 #ifndef HAVE_X_WINDOWS
2420 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 1)
2422 /* Move the menu away of the echo area, to avoid overwriting the
2423 menu with help echo messages or vice versa. */
2424 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
2426 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2427 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2436 if (ulx
< 0) x
-= ulx
;
2437 if (uly
< 0) y
-= uly
;
2441 /* If position was not given by a mouse click, adjust so upper left
2442 corner of the menu as a whole ends up at given coordinates. This
2443 is what x-popup-menu says in its documentation. */
2445 y
+= 1.5*height
/(maxlines
+2);
2448 XMenuSetAEQ (menu
, TRUE
);
2449 XMenuSetFreeze (menu
, TRUE
);
2453 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
2456 record_unwind_protect (pop_down_menu
,
2457 Fcons (make_save_value (f
, 0),
2458 make_save_value (menu
, 0)));
2460 /* Help display under X won't work because XMenuActivate contains
2461 a loop that doesn't give Emacs a chance to process it. */
2462 menu_help_frame
= f
;
2463 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2464 x
, y
, ButtonReleaseMask
, &datap
,
2465 menu_help_callback
);
2466 entry
= pane_prefix
= Qnil
;
2472 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2475 /* Find the item number SELIDX in pane number PANE. */
2477 while (i
< menu_items_used
)
2479 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2483 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2485 i
+= MENU_ITEMS_PANE_LENGTH
;
2494 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2497 entry
= Fcons (entry
, Qnil
);
2498 if (!NILP (pane_prefix
))
2499 entry
= Fcons (pane_prefix
, entry
);
2505 i
+= MENU_ITEMS_ITEM_LENGTH
;
2511 *error_name
= "Can't activate menu";
2515 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2516 the menu was invoked with a mouse event as POSITION). */
2518 Fsignal (Qquit
, Qnil
);
2522 unbind_to (specpdl_count
, Qnil
);
2527 #endif /* not USE_X_TOOLKIT */
2529 #endif /* HAVE_MENUS */
2532 /* Detect if a dialog or menu has been posted. MSDOS has its own
2533 implementation on msdos.c. */
2536 popup_activated (void)
2538 return popup_activated_flag
;
2540 #endif /* not MSDOS */
2542 /* The following is used by delayed window autoselection. */
2544 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
2545 doc
: /* Return t if a menu or popup dialog is active. */)
2549 return (popup_activated ()) ? Qt
: Qnil
;
2552 #endif /* HAVE_MENUS */
2556 syms_of_xmenu (void)
2558 Qdebug_on_next_call
= intern_c_string ("debug-on-next-call");
2559 staticpro (&Qdebug_on_next_call
);
2561 #ifdef USE_X_TOOLKIT
2562 widget_id_tick
= (1<<16);
2563 next_menubar_widget_id
= 1;
2566 defsubr (&Smenu_or_popup_active_p
);
2568 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2569 defsubr (&Sx_menu_bar_open_internal
);
2570 Ffset (intern_c_string ("accelerate-menu"),
2571 intern_c_string (Sx_menu_bar_open_internal
.symbol_name
));
2575 defsubr (&Sx_popup_dialog
);