1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 88, 93, 94, 96, 99, 2000, 2001
3 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 2, or (at your option)
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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* X pop-up deck-of-cards menu facility for gnuemacs.
24 * Written by Jon Arnold and Roman Budzianowski
25 * Mods and rewrite by Robert Krawitz
29 /* Modified by Fred Pierresteguy on December 93
30 to make the popup menus and menubar use the Xt. */
32 /* Rewritten for clarity and GC protection by rms in Feb 94. */
36 /* On 4.3 this loses if it comes after xterm.h. */
41 #include "termhooks.h"
45 #include "blockinput.h"
53 /* This may include sys/types.h, and that somehow loses
54 if this is not done before the other system files. */
58 /* Load sys/types.h if not already loaded.
59 In some systems loading it twice is suicidal. */
61 #include <sys/types.h>
64 #include "dispextern.h"
67 #undef HAVE_MULTILINGUAL_MENU
71 #include <X11/IntrinsicP.h>
72 #include <X11/CoreP.h>
73 #include <X11/StringDefs.h>
74 #include <X11/Shell.h>
76 #include <X11/Xaw/Paned.h>
77 #endif /* USE_LUCID */
78 #include "../lwlib/lwlib.h"
79 #else /* not USE_X_TOOLKIT */
80 #include "../oldXMenu/XMenu.h"
81 #endif /* not USE_X_TOOLKIT */
82 #endif /* HAVE_X_WINDOWS */
84 #define min(x,y) (((x) < (y)) ? (x) : (y))
85 #define max(x,y) (((x) > (y)) ? (x) : (y))
92 Lisp_Object Vmenu_updating_frame
;
94 Lisp_Object Qdebug_on_next_call
;
96 extern Lisp_Object Qmenu_bar
;
97 extern Lisp_Object Qmouse_click
, Qevent_kind
;
99 extern Lisp_Object QCtoggle
, QCradio
;
101 extern Lisp_Object Voverriding_local_map
;
102 extern Lisp_Object Voverriding_local_map_menu_flag
;
104 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
106 extern Lisp_Object Qmenu_bar_update_hook
;
109 extern void set_frame_menubar ();
110 extern void process_expose_from_menu ();
111 extern XtAppContext Xt_app_con
;
113 static Lisp_Object
xdialog_show ();
114 void popup_get_selection ();
119 /* Define HAVE_BOXES if meus can handle radio and toggle buttons. */
124 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
125 Lisp_Object
, Lisp_Object
, Lisp_Object
,
126 Lisp_Object
, Lisp_Object
));
127 static int update_frame_menubar
P_ ((struct frame
*));
128 static Lisp_Object xmenu_show
P_ ((struct frame
*, int, int, int, int,
129 Lisp_Object
, char **));
130 static void keymap_panes
P_ ((Lisp_Object
*, int, int));
131 static void single_keymap_panes
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
133 static void single_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
*,
135 static void list_of_panes
P_ ((Lisp_Object
));
136 static void list_of_items
P_ ((Lisp_Object
));
138 /* This holds a Lisp vector that holds the results of decoding
139 the keymaps or alist-of-alists that specify a menu.
141 It describes the panes and items within the panes.
143 Each pane is described by 3 elements in the vector:
144 t, the pane name, the pane's prefix key.
145 Then follow the pane's items, with 5 elements per item:
146 the item string, the enable flag, the item's value,
147 the definition, and the equivalent keyboard key's description string.
149 In some cases, multiple levels of menus may be described.
150 A single vector slot containing nil indicates the start of a submenu.
151 A single vector slot containing lambda indicates the end of a submenu.
152 The submenu follows a menu item which is the way to reach the submenu.
154 A single vector slot containing quote indicates that the
155 following items should appear on the right of a dialog box.
157 Using a Lisp vector to hold this information while we decode it
158 takes care of protecting all the data from GC. */
160 #define MENU_ITEMS_PANE_NAME 1
161 #define MENU_ITEMS_PANE_PREFIX 2
162 #define MENU_ITEMS_PANE_LENGTH 3
166 MENU_ITEMS_ITEM_NAME
= 0,
167 MENU_ITEMS_ITEM_ENABLE
,
168 MENU_ITEMS_ITEM_VALUE
,
169 MENU_ITEMS_ITEM_EQUIV_KEY
,
170 MENU_ITEMS_ITEM_DEFINITION
,
171 MENU_ITEMS_ITEM_TYPE
,
172 MENU_ITEMS_ITEM_SELECTED
,
173 MENU_ITEMS_ITEM_HELP
,
174 MENU_ITEMS_ITEM_LENGTH
177 static Lisp_Object menu_items
;
179 /* Number of slots currently allocated in menu_items. */
180 static int menu_items_allocated
;
182 /* This is the index in menu_items of the first empty slot. */
183 static int menu_items_used
;
185 /* The number of panes currently recorded in menu_items,
186 excluding those within submenus. */
187 static int menu_items_n_panes
;
189 /* Current depth within submenus. */
190 static int menu_items_submenu_depth
;
192 /* Flag which when set indicates a dialog or menu has been posted by
193 Xt on behalf of one of the widget sets. */
194 int popup_activated_flag
;
196 static int next_menubar_widget_id
;
198 /* This is set nonzero after the user activates the menu bar, and set
199 to zero again after the menu bars are redisplayed by prepare_menu_bar.
200 While it is nonzero, all calls to set_frame_menubar go deep.
202 I don't understand why this is needed, but it does seem to be
203 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
205 int pending_menu_activation
;
209 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
211 static struct frame
*
212 menubar_id_to_frame (id
)
215 Lisp_Object tail
, frame
;
218 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
221 if (!GC_FRAMEP (frame
))
224 if (!FRAME_WINDOW_P (f
))
226 if (f
->output_data
.x
->id
== id
)
234 /* Initialize the menu_items structure if we haven't already done so.
235 Also mark it as currently empty. */
240 if (NILP (menu_items
))
242 menu_items_allocated
= 60;
243 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
247 menu_items_n_panes
= 0;
248 menu_items_submenu_depth
= 0;
251 /* Call at the end of generating the data in menu_items.
252 This fills in the number of items in the last pane. */
259 /* Call when finished using the data for the current menu
263 discard_menu_items ()
265 /* Free the structure if it is especially large.
266 Otherwise, hold on to it, to save time. */
267 if (menu_items_allocated
> 200)
270 menu_items_allocated
= 0;
274 /* Make the menu_items vector twice as large. */
280 int old_size
= menu_items_allocated
;
283 menu_items_allocated
*= 2;
284 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
285 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
286 old_size
* sizeof (Lisp_Object
));
289 /* Begin a submenu. */
292 push_submenu_start ()
294 if (menu_items_used
+ 1 > menu_items_allocated
)
297 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
298 menu_items_submenu_depth
++;
306 if (menu_items_used
+ 1 > menu_items_allocated
)
309 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
310 menu_items_submenu_depth
--;
313 /* Indicate boundary between left and right. */
316 push_left_right_boundary ()
318 if (menu_items_used
+ 1 > menu_items_allocated
)
321 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
324 /* Start a new menu pane in menu_items..
325 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
328 push_menu_pane (name
, prefix_vec
)
329 Lisp_Object name
, prefix_vec
;
331 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
334 if (menu_items_submenu_depth
== 0)
335 menu_items_n_panes
++;
336 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
337 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
338 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
341 /* Push one menu item into the current pane. NAME is the string to
342 display. ENABLE if non-nil means this item can be selected. KEY
343 is the key generated by choosing this item, or nil if this item
344 doesn't really have a definition. DEF is the definition of this
345 item. EQUIV is the textual description of the keyboard equivalent
346 for this item (or nil if none). TYPE is the type of this menu
347 item, one of nil, `toggle' or `radio'. */
350 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
351 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
353 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
356 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
357 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
358 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
359 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
360 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
361 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
362 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
363 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
366 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
367 and generate menu panes for them in menu_items.
368 If NOTREAL is nonzero,
369 don't bother really computing whether an item is enabled. */
372 keymap_panes (keymaps
, nmaps
, notreal
)
373 Lisp_Object
*keymaps
;
381 /* Loop over the given keymaps, making a pane for each map.
382 But don't make a pane that is empty--ignore that map instead.
383 P is the number of panes we have made so far. */
384 for (mapno
= 0; mapno
< nmaps
; mapno
++)
385 single_keymap_panes (keymaps
[mapno
],
386 map_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
388 finish_menu_items ();
391 /* This is a recursive subroutine of keymap_panes.
392 It handles one keymap, KEYMAP.
393 The other arguments are passed along
394 or point to local variables of the previous function.
395 If NOTREAL is nonzero, only check for equivalent key bindings, don't
396 evaluate expressions in menu items and don't make any menu.
398 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
401 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
403 Lisp_Object pane_name
;
408 Lisp_Object pending_maps
= Qnil
;
409 Lisp_Object tail
, item
;
410 struct gcpro gcpro1
, gcpro2
;
416 push_menu_pane (pane_name
, prefix
);
419 /* Remember index for first item in this pane so we can go back and
420 add a prefix when (if) we see the first button. After that, notbuttons
421 is set to 0, to mark that we have seen a button and all non button
422 items need a prefix. */
423 notbuttons
= menu_items_used
;
426 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
428 GCPRO2 (keymap
, pending_maps
);
429 /* Look at each key binding, and if it is a menu item add it
433 single_menu_item (XCAR (item
), XCDR (item
),
434 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
435 else if (VECTORP (item
))
437 /* Loop over the char values represented in the vector. */
438 int len
= XVECTOR (item
)->size
;
440 for (c
= 0; c
< len
; c
++)
442 Lisp_Object character
;
443 XSETFASTINT (character
, c
);
444 single_menu_item (character
, XVECTOR (item
)->contents
[c
],
445 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
451 /* Process now any submenus which want to be panes at this level. */
452 while (!NILP (pending_maps
))
454 Lisp_Object elt
, eltcdr
, string
;
455 elt
= Fcar (pending_maps
);
457 string
= XCAR (eltcdr
);
458 /* We no longer discard the @ from the beginning of the string here.
459 Instead, we do this in xmenu_show. */
460 single_keymap_panes (Fcar (elt
), string
,
461 XCDR (eltcdr
), notreal
, maxdepth
- 1);
462 pending_maps
= Fcdr (pending_maps
);
466 /* This is a subroutine of single_keymap_panes that handles one
468 KEY is a key in a keymap and ITEM is its binding.
469 PENDING_MAPS_PTR points to a list of keymaps waiting to be made into
471 If NOTREAL is nonzero, only check for equivalent key bindings, don't
472 evaluate expressions in menu items and don't make any menu.
473 If we encounter submenus deeper than MAXDEPTH levels, ignore them.
474 NOTBUTTONS_PTR is only used when simulating toggle boxes and radio
475 buttons. It points to variable notbuttons in single_keymap_panes,
476 which keeps track of if we have seen a button in this menu or not. */
479 single_menu_item (key
, item
, pending_maps_ptr
, notreal
, maxdepth
,
481 Lisp_Object key
, item
;
482 Lisp_Object
*pending_maps_ptr
;
483 int maxdepth
, notreal
;
486 Lisp_Object map
, item_string
, enabled
;
487 struct gcpro gcpro1
, gcpro2
;
490 /* Parse the menu item and leave the result in item_properties. */
492 res
= parse_menu_item (item
, notreal
, 0);
495 return; /* Not a menu item. */
497 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
501 /* We don't want to make a menu, just traverse the keymaps to
502 precompute equivalent key bindings. */
504 single_keymap_panes (map
, Qnil
, key
, 1, maxdepth
- 1);
508 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
509 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
511 if (!NILP (map
) && XSTRING (item_string
)->data
[0] == '@')
514 /* An enabled separate pane. Remember this to handle it later. */
515 *pending_maps_ptr
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
521 /* Simulate radio buttons and toggle boxes by putting a prefix in
524 Lisp_Object prefix
= Qnil
;
525 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
529 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
532 /* The first button. Line up previous items in this menu. */
534 int index
= *notbuttons_ptr
; /* Index for first item this menu. */
537 while (index
< menu_items_used
)
540 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
544 submenu
++; /* Skip sub menu. */
546 else if (EQ (tem
, Qlambda
))
549 submenu
--; /* End sub menu. */
551 else if (EQ (tem
, Qt
))
552 index
+= 3; /* Skip new pane marker. */
553 else if (EQ (tem
, Qquote
))
554 index
++; /* Skip a left, right divider. */
557 if (!submenu
&& XSTRING (tem
)->data
[0] != '\0'
558 && XSTRING (tem
)->data
[0] != '-')
559 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
560 = concat2 (build_string (" "), tem
);
561 index
+= MENU_ITEMS_ITEM_LENGTH
;
567 /* Calculate prefix, if any, for this item. */
568 if (EQ (type
, QCtoggle
))
569 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
570 else if (EQ (type
, QCradio
))
571 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
573 /* Not a button. If we have earlier buttons, then we need a prefix. */
574 else if (!*notbuttons_ptr
&& XSTRING (item_string
)->data
[0] != '\0'
575 && XSTRING (item_string
)->data
[0] != '-')
576 prefix
= build_string (" ");
579 item_string
= concat2 (prefix
, item_string
);
581 #endif /* not HAVE_BOXES */
583 #ifndef USE_X_TOOLKIT
585 /* Indicate visually that this is a submenu. */
586 item_string
= concat2 (item_string
, build_string (" >"));
589 push_menu_item (item_string
, enabled
, key
,
590 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
591 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
592 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
593 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
594 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
597 /* Display a submenu using the toolkit. */
598 if (! (NILP (map
) || NILP (enabled
)))
600 push_submenu_start ();
601 single_keymap_panes (map
, Qnil
, key
, 0, maxdepth
- 1);
607 /* Push all the panes and items of a menu described by the
608 alist-of-alists MENU.
609 This handles old-fashioned calls to x-popup-menu. */
619 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
621 Lisp_Object elt
, pane_name
, pane_data
;
623 pane_name
= Fcar (elt
);
624 CHECK_STRING (pane_name
, 0);
625 push_menu_pane (pane_name
, Qnil
);
626 pane_data
= Fcdr (elt
);
627 CHECK_CONS (pane_data
, 0);
628 list_of_items (pane_data
);
631 finish_menu_items ();
634 /* Push the items in a single pane defined by the alist PANE. */
640 Lisp_Object tail
, item
, item1
;
642 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
646 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
647 else if (NILP (item
))
648 push_left_right_boundary ();
651 CHECK_CONS (item
, 0);
653 CHECK_STRING (item1
, 1);
654 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
659 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
660 "Pop up a deck-of-cards menu and return user's selection.\n\
661 POSITION is a position specification. This is either a mouse button event\n\
662 or a list ((XOFFSET YOFFSET) WINDOW)\n\
663 where XOFFSET and YOFFSET are positions in pixels from the top left\n\
664 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
665 This controls the position of the center of the first line\n\
666 in the first pane of the menu, not the top left of the menu as a whole.\n\
667 If POSITION is t, it means to use the current mouse position.\n\
669 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
670 The menu items come from key bindings that have a menu string as well as\n\
671 a definition; actually, the \"definition\" in such a key binding looks like\n\
672 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
673 the keymap as a top-level element.\n\n\
674 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.\n\
675 Otherwise, REAL-DEFINITION should be a valid key binding definition.\n\
677 You can also use a list of keymaps as MENU.\n\
678 Then each keymap makes a separate pane.\n\
679 When MENU is a keymap or a list of keymaps, the return value\n\
680 is a list of events.\n\n\
682 Alternatively, you can specify a menu of multiple panes\n\
683 with a list of the form (TITLE PANE1 PANE2...),\n\
684 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
685 Each ITEM is normally a cons cell (STRING . VALUE);\n\
686 but a string can appear as an item--that makes a nonselectable line\n\
688 With this form of menu, the return value is VALUE from the chosen item.\n\
690 If POSITION is nil, don't display the menu at all, just precalculate the\n\
691 cached information about equivalent key sequences.")
693 Lisp_Object position
, menu
;
695 Lisp_Object keymap
, tem
;
696 int xpos
= 0, ypos
= 0;
699 Lisp_Object selection
;
700 struct frame
*f
= NULL
;
701 Lisp_Object x
, y
, window
;
707 if (! NILP (position
))
711 /* Decode the first argument: find the window and the coordinates. */
712 if (EQ (position
, Qt
)
713 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
714 || EQ (XCAR (position
), Qtool_bar
))))
716 /* Use the mouse's current position. */
717 FRAME_PTR new_f
= SELECTED_FRAME ();
718 Lisp_Object bar_window
;
719 enum scroll_bar_part part
;
722 if (mouse_position_hook
)
723 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
724 &part
, &x
, &y
, &time
);
726 XSETFRAME (window
, new_f
);
729 window
= selected_window
;
736 tem
= Fcar (position
);
739 window
= Fcar (Fcdr (position
));
741 y
= Fcar (Fcdr (tem
));
746 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
747 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
748 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
757 /* Decode where to put the menu. */
765 else if (WINDOWP (window
))
767 CHECK_LIVE_WINDOW (window
, 0);
768 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
770 xpos
= (FONT_WIDTH (f
->output_data
.x
->font
)
771 * XFASTINT (XWINDOW (window
)->left
));
772 ypos
= (f
->output_data
.x
->line_height
773 * XFASTINT (XWINDOW (window
)->top
));
776 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
777 but I don't want to make one now. */
778 CHECK_WINDOW (window
, 0);
783 XSETFRAME (Vmenu_updating_frame
, f
);
785 Vmenu_updating_frame
= Qnil
;
786 #endif /* HAVE_MENUS */
791 /* Decode the menu items from what was specified. */
793 keymap
= get_keymap (menu
, 0, 0);
796 /* We were given a keymap. Extract menu info from the keymap. */
799 /* Extract the detailed info to make one pane. */
800 keymap_panes (&menu
, 1, NILP (position
));
802 /* Search for a string appearing directly as an element of the keymap.
803 That string is the title of the menu. */
804 prompt
= map_prompt (keymap
);
805 if (NILP (title
) && !NILP (prompt
))
808 /* Make that be the pane title of the first pane. */
809 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
810 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
814 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
816 /* We were given a list of keymaps. */
817 int nmaps
= XFASTINT (Flength (menu
));
819 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
824 /* The first keymap that has a prompt string
825 supplies the menu title. */
826 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
830 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
832 prompt
= map_prompt (keymap
);
833 if (NILP (title
) && !NILP (prompt
))
837 /* Extract the detailed info to make one pane. */
838 keymap_panes (maps
, nmaps
, NILP (position
));
840 /* Make the title be the pane title of the first pane. */
841 if (!NILP (title
) && menu_items_n_panes
>= 0)
842 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
848 /* We were given an old-fashioned menu. */
850 CHECK_STRING (title
, 1);
852 list_of_panes (Fcdr (menu
));
859 discard_menu_items ();
865 /* Display them in a menu. */
868 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
869 keymaps
, title
, &error_name
);
872 discard_menu_items ();
875 #endif /* HAVE_MENUS */
877 if (error_name
) error (error_name
);
883 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
884 "Pop up a dialog box and return user's selection.\n\
885 POSITION specifies which frame to use.\n\
886 This is normally a mouse button event or a window or frame.\n\
887 If POSITION is t, it means to use the frame the mouse is on.\n\
888 The dialog box appears in the middle of the specified frame.\n\
890 CONTENTS specifies the alternatives to display in the dialog box.\n\
891 It is a list of the form (TITLE ITEM1 ITEM2...).\n\
892 Each ITEM is a cons cell (STRING . VALUE).\n\
893 The return value is VALUE from the chosen item.\n\n\
894 An ITEM may also be just a string--that makes a nonselectable item.\n\
895 An ITEM may also be nil--that means to put all preceding items\n\
896 on the left of the dialog box and all following items on the right.\n\
897 \(By default, approximately half appear on each side.)")
899 Lisp_Object position
, contents
;
901 struct frame
* f
= NULL
;
906 /* Decode the first argument: find the window or frame to use. */
907 if (EQ (position
, Qt
)
908 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
909 || EQ (XCAR (position
), Qtool_bar
))))
911 #if 0 /* Using the frame the mouse is on may not be right. */
912 /* Use the mouse's current position. */
913 FRAME_PTR new_f
= SELECTED_FRAME ();
914 Lisp_Object bar_window
;
919 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
922 XSETFRAME (window
, new_f
);
924 window
= selected_window
;
926 window
= selected_window
;
928 else if (CONSP (position
))
931 tem
= Fcar (position
);
933 window
= Fcar (Fcdr (position
));
936 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
937 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
940 else if (WINDOWP (position
) || FRAMEP (position
))
945 /* Decode where to put the menu. */
949 else if (WINDOWP (window
))
951 CHECK_LIVE_WINDOW (window
, 0);
952 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
955 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
956 but I don't want to make one now. */
957 CHECK_WINDOW (window
, 0);
959 #ifndef USE_X_TOOLKIT
960 /* Display a menu with these alternatives
961 in the middle of frame F. */
963 Lisp_Object x
, y
, frame
, newpos
;
964 XSETFRAME (frame
, f
);
965 XSETINT (x
, x_pixel_width (f
) / 2);
966 XSETINT (y
, x_pixel_height (f
) / 2);
967 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
969 return Fx_popup_menu (newpos
,
970 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
976 Lisp_Object selection
;
978 /* Decode the dialog items from what was specified. */
979 title
= Fcar (contents
);
980 CHECK_STRING (title
, 1);
982 list_of_panes (Fcons (contents
, Qnil
));
984 /* Display them in a dialog box. */
986 selection
= xdialog_show (f
, 0, title
, &error_name
);
989 discard_menu_items ();
991 if (error_name
) error (error_name
);
999 /* Loop in Xt until the menu pulldown or dialog popup has been
1000 popped down (deactivated). This is used for x-popup-menu
1001 and x-popup-dialog; it is not used for the menu bar any more.
1003 NOTE: All calls to popup_get_selection should be protected
1004 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1007 popup_get_selection (initial_event
, dpyinfo
, id
)
1008 XEvent
*initial_event
;
1009 struct x_display_info
*dpyinfo
;
1014 /* Define a queue to save up for later unreading
1015 all X events that don't pertain to the menu. */
1019 struct event_queue
*next
;
1022 struct event_queue
*queue
= NULL
;
1023 struct event_queue
*queue_tmp
;
1026 event
= *initial_event
;
1028 XtAppNextEvent (Xt_app_con
, &event
);
1032 /* Handle expose events for editor frames right away. */
1033 if (event
.type
== Expose
)
1034 process_expose_from_menu (event
);
1035 /* Make sure we don't consider buttons grabbed after menu goes.
1036 And make sure to deactivate for any ButtonRelease,
1037 even if XtDispatchEvent doesn't do that. */
1038 else if (event
.type
== ButtonRelease
1039 && dpyinfo
->display
== event
.xbutton
.display
)
1041 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1042 popup_activated_flag
= 0;
1043 #ifdef USE_MOTIF /* Pretending that the event came from a
1044 Btn1Down seems the only way to convince Motif to
1045 activate its callbacks; setting the XmNmenuPost
1046 isn't working. --marcus@sysc.pdx.edu. */
1047 event
.xbutton
.button
= 1;
1050 /* If the user presses a key, deactivate the menu.
1051 The user is likely to do that if we get wedged. */
1052 else if (event
.type
== KeyPress
1053 && dpyinfo
->display
== event
.xbutton
.display
)
1055 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1056 if (!IsModifierKey (keysym
))
1058 popup_activated_flag
= 0;
1062 /* Button presses outside the menu also pop it down. */
1063 else if (event
.type
== ButtonPress
1064 && event
.xany
.display
== dpyinfo
->display
1065 && x_any_window_to_frame (dpyinfo
, event
.xany
.window
))
1067 popup_activated_flag
= 0;
1071 /* Queue all events not for this popup,
1072 except for Expose, which we've already handled, and ButtonRelease.
1073 Note that the X window is associated with the frame if this
1074 is a menu bar popup, but not if it's a dialog box. So we use
1075 x_non_menubar_window_to_frame, not x_any_window_to_frame. */
1076 if (event
.type
!= Expose
1077 && !(event
.type
== ButtonRelease
1078 && dpyinfo
->display
== event
.xbutton
.display
)
1079 && (event
.xany
.display
!= dpyinfo
->display
1080 || x_non_menubar_window_to_frame (dpyinfo
, event
.xany
.window
)))
1082 queue_tmp
= (struct event_queue
*) xmalloc (sizeof *queue_tmp
);
1083 queue_tmp
->event
= event
;
1084 queue_tmp
->next
= queue
;
1088 XtDispatchEvent (&event
);
1090 if (!popup_activated ())
1092 XtAppNextEvent (Xt_app_con
, &event
);
1095 /* Unread any events that we got but did not handle. */
1096 while (queue
!= NULL
)
1099 XPutBackEvent (queue_tmp
->event
.xany
.display
, &queue_tmp
->event
);
1100 queue
= queue_tmp
->next
;
1101 xfree ((char *)queue_tmp
);
1102 /* Cause these events to get read as soon as we UNBLOCK_INPUT. */
1103 interrupt_input_pending
= 1;
1107 /* Activate the menu bar of frame F.
1108 This is called from keyboard.c when it gets the
1109 menu_bar_activate_event out of the Emacs event queue.
1111 To activate the menu bar, we use the X button-press event
1112 that was saved in saved_menu_event.
1113 That makes the toolkit do its thing.
1115 But first we recompute the menu bar contents (the whole tree).
1117 The reason for saving the button event until here, instead of
1118 passing it to the toolkit right away, is that we can safely
1119 execute Lisp code. */
1122 x_activate_menubar (f
)
1125 if (!f
->output_data
.x
->saved_menu_event
->type
)
1128 set_frame_menubar (f
, 0, 1);
1130 XtDispatchEvent ((XEvent
*) f
->output_data
.x
->saved_menu_event
);
1133 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1134 pending_menu_activation
= 1;
1137 /* Ignore this if we get it a second time. */
1138 f
->output_data
.x
->saved_menu_event
->type
= 0;
1141 /* Detect if a dialog or menu has been posted. */
1146 return popup_activated_flag
;
1149 /* This callback is invoked when the user selects a menubar cascade
1150 pushbutton, but before the pulldown menu is posted. */
1153 popup_activate_callback (widget
, id
, client_data
)
1156 XtPointer client_data
;
1158 popup_activated_flag
= 1;
1161 /* This callback is invoked when a dialog or menu is finished being
1162 used and has been unposted. */
1165 popup_deactivate_callback (widget
, id
, client_data
)
1168 XtPointer client_data
;
1170 popup_activated_flag
= 0;
1173 /* Lwlib callback called when menu items are highlighted/unhighlighted
1174 while moving the mouse over them. WIDGET is the menu bar or menu
1175 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1176 the widget_value structure for the menu item, or null in case of
1180 menu_highlight_callback (widget
, id
, call_data
)
1185 widget_value
*wv
= (widget_value
*) call_data
;
1187 Lisp_Object frame
, help
;
1189 help
= wv
&& wv
->help
? build_string (wv
->help
) : Qnil
;
1191 /* Determine the frame for the help event. */
1192 f
= menubar_id_to_frame (id
);
1195 XSETFRAME (frame
, f
);
1196 kbd_buffer_store_help_event (frame
, help
);
1200 /* WIDGET is the popup menu. It's parent is the frame's
1201 widget. See which frame that is. */
1202 Widget frame_widget
= XtParent (widget
);
1205 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1207 frame
= XCAR (tail
);
1208 if (GC_FRAMEP (frame
)
1209 && (f
= XFRAME (frame
),
1210 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1214 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1218 /* This callback is called from the menu bar pulldown menu
1219 when the user makes a selection.
1220 Figure out what the user chose
1221 and put the appropriate events into the keyboard buffer. */
1224 menubar_selection_callback (widget
, id
, client_data
)
1227 XtPointer client_data
;
1229 Lisp_Object prefix
, entry
;
1230 FRAME_PTR f
= menubar_id_to_frame (id
);
1232 Lisp_Object
*subprefix_stack
;
1233 int submenu_depth
= 0;
1239 subprefix_stack
= (Lisp_Object
*) alloca (f
->menu_bar_items_used
* sizeof (Lisp_Object
));
1240 vector
= f
->menu_bar_vector
;
1243 while (i
< f
->menu_bar_items_used
)
1245 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1247 subprefix_stack
[submenu_depth
++] = prefix
;
1251 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1253 prefix
= subprefix_stack
[--submenu_depth
];
1256 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1258 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1259 i
+= MENU_ITEMS_PANE_LENGTH
;
1263 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1264 /* The EMACS_INT cast avoids a warning. There's no problem
1265 as long as pointers have enough bits to hold small integers. */
1266 if ((int) (EMACS_INT
) client_data
== i
)
1269 struct input_event buf
;
1272 XSETFRAME (frame
, f
);
1273 buf
.kind
= MENU_BAR_EVENT
;
1274 buf
.frame_or_window
= frame
;
1276 kbd_buffer_store_event (&buf
);
1278 for (j
= 0; j
< submenu_depth
; j
++)
1279 if (!NILP (subprefix_stack
[j
]))
1281 buf
.kind
= MENU_BAR_EVENT
;
1282 buf
.frame_or_window
= frame
;
1283 buf
.arg
= subprefix_stack
[j
];
1284 kbd_buffer_store_event (&buf
);
1289 buf
.kind
= MENU_BAR_EVENT
;
1290 buf
.frame_or_window
= frame
;
1292 kbd_buffer_store_event (&buf
);
1295 buf
.kind
= MENU_BAR_EVENT
;
1296 buf
.frame_or_window
= frame
;
1298 kbd_buffer_store_event (&buf
);
1302 i
+= MENU_ITEMS_ITEM_LENGTH
;
1307 /* Allocate a widget_value, blocking input. */
1310 xmalloc_widget_value ()
1312 widget_value
*value
;
1315 value
= malloc_widget_value ();
1321 /* This recursively calls free_widget_value on the tree of widgets.
1322 It must free all data that was malloc'ed for these widget_values.
1323 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1324 must be left alone. */
1327 free_menubar_widget_value_tree (wv
)
1332 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1334 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1336 free_menubar_widget_value_tree (wv
->contents
);
1337 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1341 free_menubar_widget_value_tree (wv
->next
);
1342 wv
->next
= (widget_value
*) 0xDEADBEEF;
1345 free_widget_value (wv
);
1349 /* Return a tree of widget_value structures for a menu bar item
1350 whose event type is ITEM_KEY (with string ITEM_NAME)
1351 and whose contents come from the list of keymaps MAPS. */
1353 static widget_value
*
1354 single_submenu (item_key
, item_name
, maps
)
1355 Lisp_Object item_key
, item_name
, maps
;
1357 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1359 int submenu_depth
= 0;
1362 Lisp_Object
*mapvec
;
1363 widget_value
**submenu_stack
;
1364 int previous_items
= menu_items_used
;
1365 int top_level_items
= 0;
1367 length
= Flength (maps
);
1368 len
= XINT (length
);
1370 /* Convert the list MAPS into a vector MAPVEC. */
1371 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1372 for (i
= 0; i
< len
; i
++)
1374 mapvec
[i
] = Fcar (maps
);
1378 menu_items_n_panes
= 0;
1380 /* Loop over the given keymaps, making a pane for each map.
1381 But don't make a pane that is empty--ignore that map instead. */
1382 for (i
= 0; i
< len
; i
++)
1384 if (SYMBOLP (mapvec
[i
])
1385 || (CONSP (mapvec
[i
]) && !KEYMAPP (mapvec
[i
])))
1387 /* Here we have a command at top level in the menu bar
1388 as opposed to a submenu. */
1389 top_level_items
= 1;
1390 push_menu_pane (Qnil
, Qnil
);
1391 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1392 Qnil
, Qnil
, Qnil
, Qnil
);
1395 single_keymap_panes (mapvec
[i
], item_name
, item_key
, 0, 10);
1398 /* Create a tree of widget_value objects
1399 representing the panes and their items. */
1402 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1403 wv
= xmalloc_widget_value ();
1407 wv
->button_type
= BUTTON_TYPE_NONE
;
1412 /* Loop over all panes and items made during this call
1413 and construct a tree of widget_value objects.
1414 Ignore the panes and items made by previous calls to
1415 single_submenu, even though those are also in menu_items. */
1417 while (i
< menu_items_used
)
1419 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1421 submenu_stack
[submenu_depth
++] = save_wv
;
1426 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1429 save_wv
= submenu_stack
[--submenu_depth
];
1432 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1433 && submenu_depth
!= 0)
1434 i
+= MENU_ITEMS_PANE_LENGTH
;
1435 /* Ignore a nil in the item list.
1436 It's meaningful only for dialog boxes. */
1437 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1439 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1441 /* Create a new pane. */
1442 Lisp_Object pane_name
, prefix
;
1444 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1445 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1446 #ifndef HAVE_MULTILINGUAL_MENU
1447 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1448 pane_name
= string_make_unibyte (pane_name
);
1450 pane_string
= (NILP (pane_name
)
1451 ? "" : (char *) XSTRING (pane_name
)->data
);
1452 /* If there is just one top-level pane, put all its items directly
1453 under the top-level menu. */
1454 if (menu_items_n_panes
== 1)
1457 /* If the pane has a meaningful name,
1458 make the pane a top-level menu item
1459 with its items as a submenu beneath it. */
1460 if (strcmp (pane_string
, ""))
1462 wv
= xmalloc_widget_value ();
1466 first_wv
->contents
= wv
;
1467 wv
->name
= pane_string
;
1468 /* Ignore the @ that means "separate pane".
1469 This is a kludge, but this isn't worth more time. */
1470 if (!NILP (prefix
) && wv
->name
[0] == '@')
1474 wv
->button_type
= BUTTON_TYPE_NONE
;
1478 i
+= MENU_ITEMS_PANE_LENGTH
;
1482 /* Create a new item within current pane. */
1483 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1486 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1487 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1489 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1490 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
1491 type
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_TYPE
];
1492 selected
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_SELECTED
];
1493 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
1495 #ifndef HAVE_MULTILINGUAL_MENU
1496 if (STRING_MULTIBYTE (item_name
))
1497 item_name
= string_make_unibyte (item_name
);
1498 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1499 descrip
= string_make_unibyte (descrip
);
1502 wv
= xmalloc_widget_value ();
1506 save_wv
->contents
= wv
;
1508 wv
->name
= (char *) XSTRING (item_name
)->data
;
1509 if (!NILP (descrip
))
1510 wv
->key
= (char *) XSTRING (descrip
)->data
;
1512 /* The EMACS_INT cast avoids a warning. There's no problem
1513 as long as pointers have enough bits to hold small integers. */
1514 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1515 wv
->enabled
= !NILP (enable
);
1518 wv
->button_type
= BUTTON_TYPE_NONE
;
1519 else if (EQ (type
, QCradio
))
1520 wv
->button_type
= BUTTON_TYPE_RADIO
;
1521 else if (EQ (type
, QCtoggle
))
1522 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1526 wv
->selected
= !NILP (selected
);
1528 wv
->help
= XSTRING (help
)->data
;
1532 i
+= MENU_ITEMS_ITEM_LENGTH
;
1536 /* If we have just one "menu item"
1537 that was originally a button, return it by itself. */
1538 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1540 wv
= first_wv
->contents
;
1541 free_widget_value (first_wv
);
1550 /* Recompute all the widgets of frame F, when the menu bar has been
1551 changed. Value is non-zero if widgets were updated. */
1554 update_frame_menubar (f
)
1557 struct x_output
*x
= f
->output_data
.x
;
1560 if (!x
->menubar_widget
|| XtIsManaged (x
->menubar_widget
))
1564 /* Save the size of the frame because the pane widget doesn't accept
1565 to resize itself. So force it. */
1569 /* Do the voodoo which means "I'm changing lots of things, don't try
1570 to refigure sizes until I'm done." */
1571 lw_refigure_widget (x
->column_widget
, False
);
1573 /* The order in which children are managed is the top to bottom
1574 order in which they are displayed in the paned window. First,
1575 remove the text-area widget. */
1576 XtUnmanageChild (x
->edit_widget
);
1578 /* Remove the menubar that is there now, and put up the menubar that
1580 XtManageChild (x
->menubar_widget
);
1581 XtMapWidget (x
->menubar_widget
);
1582 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1584 /* Re-manage the text-area widget, and then thrash the sizes. */
1585 XtManageChild (x
->edit_widget
);
1586 lw_refigure_widget (x
->column_widget
, True
);
1588 /* Force the pane widget to resize itself with the right values. */
1589 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1594 /* Set the contents of the menubar widgets of frame F.
1595 The argument FIRST_TIME is currently ignored;
1596 it is set the first time this is called, from initialize_frame_menubar. */
1599 set_frame_menubar (f
, first_time
, deep_p
)
1604 Widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1606 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1610 XSETFRAME (Vmenu_updating_frame
, f
);
1612 if (f
->output_data
.x
->id
== 0)
1613 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1614 id
= f
->output_data
.x
->id
;
1616 if (! menubar_widget
)
1618 else if (pending_menu_activation
&& !deep_p
)
1620 /* Make the first call for any given frame always go deep. */
1621 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1624 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1625 f
->output_data
.x
->saved_menu_event
->type
= 0;
1628 wv
= xmalloc_widget_value ();
1629 wv
->name
= "menubar";
1632 wv
->button_type
= BUTTON_TYPE_NONE
;
1637 /* Make a widget-value tree representing the entire menu trees. */
1639 struct buffer
*prev
= current_buffer
;
1641 int specpdl_count
= specpdl_ptr
- specpdl
;
1642 int previous_menu_items_used
= f
->menu_bar_items_used
;
1643 Lisp_Object
*previous_items
1644 = (Lisp_Object
*) alloca (previous_menu_items_used
1645 * sizeof (Lisp_Object
));
1647 /* If we are making a new widget, its contents are empty,
1648 do always reinitialize them. */
1649 if (! menubar_widget
)
1650 previous_menu_items_used
= 0;
1652 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1653 specbind (Qinhibit_quit
, Qt
);
1654 /* Don't let the debugger step into this code
1655 because it is not reentrant. */
1656 specbind (Qdebug_on_next_call
, Qnil
);
1658 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1659 if (NILP (Voverriding_local_map_menu_flag
))
1661 specbind (Qoverriding_terminal_local_map
, Qnil
);
1662 specbind (Qoverriding_local_map
, Qnil
);
1665 set_buffer_internal_1 (XBUFFER (buffer
));
1667 /* Run the Lucid hook. */
1668 safe_run_hooks (Qactivate_menubar_hook
);
1670 /* If it has changed current-menubar from previous value,
1671 really recompute the menubar from the value. */
1672 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1673 call0 (Qrecompute_lucid_menubar
);
1674 safe_run_hooks (Qmenu_bar_update_hook
);
1675 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1677 items
= FRAME_MENU_BAR_ITEMS (f
);
1679 inhibit_garbage_collection ();
1681 /* Save the frame's previous menu bar contents data. */
1682 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1683 previous_menu_items_used
* sizeof (Lisp_Object
));
1685 /* Fill in the current menu bar contents. */
1686 menu_items
= f
->menu_bar_vector
;
1687 menu_items_allocated
= XVECTOR (menu_items
)->size
;
1689 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1691 Lisp_Object key
, string
, maps
;
1693 key
= XVECTOR (items
)->contents
[i
];
1694 string
= XVECTOR (items
)->contents
[i
+ 1];
1695 maps
= XVECTOR (items
)->contents
[i
+ 2];
1699 wv
= single_submenu (key
, string
, maps
);
1703 first_wv
->contents
= wv
;
1704 /* Don't set wv->name here; GC during the loop might relocate it. */
1706 wv
->button_type
= BUTTON_TYPE_NONE
;
1710 finish_menu_items ();
1712 set_buffer_internal_1 (prev
);
1713 unbind_to (specpdl_count
, Qnil
);
1715 /* If there has been no change in the Lisp-level contents
1716 of the menu bar, skip redisplaying it. Just exit. */
1718 for (i
= 0; i
< previous_menu_items_used
; i
++)
1719 if (menu_items_used
== i
1720 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1722 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1724 free_menubar_widget_value_tree (first_wv
);
1730 /* Now GC cannot happen during the lifetime of the widget_value,
1731 so it's safe to store data from a Lisp_String. */
1732 wv
= first_wv
->contents
;
1733 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1736 string
= XVECTOR (items
)->contents
[i
+ 1];
1739 wv
->name
= (char *) XSTRING (string
)->data
;
1743 f
->menu_bar_vector
= menu_items
;
1744 f
->menu_bar_items_used
= menu_items_used
;
1749 /* Make a widget-value tree containing
1750 just the top level menu bar strings. */
1752 items
= FRAME_MENU_BAR_ITEMS (f
);
1753 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1757 string
= XVECTOR (items
)->contents
[i
+ 1];
1761 wv
= xmalloc_widget_value ();
1762 wv
->name
= (char *) XSTRING (string
)->data
;
1765 wv
->button_type
= BUTTON_TYPE_NONE
;
1766 /* This prevents lwlib from assuming this
1767 menu item is really supposed to be empty. */
1768 /* The EMACS_INT cast avoids a warning.
1769 This value just has to be different from small integers. */
1770 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1775 first_wv
->contents
= wv
;
1779 /* Forget what we thought we knew about what is in the
1780 detailed contents of the menu bar menus.
1781 Changing the top level always destroys the contents. */
1782 f
->menu_bar_items_used
= 0;
1785 /* Create or update the menu bar widget. */
1791 /* Disable resizing (done for Motif!) */
1792 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1794 /* The third arg is DEEP_P, which says to consider the entire
1795 menu trees we supply, rather than just the menu bar item names. */
1796 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1798 /* Re-enable the edit widget to resize. */
1799 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1803 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1804 f
->output_data
.x
->column_widget
,
1806 popup_activate_callback
,
1807 menubar_selection_callback
,
1808 popup_deactivate_callback
,
1809 menu_highlight_callback
);
1810 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1815 = (f
->output_data
.x
->menubar_widget
1816 ? (f
->output_data
.x
->menubar_widget
->core
.height
1817 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1820 #if 0 /* Experimentally, we now get the right results
1821 for -geometry -0-0 without this. 24 Aug 96, rms. */
1823 if (FRAME_EXTERNAL_MENU_BAR (f
))
1826 XtVaGetValues (f
->output_data
.x
->column_widget
,
1827 XtNinternalBorderWidth
, &ibw
, NULL
);
1828 menubar_size
+= ibw
;
1830 #endif /* USE_LUCID */
1833 f
->output_data
.x
->menubar_height
= menubar_size
;
1836 free_menubar_widget_value_tree (first_wv
);
1837 update_frame_menubar (f
);
1842 /* Called from Fx_create_frame to create the initial menubar of a frame
1843 before it is mapped, so that the window is mapped with the menubar already
1844 there instead of us tacking it on later and thrashing the window after it
1848 initialize_frame_menubar (f
)
1851 /* This function is called before the first chance to redisplay
1852 the frame. It has to be, so the frame will have the right size. */
1853 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1854 set_frame_menubar (f
, 1, 1);
1858 /* Get rid of the menu bar of frame F, and free its storage.
1859 This is used when deleting a frame, and when turning off the menu bar. */
1862 free_frame_menubar (f
)
1865 Widget menubar_widget
;
1867 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1869 f
->output_data
.x
->menubar_height
= 0;
1874 /* Removing the menu bar magically changes the shell widget's x
1875 and y position of (0, 0) which, when the menu bar is turned
1876 on again, leads to pull-down menuss appearing in strange
1877 positions near the upper-left corner of the display. This
1878 happens only with some window managers like twm and ctwm,
1879 but not with other like Motif's mwm or kwm, because the
1880 latter generate ConfigureNotify events when the menu bar
1881 is switched off, which fixes the shell position. */
1882 Position x0
, y0
, x1
, y1
;
1888 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x0
, XtNy
, &y0
, NULL
);
1891 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1892 f
->output_data
.x
->menubar_widget
= NULL
;
1895 XtVaGetValues (f
->output_data
.x
->widget
, XtNx
, &x1
, XtNy
, &y1
, NULL
);
1896 if (x1
== 0 && y1
== 0)
1897 XtVaSetValues (f
->output_data
.x
->widget
, XtNx
, x0
, XtNy
, y0
, NULL
);
1904 #endif /* USE_X_TOOLKIT */
1906 /* xmenu_show actually displays a menu using the panes and items in menu_items
1907 and returns the value selected from it.
1908 There are two versions of xmenu_show, one for Xt and one for Xlib.
1909 Both assume input is blocked by the caller. */
1911 /* F is the frame the menu is for.
1912 X and Y are the frame-relative specified position,
1913 relative to the inside upper left corner of the frame F.
1914 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1915 KEYMAPS is 1 if this menu was specified with keymaps;
1916 in that case, we return a list containing the chosen item's value
1917 and perhaps also the pane's prefix.
1918 TITLE is the specified menu title.
1919 ERROR is a place to store an error message string in case of failure.
1920 (We return nil on failure, but the value doesn't actually matter.) */
1922 #ifdef USE_X_TOOLKIT
1924 /* We need a unique id for each widget handled by the Lucid Widget
1927 For the main windows, and popup menus, we use this counter,
1928 which we increment each time after use. This starts from 1<<16.
1930 For menu bars, we use numbers starting at 0, counted in
1931 next_menubar_widget_id. */
1932 LWLIB_ID widget_id_tick
;
1934 static Lisp_Object
*volatile menu_item_selection
;
1937 popup_selection_callback (widget
, id
, client_data
)
1940 XtPointer client_data
;
1942 menu_item_selection
= (Lisp_Object
*) client_data
;
1946 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
1960 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1961 widget_value
**submenu_stack
1962 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1963 Lisp_Object
*subprefix_stack
1964 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1965 int submenu_depth
= 0;
1966 XButtonPressedEvent dummy
;
1972 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1974 *error
= "Empty menu";
1978 /* Create a tree of widget_value objects
1979 representing the panes and their items. */
1980 wv
= xmalloc_widget_value ();
1984 wv
->button_type
= BUTTON_TYPE_NONE
;
1988 /* Loop over all panes and items, filling in the tree. */
1990 while (i
< menu_items_used
)
1992 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1994 submenu_stack
[submenu_depth
++] = save_wv
;
2000 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2003 save_wv
= submenu_stack
[--submenu_depth
];
2007 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2008 && submenu_depth
!= 0)
2009 i
+= MENU_ITEMS_PANE_LENGTH
;
2010 /* Ignore a nil in the item list.
2011 It's meaningful only for dialog boxes. */
2012 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2014 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2016 /* Create a new pane. */
2017 Lisp_Object pane_name
, prefix
;
2019 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2020 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2021 #ifndef HAVE_MULTILINGUAL_MENU
2022 if (!NILP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2023 pane_name
= string_make_unibyte (pane_name
);
2025 pane_string
= (NILP (pane_name
)
2026 ? "" : (char *) XSTRING (pane_name
)->data
);
2027 /* If there is just one top-level pane, put all its items directly
2028 under the top-level menu. */
2029 if (menu_items_n_panes
== 1)
2032 /* If the pane has a meaningful name,
2033 make the pane a top-level menu item
2034 with its items as a submenu beneath it. */
2035 if (!keymaps
&& strcmp (pane_string
, ""))
2037 wv
= xmalloc_widget_value ();
2041 first_wv
->contents
= wv
;
2042 wv
->name
= pane_string
;
2043 if (keymaps
&& !NILP (prefix
))
2047 wv
->button_type
= BUTTON_TYPE_NONE
;
2051 else if (first_pane
)
2057 i
+= MENU_ITEMS_PANE_LENGTH
;
2061 /* Create a new item within current pane. */
2062 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2063 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2064 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2066 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2067 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
2068 type
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_TYPE
];
2069 selected
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_SELECTED
];
2070 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2072 #ifndef HAVE_MULTILINGUAL_MENU
2073 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2074 item_name
= string_make_unibyte (item_name
);
2075 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2076 item_name
= string_make_unibyte (descrip
);
2079 wv
= xmalloc_widget_value ();
2083 save_wv
->contents
= wv
;
2084 wv
->name
= (char *) XSTRING (item_name
)->data
;
2085 if (!NILP (descrip
))
2086 wv
->key
= (char *) XSTRING (descrip
)->data
;
2088 /* If this item has a null value,
2089 make the call_data null so that it won't display a box
2090 when the mouse is on it. */
2092 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2093 wv
->enabled
= !NILP (enable
);
2096 wv
->button_type
= BUTTON_TYPE_NONE
;
2097 else if (EQ (type
, QCtoggle
))
2098 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2099 else if (EQ (type
, QCradio
))
2100 wv
->button_type
= BUTTON_TYPE_RADIO
;
2104 wv
->selected
= !NILP (selected
);
2106 wv
->help
= XSTRING (help
)->data
;
2110 i
+= MENU_ITEMS_ITEM_LENGTH
;
2114 /* Deal with the title, if it is non-nil. */
2117 widget_value
*wv_title
= xmalloc_widget_value ();
2118 widget_value
*wv_sep1
= xmalloc_widget_value ();
2119 widget_value
*wv_sep2
= xmalloc_widget_value ();
2121 wv_sep2
->name
= "--";
2122 wv_sep2
->next
= first_wv
->contents
;
2124 wv_sep1
->name
= "--";
2125 wv_sep1
->next
= wv_sep2
;
2127 #ifndef HAVE_MULTILINGUAL_MENU
2128 if (STRING_MULTIBYTE (title
))
2129 title
= string_make_unibyte (title
);
2131 wv_title
->name
= (char *) XSTRING (title
)->data
;
2132 wv_title
->enabled
= True
;
2133 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2134 wv_title
->next
= wv_sep1
;
2135 first_wv
->contents
= wv_title
;
2138 /* Actually create the menu. */
2139 menu_id
= widget_id_tick
++;
2140 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2141 f
->output_data
.x
->widget
, 1, 0,
2142 popup_selection_callback
,
2143 popup_deactivate_callback
,
2144 menu_highlight_callback
);
2146 /* Adjust coordinates to relative to the outer (window manager) window. */
2149 int win_x
= 0, win_y
= 0;
2151 /* Find the position of the outside upper-left corner of
2152 the inner window, with respect to the outer window. */
2153 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2156 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2158 /* From-window, to-window. */
2159 f
->output_data
.x
->window_desc
,
2160 f
->output_data
.x
->parent_desc
,
2162 /* From-position, to-position. */
2163 0, 0, &win_x
, &win_y
,
2165 /* Child of window. */
2173 /* Adjust coordinates to be root-window-relative. */
2174 x
+= f
->output_data
.x
->left_pos
;
2175 y
+= f
->output_data
.x
->top_pos
;
2177 dummy
.type
= ButtonPress
;
2179 dummy
.send_event
= 0;
2180 dummy
.display
= FRAME_X_DISPLAY (f
);
2181 dummy
.time
= CurrentTime
;
2182 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2183 dummy
.window
= dummy
.root
;
2184 dummy
.subwindow
= dummy
.root
;
2189 dummy
.state
= (FRAME_X_DISPLAY_INFO (f
)->grabbed
>> 1) * Button1Mask
;
2191 for (i
= 0; i
< 5; i
++)
2192 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2195 /* Don't allow any geometry request from the user. */
2196 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2197 XtSetValues (menu
, av
, ac
);
2199 /* Free the widget_value objects we used to specify the contents. */
2200 free_menubar_widget_value_tree (first_wv
);
2202 /* No selection has been chosen yet. */
2203 menu_item_selection
= 0;
2205 /* Display the menu. */
2206 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2207 popup_activated_flag
= 1;
2209 /* Process events that apply to the menu. */
2210 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
);
2212 /* fp turned off the following statement and wrote a comment
2213 that it is unnecessary--that the menu has already disappeared.
2214 Nowadays the menu disappears ok, all right, but
2215 we need to delete the widgets or multiple ones will pile up. */
2216 lw_destroy_all_widgets (menu_id
);
2218 /* Find the selected item, and its pane, to return
2219 the proper value. */
2220 if (menu_item_selection
!= 0)
2222 Lisp_Object prefix
, entry
;
2224 prefix
= entry
= Qnil
;
2226 while (i
< menu_items_used
)
2228 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2230 subprefix_stack
[submenu_depth
++] = prefix
;
2234 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2236 prefix
= subprefix_stack
[--submenu_depth
];
2239 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2242 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2243 i
+= MENU_ITEMS_PANE_LENGTH
;
2245 /* Ignore a nil in the item list.
2246 It's meaningful only for dialog boxes. */
2247 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2252 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2253 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2259 entry
= Fcons (entry
, Qnil
);
2261 entry
= Fcons (prefix
, entry
);
2262 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2263 if (!NILP (subprefix_stack
[j
]))
2264 entry
= Fcons (subprefix_stack
[j
], entry
);
2268 i
+= MENU_ITEMS_ITEM_LENGTH
;
2277 dialog_selection_callback (widget
, id
, client_data
)
2280 XtPointer client_data
;
2282 /* The EMACS_INT cast avoids a warning. There's no problem
2283 as long as pointers have enough bits to hold small integers. */
2284 if ((int) (EMACS_INT
) client_data
!= -1)
2285 menu_item_selection
= (Lisp_Object
*) client_data
;
2287 lw_destroy_all_widgets (id
);
2289 popup_activated_flag
= 0;
2292 static char * button_names
[] = {
2293 "button1", "button2", "button3", "button4", "button5",
2294 "button6", "button7", "button8", "button9", "button10" };
2297 xdialog_show (f
, keymaps
, title
, error
)
2303 int i
, nb_buttons
=0;
2306 char dialog_name
[6];
2308 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2310 /* Number of elements seen so far, before boundary. */
2312 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2313 int boundary_seen
= 0;
2317 if (menu_items_n_panes
> 1)
2319 *error
= "Multiple panes in dialog box";
2323 /* Create a tree of widget_value objects
2324 representing the text label and buttons. */
2326 Lisp_Object pane_name
, prefix
;
2328 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2329 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2330 pane_string
= (NILP (pane_name
)
2331 ? "" : (char *) XSTRING (pane_name
)->data
);
2332 prev_wv
= xmalloc_widget_value ();
2333 prev_wv
->value
= pane_string
;
2334 if (keymaps
&& !NILP (prefix
))
2336 prev_wv
->enabled
= 1;
2337 prev_wv
->name
= "message";
2340 /* Loop over all panes and items, filling in the tree. */
2341 i
= MENU_ITEMS_PANE_LENGTH
;
2342 while (i
< menu_items_used
)
2345 /* Create a new item within current pane. */
2346 Lisp_Object item_name
, enable
, descrip
;
2347 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2348 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2350 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2352 if (NILP (item_name
))
2354 free_menubar_widget_value_tree (first_wv
);
2355 *error
= "Submenu in dialog items";
2358 if (EQ (item_name
, Qquote
))
2360 /* This is the boundary between left-side elts
2361 and right-side elts. Stop incrementing right_count. */
2366 if (nb_buttons
>= 9)
2368 free_menubar_widget_value_tree (first_wv
);
2369 *error
= "Too many dialog items";
2373 wv
= xmalloc_widget_value ();
2375 wv
->name
= (char *) button_names
[nb_buttons
];
2376 if (!NILP (descrip
))
2377 wv
->key
= (char *) XSTRING (descrip
)->data
;
2378 wv
->value
= (char *) XSTRING (item_name
)->data
;
2379 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2380 wv
->enabled
= !NILP (enable
);
2383 if (! boundary_seen
)
2387 i
+= MENU_ITEMS_ITEM_LENGTH
;
2390 /* If the boundary was not specified,
2391 by default put half on the left and half on the right. */
2392 if (! boundary_seen
)
2393 left_count
= nb_buttons
- nb_buttons
/ 2;
2395 wv
= xmalloc_widget_value ();
2396 wv
->name
= dialog_name
;
2398 /* Dialog boxes use a really stupid name encoding
2399 which specifies how many buttons to use
2400 and how many buttons are on the right.
2401 The Q means something also. */
2402 dialog_name
[0] = 'Q';
2403 dialog_name
[1] = '0' + nb_buttons
;
2404 dialog_name
[2] = 'B';
2405 dialog_name
[3] = 'R';
2406 /* Number of buttons to put on the right. */
2407 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2409 wv
->contents
= first_wv
;
2413 /* Actually create the dialog. */
2414 dialog_id
= widget_id_tick
++;
2415 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2416 f
->output_data
.x
->widget
, 1, 0,
2417 dialog_selection_callback
, 0, 0);
2418 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2419 /* Free the widget_value objects we used to specify the contents. */
2420 free_menubar_widget_value_tree (first_wv
);
2422 /* No selection has been chosen yet. */
2423 menu_item_selection
= 0;
2425 /* Display the menu. */
2426 lw_pop_up_all_widgets (dialog_id
);
2427 popup_activated_flag
= 1;
2429 /* Process events that apply to the menu. */
2430 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
);
2432 lw_destroy_all_widgets (dialog_id
);
2434 /* Find the selected item, and its pane, to return
2435 the proper value. */
2436 if (menu_item_selection
!= 0)
2442 while (i
< menu_items_used
)
2446 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2449 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2450 i
+= MENU_ITEMS_PANE_LENGTH
;
2452 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2454 /* This is the boundary between left-side elts and
2461 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2462 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2466 entry
= Fcons (entry
, Qnil
);
2468 entry
= Fcons (prefix
, entry
);
2472 i
+= MENU_ITEMS_ITEM_LENGTH
;
2480 #else /* not USE_X_TOOLKIT */
2482 /* The frame of the last activated non-toolkit menu bar.
2483 Used to generate menu help events. */
2485 static struct frame
*menu_help_frame
;
2488 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2490 PANE is the pane number, and ITEM is the menu item number in
2491 the menu (currently not used).
2493 This cannot be done with generating a HELP_EVENT because
2494 XMenuActivate contains a loop that doesn't let Emacs process
2498 menu_help_callback (help_string
, pane
, item
)
2502 extern Lisp_Object Qmenu_item
;
2503 Lisp_Object
*first_item
;
2504 Lisp_Object pane_name
;
2505 Lisp_Object menu_object
;
2507 first_item
= XVECTOR (menu_items
)->contents
;
2508 if (EQ (first_item
[0], Qt
))
2509 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2510 else if (EQ (first_item
[0], Qquote
))
2511 /* This shouldn't happen, see xmenu_show. */
2512 pane_name
= build_string ("");
2514 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2516 /* (menu-item MENU-NAME PANE-NUMBER) */
2517 menu_object
= Fcons (Qmenu_item
,
2519 Fcons (make_number (pane
), Qnil
)));
2520 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2521 Qnil
, menu_object
, make_number (item
), 1);
2526 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2536 int pane
, selidx
, lpane
, status
;
2537 Lisp_Object entry
, pane_prefix
;
2539 int ulx
, uly
, width
, height
;
2540 int dispwidth
, dispheight
;
2544 unsigned int dummy_uint
;
2547 if (menu_items_n_panes
== 0)
2550 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2552 *error
= "Empty menu";
2556 /* Figure out which root window F is on. */
2557 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2558 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2559 &dummy_uint
, &dummy_uint
);
2561 /* Make the menu on that window. */
2562 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2565 *error
= "Can't create menu";
2569 #ifdef HAVE_X_WINDOWS
2570 /* Adjust coordinates to relative to the outer (window manager) window. */
2573 int win_x
= 0, win_y
= 0;
2575 /* Find the position of the outside upper-left corner of
2576 the inner window, with respect to the outer window. */
2577 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2580 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2582 /* From-window, to-window. */
2583 f
->output_data
.x
->window_desc
,
2584 f
->output_data
.x
->parent_desc
,
2586 /* From-position, to-position. */
2587 0, 0, &win_x
, &win_y
,
2589 /* Child of window. */
2596 #endif /* HAVE_X_WINDOWS */
2598 /* Adjust coordinates to be root-window-relative. */
2599 x
+= f
->output_data
.x
->left_pos
;
2600 y
+= f
->output_data
.x
->top_pos
;
2602 /* Create all the necessary panes and their items. */
2604 while (i
< menu_items_used
)
2606 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2608 /* Create a new pane. */
2609 Lisp_Object pane_name
, prefix
;
2612 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2613 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2614 pane_string
= (NILP (pane_name
)
2615 ? "" : (char *) XSTRING (pane_name
)->data
);
2616 if (keymaps
&& !NILP (prefix
))
2619 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2620 if (lpane
== XM_FAILURE
)
2622 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2623 *error
= "Can't create pane";
2626 i
+= MENU_ITEMS_PANE_LENGTH
;
2628 /* Find the width of the widest item in this pane. */
2631 while (j
< menu_items_used
)
2634 item
= XVECTOR (menu_items
)->contents
[j
];
2642 width
= STRING_BYTES (XSTRING (item
));
2643 if (width
> maxwidth
)
2646 j
+= MENU_ITEMS_ITEM_LENGTH
;
2649 /* Ignore a nil in the item list.
2650 It's meaningful only for dialog boxes. */
2651 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2655 /* Create a new item within current pane. */
2656 Lisp_Object item_name
, enable
, descrip
, help
;
2657 unsigned char *item_data
;
2660 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2661 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2663 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2664 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2665 help_string
= STRINGP (help
) ? XSTRING (help
)->data
: NULL
;
2667 if (!NILP (descrip
))
2669 int gap
= maxwidth
- STRING_BYTES (XSTRING (item_name
));
2672 spacer
= Fmake_string (make_number (gap
), make_number (' '));
2673 item_name
= concat2 (item_name
, spacer
);
2674 item_name
= concat2 (item_name
, descrip
);
2675 item_data
= XSTRING (item_name
)->data
;
2677 /* if alloca is fast, use that to make the space,
2678 to reduce gc needs. */
2680 = (unsigned char *) alloca (maxwidth
2681 + STRING_BYTES (XSTRING (descrip
)) + 1);
2682 bcopy (XSTRING (item_name
)->data
, item_data
,
2683 STRING_BYTES (XSTRING (item_name
)));
2684 for (j
= XSTRING (item_name
)->size
; j
< maxwidth
; j
++)
2686 bcopy (XSTRING (descrip
)->data
, item_data
+ j
,
2687 STRING_BYTES (XSTRING (descrip
)));
2688 item_data
[j
+ STRING_BYTES (XSTRING (descrip
))] = 0;
2692 item_data
= XSTRING (item_name
)->data
;
2694 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2695 menu
, lpane
, 0, item_data
,
2696 !NILP (enable
), help_string
)
2699 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2700 *error
= "Can't add selection to menu";
2703 i
+= MENU_ITEMS_ITEM_LENGTH
;
2707 /* All set and ready to fly. */
2708 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2709 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
),
2710 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2711 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
),
2712 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2713 x
= min (x
, dispwidth
);
2714 y
= min (y
, dispheight
);
2717 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2718 &ulx
, &uly
, &width
, &height
);
2719 if (ulx
+width
> dispwidth
)
2721 x
-= (ulx
+ width
) - dispwidth
;
2722 ulx
= dispwidth
- width
;
2724 if (uly
+height
> dispheight
)
2726 y
-= (uly
+ height
) - dispheight
;
2727 uly
= dispheight
- height
;
2729 if (ulx
< 0) x
-= ulx
;
2730 if (uly
< 0) y
-= uly
;
2732 XMenuSetAEQ (menu
, TRUE
);
2733 XMenuSetFreeze (menu
, TRUE
);
2736 /* Help display under X won't work because XMenuActivate contains
2737 a loop that doesn't give Emacs a chance to process it. */
2738 menu_help_frame
= f
;
2739 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2740 x
, y
, ButtonReleaseMask
, &datap
,
2741 menu_help_callback
);
2744 #ifdef HAVE_X_WINDOWS
2745 /* Assume the mouse has moved out of the X window.
2746 If it has actually moved in, we will get an EnterNotify. */
2747 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2754 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2757 /* Find the item number SELIDX in pane number PANE. */
2759 while (i
< menu_items_used
)
2761 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2765 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2767 i
+= MENU_ITEMS_PANE_LENGTH
;
2776 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2779 entry
= Fcons (entry
, Qnil
);
2780 if (!NILP (pane_prefix
))
2781 entry
= Fcons (pane_prefix
, entry
);
2787 i
+= MENU_ITEMS_ITEM_LENGTH
;
2793 *error
= "Can't activate menu";
2799 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2801 #ifdef HAVE_X_WINDOWS
2802 /* State that no mouse buttons are now held.
2803 (The oldXMenu code doesn't track this info for us.)
2804 That is not necessarily true, but the fiction leads to reasonable
2805 results, and it is a pain to ask which are actually held now. */
2806 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2812 #endif /* not USE_X_TOOLKIT */
2814 #endif /* HAVE_MENUS */
2819 staticpro (&menu_items
);
2822 Qdebug_on_next_call
= intern ("debug-on-next-call");
2823 staticpro (&Qdebug_on_next_call
);
2825 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
2826 "Frame for which we are updating a menu.\n\
2827 The enable predicate for a menu command should check this variable.");
2828 Vmenu_updating_frame
= Qnil
;
2830 #ifdef USE_X_TOOLKIT
2831 widget_id_tick
= (1<<16);
2832 next_menubar_widget_id
= 1;
2835 defsubr (&Sx_popup_menu
);
2837 defsubr (&Sx_popup_dialog
);