Fix typos.
[emacs.git] / src / xmenu.c
blob0dd652b566d1e710444e851b491d9b18bc7e7c3e
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. */
33 #include <config.h>
35 #if 0 /* Why was this included? And without syssignal.h? */
36 /* On 4.3 this loses if it comes after xterm.h. */
37 #include <signal.h>
38 #endif
40 #include <stdio.h>
41 #include <setjmp.h>
43 #include "lisp.h"
44 #include "keyboard.h"
45 #include "keymap.h"
46 #include "frame.h"
47 #include "termhooks.h"
48 #include "window.h"
49 #include "blockinput.h"
50 #include "buffer.h"
51 #include "charset.h"
52 #include "coding.h"
53 #include "sysselect.h"
55 #ifdef MSDOS
56 #include "msdos.h"
57 #endif
59 #ifdef HAVE_X_WINDOWS
60 /* This may include sys/types.h, and that somehow loses
61 if this is not done before the other system files. */
62 #include "xterm.h"
63 #endif
65 /* Load sys/types.h if not already loaded.
66 In some systems loading it twice is suicidal. */
67 #ifndef makedev
68 #include <sys/types.h>
69 #endif
71 #include "dispextern.h"
73 #ifdef HAVE_X_WINDOWS
74 /* Defining HAVE_MULTILINGUAL_MENU would mean that the toolkit menu
75 code accepts the Emacs internal encoding. */
76 #undef HAVE_MULTILINGUAL_MENU
77 #ifdef USE_X_TOOLKIT
78 #include "widget.h"
79 #include <X11/Xlib.h>
80 #include <X11/IntrinsicP.h>
81 #include <X11/CoreP.h>
82 #include <X11/StringDefs.h>
83 #include <X11/Shell.h>
84 #ifdef USE_LUCID
85 #include "xsettings.h"
86 #include "../lwlib/xlwmenu.h"
87 #ifdef HAVE_XAW3D
88 #include <X11/Xaw3d/Paned.h>
89 #else /* !HAVE_XAW3D */
90 #include <X11/Xaw/Paned.h>
91 #endif /* HAVE_XAW3D */
92 #endif /* USE_LUCID */
93 #ifdef USE_MOTIF
94 #include "../lwlib/lwlib.h"
95 #endif
96 #else /* not USE_X_TOOLKIT */
97 #ifndef USE_GTK
98 #include "../oldXMenu/XMenu.h"
99 #endif
100 #endif /* not USE_X_TOOLKIT */
101 #endif /* HAVE_X_WINDOWS */
103 #ifdef USE_GTK
104 #include "gtkutil.h"
105 #endif
107 #include "menu.h"
109 #ifndef TRUE
110 #define TRUE 1
111 #endif /* no TRUE */
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,
117 const char **);
118 #endif
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;
125 #ifdef USE_X_TOOLKIT
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;
135 FRAME_PTR f;
137 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
139 frame = XCAR (tail);
140 if (!FRAMEP (frame))
141 continue;
142 f = XFRAME (frame);
143 if (!FRAME_WINDOW_P (f))
144 continue;
145 if (f->output_data.x->id == id)
146 return f;
148 return 0;
151 #endif
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. */
161 void
162 mouse_position_for_popup (FRAME_PTR f, int *x, int *y)
164 Window root, dummy_window;
165 int dummy;
167 if (! FRAME_X_P (f))
168 abort ();
170 BLOCK_INPUT;
172 XQueryPointer (FRAME_X_DISPLAY (f),
173 DefaultRootWindow (FRAME_X_DISPLAY (f)),
175 /* The root window which contains the pointer. */
176 &root,
178 /* Window pointer is on, not used */
179 &dummy_window,
181 /* The position on that root window. */
182 x, y,
184 /* x/y in dummy_window coordinates, not used. */
185 &dummy, &dummy,
187 /* Modifier keys and pointer buttons, about which
188 we don't care. */
189 (unsigned int *) &dummy);
191 UNBLOCK_INPUT;
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 */
201 #ifdef HAVE_MENUS
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)
228 FRAME_PTR f = NULL;
229 Lisp_Object window;
231 check_x ();
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;
243 Time time;
244 Lisp_Object x, y;
246 (*mouse_position_hook) (&new_f, 1, &bar_window, &part, &x, &y, &time);
248 if (new_f != 0)
249 XSETFRAME (window, new_f);
250 else
251 window = selected_window;
252 #endif
253 window = selected_window;
255 else if (CONSP (position))
257 Lisp_Object tem;
258 tem = Fcar (position);
259 if (CONSP (tem))
260 window = Fcar (Fcdr (position));
261 else
263 tem = Fcar (Fcdr (position)); /* EVENT_START (position) */
264 window = Fcar (tem); /* POSN_WINDOW (tem) */
267 else if (WINDOWP (position) || FRAMEP (position))
268 window = position;
269 else
270 window = Qnil;
272 /* Decode where to put the menu. */
274 if (FRAMEP (window))
275 f = XFRAME (window);
276 else if (WINDOWP (window))
278 CHECK_LIVE_WINDOW (window);
279 f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
281 else
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. */
298 Fredisplay (Qt);
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)));
313 #else
315 Lisp_Object title;
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
328 no buttons. */
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. */
334 BLOCK_INPUT;
335 selection = xdialog_show (f, 0, title, header, &error_name);
336 UNBLOCK_INPUT;
338 unbind_to (specpdl_count, Qnil);
339 discard_menu_items ();
341 if (error_name) error ("%s", error_name);
342 return selection;
344 #endif
348 #ifndef MSDOS
350 #if defined USE_GTK || defined USE_MOTIF
352 /* Set menu_items_inuse so no other popup menu or dialog is created. */
354 void
355 x_menu_set_in_use (int in_use)
357 menu_items_inuse = in_use ? Qt : Qnil;
358 popup_activated_flag = in_use;
359 #ifdef USE_X_TOOLKIT
360 if (popup_activated_flag)
361 x_activate_timeout_atimer ();
362 #endif
365 #endif
367 /* Wait for an X event to arrive or for a timer to expire. */
369 #ifndef USE_MOTIF
370 static
371 #endif
372 void
373 x_menu_wait_for_event (void *data)
375 /* Another way to do this is to register a timer callback, that can be
376 done in GTK and Xt. But we have to do it like this when using only X
377 anyway, and with callbacks we would have three variants for timer handling
378 instead of the small ifdefs below. */
380 while (
381 #ifdef USE_X_TOOLKIT
382 ! XtAppPending (Xt_app_con)
383 #elif defined USE_GTK
384 ! gtk_events_pending ()
385 #else
386 ! XPending ((Display*) data)
387 #endif
390 EMACS_TIME next_time = timer_check (), *ntp;
391 long secs = EMACS_SECS (next_time);
392 long usecs = EMACS_USECS (next_time);
393 SELECT_TYPE read_fds;
394 struct x_display_info *dpyinfo;
395 int n = 0;
397 FD_ZERO (&read_fds);
398 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
400 int fd = ConnectionNumber (dpyinfo->display);
401 FD_SET (fd, &read_fds);
402 if (fd > n) n = fd;
403 XFlush (dpyinfo->display);
406 if (secs < 0 && usecs < 0)
407 ntp = 0;
408 else
409 ntp = &next_time;
411 select (n + 1, &read_fds, (SELECT_TYPE *)0, (SELECT_TYPE *)0, ntp);
414 #endif /* ! MSDOS */
417 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
419 #ifdef USE_X_TOOLKIT
421 /* Loop in Xt until the menu pulldown or dialog popup has been
422 popped down (deactivated). This is used for x-popup-menu
423 and x-popup-dialog; it is not used for the menu bar.
425 NOTE: All calls to popup_get_selection should be protected
426 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
428 static void
429 popup_get_selection (XEvent *initial_event, struct x_display_info *dpyinfo, LWLIB_ID id, int do_timers)
431 XEvent event;
433 while (popup_activated_flag)
435 if (initial_event)
437 event = *initial_event;
438 initial_event = 0;
440 else
442 if (do_timers) x_menu_wait_for_event (0);
443 XtAppNextEvent (Xt_app_con, &event);
446 /* Make sure we don't consider buttons grabbed after menu goes.
447 And make sure to deactivate for any ButtonRelease,
448 even if XtDispatchEvent doesn't do that. */
449 if (event.type == ButtonRelease
450 && dpyinfo->display == event.xbutton.display)
452 dpyinfo->grabbed &= ~(1 << event.xbutton.button);
453 #ifdef USE_MOTIF /* Pretending that the event came from a
454 Btn1Down seems the only way to convince Motif to
455 activate its callbacks; setting the XmNmenuPost
456 isn't working. --marcus@sysc.pdx.edu. */
457 event.xbutton.button = 1;
458 /* Motif only pops down menus when no Ctrl, Alt or Mod
459 key is pressed and the button is released. So reset key state
460 so Motif thinks this is the case. */
461 event.xbutton.state = 0;
462 #endif
464 /* Pop down on C-g and Escape. */
465 else if (event.type == KeyPress
466 && dpyinfo->display == event.xbutton.display)
468 KeySym keysym = XLookupKeysym (&event.xkey, 0);
470 if ((keysym == XK_g && (event.xkey.state & ControlMask) != 0)
471 || keysym == XK_Escape) /* Any escape, ignore modifiers. */
472 popup_activated_flag = 0;
475 x_dispatch_event (&event, event.xany.display);
479 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal, Sx_menu_bar_open_internal, 0, 1, "i",
480 doc: /* Start key navigation of the menu bar in FRAME.
481 This initially opens the first menu bar item and you can then navigate with the
482 arrow keys, select a menu entry with the return key or cancel with the
483 escape key. If FRAME has no menu bar this function does nothing.
485 If FRAME is nil or not given, use the selected frame. */)
486 (Lisp_Object frame)
488 XEvent ev;
489 FRAME_PTR f = check_x_frame (frame);
490 Widget menubar;
491 BLOCK_INPUT;
493 if (FRAME_EXTERNAL_MENU_BAR (f))
494 set_frame_menubar (f, 0, 1);
496 menubar = FRAME_X_OUTPUT (f)->menubar_widget;
497 if (menubar)
499 Window child;
500 int error_p = 0;
502 x_catch_errors (FRAME_X_DISPLAY (f));
503 memset (&ev, 0, sizeof ev);
504 ev.xbutton.display = FRAME_X_DISPLAY (f);
505 ev.xbutton.window = XtWindow (menubar);
506 ev.xbutton.root = FRAME_X_DISPLAY_INFO (f)->root_window;
507 ev.xbutton.time = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
508 ev.xbutton.button = Button1;
509 ev.xbutton.x = ev.xbutton.y = FRAME_MENUBAR_HEIGHT (f) / 2;
510 ev.xbutton.same_screen = True;
512 #ifdef USE_MOTIF
514 Arg al[2];
515 WidgetList list;
516 Cardinal nr;
517 XtSetArg (al[0], XtNchildren, &list);
518 XtSetArg (al[1], XtNnumChildren, &nr);
519 XtGetValues (menubar, al, 2);
520 ev.xbutton.window = XtWindow (list[0]);
522 #endif
524 XTranslateCoordinates (FRAME_X_DISPLAY (f),
525 /* From-window, to-window. */
526 ev.xbutton.window, ev.xbutton.root,
528 /* From-position, to-position. */
529 ev.xbutton.x, ev.xbutton.y,
530 &ev.xbutton.x_root, &ev.xbutton.y_root,
532 /* Child of win. */
533 &child);
534 error_p = x_had_errors_p (FRAME_X_DISPLAY (f));
535 x_uncatch_errors ();
537 if (! error_p)
539 ev.type = ButtonPress;
540 ev.xbutton.state = 0;
542 XtDispatchEvent (&ev);
543 ev.xbutton.type = ButtonRelease;
544 ev.xbutton.state = Button1Mask;
545 XtDispatchEvent (&ev);
549 UNBLOCK_INPUT;
551 return Qnil;
553 #endif /* USE_X_TOOLKIT */
556 #ifdef USE_GTK
557 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal, Sx_menu_bar_open_internal, 0, 1, "i",
558 doc: /* Start key navigation of the menu bar in FRAME.
559 This initially opens the first menu bar item and you can then navigate with the
560 arrow keys, select a menu entry with the return key or cancel with the
561 escape key. If FRAME has no menu bar this function does nothing.
563 If FRAME is nil or not given, use the selected frame. */)
564 (Lisp_Object frame)
566 GtkWidget *menubar;
567 FRAME_PTR f;
569 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
570 BLOCK_INPUT. */
572 BLOCK_INPUT;
573 f = check_x_frame (frame);
575 if (FRAME_EXTERNAL_MENU_BAR (f))
576 set_frame_menubar (f, 0, 1);
578 menubar = FRAME_X_OUTPUT (f)->menubar_widget;
579 if (menubar)
581 /* Activate the first menu. */
582 GList *children = gtk_container_get_children (GTK_CONTAINER (menubar));
584 if (children)
586 g_signal_emit_by_name (children->data, "activate_item");
587 popup_activated_flag = 1;
588 g_list_free (children);
591 UNBLOCK_INPUT;
593 return Qnil;
596 /* Loop util popup_activated_flag is set to zero in a callback.
597 Used for popup menus and dialogs. */
599 static void
600 popup_widget_loop (int do_timers, GtkWidget *widget)
602 ++popup_activated_flag;
604 /* Process events in the Gtk event loop until done. */
605 while (popup_activated_flag)
607 if (do_timers) x_menu_wait_for_event (0);
608 gtk_main_iteration ();
611 #endif
613 /* Activate the menu bar of frame F.
614 This is called from keyboard.c when it gets the
615 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
617 To activate the menu bar, we use the X button-press event
618 that was saved in saved_menu_event.
619 That makes the toolkit do its thing.
621 But first we recompute the menu bar contents (the whole tree).
623 The reason for saving the button event until here, instead of
624 passing it to the toolkit right away, is that we can safely
625 execute Lisp code. */
627 void
628 x_activate_menubar (FRAME_PTR f)
630 if (! FRAME_X_P (f))
631 abort ();
633 if (!f->output_data.x->saved_menu_event->type)
634 return;
636 #ifdef USE_GTK
637 if (! xg_win_to_widget (FRAME_X_DISPLAY (f),
638 f->output_data.x->saved_menu_event->xany.window))
639 return;
640 #endif
642 set_frame_menubar (f, 0, 1);
643 BLOCK_INPUT;
644 popup_activated_flag = 1;
645 #ifdef USE_GTK
646 XPutBackEvent (f->output_data.x->display_info->display,
647 f->output_data.x->saved_menu_event);
648 #else
649 XtDispatchEvent (f->output_data.x->saved_menu_event);
650 #endif
651 UNBLOCK_INPUT;
653 /* Ignore this if we get it a second time. */
654 f->output_data.x->saved_menu_event->type = 0;
657 /* This callback is invoked when the user selects a menubar cascade
658 pushbutton, but before the pulldown menu is posted. */
660 #ifndef USE_GTK
661 static void
662 popup_activate_callback (Widget widget, LWLIB_ID id, XtPointer client_data)
664 popup_activated_flag = 1;
665 #ifdef USE_X_TOOLKIT
666 x_activate_timeout_atimer ();
667 #endif
669 #endif
671 /* This callback is invoked when a dialog or menu is finished being
672 used and has been unposted. */
674 #ifdef USE_GTK
675 static void
676 popup_deactivate_callback (GtkWidget *widget, gpointer client_data)
678 popup_activated_flag = 0;
680 #else
681 static void
682 popup_deactivate_callback (Widget widget, LWLIB_ID id, XtPointer client_data)
684 popup_activated_flag = 0;
686 #endif
689 /* Function that finds the frame for WIDGET and shows the HELP text
690 for that widget.
691 F is the frame if known, or NULL if not known. */
692 static void
693 show_help_event (FRAME_PTR f, xt_or_gtk_widget widget, Lisp_Object help)
695 Lisp_Object frame;
697 if (f)
699 XSETFRAME (frame, f);
700 kbd_buffer_store_help_event (frame, help);
702 else
704 #if 0 /* This code doesn't do anything useful. ++kfs */
705 /* WIDGET is the popup menu. It's parent is the frame's
706 widget. See which frame that is. */
707 xt_or_gtk_widget frame_widget = XtParent (widget);
708 Lisp_Object tail;
710 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
712 frame = XCAR (tail);
713 if (FRAMEP (frame)
714 && (f = XFRAME (frame),
715 FRAME_X_P (f) && f->output_data.x->widget == frame_widget))
716 break;
718 #endif
719 show_help_echo (help, Qnil, Qnil, Qnil);
723 /* Callback called when menu items are highlighted/unhighlighted
724 while moving the mouse over them. WIDGET is the menu bar or menu
725 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
726 the data structure for the menu item, or null in case of
727 unhighlighting. */
729 #ifdef USE_GTK
730 static void
731 menu_highlight_callback (GtkWidget *widget, gpointer call_data)
733 xg_menu_item_cb_data *cb_data;
734 Lisp_Object help;
736 cb_data = (xg_menu_item_cb_data*) g_object_get_data (G_OBJECT (widget),
737 XG_ITEM_DATA);
738 if (! cb_data) return;
740 help = call_data ? cb_data->help : Qnil;
742 /* If popup_activated_flag is greater than 1 we are in a popup menu.
743 Don't pass the frame to show_help_event for those.
744 Passing frame creates an Emacs event. As we are looping in
745 popup_widget_loop, it won't be handled. Passing NULL shows the tip
746 directly without using an Emacs event. This is what the Lucid code
747 does below. */
748 show_help_event (popup_activated_flag <= 1 ? cb_data->cl_data->f : NULL,
749 widget, help);
751 #else
752 static void
753 menu_highlight_callback (Widget widget, LWLIB_ID id, void *call_data)
755 struct frame *f;
756 Lisp_Object help;
758 widget_value *wv = (widget_value *) call_data;
760 help = wv ? wv->help : Qnil;
762 /* Determine the frame for the help event. */
763 f = menubar_id_to_frame (id);
765 show_help_event (f, widget, help);
767 #endif
769 #ifdef USE_GTK
770 /* Gtk calls callbacks just because we tell it what item should be
771 selected in a radio group. If this variable is set to a non-zero
772 value, we are creating menus and don't want callbacks right now.
774 static int xg_crazy_callback_abort;
776 /* This callback is called from the menu bar pulldown menu
777 when the user makes a selection.
778 Figure out what the user chose
779 and put the appropriate events into the keyboard buffer. */
780 static void
781 menubar_selection_callback (GtkWidget *widget, gpointer client_data)
783 xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
785 if (xg_crazy_callback_abort)
786 return;
788 if (! cb_data || ! cb_data->cl_data || ! cb_data->cl_data->f)
789 return;
791 /* For a group of radio buttons, GTK calls the selection callback first
792 for the item that was active before the selection and then for the one that
793 is active after the selection. For C-h k this means we get the help on
794 the deselected item and then the selected item is executed. Prevent that
795 by ignoring the non-active item. */
796 if (GTK_IS_RADIO_MENU_ITEM (widget)
797 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
798 return;
800 /* When a menu is popped down, X generates a focus event (i.e. focus
801 goes back to the frame below the menu). Since GTK buffers events,
802 we force it out here before the menu selection event. Otherwise
803 sit-for will exit at once if the focus event follows the menu selection
804 event. */
806 BLOCK_INPUT;
807 while (gtk_events_pending ())
808 gtk_main_iteration ();
809 UNBLOCK_INPUT;
811 find_and_call_menu_selection (cb_data->cl_data->f,
812 cb_data->cl_data->menu_bar_items_used,
813 cb_data->cl_data->menu_bar_vector,
814 cb_data->call_data);
817 #else /* not USE_GTK */
819 /* This callback is called from the menu bar pulldown menu
820 when the user makes a selection.
821 Figure out what the user chose
822 and put the appropriate events into the keyboard buffer. */
823 static void
824 menubar_selection_callback (Widget widget, LWLIB_ID id, XtPointer client_data)
826 FRAME_PTR f;
828 f = menubar_id_to_frame (id);
829 if (!f)
830 return;
831 find_and_call_menu_selection (f, f->menu_bar_items_used,
832 f->menu_bar_vector, client_data);
834 #endif /* not USE_GTK */
836 /* Recompute all the widgets of frame F, when the menu bar has been
837 changed. Value is non-zero if widgets were updated. */
839 static int
840 update_frame_menubar (FRAME_PTR f)
842 #ifdef USE_GTK
843 return xg_update_frame_menubar (f);
844 #else
845 struct x_output *x;
846 int columns, rows;
848 if (! FRAME_X_P (f))
849 abort ();
851 x = f->output_data.x;
853 if (!x->menubar_widget || XtIsManaged (x->menubar_widget))
854 return 0;
856 BLOCK_INPUT;
857 /* Save the size of the frame because the pane widget doesn't accept
858 to resize itself. So force it. */
859 columns = FRAME_COLS (f);
860 rows = FRAME_LINES (f);
862 /* Do the voodoo which means "I'm changing lots of things, don't try
863 to refigure sizes until I'm done." */
864 lw_refigure_widget (x->column_widget, False);
866 /* The order in which children are managed is the top to bottom
867 order in which they are displayed in the paned window. First,
868 remove the text-area widget. */
869 XtUnmanageChild (x->edit_widget);
871 /* Remove the menubar that is there now, and put up the menubar that
872 should be there. */
873 XtManageChild (x->menubar_widget);
874 XtMapWidget (x->menubar_widget);
875 XtVaSetValues (x->menubar_widget, XtNmappedWhenManaged, 1, NULL);
877 /* Re-manage the text-area widget, and then thrash the sizes. */
878 XtManageChild (x->edit_widget);
879 lw_refigure_widget (x->column_widget, True);
881 /* Force the pane widget to resize itself with the right values. */
882 EmacsFrameSetCharSize (x->edit_widget, columns, rows);
883 UNBLOCK_INPUT;
884 #endif
885 return 1;
888 #ifdef USE_LUCID
889 static void
890 apply_systemfont_to_dialog (Widget w)
892 const char *fn = xsettings_get_system_normal_font ();
893 if (fn)
895 XrmDatabase db = XtDatabase (XtDisplay (w));
896 if (db)
897 XrmPutStringResource (&db, "*dialog.font", fn);
901 static void
902 apply_systemfont_to_menu (struct frame *f, Widget w)
904 const char *fn = xsettings_get_system_normal_font ();
906 if (fn)
908 XrmDatabase db = XtDatabase (XtDisplay (w));
909 if (db)
911 XrmPutStringResource (&db, "*menubar*font", fn);
912 XrmPutStringResource (&db, "*popup*font", fn);
917 #endif
919 /* Set the contents of the menubar widgets of frame F.
920 The argument FIRST_TIME is currently ignored;
921 it is set the first time this is called, from initialize_frame_menubar. */
923 void
924 set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
926 xt_or_gtk_widget menubar_widget;
927 #ifdef USE_X_TOOLKIT
928 LWLIB_ID id;
929 #endif
930 Lisp_Object items;
931 widget_value *wv, *first_wv, *prev_wv = 0;
932 int i;
933 int *submenu_start, *submenu_end;
934 int *submenu_top_level_items, *submenu_n_panes;
936 if (! FRAME_X_P (f))
937 abort ();
939 menubar_widget = f->output_data.x->menubar_widget;
941 XSETFRAME (Vmenu_updating_frame, f);
943 #ifdef USE_X_TOOLKIT
944 if (f->output_data.x->id == 0)
945 f->output_data.x->id = next_menubar_widget_id++;
946 id = f->output_data.x->id;
947 #endif
949 if (! menubar_widget)
950 deep_p = 1;
951 /* Make the first call for any given frame always go deep. */
952 else if (!f->output_data.x->saved_menu_event && !deep_p)
954 deep_p = 1;
955 f->output_data.x->saved_menu_event = (XEvent*)xmalloc (sizeof (XEvent));
956 f->output_data.x->saved_menu_event->type = 0;
959 #ifdef USE_GTK
960 /* If we have detached menus, we must update deep so detached menus
961 also gets updated. */
962 deep_p = deep_p || xg_have_tear_offs ();
963 #endif
965 if (deep_p)
967 /* Make a widget-value tree representing the entire menu trees. */
969 struct buffer *prev = current_buffer;
970 Lisp_Object buffer;
971 int specpdl_count = SPECPDL_INDEX ();
972 int previous_menu_items_used = f->menu_bar_items_used;
973 Lisp_Object *previous_items
974 = (Lisp_Object *) alloca (previous_menu_items_used
975 * sizeof (Lisp_Object));
976 int subitems;
978 /* If we are making a new widget, its contents are empty,
979 do always reinitialize them. */
980 if (! menubar_widget)
981 previous_menu_items_used = 0;
983 buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer;
984 specbind (Qinhibit_quit, Qt);
985 /* Don't let the debugger step into this code
986 because it is not reentrant. */
987 specbind (Qdebug_on_next_call, Qnil);
989 record_unwind_save_match_data ();
990 if (NILP (Voverriding_local_map_menu_flag))
992 specbind (Qoverriding_terminal_local_map, Qnil);
993 specbind (Qoverriding_local_map, Qnil);
996 set_buffer_internal_1 (XBUFFER (buffer));
998 /* Run the Lucid hook. */
999 safe_run_hooks (Qactivate_menubar_hook);
1001 /* If it has changed current-menubar from previous value,
1002 really recompute the menubar from the value. */
1003 if (! NILP (Vlucid_menu_bar_dirty_flag))
1004 call0 (Qrecompute_lucid_menubar);
1005 safe_run_hooks (Qmenu_bar_update_hook);
1006 FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
1008 items = FRAME_MENU_BAR_ITEMS (f);
1010 /* Save the frame's previous menu bar contents data. */
1011 if (previous_menu_items_used)
1012 memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
1013 previous_menu_items_used * sizeof (Lisp_Object));
1015 /* Fill in menu_items with the current menu bar contents.
1016 This can evaluate Lisp code. */
1017 save_menu_items ();
1019 menu_items = f->menu_bar_vector;
1020 menu_items_allocated = VECTORP (menu_items) ? ASIZE (menu_items) : 0;
1021 subitems = ASIZE (items) / 4;
1022 submenu_start = (int *) alloca ((subitems + 1) * sizeof (int));
1023 submenu_end = (int *) alloca (subitems * sizeof (int));
1024 submenu_n_panes = (int *) alloca (subitems * sizeof (int));
1025 submenu_top_level_items = (int *) alloca (subitems * sizeof (int));
1026 init_menu_items ();
1027 for (i = 0; i < subitems; i++)
1029 Lisp_Object key, string, maps;
1031 key = XVECTOR (items)->contents[4 * i];
1032 string = XVECTOR (items)->contents[4 * i + 1];
1033 maps = XVECTOR (items)->contents[4 * i + 2];
1034 if (NILP (string))
1035 break;
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 submenu_start[i] = -1;
1048 finish_menu_items ();
1050 /* Convert menu_items into widget_value trees
1051 to display the menu. This cannot evaluate Lisp code. */
1053 wv = xmalloc_widget_value ();
1054 wv->name = "menubar";
1055 wv->value = 0;
1056 wv->enabled = 1;
1057 wv->button_type = BUTTON_TYPE_NONE;
1058 wv->help = Qnil;
1059 first_wv = wv;
1061 for (i = 0; 0 <= submenu_start[i]; i++)
1063 menu_items_n_panes = submenu_n_panes[i];
1064 wv = digest_single_submenu (submenu_start[i], submenu_end[i],
1065 submenu_top_level_items[i]);
1066 if (prev_wv)
1067 prev_wv->next = wv;
1068 else
1069 first_wv->contents = wv;
1070 /* Don't set wv->name here; GC during the loop might relocate it. */
1071 wv->enabled = 1;
1072 wv->button_type = BUTTON_TYPE_NONE;
1073 prev_wv = wv;
1076 set_buffer_internal_1 (prev);
1078 /* If there has been no change in the Lisp-level contents
1079 of the menu bar, skip redisplaying it. Just exit. */
1081 /* Compare the new menu items with the ones computed last time. */
1082 for (i = 0; i < previous_menu_items_used; i++)
1083 if (menu_items_used == i
1084 || (!EQ (previous_items[i], XVECTOR (menu_items)->contents[i])))
1085 break;
1086 if (i == menu_items_used && i == previous_menu_items_used && i != 0)
1088 /* The menu items have not changed. Don't bother updating
1089 the menus in any form, since it would be a no-op. */
1090 free_menubar_widget_value_tree (first_wv);
1091 discard_menu_items ();
1092 unbind_to (specpdl_count, Qnil);
1093 return;
1096 /* The menu items are different, so store them in the frame. */
1097 f->menu_bar_vector = menu_items;
1098 f->menu_bar_items_used = menu_items_used;
1100 /* This undoes save_menu_items. */
1101 unbind_to (specpdl_count, Qnil);
1103 /* Now GC cannot happen during the lifetime of the widget_value,
1104 so it's safe to store data from a Lisp_String. */
1105 wv = first_wv->contents;
1106 for (i = 0; i < ASIZE (items); i += 4)
1108 Lisp_Object string;
1109 string = XVECTOR (items)->contents[i + 1];
1110 if (NILP (string))
1111 break;
1112 wv->name = SSDATA (string);
1113 update_submenu_strings (wv->contents);
1114 wv = wv->next;
1118 else
1120 /* Make a widget-value tree containing
1121 just the top level menu bar strings. */
1123 wv = xmalloc_widget_value ();
1124 wv->name = "menubar";
1125 wv->value = 0;
1126 wv->enabled = 1;
1127 wv->button_type = BUTTON_TYPE_NONE;
1128 wv->help = Qnil;
1129 first_wv = wv;
1131 items = FRAME_MENU_BAR_ITEMS (f);
1132 for (i = 0; i < ASIZE (items); i += 4)
1134 Lisp_Object string;
1136 string = XVECTOR (items)->contents[i + 1];
1137 if (NILP (string))
1138 break;
1140 wv = xmalloc_widget_value ();
1141 wv->name = SSDATA (string);
1142 wv->value = 0;
1143 wv->enabled = 1;
1144 wv->button_type = BUTTON_TYPE_NONE;
1145 wv->help = Qnil;
1146 /* This prevents lwlib from assuming this
1147 menu item is really supposed to be empty. */
1148 /* The intptr_t cast avoids a warning.
1149 This value just has to be different from small integers. */
1150 wv->call_data = (void *) (intptr_t) (-1);
1152 if (prev_wv)
1153 prev_wv->next = wv;
1154 else
1155 first_wv->contents = wv;
1156 prev_wv = wv;
1159 /* Forget what we thought we knew about what is in the
1160 detailed contents of the menu bar menus.
1161 Changing the top level always destroys the contents. */
1162 f->menu_bar_items_used = 0;
1165 /* Create or update the menu bar widget. */
1167 BLOCK_INPUT;
1169 #ifdef USE_GTK
1170 xg_crazy_callback_abort = 1;
1171 if (menubar_widget)
1173 /* The fourth arg is DEEP_P, which says to consider the entire
1174 menu trees we supply, rather than just the menu bar item names. */
1175 xg_modify_menubar_widgets (menubar_widget,
1177 first_wv,
1178 deep_p,
1179 G_CALLBACK (menubar_selection_callback),
1180 G_CALLBACK (popup_deactivate_callback),
1181 G_CALLBACK (menu_highlight_callback));
1183 else
1185 menubar_widget
1186 = xg_create_widget ("menubar", "menubar", f, first_wv,
1187 G_CALLBACK (menubar_selection_callback),
1188 G_CALLBACK (popup_deactivate_callback),
1189 G_CALLBACK (menu_highlight_callback));
1191 f->output_data.x->menubar_widget = menubar_widget;
1195 #else /* not USE_GTK */
1196 if (menubar_widget)
1198 /* Disable resizing (done for Motif!) */
1199 lw_allow_resizing (f->output_data.x->widget, False);
1201 /* The third arg is DEEP_P, which says to consider the entire
1202 menu trees we supply, rather than just the menu bar item names. */
1203 lw_modify_all_widgets (id, first_wv, deep_p);
1205 /* Re-enable the edit widget to resize. */
1206 lw_allow_resizing (f->output_data.x->widget, True);
1208 else
1210 char menuOverride[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
1211 XtTranslations override = XtParseTranslationTable (menuOverride);
1213 #ifdef USE_LUCID
1214 apply_systemfont_to_menu (f, f->output_data.x->column_widget);
1215 #endif
1216 menubar_widget = lw_create_widget ("menubar", "menubar", id,
1217 first_wv,
1218 f->output_data.x->column_widget,
1220 popup_activate_callback,
1221 menubar_selection_callback,
1222 popup_deactivate_callback,
1223 menu_highlight_callback);
1224 f->output_data.x->menubar_widget = menubar_widget;
1226 /* Make menu pop down on C-g. */
1227 XtOverrideTranslations (menubar_widget, override);
1231 int menubar_size;
1232 if (f->output_data.x->menubar_widget)
1233 XtRealizeWidget (f->output_data.x->menubar_widget);
1235 menubar_size
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)
1239 : 0);
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. */
1245 #ifdef USE_LUCID
1246 if (FRAME_EXTERNAL_MENU_BAR (f))
1248 Dimension ibw = 0;
1249 XtVaGetValues (f->output_data.x->column_widget,
1250 XtNinternalBorderWidth, &ibw, NULL);
1251 menubar_size += ibw;
1253 #endif /* USE_LUCID */
1254 #endif /* 1 */
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);
1263 #ifdef USE_GTK
1264 xg_crazy_callback_abort = 0;
1265 #endif
1267 UNBLOCK_INPUT;
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
1273 is visible. */
1275 void
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. */
1289 #ifndef USE_GTK
1290 void
1291 free_frame_menubar (FRAME_PTR f)
1293 Widget menubar_widget;
1295 if (! FRAME_X_P (f))
1296 abort ();
1298 menubar_widget = f->output_data.x->menubar_widget;
1300 f->output_data.x->menubar_height = 0;
1302 if (menubar_widget)
1304 #ifdef USE_MOTIF
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;
1314 #endif
1316 BLOCK_INPUT;
1318 #ifdef USE_MOTIF
1319 if (f->output_data.x->widget)
1320 XtVaGetValues (f->output_data.x->widget, XtNx, &x0, XtNy, &y0, NULL);
1321 #endif
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)
1328 #ifdef USE_MOTIF
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);
1332 #endif
1333 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
1335 UNBLOCK_INPUT;
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;
1363 #ifdef USE_GTK
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
1369 FRAME_PTR f;
1370 int x;
1371 int 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. */
1384 static void
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;
1388 GtkRequisition req;
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);
1393 *x = data->x;
1394 *y = data->y;
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_get_preferred_size (GTK_WIDGET (menu), NULL, &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;
1405 static void
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;
1414 static Lisp_Object
1415 pop_down_menu (Lisp_Object arg)
1417 struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
1419 popup_activated_flag = 0;
1420 BLOCK_INPUT;
1421 gtk_widget_destroy (GTK_WIDGET (p->pointer));
1422 UNBLOCK_INPUT;
1423 return Qnil;
1426 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1427 menu pops down.
1428 menu_item_selection will be set to the selection. */
1429 static void
1430 create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv, int x, int y,
1431 int for_click, Time timestamp)
1433 int i;
1434 GtkWidget *menu;
1435 GtkMenuPositionFunc pos_func = 0; /* Pop up at pointer. */
1436 struct next_popup_x_y popup_x_y;
1437 int specpdl_count = SPECPDL_INDEX ();
1439 if (! FRAME_X_P (f))
1440 abort ();
1442 xg_crazy_callback_abort = 1;
1443 menu = xg_create_widget ("popup", first_wv->name, f, first_wv,
1444 G_CALLBACK (popup_selection_callback),
1445 G_CALLBACK (popup_deactivate_callback),
1446 G_CALLBACK (menu_highlight_callback));
1447 xg_crazy_callback_abort = 0;
1449 if (! for_click)
1451 /* Not invoked by a click. pop up at x/y. */
1452 pos_func = menu_position_func;
1454 /* Adjust coordinates to be root-window-relative. */
1455 x += f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
1456 y += f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
1458 popup_x_y.x = x;
1459 popup_x_y.y = y;
1460 popup_x_y.f = f;
1462 i = 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1464 else
1466 for (i = 0; i < 5; i++)
1467 if (FRAME_X_DISPLAY_INFO (f)->grabbed & (1 << i))
1468 break;
1471 /* Display the menu. */
1472 gtk_widget_show_all (menu);
1474 gtk_menu_popup (GTK_MENU (menu), 0, 0, pos_func, &popup_x_y, i,
1475 timestamp ? timestamp : gtk_get_current_event_time ());
1477 record_unwind_protect (pop_down_menu, make_save_value (menu, 0));
1479 if (gtk_widget_get_mapped (menu))
1481 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1482 two. show_help_echo uses this to detect popup menus. */
1483 popup_activated_flag = 1;
1484 /* Process events that apply to the menu. */
1485 popup_widget_loop (1, menu);
1488 unbind_to (specpdl_count, Qnil);
1490 /* Must reset this manually because the button release event is not passed
1491 to Emacs event loop. */
1492 FRAME_X_DISPLAY_INFO (f)->grabbed = 0;
1495 #else /* not USE_GTK */
1497 /* We need a unique id for each widget handled by the Lucid Widget
1498 library.
1500 For the main windows, and popup menus, we use this counter,
1501 which we increment each time after use. This starts from 1<<16.
1503 For menu bars, we use numbers starting at 0, counted in
1504 next_menubar_widget_id. */
1505 LWLIB_ID widget_id_tick;
1507 static void
1508 popup_selection_callback (Widget widget, LWLIB_ID id, XtPointer client_data)
1510 menu_item_selection = (Lisp_Object *) client_data;
1513 /* ARG is the LWLIB ID of the dialog box, represented
1514 as a Lisp object as (HIGHPART . LOWPART). */
1516 static Lisp_Object
1517 pop_down_menu (Lisp_Object arg)
1519 LWLIB_ID id = (XINT (XCAR (arg)) << 4 * sizeof (LWLIB_ID)
1520 | XINT (XCDR (arg)));
1522 BLOCK_INPUT;
1523 lw_destroy_all_widgets (id);
1524 UNBLOCK_INPUT;
1525 popup_activated_flag = 0;
1527 return Qnil;
1530 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1531 menu pops down.
1532 menu_item_selection will be set to the selection. */
1533 static void
1534 create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv,
1535 int x, int y, int for_click, Time timestamp)
1537 int i;
1538 Arg av[2];
1539 int ac = 0;
1540 XEvent dummy;
1541 XButtonPressedEvent *event = &(dummy.xbutton);
1542 LWLIB_ID menu_id;
1543 Widget menu;
1545 if (! FRAME_X_P (f))
1546 abort ();
1548 #ifdef USE_LUCID
1549 apply_systemfont_to_menu (f, f->output_data.x->widget);
1550 #endif
1552 menu_id = widget_id_tick++;
1553 menu = lw_create_widget ("popup", first_wv->name, menu_id, first_wv,
1554 f->output_data.x->widget, 1, 0,
1555 popup_selection_callback,
1556 popup_deactivate_callback,
1557 menu_highlight_callback);
1559 event->type = ButtonPress;
1560 event->serial = 0;
1561 event->send_event = 0;
1562 event->display = FRAME_X_DISPLAY (f);
1563 event->time = CurrentTime;
1564 event->root = FRAME_X_DISPLAY_INFO (f)->root_window;
1565 event->window = event->subwindow = event->root;
1566 event->x = x;
1567 event->y = y;
1569 /* Adjust coordinates to be root-window-relative. */
1570 x += f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
1571 y += f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
1573 event->x_root = x;
1574 event->y_root = y;
1576 event->state = 0;
1577 event->button = 0;
1578 for (i = 0; i < 5; i++)
1579 if (FRAME_X_DISPLAY_INFO (f)->grabbed & (1 << i))
1580 event->button = i;
1582 /* Don't allow any geometry request from the user. */
1583 XtSetArg (av[ac], XtNgeometry, 0); ac++;
1584 XtSetValues (menu, av, ac);
1586 /* Display the menu. */
1587 lw_popup_menu (menu, &dummy);
1588 popup_activated_flag = 1;
1589 x_activate_timeout_atimer ();
1592 int fact = 4 * sizeof (LWLIB_ID);
1593 int specpdl_count = SPECPDL_INDEX ();
1594 record_unwind_protect (pop_down_menu,
1595 Fcons (make_number (menu_id >> (fact)),
1596 make_number (menu_id & ~(-1 << (fact)))));
1598 /* Process events that apply to the menu. */
1599 popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f), menu_id, 1);
1601 unbind_to (specpdl_count, Qnil);
1605 #endif /* not USE_GTK */
1607 static Lisp_Object
1608 cleanup_widget_value_tree (Lisp_Object arg)
1610 struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
1611 widget_value *wv = p->pointer;
1613 free_menubar_widget_value_tree (wv);
1615 return Qnil;
1618 Lisp_Object
1619 xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
1620 Lisp_Object title, const char **error_name, Time timestamp)
1622 int i;
1623 widget_value *wv, *save_wv = 0, *first_wv = 0, *prev_wv = 0;
1624 widget_value **submenu_stack
1625 = (widget_value **) alloca (menu_items_used * sizeof (widget_value *));
1626 Lisp_Object *subprefix_stack
1627 = (Lisp_Object *) alloca (menu_items_used * sizeof (Lisp_Object));
1628 int submenu_depth = 0;
1630 int first_pane;
1632 int specpdl_count = SPECPDL_INDEX ();
1634 if (! FRAME_X_P (f))
1635 abort ();
1637 *error_name = NULL;
1639 if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)
1641 *error_name = "Empty menu";
1642 return Qnil;
1645 /* Create a tree of widget_value objects
1646 representing the panes and their items. */
1647 wv = xmalloc_widget_value ();
1648 wv->name = "menu";
1649 wv->value = 0;
1650 wv->enabled = 1;
1651 wv->button_type = BUTTON_TYPE_NONE;
1652 wv->help =Qnil;
1653 first_wv = wv;
1654 first_pane = 1;
1656 /* Loop over all panes and items, filling in the tree. */
1657 i = 0;
1658 while (i < menu_items_used)
1660 if (EQ (XVECTOR (menu_items)->contents[i], Qnil))
1662 submenu_stack[submenu_depth++] = save_wv;
1663 save_wv = prev_wv;
1664 prev_wv = 0;
1665 first_pane = 1;
1666 i++;
1668 else if (EQ (XVECTOR (menu_items)->contents[i], Qlambda))
1670 prev_wv = save_wv;
1671 save_wv = submenu_stack[--submenu_depth];
1672 first_pane = 0;
1673 i++;
1675 else if (EQ (XVECTOR (menu_items)->contents[i], Qt)
1676 && submenu_depth != 0)
1677 i += MENU_ITEMS_PANE_LENGTH;
1678 /* Ignore a nil in the item list.
1679 It's meaningful only for dialog boxes. */
1680 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
1681 i += 1;
1682 else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
1684 /* Create a new pane. */
1685 Lisp_Object pane_name, prefix;
1686 const char *pane_string;
1688 pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
1689 prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
1691 #ifndef HAVE_MULTILINGUAL_MENU
1692 if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
1694 pane_name = ENCODE_MENU_STRING (pane_name);
1695 ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
1697 #endif
1698 pane_string = (NILP (pane_name)
1699 ? "" : SSDATA (pane_name));
1700 /* If there is just one top-level pane, put all its items directly
1701 under the top-level menu. */
1702 if (menu_items_n_panes == 1)
1703 pane_string = "";
1705 /* If the pane has a meaningful name,
1706 make the pane a top-level menu item
1707 with its items as a submenu beneath it. */
1708 if (!keymaps && strcmp (pane_string, ""))
1710 wv = xmalloc_widget_value ();
1711 if (save_wv)
1712 save_wv->next = wv;
1713 else
1714 first_wv->contents = wv;
1715 wv->name = pane_string;
1716 if (keymaps && !NILP (prefix))
1717 wv->name++;
1718 wv->value = 0;
1719 wv->enabled = 1;
1720 wv->button_type = BUTTON_TYPE_NONE;
1721 wv->help = Qnil;
1722 save_wv = wv;
1723 prev_wv = 0;
1725 else if (first_pane)
1727 save_wv = wv;
1728 prev_wv = 0;
1730 first_pane = 0;
1731 i += MENU_ITEMS_PANE_LENGTH;
1733 else
1735 /* Create a new item within current pane. */
1736 Lisp_Object item_name, enable, descrip, def, type, selected, help;
1737 item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
1738 enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
1739 descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
1740 def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);
1741 type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);
1742 selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
1743 help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
1745 #ifndef HAVE_MULTILINGUAL_MENU
1746 if (STRINGP (item_name) && STRING_MULTIBYTE (item_name))
1748 item_name = ENCODE_MENU_STRING (item_name);
1749 ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
1752 if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
1754 descrip = ENCODE_MENU_STRING (descrip);
1755 ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
1757 #endif /* not HAVE_MULTILINGUAL_MENU */
1759 wv = xmalloc_widget_value ();
1760 if (prev_wv)
1761 prev_wv->next = wv;
1762 else
1763 save_wv->contents = wv;
1764 wv->name = SSDATA (item_name);
1765 if (!NILP (descrip))
1766 wv->key = SSDATA (descrip);
1767 wv->value = 0;
1768 /* If this item has a null value,
1769 make the call_data null so that it won't display a box
1770 when the mouse is on it. */
1771 wv->call_data
1772 = (!NILP (def) ? (void *) &XVECTOR (menu_items)->contents[i] : 0);
1773 wv->enabled = !NILP (enable);
1775 if (NILP (type))
1776 wv->button_type = BUTTON_TYPE_NONE;
1777 else if (EQ (type, QCtoggle))
1778 wv->button_type = BUTTON_TYPE_TOGGLE;
1779 else if (EQ (type, QCradio))
1780 wv->button_type = BUTTON_TYPE_RADIO;
1781 else
1782 abort ();
1784 wv->selected = !NILP (selected);
1786 if (! STRINGP (help))
1787 help = Qnil;
1789 wv->help = help;
1791 prev_wv = wv;
1793 i += MENU_ITEMS_ITEM_LENGTH;
1797 /* Deal with the title, if it is non-nil. */
1798 if (!NILP (title))
1800 widget_value *wv_title = xmalloc_widget_value ();
1801 widget_value *wv_sep1 = xmalloc_widget_value ();
1802 widget_value *wv_sep2 = xmalloc_widget_value ();
1804 wv_sep2->name = "--";
1805 wv_sep2->next = first_wv->contents;
1806 wv_sep2->help = Qnil;
1808 wv_sep1->name = "--";
1809 wv_sep1->next = wv_sep2;
1810 wv_sep1->help = Qnil;
1812 #ifndef HAVE_MULTILINGUAL_MENU
1813 if (STRING_MULTIBYTE (title))
1814 title = ENCODE_MENU_STRING (title);
1815 #endif
1817 wv_title->name = SSDATA (title);
1818 wv_title->enabled = TRUE;
1819 wv_title->button_type = BUTTON_TYPE_NONE;
1820 wv_title->help = Qnil;
1821 wv_title->next = wv_sep1;
1822 first_wv->contents = wv_title;
1825 /* No selection has been chosen yet. */
1826 menu_item_selection = 0;
1828 /* Make sure to free the widget_value objects we used to specify the
1829 contents even with longjmp. */
1830 record_unwind_protect (cleanup_widget_value_tree,
1831 make_save_value (first_wv, 0));
1833 /* Actually create and show the menu until popped down. */
1834 create_and_show_popup_menu (f, first_wv, x, y, for_click, timestamp);
1836 unbind_to (specpdl_count, Qnil);
1838 /* Find the selected item, and its pane, to return
1839 the proper value. */
1840 if (menu_item_selection != 0)
1842 Lisp_Object prefix, entry;
1844 prefix = entry = Qnil;
1845 i = 0;
1846 while (i < menu_items_used)
1848 if (EQ (XVECTOR (menu_items)->contents[i], Qnil))
1850 subprefix_stack[submenu_depth++] = prefix;
1851 prefix = entry;
1852 i++;
1854 else if (EQ (XVECTOR (menu_items)->contents[i], Qlambda))
1856 prefix = subprefix_stack[--submenu_depth];
1857 i++;
1859 else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
1861 prefix
1862 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
1863 i += MENU_ITEMS_PANE_LENGTH;
1865 /* Ignore a nil in the item list.
1866 It's meaningful only for dialog boxes. */
1867 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
1868 i += 1;
1869 else
1871 entry
1872 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
1873 if (menu_item_selection == &XVECTOR (menu_items)->contents[i])
1875 if (keymaps != 0)
1877 int j;
1879 entry = Fcons (entry, Qnil);
1880 if (!NILP (prefix))
1881 entry = Fcons (prefix, entry);
1882 for (j = submenu_depth - 1; j >= 0; j--)
1883 if (!NILP (subprefix_stack[j]))
1884 entry = Fcons (subprefix_stack[j], entry);
1886 return entry;
1888 i += MENU_ITEMS_ITEM_LENGTH;
1892 else if (!for_click)
1893 /* Make "Cancel" equivalent to C-g. */
1894 Fsignal (Qquit, Qnil);
1896 return Qnil;
1899 #ifdef USE_GTK
1900 static void
1901 dialog_selection_callback (GtkWidget *widget, gpointer client_data)
1903 /* Treat the pointer as an integer. There's no problem
1904 as long as pointers have enough bits to hold small integers. */
1905 if ((intptr_t) client_data != -1)
1906 menu_item_selection = (Lisp_Object *) client_data;
1908 popup_activated_flag = 0;
1911 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1912 dialog pops down.
1913 menu_item_selection will be set to the selection. */
1914 static void
1915 create_and_show_dialog (FRAME_PTR f, widget_value *first_wv)
1917 GtkWidget *menu;
1919 if (! FRAME_X_P (f))
1920 abort ();
1922 menu = xg_create_widget ("dialog", first_wv->name, f, first_wv,
1923 G_CALLBACK (dialog_selection_callback),
1924 G_CALLBACK (popup_deactivate_callback),
1927 if (menu)
1929 int specpdl_count = SPECPDL_INDEX ();
1930 record_unwind_protect (pop_down_menu, make_save_value (menu, 0));
1932 /* Display the menu. */
1933 gtk_widget_show_all (menu);
1935 /* Process events that apply to the menu. */
1936 popup_widget_loop (1, menu);
1938 unbind_to (specpdl_count, Qnil);
1942 #else /* not USE_GTK */
1943 static void
1944 dialog_selection_callback (Widget widget, LWLIB_ID id, XtPointer client_data)
1946 /* Treat the pointer as an integer. There's no problem
1947 as long as pointers have enough bits to hold small integers. */
1948 if ((intptr_t) client_data != -1)
1949 menu_item_selection = (Lisp_Object *) client_data;
1951 BLOCK_INPUT;
1952 lw_destroy_all_widgets (id);
1953 UNBLOCK_INPUT;
1954 popup_activated_flag = 0;
1958 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
1959 dialog pops down.
1960 menu_item_selection will be set to the selection. */
1961 static void
1962 create_and_show_dialog (FRAME_PTR f, widget_value *first_wv)
1964 LWLIB_ID dialog_id;
1966 if (!FRAME_X_P (f))
1967 abort ();
1969 dialog_id = widget_id_tick++;
1970 #ifdef USE_LUCID
1971 apply_systemfont_to_dialog (f->output_data.x->widget);
1972 #endif
1973 lw_create_widget (first_wv->name, "dialog", dialog_id, first_wv,
1974 f->output_data.x->widget, 1, 0,
1975 dialog_selection_callback, 0, 0);
1976 lw_modify_all_widgets (dialog_id, first_wv->contents, True);
1977 /* Display the dialog box. */
1978 lw_pop_up_all_widgets (dialog_id);
1979 popup_activated_flag = 1;
1980 x_activate_timeout_atimer ();
1982 /* Process events that apply to the dialog box.
1983 Also handle timers. */
1985 int count = SPECPDL_INDEX ();
1986 int fact = 4 * sizeof (LWLIB_ID);
1988 /* xdialog_show_unwind is responsible for popping the dialog box down. */
1989 record_unwind_protect (pop_down_menu,
1990 Fcons (make_number (dialog_id >> (fact)),
1991 make_number (dialog_id & ~(-1 << (fact)))));
1993 popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f),
1994 dialog_id, 1);
1996 unbind_to (count, Qnil);
2000 #endif /* not USE_GTK */
2002 static const char * button_names [] = {
2003 "button1", "button2", "button3", "button4", "button5",
2004 "button6", "button7", "button8", "button9", "button10" };
2006 static Lisp_Object
2007 xdialog_show (FRAME_PTR f,
2008 int keymaps,
2009 Lisp_Object title,
2010 Lisp_Object header,
2011 const char **error_name)
2013 int i, nb_buttons=0;
2014 char dialog_name[6];
2016 widget_value *wv, *first_wv = 0, *prev_wv = 0;
2018 /* Number of elements seen so far, before boundary. */
2019 int left_count = 0;
2020 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2021 int boundary_seen = 0;
2023 int specpdl_count = SPECPDL_INDEX ();
2025 if (! FRAME_X_P (f))
2026 abort ();
2028 *error_name = NULL;
2030 if (menu_items_n_panes > 1)
2032 *error_name = "Multiple panes in dialog box";
2033 return Qnil;
2036 /* Create a tree of widget_value objects
2037 representing the text label and buttons. */
2039 Lisp_Object pane_name, prefix;
2040 const char *pane_string;
2041 pane_name = XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_NAME];
2042 prefix = XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_PREFIX];
2043 pane_string = (NILP (pane_name)
2044 ? "" : SSDATA (pane_name));
2045 prev_wv = xmalloc_widget_value ();
2046 prev_wv->value = pane_string;
2047 if (keymaps && !NILP (prefix))
2048 prev_wv->name++;
2049 prev_wv->enabled = 1;
2050 prev_wv->name = "message";
2051 prev_wv->help = Qnil;
2052 first_wv = prev_wv;
2054 /* Loop over all panes and items, filling in the tree. */
2055 i = MENU_ITEMS_PANE_LENGTH;
2056 while (i < menu_items_used)
2059 /* Create a new item within current pane. */
2060 Lisp_Object item_name, enable, descrip;
2061 item_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_NAME];
2062 enable = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_ENABLE];
2063 descrip
2064 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_EQUIV_KEY];
2066 if (NILP (item_name))
2068 free_menubar_widget_value_tree (first_wv);
2069 *error_name = "Submenu in dialog items";
2070 return Qnil;
2072 if (EQ (item_name, Qquote))
2074 /* This is the boundary between left-side elts
2075 and right-side elts. Stop incrementing right_count. */
2076 boundary_seen = 1;
2077 i++;
2078 continue;
2080 if (nb_buttons >= 9)
2082 free_menubar_widget_value_tree (first_wv);
2083 *error_name = "Too many dialog items";
2084 return Qnil;
2087 wv = xmalloc_widget_value ();
2088 prev_wv->next = wv;
2089 wv->name = (char *) button_names[nb_buttons];
2090 if (!NILP (descrip))
2091 wv->key = SSDATA (descrip);
2092 wv->value = SSDATA (item_name);
2093 wv->call_data = (void *) &XVECTOR (menu_items)->contents[i];
2094 wv->enabled = !NILP (enable);
2095 wv->help = Qnil;
2096 prev_wv = wv;
2098 if (! boundary_seen)
2099 left_count++;
2101 nb_buttons++;
2102 i += MENU_ITEMS_ITEM_LENGTH;
2105 /* If the boundary was not specified,
2106 by default put half on the left and half on the right. */
2107 if (! boundary_seen)
2108 left_count = nb_buttons - nb_buttons / 2;
2110 wv = xmalloc_widget_value ();
2111 wv->name = dialog_name;
2112 wv->help = Qnil;
2114 /* Frame title: 'Q' = Question, 'I' = Information.
2115 Can also have 'E' = Error if, one day, we want
2116 a popup for errors. */
2117 if (NILP (header))
2118 dialog_name[0] = 'Q';
2119 else
2120 dialog_name[0] = 'I';
2122 /* Dialog boxes use a really stupid name encoding
2123 which specifies how many buttons to use
2124 and how many buttons are on the right. */
2125 dialog_name[1] = '0' + nb_buttons;
2126 dialog_name[2] = 'B';
2127 dialog_name[3] = 'R';
2128 /* Number of buttons to put on the right. */
2129 dialog_name[4] = '0' + nb_buttons - left_count;
2130 dialog_name[5] = 0;
2131 wv->contents = first_wv;
2132 first_wv = wv;
2135 /* No selection has been chosen yet. */
2136 menu_item_selection = 0;
2138 /* Make sure to free the widget_value objects we used to specify the
2139 contents even with longjmp. */
2140 record_unwind_protect (cleanup_widget_value_tree,
2141 make_save_value (first_wv, 0));
2143 /* Actually create and show the dialog. */
2144 create_and_show_dialog (f, first_wv);
2146 unbind_to (specpdl_count, Qnil);
2148 /* Find the selected item, and its pane, to return
2149 the proper value. */
2150 if (menu_item_selection != 0)
2152 Lisp_Object prefix;
2154 prefix = Qnil;
2155 i = 0;
2156 while (i < menu_items_used)
2158 Lisp_Object entry;
2160 if (EQ (XVECTOR (menu_items)->contents[i], Qt))
2162 prefix
2163 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
2164 i += MENU_ITEMS_PANE_LENGTH;
2166 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
2168 /* This is the boundary between left-side elts and
2169 right-side elts. */
2170 ++i;
2172 else
2174 entry
2175 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
2176 if (menu_item_selection == &XVECTOR (menu_items)->contents[i])
2178 if (keymaps != 0)
2180 entry = Fcons (entry, Qnil);
2181 if (!NILP (prefix))
2182 entry = Fcons (prefix, entry);
2184 return entry;
2186 i += MENU_ITEMS_ITEM_LENGTH;
2190 else
2191 /* Make "Cancel" equivalent to C-g. */
2192 Fsignal (Qquit, Qnil);
2194 return Qnil;
2197 #else /* not USE_X_TOOLKIT && not USE_GTK */
2199 /* The frame of the last activated non-toolkit menu bar.
2200 Used to generate menu help events. */
2202 static struct frame *menu_help_frame;
2205 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2207 PANE is the pane number, and ITEM is the menu item number in
2208 the menu (currently not used).
2210 This cannot be done with generating a HELP_EVENT because
2211 XMenuActivate contains a loop that doesn't let Emacs process
2212 keyboard events. */
2214 static void
2215 menu_help_callback (char const *help_string, int pane, int item)
2217 Lisp_Object *first_item;
2218 Lisp_Object pane_name;
2219 Lisp_Object menu_object;
2221 first_item = XVECTOR (menu_items)->contents;
2222 if (EQ (first_item[0], Qt))
2223 pane_name = first_item[MENU_ITEMS_PANE_NAME];
2224 else if (EQ (first_item[0], Qquote))
2225 /* This shouldn't happen, see xmenu_show. */
2226 pane_name = empty_unibyte_string;
2227 else
2228 pane_name = first_item[MENU_ITEMS_ITEM_NAME];
2230 /* (menu-item MENU-NAME PANE-NUMBER) */
2231 menu_object = Fcons (Qmenu_item,
2232 Fcons (pane_name,
2233 Fcons (make_number (pane), Qnil)));
2234 show_help_echo (help_string ? build_string (help_string) : Qnil,
2235 Qnil, menu_object, make_number (item));
2238 static Lisp_Object
2239 pop_down_menu (Lisp_Object arg)
2241 struct Lisp_Save_Value *p1 = XSAVE_VALUE (Fcar (arg));
2242 struct Lisp_Save_Value *p2 = XSAVE_VALUE (Fcdr (arg));
2244 FRAME_PTR f = p1->pointer;
2245 XMenu *menu = p2->pointer;
2247 BLOCK_INPUT;
2248 #ifndef MSDOS
2249 XUngrabPointer (FRAME_X_DISPLAY (f), CurrentTime);
2250 XUngrabKeyboard (FRAME_X_DISPLAY (f), CurrentTime);
2251 #endif
2252 XMenuDestroy (FRAME_X_DISPLAY (f), menu);
2254 #ifdef HAVE_X_WINDOWS
2255 /* Assume the mouse has moved out of the X window.
2256 If it has actually moved in, we will get an EnterNotify. */
2257 x_mouse_leave (FRAME_X_DISPLAY_INFO (f));
2259 /* State that no mouse buttons are now held.
2260 (The oldXMenu code doesn't track this info for us.)
2261 That is not necessarily true, but the fiction leads to reasonable
2262 results, and it is a pain to ask which are actually held now. */
2263 FRAME_X_DISPLAY_INFO (f)->grabbed = 0;
2265 #endif /* HAVE_X_WINDOWS */
2267 UNBLOCK_INPUT;
2269 return Qnil;
2273 Lisp_Object
2274 xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
2275 Lisp_Object title, const char **error_name, Time timestamp)
2277 Window root;
2278 XMenu *menu;
2279 int pane, selidx, lpane, status;
2280 Lisp_Object entry, pane_prefix;
2281 char *datap;
2282 int ulx, uly, width, height;
2283 int dispwidth, dispheight;
2284 int i, j, lines, maxlines;
2285 int maxwidth;
2286 int dummy_int;
2287 unsigned int dummy_uint;
2288 int specpdl_count = SPECPDL_INDEX ();
2290 if (! FRAME_X_P (f) && ! FRAME_MSDOS_P (f))
2291 abort ();
2293 *error_name = 0;
2294 if (menu_items_n_panes == 0)
2295 return Qnil;
2297 if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)
2299 *error_name = "Empty menu";
2300 return Qnil;
2303 /* Figure out which root window F is on. */
2304 XGetGeometry (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &root,
2305 &dummy_int, &dummy_int, &dummy_uint, &dummy_uint,
2306 &dummy_uint, &dummy_uint);
2308 /* Make the menu on that window. */
2309 menu = XMenuCreate (FRAME_X_DISPLAY (f), root, "emacs");
2310 if (menu == NULL)
2312 *error_name = "Can't create menu";
2313 return Qnil;
2316 /* Don't GC while we prepare and show the menu,
2317 because we give the oldxmenu library pointers to the
2318 contents of strings. */
2319 inhibit_garbage_collection ();
2321 #ifdef HAVE_X_WINDOWS
2322 /* Adjust coordinates to relative to the outer (window manager) window. */
2323 x += FRAME_OUTER_TO_INNER_DIFF_X (f);
2324 y += FRAME_OUTER_TO_INNER_DIFF_Y (f);
2325 #endif /* HAVE_X_WINDOWS */
2327 /* Adjust coordinates to be root-window-relative. */
2328 x += f->left_pos;
2329 y += f->top_pos;
2331 /* Create all the necessary panes and their items. */
2332 maxwidth = maxlines = lines = i = 0;
2333 lpane = XM_FAILURE;
2334 while (i < menu_items_used)
2336 if (EQ (XVECTOR (menu_items)->contents[i], Qt))
2338 /* Create a new pane. */
2339 Lisp_Object pane_name, prefix;
2340 const char *pane_string;
2342 maxlines = max (maxlines, lines);
2343 lines = 0;
2344 pane_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_NAME];
2345 prefix = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
2346 pane_string = (NILP (pane_name)
2347 ? "" : SSDATA (pane_name));
2348 if (keymaps && !NILP (prefix))
2349 pane_string++;
2351 lpane = XMenuAddPane (FRAME_X_DISPLAY (f), menu, pane_string, TRUE);
2352 if (lpane == XM_FAILURE)
2354 XMenuDestroy (FRAME_X_DISPLAY (f), menu);
2355 *error_name = "Can't create pane";
2356 return Qnil;
2358 i += MENU_ITEMS_PANE_LENGTH;
2360 /* Find the width of the widest item in this pane. */
2361 j = i;
2362 while (j < menu_items_used)
2364 Lisp_Object item;
2365 item = XVECTOR (menu_items)->contents[j];
2366 if (EQ (item, Qt))
2367 break;
2368 if (NILP (item))
2370 j++;
2371 continue;
2373 width = SBYTES (item);
2374 if (width > maxwidth)
2375 maxwidth = width;
2377 j += MENU_ITEMS_ITEM_LENGTH;
2380 /* Ignore a nil in the item list.
2381 It's meaningful only for dialog boxes. */
2382 else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
2383 i += 1;
2384 else
2386 /* Create a new item within current pane. */
2387 Lisp_Object item_name, enable, descrip, help;
2388 char *item_data;
2389 char const *help_string;
2391 item_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_NAME];
2392 enable = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_ENABLE];
2393 descrip
2394 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_EQUIV_KEY];
2395 help = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_HELP];
2396 help_string = STRINGP (help) ? SSDATA (help) : NULL;
2398 if (!NILP (descrip))
2400 /* if alloca is fast, use that to make the space,
2401 to reduce gc needs. */
2402 item_data = (char *) alloca (maxwidth + SBYTES (descrip) + 1);
2403 memcpy (item_data, SSDATA (item_name), SBYTES (item_name));
2404 for (j = SCHARS (item_name); j < maxwidth; j++)
2405 item_data[j] = ' ';
2406 memcpy (item_data + j, SSDATA (descrip), SBYTES (descrip));
2407 item_data[j + SBYTES (descrip)] = 0;
2409 else
2410 item_data = SSDATA (item_name);
2412 if (lpane == XM_FAILURE
2413 || (XMenuAddSelection (FRAME_X_DISPLAY (f),
2414 menu, lpane, 0, item_data,
2415 !NILP (enable), help_string)
2416 == XM_FAILURE))
2418 XMenuDestroy (FRAME_X_DISPLAY (f), menu);
2419 *error_name = "Can't add selection to menu";
2420 return Qnil;
2422 i += MENU_ITEMS_ITEM_LENGTH;
2423 lines++;
2427 maxlines = max (maxlines, lines);
2429 /* All set and ready to fly. */
2430 XMenuRecompute (FRAME_X_DISPLAY (f), menu);
2431 dispwidth = DisplayWidth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
2432 dispheight = DisplayHeight (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
2433 x = min (x, dispwidth);
2434 y = min (y, dispheight);
2435 x = max (x, 1);
2436 y = max (y, 1);
2437 XMenuLocate (FRAME_X_DISPLAY (f), menu, 0, 0, x, y,
2438 &ulx, &uly, &width, &height);
2439 if (ulx+width > dispwidth)
2441 x -= (ulx + width) - dispwidth;
2442 ulx = dispwidth - width;
2444 if (uly+height > dispheight)
2446 y -= (uly + height) - dispheight;
2447 uly = dispheight - height;
2449 #ifndef HAVE_X_WINDOWS
2450 if (FRAME_HAS_MINIBUF_P (f) && uly+height > dispheight - 1)
2452 /* Move the menu away of the echo area, to avoid overwriting the
2453 menu with help echo messages or vice versa. */
2454 if (BUFFERP (echo_area_buffer[0]) && WINDOWP (echo_area_window))
2456 y -= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window));
2457 uly -= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window));
2459 else
2461 y--;
2462 uly--;
2465 #endif
2466 if (ulx < 0) x -= ulx;
2467 if (uly < 0) y -= uly;
2469 if (! for_click)
2471 /* If position was not given by a mouse click, adjust so upper left
2472 corner of the menu as a whole ends up at given coordinates. This
2473 is what x-popup-menu says in its documentation. */
2474 x += width/2;
2475 y += 1.5*height/(maxlines+2);
2478 XMenuSetAEQ (menu, TRUE);
2479 XMenuSetFreeze (menu, TRUE);
2480 pane = selidx = 0;
2482 #ifndef MSDOS
2483 XMenuActivateSetWaitFunction (x_menu_wait_for_event, FRAME_X_DISPLAY (f));
2484 #endif
2486 record_unwind_protect (pop_down_menu,
2487 Fcons (make_save_value (f, 0),
2488 make_save_value (menu, 0)));
2490 /* Help display under X won't work because XMenuActivate contains
2491 a loop that doesn't give Emacs a chance to process it. */
2492 menu_help_frame = f;
2493 status = XMenuActivate (FRAME_X_DISPLAY (f), menu, &pane, &selidx,
2494 x, y, ButtonReleaseMask, &datap,
2495 menu_help_callback);
2496 entry = pane_prefix = Qnil;
2498 switch (status)
2500 case XM_SUCCESS:
2501 #ifdef XDEBUG
2502 fprintf (stderr, "pane= %d line = %d\n", panes, selidx);
2503 #endif
2505 /* Find the item number SELIDX in pane number PANE. */
2506 i = 0;
2507 while (i < menu_items_used)
2509 if (EQ (XVECTOR (menu_items)->contents[i], Qt))
2511 if (pane == 0)
2512 pane_prefix
2513 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
2514 pane--;
2515 i += MENU_ITEMS_PANE_LENGTH;
2517 else
2519 if (pane == -1)
2521 if (selidx == 0)
2523 entry
2524 = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
2525 if (keymaps != 0)
2527 entry = Fcons (entry, Qnil);
2528 if (!NILP (pane_prefix))
2529 entry = Fcons (pane_prefix, entry);
2531 break;
2533 selidx--;
2535 i += MENU_ITEMS_ITEM_LENGTH;
2538 break;
2540 case XM_FAILURE:
2541 *error_name = "Can't activate menu";
2542 case XM_IA_SELECT:
2543 break;
2544 case XM_NO_SELECT:
2545 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2546 the menu was invoked with a mouse event as POSITION). */
2547 if (! for_click)
2548 Fsignal (Qquit, Qnil);
2549 break;
2552 unbind_to (specpdl_count, Qnil);
2554 return entry;
2557 #endif /* not USE_X_TOOLKIT */
2559 #endif /* HAVE_MENUS */
2561 #ifndef MSDOS
2562 /* Detect if a dialog or menu has been posted. MSDOS has its own
2563 implementation on msdos.c. */
2566 popup_activated (void)
2568 return popup_activated_flag;
2570 #endif /* not MSDOS */
2572 /* The following is used by delayed window autoselection. */
2574 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_p, 0, 0, 0,
2575 doc: /* Return t if a menu or popup dialog is active. */)
2576 (void)
2578 #ifdef HAVE_MENUS
2579 return (popup_activated ()) ? Qt : Qnil;
2580 #else
2581 return Qnil;
2582 #endif /* HAVE_MENUS */
2585 void
2586 syms_of_xmenu (void)
2588 DEFSYM (Qdebug_on_next_call, "debug-on-next-call");
2590 #ifdef USE_X_TOOLKIT
2591 widget_id_tick = (1<<16);
2592 next_menubar_widget_id = 1;
2593 #endif
2595 defsubr (&Smenu_or_popup_active_p);
2597 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2598 defsubr (&Sx_menu_bar_open_internal);
2599 Ffset (intern_c_string ("accelerate-menu"),
2600 intern_c_string (Sx_menu_bar_open_internal.symbol_name));
2601 #endif
2603 #ifdef HAVE_MENUS
2604 defsubr (&Sx_popup_dialog);
2605 #endif