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 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>
85 #include <X11/Xaw3d/Paned.h>
86 #else /* !HAVE_XAW3D */
87 #include <X11/Xaw/Paned.h>
88 #endif /* HAVE_XAW3D */
89 #endif /* USE_LUCID */
90 #include "../lwlib/lwlib.h"
91 #else /* not USE_X_TOOLKIT */
93 #include "../oldXMenu/XMenu.h"
95 #endif /* not USE_X_TOOLKIT */
96 #endif /* HAVE_X_WINDOWS */
109 Lisp_Object Qdebug_on_next_call
;
111 extern Lisp_Object Vmenu_updating_frame
;
113 extern Lisp_Object Qmenu_bar
;
115 extern Lisp_Object QCtoggle
, QCradio
;
117 extern Lisp_Object Voverriding_local_map
;
118 extern Lisp_Object Voverriding_local_map_menu_flag
;
120 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
122 extern Lisp_Object Qmenu_bar_update_hook
;
125 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
126 extern XtAppContext Xt_app_con
;
128 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
130 static void popup_get_selection
P_ ((XEvent
*, struct x_display_info
*,
132 #endif /* USE_X_TOOLKIT */
135 extern void set_frame_menubar
P_ ((FRAME_PTR
, int, int));
136 static Lisp_Object xdialog_show
P_ ((FRAME_PTR
, int, Lisp_Object
, Lisp_Object
,
140 static int update_frame_menubar
P_ ((struct frame
*));
141 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
142 Lisp_Object
, char **));
144 /* Flag which when set indicates a dialog or menu has been posted by
145 Xt on behalf of one of the widget sets. */
146 static int popup_activated_flag
;
148 static int next_menubar_widget_id
;
150 /* For NS and NTGUI, these prototypes are defined in keyboard.h. */
151 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
152 extern widget_value
*xmalloc_widget_value
P_ ((void));
153 extern widget_value
*digest_single_submenu
P_ ((int, int, int));
156 /* This is set nonzero after the user activates the menu bar, and set
157 to zero again after the menu bars are redisplayed by prepare_menu_bar.
158 While it is nonzero, all calls to set_frame_menubar go deep.
160 I don't understand why this is needed, but it does seem to be
161 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
163 int pending_menu_activation
;
167 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
169 static struct frame
*
170 menubar_id_to_frame (id
)
173 Lisp_Object tail
, frame
;
176 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
182 if (!FRAME_WINDOW_P (f
))
184 if (f
->output_data
.x
->id
== id
)
192 #ifdef HAVE_X_WINDOWS
193 /* Return the mouse position in *X and *Y. The coordinates are window
194 relative for the edit window in frame F.
195 This is for Fx_popup_menu. The mouse_position_hook can not
196 be used for X, as it returns window relative coordinates
197 for the window where the mouse is in. This could be the menu bar,
198 the scroll bar or the edit window. Fx_popup_menu needs to be
199 sure it is the edit window. */
201 mouse_position_for_popup (f
, x
, y
)
206 Window root
, dummy_window
;
214 XQueryPointer (FRAME_X_DISPLAY (f
),
215 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
217 /* The root window which contains the pointer. */
220 /* Window pointer is on, not used */
223 /* The position on that root window. */
226 /* x/y in dummy_window coordinates, not used. */
229 /* Modifier keys and pointer buttons, about which
231 (unsigned int *) &dummy
);
235 /* xmenu_show expects window coordinates, not root window
236 coordinates. Translate. */
237 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
238 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
241 #endif /* HAVE_X_WINDOWS */
243 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
244 doc
: /* Pop up a deck-of-cards menu and return user's selection.
245 POSITION is a position specification. This is either a mouse button event
246 or a list ((XOFFSET YOFFSET) WINDOW)
247 where XOFFSET and YOFFSET are positions in pixels from the top left
248 corner of WINDOW. (WINDOW may be a window or a frame object.)
249 This controls the position of the top left of the menu as a whole.
250 If POSITION is t, it means to use the current mouse position.
252 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.
253 The menu items come from key bindings that have a menu string as well as
254 a definition; actually, the "definition" in such a key binding looks like
255 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into
256 the keymap as a top-level element.
258 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.
259 Otherwise, REAL-DEFINITION should be a valid key binding definition.
261 You can also use a list of keymaps as MENU.
262 Then each keymap makes a separate pane.
264 When MENU is a keymap or a list of keymaps, the return value is the
265 list of events corresponding to the user's choice. Note that
266 `x-popup-menu' does not actually execute the command bound to that
269 Alternatively, you can specify a menu of multiple panes
270 with a list of the form (TITLE PANE1 PANE2...),
271 where each pane is a list of form (TITLE ITEM1 ITEM2...).
272 Each ITEM is normally a cons cell (STRING . VALUE);
273 but a string can appear as an item--that makes a nonselectable line
275 With this form of menu, the return value is VALUE from the chosen item.
277 If POSITION is nil, don't display the menu at all, just precalculate the
278 cached information about equivalent key sequences.
280 If the user gets rid of the menu without making a valid choice, for
281 instance by clicking the mouse away from a valid choice or by typing
282 keyboard input, then this normally results in a quit and
283 `x-popup-menu' does not return. But if POSITION is a mouse button
284 event (indicating that the user invoked the menu with the mouse) then
285 no quit occurs and `x-popup-menu' returns nil. */)
287 Lisp_Object position
, menu
;
289 Lisp_Object keymap
, tem
;
290 int xpos
= 0, ypos
= 0;
292 char *error_name
= NULL
;
293 Lisp_Object selection
= Qnil
;
295 Lisp_Object x
, y
, window
;
298 int specpdl_count
= SPECPDL_INDEX ();
302 if (! NILP (position
))
304 int get_current_pos_p
= 0;
307 /* Decode the first argument: find the window and the coordinates. */
308 if (EQ (position
, Qt
)
309 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
310 || EQ (XCAR (position
), Qtool_bar
))))
312 get_current_pos_p
= 1;
316 tem
= Fcar (position
);
319 window
= Fcar (Fcdr (position
));
321 y
= Fcar (XCDR (tem
));
326 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
327 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
328 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
333 /* If a click happens in an external tool bar or a detached
334 tool bar, x and y is NIL. In that case, use the current
335 mouse position. This happens for the help button in the
336 tool bar. Ideally popup-menu should pass NIL to
337 this function, but it doesn't. */
338 if (NILP (x
) && NILP (y
))
339 get_current_pos_p
= 1;
342 if (get_current_pos_p
)
344 /* Use the mouse's current position. */
345 FRAME_PTR new_f
= SELECTED_FRAME ();
346 #ifdef HAVE_X_WINDOWS
347 /* Can't use mouse_position_hook for X since it returns
348 coordinates relative to the window the mouse is in,
349 we need coordinates relative to the edit widget always. */
354 mouse_position_for_popup (new_f
, &cur_x
, &cur_y
);
355 /* cur_x/y may be negative, so use make_number. */
356 x
= make_number (cur_x
);
357 y
= make_number (cur_y
);
360 #else /* not HAVE_X_WINDOWS */
361 Lisp_Object bar_window
;
362 enum scroll_bar_part part
;
364 void (*mouse_position_hook
) P_ ((struct frame
**, int,
366 enum scroll_bar_part
*,
370 new_f
->terminal
->mouse_position_hook
;
372 if (mouse_position_hook
)
373 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
374 &part
, &x
, &y
, &time
);
375 #endif /* not HAVE_X_WINDOWS */
378 XSETFRAME (window
, new_f
);
381 window
= selected_window
;
390 /* Decode where to put the menu. */
398 else if (WINDOWP (window
))
400 CHECK_LIVE_WINDOW (window
);
401 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
403 xpos
= WINDOW_LEFT_EDGE_X (XWINDOW (window
));
404 ypos
= WINDOW_TOP_EDGE_Y (XWINDOW (window
));
407 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
408 but I don't want to make one now. */
409 CHECK_WINDOW (window
);
414 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
415 error ("Can not put X menu on this terminal");
417 XSETFRAME (Vmenu_updating_frame
, f
);
420 Vmenu_updating_frame
= Qnil
;
421 #endif /* HAVE_MENUS */
423 record_unwind_protect (unuse_menu_items
, Qnil
);
427 /* Decode the menu items from what was specified. */
429 keymap
= get_keymap (menu
, 0, 0);
432 /* We were given a keymap. Extract menu info from the keymap. */
435 /* Extract the detailed info to make one pane. */
436 keymap_panes (&menu
, 1, NILP (position
));
438 /* Search for a string appearing directly as an element of the keymap.
439 That string is the title of the menu. */
440 prompt
= Fkeymap_prompt (keymap
);
441 if (NILP (title
) && !NILP (prompt
))
444 /* Make that be the pane title of the first pane. */
445 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
446 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
450 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
452 /* We were given a list of keymaps. */
453 int nmaps
= XFASTINT (Flength (menu
));
455 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
460 /* The first keymap that has a prompt string
461 supplies the menu title. */
462 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= XCDR (tem
))
466 maps
[i
++] = keymap
= get_keymap (XCAR (tem
), 1, 0);
468 prompt
= Fkeymap_prompt (keymap
);
469 if (NILP (title
) && !NILP (prompt
))
473 /* Extract the detailed info to make one pane. */
474 keymap_panes (maps
, nmaps
, NILP (position
));
476 /* Make the title be the pane title of the first pane. */
477 if (!NILP (title
) && menu_items_n_panes
>= 0)
478 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
484 /* We were given an old-fashioned menu. */
486 CHECK_STRING (title
);
488 list_of_panes (Fcdr (menu
));
493 unbind_to (specpdl_count
, Qnil
);
497 discard_menu_items ();
503 /* Display them in a menu. */
506 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
507 keymaps
, title
, &error_name
);
510 discard_menu_items ();
513 #endif /* HAVE_MENUS */
515 if (error_name
) error (error_name
);
521 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 3, 0,
522 doc
: /* Pop up a dialog box and return user's selection.
523 POSITION specifies which frame to use.
524 This is normally a mouse button event or a window or frame.
525 If POSITION is t, it means to use the frame the mouse is on.
526 The dialog box appears in the middle of the specified frame.
528 CONTENTS specifies the alternatives to display in the dialog box.
529 It is a list of the form (DIALOG ITEM1 ITEM2...).
530 Each ITEM is a cons cell (STRING . VALUE).
531 The return value is VALUE from the chosen item.
533 An ITEM may also be just a string--that makes a nonselectable item.
534 An ITEM may also be nil--that means to put all preceding items
535 on the left of the dialog box and all following items on the right.
536 \(By default, approximately half appear on each side.)
538 If HEADER is non-nil, the frame title for the box is "Information",
539 otherwise it is "Question".
541 If the user gets rid of the dialog box without making a valid choice,
542 for instance using the window manager, then this produces a quit and
543 `x-popup-dialog' does not return. */)
544 (position
, contents
, header
)
545 Lisp_Object position
, contents
, header
;
552 /* Decode the first argument: find the window or frame to use. */
553 if (EQ (position
, Qt
)
554 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
555 || EQ (XCAR (position
), Qtool_bar
))))
557 #if 0 /* Using the frame the mouse is on may not be right. */
558 /* Use the mouse's current position. */
559 FRAME_PTR new_f
= SELECTED_FRAME ();
560 Lisp_Object bar_window
;
561 enum scroll_bar_part part
;
565 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
568 XSETFRAME (window
, new_f
);
570 window
= selected_window
;
572 window
= selected_window
;
574 else if (CONSP (position
))
577 tem
= Fcar (position
);
579 window
= Fcar (Fcdr (position
));
582 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
583 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
586 else if (WINDOWP (position
) || FRAMEP (position
))
591 /* Decode where to put the menu. */
595 else if (WINDOWP (window
))
597 CHECK_LIVE_WINDOW (window
);
598 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
601 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
602 but I don't want to make one now. */
603 CHECK_WINDOW (window
);
605 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
606 error ("Can not put X dialog on this terminal");
608 /* Force a redisplay before showing the dialog. If a frame is created
609 just before showing the dialog, its contents may not have been fully
610 drawn, as this depends on timing of events from the X server. Redisplay
611 is not done when a dialog is shown. If redisplay could be done in the
612 X event loop (i.e. the X event loop does not run in a signal handler)
613 this would not be needed.
615 Do this before creating the widget value that points to Lisp
616 string contents, because Fredisplay may GC and relocate them. */
619 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
620 /* Display a menu with these alternatives
621 in the middle of frame F. */
623 Lisp_Object x
, y
, frame
, newpos
;
624 XSETFRAME (frame
, f
);
625 XSETINT (x
, x_pixel_width (f
) / 2);
626 XSETINT (y
, x_pixel_height (f
) / 2);
627 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
629 return Fx_popup_menu (newpos
,
630 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
636 Lisp_Object selection
;
637 int specpdl_count
= SPECPDL_INDEX ();
639 /* Decode the dialog items from what was specified. */
640 title
= Fcar (contents
);
641 CHECK_STRING (title
);
642 record_unwind_protect (unuse_menu_items
, Qnil
);
644 if (NILP (Fcar (Fcdr (contents
))))
645 /* No buttons specified, add an "Ok" button so users can pop down
646 the dialog. Also, the lesstif/motif version crashes if there are
648 contents
= Fcons (title
, Fcons (Fcons (build_string ("Ok"), Qt
), Qnil
));
650 list_of_panes (Fcons (contents
, Qnil
));
652 /* Display them in a dialog box. */
654 selection
= xdialog_show (f
, 0, title
, header
, &error_name
);
657 unbind_to (specpdl_count
, Qnil
);
658 discard_menu_items ();
660 if (error_name
) error (error_name
);
669 /* Set menu_items_inuse so no other popup menu or dialog is created. */
672 x_menu_set_in_use (in_use
)
675 menu_items_inuse
= in_use
? Qt
: Qnil
;
676 popup_activated_flag
= in_use
;
678 if (popup_activated_flag
)
679 x_activate_timeout_atimer ();
683 /* Wait for an X event to arrive or for a timer to expire. */
686 x_menu_wait_for_event (void *data
)
688 extern EMACS_TIME timer_check
P_ ((int));
690 /* Another way to do this is to register a timer callback, that can be
691 done in GTK and Xt. But we have to do it like this when using only X
692 anyway, and with callbacks we would have three variants for timer handling
693 instead of the small ifdefs below. */
697 ! XtAppPending (Xt_app_con
)
698 #elif defined USE_GTK
699 ! gtk_events_pending ()
701 ! XPending ((Display
*) data
)
705 EMACS_TIME next_time
= timer_check (1);
706 long secs
= EMACS_SECS (next_time
);
707 long usecs
= EMACS_USECS (next_time
);
708 SELECT_TYPE read_fds
;
709 struct x_display_info
*dpyinfo
;
713 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
715 int fd
= ConnectionNumber (dpyinfo
->display
);
716 FD_SET (fd
, &read_fds
);
720 if (secs
< 0 || (secs
== 0 && usecs
== 0))
722 /* Sometimes timer_check returns -1 (no timers) even if there are
723 timers. So do a timeout anyway. */
724 EMACS_SET_SECS (next_time
, 1);
725 EMACS_SET_USECS (next_time
, 0);
728 select (n
+ 1, &read_fds
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0, &next_time
);
734 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
738 /* Loop in Xt until the menu pulldown or dialog popup has been
739 popped down (deactivated). This is used for x-popup-menu
740 and x-popup-dialog; it is not used for the menu bar.
742 NOTE: All calls to popup_get_selection should be protected
743 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
746 popup_get_selection (initial_event
, dpyinfo
, id
, do_timers
)
747 XEvent
*initial_event
;
748 struct x_display_info
*dpyinfo
;
754 while (popup_activated_flag
)
758 event
= *initial_event
;
763 if (do_timers
) x_menu_wait_for_event (0);
764 XtAppNextEvent (Xt_app_con
, &event
);
767 /* Make sure we don't consider buttons grabbed after menu goes.
768 And make sure to deactivate for any ButtonRelease,
769 even if XtDispatchEvent doesn't do that. */
770 if (event
.type
== ButtonRelease
771 && dpyinfo
->display
== event
.xbutton
.display
)
773 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
774 #ifdef USE_MOTIF /* Pretending that the event came from a
775 Btn1Down seems the only way to convince Motif to
776 activate its callbacks; setting the XmNmenuPost
777 isn't working. --marcus@sysc.pdx.edu. */
778 event
.xbutton
.button
= 1;
779 /* Motif only pops down menus when no Ctrl, Alt or Mod
780 key is pressed and the button is released. So reset key state
781 so Motif thinks this is the case. */
782 event
.xbutton
.state
= 0;
785 /* Pop down on C-g and Escape. */
786 else if (event
.type
== KeyPress
787 && dpyinfo
->display
== event
.xbutton
.display
)
789 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
791 if ((keysym
== XK_g
&& (event
.xkey
.state
& ControlMask
) != 0)
792 || keysym
== XK_Escape
) /* Any escape, ignore modifiers. */
793 popup_activated_flag
= 0;
796 x_dispatch_event (&event
, event
.xany
.display
);
800 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
801 doc
: /* Start key navigation of the menu bar in FRAME.
802 This initially opens the first menu bar item and you can then navigate with the
803 arrow keys, select a menu entry with the return key or cancel with the
804 escape key. If FRAME has no menu bar this function does nothing.
806 If FRAME is nil or not given, use the selected frame. */)
811 FRAME_PTR f
= check_x_frame (frame
);
815 if (FRAME_EXTERNAL_MENU_BAR (f
))
816 set_frame_menubar (f
, 0, 1);
818 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
824 x_catch_errors (FRAME_X_DISPLAY (f
));
825 memset (&ev
, 0, sizeof ev
);
826 ev
.xbutton
.display
= FRAME_X_DISPLAY (f
);
827 ev
.xbutton
.window
= XtWindow (menubar
);
828 ev
.xbutton
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
829 ev
.xbutton
.time
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
830 ev
.xbutton
.button
= Button1
;
831 ev
.xbutton
.x
= ev
.xbutton
.y
= FRAME_MENUBAR_HEIGHT (f
) / 2;
832 ev
.xbutton
.same_screen
= True
;
839 XtSetArg (al
[0], XtNchildren
, &list
);
840 XtSetArg (al
[1], XtNnumChildren
, &nr
);
841 XtGetValues (menubar
, al
, 2);
842 ev
.xbutton
.window
= XtWindow (list
[0]);
846 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
847 /* From-window, to-window. */
848 ev
.xbutton
.window
, ev
.xbutton
.root
,
850 /* From-position, to-position. */
851 ev
.xbutton
.x
, ev
.xbutton
.y
,
852 &ev
.xbutton
.x_root
, &ev
.xbutton
.y_root
,
856 error_p
= x_had_errors_p (FRAME_X_DISPLAY (f
));
861 ev
.type
= ButtonPress
;
862 ev
.xbutton
.state
= 0;
864 XtDispatchEvent (&ev
);
865 ev
.xbutton
.type
= ButtonRelease
;
866 ev
.xbutton
.state
= Button1Mask
;
867 XtDispatchEvent (&ev
);
875 #endif /* USE_X_TOOLKIT */
879 DEFUN ("x-menu-bar-open-internal", Fx_menu_bar_open_internal
, Sx_menu_bar_open_internal
, 0, 1, "i",
880 doc
: /* Start key navigation of the menu bar in FRAME.
881 This initially opens the first menu bar item and you can then navigate with the
882 arrow keys, select a menu entry with the return key or cancel with the
883 escape key. If FRAME has no menu bar this function does nothing.
885 If FRAME is nil or not given, use the selected frame. */)
892 /* gcc 2.95 doesn't accept the FRAME_PTR declaration after
896 f
= check_x_frame (frame
);
898 if (FRAME_EXTERNAL_MENU_BAR (f
))
899 set_frame_menubar (f
, 0, 1);
901 menubar
= FRAME_X_OUTPUT (f
)->menubar_widget
;
904 /* Activate the first menu. */
905 GList
*children
= gtk_container_get_children (GTK_CONTAINER (menubar
));
909 g_signal_emit_by_name (children
->data
, "activate_item");
910 popup_activated_flag
= 1;
911 g_list_free (children
);
919 /* Loop util popup_activated_flag is set to zero in a callback.
920 Used for popup menus and dialogs. */
923 popup_widget_loop (do_timers
, widget
)
927 ++popup_activated_flag
;
929 /* Process events in the Gtk event loop until done. */
930 while (popup_activated_flag
)
932 if (do_timers
) x_menu_wait_for_event (0);
933 gtk_main_iteration ();
938 /* Activate the menu bar of frame F.
939 This is called from keyboard.c when it gets the
940 MENU_BAR_ACTIVATE_EVENT out of the Emacs event queue.
942 To activate the menu bar, we use the X button-press event
943 that was saved in saved_menu_event.
944 That makes the toolkit do its thing.
946 But first we recompute the menu bar contents (the whole tree).
948 The reason for saving the button event until here, instead of
949 passing it to the toolkit right away, is that we can safely
950 execute Lisp code. */
953 x_activate_menubar (f
)
959 if (!f
->output_data
.x
->saved_menu_event
->type
)
963 if (! xg_win_to_widget (FRAME_X_DISPLAY (f
),
964 f
->output_data
.x
->saved_menu_event
->xany
.window
))
968 set_frame_menubar (f
, 0, 1);
971 XPutBackEvent (f
->output_data
.x
->display_info
->display
,
972 f
->output_data
.x
->saved_menu_event
);
973 popup_activated_flag
= 1;
975 XtDispatchEvent (f
->output_data
.x
->saved_menu_event
);
979 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
980 pending_menu_activation
= 1;
983 /* Ignore this if we get it a second time. */
984 f
->output_data
.x
->saved_menu_event
->type
= 0;
987 /* This callback is invoked when the user selects a menubar cascade
988 pushbutton, but before the pulldown menu is posted. */
992 popup_activate_callback (widget
, id
, client_data
)
995 XtPointer client_data
;
997 popup_activated_flag
= 1;
999 x_activate_timeout_atimer ();
1004 /* This callback is invoked when a dialog or menu is finished being
1005 used and has been unposted. */
1009 popup_deactivate_callback (widget
, client_data
)
1011 gpointer client_data
;
1013 popup_activated_flag
= 0;
1017 popup_deactivate_callback (widget
, id
, client_data
)
1020 XtPointer client_data
;
1022 popup_activated_flag
= 0;
1027 /* Function that finds the frame for WIDGET and shows the HELP text
1029 F is the frame if known, or NULL if not known. */
1031 show_help_event (f
, widget
, help
)
1033 xt_or_gtk_widget widget
;
1040 XSETFRAME (frame
, f
);
1041 kbd_buffer_store_help_event (frame
, help
);
1045 #if 0 /* This code doesn't do anything useful. ++kfs */
1046 /* WIDGET is the popup menu. It's parent is the frame's
1047 widget. See which frame that is. */
1048 xt_or_gtk_widget frame_widget
= XtParent (widget
);
1051 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1053 frame
= XCAR (tail
);
1055 && (f
= XFRAME (frame
),
1056 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1060 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1064 /* Callback called when menu items are highlighted/unhighlighted
1065 while moving the mouse over them. WIDGET is the menu bar or menu
1066 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1067 the data structure for the menu item, or null in case of
1072 menu_highlight_callback (widget
, call_data
)
1076 xg_menu_item_cb_data
*cb_data
;
1079 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (widget
),
1081 if (! cb_data
) return;
1083 help
= call_data
? cb_data
->help
: Qnil
;
1085 /* If popup_activated_flag is greater than 1 we are in a popup menu.
1086 Don't show help for them, they won't appear before the
1087 popup is popped down. */
1088 if (popup_activated_flag
<= 1)
1089 show_help_event (cb_data
->cl_data
->f
, widget
, help
);
1093 menu_highlight_callback (widget
, id
, call_data
)
1101 widget_value
*wv
= (widget_value
*) call_data
;
1103 help
= wv
? wv
->help
: Qnil
;
1105 /* Determine the frame for the help event. */
1106 f
= menubar_id_to_frame (id
);
1108 show_help_event (f
, widget
, help
);
1113 /* Gtk calls callbacks just because we tell it what item should be
1114 selected in a radio group. If this variable is set to a non-zero
1115 value, we are creating menus and don't want callbacks right now.
1117 static int xg_crazy_callback_abort
;
1119 /* This callback is called from the menu bar pulldown menu
1120 when the user makes a selection.
1121 Figure out what the user chose
1122 and put the appropriate events into the keyboard buffer. */
1124 menubar_selection_callback (widget
, client_data
)
1126 gpointer client_data
;
1128 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1130 if (xg_crazy_callback_abort
)
1133 if (! cb_data
|| ! cb_data
->cl_data
|| ! cb_data
->cl_data
->f
)
1136 /* For a group of radio buttons, GTK calls the selection callback first
1137 for the item that was active before the selection and then for the one that
1138 is active after the selection. For C-h k this means we get the help on
1139 the deselected item and then the selected item is executed. Prevent that
1140 by ignoring the non-active item. */
1141 if (GTK_IS_RADIO_MENU_ITEM (widget
)
1142 && ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget
)))
1145 /* When a menu is popped down, X generates a focus event (i.e. focus
1146 goes back to the frame below the menu). Since GTK buffers events,
1147 we force it out here before the menu selection event. Otherwise
1148 sit-for will exit at once if the focus event follows the menu selection
1152 while (gtk_events_pending ())
1153 gtk_main_iteration ();
1156 find_and_call_menu_selection (cb_data
->cl_data
->f
,
1157 cb_data
->cl_data
->menu_bar_items_used
,
1158 cb_data
->cl_data
->menu_bar_vector
,
1159 cb_data
->call_data
);
1162 #else /* not USE_GTK */
1164 /* This callback is called from the menu bar pulldown menu
1165 when the user makes a selection.
1166 Figure out what the user chose
1167 and put the appropriate events into the keyboard buffer. */
1169 menubar_selection_callback (widget
, id
, client_data
)
1172 XtPointer client_data
;
1176 f
= menubar_id_to_frame (id
);
1179 find_and_call_menu_selection (f
, f
->menu_bar_items_used
,
1180 f
->menu_bar_vector
, client_data
);
1182 #endif /* not USE_GTK */
1184 /* Recompute all the widgets of frame F, when the menu bar has been
1185 changed. Value is non-zero if widgets were updated. */
1188 update_frame_menubar (f
)
1192 return xg_update_frame_menubar (f
);
1197 if (! FRAME_X_P (f
))
1200 x
= f
->output_data
.x
;
1202 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1206 /* Save the size of the frame because the pane widget doesn't accept
1207 to resize itself. So force it. */
1208 columns
= FRAME_COLS (f
);
1209 rows
= FRAME_LINES (f
);
1211 /* Do the voodoo which means "I'm changing lots of things, don't try
1212 to refigure sizes until I'm done." */
1213 lw_refigure_widget (x
->column_widget
, False
);
1215 /* The order in which children are managed is the top to bottom
1216 order in which they are displayed in the paned window. First,
1217 remove the text-area widget. */
1218 XtUnmanageChild (x
->edit_widget
);
1220 /* Remove the menubar that is there now, and put up the menubar that
1222 XtManageChild (x
->menubar_widget
);
1223 XtMapWidget (x
->menubar_widget
);
1224 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1226 /* Re-manage the text-area widget, and then thrash the sizes. */
1227 XtManageChild (x
->edit_widget
);
1228 lw_refigure_widget (x
->column_widget
, True
);
1230 /* Force the pane widget to resize itself with the right values. */
1231 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1237 /* Set the contents of the menubar widgets of frame F.
1238 The argument FIRST_TIME is currently ignored;
1239 it is set the first time this is called, from initialize_frame_menubar. */
1242 set_frame_menubar (f
, first_time
, deep_p
)
1247 xt_or_gtk_widget menubar_widget
;
1248 #ifdef USE_X_TOOLKIT
1252 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1254 int *submenu_start
, *submenu_end
;
1255 int *submenu_top_level_items
, *submenu_n_panes
;
1257 if (! FRAME_X_P (f
))
1260 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1262 XSETFRAME (Vmenu_updating_frame
, f
);
1264 #ifdef USE_X_TOOLKIT
1265 if (f
->output_data
.x
->id
== 0)
1266 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1267 id
= f
->output_data
.x
->id
;
1270 if (! menubar_widget
)
1272 else if (pending_menu_activation
&& !deep_p
)
1274 /* Make the first call for any given frame always go deep. */
1275 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1278 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1279 f
->output_data
.x
->saved_menu_event
->type
= 0;
1283 /* If we have detached menus, we must update deep so detached menus
1284 also gets updated. */
1285 deep_p
= deep_p
|| xg_have_tear_offs ();
1290 /* Make a widget-value tree representing the entire menu trees. */
1292 struct buffer
*prev
= current_buffer
;
1294 int specpdl_count
= SPECPDL_INDEX ();
1295 int previous_menu_items_used
= f
->menu_bar_items_used
;
1296 Lisp_Object
*previous_items
1297 = (Lisp_Object
*) alloca (previous_menu_items_used
1298 * sizeof (Lisp_Object
));
1300 /* If we are making a new widget, its contents are empty,
1301 do always reinitialize them. */
1302 if (! menubar_widget
)
1303 previous_menu_items_used
= 0;
1305 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1306 specbind (Qinhibit_quit
, Qt
);
1307 /* Don't let the debugger step into this code
1308 because it is not reentrant. */
1309 specbind (Qdebug_on_next_call
, Qnil
);
1311 record_unwind_save_match_data ();
1312 if (NILP (Voverriding_local_map_menu_flag
))
1314 specbind (Qoverriding_terminal_local_map
, Qnil
);
1315 specbind (Qoverriding_local_map
, Qnil
);
1318 set_buffer_internal_1 (XBUFFER (buffer
));
1320 /* Run the Lucid hook. */
1321 safe_run_hooks (Qactivate_menubar_hook
);
1323 /* If it has changed current-menubar from previous value,
1324 really recompute the menubar from the value. */
1325 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1326 call0 (Qrecompute_lucid_menubar
);
1327 safe_run_hooks (Qmenu_bar_update_hook
);
1328 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1330 items
= FRAME_MENU_BAR_ITEMS (f
);
1332 /* Save the frame's previous menu bar contents data. */
1333 if (previous_menu_items_used
)
1334 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1335 previous_menu_items_used
* sizeof (Lisp_Object
));
1337 /* Fill in menu_items with the current menu bar contents.
1338 This can evaluate Lisp code. */
1341 menu_items
= f
->menu_bar_vector
;
1342 menu_items_allocated
= VECTORP (menu_items
) ? ASIZE (menu_items
) : 0;
1343 submenu_start
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1344 submenu_end
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1345 submenu_n_panes
= (int *) alloca (XVECTOR (items
)->size
* sizeof (int));
1346 submenu_top_level_items
1347 = (int *) alloca (XVECTOR (items
)->size
* sizeof (int *));
1349 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1351 Lisp_Object key
, string
, maps
;
1355 key
= XVECTOR (items
)->contents
[i
];
1356 string
= XVECTOR (items
)->contents
[i
+ 1];
1357 maps
= XVECTOR (items
)->contents
[i
+ 2];
1361 submenu_start
[i
] = menu_items_used
;
1363 menu_items_n_panes
= 0;
1364 submenu_top_level_items
[i
]
1365 = parse_single_submenu (key
, string
, maps
);
1366 submenu_n_panes
[i
] = menu_items_n_panes
;
1368 submenu_end
[i
] = menu_items_used
;
1371 finish_menu_items ();
1373 /* Convert menu_items into widget_value trees
1374 to display the menu. This cannot evaluate Lisp code. */
1376 wv
= xmalloc_widget_value ();
1377 wv
->name
= "menubar";
1380 wv
->button_type
= BUTTON_TYPE_NONE
;
1384 for (i
= 0; i
< last_i
; i
+= 4)
1386 menu_items_n_panes
= submenu_n_panes
[i
];
1387 wv
= digest_single_submenu (submenu_start
[i
], submenu_end
[i
],
1388 submenu_top_level_items
[i
]);
1392 first_wv
->contents
= wv
;
1393 /* Don't set wv->name here; GC during the loop might relocate it. */
1395 wv
->button_type
= BUTTON_TYPE_NONE
;
1399 set_buffer_internal_1 (prev
);
1401 /* If there has been no change in the Lisp-level contents
1402 of the menu bar, skip redisplaying it. Just exit. */
1404 /* Compare the new menu items with the ones computed last time. */
1405 for (i
= 0; i
< previous_menu_items_used
; i
++)
1406 if (menu_items_used
== i
1407 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1409 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1411 /* The menu items have not changed. Don't bother updating
1412 the menus in any form, since it would be a no-op. */
1413 free_menubar_widget_value_tree (first_wv
);
1414 discard_menu_items ();
1415 unbind_to (specpdl_count
, Qnil
);
1419 /* The menu items are different, so store them in the frame. */
1420 f
->menu_bar_vector
= menu_items
;
1421 f
->menu_bar_items_used
= menu_items_used
;
1423 /* This undoes save_menu_items. */
1424 unbind_to (specpdl_count
, Qnil
);
1426 /* Now GC cannot happen during the lifetime of the widget_value,
1427 so it's safe to store data from a Lisp_String. */
1428 wv
= first_wv
->contents
;
1429 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1432 string
= XVECTOR (items
)->contents
[i
+ 1];
1435 wv
->name
= (char *) SDATA (string
);
1436 update_submenu_strings (wv
->contents
);
1443 /* Make a widget-value tree containing
1444 just the top level menu bar strings. */
1446 wv
= xmalloc_widget_value ();
1447 wv
->name
= "menubar";
1450 wv
->button_type
= BUTTON_TYPE_NONE
;
1454 items
= FRAME_MENU_BAR_ITEMS (f
);
1455 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1459 string
= XVECTOR (items
)->contents
[i
+ 1];
1463 wv
= xmalloc_widget_value ();
1464 wv
->name
= (char *) SDATA (string
);
1467 wv
->button_type
= BUTTON_TYPE_NONE
;
1469 /* This prevents lwlib from assuming this
1470 menu item is really supposed to be empty. */
1471 /* The EMACS_INT cast avoids a warning.
1472 This value just has to be different from small integers. */
1473 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1478 first_wv
->contents
= wv
;
1482 /* Forget what we thought we knew about what is in the
1483 detailed contents of the menu bar menus.
1484 Changing the top level always destroys the contents. */
1485 f
->menu_bar_items_used
= 0;
1488 /* Create or update the menu bar widget. */
1493 xg_crazy_callback_abort
= 1;
1496 /* The fourth arg is DEEP_P, which says to consider the entire
1497 menu trees we supply, rather than just the menu bar item names. */
1498 xg_modify_menubar_widgets (menubar_widget
,
1502 G_CALLBACK (menubar_selection_callback
),
1503 G_CALLBACK (popup_deactivate_callback
),
1504 G_CALLBACK (menu_highlight_callback
));
1508 GtkWidget
*wvbox
= f
->output_data
.x
->vbox_widget
;
1511 = xg_create_widget ("menubar", "menubar", f
, first_wv
,
1512 G_CALLBACK (menubar_selection_callback
),
1513 G_CALLBACK (popup_deactivate_callback
),
1514 G_CALLBACK (menu_highlight_callback
));
1516 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1520 #else /* not USE_GTK */
1523 /* Disable resizing (done for Motif!) */
1524 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1526 /* The third arg is DEEP_P, which says to consider the entire
1527 menu trees we supply, rather than just the menu bar item names. */
1528 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1530 /* Re-enable the edit widget to resize. */
1531 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1535 char menuOverride
[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
1536 XtTranslations override
= XtParseTranslationTable (menuOverride
);
1538 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1539 f
->output_data
.x
->column_widget
,
1541 popup_activate_callback
,
1542 menubar_selection_callback
,
1543 popup_deactivate_callback
,
1544 menu_highlight_callback
);
1545 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1547 /* Make menu pop down on C-g. */
1548 XtOverrideTranslations (menubar_widget
, override
);
1553 = (f
->output_data
.x
->menubar_widget
1554 ? (f
->output_data
.x
->menubar_widget
->core
.height
1555 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1558 #if 0 /* Experimentally, we now get the right results
1559 for -geometry -0-0 without this. 24 Aug 96, rms. */
1561 if (FRAME_EXTERNAL_MENU_BAR (f
))
1564 XtVaGetValues (f
->output_data
.x
->column_widget
,
1565 XtNinternalBorderWidth
, &ibw
, NULL
);
1566 menubar_size
+= ibw
;
1568 #endif /* USE_LUCID */
1571 f
->output_data
.x
->menubar_height
= menubar_size
;
1573 #endif /* not USE_GTK */
1575 free_menubar_widget_value_tree (first_wv
);
1576 update_frame_menubar (f
);
1579 xg_crazy_callback_abort
= 0;
1585 /* Called from Fx_create_frame to create the initial menubar of a frame
1586 before it is mapped, so that the window is mapped with the menubar already
1587 there instead of us tacking it on later and thrashing the window after it
1591 initialize_frame_menubar (f
)
1594 /* This function is called before the first chance to redisplay
1595 the frame. It has to be, so the frame will have the right size. */
1596 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1597 set_frame_menubar (f
, 1, 1);
1601 /* Get rid of the menu bar of frame F, and free its storage.
1602 This is used when deleting a frame, and when turning off the menu bar.
1603 For GTK this function is in gtkutil.c. */
1607 free_frame_menubar (f
)
1610 Widget menubar_widget
;
1612 if (! FRAME_X_P (f
))
1615 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1617 f
->output_data
.x
->menubar_height
= 0;
1622 /* Removing the menu bar magically changes the shell widget's x
1623 and y position of (0, 0) which, when the menu bar is turned
1624 on again, leads to pull-down menuss appearing in strange
1625 positions near the upper-left corner of the display. This
1626 happens only with some window managers like twm and ctwm,
1627 but not with other like Motif's mwm or kwm, because the
1628 latter generate ConfigureNotify events when the menu bar
1629 is switched off, which fixes the shell position. */
1630 Position x0
, y0
, x1
, y1
;
1636 if (f
->output_data
.x
->widget
)
1637 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1640 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1641 f
->output_data
.x
->menubar_widget
= NULL
;
1644 if (f
->output_data
.x
->widget
)
1646 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1647 if (x1
== 0 && y1
== 0)
1648 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1655 #endif /* not USE_GTK */
1657 #endif /* USE_X_TOOLKIT || USE_GTK */
1659 /* xmenu_show actually displays a menu using the panes and items in menu_items
1660 and returns the value selected from it.
1661 There are two versions of xmenu_show, one for Xt and one for Xlib.
1662 Both assume input is blocked by the caller. */
1664 /* F is the frame the menu is for.
1665 X and Y are the frame-relative specified position,
1666 relative to the inside upper left corner of the frame F.
1667 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1668 KEYMAPS is 1 if this menu was specified with keymaps;
1669 in that case, we return a list containing the chosen item's value
1670 and perhaps also the pane's prefix.
1671 TITLE is the specified menu title.
1672 ERROR is a place to store an error message string in case of failure.
1673 (We return nil on failure, but the value doesn't actually matter.) */
1675 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1677 /* The item selected in the popup menu. */
1678 static Lisp_Object
*volatile menu_item_selection
;
1682 /* Used when position a popup menu. See menu_position_func and
1683 create_and_show_popup_menu below. */
1684 struct next_popup_x_y
1691 /* The menu position function to use if we are not putting a popup
1692 menu where the pointer is.
1693 MENU is the menu to pop up.
1694 X and Y shall on exit contain x/y where the menu shall pop up.
1695 PUSH_IN is not documented in the GTK manual.
1696 USER_DATA is any data passed in when calling gtk_menu_popup.
1697 Here it points to a struct next_popup_x_y where the coordinates
1698 to store in *X and *Y are as well as the frame for the popup.
1700 Here only X and Y are used. */
1702 menu_position_func (menu
, x
, y
, push_in
, user_data
)
1709 struct next_popup_x_y
* data
= (struct next_popup_x_y
*)user_data
;
1711 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (data
->f
);
1712 int disp_width
= x_display_pixel_width (dpyinfo
);
1713 int disp_height
= x_display_pixel_height (dpyinfo
);
1718 /* Check if there is room for the menu. If not, adjust x/y so that
1719 the menu is fully visible. */
1720 gtk_widget_size_request (GTK_WIDGET (menu
), &req
);
1721 if (data
->x
+ req
.width
> disp_width
)
1722 *x
-= data
->x
+ req
.width
- disp_width
;
1723 if (data
->y
+ req
.height
> disp_height
)
1724 *y
-= data
->y
+ req
.height
- disp_height
;
1728 popup_selection_callback (widget
, client_data
)
1730 gpointer client_data
;
1732 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) client_data
;
1734 if (xg_crazy_callback_abort
) return;
1735 if (cb_data
) menu_item_selection
= (Lisp_Object
*) cb_data
->call_data
;
1742 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1744 popup_activated_flag
= 0;
1746 gtk_widget_destroy (GTK_WIDGET (p
->pointer
));
1751 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1753 menu_item_selection will be set to the selection. */
1755 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
1757 widget_value
*first_wv
;
1764 GtkMenuPositionFunc pos_func
= 0; /* Pop up at pointer. */
1765 struct next_popup_x_y popup_x_y
;
1766 int specpdl_count
= SPECPDL_INDEX ();
1768 if (! FRAME_X_P (f
))
1771 xg_crazy_callback_abort
= 1;
1772 menu
= xg_create_widget ("popup", first_wv
->name
, f
, first_wv
,
1773 G_CALLBACK (popup_selection_callback
),
1774 G_CALLBACK (popup_deactivate_callback
),
1775 G_CALLBACK (menu_highlight_callback
));
1776 xg_crazy_callback_abort
= 0;
1780 /* Not invoked by a click. pop up at x/y. */
1781 pos_func
= menu_position_func
;
1783 /* Adjust coordinates to be root-window-relative. */
1784 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1785 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1791 i
= 0; /* gtk_menu_popup needs this to be 0 for a non-button popup. */
1795 for (i
= 0; i
< 5; i
++)
1796 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1800 /* Display the menu. */
1801 gtk_widget_show_all (menu
);
1802 gtk_menu_popup (GTK_MENU (menu
), 0, 0, pos_func
, &popup_x_y
, i
, 0);
1804 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
1806 if (GTK_WIDGET_MAPPED (menu
))
1808 /* Set this to one. popup_widget_loop increases it by one, so it becomes
1809 two. show_help_echo uses this to detect popup menus. */
1810 popup_activated_flag
= 1;
1811 /* Process events that apply to the menu. */
1812 popup_widget_loop (1, menu
);
1815 unbind_to (specpdl_count
, Qnil
);
1817 /* Must reset this manually because the button release event is not passed
1818 to Emacs event loop. */
1819 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
1822 #else /* not USE_GTK */
1824 /* We need a unique id for each widget handled by the Lucid Widget
1827 For the main windows, and popup menus, we use this counter,
1828 which we increment each time after use. This starts from 1<<16.
1830 For menu bars, we use numbers starting at 0, counted in
1831 next_menubar_widget_id. */
1832 LWLIB_ID widget_id_tick
;
1835 popup_selection_callback (widget
, id
, client_data
)
1838 XtPointer client_data
;
1840 menu_item_selection
= (Lisp_Object
*) client_data
;
1843 /* ARG is the LWLIB ID of the dialog box, represented
1844 as a Lisp object as (HIGHPART . LOWPART). */
1850 LWLIB_ID id
= (XINT (XCAR (arg
)) << 4 * sizeof (LWLIB_ID
)
1851 | XINT (XCDR (arg
)));
1854 lw_destroy_all_widgets (id
);
1856 popup_activated_flag
= 0;
1861 /* Pop up the menu for frame F defined by FIRST_WV at X/Y and loop until the
1863 menu_item_selection will be set to the selection. */
1865 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
)
1867 widget_value
*first_wv
;
1875 XButtonPressedEvent dummy
;
1879 if (! FRAME_X_P (f
))
1882 menu_id
= widget_id_tick
++;
1883 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1884 f
->output_data
.x
->widget
, 1, 0,
1885 popup_selection_callback
,
1886 popup_deactivate_callback
,
1887 menu_highlight_callback
);
1889 dummy
.type
= ButtonPress
;
1891 dummy
.send_event
= 0;
1892 dummy
.display
= FRAME_X_DISPLAY (f
);
1893 dummy
.time
= CurrentTime
;
1894 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
1895 dummy
.window
= dummy
.root
;
1896 dummy
.subwindow
= dummy
.root
;
1900 /* Adjust coordinates to be root-window-relative. */
1901 x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
1902 y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
1909 for (i
= 0; i
< 5; i
++)
1910 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
1913 /* Don't allow any geometry request from the user. */
1914 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
1915 XtSetValues (menu
, av
, ac
);
1917 /* Display the menu. */
1918 lw_popup_menu (menu
, (XEvent
*) &dummy
);
1919 popup_activated_flag
= 1;
1920 x_activate_timeout_atimer ();
1923 int fact
= 4 * sizeof (LWLIB_ID
);
1924 int specpdl_count
= SPECPDL_INDEX ();
1925 record_unwind_protect (pop_down_menu
,
1926 Fcons (make_number (menu_id
>> (fact
)),
1927 make_number (menu_id
& ~(-1 << (fact
)))));
1929 /* Process events that apply to the menu. */
1930 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
, 1);
1932 unbind_to (specpdl_count
, Qnil
);
1936 #endif /* not USE_GTK */
1939 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
1949 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1950 widget_value
**submenu_stack
1951 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1952 Lisp_Object
*subprefix_stack
1953 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1954 int submenu_depth
= 0;
1958 if (! FRAME_X_P (f
))
1963 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1965 *error
= "Empty menu";
1969 /* Create a tree of widget_value objects
1970 representing the panes and their items. */
1971 wv
= xmalloc_widget_value ();
1975 wv
->button_type
= BUTTON_TYPE_NONE
;
1980 /* Loop over all panes and items, filling in the tree. */
1982 while (i
< menu_items_used
)
1984 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1986 submenu_stack
[submenu_depth
++] = save_wv
;
1992 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1995 save_wv
= submenu_stack
[--submenu_depth
];
1999 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2000 && submenu_depth
!= 0)
2001 i
+= MENU_ITEMS_PANE_LENGTH
;
2002 /* Ignore a nil in the item list.
2003 It's meaningful only for dialog boxes. */
2004 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2006 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2008 /* Create a new pane. */
2009 Lisp_Object pane_name
, prefix
;
2012 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
2013 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
2015 #ifndef HAVE_MULTILINGUAL_MENU
2016 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2018 pane_name
= ENCODE_MENU_STRING (pane_name
);
2019 ASET (menu_items
, i
+ MENU_ITEMS_PANE_NAME
, pane_name
);
2022 pane_string
= (NILP (pane_name
)
2023 ? "" : (char *) SDATA (pane_name
));
2024 /* If there is just one top-level pane, put all its items directly
2025 under the top-level menu. */
2026 if (menu_items_n_panes
== 1)
2029 /* If the pane has a meaningful name,
2030 make the pane a top-level menu item
2031 with its items as a submenu beneath it. */
2032 if (!keymaps
&& strcmp (pane_string
, ""))
2034 wv
= xmalloc_widget_value ();
2038 first_wv
->contents
= wv
;
2039 wv
->name
= pane_string
;
2040 if (keymaps
&& !NILP (prefix
))
2044 wv
->button_type
= BUTTON_TYPE_NONE
;
2049 else if (first_pane
)
2055 i
+= MENU_ITEMS_PANE_LENGTH
;
2059 /* Create a new item within current pane. */
2060 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2061 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
2062 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
2063 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
2064 def
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_DEFINITION
);
2065 type
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_TYPE
);
2066 selected
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_SELECTED
);
2067 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
2069 #ifndef HAVE_MULTILINGUAL_MENU
2070 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2072 item_name
= ENCODE_MENU_STRING (item_name
);
2073 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
, item_name
);
2076 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2078 descrip
= ENCODE_MENU_STRING (descrip
);
2079 ASET (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
, descrip
);
2081 #endif /* not HAVE_MULTILINGUAL_MENU */
2083 wv
= xmalloc_widget_value ();
2087 save_wv
->contents
= wv
;
2088 wv
->name
= (char *) SDATA (item_name
);
2089 if (!NILP (descrip
))
2090 wv
->key
= (char *) SDATA (descrip
);
2092 /* If this item has a null value,
2093 make the call_data null so that it won't display a box
2094 when the mouse is on it. */
2096 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2097 wv
->enabled
= !NILP (enable
);
2100 wv
->button_type
= BUTTON_TYPE_NONE
;
2101 else if (EQ (type
, QCtoggle
))
2102 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2103 else if (EQ (type
, QCradio
))
2104 wv
->button_type
= BUTTON_TYPE_RADIO
;
2108 wv
->selected
= !NILP (selected
);
2110 if (! STRINGP (help
))
2117 i
+= MENU_ITEMS_ITEM_LENGTH
;
2121 /* Deal with the title, if it is non-nil. */
2124 widget_value
*wv_title
= xmalloc_widget_value ();
2125 widget_value
*wv_sep1
= xmalloc_widget_value ();
2126 widget_value
*wv_sep2
= xmalloc_widget_value ();
2128 wv_sep2
->name
= "--";
2129 wv_sep2
->next
= first_wv
->contents
;
2130 wv_sep2
->help
= Qnil
;
2132 wv_sep1
->name
= "--";
2133 wv_sep1
->next
= wv_sep2
;
2134 wv_sep1
->help
= Qnil
;
2136 #ifndef HAVE_MULTILINGUAL_MENU
2137 if (STRING_MULTIBYTE (title
))
2138 title
= ENCODE_MENU_STRING (title
);
2141 wv_title
->name
= (char *) SDATA (title
);
2142 wv_title
->enabled
= TRUE
;
2143 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2144 wv_title
->help
= Qnil
;
2145 wv_title
->next
= wv_sep1
;
2146 first_wv
->contents
= wv_title
;
2149 /* No selection has been chosen yet. */
2150 menu_item_selection
= 0;
2152 /* Actually create and show the menu until popped down. */
2153 create_and_show_popup_menu (f
, first_wv
, x
, y
, for_click
);
2155 /* Free the widget_value objects we used to specify the contents. */
2156 free_menubar_widget_value_tree (first_wv
);
2158 /* Find the selected item, and its pane, to return
2159 the proper value. */
2160 if (menu_item_selection
!= 0)
2162 Lisp_Object prefix
, entry
;
2164 prefix
= entry
= Qnil
;
2166 while (i
< menu_items_used
)
2168 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2170 subprefix_stack
[submenu_depth
++] = prefix
;
2174 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2176 prefix
= subprefix_stack
[--submenu_depth
];
2179 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2182 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2183 i
+= MENU_ITEMS_PANE_LENGTH
;
2185 /* Ignore a nil in the item list.
2186 It's meaningful only for dialog boxes. */
2187 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2192 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2193 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2199 entry
= Fcons (entry
, Qnil
);
2201 entry
= Fcons (prefix
, entry
);
2202 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2203 if (!NILP (subprefix_stack
[j
]))
2204 entry
= Fcons (subprefix_stack
[j
], entry
);
2208 i
+= MENU_ITEMS_ITEM_LENGTH
;
2212 else if (!for_click
)
2213 /* Make "Cancel" equivalent to C-g. */
2214 Fsignal (Qquit
, Qnil
);
2221 dialog_selection_callback (widget
, client_data
)
2223 gpointer client_data
;
2225 /* The EMACS_INT cast avoids a warning. There's no problem
2226 as long as pointers have enough bits to hold small integers. */
2227 if ((int) (EMACS_INT
) client_data
!= -1)
2228 menu_item_selection
= (Lisp_Object
*) client_data
;
2230 popup_activated_flag
= 0;
2233 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2235 menu_item_selection will be set to the selection. */
2237 create_and_show_dialog (f
, first_wv
)
2239 widget_value
*first_wv
;
2243 if (! FRAME_X_P (f
))
2246 menu
= xg_create_widget ("dialog", first_wv
->name
, f
, first_wv
,
2247 G_CALLBACK (dialog_selection_callback
),
2248 G_CALLBACK (popup_deactivate_callback
),
2253 int specpdl_count
= SPECPDL_INDEX ();
2254 record_unwind_protect (pop_down_menu
, make_save_value (menu
, 0));
2256 /* Display the menu. */
2257 gtk_widget_show_all (menu
);
2259 /* Process events that apply to the menu. */
2260 popup_widget_loop (1, menu
);
2262 unbind_to (specpdl_count
, Qnil
);
2266 #else /* not USE_GTK */
2268 dialog_selection_callback (widget
, id
, client_data
)
2271 XtPointer client_data
;
2273 /* The EMACS_INT cast avoids a warning. There's no problem
2274 as long as pointers have enough bits to hold small integers. */
2275 if ((int) (EMACS_INT
) client_data
!= -1)
2276 menu_item_selection
= (Lisp_Object
*) client_data
;
2279 lw_destroy_all_widgets (id
);
2281 popup_activated_flag
= 0;
2285 /* Pop up the dialog for frame F defined by FIRST_WV and loop until the
2287 menu_item_selection will be set to the selection. */
2289 create_and_show_dialog (f
, first_wv
)
2291 widget_value
*first_wv
;
2298 dialog_id
= widget_id_tick
++;
2299 lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2300 f
->output_data
.x
->widget
, 1, 0,
2301 dialog_selection_callback
, 0, 0);
2302 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2304 /* Display the dialog box. */
2305 lw_pop_up_all_widgets (dialog_id
);
2306 popup_activated_flag
= 1;
2307 x_activate_timeout_atimer ();
2309 /* Process events that apply to the dialog box.
2310 Also handle timers. */
2312 int count
= SPECPDL_INDEX ();
2313 int fact
= 4 * sizeof (LWLIB_ID
);
2315 /* xdialog_show_unwind is responsible for popping the dialog box down. */
2316 record_unwind_protect (pop_down_menu
,
2317 Fcons (make_number (dialog_id
>> (fact
)),
2318 make_number (dialog_id
& ~(-1 << (fact
)))));
2320 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
),
2323 unbind_to (count
, Qnil
);
2327 #endif /* not USE_GTK */
2329 static char * button_names
[] = {
2330 "button1", "button2", "button3", "button4", "button5",
2331 "button6", "button7", "button8", "button9", "button10" };
2334 xdialog_show (f
, keymaps
, title
, header
, error_name
)
2337 Lisp_Object title
, header
;
2340 int i
, nb_buttons
=0;
2341 char dialog_name
[6];
2343 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2345 /* Number of elements seen so far, before boundary. */
2347 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2348 int boundary_seen
= 0;
2350 if (! FRAME_X_P (f
))
2355 if (menu_items_n_panes
> 1)
2357 *error_name
= "Multiple panes in dialog box";
2361 /* Create a tree of widget_value objects
2362 representing the text label and buttons. */
2364 Lisp_Object pane_name
, prefix
;
2366 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2367 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2368 pane_string
= (NILP (pane_name
)
2369 ? "" : (char *) SDATA (pane_name
));
2370 prev_wv
= xmalloc_widget_value ();
2371 prev_wv
->value
= pane_string
;
2372 if (keymaps
&& !NILP (prefix
))
2374 prev_wv
->enabled
= 1;
2375 prev_wv
->name
= "message";
2376 prev_wv
->help
= Qnil
;
2379 /* Loop over all panes and items, filling in the tree. */
2380 i
= MENU_ITEMS_PANE_LENGTH
;
2381 while (i
< menu_items_used
)
2384 /* Create a new item within current pane. */
2385 Lisp_Object item_name
, enable
, descrip
;
2386 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2387 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2389 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2391 if (NILP (item_name
))
2393 free_menubar_widget_value_tree (first_wv
);
2394 *error_name
= "Submenu in dialog items";
2397 if (EQ (item_name
, Qquote
))
2399 /* This is the boundary between left-side elts
2400 and right-side elts. Stop incrementing right_count. */
2405 if (nb_buttons
>= 9)
2407 free_menubar_widget_value_tree (first_wv
);
2408 *error_name
= "Too many dialog items";
2412 wv
= xmalloc_widget_value ();
2414 wv
->name
= (char *) button_names
[nb_buttons
];
2415 if (!NILP (descrip
))
2416 wv
->key
= (char *) SDATA (descrip
);
2417 wv
->value
= (char *) SDATA (item_name
);
2418 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2419 wv
->enabled
= !NILP (enable
);
2423 if (! boundary_seen
)
2427 i
+= MENU_ITEMS_ITEM_LENGTH
;
2430 /* If the boundary was not specified,
2431 by default put half on the left and half on the right. */
2432 if (! boundary_seen
)
2433 left_count
= nb_buttons
- nb_buttons
/ 2;
2435 wv
= xmalloc_widget_value ();
2436 wv
->name
= dialog_name
;
2439 /* Frame title: 'Q' = Question, 'I' = Information.
2440 Can also have 'E' = Error if, one day, we want
2441 a popup for errors. */
2443 dialog_name
[0] = 'Q';
2445 dialog_name
[0] = 'I';
2447 /* Dialog boxes use a really stupid name encoding
2448 which specifies how many buttons to use
2449 and how many buttons are on the right. */
2450 dialog_name
[1] = '0' + nb_buttons
;
2451 dialog_name
[2] = 'B';
2452 dialog_name
[3] = 'R';
2453 /* Number of buttons to put on the right. */
2454 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2456 wv
->contents
= first_wv
;
2460 /* No selection has been chosen yet. */
2461 menu_item_selection
= 0;
2463 /* Actually create and show the dialog. */
2464 create_and_show_dialog (f
, first_wv
);
2466 /* Free the widget_value objects we used to specify the contents. */
2467 free_menubar_widget_value_tree (first_wv
);
2469 /* Find the selected item, and its pane, to return
2470 the proper value. */
2471 if (menu_item_selection
!= 0)
2477 while (i
< menu_items_used
)
2481 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2484 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2485 i
+= MENU_ITEMS_PANE_LENGTH
;
2487 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2489 /* This is the boundary between left-side elts and
2496 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2497 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2501 entry
= Fcons (entry
, Qnil
);
2503 entry
= Fcons (prefix
, entry
);
2507 i
+= MENU_ITEMS_ITEM_LENGTH
;
2512 /* Make "Cancel" equivalent to C-g. */
2513 Fsignal (Qquit
, Qnil
);
2518 #else /* not USE_X_TOOLKIT && not USE_GTK */
2520 /* The frame of the last activated non-toolkit menu bar.
2521 Used to generate menu help events. */
2523 static struct frame
*menu_help_frame
;
2526 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2528 PANE is the pane number, and ITEM is the menu item number in
2529 the menu (currently not used).
2531 This cannot be done with generating a HELP_EVENT because
2532 XMenuActivate contains a loop that doesn't let Emacs process
2536 menu_help_callback (help_string
, pane
, item
)
2540 extern Lisp_Object Qmenu_item
;
2541 Lisp_Object
*first_item
;
2542 Lisp_Object pane_name
;
2543 Lisp_Object menu_object
;
2545 first_item
= XVECTOR (menu_items
)->contents
;
2546 if (EQ (first_item
[0], Qt
))
2547 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2548 else if (EQ (first_item
[0], Qquote
))
2549 /* This shouldn't happen, see xmenu_show. */
2550 pane_name
= empty_unibyte_string
;
2552 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2554 /* (menu-item MENU-NAME PANE-NUMBER) */
2555 menu_object
= Fcons (Qmenu_item
,
2557 Fcons (make_number (pane
), Qnil
)));
2558 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2559 Qnil
, menu_object
, make_number (item
), 1);
2566 struct Lisp_Save_Value
*p1
= XSAVE_VALUE (Fcar (arg
));
2567 struct Lisp_Save_Value
*p2
= XSAVE_VALUE (Fcdr (arg
));
2569 FRAME_PTR f
= p1
->pointer
;
2570 XMenu
*menu
= p2
->pointer
;
2574 XUngrabPointer (FRAME_X_DISPLAY (f
), CurrentTime
);
2575 XUngrabKeyboard (FRAME_X_DISPLAY (f
), CurrentTime
);
2577 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2579 #ifdef HAVE_X_WINDOWS
2580 /* Assume the mouse has moved out of the X window.
2581 If it has actually moved in, we will get an EnterNotify. */
2582 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2584 /* State that no mouse buttons are now held.
2585 (The oldXMenu code doesn't track this info for us.)
2586 That is not necessarily true, but the fiction leads to reasonable
2587 results, and it is a pain to ask which are actually held now. */
2588 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2590 #endif /* HAVE_X_WINDOWS */
2599 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2609 int pane
, selidx
, lpane
, status
;
2610 Lisp_Object entry
, pane_prefix
;
2612 int ulx
, uly
, width
, height
;
2613 int dispwidth
, dispheight
;
2614 int i
, j
, lines
, maxlines
;
2617 unsigned int dummy_uint
;
2618 int specpdl_count
= SPECPDL_INDEX ();
2620 if (! FRAME_X_P (f
) && ! FRAME_MSDOS_P (f
))
2624 if (menu_items_n_panes
== 0)
2627 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2629 *error
= "Empty menu";
2633 /* Figure out which root window F is on. */
2634 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2635 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2636 &dummy_uint
, &dummy_uint
);
2638 /* Make the menu on that window. */
2639 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2642 *error
= "Can't create menu";
2646 /* Don't GC while we prepare and show the menu,
2647 because we give the oldxmenu library pointers to the
2648 contents of strings. */
2649 inhibit_garbage_collection ();
2651 #ifdef HAVE_X_WINDOWS
2652 /* Adjust coordinates to relative to the outer (window manager) window. */
2653 x
+= FRAME_OUTER_TO_INNER_DIFF_X (f
);
2654 y
+= FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2655 #endif /* HAVE_X_WINDOWS */
2657 /* Adjust coordinates to be root-window-relative. */
2661 /* Create all the necessary panes and their items. */
2662 maxlines
= lines
= i
= 0;
2663 while (i
< menu_items_used
)
2665 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2667 /* Create a new pane. */
2668 Lisp_Object pane_name
, prefix
;
2671 maxlines
= max (maxlines
, lines
);
2673 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2674 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2675 pane_string
= (NILP (pane_name
)
2676 ? "" : (char *) SDATA (pane_name
));
2677 if (keymaps
&& !NILP (prefix
))
2680 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2681 if (lpane
== XM_FAILURE
)
2683 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2684 *error
= "Can't create pane";
2687 i
+= MENU_ITEMS_PANE_LENGTH
;
2689 /* Find the width of the widest item in this pane. */
2692 while (j
< menu_items_used
)
2695 item
= XVECTOR (menu_items
)->contents
[j
];
2703 width
= SBYTES (item
);
2704 if (width
> maxwidth
)
2707 j
+= MENU_ITEMS_ITEM_LENGTH
;
2710 /* Ignore a nil in the item list.
2711 It's meaningful only for dialog boxes. */
2712 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2716 /* Create a new item within current pane. */
2717 Lisp_Object item_name
, enable
, descrip
, help
;
2718 unsigned char *item_data
;
2721 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2722 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2724 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2725 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2726 help_string
= STRINGP (help
) ? SDATA (help
) : NULL
;
2728 if (!NILP (descrip
))
2730 int gap
= maxwidth
- SBYTES (item_name
);
2731 /* if alloca is fast, use that to make the space,
2732 to reduce gc needs. */
2734 = (unsigned char *) alloca (maxwidth
2735 + SBYTES (descrip
) + 1);
2736 bcopy (SDATA (item_name
), item_data
,
2737 SBYTES (item_name
));
2738 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
2740 bcopy (SDATA (descrip
), item_data
+ j
,
2742 item_data
[j
+ SBYTES (descrip
)] = 0;
2745 item_data
= SDATA (item_name
);
2747 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2748 menu
, lpane
, 0, item_data
,
2749 !NILP (enable
), help_string
)
2752 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2753 *error
= "Can't add selection to menu";
2756 i
+= MENU_ITEMS_ITEM_LENGTH
;
2761 maxlines
= max (maxlines
, lines
);
2763 /* All set and ready to fly. */
2764 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2765 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2766 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
));
2767 x
= min (x
, dispwidth
);
2768 y
= min (y
, dispheight
);
2771 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2772 &ulx
, &uly
, &width
, &height
);
2773 if (ulx
+width
> dispwidth
)
2775 x
-= (ulx
+ width
) - dispwidth
;
2776 ulx
= dispwidth
- width
;
2778 if (uly
+height
> dispheight
)
2780 y
-= (uly
+ height
) - dispheight
;
2781 uly
= dispheight
- height
;
2783 #ifndef HAVE_X_WINDOWS
2784 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 1)
2786 /* Move the menu away of the echo area, to avoid overwriting the
2787 menu with help echo messages or vice versa. */
2788 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
2790 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2791 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
));
2800 if (ulx
< 0) x
-= ulx
;
2801 if (uly
< 0) y
-= uly
;
2805 /* If position was not given by a mouse click, adjust so upper left
2806 corner of the menu as a whole ends up at given coordinates. This
2807 is what x-popup-menu says in its documentation. */
2809 y
+= 1.5*height
/(maxlines
+2);
2812 XMenuSetAEQ (menu
, TRUE
);
2813 XMenuSetFreeze (menu
, TRUE
);
2817 XMenuActivateSetWaitFunction (x_menu_wait_for_event
, FRAME_X_DISPLAY (f
));
2820 record_unwind_protect (pop_down_menu
,
2821 Fcons (make_save_value (f
, 0),
2822 make_save_value (menu
, 0)));
2824 /* Help display under X won't work because XMenuActivate contains
2825 a loop that doesn't give Emacs a chance to process it. */
2826 menu_help_frame
= f
;
2827 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2828 x
, y
, ButtonReleaseMask
, &datap
,
2829 menu_help_callback
);
2835 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2838 /* Find the item number SELIDX in pane number PANE. */
2840 while (i
< menu_items_used
)
2842 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2846 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2848 i
+= MENU_ITEMS_PANE_LENGTH
;
2857 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2860 entry
= Fcons (entry
, Qnil
);
2861 if (!NILP (pane_prefix
))
2862 entry
= Fcons (pane_prefix
, entry
);
2868 i
+= MENU_ITEMS_ITEM_LENGTH
;
2874 *error
= "Can't activate menu";
2879 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
2880 the menu was invoked with a mouse event as POSITION). */
2882 Fsignal (Qquit
, Qnil
);
2887 unbind_to (specpdl_count
, Qnil
);
2892 #endif /* not USE_X_TOOLKIT */
2894 #endif /* HAVE_MENUS */
2896 /* Detect if a dialog or menu has been posted. */
2901 return popup_activated_flag
;
2904 /* The following is used by delayed window autoselection. */
2906 DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p
, Smenu_or_popup_active_p
, 0, 0, 0,
2907 doc
: /* Return t if a menu or popup dialog is active. */)
2911 return (popup_activated ()) ? Qt
: Qnil
;
2914 #endif /* HAVE_MENUS */
2920 Qdebug_on_next_call
= intern ("debug-on-next-call");
2921 staticpro (&Qdebug_on_next_call
);
2923 #ifdef USE_X_TOOLKIT
2924 widget_id_tick
= (1<<16);
2925 next_menubar_widget_id
= 1;
2928 defsubr (&Sx_popup_menu
);
2929 defsubr (&Smenu_or_popup_active_p
);
2931 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
2932 defsubr (&Sx_menu_bar_open_internal
);
2933 Ffset (intern ("accelerate-menu"),
2934 intern (Sx_menu_bar_open_internal
.symbol_name
));
2938 defsubr (&Sx_popup_dialog
);
2942 /* arch-tag: 92ea573c-398e-496e-ac73-2436f7d63242
2943 (do not change this comment) */