1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 88, 93, 94, 96, 99, 2000 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* X pop-up deck-of-cards menu facility for gnuemacs.
23 * Written by Jon Arnold and Roman Budzianowski
24 * Mods and rewrite by Robert Krawitz
28 /* Modified by Fred Pierresteguy on December 93
29 to make the popup menus and menubar use the Xt. */
31 /* Rewritten for clarity and GC protection by rms in Feb 94. */
35 /* On 4.3 this loses if it comes after xterm.h. */
40 #include "termhooks.h"
44 #include "blockinput.h"
52 /* This may include sys/types.h, and that somehow loses
53 if this is not done before the other system files. */
57 /* Load sys/types.h if not already loaded.
58 In some systems loading it twice is suicidal. */
60 #include <sys/types.h>
63 #include "dispextern.h"
66 #undef HAVE_MULTILINGUAL_MENU
69 #include <X11/IntrinsicP.h>
70 #include <X11/CoreP.h>
71 #include <X11/StringDefs.h>
72 #include <X11/Shell.h>
74 #include <X11/Xaw/Paned.h>
75 #endif /* USE_LUCID */
76 #include "../lwlib/lwlib.h"
77 #else /* not USE_X_TOOLKIT */
78 #include "../oldXMenu/XMenu.h"
79 #endif /* not USE_X_TOOLKIT */
80 #endif /* HAVE_X_WINDOWS */
83 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
86 #define min(x,y) (((x) < (y)) ? (x) : (y))
87 #define max(x,y) (((x) > (y)) ? (x) : (y))
94 Lisp_Object Vmenu_updating_frame
;
96 Lisp_Object Qdebug_on_next_call
;
98 extern Lisp_Object Qmenu_bar
;
99 extern Lisp_Object Qmouse_click
, Qevent_kind
;
101 extern Lisp_Object QCtoggle
, QCradio
;
103 extern Lisp_Object Voverriding_local_map
;
104 extern Lisp_Object Voverriding_local_map_menu_flag
;
106 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
108 extern Lisp_Object Qmenu_bar_update_hook
;
111 extern void set_frame_menubar ();
112 extern void process_expose_from_menu ();
113 extern XtAppContext Xt_app_con
;
115 static Lisp_Object
xdialog_show ();
116 void popup_get_selection ();
121 /* Define HAVE_BOXES if meus can handle radio and toggle buttons. */
126 static void push_menu_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
,
127 Lisp_Object
, Lisp_Object
, Lisp_Object
,
128 Lisp_Object
, Lisp_Object
));
129 static Lisp_Object
xmenu_show ();
130 static void keymap_panes ();
131 static void single_keymap_panes ();
132 static void single_menu_item ();
133 static void list_of_panes ();
134 static void list_of_items ();
136 /* This holds a Lisp vector that holds the results of decoding
137 the keymaps or alist-of-alists that specify a menu.
139 It describes the panes and items within the panes.
141 Each pane is described by 3 elements in the vector:
142 t, the pane name, the pane's prefix key.
143 Then follow the pane's items, with 5 elements per item:
144 the item string, the enable flag, the item's value,
145 the definition, and the equivalent keyboard key's description string.
147 In some cases, multiple levels of menus may be described.
148 A single vector slot containing nil indicates the start of a submenu.
149 A single vector slot containing lambda indicates the end of a submenu.
150 The submenu follows a menu item which is the way to reach the submenu.
152 A single vector slot containing quote indicates that the
153 following items should appear on the right of a dialog box.
155 Using a Lisp vector to hold this information while we decode it
156 takes care of protecting all the data from GC. */
158 #define MENU_ITEMS_PANE_NAME 1
159 #define MENU_ITEMS_PANE_PREFIX 2
160 #define MENU_ITEMS_PANE_LENGTH 3
164 MENU_ITEMS_ITEM_NAME
= 0,
165 MENU_ITEMS_ITEM_ENABLE
,
166 MENU_ITEMS_ITEM_VALUE
,
167 MENU_ITEMS_ITEM_EQUIV_KEY
,
168 MENU_ITEMS_ITEM_DEFINITION
,
169 MENU_ITEMS_ITEM_TYPE
,
170 MENU_ITEMS_ITEM_SELECTED
,
171 MENU_ITEMS_ITEM_HELP
,
172 MENU_ITEMS_ITEM_LENGTH
175 static Lisp_Object menu_items
;
177 /* Number of slots currently allocated in menu_items. */
178 static int menu_items_allocated
;
180 /* This is the index in menu_items of the first empty slot. */
181 static int menu_items_used
;
183 /* The number of panes currently recorded in menu_items,
184 excluding those within submenus. */
185 static int menu_items_n_panes
;
187 /* Current depth within submenus. */
188 static int menu_items_submenu_depth
;
190 /* Flag which when set indicates a dialog or menu has been posted by
191 Xt on behalf of one of the widget sets. */
192 int popup_activated_flag
;
194 static int next_menubar_widget_id
;
196 /* This is set nonzero after the user activates the menu bar, and set
197 to zero again after the menu bars are redisplayed by prepare_menu_bar.
198 While it is nonzero, all calls to set_frame_menubar go deep.
200 I don't understand why this is needed, but it does seem to be
201 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
203 int pending_menu_activation
;
207 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
209 static struct frame
*
210 menubar_id_to_frame (id
)
213 Lisp_Object tail
, frame
;
216 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
219 if (!GC_FRAMEP (frame
))
222 if (!FRAME_WINDOW_P (f
))
224 if (f
->output_data
.x
->id
== id
)
232 /* Initialize the menu_items structure if we haven't already done so.
233 Also mark it as currently empty. */
238 if (NILP (menu_items
))
240 menu_items_allocated
= 60;
241 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
245 menu_items_n_panes
= 0;
246 menu_items_submenu_depth
= 0;
249 /* Call at the end of generating the data in menu_items.
250 This fills in the number of items in the last pane. */
257 /* Call when finished using the data for the current menu
261 discard_menu_items ()
263 /* Free the structure if it is especially large.
264 Otherwise, hold on to it, to save time. */
265 if (menu_items_allocated
> 200)
268 menu_items_allocated
= 0;
272 /* Make the menu_items vector twice as large. */
278 int old_size
= menu_items_allocated
;
281 menu_items_allocated
*= 2;
282 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
283 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
284 old_size
* sizeof (Lisp_Object
));
287 /* Begin a submenu. */
290 push_submenu_start ()
292 if (menu_items_used
+ 1 > menu_items_allocated
)
295 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
296 menu_items_submenu_depth
++;
304 if (menu_items_used
+ 1 > menu_items_allocated
)
307 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
308 menu_items_submenu_depth
--;
311 /* Indicate boundary between left and right. */
314 push_left_right_boundary ()
316 if (menu_items_used
+ 1 > menu_items_allocated
)
319 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
322 /* Start a new menu pane in menu_items..
323 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
326 push_menu_pane (name
, prefix_vec
)
327 Lisp_Object name
, prefix_vec
;
329 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
332 if (menu_items_submenu_depth
== 0)
333 menu_items_n_panes
++;
334 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
335 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
336 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
339 /* Push one menu item into the current pane. NAME is the string to
340 display. ENABLE if non-nil means this item can be selected. KEY
341 is the key generated by choosing this item, or nil if this item
342 doesn't really have a definition. DEF is the definition of this
343 item. EQUIV is the textual description of the keyboard equivalent
344 for this item (or nil if none). TYPE is the type of this menu
345 item, one of nil, `toggle' or `radio'. */
348 push_menu_item (name
, enable
, key
, def
, equiv
, type
, selected
, help
)
349 Lisp_Object name
, enable
, key
, def
, equiv
, type
, selected
, help
;
351 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
354 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
355 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
356 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
357 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
358 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
359 XVECTOR (menu_items
)->contents
[menu_items_used
++] = type
;
360 XVECTOR (menu_items
)->contents
[menu_items_used
++] = selected
;
361 XVECTOR (menu_items
)->contents
[menu_items_used
++] = help
;
364 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
365 and generate menu panes for them in menu_items.
366 If NOTREAL is nonzero,
367 don't bother really computing whether an item is enabled. */
370 keymap_panes (keymaps
, nmaps
, notreal
)
371 Lisp_Object
*keymaps
;
379 /* Loop over the given keymaps, making a pane for each map.
380 But don't make a pane that is empty--ignore that map instead.
381 P is the number of panes we have made so far. */
382 for (mapno
= 0; mapno
< nmaps
; mapno
++)
383 single_keymap_panes (keymaps
[mapno
],
384 map_prompt (keymaps
[mapno
]), Qnil
, notreal
, 10);
386 finish_menu_items ();
389 /* This is a recursive subroutine of keymap_panes.
390 It handles one keymap, KEYMAP.
391 The other arguments are passed along
392 or point to local variables of the previous function.
393 If NOTREAL is nonzero, only check for equivalent key bindings, don't
394 evaluate expressions in menu items and don't make any menu.
396 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
399 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
401 Lisp_Object pane_name
;
406 Lisp_Object pending_maps
= Qnil
;
407 Lisp_Object tail
, item
;
408 struct gcpro gcpro1
, gcpro2
;
414 push_menu_pane (pane_name
, prefix
);
417 /* Remember index for first item in this pane so we can go back and
418 add a prefix when (if) we see the first button. After that, notbuttons
419 is set to 0, to mark that we have seen a button and all non button
420 items need a prefix. */
421 notbuttons
= menu_items_used
;
424 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
426 GCPRO2 (keymap
, pending_maps
);
427 /* Look at each key binding, and if it is a menu item add it
431 single_menu_item (XCAR (item
), XCDR (item
),
432 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
433 else if (VECTORP (item
))
435 /* Loop over the char values represented in the vector. */
436 int len
= XVECTOR (item
)->size
;
438 for (c
= 0; c
< len
; c
++)
440 Lisp_Object character
;
441 XSETFASTINT (character
, c
);
442 single_menu_item (character
, XVECTOR (item
)->contents
[c
],
443 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
449 /* Process now any submenus which want to be panes at this level. */
450 while (!NILP (pending_maps
))
452 Lisp_Object elt
, eltcdr
, string
;
453 elt
= Fcar (pending_maps
);
455 string
= XCAR (eltcdr
);
456 /* We no longer discard the @ from the beginning of the string here.
457 Instead, we do this in xmenu_show. */
458 single_keymap_panes (Fcar (elt
), string
,
459 XCDR (eltcdr
), notreal
, maxdepth
- 1);
460 pending_maps
= Fcdr (pending_maps
);
464 /* This is a subroutine of single_keymap_panes that handles one
466 KEY is a key in a keymap and ITEM is its binding.
467 PENDING_MAPS_PTR points to a list of keymaps waiting to be made into
469 If NOTREAL is nonzero, only check for equivalent key bindings, don't
470 evaluate expressions in menu items and don't make any menu.
471 If we encounter submenus deeper than MAXDEPTH levels, ignore them.
472 NOTBUTTONS_PTR is only used when simulating toggle boxes and radio
473 buttons. It points to variable notbuttons in single_keymap_panes,
474 which keeps track of if we have seen a button in this menu or not. */
477 single_menu_item (key
, item
, pending_maps_ptr
, notreal
, maxdepth
,
479 Lisp_Object key
, item
;
480 Lisp_Object
*pending_maps_ptr
;
481 int maxdepth
, notreal
;
484 Lisp_Object map
, item_string
, enabled
;
485 struct gcpro gcpro1
, gcpro2
;
488 /* Parse the menu item and leave the result in item_properties. */
490 res
= parse_menu_item (item
, notreal
, 0);
493 return; /* Not a menu item. */
495 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
499 /* We don't want to make a menu, just traverse the keymaps to
500 precompute equivalent key bindings. */
502 single_keymap_panes (map
, Qnil
, key
, 1, maxdepth
- 1);
506 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
507 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
509 if (!NILP (map
) && XSTRING (item_string
)->data
[0] == '@')
512 /* An enabled separate pane. Remember this to handle it later. */
513 *pending_maps_ptr
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
519 /* Simulate radio buttons and toggle boxes by putting a prefix in
522 Lisp_Object prefix
= Qnil
;
523 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
527 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
530 /* The first button. Line up previous items in this menu. */
532 int index
= *notbuttons_ptr
; /* Index for first item this menu. */
535 while (index
< menu_items_used
)
538 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
542 submenu
++; /* Skip sub menu. */
544 else if (EQ (tem
, Qlambda
))
547 submenu
--; /* End sub menu. */
549 else if (EQ (tem
, Qt
))
550 index
+= 3; /* Skip new pane marker. */
551 else if (EQ (tem
, Qquote
))
552 index
++; /* Skip a left, right divider. */
555 if (!submenu
&& XSTRING (tem
)->data
[0] != '\0'
556 && XSTRING (tem
)->data
[0] != '-')
557 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
558 = concat2 (build_string (" "), tem
);
559 index
+= MENU_ITEMS_ITEM_LENGTH
;
565 /* Calculate prefix, if any, for this item. */
566 if (EQ (type
, QCtoggle
))
567 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
568 else if (EQ (type
, QCradio
))
569 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
571 /* Not a button. If we have earlier buttons, then we need a prefix. */
572 else if (!*notbuttons_ptr
&& XSTRING (item_string
)->data
[0] != '\0'
573 && XSTRING (item_string
)->data
[0] != '-')
574 prefix
= build_string (" ");
577 item_string
= concat2 (prefix
, item_string
);
579 #endif /* not HAVE_BOXES */
581 #ifndef USE_X_TOOLKIT
583 /* Indicate visually that this is a submenu. */
584 item_string
= concat2 (item_string
, build_string (" >"));
587 push_menu_item (item_string
, enabled
, key
,
588 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
589 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
590 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
591 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
592 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
595 /* Display a submenu using the toolkit. */
596 if (! (NILP (map
) || NILP (enabled
)))
598 push_submenu_start ();
599 single_keymap_panes (map
, Qnil
, key
, 0, maxdepth
- 1);
605 /* Push all the panes and items of a menu described by the
606 alist-of-alists MENU.
607 This handles old-fashioned calls to x-popup-menu. */
617 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
619 Lisp_Object elt
, pane_name
, pane_data
;
621 pane_name
= Fcar (elt
);
622 CHECK_STRING (pane_name
, 0);
623 push_menu_pane (pane_name
, Qnil
);
624 pane_data
= Fcdr (elt
);
625 CHECK_CONS (pane_data
, 0);
626 list_of_items (pane_data
);
629 finish_menu_items ();
632 /* Push the items in a single pane defined by the alist PANE. */
638 Lisp_Object tail
, item
, item1
;
640 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
644 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
645 else if (NILP (item
))
646 push_left_right_boundary ();
649 CHECK_CONS (item
, 0);
651 CHECK_STRING (item1
, 1);
652 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
657 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
658 "Pop up a deck-of-cards menu and return user's selection.\n\
659 POSITION is a position specification. This is either a mouse button event\n\
660 or a list ((XOFFSET YOFFSET) WINDOW)\n\
661 where XOFFSET and YOFFSET are positions in pixels from the top left\n\
662 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
663 This controls the position of the center of the first line\n\
664 in the first pane of the menu, not the top left of the menu as a whole.\n\
665 If POSITION is t, it means to use the current mouse position.\n\
667 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
668 The menu items come from key bindings that have a menu string as well as\n\
669 a definition; actually, the \"definition\" in such a key binding looks like\n\
670 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
671 the keymap as a top-level element.\n\n\
672 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.\n\
673 Otherwise, REAL-DEFINITION should be a valid key binding definition.\n\
675 You can also use a list of keymaps as MENU.\n\
676 Then each keymap makes a separate pane.\n\
677 When MENU is a keymap or a list of keymaps, the return value\n\
678 is a list of events.\n\n\
680 Alternatively, you can specify a menu of multiple panes\n\
681 with a list of the form (TITLE PANE1 PANE2...),\n\
682 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
683 Each ITEM is normally a cons cell (STRING . VALUE);\n\
684 but a string can appear as an item--that makes a nonselectable line\n\
686 With this form of menu, the return value is VALUE from the chosen item.\n\
688 If POSITION is nil, don't display the menu at all, just precalculate the\n\
689 cached information about equivalent key sequences.")
691 Lisp_Object position
, menu
;
693 Lisp_Object keymap
, tem
;
694 int xpos
= 0, ypos
= 0;
697 Lisp_Object selection
;
698 struct frame
*f
= NULL
;
699 Lisp_Object x
, y
, window
;
705 if (! NILP (position
))
709 /* Decode the first argument: find the window and the coordinates. */
710 if (EQ (position
, Qt
)
711 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
712 || EQ (XCAR (position
), Qtool_bar
))))
714 /* Use the mouse's current position. */
715 FRAME_PTR new_f
= SELECTED_FRAME ();
716 Lisp_Object bar_window
;
717 enum scroll_bar_part part
;
720 if (mouse_position_hook
)
721 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
722 &part
, &x
, &y
, &time
);
724 XSETFRAME (window
, new_f
);
727 window
= selected_window
;
734 tem
= Fcar (position
);
737 window
= Fcar (Fcdr (position
));
739 y
= Fcar (Fcdr (tem
));
744 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
745 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
746 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
755 /* Decode where to put the menu. */
763 else if (WINDOWP (window
))
765 CHECK_LIVE_WINDOW (window
, 0);
766 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
768 xpos
= (FONT_WIDTH (f
->output_data
.x
->font
)
769 * XFASTINT (XWINDOW (window
)->left
));
770 ypos
= (f
->output_data
.x
->line_height
771 * XFASTINT (XWINDOW (window
)->top
));
774 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
775 but I don't want to make one now. */
776 CHECK_WINDOW (window
, 0);
781 XSETFRAME (Vmenu_updating_frame
, f
);
783 Vmenu_updating_frame
= Qnil
;
784 #endif /* HAVE_MENUS */
789 /* Decode the menu items from what was specified. */
791 keymap
= get_keymap (menu
, 0, 0);
794 /* We were given a keymap. Extract menu info from the keymap. */
797 /* Extract the detailed info to make one pane. */
798 keymap_panes (&menu
, 1, NILP (position
));
800 /* Search for a string appearing directly as an element of the keymap.
801 That string is the title of the menu. */
802 prompt
= map_prompt (keymap
);
803 if (NILP (title
) && !NILP (prompt
))
806 /* Make that be the pane title of the first pane. */
807 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
808 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
812 else if (CONSP (menu
) && KEYMAPP (XCAR (menu
)))
814 /* We were given a list of keymaps. */
815 int nmaps
= XFASTINT (Flength (menu
));
817 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
822 /* The first keymap that has a prompt string
823 supplies the menu title. */
824 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
828 maps
[i
++] = keymap
= get_keymap (Fcar (tem
), 1, 0);
830 prompt
= map_prompt (keymap
);
831 if (NILP (title
) && !NILP (prompt
))
835 /* Extract the detailed info to make one pane. */
836 keymap_panes (maps
, nmaps
, NILP (position
));
838 /* Make the title be the pane title of the first pane. */
839 if (!NILP (title
) && menu_items_n_panes
>= 0)
840 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
846 /* We were given an old-fashioned menu. */
848 CHECK_STRING (title
, 1);
850 list_of_panes (Fcdr (menu
));
857 discard_menu_items ();
863 /* Display them in a menu. */
866 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
867 keymaps
, title
, &error_name
);
870 discard_menu_items ();
873 #endif /* HAVE_MENUS */
875 if (error_name
) error (error_name
);
881 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
882 "Pop up a dialog box and return user's selection.\n\
883 POSITION specifies which frame to use.\n\
884 This is normally a mouse button event or a window or frame.\n\
885 If POSITION is t, it means to use the frame the mouse is on.\n\
886 The dialog box appears in the middle of the specified frame.\n\
888 CONTENTS specifies the alternatives to display in the dialog box.\n\
889 It is a list of the form (TITLE ITEM1 ITEM2...).\n\
890 Each ITEM is a cons cell (STRING . VALUE).\n\
891 The return value is VALUE from the chosen item.\n\n\
892 An ITEM may also be just a string--that makes a nonselectable item.\n\
893 An ITEM may also be nil--that means to put all preceding items\n\
894 on the left of the dialog box and all following items on the right.\n\
895 \(By default, approximately half appear on each side.)")
897 Lisp_Object position
, contents
;
899 struct frame
* f
= NULL
;
904 /* Decode the first argument: find the window or frame to use. */
905 if (EQ (position
, Qt
)
906 || (CONSP (position
) && (EQ (XCAR (position
), Qmenu_bar
)
907 || EQ (XCAR (position
), Qtool_bar
))))
909 #if 0 /* Using the frame the mouse is on may not be right. */
910 /* Use the mouse's current position. */
911 FRAME_PTR new_f
= SELECTED_FRAME ();
912 Lisp_Object bar_window
;
917 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
920 XSETFRAME (window
, new_f
);
922 window
= selected_window
;
924 window
= selected_window
;
926 else if (CONSP (position
))
929 tem
= Fcar (position
);
931 window
= Fcar (Fcdr (position
));
934 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
935 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
938 else if (WINDOWP (position
) || FRAMEP (position
))
943 /* Decode where to put the menu. */
947 else if (WINDOWP (window
))
949 CHECK_LIVE_WINDOW (window
, 0);
950 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
953 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
954 but I don't want to make one now. */
955 CHECK_WINDOW (window
, 0);
957 #ifndef USE_X_TOOLKIT
958 /* Display a menu with these alternatives
959 in the middle of frame F. */
961 Lisp_Object x
, y
, frame
, newpos
;
962 XSETFRAME (frame
, f
);
963 XSETINT (x
, x_pixel_width (f
) / 2);
964 XSETINT (y
, x_pixel_height (f
) / 2);
965 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
967 return Fx_popup_menu (newpos
,
968 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
974 Lisp_Object selection
;
976 /* Decode the dialog items from what was specified. */
977 title
= Fcar (contents
);
978 CHECK_STRING (title
, 1);
980 list_of_panes (Fcons (contents
, Qnil
));
982 /* Display them in a dialog box. */
984 selection
= xdialog_show (f
, 0, title
, &error_name
);
987 discard_menu_items ();
989 if (error_name
) error (error_name
);
997 /* Loop in Xt until the menu pulldown or dialog popup has been
998 popped down (deactivated). This is used for x-popup-menu
999 and x-popup-dialog; it is not used for the menu bar any more.
1001 NOTE: All calls to popup_get_selection should be protected
1002 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1005 popup_get_selection (initial_event
, dpyinfo
, id
)
1006 XEvent
*initial_event
;
1007 struct x_display_info
*dpyinfo
;
1012 /* Define a queue to save up for later unreading
1013 all X events that don't pertain to the menu. */
1017 struct event_queue
*next
;
1020 struct event_queue
*queue
= NULL
;
1021 struct event_queue
*queue_tmp
;
1024 event
= *initial_event
;
1026 XtAppNextEvent (Xt_app_con
, &event
);
1030 /* Handle expose events for editor frames right away. */
1031 if (event
.type
== Expose
)
1032 process_expose_from_menu (event
);
1033 /* Make sure we don't consider buttons grabbed after menu goes.
1034 And make sure to deactivate for any ButtonRelease,
1035 even if XtDispatchEvent doesn't do that. */
1036 else if (event
.type
== ButtonRelease
1037 && dpyinfo
->display
== event
.xbutton
.display
)
1039 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1040 popup_activated_flag
= 0;
1041 #ifdef USE_MOTIF /* Pretending that the event came from a
1042 Btn1Down seems the only way to convince Motif to
1043 activate its callbacks; setting the XmNmenuPost
1044 isn't working. --marcus@sysc.pdx.edu. */
1045 event
.xbutton
.button
= 1;
1048 /* If the user presses a key, deactivate the menu.
1049 The user is likely to do that if we get wedged. */
1050 else if (event
.type
== KeyPress
1051 && dpyinfo
->display
== event
.xbutton
.display
)
1053 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1054 if (!IsModifierKey (keysym
))
1056 popup_activated_flag
= 0;
1060 /* Button presses outside the menu also pop it down. */
1061 else if (event
.type
== ButtonPress
1062 && event
.xany
.display
== dpyinfo
->display
1063 && x_any_window_to_frame (dpyinfo
, event
.xany
.window
))
1065 popup_activated_flag
= 0;
1069 /* Queue all events not for this popup,
1070 except for Expose, which we've already handled, and ButtonRelease.
1071 Note that the X window is associated with the frame if this
1072 is a menu bar popup, but not if it's a dialog box. So we use
1073 x_non_menubar_window_to_frame, not x_any_window_to_frame. */
1074 if (event
.type
!= Expose
1075 && !(event
.type
== ButtonRelease
1076 && dpyinfo
->display
== event
.xbutton
.display
)
1077 && (event
.xany
.display
!= dpyinfo
->display
1078 || x_non_menubar_window_to_frame (dpyinfo
, event
.xany
.window
)))
1080 queue_tmp
= (struct event_queue
*) malloc (sizeof (struct event_queue
));
1082 if (queue_tmp
!= NULL
)
1084 queue_tmp
->event
= event
;
1085 queue_tmp
->next
= queue
;
1090 XtDispatchEvent (&event
);
1092 if (!popup_activated ())
1094 XtAppNextEvent (Xt_app_con
, &event
);
1097 /* Unread any events that we got but did not handle. */
1098 while (queue
!= NULL
)
1101 XPutBackEvent (queue_tmp
->event
.xany
.display
, &queue_tmp
->event
);
1102 queue
= queue_tmp
->next
;
1103 xfree ((char *)queue_tmp
);
1104 /* Cause these events to get read as soon as we UNBLOCK_INPUT. */
1105 interrupt_input_pending
= 1;
1109 /* Activate the menu bar of frame F.
1110 This is called from keyboard.c when it gets the
1111 menu_bar_activate_event out of the Emacs event queue.
1113 To activate the menu bar, we use the X button-press event
1114 that was saved in saved_menu_event.
1115 That makes the toolkit do its thing.
1117 But first we recompute the menu bar contents (the whole tree).
1119 The reason for saving the button event until here, instead of
1120 passing it to the toolkit right away, is that we can safely
1121 execute Lisp code. */
1124 x_activate_menubar (f
)
1127 if (!f
->output_data
.x
->saved_menu_event
->type
)
1130 set_frame_menubar (f
, 0, 1);
1132 XtDispatchEvent ((XEvent
*) f
->output_data
.x
->saved_menu_event
);
1135 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1136 pending_menu_activation
= 1;
1139 /* Ignore this if we get it a second time. */
1140 f
->output_data
.x
->saved_menu_event
->type
= 0;
1143 /* Detect if a dialog or menu has been posted. */
1148 return popup_activated_flag
;
1151 /* This callback is invoked when the user selects a menubar cascade
1152 pushbutton, but before the pulldown menu is posted. */
1155 popup_activate_callback (widget
, id
, client_data
)
1158 XtPointer client_data
;
1161 ++popup_activated_flag
;
1163 popup_activated_flag
= 1;
1167 /* This callback is invoked when a dialog or menu is finished being
1168 used and has been unposted. */
1171 popup_deactivate_callback (widget
, id
, client_data
)
1174 XtPointer client_data
;
1177 --popup_activated_flag
;
1179 popup_activated_flag
= 0;
1183 /* Lwlib callback called when menu items are highlighted/unhighlighted
1184 while moving the mouse over them. WIDGET is the menu bar or menu
1185 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1186 the widget_value structure for the menu item, or null in case of
1190 menu_highlight_callback (widget
, id
, call_data
)
1195 widget_value
*wv
= (widget_value
*) call_data
;
1197 Lisp_Object frame
, help
;
1199 help
= wv
&& wv
->help
? build_string (wv
->help
) : Qnil
;
1201 /* Determine the frame for the help event. */
1202 f
= menubar_id_to_frame (id
);
1205 XSETFRAME (frame
, f
);
1206 kbd_buffer_store_help_event (frame
, help
);
1210 /* WIDGET is the popup menu. It's parent is the frame's
1211 widget. See which frame that is. */
1212 Widget frame_widget
= XtParent (widget
);
1215 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1217 frame
= XCAR (tail
);
1218 if (GC_FRAMEP (frame
)
1219 && (f
= XFRAME (frame
),
1220 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1224 show_help_echo (help
, Qnil
, Qnil
, Qnil
, 1);
1228 /* This callback is called from the menu bar pulldown menu
1229 when the user makes a selection.
1230 Figure out what the user chose
1231 and put the appropriate events into the keyboard buffer. */
1234 menubar_selection_callback (widget
, id
, client_data
)
1237 XtPointer client_data
;
1239 Lisp_Object prefix
, entry
;
1240 FRAME_PTR f
= menubar_id_to_frame (id
);
1242 Lisp_Object
*subprefix_stack
;
1243 int submenu_depth
= 0;
1249 subprefix_stack
= (Lisp_Object
*) alloca (f
->menu_bar_items_used
* sizeof (Lisp_Object
));
1250 vector
= f
->menu_bar_vector
;
1253 while (i
< f
->menu_bar_items_used
)
1255 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1257 subprefix_stack
[submenu_depth
++] = prefix
;
1261 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1263 prefix
= subprefix_stack
[--submenu_depth
];
1266 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1268 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1269 i
+= MENU_ITEMS_PANE_LENGTH
;
1273 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1274 /* The EMACS_INT cast avoids a warning. There's no problem
1275 as long as pointers have enough bits to hold small integers. */
1276 if ((int) (EMACS_INT
) client_data
== i
)
1279 struct input_event buf
;
1282 XSETFRAME (frame
, f
);
1283 buf
.kind
= MENU_BAR_EVENT
;
1284 buf
.frame_or_window
= frame
;
1286 kbd_buffer_store_event (&buf
);
1288 for (j
= 0; j
< submenu_depth
; j
++)
1289 if (!NILP (subprefix_stack
[j
]))
1291 buf
.kind
= MENU_BAR_EVENT
;
1292 buf
.frame_or_window
= frame
;
1293 buf
.arg
= subprefix_stack
[j
];
1294 kbd_buffer_store_event (&buf
);
1299 buf
.kind
= MENU_BAR_EVENT
;
1300 buf
.frame_or_window
= frame
;
1302 kbd_buffer_store_event (&buf
);
1305 buf
.kind
= MENU_BAR_EVENT
;
1306 buf
.frame_or_window
= frame
;
1308 kbd_buffer_store_event (&buf
);
1312 i
+= MENU_ITEMS_ITEM_LENGTH
;
1317 /* Allocate a widget_value, blocking input. */
1320 xmalloc_widget_value ()
1322 widget_value
*value
;
1325 value
= malloc_widget_value ();
1331 /* This recursively calls free_widget_value on the tree of widgets.
1332 It must free all data that was malloc'ed for these widget_values.
1333 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1334 must be left alone. */
1337 free_menubar_widget_value_tree (wv
)
1342 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1344 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1346 free_menubar_widget_value_tree (wv
->contents
);
1347 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1351 free_menubar_widget_value_tree (wv
->next
);
1352 wv
->next
= (widget_value
*) 0xDEADBEEF;
1355 free_widget_value (wv
);
1359 /* Return a tree of widget_value structures for a menu bar item
1360 whose event type is ITEM_KEY (with string ITEM_NAME)
1361 and whose contents come from the list of keymaps MAPS. */
1363 static widget_value
*
1364 single_submenu (item_key
, item_name
, maps
)
1365 Lisp_Object item_key
, item_name
, maps
;
1367 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1369 int submenu_depth
= 0;
1372 Lisp_Object
*mapvec
;
1373 widget_value
**submenu_stack
;
1374 int previous_items
= menu_items_used
;
1375 int top_level_items
= 0;
1377 length
= Flength (maps
);
1378 len
= XINT (length
);
1380 /* Convert the list MAPS into a vector MAPVEC. */
1381 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1382 for (i
= 0; i
< len
; i
++)
1384 mapvec
[i
] = Fcar (maps
);
1388 menu_items_n_panes
= 0;
1390 /* Loop over the given keymaps, making a pane for each map.
1391 But don't make a pane that is empty--ignore that map instead. */
1392 for (i
= 0; i
< len
; i
++)
1394 if (SYMBOLP (mapvec
[i
])
1395 || (CONSP (mapvec
[i
]) && !KEYMAPP (mapvec
[i
])))
1397 /* Here we have a command at top level in the menu bar
1398 as opposed to a submenu. */
1399 top_level_items
= 1;
1400 push_menu_pane (Qnil
, Qnil
);
1401 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1402 Qnil
, Qnil
, Qnil
, Qnil
);
1405 single_keymap_panes (mapvec
[i
], item_name
, item_key
, 0, 10);
1408 /* Create a tree of widget_value objects
1409 representing the panes and their items. */
1412 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1413 wv
= xmalloc_widget_value ();
1417 wv
->button_type
= BUTTON_TYPE_NONE
;
1422 /* Loop over all panes and items made during this call
1423 and construct a tree of widget_value objects.
1424 Ignore the panes and items made by previous calls to
1425 single_submenu, even though those are also in menu_items. */
1427 while (i
< menu_items_used
)
1429 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1431 submenu_stack
[submenu_depth
++] = save_wv
;
1436 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1439 save_wv
= submenu_stack
[--submenu_depth
];
1442 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1443 && submenu_depth
!= 0)
1444 i
+= MENU_ITEMS_PANE_LENGTH
;
1445 /* Ignore a nil in the item list.
1446 It's meaningful only for dialog boxes. */
1447 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1449 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1451 /* Create a new pane. */
1452 Lisp_Object pane_name
, prefix
;
1454 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1455 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1456 #ifndef HAVE_MULTILINGUAL_MENU
1457 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1458 pane_name
= string_make_unibyte (pane_name
);
1460 pane_string
= (NILP (pane_name
)
1461 ? "" : (char *) XSTRING (pane_name
)->data
);
1462 /* If there is just one top-level pane, put all its items directly
1463 under the top-level menu. */
1464 if (menu_items_n_panes
== 1)
1467 /* If the pane has a meaningful name,
1468 make the pane a top-level menu item
1469 with its items as a submenu beneath it. */
1470 if (strcmp (pane_string
, ""))
1472 wv
= xmalloc_widget_value ();
1476 first_wv
->contents
= wv
;
1477 wv
->name
= pane_string
;
1478 /* Ignore the @ that means "separate pane".
1479 This is a kludge, but this isn't worth more time. */
1480 if (!NILP (prefix
) && wv
->name
[0] == '@')
1484 wv
->button_type
= BUTTON_TYPE_NONE
;
1488 i
+= MENU_ITEMS_PANE_LENGTH
;
1492 /* Create a new item within current pane. */
1493 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1496 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1497 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1499 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1500 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
1501 type
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_TYPE
];
1502 selected
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_SELECTED
];
1503 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
1505 #ifndef HAVE_MULTILINGUAL_MENU
1506 if (STRING_MULTIBYTE (item_name
))
1507 item_name
= string_make_unibyte (item_name
);
1508 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1509 descrip
= string_make_unibyte (descrip
);
1512 wv
= xmalloc_widget_value ();
1516 save_wv
->contents
= wv
;
1518 wv
->name
= (char *) XSTRING (item_name
)->data
;
1519 if (!NILP (descrip
))
1520 wv
->key
= (char *) XSTRING (descrip
)->data
;
1522 /* The EMACS_INT cast avoids a warning. There's no problem
1523 as long as pointers have enough bits to hold small integers. */
1524 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1525 wv
->enabled
= !NILP (enable
);
1528 wv
->button_type
= BUTTON_TYPE_NONE
;
1529 else if (EQ (type
, QCradio
))
1530 wv
->button_type
= BUTTON_TYPE_RADIO
;
1531 else if (EQ (type
, QCtoggle
))
1532 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1536 wv
->selected
= !NILP (selected
);
1538 wv
->help
= XSTRING (help
)->data
;
1542 i
+= MENU_ITEMS_ITEM_LENGTH
;
1546 /* If we have just one "menu item"
1547 that was originally a button, return it by itself. */
1548 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1550 wv
= first_wv
->contents
;
1551 free_widget_value (first_wv
);
1558 extern void EmacsFrameSetCharSize ();
1560 /* Recompute all the widgets of frame F, when the menu bar
1561 has been changed. */
1564 update_frame_menubar (f
)
1567 struct x_output
*x
= f
->output_data
.x
;
1569 int menubar_changed
;
1571 /* We assume the menubar contents has changed if the global flag is set,
1572 or if the current buffer has changed, or if the menubar has never
1573 been updated before.
1575 menubar_changed
= (x
->menubar_widget
1576 && !XtIsManaged (x
->menubar_widget
));
1578 if (! (menubar_changed
))
1582 /* Save the size of the frame because the pane widget doesn't accept to
1583 resize itself. So force it. */
1587 /* Do the voodoo which means "I'm changing lots of things, don't try to
1588 refigure sizes until I'm done." */
1589 lw_refigure_widget (x
->column_widget
, False
);
1591 /* the order in which children are managed is the top to
1592 bottom order in which they are displayed in the paned window.
1593 First, remove the text-area widget.
1595 XtUnmanageChild (x
->edit_widget
);
1597 /* remove the menubar that is there now, and put up the menubar that
1600 if (menubar_changed
)
1602 XtManageChild (x
->menubar_widget
);
1603 XtMapWidget (x
->menubar_widget
);
1604 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, NULL
);
1607 /* Re-manage the text-area widget, and then thrash the sizes. */
1608 XtManageChild (x
->edit_widget
);
1609 x_set_menu_resources_from_menu_face (f
, x
->menubar_widget
);
1610 lw_refigure_widget (x
->column_widget
, True
);
1612 /* Force the pane widget to resize itself with the right values. */
1613 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1617 /* Set the contents of the menubar widgets of frame F.
1618 The argument FIRST_TIME is currently ignored;
1619 it is set the first time this is called, from initialize_frame_menubar. */
1622 set_frame_menubar (f
, first_time
, deep_p
)
1627 Widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1629 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1633 XSETFRAME (Vmenu_updating_frame
, f
);
1635 if (f
->output_data
.x
->id
== 0)
1636 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1637 id
= f
->output_data
.x
->id
;
1639 if (! menubar_widget
)
1641 else if (pending_menu_activation
&& !deep_p
)
1643 /* Make the first call for any given frame always go deep. */
1644 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1647 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1648 f
->output_data
.x
->saved_menu_event
->type
= 0;
1651 wv
= xmalloc_widget_value ();
1652 wv
->name
= "menubar";
1655 wv
->button_type
= BUTTON_TYPE_NONE
;
1660 /* Make a widget-value tree representing the entire menu trees. */
1662 struct buffer
*prev
= current_buffer
;
1664 int specpdl_count
= specpdl_ptr
- specpdl
;
1665 int previous_menu_items_used
= f
->menu_bar_items_used
;
1666 Lisp_Object
*previous_items
1667 = (Lisp_Object
*) alloca (previous_menu_items_used
1668 * sizeof (Lisp_Object
));
1670 /* If we are making a new widget, its contents are empty,
1671 do always reinitialize them. */
1672 if (! menubar_widget
)
1673 previous_menu_items_used
= 0;
1675 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1676 specbind (Qinhibit_quit
, Qt
);
1677 /* Don't let the debugger step into this code
1678 because it is not reentrant. */
1679 specbind (Qdebug_on_next_call
, Qnil
);
1681 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1682 if (NILP (Voverriding_local_map_menu_flag
))
1684 specbind (Qoverriding_terminal_local_map
, Qnil
);
1685 specbind (Qoverriding_local_map
, Qnil
);
1688 set_buffer_internal_1 (XBUFFER (buffer
));
1690 /* Run the Lucid hook. */
1691 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1692 /* If it has changed current-menubar from previous value,
1693 really recompute the menubar from the value. */
1694 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1695 call0 (Qrecompute_lucid_menubar
);
1696 safe_run_hooks (Qmenu_bar_update_hook
);
1697 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1699 items
= FRAME_MENU_BAR_ITEMS (f
);
1701 inhibit_garbage_collection ();
1703 /* Save the frame's previous menu bar contents data. */
1704 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1705 previous_menu_items_used
* sizeof (Lisp_Object
));
1707 /* Fill in the current menu bar contents. */
1708 menu_items
= f
->menu_bar_vector
;
1709 menu_items_allocated
= XVECTOR (menu_items
)->size
;
1711 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1713 Lisp_Object key
, string
, maps
;
1715 key
= XVECTOR (items
)->contents
[i
];
1716 string
= XVECTOR (items
)->contents
[i
+ 1];
1717 maps
= XVECTOR (items
)->contents
[i
+ 2];
1721 wv
= single_submenu (key
, string
, maps
);
1725 first_wv
->contents
= wv
;
1726 /* Don't set wv->name here; GC during the loop might relocate it. */
1728 wv
->button_type
= BUTTON_TYPE_NONE
;
1732 finish_menu_items ();
1734 set_buffer_internal_1 (prev
);
1735 unbind_to (specpdl_count
, Qnil
);
1737 /* If there has been no change in the Lisp-level contents
1738 of the menu bar, skip redisplaying it. Just exit. */
1740 for (i
= 0; i
< previous_menu_items_used
; i
++)
1741 if (menu_items_used
== i
1742 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1744 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1746 free_menubar_widget_value_tree (first_wv
);
1752 /* Now GC cannot happen during the lifetime of the widget_value,
1753 so it's safe to store data from a Lisp_String. */
1754 wv
= first_wv
->contents
;
1755 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1758 string
= XVECTOR (items
)->contents
[i
+ 1];
1761 wv
->name
= (char *) XSTRING (string
)->data
;
1765 f
->menu_bar_vector
= menu_items
;
1766 f
->menu_bar_items_used
= menu_items_used
;
1771 /* Make a widget-value tree containing
1772 just the top level menu bar strings. */
1774 items
= FRAME_MENU_BAR_ITEMS (f
);
1775 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1779 string
= XVECTOR (items
)->contents
[i
+ 1];
1783 wv
= xmalloc_widget_value ();
1784 wv
->name
= (char *) XSTRING (string
)->data
;
1787 wv
->button_type
= BUTTON_TYPE_NONE
;
1788 /* This prevents lwlib from assuming this
1789 menu item is really supposed to be empty. */
1790 /* The EMACS_INT cast avoids a warning.
1791 This value just has to be different from small integers. */
1792 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1797 first_wv
->contents
= wv
;
1801 /* Forget what we thought we knew about what is in the
1802 detailed contents of the menu bar menus.
1803 Changing the top level always destroys the contents. */
1804 f
->menu_bar_items_used
= 0;
1807 /* Create or update the menu bar widget. */
1813 /* Disable resizing (done for Motif!) */
1814 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1816 /* The third arg is DEEP_P, which says to consider the entire
1817 menu trees we supply, rather than just the menu bar item names. */
1818 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1820 /* Re-enable the edit widget to resize. */
1821 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1825 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1826 f
->output_data
.x
->column_widget
,
1828 popup_activate_callback
,
1829 menubar_selection_callback
,
1830 popup_deactivate_callback
,
1831 menu_highlight_callback
);
1832 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1837 = (f
->output_data
.x
->menubar_widget
1838 ? (f
->output_data
.x
->menubar_widget
->core
.height
1839 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1842 #if 0 /* Experimentally, we now get the right results
1843 for -geometry -0-0 without this. 24 Aug 96, rms. */
1845 if (FRAME_EXTERNAL_MENU_BAR (f
))
1848 XtVaGetValues (f
->output_data
.x
->column_widget
,
1849 XtNinternalBorderWidth
, &ibw
, NULL
);
1850 menubar_size
+= ibw
;
1852 #endif /* USE_LUCID */
1855 f
->output_data
.x
->menubar_height
= menubar_size
;
1858 free_menubar_widget_value_tree (first_wv
);
1859 update_frame_menubar (f
);
1864 /* Called from Fx_create_frame to create the initial menubar of a frame
1865 before it is mapped, so that the window is mapped with the menubar already
1866 there instead of us tacking it on later and thrashing the window after it
1870 initialize_frame_menubar (f
)
1873 /* This function is called before the first chance to redisplay
1874 the frame. It has to be, so the frame will have the right size. */
1875 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1876 set_frame_menubar (f
, 1, 1);
1879 /* Get rid of the menu bar of frame F, and free its storage.
1880 This is used when deleting a frame, and when turning off the menu bar. */
1883 free_frame_menubar (f
)
1886 Widget menubar_widget
;
1888 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1890 f
->output_data
.x
->menubar_height
= 0;
1895 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1900 #endif /* USE_X_TOOLKIT */
1902 /* xmenu_show actually displays a menu using the panes and items in menu_items
1903 and returns the value selected from it.
1904 There are two versions of xmenu_show, one for Xt and one for Xlib.
1905 Both assume input is blocked by the caller. */
1907 /* F is the frame the menu is for.
1908 X and Y are the frame-relative specified position,
1909 relative to the inside upper left corner of the frame F.
1910 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1911 KEYMAPS is 1 if this menu was specified with keymaps;
1912 in that case, we return a list containing the chosen item's value
1913 and perhaps also the pane's prefix.
1914 TITLE is the specified menu title.
1915 ERROR is a place to store an error message string in case of failure.
1916 (We return nil on failure, but the value doesn't actually matter.) */
1918 #ifdef USE_X_TOOLKIT
1920 /* We need a unique id for each widget handled by the Lucid Widget
1923 For the main windows, and popup menus, we use this counter,
1924 which we increment each time after use. This starts from 1<<16.
1926 For menu bars, we use numbers starting at 0, counted in
1927 next_menubar_widget_id. */
1928 LWLIB_ID widget_id_tick
;
1930 static Lisp_Object
*volatile menu_item_selection
;
1933 popup_selection_callback (widget
, id
, client_data
)
1936 XtPointer client_data
;
1938 menu_item_selection
= (Lisp_Object
*) client_data
;
1942 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
1956 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1957 widget_value
**submenu_stack
1958 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1959 Lisp_Object
*subprefix_stack
1960 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1961 int submenu_depth
= 0;
1962 XButtonPressedEvent dummy
;
1968 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1970 *error
= "Empty menu";
1974 /* Create a tree of widget_value objects
1975 representing the panes and their items. */
1976 wv
= xmalloc_widget_value ();
1980 wv
->button_type
= BUTTON_TYPE_NONE
;
1984 /* Loop over all panes and items, filling in the tree. */
1986 while (i
< menu_items_used
)
1988 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1990 submenu_stack
[submenu_depth
++] = save_wv
;
1996 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1999 save_wv
= submenu_stack
[--submenu_depth
];
2003 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2004 && submenu_depth
!= 0)
2005 i
+= MENU_ITEMS_PANE_LENGTH
;
2006 /* Ignore a nil in the item list.
2007 It's meaningful only for dialog boxes. */
2008 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2010 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2012 /* Create a new pane. */
2013 Lisp_Object pane_name
, prefix
;
2015 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2016 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2017 #ifndef HAVE_MULTILINGUAL_MENU
2018 if (!NILP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2019 pane_name
= string_make_unibyte (pane_name
);
2021 pane_string
= (NILP (pane_name
)
2022 ? "" : (char *) XSTRING (pane_name
)->data
);
2023 /* If there is just one top-level pane, put all its items directly
2024 under the top-level menu. */
2025 if (menu_items_n_panes
== 1)
2028 /* If the pane has a meaningful name,
2029 make the pane a top-level menu item
2030 with its items as a submenu beneath it. */
2031 if (!keymaps
&& strcmp (pane_string
, ""))
2033 wv
= xmalloc_widget_value ();
2037 first_wv
->contents
= wv
;
2038 wv
->name
= pane_string
;
2039 if (keymaps
&& !NILP (prefix
))
2043 wv
->button_type
= BUTTON_TYPE_NONE
;
2047 else if (first_pane
)
2053 i
+= MENU_ITEMS_PANE_LENGTH
;
2057 /* Create a new item within current pane. */
2058 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
, help
;
2059 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2060 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2062 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2063 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
2064 type
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_TYPE
];
2065 selected
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_SELECTED
];
2066 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2068 #ifndef HAVE_MULTILINGUAL_MENU
2069 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2070 item_name
= string_make_unibyte (item_name
);
2071 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2072 item_name
= string_make_unibyte (descrip
);
2075 wv
= xmalloc_widget_value ();
2079 save_wv
->contents
= wv
;
2080 wv
->name
= (char *) XSTRING (item_name
)->data
;
2081 if (!NILP (descrip
))
2082 wv
->key
= (char *) XSTRING (descrip
)->data
;
2084 /* If this item has a null value,
2085 make the call_data null so that it won't display a box
2086 when the mouse is on it. */
2088 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2089 wv
->enabled
= !NILP (enable
);
2092 wv
->button_type
= BUTTON_TYPE_NONE
;
2093 else if (EQ (type
, QCtoggle
))
2094 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2095 else if (EQ (type
, QCradio
))
2096 wv
->button_type
= BUTTON_TYPE_RADIO
;
2100 wv
->selected
= !NILP (selected
);
2102 wv
->help
= XSTRING (help
)->data
;
2106 i
+= MENU_ITEMS_ITEM_LENGTH
;
2110 /* Deal with the title, if it is non-nil. */
2113 widget_value
*wv_title
= xmalloc_widget_value ();
2114 widget_value
*wv_sep1
= xmalloc_widget_value ();
2115 widget_value
*wv_sep2
= xmalloc_widget_value ();
2117 wv_sep2
->name
= "--";
2118 wv_sep2
->next
= first_wv
->contents
;
2120 wv_sep1
->name
= "--";
2121 wv_sep1
->next
= wv_sep2
;
2123 #ifndef HAVE_MULTILINGUAL_MENU
2124 if (STRING_MULTIBYTE (title
))
2125 title
= string_make_unibyte (title
);
2127 wv_title
->name
= (char *) XSTRING (title
)->data
;
2128 wv_title
->enabled
= True
;
2129 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2130 wv_title
->next
= wv_sep1
;
2131 first_wv
->contents
= wv_title
;
2134 /* Actually create the menu. */
2135 menu_id
= widget_id_tick
++;
2136 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2137 f
->output_data
.x
->widget
, 1, 0,
2138 popup_selection_callback
,
2139 popup_deactivate_callback
,
2140 menu_highlight_callback
);
2142 /* Adjust coordinates to relative to the outer (window manager) window. */
2145 int win_x
= 0, win_y
= 0;
2147 /* Find the position of the outside upper-left corner of
2148 the inner window, with respect to the outer window. */
2149 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2152 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2154 /* From-window, to-window. */
2155 f
->output_data
.x
->window_desc
,
2156 f
->output_data
.x
->parent_desc
,
2158 /* From-position, to-position. */
2159 0, 0, &win_x
, &win_y
,
2161 /* Child of window. */
2169 /* Adjust coordinates to be root-window-relative. */
2170 x
+= f
->output_data
.x
->left_pos
;
2171 y
+= f
->output_data
.x
->top_pos
;
2173 dummy
.type
= ButtonPress
;
2175 dummy
.send_event
= 0;
2176 dummy
.display
= FRAME_X_DISPLAY (f
);
2177 dummy
.time
= CurrentTime
;
2178 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2179 dummy
.window
= dummy
.root
;
2180 dummy
.subwindow
= dummy
.root
;
2185 dummy
.state
= (FRAME_X_DISPLAY_INFO (f
)->grabbed
>> 1) * Button1Mask
;
2187 for (i
= 0; i
< 5; i
++)
2188 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2191 /* Don't allow any geometry request from the user. */
2192 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2193 XtSetValues (menu
, av
, ac
);
2195 /* Free the widget_value objects we used to specify the contents. */
2196 free_menubar_widget_value_tree (first_wv
);
2198 /* Override any default settings with ones from the `menu' face. */
2199 x_set_menu_resources_from_menu_face (f
, menu
);
2201 /* No selection has been chosen yet. */
2202 menu_item_selection
= 0;
2204 /* Display the menu. */
2205 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2206 popup_activated_flag
= 1;
2208 /* Process events that apply to the menu. */
2209 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
);
2211 #ifdef LESSTIF_VERSION
2212 /* Nov 1998: For an unknown reason a button grab remains active
2213 after the popup menu has gone. */
2214 XUngrabButton (XtDisplay (f
->output_data
.x
->widget
),
2215 AnyButton
, AnyModifier
,
2216 XtWindow (f
->output_data
.x
->widget
));
2217 XUngrabButton (XtDisplay (f
->output_data
.x
->edit_widget
),
2218 AnyButton
, AnyModifier
,
2219 XtWindow (f
->output_data
.x
->edit_widget
));
2220 #endif /* LESSTIF_VERSION */
2222 /* fp turned off the following statement and wrote a comment
2223 that it is unnecessary--that the menu has already disappeared.
2224 Nowadays the menu disappears ok, all right, but
2225 we need to delete the widgets or multiple ones will pile up. */
2226 lw_destroy_all_widgets (menu_id
);
2228 /* Find the selected item, and its pane, to return
2229 the proper value. */
2230 if (menu_item_selection
!= 0)
2232 Lisp_Object prefix
, entry
;
2234 prefix
= entry
= Qnil
;
2236 while (i
< menu_items_used
)
2238 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2240 subprefix_stack
[submenu_depth
++] = prefix
;
2244 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2246 prefix
= subprefix_stack
[--submenu_depth
];
2249 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2252 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2253 i
+= MENU_ITEMS_PANE_LENGTH
;
2255 /* Ignore a nil in the item list.
2256 It's meaningful only for dialog boxes. */
2257 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2262 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2263 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2269 entry
= Fcons (entry
, Qnil
);
2271 entry
= Fcons (prefix
, entry
);
2272 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2273 if (!NILP (subprefix_stack
[j
]))
2274 entry
= Fcons (subprefix_stack
[j
], entry
);
2278 i
+= MENU_ITEMS_ITEM_LENGTH
;
2287 dialog_selection_callback (widget
, id
, client_data
)
2290 XtPointer client_data
;
2292 /* The EMACS_INT cast avoids a warning. There's no problem
2293 as long as pointers have enough bits to hold small integers. */
2294 if ((int) (EMACS_INT
) client_data
!= -1)
2295 menu_item_selection
= (Lisp_Object
*) client_data
;
2297 lw_destroy_all_widgets (id
);
2299 popup_activated_flag
= 0;
2302 static char * button_names
[] = {
2303 "button1", "button2", "button3", "button4", "button5",
2304 "button6", "button7", "button8", "button9", "button10" };
2307 xdialog_show (f
, keymaps
, title
, error
)
2313 int i
, nb_buttons
=0;
2316 char dialog_name
[6];
2318 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2320 /* Number of elements seen so far, before boundary. */
2322 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2323 int boundary_seen
= 0;
2327 if (menu_items_n_panes
> 1)
2329 *error
= "Multiple panes in dialog box";
2333 /* Create a tree of widget_value objects
2334 representing the text label and buttons. */
2336 Lisp_Object pane_name
, prefix
;
2338 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2339 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2340 pane_string
= (NILP (pane_name
)
2341 ? "" : (char *) XSTRING (pane_name
)->data
);
2342 prev_wv
= xmalloc_widget_value ();
2343 prev_wv
->value
= pane_string
;
2344 if (keymaps
&& !NILP (prefix
))
2346 prev_wv
->enabled
= 1;
2347 prev_wv
->name
= "message";
2350 /* Loop over all panes and items, filling in the tree. */
2351 i
= MENU_ITEMS_PANE_LENGTH
;
2352 while (i
< menu_items_used
)
2355 /* Create a new item within current pane. */
2356 Lisp_Object item_name
, enable
, descrip
;
2357 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2358 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2360 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2362 if (NILP (item_name
))
2364 free_menubar_widget_value_tree (first_wv
);
2365 *error
= "Submenu in dialog items";
2368 if (EQ (item_name
, Qquote
))
2370 /* This is the boundary between left-side elts
2371 and right-side elts. Stop incrementing right_count. */
2376 if (nb_buttons
>= 9)
2378 free_menubar_widget_value_tree (first_wv
);
2379 *error
= "Too many dialog items";
2383 wv
= xmalloc_widget_value ();
2385 wv
->name
= (char *) button_names
[nb_buttons
];
2386 if (!NILP (descrip
))
2387 wv
->key
= (char *) XSTRING (descrip
)->data
;
2388 wv
->value
= (char *) XSTRING (item_name
)->data
;
2389 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2390 wv
->enabled
= !NILP (enable
);
2393 if (! boundary_seen
)
2397 i
+= MENU_ITEMS_ITEM_LENGTH
;
2400 /* If the boundary was not specified,
2401 by default put half on the left and half on the right. */
2402 if (! boundary_seen
)
2403 left_count
= nb_buttons
- nb_buttons
/ 2;
2405 wv
= xmalloc_widget_value ();
2406 wv
->name
= dialog_name
;
2408 /* Dialog boxes use a really stupid name encoding
2409 which specifies how many buttons to use
2410 and how many buttons are on the right.
2411 The Q means something also. */
2412 dialog_name
[0] = 'Q';
2413 dialog_name
[1] = '0' + nb_buttons
;
2414 dialog_name
[2] = 'B';
2415 dialog_name
[3] = 'R';
2416 /* Number of buttons to put on the right. */
2417 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2419 wv
->contents
= first_wv
;
2423 /* Actually create the dialog. */
2424 dialog_id
= widget_id_tick
++;
2425 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2426 f
->output_data
.x
->widget
, 1, 0,
2427 dialog_selection_callback
, 0, 0);
2428 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2429 /* Free the widget_value objects we used to specify the contents. */
2430 free_menubar_widget_value_tree (first_wv
);
2432 /* No selection has been chosen yet. */
2433 menu_item_selection
= 0;
2435 /* Display the menu. */
2436 lw_pop_up_all_widgets (dialog_id
);
2437 popup_activated_flag
= 1;
2439 /* Process events that apply to the menu. */
2440 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
);
2442 lw_destroy_all_widgets (dialog_id
);
2444 /* Find the selected item, and its pane, to return
2445 the proper value. */
2446 if (menu_item_selection
!= 0)
2452 while (i
< menu_items_used
)
2456 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2459 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2460 i
+= MENU_ITEMS_PANE_LENGTH
;
2462 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2464 /* This is the boundary between left-side elts and
2471 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2472 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2476 entry
= Fcons (entry
, Qnil
);
2478 entry
= Fcons (prefix
, entry
);
2482 i
+= MENU_ITEMS_ITEM_LENGTH
;
2490 #else /* not USE_X_TOOLKIT */
2492 /* The frame of the last activated non-toolkit menu bar.
2493 Used to generate menu help events. */
2495 static struct frame
*menu_help_frame
;
2498 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
2500 PANE is the pane number, and ITEM is the menu item number in
2501 the menu (currently not used).
2503 This cannot be done with generating a HELP_EVENT because
2504 XMenuActivate contains a loop that doesn't let Emacs process
2508 menu_help_callback (help_string
, pane
, item
)
2512 extern Lisp_Object Qmenu_item
;
2513 Lisp_Object
*first_item
;
2514 Lisp_Object pane_name
;
2515 Lisp_Object menu_object
;
2517 first_item
= XVECTOR (menu_items
)->contents
;
2518 if (EQ (first_item
[0], Qt
))
2519 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
2520 else if (EQ (first_item
[0], Qquote
))
2521 /* This shouldn't happen, see xmenu_show. */
2522 pane_name
= build_string ("");
2524 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
2526 /* (menu-item MENU-NAME PANE-NUMBER) */
2527 menu_object
= Fcons (Qmenu_item
,
2529 Fcons (make_number (pane
), Qnil
)));
2530 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
2531 Qnil
, menu_object
, make_number (item
), 1);
2536 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2546 int pane
, selidx
, lpane
, status
;
2547 Lisp_Object entry
, pane_prefix
;
2549 int ulx
, uly
, width
, height
;
2550 int dispwidth
, dispheight
;
2554 unsigned int dummy_uint
;
2557 if (menu_items_n_panes
== 0)
2560 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2562 *error
= "Empty menu";
2566 /* Figure out which root window F is on. */
2567 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2568 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2569 &dummy_uint
, &dummy_uint
);
2571 /* Make the menu on that window. */
2572 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2575 *error
= "Can't create menu";
2579 #ifdef HAVE_X_WINDOWS
2580 /* Adjust coordinates to relative to the outer (window manager) window. */
2583 int win_x
= 0, win_y
= 0;
2585 /* Find the position of the outside upper-left corner of
2586 the inner window, with respect to the outer window. */
2587 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2590 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2592 /* From-window, to-window. */
2593 f
->output_data
.x
->window_desc
,
2594 f
->output_data
.x
->parent_desc
,
2596 /* From-position, to-position. */
2597 0, 0, &win_x
, &win_y
,
2599 /* Child of window. */
2606 #endif /* HAVE_X_WINDOWS */
2608 /* Adjust coordinates to be root-window-relative. */
2609 x
+= f
->output_data
.x
->left_pos
;
2610 y
+= f
->output_data
.x
->top_pos
;
2612 /* Create all the necessary panes and their items. */
2614 while (i
< menu_items_used
)
2616 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2618 /* Create a new pane. */
2619 Lisp_Object pane_name
, prefix
;
2622 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2623 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2624 pane_string
= (NILP (pane_name
)
2625 ? "" : (char *) XSTRING (pane_name
)->data
);
2626 if (keymaps
&& !NILP (prefix
))
2629 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2630 if (lpane
== XM_FAILURE
)
2632 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2633 *error
= "Can't create pane";
2636 i
+= MENU_ITEMS_PANE_LENGTH
;
2638 /* Find the width of the widest item in this pane. */
2641 while (j
< menu_items_used
)
2644 item
= XVECTOR (menu_items
)->contents
[j
];
2652 width
= STRING_BYTES (XSTRING (item
));
2653 if (width
> maxwidth
)
2656 j
+= MENU_ITEMS_ITEM_LENGTH
;
2659 /* Ignore a nil in the item list.
2660 It's meaningful only for dialog boxes. */
2661 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2665 /* Create a new item within current pane. */
2666 Lisp_Object item_name
, enable
, descrip
, help
;
2667 unsigned char *item_data
;
2670 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2671 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2673 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2674 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2675 help_string
= STRINGP (help
) ? XSTRING (help
)->data
: NULL
;
2677 if (!NILP (descrip
))
2679 int gap
= maxwidth
- STRING_BYTES (XSTRING (item_name
));
2682 spacer
= Fmake_string (make_number (gap
), make_number (' '));
2683 item_name
= concat2 (item_name
, spacer
);
2684 item_name
= concat2 (item_name
, descrip
);
2685 item_data
= XSTRING (item_name
)->data
;
2687 /* if alloca is fast, use that to make the space,
2688 to reduce gc needs. */
2690 = (unsigned char *) alloca (maxwidth
2691 + STRING_BYTES (XSTRING (descrip
)) + 1);
2692 bcopy (XSTRING (item_name
)->data
, item_data
,
2693 STRING_BYTES (XSTRING (item_name
)));
2694 for (j
= XSTRING (item_name
)->size
; j
< maxwidth
; j
++)
2696 bcopy (XSTRING (descrip
)->data
, item_data
+ j
,
2697 STRING_BYTES (XSTRING (descrip
)));
2698 item_data
[j
+ STRING_BYTES (XSTRING (descrip
))] = 0;
2702 item_data
= XSTRING (item_name
)->data
;
2704 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2705 menu
, lpane
, 0, item_data
,
2706 !NILP (enable
), help_string
)
2709 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2710 *error
= "Can't add selection to menu";
2713 i
+= MENU_ITEMS_ITEM_LENGTH
;
2717 /* All set and ready to fly. */
2718 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2719 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
),
2720 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2721 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
),
2722 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2723 x
= min (x
, dispwidth
);
2724 y
= min (y
, dispheight
);
2727 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2728 &ulx
, &uly
, &width
, &height
);
2729 if (ulx
+width
> dispwidth
)
2731 x
-= (ulx
+ width
) - dispwidth
;
2732 ulx
= dispwidth
- width
;
2734 if (uly
+height
> dispheight
)
2736 y
-= (uly
+ height
) - dispheight
;
2737 uly
= dispheight
- height
;
2739 if (ulx
< 0) x
-= ulx
;
2740 if (uly
< 0) y
-= uly
;
2742 XMenuSetAEQ (menu
, TRUE
);
2743 XMenuSetFreeze (menu
, TRUE
);
2746 /* Help display under X won't work because XMenuActivate contains
2747 a loop that doesn't give Emacs a chance to process it. */
2748 menu_help_frame
= f
;
2749 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2750 x
, y
, ButtonReleaseMask
, &datap
,
2751 menu_help_callback
);
2754 #ifdef HAVE_X_WINDOWS
2755 /* Assume the mouse has moved out of the X window.
2756 If it has actually moved in, we will get an EnterNotify. */
2757 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2764 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2767 /* Find the item number SELIDX in pane number PANE. */
2769 while (i
< menu_items_used
)
2771 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2775 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2777 i
+= MENU_ITEMS_PANE_LENGTH
;
2786 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2789 entry
= Fcons (entry
, Qnil
);
2790 if (!NILP (pane_prefix
))
2791 entry
= Fcons (pane_prefix
, entry
);
2797 i
+= MENU_ITEMS_ITEM_LENGTH
;
2803 *error
= "Can't activate menu";
2809 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2811 #ifdef HAVE_X_WINDOWS
2812 /* State that no mouse buttons are now held.
2813 (The oldXMenu code doesn't track this info for us.)
2814 That is not necessarily true, but the fiction leads to reasonable
2815 results, and it is a pain to ask which are actually held now. */
2816 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2822 #endif /* not USE_X_TOOLKIT */
2824 #endif /* HAVE_MENUS */
2829 staticpro (&menu_items
);
2832 Qdebug_on_next_call
= intern ("debug-on-next-call");
2833 staticpro (&Qdebug_on_next_call
);
2835 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
2836 "Frame for which we are updating a menu.\n\
2837 The enable predicate for a menu command should check this variable.");
2838 Vmenu_updating_frame
= Qnil
;
2840 #ifdef USE_X_TOOLKIT
2841 widget_id_tick
= (1<<16);
2842 next_menubar_widget_id
= 1;
2845 defsubr (&Sx_popup_menu
);
2847 defsubr (&Sx_popup_dialog
);