1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* X pop-up deck-of-cards menu facility for GNU Emacs.
22 * Written by Jon Arnold and Roman Budzianowski
23 * Mods and rewrite by Robert Krawitz
27 /* Modified by Fred Pierresteguy on December 93
28 to make the popup menus and menubar use the Xt. */
30 /* Rewritten for clarity and GC protection by rms in Feb 94. */
34 #if 0 /* Why was this included? And without syssignal.h? */
35 /* On 4.3 this loses if it comes after xterm.h. */
46 #include "termhooks.h"
48 #include "blockinput.h"
52 #include "sysselect.h"
59 /* This may include sys/types.h, and that somehow loses
60 if this is not done before the other system files. */
64 /* Load sys/types.h if not already loaded.
65 In some systems loading it twice is suicidal. */
67 #include <sys/types.h>
70 #include "dispextern.h"
73 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
74 code accepts the Emacs internal encoding. */
75 #undef HAVE_MULTILINGUAL_MENU
79 #include <X11/IntrinsicP.h>
80 #include <X11/CoreP.h>
81 #include <X11/StringDefs.h>
82 #include <X11/Shell.h>
84 #include "xsettings.h"
85 #include "../lwlib/xlwmenu.h"
87 #include <X11/Xaw3d/Paned.h>
88 #else /* !HAVE_XAW3D */
89 #include <X11/Xaw/Paned.h>
90 #endif /* HAVE_XAW3D */
91 #endif /* USE_LUCID */
92 #else /* not USE_X_TOOLKIT */
94 #include "../oldXMenu/XMenu.h"
96 #endif /* not USE_X_TOOLKIT */
97 #endif /* HAVE_X_WINDOWS */
110 Lisp_Object Qdebug_on_next_call
;
112 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
113 static Lisp_Object
xdialog_show (FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
117 static int update_frame_menubar (struct frame
*);
119 /* Flag which when set indicates a dialog or menu has been posted by
120 Xt on behalf of one of the widget sets. */
121 static int popup_activated_flag
;
123 static int next_menubar_widget_id
;
125 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
126 extern widget_value
*xmalloc_widget_value (void);
127 extern widget_value
*digest_single_submenu (int, int, int);
133 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
135 static struct frame
*
136 menubar_id_to_frame (LWLIB_ID id
)
138 Lisp_Object tail
, frame
;
141 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
147 if (!FRAME_WINDOW_P (f
))
149 if (f
->output_data
.x
->id
== id
)
157 #ifdef HAVE_X_WINDOWS
158 /* Return the mouse position in *X and *Y. The coordinates are window
159 relative for the edit window in frame F.
160 This is for Fx_popup_menu. The mouse_position_hook can not
161 be used for X, as it returns window relative coordinates
162 for the window where the mouse is in. This could be the menu bar,
163 the scroll bar or the edit window. Fx_popup_menu needs to be
164 sure it is the edit window. */
166 mouse_position_for_popup (FRAME_PTR f
, int *x
, int *y
)
168 Window root
, dummy_window
;
176 XQueryPointer (FRAME_X_DISPLAY (f
),
177 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
179 /* The root window which contains the pointer. */
182 /* Window pointer is on, not used */
185 /* The position on that root window. */
188 /* x/y in dummy_window coordinates, not used. */
191 /* Modifier keys and pointer buttons, about which
193 (unsigned int *) &dummy
);
197 /* xmenu_show expects window coordinates, not root window
198 coordinates. Translate. */
199 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
200 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
203 #endif /* HAVE_X_WINDOWS */
207 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
208 doc
: /* Pop up a dialog box and return user's selection.
209 POSITION specifies which frame to use.
210 This is normally a mouse button event or a window or frame.
211 If POSITION is t, it means to use the frame the mouse is on.
212 The dialog box appears in the middle of the specified frame.
214 CONTENTS specifies the alternatives to display in the dialog box.
215 It is a list of the form (DIALOG ITEM1 ITEM2...).
216 Each ITEM is a cons cell (STRING . VALUE).
217 The return value is VALUE from the chosen item.
219 An ITEM may also be just a string--that makes a nonselectable item.
220 An ITEM may also be nil--that means to put all preceding items
221 on the left of the dialog box and all following items on the right.
222 \(By default, approximately half appear on each side.)
224 If HEADER is non-nil, the frame title for the box is "Information",
225 otherwise it is "Question".
227 If the user gets rid of the dialog box without making a valid choice,
228 for instance using the window manager, then this produces a quit and
229 `x-popup-dialog' does not return. */)
230 (Lisp_Object position
, Lisp_Object contents
, Lisp_Object header
)
237 /* Decode the first argument: find the window or frame to use. */
238 if (EQ (position
, Qt
)
239 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
240 || EQ (XCAR (position
), Qtool_bar
))))
242 #if 0 /* Using the frame the mouse is on may not be right. */
243 /* Use the mouse's current position. */
244 FRAME_PTR new_f
= SELECTED_FRAME ();
245 Lisp_Object bar_window
;
246 enum scroll_bar_part part
;
250 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
253 XSETFRAME (window
, new_f
);
255 window
= selected_window
;
257 window
= selected_window
;
259 else if (CONSP (position
))
262 tem
= Fcar (position
);
264 window
= Fcar (Fcdr (position
));
267 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
268 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
271 else if (WINDOWP (position
) || FRAMEP (position
))
276 /* Decode where to put the menu. */
280 else if (WINDOWP (window
))
282 CHECK_LIVE_WINDOW (window
);
283 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
286 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
287 but I don't want to make one now. */
288 CHECK_WINDOW (window
);
290 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
291 error ("Can not put X dialog on this terminal");
293 /* Force a redisplay before showing the dialog. If a frame is created
294 just before showing the dialog, its contents may not have been fully
295 drawn, as this depends on timing of events from the X server. Redisplay
296 is not done when a dialog is shown. If redisplay could be done in the
297 X event loop (i.e. the X event loop does not run in a signal handler)
298 this would not be needed.
300 Do this before creating the widget value that points to Lisp
301 string contents, because Fredisplay may GC and relocate them. */
304 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
305 /* Display a menu with these alternatives
306 in the middle of frame F. */
308 Lisp_Object x
, y
, frame
, newpos
;
309 XSETFRAME (frame
, f
);
310 XSETINT (x
, x_pixel_width (f
) / 2);
311 XSETINT (y
, x_pixel_height (f
) / 2);
312 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
314 return Fx_popup_menu (newpos
,
315 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
321 Lisp_Object selection
;
322 int specpdl_count
= SPECPDL_INDEX ();
324 /* Decode the dialog items from what was specified. */
325 title
= Fcar (contents
);
326 CHECK_STRING (title
);
327 record_unwind_protect (unuse_menu_items
, Qnil
);
329 if (NILP (Fcar (Fcdr (contents
))))
330 /* No buttons specified, add an "Ok" button so users can pop down
331 the dialog. Also, the lesstif/motif version crashes if there are
333 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
335 list_of_panes (Fcons (contents
, Qnil
));
337 /* Display them in a dialog box. */
339 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
342 unbind_to (specpdl_count
, Qnil
);
343 discard_menu_items ();
345 if (error_name
) error (error_name
);
354 /* Set menu_items_inuse so no other popup menu or dialog is created. */
357 x_menu_set_in_use (int in_use
)
359 menu_items_inuse
= in_use
? Qt
: Qnil
;
360 popup_activated_flag
= in_use
;
362 if (popup_activated_flag
)
363 x_activate_timeout_atimer ();
367 /* Wait for an X event to arrive or for a timer to expire. */
370 x_menu_wait_for_event (void *data
)
372 /* Another way to do this is to register a timer callback, that can be
373 done in GTK and Xt. But we have to do it like this when using only X
374 anyway, and with callbacks we would have three variants for timer handling
375 instead of the small ifdefs below. */
379 ! XtAppPending (Xt_app_con
)
380 #elif defined USE_GTK
381 ! gtk_events_pending ()
383 ! XPending ((Display
*) data
)
387 EMACS_TIME next_time
= timer_check (1), *ntp
;
388 long secs
= EMACS_SECS (next_time
);
389 long usecs
= EMACS_USECS (next_time
);
390 SELECT_TYPE read_fds
;
391 struct x_display_info
*dpyinfo
;
395 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
397 int fd
= ConnectionNumber (dpyinfo
->display
);
398 FD_SET (fd
, &read_fds
);
400 XFlush (dpyinfo
->display
);
403 if (secs
< 0 && usecs
< 0)
408 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, ntp
);
414 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
418 /* Loop in Xt until the menu pulldown or dialog popup has been
419 popped down (deactivated). This is used for x-popup-menu
420 and x-popup-dialog; it is not used for the menu bar.
422 NOTE: All calls to popup_get_selection should be protected
423 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
426 popup_get_selection (XEvent
*initial_event
, struct x_display_info
*dpyinfo
, LWLIB_ID id
, int do_timers
)
430 while (popup_activated_flag
)
434 event
= *initial_event
;
439 if (do_timers
) x_menu_wait_for_event (0);
440 XtAppNextEvent (Xt_app_con
, &event
);
443 /* Make sure we don't consider buttons grabbed after menu goes.
444 And make sure to deactivate for any ButtonRelease,
445 even if XtDispatchEvent doesn't do that. */
446 if (event
.type
== ButtonRelease
447 && dpyinfo
->display
== event
.xbutton
.display
)
449 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
450 #ifdef USE_MOTIF /* Pretending that the event came from a
451 Btn1Down seems the only way to convince Motif to
452 activate its callbacks; setting the XmNmenuPost
453 isn't working. --marcus@sysc.pdx.edu. */
454 event
.xbutton
.button
= 1;
455 /* Motif only pops down menus when no Ctrl, Alt or Mod
456 key is pressed and the button is released. So reset key state
457 so Motif thinks this is the case. */
458 event
.xbutton
.state
= 0;
461 /* Pop down on C-g and Escape. */
462 else if (event
.type
== KeyPress
463 && dpyinfo
->display
== event
.xbutton
.display
)
465 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
467 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
468 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
469 popup_activated_flag
= 0;
472 x_dispatch_event (&event
, event
.xany
.display
);
476 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
477 doc
: /* Start key navigation of the menu bar in FRAME.
478 This initially opens the first menu bar item and you can then navigate with the
479 arrow keys, select a menu entry with the return key or cancel with the
480 escape key. If FRAME has no menu bar this function does nothing.
482 If FRAME is nil or not given, use the selected frame. */)
486 FRAME_PTR f
= check_x_frame (frame
);
490 if (FRAME_EXTERNAL_MENU_BAR (f
))
491 set_frame_menubar (f
, 0, 1);
493 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
499 x_catch_errors (FRAME_X_DISPLAY (f
));
500 memset (&ev
, 0, sizeof ev
);
501 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
502 ev
.xbutton
.window
= XtWindow (menubar
);
503 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
504 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
505 ev
.xbutton
.button
= Button1
;
506 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
507 ev
.xbutton
.same_screen
= True
;
514 XtSetArg (al
[0], XtNchildren
, &list
);
515 XtSetArg (al
[1], XtNnumChildren
, &nr
);
516 XtGetValues (menubar
, al
, 2);
517 ev
.xbutton
.window
= XtWindow (list
[0]);
521 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
522 /* From-window, to-window. */
523 ev
.xbutton
.window
, ev
.xbutton
.root
,
525 /* From-position, to-position. */
526 ev
.xbutton
.x
, ev
.xbutton
.y
,
527 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
531 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
536 ev
.type
= ButtonPress
;
537 ev
.xbutton
.state
= 0;
539 XtDispatchEvent (&ev
);
540 ev
.xbutton
.type
= ButtonRelease
;
541 ev
.xbutton
.state
= Button1Mask
;
542 XtDispatchEvent (&ev
);
550 #endif /* USE_X_TOOLKIT */
554 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
555 doc
: /* Start key navigation of the menu bar in FRAME.
556 This initially opens the first menu bar item and you can then navigate with the
557 arrow keys, select a menu entry with the return key or cancel with the
558 escape key. If FRAME has no menu bar this function does nothing.
560 If FRAME is nil or not given, use the selected frame. */)
566 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
570 f
= check_x_frame (frame
);
572 if (FRAME_EXTERNAL_MENU_BAR (f
))
573 set_frame_menubar (f
, 0, 1);
575 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
578 /* Activate the first menu. */
579 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
583 g_signal_emit_by_name (children
->data
, "activate_item");
584 popup_activated_flag
= 1;
585 g_list_free (children
);
593 /* Loop util popup_activated_flag is set to zero in a callback.
594 Used for popup menus and dialogs. */
597 popup_widget_loop (int do_timers
, GtkWidget
*widget
)
599 ++popup_activated_flag
;
601 /* Process events in the Gtk event loop until done. */
602 while (popup_activated_flag
)
604 if (do_timers
) x_menu_wait_for_event (0);
605 gtk_main_iteration ();
610 /* Activate the menu bar of frame F.
611 This is called from keyboard.c when it gets the
612 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
614 To activate the menu bar, we use the X button-press event
615 that was saved in saved_menu_event.
616 That makes the toolkit do its thing.
618 But first we recompute the menu bar contents (the whole tree).
620 The reason for saving the button event until here, instead of
621 passing it to the toolkit right away, is that we can safely
622 execute Lisp code. */
625 x_activate_menubar (FRAME_PTR f
)
630 if (!f
->output_data
.x
->saved_menu_event
->type
)
634 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
635 f
->output_data
.x
->saved_menu_event
->xany
.window
))
639 set_frame_menubar (f
, 0, 1);
641 popup_activated_flag
= 1;
643 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
644 f
->output_data
.x
->saved_menu_event
);
646 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
650 /* Ignore this if we get it a second time. */
651 f
->output_data
.x
->saved_menu_event
->type
= 0;
654 /* This callback is invoked when the user selects a menubar cascade
655 pushbutton, but before the pulldown menu is posted. */
659 popup_activate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
661 popup_activated_flag
= 1;
663 x_activate_timeout_atimer ();
668 /* This callback is invoked when a dialog or menu is finished being
669 used and has been unposted. */
673 popup_deactivate_callback (GtkWidget
*widget
, gpointer client_data
)
675 popup_activated_flag
= 0;
679 popup_deactivate_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
681 popup_activated_flag
= 0;
686 /* Function that finds the frame for WIDGET and shows the HELP text
688 F is the frame if known, or NULL if not known. */
690 show_help_event (FRAME_PTR f
, xt_or_gtk_widget widget
, Lisp_Object help
)
696 XSETFRAME (frame
, f
);
697 kbd_buffer_store_help_event (frame
, help
);
701 #if 0 /* This code doesn't do anything useful. ++kfs */
702 /* WIDGET is the popup menu. It's parent is the frame's
703 widget. See which frame that is. */
704 xt_or_gtk_widget frame_widget
= XtParent (widget
);
707 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
711 && (f
= XFRAME (frame
),
712 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
716 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
720 /* Callback called when menu items are highlighted/unhighlighted
721 while moving the mouse over them. WIDGET is the menu bar or menu
722 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
723 the data structure for the menu item, or null in case of
728 menu_highlight_callback (GtkWidget
*widget
, gpointer call_data
)
730 xg_menu_item_cb_data
*cb_data
;
733 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
735 if (! cb_data
) return;
737 help
= call_data
? cb_data
->help
: Qnil
;
739 /* If popup_activated_flag is greater than 1 we are in a popup menu.
740 Don't show help for them, they won't appear before the
741 popup is popped down. */
742 if (popup_activated_flag
<= 1)
743 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
747 menu_highlight_callback (Widget widget
, LWLIB_ID id
, void *call_data
)
752 widget_value
*wv
= (widget_value
*) call_data
;
754 help
= wv
? wv
->help
: Qnil
;
756 /* Determine the frame for the help event. */
757 f
= menubar_id_to_frame (id
);
759 show_help_event (f
, widget
, help
);
764 /* Gtk calls callbacks just because we tell it what item should be
765 selected in a radio group. If this variable is set to a non-zero
766 value, we are creating menus and don't want callbacks right now.
768 static int xg_crazy_callback_abort
;
770 /* This callback is called from the menu bar pulldown menu
771 when the user makes a selection.
772 Figure out what the user chose
773 and put the appropriate events into the keyboard buffer. */
775 menubar_selection_callback (GtkWidget
*widget
, gpointer client_data
)
777 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
779 if (xg_crazy_callback_abort
)
782 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
785 /* For a group of radio buttons, GTK calls the selection callback first
786 for the item that was active before the selection and then for the one that
787 is active after the selection. For C-h k this means we get the help on
788 the deselected item and then the selected item is executed. Prevent that
789 by ignoring the non-active item. */
790 if (GTK_IS_RADIO_MENU_ITEM (widget
)
791 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
794 /* When a menu is popped down, X generates a focus event (i.e. focus
795 goes back to the frame below the menu). Since GTK buffers events,
796 we force it out here before the menu selection event. Otherwise
797 sit-for will exit at once if the focus event follows the menu selection
801 while (gtk_events_pending ())
802 gtk_main_iteration ();
805 find_and_call_menu_selection (cb_data
->cl_data
->f
,
806 cb_data
->cl_data
->menu_bar_items_used
,
807 cb_data
->cl_data
->menu_bar_vector
,
811 #else /* not USE_GTK */
813 /* This callback is called from the menu bar pulldown menu
814 when the user makes a selection.
815 Figure out what the user chose
816 and put the appropriate events into the keyboard buffer. */
818 menubar_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
822 f
= menubar_id_to_frame (id
);
825 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
826 f
->menu_bar_vector
, client_data
);
828 #endif /* not USE_GTK */
830 /* Recompute all the widgets of frame F, when the menu bar has been
831 changed. Value is non-zero if widgets were updated. */
834 update_frame_menubar (FRAME_PTR f
)
837 return xg_update_frame_menubar (f
);
845 x
= f
->output_data
.x
;
847 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
851 /* Save the size of the frame because the pane widget doesn't accept
852 to resize itself. So force it. */
853 columns
= FRAME_COLS (f
);
854 rows
= FRAME_LINES (f
);
856 /* Do the voodoo which means "I'm changing lots of things, don't try
857 to refigure sizes until I'm done." */
858 lw_refigure_widget (x
->column_widget
, False
);
860 /* The order in which children are managed is the top to bottom
861 order in which they are displayed in the paned window. First,
862 remove the text-area widget. */
863 XtUnmanageChild (x
->edit_widget
);
865 /* Remove the menubar that is there now, and put up the menubar that
867 XtManageChild (x
->menubar_widget
);
868 XtMapWidget (x
->menubar_widget
);
869 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
871 /* Re-manage the text-area widget, and then thrash the sizes. */
872 XtManageChild (x
->edit_widget
);
873 lw_refigure_widget (x
->column_widget
, True
);
875 /* Force the pane widget to resize itself with the right values. */
876 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
884 apply_systemfont_to_dialog (Widget w
)
886 const char *fn
= xsettings_get_system_normal_font ();
889 XrmDatabase db
= XtDatabase (XtDisplay (w
));
891 XrmPutStringResource (&db
, "*dialog.faceName", fn
);
896 apply_systemfont_to_menu (Widget w
)
898 const char *fn
= xsettings_get_system_normal_font ();
903 if (XtIsShell (w
)) /* popup menu */
905 Widget
*childs
= NULL
;
907 XtVaGetValues (w
, XtNchildren
, &childs
, NULL
);
908 if (*childs
) w
= *childs
;
911 /* Only use system font if the default is used for the menu. */
912 XtVaGetValues (w
, XtNdefaultFace
, &defflt
, NULL
);
914 XtVaSetValues (w
, XtNfaceName
, fn
, NULL
);
918 /* Set the contents of the menubar widgets of frame F.
919 The argument FIRST_TIME is currently ignored;
920 it is set the first time this is called, from initialize_frame_menubar. */
923 set_frame_menubar (FRAME_PTR f
, int first_time
, int deep_p
)
925 xt_or_gtk_widget menubar_widget
;
930 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
932 int *submenu_start
, *submenu_end
;
933 int *submenu_top_level_items
, *submenu_n_panes
;
938 menubar_widget
= f
->output_data
.x
->menubar_widget
;
940 XSETFRAME (Vmenu_updating_frame
, f
);
943 if (f
->output_data
.x
->id
== 0)
944 f
->output_data
.x
->id
= next_menubar_widget_id
++;
945 id
= f
->output_data
.x
->id
;
948 if (! menubar_widget
)
950 /* Make the first call for any given frame always go deep. */
951 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
954 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
955 f
->output_data
.x
->saved_menu_event
->type
= 0;
959 /* If we have detached menus, we must update deep so detached menus
960 also gets updated. */
961 deep_p
= deep_p
|| xg_have_tear_offs ();
966 /* Make a widget-value tree representing the entire menu trees. */
968 struct buffer
*prev
= current_buffer
;
970 int specpdl_count
= SPECPDL_INDEX ();
971 int previous_menu_items_used
= f
->menu_bar_items_used
;
972 Lisp_Object
*previous_items
973 = (Lisp_Object
*) alloca (previous_menu_items_used
974 * sizeof (Lisp_Object
));
976 /* If we are making a new widget, its contents are empty,
977 do always reinitialize them. */
978 if (! menubar_widget
)
979 previous_menu_items_used
= 0;
981 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
982 specbind (Qinhibit_quit
, Qt
);
983 /* Don't let the debugger step into this code
984 because it is not reentrant. */
985 specbind (Qdebug_on_next_call
, Qnil
);
987 record_unwind_save_match_data ();
988 if (NILP (Voverriding_local_map_menu_flag
))
990 specbind (Qoverriding_terminal_local_map
, Qnil
);
991 specbind (Qoverriding_local_map
, Qnil
);
994 set_buffer_internal_1 (XBUFFER (buffer
));
996 /* Run the Lucid hook. */
997 safe_run_hooks (Qactivate_menubar_hook
);
999 /* If it has changed current-menubar from previous value,
1000 really recompute the menubar from the value. */
1001 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1002 call0 (Qrecompute_lucid_menubar
);
1003 safe_run_hooks (Qmenu_bar_update_hook
);
1004 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1006 items
= FRAME_MENU_BAR_ITEMS (f
);
1008 /* Save the frame's previous menu bar contents data. */
1009 if (previous_menu_items_used
)
1010 memcpy (previous_items
, XVECTOR (f
->menu_bar_vector
)->contents
,
1011 previous_menu_items_used
* sizeof (Lisp_Object
));
1013 /* Fill in menu_items with the current menu bar contents.
1014 This can evaluate Lisp code. */
1017 menu_items
= f
->menu_bar_vector
;
1018 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1019 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1020 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1021 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1022 submenu_top_level_items
1023 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1025 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1027 Lisp_Object key
, string
, maps
;
1031 key
= XVECTOR (items
)->contents
[i
];
1032 string
= XVECTOR (items
)->contents
[i
+ 1];
1033 maps
= XVECTOR (items
)->contents
[i
+ 2];
1037 submenu_start
[i
] = menu_items_used
;
1039 menu_items_n_panes
= 0;
1040 submenu_top_level_items
[i
]
1041 = parse_single_submenu (key
, string
, maps
);
1042 submenu_n_panes
[i
] = menu_items_n_panes
;
1044 submenu_end
[i
] = menu_items_used
;
1047 finish_menu_items ();
1049 /* Convert menu_items into widget_value trees
1050 to display the menu. This cannot evaluate Lisp code. */
1052 wv
= xmalloc_widget_value ();
1053 wv
->name
= "menubar";
1056 wv
->button_type
= BUTTON_TYPE_NONE
;
1060 for (i
= 0; i
< last_i
; i
+= 4)
1062 menu_items_n_panes
= submenu_n_panes
[i
];
1063 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1064 submenu_top_level_items
[i
]);
1068 first_wv
->contents
= wv
;
1069 /* Don't set wv->name here; GC during the loop might relocate it. */
1071 wv
->button_type
= BUTTON_TYPE_NONE
;
1075 set_buffer_internal_1 (prev
);
1077 /* If there has been no change in the Lisp-level contents
1078 of the menu bar, skip redisplaying it. Just exit. */
1080 /* Compare the new menu items with the ones computed last time. */
1081 for (i
= 0; i
< previous_menu_items_used
; i
++)
1082 if (menu_items_used
== i
1083 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1085 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1087 /* The menu items have not changed. Don't bother updating
1088 the menus in any form, since it would be a no-op. */
1089 free_menubar_widget_value_tree (first_wv
);
1090 discard_menu_items ();
1091 unbind_to (specpdl_count
, Qnil
);
1095 /* The menu items are different, so store them in the frame. */
1096 f
->menu_bar_vector
= menu_items
;
1097 f
->menu_bar_items_used
= menu_items_used
;
1099 /* This undoes save_menu_items. */
1100 unbind_to (specpdl_count
, Qnil
);
1102 /* Now GC cannot happen during the lifetime of the widget_value,
1103 so it's safe to store data from a Lisp_String. */
1104 wv
= first_wv
->contents
;
1105 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1108 string
= XVECTOR (items
)->contents
[i
+ 1];
1111 wv
->name
= (char *) SDATA (string
);
1112 update_submenu_strings (wv
->contents
);
1119 /* Make a widget-value tree containing
1120 just the top level menu bar strings. */
1122 wv
= xmalloc_widget_value ();
1123 wv
->name
= "menubar";
1126 wv
->button_type
= BUTTON_TYPE_NONE
;
1130 items
= FRAME_MENU_BAR_ITEMS (f
);
1131 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1135 string
= XVECTOR (items
)->contents
[i
+ 1];
1139 wv
= xmalloc_widget_value ();
1140 wv
->name
= (char *) SDATA (string
);
1143 wv
->button_type
= BUTTON_TYPE_NONE
;
1145 /* This prevents lwlib from assuming this
1146 menu item is really supposed to be empty. */
1147 /* The EMACS_INT cast avoids a warning.
1148 This value just has to be different from small integers. */
1149 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1154 first_wv
->contents
= wv
;
1158 /* Forget what we thought we knew about what is in the
1159 detailed contents of the menu bar menus.
1160 Changing the top level always destroys the contents. */
1161 f
->menu_bar_items_used
= 0;
1164 /* Create or update the menu bar widget. */
1169 xg_crazy_callback_abort
= 1;
1172 /* The fourth arg is DEEP_P, which says to consider the entire
1173 menu trees we supply, rather than just the menu bar item names. */
1174 xg_modify_menubar_widgets (menubar_widget
,
1178 G_CALLBACK (menubar_selection_callback
),
1179 G_CALLBACK (popup_deactivate_callback
),
1180 G_CALLBACK (menu_highlight_callback
));
1184 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
1187 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
1188 G_CALLBACK (menubar_selection_callback
),
1189 G_CALLBACK (popup_deactivate_callback
),
1190 G_CALLBACK (menu_highlight_callback
));
1192 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1196 #else /* not USE_GTK */
1199 /* Disable resizing (done for Motif!) */
1200 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1202 /* The third arg is DEEP_P, which says to consider the entire
1203 menu trees we supply, rather than just the menu bar item names. */
1204 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1206 /* Re-enable the edit widget to resize. */
1207 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1211 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
1212 XtTranslations override
= XtParseTranslationTable (menuOverride
);
1214 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1215 f
->output_data
.x
->column_widget
,
1217 popup_activate_callback
,
1218 menubar_selection_callback
,
1219 popup_deactivate_callback
,
1220 menu_highlight_callback
);
1221 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1223 /* Make menu pop down on C-g. */
1224 XtOverrideTranslations (menubar_widget
, override
);
1226 apply_systemfont_to_menu (menubar_widget
);
1232 if (f
->output_data
.x
->menubar_widget
)
1233 XtRealizeWidget (f
->output_data
.x
->menubar_widget
);
1236 = (f
->output_data
.x
->menubar_widget
1237 ? (f
->output_data
.x
->menubar_widget
->core
.height
1238 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1241 #if 1 /* Experimentally, we now get the right results
1242 for -geometry -0-0 without this. 24 Aug 96, rms.
1243 Maybe so, but the menu bar size is missing the pixels so the
1244 WM size hints are off by these pixels. Jan D, oct 2009. */
1246 if (FRAME_EXTERNAL_MENU_BAR (f
))
1249 XtVaGetValues (f
->output_data
.x
->column_widget
,
1250 XtNinternalBorderWidth
, &ibw
, NULL
);
1251 menubar_size
+= ibw
;
1253 #endif /* USE_LUCID */
1256 f
->output_data
.x
->menubar_height
= menubar_size
;
1258 #endif /* not USE_GTK */
1260 free_menubar_widget_value_tree (first_wv
);
1261 update_frame_menubar (f
);
1264 xg_crazy_callback_abort
= 0;
1270 /* Called from Fx_create_frame to create the initial menubar of a frame
1271 before it is mapped, so that the window is mapped with the menubar already
1272 there instead of us tacking it on later and thrashing the window after it
1276 initialize_frame_menubar (FRAME_PTR f
)
1278 /* This function is called before the first chance to redisplay
1279 the frame. It has to be, so the frame will have the right size. */
1280 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1281 set_frame_menubar (f
, 1, 1);
1285 /* Get rid of the menu bar of frame F, and free its storage.
1286 This is used when deleting a frame, and when turning off the menu bar.
1287 For GTK this function is in gtkutil.c. */
1291 free_frame_menubar (FRAME_PTR f
)
1293 Widget menubar_widget
;
1295 if (! FRAME_X_P (f
))
1298 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1300 f
->output_data
.x
->menubar_height
= 0;
1305 /* Removing the menu bar magically changes the shell widget's x
1306 and y position of (0, 0) which, when the menu bar is turned
1307 on again, leads to pull-down menuss appearing in strange
1308 positions near the upper-left corner of the display. This
1309 happens only with some window managers like twm and ctwm,
1310 but not with other like Motif's mwm or kwm, because the
1311 latter generate ConfigureNotify events when the menu bar
1312 is switched off, which fixes the shell position. */
1313 Position x0
, y0
, x1
, y1
;
1319 if (f
->output_data
.x
->widget
)
1320 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1323 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1324 f
->output_data
.x
->menubar_widget
= NULL
;
1326 if (f
->output_data
.x
->widget
)
1329 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1330 if (x1
== 0 && y1
== 0)
1331 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1333 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1338 #endif /* not USE_GTK */
1340 #endif /* USE_X_TOOLKIT || USE_GTK */
1342 /* xmenu_show actually displays a menu using the panes and items in menu_items
1343 and returns the value selected from it.
1344 There are two versions of xmenu_show, one for Xt and one for Xlib.
1345 Both assume input is blocked by the caller. */
1347 /* F is the frame the menu is for.
1348 X and Y are the frame-relative specified position,
1349 relative to the inside upper left corner of the frame F.
1350 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1351 KEYMAPS is 1 if this menu was specified with keymaps;
1352 in that case, we return a list containing the chosen item's value
1353 and perhaps also the pane's prefix.
1354 TITLE is the specified menu title.
1355 ERROR is a place to store an error message string in case of failure.
1356 (We return nil on failure, but the value doesn't actually matter.) */
1358 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1360 /* The item selected in the popup menu. */
1361 static Lisp_Object
*volatile menu_item_selection
;
1365 /* Used when position a popup menu. See menu_position_func and
1366 create_and_show_popup_menu below. */
1367 struct next_popup_x_y
1374 /* The menu position function to use if we are not putting a popup
1375 menu where the pointer is.
1376 MENU is the menu to pop up.
1377 X and Y shall on exit contain x/y where the menu shall pop up.
1378 PUSH_IN is not documented in the GTK manual.
1379 USER_DATA is any data passed in when calling gtk_menu_popup.
1380 Here it points to a struct next_popup_x_y where the coordinates
1381 to store in *X and *Y are as well as the frame for the popup.
1383 Here only X and Y are used. */
1385 menu_position_func (GtkMenu
*menu
, gint
*x
, gint
*y
, gboolean
*push_in
, gpointer user_data
)
1387 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
1389 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (data
->f
);
1390 int disp_width
= x_display_pixel_width (dpyinfo
);
1391 int disp_height
= x_display_pixel_height (dpyinfo
);
1396 /* Check if there is room for the menu. If not, adjust x/y so that
1397 the menu is fully visible. */
1398 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
1399 if (data
->x
+ req
.width
> disp_width
)
1400 *x
-= data
->x
+ req
.width
- disp_width
;
1401 if (data
->y
+ req
.height
> disp_height
)
1402 *y
-= data
->y
+ req
.height
- disp_height
;
1406 popup_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1408 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1410 if (xg_crazy_callback_abort
) return;
1411 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
1415 pop_down_menu (Lisp_Object arg
)
1417 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1419 popup_activated_flag
= 0;
1421 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1426 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1428 menu_item_selection will be set to the selection. */
1430 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
, int x
, int y
, int for_click
, EMACS_UINT timestamp
)
1434 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
1435 struct next_popup_x_y popup_x_y
;
1436 int specpdl_count
= SPECPDL_INDEX ();
1438 if (! FRAME_X_P (f
))
1441 xg_crazy_callback_abort
= 1;
1442 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
1443 G_CALLBACK (popup_selection_callback
),
1444 G_CALLBACK (popup_deactivate_callback
),
1445 G_CALLBACK (menu_highlight_callback
));
1446 xg_crazy_callback_abort
= 0;
1450 /* Not invoked by a click. pop up at x/y. */
1451 pos_func
= menu_position_func
;
1453 /* Adjust coordinates to be root-window-relative. */
1454 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1455 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1461 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1465 for (i
= 0; i
< 5; i
++)
1466 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1470 /* Display the menu. */
1471 gtk_widget_show_all (menu
);
1473 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
,
1474 timestamp
> 0 ? timestamp
: gtk_get_current_event_time());
1476 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1478 if (gtk_widget_get_mapped (menu
))
1480 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1481 two. show_help_echo uses this to detect popup menus. */
1482 popup_activated_flag
= 1;
1483 /* Process events that apply to the menu. */
1484 popup_widget_loop (1, menu
);
1487 unbind_to (specpdl_count
, Qnil
);
1489 /* Must reset this manually because the button release event is not passed
1490 to Emacs event loop. */
1491 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1494 #else /* not USE_GTK */
1496 /* We need a unique id for each widget handled by the Lucid Widget
1499 For the main windows, and popup menus, we use this counter,
1500 which we increment each time after use. This starts from 1<<16.
1502 For menu bars, we use numbers starting at 0, counted in
1503 next_menubar_widget_id. */
1504 LWLIB_ID widget_id_tick
;
1507 popup_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1509 menu_item_selection
= (Lisp_Object
*) client_data
;
1512 /* ARG is the LWLIB ID of the dialog box, represented
1513 as a Lisp object as (HIGHPART . LOWPART). */
1516 pop_down_menu (Lisp_Object arg
)
1518 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
1519 | XINT (XCDR (arg
)));
1522 lw_destroy_all_widgets (id
);
1524 popup_activated_flag
= 0;
1529 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1531 menu_item_selection will be set to the selection. */
1533 create_and_show_popup_menu (FRAME_PTR f
, widget_value
*first_wv
,
1534 int x
, int y
, int for_click
, EMACS_UINT timestamp
)
1539 XButtonPressedEvent dummy
;
1543 if (! FRAME_X_P (f
))
1546 menu_id
= widget_id_tick
++;
1547 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1548 f
->output_data
.x
->widget
, 1, 0,
1549 popup_selection_callback
,
1550 popup_deactivate_callback
,
1551 menu_highlight_callback
);
1554 apply_systemfont_to_menu (menu
);
1557 dummy
.type
= ButtonPress
;
1559 dummy
.send_event
= 0;
1560 dummy
.display
= FRAME_X_DISPLAY (f
);
1561 dummy
.time
= CurrentTime
;
1562 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1563 dummy
.window
= dummy
.root
;
1564 dummy
.subwindow
= dummy
.root
;
1568 /* Adjust coordinates to be root-window-relative. */
1569 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1570 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1577 for (i
= 0; i
< 5; i
++)
1578 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1581 /* Don't allow any geometry request from the user. */
1582 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
1583 XtSetValues (menu
, av
, ac
);
1585 /* Display the menu. */
1586 lw_popup_menu (menu
, (XEvent
*) &dummy
);
1587 popup_activated_flag
= 1;
1588 x_activate_timeout_atimer ();
1591 int fact
= 4 * sizeof (LWLIB_ID
);
1592 int specpdl_count
= SPECPDL_INDEX ();
1593 record_unwind_protect (pop_down_menu
,
1594 Fcons (make_number (menu_id
>> (fact
)),
1595 make_number (menu_id
& ~(-1 << (fact
)))));
1597 /* Process events that apply to the menu. */
1598 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
1600 unbind_to (specpdl_count
, Qnil
);
1604 #endif /* not USE_GTK */
1607 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
1608 Lisp_Object title
, char **error
, EMACS_UINT timestamp
)
1611 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1612 widget_value
**submenu_stack
1613 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1614 Lisp_Object
*subprefix_stack
1615 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1616 int submenu_depth
= 0;
1620 if (! FRAME_X_P (f
))
1625 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1627 *error
= "Empty menu";
1631 /* Create a tree of widget_value objects
1632 representing the panes and their items. */
1633 wv
= xmalloc_widget_value ();
1637 wv
->button_type
= BUTTON_TYPE_NONE
;
1642 /* Loop over all panes and items, filling in the tree. */
1644 while (i
< menu_items_used
)
1646 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1648 submenu_stack
[submenu_depth
++] = save_wv
;
1654 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1657 save_wv
= submenu_stack
[--submenu_depth
];
1661 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1662 && submenu_depth
!= 0)
1663 i
+= MENU_ITEMS_PANE_LENGTH
;
1664 /* Ignore a nil in the item list.
1665 It's meaningful only for dialog boxes. */
1666 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1668 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1670 /* Create a new pane. */
1671 Lisp_Object pane_name
, prefix
;
1674 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
1675 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
1677 #ifndef HAVE_MULTILINGUAL_MENU
1678 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1680 pane_name
= ENCODE_MENU_STRING (pane_name
);
1681 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
1684 pane_string
= (NILP (pane_name
)
1685 ? "" : (char *) SDATA (pane_name
));
1686 /* If there is just one top-level pane, put all its items directly
1687 under the top-level menu. */
1688 if (menu_items_n_panes
== 1)
1691 /* If the pane has a meaningful name,
1692 make the pane a top-level menu item
1693 with its items as a submenu beneath it. */
1694 if (!keymaps
&& strcmp (pane_string
, ""))
1696 wv
= xmalloc_widget_value ();
1700 first_wv
->contents
= wv
;
1701 wv
->name
= pane_string
;
1702 if (keymaps
&& !NILP (prefix
))
1706 wv
->button_type
= BUTTON_TYPE_NONE
;
1711 else if (first_pane
)
1717 i
+= MENU_ITEMS_PANE_LENGTH
;
1721 /* Create a new item within current pane. */
1722 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
1723 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
1724 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
1725 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
1726 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
1727 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
1728 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
1729 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
1731 #ifndef HAVE_MULTILINGUAL_MENU
1732 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
1734 item_name
= ENCODE_MENU_STRING (item_name
);
1735 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
1738 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1740 descrip
= ENCODE_MENU_STRING (descrip
);
1741 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
1743 #endif /* not HAVE_MULTILINGUAL_MENU */
1745 wv
= xmalloc_widget_value ();
1749 save_wv
->contents
= wv
;
1750 wv
->name
= (char *) SDATA (item_name
);
1751 if (!NILP (descrip
))
1752 wv
->key
= (char *) SDATA (descrip
);
1754 /* If this item has a null value,
1755 make the call_data null so that it won't display a box
1756 when the mouse is on it. */
1758 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
1759 wv
->enabled
= !NILP (enable
);
1762 wv
->button_type
= BUTTON_TYPE_NONE
;
1763 else if (EQ (type
, QCtoggle
))
1764 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1765 else if (EQ (type
, QCradio
))
1766 wv
->button_type
= BUTTON_TYPE_RADIO
;
1770 wv
->selected
= !NILP (selected
);
1772 if (! STRINGP (help
))
1779 i
+= MENU_ITEMS_ITEM_LENGTH
;
1783 /* Deal with the title, if it is non-nil. */
1786 widget_value
*wv_title
= xmalloc_widget_value ();
1787 widget_value
*wv_sep1
= xmalloc_widget_value ();
1788 widget_value
*wv_sep2
= xmalloc_widget_value ();
1790 wv_sep2
->name
= "--";
1791 wv_sep2
->next
= first_wv
->contents
;
1792 wv_sep2
->help
= Qnil
;
1794 wv_sep1
->name
= "--";
1795 wv_sep1
->next
= wv_sep2
;
1796 wv_sep1
->help
= Qnil
;
1798 #ifndef HAVE_MULTILINGUAL_MENU
1799 if (STRING_MULTIBYTE (title
))
1800 title
= ENCODE_MENU_STRING (title
);
1803 wv_title
->name
= (char *) SDATA (title
);
1804 wv_title
->enabled
= TRUE
;
1805 wv_title
->button_type
= BUTTON_TYPE_NONE
;
1806 wv_title
->help
= Qnil
;
1807 wv_title
->next
= wv_sep1
;
1808 first_wv
->contents
= wv_title
;
1811 /* No selection has been chosen yet. */
1812 menu_item_selection
= 0;
1814 /* Actually create and show the menu until popped down. */
1815 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
, timestamp
);
1817 /* Free the widget_value objects we used to specify the contents. */
1818 free_menubar_widget_value_tree (first_wv
);
1820 /* Find the selected item, and its pane, to return
1821 the proper value. */
1822 if (menu_item_selection
!= 0)
1824 Lisp_Object prefix
, entry
;
1826 prefix
= entry
= Qnil
;
1828 while (i
< menu_items_used
)
1830 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1832 subprefix_stack
[submenu_depth
++] = prefix
;
1836 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1838 prefix
= subprefix_stack
[--submenu_depth
];
1841 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1844 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1845 i
+= MENU_ITEMS_PANE_LENGTH
;
1847 /* Ignore a nil in the item list.
1848 It's meaningful only for dialog boxes. */
1849 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1854 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1855 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
1861 entry
= Fcons (entry
, Qnil
);
1863 entry
= Fcons (prefix
, entry
);
1864 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1865 if (!NILP (subprefix_stack
[j
]))
1866 entry
= Fcons (subprefix_stack
[j
], entry
);
1870 i
+= MENU_ITEMS_ITEM_LENGTH
;
1874 else if (!for_click
)
1875 /* Make "Cancel" equivalent to C-g. */
1876 Fsignal (Qquit
, Qnil
);
1883 dialog_selection_callback (GtkWidget
*widget
, gpointer client_data
)
1885 /* The EMACS_INT cast avoids a warning. There's no problem
1886 as long as pointers have enough bits to hold small integers. */
1887 if ((int) (EMACS_INT
) client_data
!= -1)
1888 menu_item_selection
= (Lisp_Object
*) client_data
;
1890 popup_activated_flag
= 0;
1893 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1895 menu_item_selection will be set to the selection. */
1897 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1901 if (! FRAME_X_P (f
))
1904 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
1905 G_CALLBACK (dialog_selection_callback
),
1906 G_CALLBACK (popup_deactivate_callback
),
1911 int specpdl_count
= SPECPDL_INDEX ();
1912 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1914 /* Display the menu. */
1915 gtk_widget_show_all (menu
);
1917 /* Process events that apply to the menu. */
1918 popup_widget_loop (1, menu
);
1920 unbind_to (specpdl_count
, Qnil
);
1924 #else /* not USE_GTK */
1926 dialog_selection_callback (Widget widget
, LWLIB_ID id
, XtPointer client_data
)
1928 /* The EMACS_INT cast avoids a warning. There's no problem
1929 as long as pointers have enough bits to hold small integers. */
1930 if ((int) (EMACS_INT
) client_data
!= -1)
1931 menu_item_selection
= (Lisp_Object
*) client_data
;
1934 lw_destroy_all_widgets (id
);
1936 popup_activated_flag
= 0;
1940 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1942 menu_item_selection will be set to the selection. */
1944 create_and_show_dialog (FRAME_PTR f
, widget_value
*first_wv
)
1951 dialog_id
= widget_id_tick
++;
1953 apply_systemfont_to_dialog (f
->output_data
.x
->widget
);
1955 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1956 f
->output_data
.x
->widget
, 1, 0,
1957 dialog_selection_callback
, 0, 0);
1958 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1959 /* Display the dialog box. */
1960 lw_pop_up_all_widgets (dialog_id
);
1961 popup_activated_flag
= 1;
1962 x_activate_timeout_atimer ();
1964 /* Process events that apply to the dialog box.
1965 Also handle timers. */
1967 int count
= SPECPDL_INDEX ();
1968 int fact
= 4 * sizeof (LWLIB_ID
);
1970 /* xdialog_show_unwind is responsible for popping the dialog box down. */
1971 record_unwind_protect (pop_down_menu
,
1972 Fcons (make_number (dialog_id
>> (fact
)),
1973 make_number (dialog_id
& ~(-1 << (fact
)))));
1975 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
1978 unbind_to (count
, Qnil
);
1982 #endif /* not USE_GTK */
1984 static char * button_names
[] = {
1985 "button1", "button2", "button3", "button4", "button5",
1986 "button6", "button7", "button8", "button9", "button10" };
1989 xdialog_show (FRAME_PTR f
, int keymaps
, Lisp_Object title
, Lisp_Object header
, char **error_name
)
1991 int i
, nb_buttons
=0;
1992 char dialog_name
[6];
1994 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
1996 /* Number of elements seen so far, before boundary. */
1998 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
1999 int boundary_seen
= 0;
2001 if (! FRAME_X_P (f
))
2006 if (menu_items_n_panes
> 1)
2008 *error_name
= "Multiple panes in dialog box";
2012 /* Create a tree of widget_value objects
2013 representing the text label and buttons. */
2015 Lisp_Object pane_name
, prefix
;
2017 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2018 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2019 pane_string
= (NILP (pane_name
)
2020 ? "" : (char *) SDATA (pane_name
));
2021 prev_wv
= xmalloc_widget_value ();
2022 prev_wv
->value
= pane_string
;
2023 if (keymaps
&& !NILP (prefix
))
2025 prev_wv
->enabled
= 1;
2026 prev_wv
->name
= "message";
2027 prev_wv
->help
= Qnil
;
2030 /* Loop over all panes and items, filling in the tree. */
2031 i
= MENU_ITEMS_PANE_LENGTH
;
2032 while (i
< menu_items_used
)
2035 /* Create a new item within current pane. */
2036 Lisp_Object item_name
, enable
, descrip
;
2037 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2038 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2040 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2042 if (NILP (item_name
))
2044 free_menubar_widget_value_tree (first_wv
);
2045 *error_name
= "Submenu in dialog items";
2048 if (EQ (item_name
, Qquote
))
2050 /* This is the boundary between left-side elts
2051 and right-side elts. Stop incrementing right_count. */
2056 if (nb_buttons
>= 9)
2058 free_menubar_widget_value_tree (first_wv
);
2059 *error_name
= "Too many dialog items";
2063 wv
= xmalloc_widget_value ();
2065 wv
->name
= (char *) button_names
[nb_buttons
];
2066 if (!NILP (descrip
))
2067 wv
->key
= (char *) SDATA (descrip
);
2068 wv
->value
= (char *) SDATA (item_name
);
2069 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2070 wv
->enabled
= !NILP (enable
);
2074 if (! boundary_seen
)
2078 i
+= MENU_ITEMS_ITEM_LENGTH
;
2081 /* If the boundary was not specified,
2082 by default put half on the left and half on the right. */
2083 if (! boundary_seen
)
2084 left_count
= nb_buttons
- nb_buttons
/ 2;
2086 wv
= xmalloc_widget_value ();
2087 wv
->name
= dialog_name
;
2090 /* Frame title: 'Q' = Question, 'I' = Information.
2091 Can also have 'E' = Error if, one day, we want
2092 a popup for errors. */
2094 dialog_name
[0] = 'Q';
2096 dialog_name
[0] = 'I';
2098 /* Dialog boxes use a really stupid name encoding
2099 which specifies how many buttons to use
2100 and how many buttons are on the right. */
2101 dialog_name
[1] = '0' + nb_buttons
;
2102 dialog_name
[2] = 'B';
2103 dialog_name
[3] = 'R';
2104 /* Number of buttons to put on the right. */
2105 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2107 wv
->contents
= first_wv
;
2111 /* No selection has been chosen yet. */
2112 menu_item_selection
= 0;
2114 /* Actually create and show the dialog. */
2115 create_and_show_dialog (f
, first_wv
);
2117 /* Free the widget_value objects we used to specify the contents. */
2118 free_menubar_widget_value_tree (first_wv
);
2120 /* Find the selected item, and its pane, to return
2121 the proper value. */
2122 if (menu_item_selection
!= 0)
2128 while (i
< menu_items_used
)
2132 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2135 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2136 i
+= MENU_ITEMS_PANE_LENGTH
;
2138 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2140 /* This is the boundary between left-side elts and
2147 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2148 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2152 entry
= Fcons (entry
, Qnil
);
2154 entry
= Fcons (prefix
, entry
);
2158 i
+= MENU_ITEMS_ITEM_LENGTH
;
2163 /* Make "Cancel" equivalent to C-g. */
2164 Fsignal (Qquit
, Qnil
);
2169 #else /* not USE_X_TOOLKIT && not USE_GTK */
2171 /* The frame of the last activated non-toolkit menu bar.
2172 Used to generate menu help events. */
2174 static struct frame
*menu_help_frame
;
2177 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2179 PANE is the pane number, and ITEM is the menu item number in
2180 the menu (currently not used).
2182 This cannot be done with generating a HELP_EVENT because
2183 XMenuActivate contains a loop that doesn't let Emacs process
2187 menu_help_callback (char *help_string
, int pane
, int item
)
2189 Lisp_Object
*first_item
;
2190 Lisp_Object pane_name
;
2191 Lisp_Object menu_object
;
2193 first_item
= XVECTOR (menu_items
)->contents
;
2194 if (EQ (first_item
[0], Qt
))
2195 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2196 else if (EQ (first_item
[0], Qquote
))
2197 /* This shouldn't happen, see xmenu_show. */
2198 pane_name
= empty_unibyte_string
;
2200 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2202 /* (menu-item MENU-NAME PANE-NUMBER) */
2203 menu_object
= Fcons (Qmenu_item
,
2205 Fcons (make_number (pane
), Qnil
)));
2206 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2207 Qnil
, menu_object
, make_number (item
), 1);
2211 pop_down_menu (Lisp_Object arg
)
2213 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
2214 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
2216 FRAME_PTR f
= p1
->pointer
;
2217 XMenu
*menu
= p2
->pointer
;
2221 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
2222 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
2224 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2226 #ifdef HAVE_X_WINDOWS
2227 /* Assume the mouse has moved out of the X window.
2228 If it has actually moved in, we will get an EnterNotify. */
2229 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2231 /* State that no mouse buttons are now held.
2232 (The oldXMenu code doesn't track this info for us.)
2233 That is not necessarily true, but the fiction leads to reasonable
2234 results, and it is a pain to ask which are actually held now. */
2235 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2237 #endif /* HAVE_X_WINDOWS */
2246 xmenu_show (FRAME_PTR f
, int x
, int y
, int for_click
, int keymaps
,
2247 Lisp_Object title
, char **error
, EMACS_UINT timestamp
)
2251 int pane
, selidx
, lpane
, status
;
2252 Lisp_Object entry
, pane_prefix
;
2254 int ulx
, uly
, width
, height
;
2255 int dispwidth
, dispheight
;
2256 int i
, j
, lines
, maxlines
;
2259 unsigned int dummy_uint
;
2260 int specpdl_count
= SPECPDL_INDEX ();
2262 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
2266 if (menu_items_n_panes
== 0)
2269 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2271 *error
= "Empty menu";
2275 /* Figure out which root window F is on. */
2276 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2277 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2278 &dummy_uint
, &dummy_uint
);
2280 /* Make the menu on that window. */
2281 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2284 *error
= "Can't create menu";
2288 /* Don't GC while we prepare and show the menu,
2289 because we give the oldxmenu library pointers to the
2290 contents of strings. */
2291 inhibit_garbage_collection ();
2293 #ifdef HAVE_X_WINDOWS
2294 /* Adjust coordinates to relative to the outer (window manager) window. */
2295 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
2296 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2297 #endif /* HAVE_X_WINDOWS */
2299 /* Adjust coordinates to be root-window-relative. */
2303 /* Create all the necessary panes and their items. */
2304 maxlines
= lines
= i
= 0;
2305 while (i
< menu_items_used
)
2307 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2309 /* Create a new pane. */
2310 Lisp_Object pane_name
, prefix
;
2313 maxlines
= max (maxlines
, lines
);
2315 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2316 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2317 pane_string
= (NILP (pane_name
)
2318 ? "" : (char *) SDATA (pane_name
));
2319 if (keymaps
&& !NILP (prefix
))
2322 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2323 if (lpane
== XM_FAILURE
)
2325 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2326 *error
= "Can't create pane";
2329 i
+= MENU_ITEMS_PANE_LENGTH
;
2331 /* Find the width of the widest item in this pane. */
2334 while (j
< menu_items_used
)
2337 item
= XVECTOR (menu_items
)->contents
[j
];
2345 width
= SBYTES (item
);
2346 if (width
> maxwidth
)
2349 j
+= MENU_ITEMS_ITEM_LENGTH
;
2352 /* Ignore a nil in the item list.
2353 It's meaningful only for dialog boxes. */
2354 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2358 /* Create a new item within current pane. */
2359 Lisp_Object item_name
, enable
, descrip
, help
;
2360 unsigned char *item_data
;
2363 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2364 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2366 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2367 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2368 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
2370 if (!NILP (descrip
))
2372 int gap
= maxwidth
- SBYTES (item_name
);
2373 /* if alloca is fast, use that to make the space,
2374 to reduce gc needs. */
2376 = (unsigned char *) alloca (maxwidth
2377 + SBYTES (descrip
) + 1);
2378 memcpy (item_data
, SDATA (item_name
), SBYTES (item_name
));
2379 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
2381 memcpy (item_data
+ j
, SDATA (descrip
), SBYTES (descrip
));
2382 item_data
[j
+ SBYTES (descrip
)] = 0;
2385 item_data
= SDATA (item_name
);
2387 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2388 menu
, lpane
, 0, item_data
,
2389 !NILP (enable
), help_string
)
2392 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2393 *error
= "Can't add selection to menu";
2396 i
+= MENU_ITEMS_ITEM_LENGTH
;
2401 maxlines
= max (maxlines
, lines
);
2403 /* All set and ready to fly. */
2404 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2405 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2406 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2407 x
= min (x
, dispwidth
);
2408 y
= min (y
, dispheight
);
2411 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2412 &ulx
, &uly
, &width
, &height
);
2413 if (ulx
+width
> dispwidth
)
2415 x
-= (ulx
+ width
) - dispwidth
;
2416 ulx
= dispwidth
- width
;
2418 if (uly
+height
> dispheight
)
2420 y
-= (uly
+ height
) - dispheight
;
2421 uly
= dispheight
- height
;
2423 #ifndef HAVE_X_WINDOWS
2424 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 1)
2426 /* Move the menu away of the echo area, to avoid overwriting the
2427 menu with help echo messages or vice versa. */
2428 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
2430 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2431 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2440 if (ulx
< 0) x
-= ulx
;
2441 if (uly
< 0) y
-= uly
;
2445 /* If position was not given by a mouse click, adjust so upper left
2446 corner of the menu as a whole ends up at given coordinates. This
2447 is what x-popup-menu says in its documentation. */
2449 y
+= 1.5*height
/(maxlines
+2);
2452 XMenuSetAEQ (menu
, TRUE
);
2453 XMenuSetFreeze (menu
, TRUE
);
2457 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
2460 record_unwind_protect (pop_down_menu
,
2461 Fcons (make_save_value (f
, 0),
2462 make_save_value (menu
, 0)));
2464 /* Help display under X won't work because XMenuActivate contains
2465 a loop that doesn't give Emacs a chance to process it. */
2466 menu_help_frame
= f
;
2467 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2468 x
, y
, ButtonReleaseMask
, &datap
,
2469 menu_help_callback
);
2475 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2478 /* Find the item number SELIDX in pane number PANE. */
2480 while (i
< menu_items_used
)
2482 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2486 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2488 i
+= MENU_ITEMS_PANE_LENGTH
;
2497 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2500 entry
= Fcons (entry
, Qnil
);
2501 if (!NILP (pane_prefix
))
2502 entry
= Fcons (pane_prefix
, entry
);
2508 i
+= MENU_ITEMS_ITEM_LENGTH
;
2514 *error
= "Can't activate menu";
2519 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2520 the menu was invoked with a mouse event as POSITION). */
2522 Fsignal (Qquit
, Qnil
);
2527 unbind_to (specpdl_count
, Qnil
);
2532 #endif /* not USE_X_TOOLKIT */
2534 #endif /* HAVE_MENUS */
2536 /* Detect if a dialog or menu has been posted. */
2539 popup_activated (void)
2541 return popup_activated_flag
;
2544 /* The following is used by delayed window autoselection. */
2546 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
2547 doc
: /* Return t if a menu or popup dialog is active. */)
2551 return (popup_activated ()) ? Qt
: Qnil
;
2554 #endif /* HAVE_MENUS */
2558 syms_of_xmenu (void)
2560 Qdebug_on_next_call
= intern_c_string ("debug-on-next-call");
2561 staticpro (&Qdebug_on_next_call
);
2563 #ifdef USE_X_TOOLKIT
2564 widget_id_tick
= (1<<16);
2565 next_menubar_widget_id
= 1;
2568 defsubr (&Smenu_or_popup_active_p
);
2570 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2571 defsubr (&Sx_menu_bar_open_internal
);
2572 Ffset (intern_c_string ("accelerate-menu"),
2573 intern_c_string (Sx_menu_bar_open_internal
.symbol_name
));
2577 defsubr (&Sx_popup_dialog
);
2581 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
2582 (do not change this comment) */