1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 88, 93, 94, 96, 1999 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
], Qnil
, Qnil
, notreal
, 10);
385 finish_menu_items ();
388 /* This is a recursive subroutine of keymap_panes.
389 It handles one keymap, KEYMAP.
390 The other arguments are passed along
391 or point to local variables of the previous function.
392 If NOTREAL is nonzero, only check for equivalent key bindings, don't
393 evaluate expressions in menu items and don't make any menu.
395 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
398 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
400 Lisp_Object pane_name
;
405 Lisp_Object pending_maps
= Qnil
;
406 Lisp_Object tail
, item
;
407 struct gcpro gcpro1
, gcpro2
;
413 push_menu_pane (pane_name
, prefix
);
416 /* Remember index for first item in this pane so we can go back and
417 add a prefix when (if) we see the first button. After that, notbuttons
418 is set to 0, to mark that we have seen a button and all non button
419 items need a prefix. */
420 notbuttons
= menu_items_used
;
423 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
425 GCPRO2 (keymap
, pending_maps
);
426 /* Look at each key binding, and if it is a menu item add it
430 single_menu_item (XCAR (item
), XCDR (item
),
431 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
432 else if (VECTORP (item
))
434 /* Loop over the char values represented in the vector. */
435 int len
= XVECTOR (item
)->size
;
437 for (c
= 0; c
< len
; c
++)
439 Lisp_Object character
;
440 XSETFASTINT (character
, c
);
441 single_menu_item (character
, XVECTOR (item
)->contents
[c
],
442 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
448 /* Process now any submenus which want to be panes at this level. */
449 while (!NILP (pending_maps
))
451 Lisp_Object elt
, eltcdr
, string
;
452 elt
= Fcar (pending_maps
);
454 string
= XCAR (eltcdr
);
455 /* We no longer discard the @ from the beginning of the string here.
456 Instead, we do this in xmenu_show. */
457 single_keymap_panes (Fcar (elt
), string
,
458 XCDR (eltcdr
), notreal
, maxdepth
- 1);
459 pending_maps
= Fcdr (pending_maps
);
463 /* This is a subroutine of single_keymap_panes that handles one
465 KEY is a key in a keymap and ITEM is its binding.
466 PENDING_MAPS_PTR points to a list of keymaps waiting to be made into
468 If NOTREAL is nonzero, only check for equivalent key bindings, don't
469 evaluate expressions in menu items and don't make any menu.
470 If we encounter submenus deeper than MAXDEPTH levels, ignore them.
471 NOTBUTTONS_PTR is only used when simulating toggle boxes and radio
472 buttons. It points to variable notbuttons in single_keymap_panes,
473 which keeps track of if we have seen a button in this menu or not. */
476 single_menu_item (key
, item
, pending_maps_ptr
, notreal
, maxdepth
,
478 Lisp_Object key
, item
;
479 Lisp_Object
*pending_maps_ptr
;
480 int maxdepth
, notreal
;
483 Lisp_Object map
, item_string
, enabled
;
484 struct gcpro gcpro1
, gcpro2
;
487 /* Parse the menu item and leave the result in item_properties. */
489 res
= parse_menu_item (item
, notreal
, 0);
492 return; /* Not a menu item. */
494 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
498 /* We don't want to make a menu, just traverse the keymaps to
499 precompute equivalent key bindings. */
501 single_keymap_panes (map
, Qnil
, key
, 1, maxdepth
- 1);
505 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
506 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
508 if (!NILP (map
) && XSTRING (item_string
)->data
[0] == '@')
511 /* An enabled separate pane. Remember this to handle it later. */
512 *pending_maps_ptr
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
518 /* Simulate radio buttons and toggle boxes by putting a prefix in
521 Lisp_Object prefix
= Qnil
;
522 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
526 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
529 /* The first button. Line up previous items in this menu. */
531 int index
= *notbuttons_ptr
; /* Index for first item this menu. */
534 while (index
< menu_items_used
)
537 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
541 submenu
++; /* Skip sub menu. */
543 else if (EQ (tem
, Qlambda
))
546 submenu
--; /* End sub menu. */
548 else if (EQ (tem
, Qt
))
549 index
+= 3; /* Skip new pane marker. */
550 else if (EQ (tem
, Qquote
))
551 index
++; /* Skip a left, right divider. */
554 if (!submenu
&& XSTRING (tem
)->data
[0] != '\0'
555 && XSTRING (tem
)->data
[0] != '-')
556 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
557 = concat2 (build_string (" "), tem
);
558 index
+= MENU_ITEMS_ITEM_LENGTH
;
564 /* Calculate prefix, if any, for this item. */
565 if (EQ (type
, QCtoggle
))
566 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
567 else if (EQ (type
, QCradio
))
568 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
570 /* Not a button. If we have earlier buttons, then we need a prefix. */
571 else if (!*notbuttons_ptr
&& XSTRING (item_string
)->data
[0] != '\0'
572 && XSTRING (item_string
)->data
[0] != '-')
573 prefix
= build_string (" ");
576 item_string
= concat2 (prefix
, item_string
);
578 #endif /* not HAVE_BOXES */
580 #ifndef USE_X_TOOLKIT
582 /* Indicate visually that this is a submenu. */
583 item_string
= concat2 (item_string
, build_string (" >"));
586 push_menu_item (item_string
, enabled
, key
,
587 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
588 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
],
589 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
],
590 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
],
591 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_HELP
]);
594 /* Display a submenu using the toolkit. */
595 if (! (NILP (map
) || NILP (enabled
)))
597 push_submenu_start ();
598 single_keymap_panes (map
, Qnil
, key
, 0, maxdepth
- 1);
604 /* Push all the panes and items of a menu described by the
605 alist-of-alists MENU.
606 This handles old-fashioned calls to x-popup-menu. */
616 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
618 Lisp_Object elt
, pane_name
, pane_data
;
620 pane_name
= Fcar (elt
);
621 CHECK_STRING (pane_name
, 0);
622 push_menu_pane (pane_name
, Qnil
);
623 pane_data
= Fcdr (elt
);
624 CHECK_CONS (pane_data
, 0);
625 list_of_items (pane_data
);
628 finish_menu_items ();
631 /* Push the items in a single pane defined by the alist PANE. */
637 Lisp_Object tail
, item
, item1
;
639 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
643 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
644 else if (NILP (item
))
645 push_left_right_boundary ();
648 CHECK_CONS (item
, 0);
650 CHECK_STRING (item1
, 1);
651 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
, Qnil
, Qnil
, Qnil
);
656 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
657 "Pop up a deck-of-cards menu and return user's selection.\n\
658 POSITION is a position specification. This is either a mouse button event\n\
659 or a list ((XOFFSET YOFFSET) WINDOW)\n\
660 where XOFFSET and YOFFSET are positions in pixels from the top left\n\
661 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
662 This controls the position of the center of the first line\n\
663 in the first pane of the menu, not the top left of the menu as a whole.\n\
664 If POSITION is t, it means to use the current mouse position.\n\
666 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
667 The menu items come from key bindings that have a menu string as well as\n\
668 a definition; actually, the \"definition\" in such a key binding looks like\n\
669 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
670 the keymap as a top-level element.\n\n\
671 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.\n\
672 Otherwise, REAL-DEFINITION should be a valid key binding definition.\n\
674 You can also use a list of keymaps as MENU.\n\
675 Then each keymap makes a separate pane.\n\
676 When MENU is a keymap or a list of keymaps, the return value\n\
677 is a list of events.\n\n\
679 Alternatively, you can specify a menu of multiple panes\n\
680 with a list of the form (TITLE PANE1 PANE2...),\n\
681 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
682 Each ITEM is normally a cons cell (STRING . VALUE);\n\
683 but a string can appear as an item--that makes a nonselectable line\n\
685 With this form of menu, the return value is VALUE from the chosen item.\n\
687 If POSITION is nil, don't display the menu at all, just precalculate the\n\
688 cached information about equivalent key sequences.")
690 Lisp_Object position
, menu
;
692 Lisp_Object keymap
, tem
;
696 Lisp_Object selection
;
698 Lisp_Object x
, y
, window
;
704 if (! NILP (position
))
708 /* Decode the first argument: find the window and the coordinates. */
709 if (EQ (position
, Qt
)
710 || (CONSP (position
) && EQ (XCAR (position
), Qmenu_bar
)))
712 /* Use the mouse's current position. */
713 FRAME_PTR new_f
= SELECTED_FRAME ();
714 Lisp_Object bar_window
;
715 enum scroll_bar_part part
;
718 if (mouse_position_hook
)
719 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
720 &part
, &x
, &y
, &time
);
722 XSETFRAME (window
, new_f
);
725 window
= selected_window
;
732 tem
= Fcar (position
);
735 window
= Fcar (Fcdr (position
));
737 y
= Fcar (Fcdr (tem
));
742 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
743 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
744 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
753 /* Decode where to put the menu. */
761 else if (WINDOWP (window
))
763 CHECK_LIVE_WINDOW (window
, 0);
764 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
766 xpos
= (FONT_WIDTH (f
->output_data
.x
->font
)
767 * XFASTINT (XWINDOW (window
)->left
));
768 ypos
= (f
->output_data
.x
->line_height
769 * XFASTINT (XWINDOW (window
)->top
));
772 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
773 but I don't want to make one now. */
774 CHECK_WINDOW (window
, 0);
779 XSETFRAME (Vmenu_updating_frame
, f
);
781 Vmenu_updating_frame
= Qnil
;
782 #endif /* HAVE_MENUS */
787 /* Decode the menu items from what was specified. */
789 keymap
= Fkeymapp (menu
);
792 tem
= Fkeymapp (Fcar (menu
));
795 /* We were given a keymap. Extract menu info from the keymap. */
797 keymap
= get_keymap (menu
);
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 (!NILP (tem
))
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
));
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
;
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
)))
910 #if 0 /* Using the frame the mouse is on may not be right. */
911 /* Use the mouse's current position. */
912 FRAME_PTR new_f
= SELECTED_FRAME ();
913 Lisp_Object bar_window
;
918 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
921 XSETFRAME (window
, new_f
);
923 window
= selected_window
;
925 window
= selected_window
;
927 else if (CONSP (position
))
930 tem
= Fcar (position
);
932 window
= Fcar (Fcdr (position
));
935 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
936 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
939 else if (WINDOWP (position
) || FRAMEP (position
))
944 /* Decode where to put the menu. */
948 else if (WINDOWP (window
))
950 CHECK_LIVE_WINDOW (window
, 0);
951 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
954 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
955 but I don't want to make one now. */
956 CHECK_WINDOW (window
, 0);
958 #ifndef USE_X_TOOLKIT
959 /* Display a menu with these alternatives
960 in the middle of frame F. */
962 Lisp_Object x
, y
, frame
, newpos
;
963 XSETFRAME (frame
, f
);
964 XSETINT (x
, x_pixel_width (f
) / 2);
965 XSETINT (y
, x_pixel_height (f
) / 2);
966 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
968 return Fx_popup_menu (newpos
,
969 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
975 Lisp_Object selection
;
977 /* Decode the dialog items from what was specified. */
978 title
= Fcar (contents
);
979 CHECK_STRING (title
, 1);
981 list_of_panes (Fcons (contents
, Qnil
));
983 /* Display them in a dialog box. */
985 selection
= xdialog_show (f
, 0, title
, &error_name
);
988 discard_menu_items ();
990 if (error_name
) error (error_name
);
998 /* Loop in Xt until the menu pulldown or dialog popup has been
999 popped down (deactivated). This is used for x-popup-menu
1000 and x-popup-dialog; it is not used for the menu bar any more.
1002 NOTE: All calls to popup_get_selection should be protected
1003 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
1006 popup_get_selection (initial_event
, dpyinfo
, id
)
1007 XEvent
*initial_event
;
1008 struct x_display_info
*dpyinfo
;
1013 /* Define a queue to save up for later unreading
1014 all X events that don't pertain to the menu. */
1018 struct event_queue
*next
;
1021 struct event_queue
*queue
= NULL
;
1022 struct event_queue
*queue_tmp
;
1025 event
= *initial_event
;
1027 XtAppNextEvent (Xt_app_con
, &event
);
1031 /* Handle expose events for editor frames right away. */
1032 if (event
.type
== Expose
)
1033 process_expose_from_menu (event
);
1034 /* Make sure we don't consider buttons grabbed after menu goes.
1035 And make sure to deactivate for any ButtonRelease,
1036 even if XtDispatchEvent doesn't do that. */
1037 else if (event
.type
== ButtonRelease
1038 && dpyinfo
->display
== event
.xbutton
.display
)
1040 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1041 popup_activated_flag
= 0;
1042 #ifdef USE_MOTIF /* Pretending that the event came from a
1043 Btn1Down seems the only way to convince Motif to
1044 activate its callbacks; setting the XmNmenuPost
1045 isn't working. --marcus@sysc.pdx.edu. */
1046 event
.xbutton
.button
= 1;
1049 /* If the user presses a key, deactivate the menu.
1050 The user is likely to do that if we get wedged. */
1051 else if (event
.type
== KeyPress
1052 && dpyinfo
->display
== event
.xbutton
.display
)
1054 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1055 if (!IsModifierKey (keysym
))
1057 popup_activated_flag
= 0;
1061 /* Button presses outside the menu also pop it down. */
1062 else if (event
.type
== ButtonPress
1063 && event
.xany
.display
== dpyinfo
->display
1064 && x_any_window_to_frame (dpyinfo
, event
.xany
.window
))
1066 popup_activated_flag
= 0;
1070 /* Queue all events not for this popup,
1071 except for Expose, which we've already handled, and ButtonRelease.
1072 Note that the X window is associated with the frame if this
1073 is a menu bar popup, but not if it's a dialog box. So we use
1074 x_non_menubar_window_to_frame, not x_any_window_to_frame. */
1075 if (event
.type
!= Expose
1076 && !(event
.type
== ButtonRelease
1077 && dpyinfo
->display
== event
.xbutton
.display
)
1078 && (event
.xany
.display
!= dpyinfo
->display
1079 || x_non_menubar_window_to_frame (dpyinfo
, event
.xany
.window
)))
1081 queue_tmp
= (struct event_queue
*) malloc (sizeof (struct event_queue
));
1083 if (queue_tmp
!= NULL
)
1085 queue_tmp
->event
= event
;
1086 queue_tmp
->next
= queue
;
1091 XtDispatchEvent (&event
);
1093 if (!popup_activated ())
1095 XtAppNextEvent (Xt_app_con
, &event
);
1098 /* Unread any events that we got but did not handle. */
1099 while (queue
!= NULL
)
1102 XPutBackEvent (queue_tmp
->event
.xany
.display
, &queue_tmp
->event
);
1103 queue
= queue_tmp
->next
;
1104 free ((char *)queue_tmp
);
1105 /* Cause these events to get read as soon as we UNBLOCK_INPUT. */
1106 interrupt_input_pending
= 1;
1110 /* Activate the menu bar of frame F.
1111 This is called from keyboard.c when it gets the
1112 menu_bar_activate_event out of the Emacs event queue.
1114 To activate the menu bar, we use the X button-press event
1115 that was saved in saved_menu_event.
1116 That makes the toolkit do its thing.
1118 But first we recompute the menu bar contents (the whole tree).
1120 The reason for saving the button event until here, instead of
1121 passing it to the toolkit right away, is that we can safely
1122 execute Lisp code. */
1125 x_activate_menubar (f
)
1128 if (!f
->output_data
.x
->saved_menu_event
->type
)
1131 set_frame_menubar (f
, 0, 1);
1133 XtDispatchEvent ((XEvent
*) f
->output_data
.x
->saved_menu_event
);
1136 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1137 pending_menu_activation
= 1;
1140 /* Ignore this if we get it a second time. */
1141 f
->output_data
.x
->saved_menu_event
->type
= 0;
1144 /* Detect if a dialog or menu has been posted. */
1149 return popup_activated_flag
;
1152 /* This callback is invoked when the user selects a menubar cascade
1153 pushbutton, but before the pulldown menu is posted. */
1156 popup_activate_callback (widget
, id
, client_data
)
1159 XtPointer client_data
;
1162 ++popup_activated_flag
;
1164 popup_activated_flag
= 1;
1168 /* This callback is invoked when a dialog or menu is finished being
1169 used and has been unposted. */
1172 popup_deactivate_callback (widget
, id
, client_data
)
1175 XtPointer client_data
;
1178 --popup_activated_flag
;
1180 popup_activated_flag
= 0;
1184 /* Lwlib callback called when menu items are highlighted/unhighlighted
1185 while moving the mouse over them. WIDGET is the menu bar or menu
1186 popup widget. ID is its LWLIB_ID. CALL_DATA contains a pointer to
1187 the widget_value structure for the menu item, or null in case of
1191 menu_highlight_callback (widget
, id
, call_data
)
1196 widget_value
*wv
= (widget_value
*) call_data
;
1198 Lisp_Object frame
, help
;
1200 /* Determine the frame for the help event. */
1201 f
= menubar_id_to_frame (id
);
1203 XSETFRAME (frame
, f
);
1206 /* WIDGET is the popup menu. It's parent is the frame's
1207 widget. See which frame that is. */
1208 Widget frame_widget
= XtParent (widget
);
1211 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1213 frame
= XCAR (tail
);
1214 if (GC_FRAMEP (frame
)
1215 && (f
= XFRAME (frame
),
1216 FRAME_X_P (f
) && f
->output_data
.x
->widget
== frame_widget
))
1221 /* Store the help event. */
1222 help
= wv
&& wv
->help
? build_string (wv
->help
) : Qnil
;
1223 kbd_buffer_store_help_event (frame
, help
);
1226 /* This callback is called from the menu bar pulldown menu
1227 when the user makes a selection.
1228 Figure out what the user chose
1229 and put the appropriate events into the keyboard buffer. */
1232 menubar_selection_callback (widget
, id
, client_data
)
1235 XtPointer client_data
;
1237 Lisp_Object prefix
, entry
;
1238 FRAME_PTR f
= menubar_id_to_frame (id
);
1240 Lisp_Object
*subprefix_stack
;
1241 int submenu_depth
= 0;
1246 subprefix_stack
= (Lisp_Object
*) alloca (f
->menu_bar_items_used
* sizeof (Lisp_Object
));
1247 vector
= f
->menu_bar_vector
;
1250 while (i
< f
->menu_bar_items_used
)
1252 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1254 subprefix_stack
[submenu_depth
++] = prefix
;
1258 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1260 prefix
= subprefix_stack
[--submenu_depth
];
1263 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1265 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1266 i
+= MENU_ITEMS_PANE_LENGTH
;
1270 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1271 /* The EMACS_INT cast avoids a warning. There's no problem
1272 as long as pointers have enough bits to hold small integers. */
1273 if ((int) (EMACS_INT
) client_data
== i
)
1276 struct input_event buf
;
1279 XSETFRAME (frame
, f
);
1280 buf
.kind
= MENU_BAR_EVENT
;
1281 buf
.frame_or_window
= frame
;
1283 kbd_buffer_store_event (&buf
);
1285 for (j
= 0; j
< submenu_depth
; j
++)
1286 if (!NILP (subprefix_stack
[j
]))
1288 buf
.kind
= MENU_BAR_EVENT
;
1289 buf
.frame_or_window
= frame
;
1290 buf
.arg
= subprefix_stack
[j
];
1291 kbd_buffer_store_event (&buf
);
1296 buf
.kind
= MENU_BAR_EVENT
;
1297 buf
.frame_or_window
= frame
;
1299 kbd_buffer_store_event (&buf
);
1302 buf
.kind
= MENU_BAR_EVENT
;
1303 buf
.frame_or_window
= frame
;
1305 kbd_buffer_store_event (&buf
);
1309 i
+= MENU_ITEMS_ITEM_LENGTH
;
1314 /* Allocate a widget_value, blocking input. */
1317 xmalloc_widget_value ()
1319 widget_value
*value
;
1322 value
= malloc_widget_value ();
1328 /* This recursively calls free_widget_value on the tree of widgets.
1329 It must free all data that was malloc'ed for these widget_values.
1330 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1331 must be left alone. */
1334 free_menubar_widget_value_tree (wv
)
1339 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1341 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1343 free_menubar_widget_value_tree (wv
->contents
);
1344 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1348 free_menubar_widget_value_tree (wv
->next
);
1349 wv
->next
= (widget_value
*) 0xDEADBEEF;
1352 free_widget_value (wv
);
1356 /* Return a tree of widget_value structures for a menu bar item
1357 whose event type is ITEM_KEY (with string ITEM_NAME)
1358 and whose contents come from the list of keymaps MAPS. */
1360 static widget_value
*
1361 single_submenu (item_key
, item_name
, maps
)
1362 Lisp_Object item_key
, item_name
, maps
;
1364 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1366 int submenu_depth
= 0;
1369 Lisp_Object
*mapvec
;
1370 widget_value
**submenu_stack
;
1371 int previous_items
= menu_items_used
;
1372 int top_level_items
= 0;
1374 length
= Flength (maps
);
1375 len
= XINT (length
);
1377 /* Convert the list MAPS into a vector MAPVEC. */
1378 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1379 for (i
= 0; i
< len
; i
++)
1381 mapvec
[i
] = Fcar (maps
);
1385 menu_items_n_panes
= 0;
1387 /* Loop over the given keymaps, making a pane for each map.
1388 But don't make a pane that is empty--ignore that map instead. */
1389 for (i
= 0; i
< len
; i
++)
1391 if (SYMBOLP (mapvec
[i
])
1392 || (CONSP (mapvec
[i
])
1393 && NILP (Fkeymapp (mapvec
[i
]))))
1395 /* Here we have a command at top level in the menu bar
1396 as opposed to a submenu. */
1397 top_level_items
= 1;
1398 push_menu_pane (Qnil
, Qnil
);
1399 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
],
1400 Qnil
, Qnil
, Qnil
, Qnil
);
1403 single_keymap_panes (mapvec
[i
], item_name
, item_key
, 0, 10);
1406 /* Create a tree of widget_value objects
1407 representing the panes and their items. */
1410 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1411 wv
= xmalloc_widget_value ();
1415 wv
->button_type
= BUTTON_TYPE_NONE
;
1420 /* Loop over all panes and items made during this call
1421 and construct a tree of widget_value objects.
1422 Ignore the panes and items made by previous calls to
1423 single_submenu, even though those are also in menu_items. */
1425 while (i
< menu_items_used
)
1427 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1429 submenu_stack
[submenu_depth
++] = save_wv
;
1434 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1437 save_wv
= submenu_stack
[--submenu_depth
];
1440 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1441 && submenu_depth
!= 0)
1442 i
+= MENU_ITEMS_PANE_LENGTH
;
1443 /* Ignore a nil in the item list.
1444 It's meaningful only for dialog boxes. */
1445 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1447 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1449 /* Create a new pane. */
1450 Lisp_Object pane_name
, prefix
;
1452 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1453 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1454 #ifndef HAVE_MULTILINGUAL_MENU
1455 if (STRINGP (pane_name
) && STRING_MULTIBYTE (pane_name
))
1456 pane_name
= string_make_unibyte (pane_name
);
1458 pane_string
= (NILP (pane_name
)
1459 ? "" : (char *) XSTRING (pane_name
)->data
);
1460 /* If there is just one top-level pane, put all its items directly
1461 under the top-level menu. */
1462 if (menu_items_n_panes
== 1)
1465 /* If the pane has a meaningful name,
1466 make the pane a top-level menu item
1467 with its items as a submenu beneath it. */
1468 if (strcmp (pane_string
, ""))
1470 wv
= xmalloc_widget_value ();
1474 first_wv
->contents
= wv
;
1475 wv
->name
= pane_string
;
1476 /* Ignore the @ that means "separate pane".
1477 This is a kludge, but this isn't worth more time. */
1478 if (!NILP (prefix
) && wv
->name
[0] == '@')
1482 wv
->button_type
= BUTTON_TYPE_NONE
;
1486 i
+= MENU_ITEMS_PANE_LENGTH
;
1490 /* Create a new item within current pane. */
1491 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
1494 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1495 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1497 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1498 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
1499 type
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_TYPE
];
1500 selected
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_SELECTED
];
1501 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
1503 #ifndef HAVE_MULTILINGUAL_MENU
1504 if (STRING_MULTIBYTE (item_name
))
1505 item_name
= string_make_unibyte (item_name
);
1506 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
1507 descrip
= string_make_unibyte (descrip
);
1510 wv
= xmalloc_widget_value ();
1514 save_wv
->contents
= wv
;
1516 wv
->name
= (char *) XSTRING (item_name
)->data
;
1517 if (!NILP (descrip
))
1518 wv
->key
= (char *) XSTRING (descrip
)->data
;
1520 /* The EMACS_INT cast avoids a warning. There's no problem
1521 as long as pointers have enough bits to hold small integers. */
1522 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1523 wv
->enabled
= !NILP (enable
);
1526 wv
->button_type
= BUTTON_TYPE_NONE
;
1527 else if (EQ (type
, QCradio
))
1528 wv
->button_type
= BUTTON_TYPE_RADIO
;
1529 else if (EQ (type
, QCtoggle
))
1530 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
1534 wv
->selected
= !NILP (selected
);
1536 wv
->help
= XSTRING (help
)->data
;
1540 i
+= MENU_ITEMS_ITEM_LENGTH
;
1544 /* If we have just one "menu item"
1545 that was originally a button, return it by itself. */
1546 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1548 wv
= first_wv
->contents
;
1549 free_widget_value (first_wv
);
1556 extern void EmacsFrameSetCharSize ();
1558 /* Recompute all the widgets of frame F, when the menu bar
1559 has been changed. */
1562 update_frame_menubar (f
)
1565 struct x_output
*x
= f
->output_data
.x
;
1567 int menubar_changed
;
1569 /* We assume the menubar contents has changed if the global flag is set,
1570 or if the current buffer has changed, or if the menubar has never
1571 been updated before.
1573 menubar_changed
= (x
->menubar_widget
1574 && !XtIsManaged (x
->menubar_widget
));
1576 if (! (menubar_changed
))
1580 /* Save the size of the frame because the pane widget doesn't accept to
1581 resize itself. So force it. */
1585 /* Do the voodoo which means "I'm changing lots of things, don't try to
1586 refigure sizes until I'm done." */
1587 lw_refigure_widget (x
->column_widget
, False
);
1589 /* the order in which children are managed is the top to
1590 bottom order in which they are displayed in the paned window.
1591 First, remove the text-area widget.
1593 XtUnmanageChild (x
->edit_widget
);
1595 /* remove the menubar that is there now, and put up the menubar that
1598 if (menubar_changed
)
1600 XtManageChild (x
->menubar_widget
);
1601 XtMapWidget (x
->menubar_widget
);
1602 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, 0);
1605 /* Re-manage the text-area widget, and then thrash the sizes. */
1606 XtManageChild (x
->edit_widget
);
1607 x_set_menu_resources_from_menu_face (f
, x
->menubar_widget
);
1608 lw_refigure_widget (x
->column_widget
, True
);
1610 /* Force the pane widget to resize itself with the right values. */
1611 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1615 /* Set the contents of the menubar widgets of frame F.
1616 The argument FIRST_TIME is currently ignored;
1617 it is set the first time this is called, from initialize_frame_menubar. */
1620 set_frame_menubar (f
, first_time
, deep_p
)
1625 Widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1627 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1631 XSETFRAME (Vmenu_updating_frame
, f
);
1633 if (f
->output_data
.x
->id
== 0)
1634 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1635 id
= f
->output_data
.x
->id
;
1637 if (! menubar_widget
)
1639 else if (pending_menu_activation
&& !deep_p
)
1641 /* Make the first call for any given frame always go deep. */
1642 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1645 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1646 f
->output_data
.x
->saved_menu_event
->type
= 0;
1649 wv
= xmalloc_widget_value ();
1650 wv
->name
= "menubar";
1653 wv
->button_type
= BUTTON_TYPE_NONE
;
1658 /* Make a widget-value tree representing the entire menu trees. */
1660 struct buffer
*prev
= current_buffer
;
1662 int specpdl_count
= specpdl_ptr
- specpdl
;
1663 int previous_menu_items_used
= f
->menu_bar_items_used
;
1664 Lisp_Object
*previous_items
1665 = (Lisp_Object
*) alloca (previous_menu_items_used
1666 * sizeof (Lisp_Object
));
1668 /* If we are making a new widget, its contents are empty,
1669 do always reinitialize them. */
1670 if (! menubar_widget
)
1671 previous_menu_items_used
= 0;
1673 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1674 specbind (Qinhibit_quit
, Qt
);
1675 /* Don't let the debugger step into this code
1676 because it is not reentrant. */
1677 specbind (Qdebug_on_next_call
, Qnil
);
1679 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1680 if (NILP (Voverriding_local_map_menu_flag
))
1682 specbind (Qoverriding_terminal_local_map
, Qnil
);
1683 specbind (Qoverriding_local_map
, Qnil
);
1686 set_buffer_internal_1 (XBUFFER (buffer
));
1688 /* Run the Lucid hook. */
1689 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1690 /* If it has changed current-menubar from previous value,
1691 really recompute the menubar from the value. */
1692 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1693 call0 (Qrecompute_lucid_menubar
);
1694 safe_run_hooks (Qmenu_bar_update_hook
);
1695 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1697 items
= FRAME_MENU_BAR_ITEMS (f
);
1699 inhibit_garbage_collection ();
1701 /* Save the frame's previous menu bar contents data. */
1702 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1703 previous_menu_items_used
* sizeof (Lisp_Object
));
1705 /* Fill in the current menu bar contents. */
1706 menu_items
= f
->menu_bar_vector
;
1707 menu_items_allocated
= XVECTOR (menu_items
)->size
;
1709 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1711 Lisp_Object key
, string
, maps
;
1713 key
= XVECTOR (items
)->contents
[i
];
1714 string
= XVECTOR (items
)->contents
[i
+ 1];
1715 maps
= XVECTOR (items
)->contents
[i
+ 2];
1719 wv
= single_submenu (key
, string
, maps
);
1723 first_wv
->contents
= wv
;
1724 /* Don't set wv->name here; GC during the loop might relocate it. */
1726 wv
->button_type
= BUTTON_TYPE_NONE
;
1730 finish_menu_items ();
1732 set_buffer_internal_1 (prev
);
1733 unbind_to (specpdl_count
, Qnil
);
1735 /* If there has been no change in the Lisp-level contents
1736 of the menu bar, skip redisplaying it. Just exit. */
1738 for (i
= 0; i
< previous_menu_items_used
; i
++)
1739 if (menu_items_used
== i
1740 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1742 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1744 free_menubar_widget_value_tree (first_wv
);
1750 /* Now GC cannot happen during the lifetime of the widget_value,
1751 so it's safe to store data from a Lisp_String. */
1752 wv
= first_wv
->contents
;
1753 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1756 string
= XVECTOR (items
)->contents
[i
+ 1];
1759 wv
->name
= (char *) XSTRING (string
)->data
;
1763 f
->menu_bar_vector
= menu_items
;
1764 f
->menu_bar_items_used
= menu_items_used
;
1769 /* Make a widget-value tree containing
1770 just the top level menu bar strings. */
1772 items
= FRAME_MENU_BAR_ITEMS (f
);
1773 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1777 string
= XVECTOR (items
)->contents
[i
+ 1];
1781 wv
= xmalloc_widget_value ();
1782 wv
->name
= (char *) XSTRING (string
)->data
;
1785 wv
->button_type
= BUTTON_TYPE_NONE
;
1786 /* This prevents lwlib from assuming this
1787 menu item is really supposed to be empty. */
1788 /* The EMACS_INT cast avoids a warning.
1789 This value just has to be different from small integers. */
1790 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1795 first_wv
->contents
= wv
;
1799 /* Forget what we thought we knew about what is in the
1800 detailed contents of the menu bar menus.
1801 Changing the top level always destroys the contents. */
1802 f
->menu_bar_items_used
= 0;
1805 /* Create or update the menu bar widget. */
1811 /* Disable resizing (done for Motif!) */
1812 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1814 /* The third arg is DEEP_P, which says to consider the entire
1815 menu trees we supply, rather than just the menu bar item names. */
1816 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1818 /* Re-enable the edit widget to resize. */
1819 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1823 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1824 f
->output_data
.x
->column_widget
,
1826 popup_activate_callback
,
1827 menubar_selection_callback
,
1828 popup_deactivate_callback
,
1829 menu_highlight_callback
);
1830 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1835 = (f
->output_data
.x
->menubar_widget
1836 ? (f
->output_data
.x
->menubar_widget
->core
.height
1837 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1840 #if 0 /* Experimentally, we now get the right results
1841 for -geometry -0-0 without this. 24 Aug 96, rms. */
1843 if (FRAME_EXTERNAL_MENU_BAR (f
))
1846 XtVaGetValues (f
->output_data
.x
->column_widget
,
1847 XtNinternalBorderWidth
, &ibw
, NULL
);
1848 menubar_size
+= ibw
;
1850 #endif /* USE_LUCID */
1853 f
->output_data
.x
->menubar_height
= menubar_size
;
1856 free_menubar_widget_value_tree (first_wv
);
1857 update_frame_menubar (f
);
1862 /* Called from Fx_create_frame to create the initial menubar of a frame
1863 before it is mapped, so that the window is mapped with the menubar already
1864 there instead of us tacking it on later and thrashing the window after it
1868 initialize_frame_menubar (f
)
1871 /* This function is called before the first chance to redisplay
1872 the frame. It has to be, so the frame will have the right size. */
1873 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1874 set_frame_menubar (f
, 1, 1);
1877 /* Get rid of the menu bar of frame F, and free its storage.
1878 This is used when deleting a frame, and when turning off the menu bar. */
1881 free_frame_menubar (f
)
1884 Widget menubar_widget
;
1886 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1888 f
->output_data
.x
->menubar_height
= 0;
1893 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1898 #endif /* USE_X_TOOLKIT */
1900 /* xmenu_show actually displays a menu using the panes and items in menu_items
1901 and returns the value selected from it.
1902 There are two versions of xmenu_show, one for Xt and one for Xlib.
1903 Both assume input is blocked by the caller. */
1905 /* F is the frame the menu is for.
1906 X and Y are the frame-relative specified position,
1907 relative to the inside upper left corner of the frame F.
1908 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1909 KEYMAPS is 1 if this menu was specified with keymaps;
1910 in that case, we return a list containing the chosen item's value
1911 and perhaps also the pane's prefix.
1912 TITLE is the specified menu title.
1913 ERROR is a place to store an error message string in case of failure.
1914 (We return nil on failure, but the value doesn't actually matter.) */
1916 #ifdef USE_X_TOOLKIT
1918 /* We need a unique id for each widget handled by the Lucid Widget
1921 For the main windows, and popup menus, we use this counter,
1922 which we increment each time after use. This starts from 1<<16.
1924 For menu bars, we use numbers starting at 0, counted in
1925 next_menubar_widget_id. */
1926 LWLIB_ID widget_id_tick
;
1928 static Lisp_Object
*volatile menu_item_selection
;
1931 popup_selection_callback (widget
, id
, client_data
)
1934 XtPointer client_data
;
1936 menu_item_selection
= (Lisp_Object
*) client_data
;
1940 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
1954 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1955 widget_value
**submenu_stack
1956 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1957 Lisp_Object
*subprefix_stack
1958 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1959 int submenu_depth
= 0;
1960 XButtonPressedEvent dummy
;
1966 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1968 *error
= "Empty menu";
1972 /* Create a tree of widget_value objects
1973 representing the panes and their items. */
1974 wv
= xmalloc_widget_value ();
1978 wv
->button_type
= BUTTON_TYPE_NONE
;
1982 /* Loop over all panes and items, filling in the tree. */
1984 while (i
< menu_items_used
)
1986 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1988 submenu_stack
[submenu_depth
++] = save_wv
;
1994 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1997 save_wv
= submenu_stack
[--submenu_depth
];
2001 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
2002 && submenu_depth
!= 0)
2003 i
+= MENU_ITEMS_PANE_LENGTH
;
2004 /* Ignore a nil in the item list.
2005 It's meaningful only for dialog boxes. */
2006 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2008 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2010 /* Create a new pane. */
2011 Lisp_Object pane_name
, prefix
;
2013 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2014 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2015 #ifndef HAVE_MULTILINGUAL_MENU
2016 if (!NILP (pane_name
) && STRING_MULTIBYTE (pane_name
))
2017 pane_name
= string_make_unibyte (pane_name
);
2019 pane_string
= (NILP (pane_name
)
2020 ? "" : (char *) XSTRING (pane_name
)->data
);
2021 /* If there is just one top-level pane, put all its items directly
2022 under the top-level menu. */
2023 if (menu_items_n_panes
== 1)
2026 /* If the pane has a meaningful name,
2027 make the pane a top-level menu item
2028 with its items as a submenu beneath it. */
2029 if (!keymaps
&& strcmp (pane_string
, ""))
2031 wv
= xmalloc_widget_value ();
2035 first_wv
->contents
= wv
;
2036 wv
->name
= pane_string
;
2037 if (keymaps
&& !NILP (prefix
))
2041 wv
->button_type
= BUTTON_TYPE_NONE
;
2045 else if (first_pane
)
2051 i
+= MENU_ITEMS_PANE_LENGTH
;
2055 /* Create a new item within current pane. */
2056 Lisp_Object item_name
, enable
, descrip
, def
, type
, selected
;
2057 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2058 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2060 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2061 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
2062 type
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_TYPE
];
2063 selected
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_SELECTED
];
2065 #ifndef HAVE_MULTILINGUAL_MENU
2066 if (STRINGP (item_name
) && STRING_MULTIBYTE (item_name
))
2067 item_name
= string_make_unibyte (item_name
);
2068 if (STRINGP (descrip
) && STRING_MULTIBYTE (descrip
))
2069 item_name
= string_make_unibyte (descrip
);
2072 wv
= xmalloc_widget_value ();
2076 save_wv
->contents
= wv
;
2077 wv
->name
= (char *) XSTRING (item_name
)->data
;
2078 if (!NILP (descrip
))
2079 wv
->key
= (char *) XSTRING (descrip
)->data
;
2081 /* If this item has a null value,
2082 make the call_data null so that it won't display a box
2083 when the mouse is on it. */
2085 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
2086 wv
->enabled
= !NILP (enable
);
2089 wv
->button_type
= BUTTON_TYPE_NONE
;
2090 else if (EQ (type
, QCtoggle
))
2091 wv
->button_type
= BUTTON_TYPE_TOGGLE
;
2092 else if (EQ (type
, QCradio
))
2093 wv
->button_type
= BUTTON_TYPE_RADIO
;
2097 wv
->selected
= !NILP (selected
);
2101 i
+= MENU_ITEMS_ITEM_LENGTH
;
2105 /* Deal with the title, if it is non-nil. */
2108 widget_value
*wv_title
= xmalloc_widget_value ();
2109 widget_value
*wv_sep1
= xmalloc_widget_value ();
2110 widget_value
*wv_sep2
= xmalloc_widget_value ();
2112 wv_sep2
->name
= "--";
2113 wv_sep2
->next
= first_wv
->contents
;
2115 wv_sep1
->name
= "--";
2116 wv_sep1
->next
= wv_sep2
;
2118 #ifndef HAVE_MULTILINGUAL_MENU
2119 if (STRING_MULTIBYTE (title
))
2120 title
= string_make_unibyte (title
);
2122 wv_title
->name
= (char *) XSTRING (title
)->data
;
2123 wv_title
->enabled
= True
;
2124 wv_title
->button_type
= BUTTON_TYPE_NONE
;
2125 wv_title
->next
= wv_sep1
;
2126 first_wv
->contents
= wv_title
;
2129 /* Actually create the menu. */
2130 menu_id
= widget_id_tick
++;
2131 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
2132 f
->output_data
.x
->widget
, 1, 0,
2133 popup_selection_callback
,
2134 popup_deactivate_callback
,
2135 menu_highlight_callback
);
2137 /* Adjust coordinates to relative to the outer (window manager) window. */
2140 int win_x
= 0, win_y
= 0;
2142 /* Find the position of the outside upper-left corner of
2143 the inner window, with respect to the outer window. */
2144 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2147 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2149 /* From-window, to-window. */
2150 f
->output_data
.x
->window_desc
,
2151 f
->output_data
.x
->parent_desc
,
2153 /* From-position, to-position. */
2154 0, 0, &win_x
, &win_y
,
2156 /* Child of window. */
2164 /* Adjust coordinates to be root-window-relative. */
2165 x
+= f
->output_data
.x
->left_pos
;
2166 y
+= f
->output_data
.x
->top_pos
;
2168 dummy
.type
= ButtonPress
;
2170 dummy
.send_event
= 0;
2171 dummy
.display
= FRAME_X_DISPLAY (f
);
2172 dummy
.time
= CurrentTime
;
2173 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2174 dummy
.window
= dummy
.root
;
2175 dummy
.subwindow
= dummy
.root
;
2180 dummy
.state
= (FRAME_X_DISPLAY_INFO (f
)->grabbed
>> 1) * Button1Mask
;
2182 for (i
= 0; i
< 5; i
++)
2183 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2186 /* Don't allow any geometry request from the user. */
2187 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2188 XtSetValues (menu
, av
, ac
);
2190 /* Free the widget_value objects we used to specify the contents. */
2191 free_menubar_widget_value_tree (first_wv
);
2193 /* No selection has been chosen yet. */
2194 menu_item_selection
= 0;
2196 /* Display the menu. */
2197 lw_popup_menu (menu
, (XEvent
*) &dummy
);
2198 x_set_menu_resources_from_menu_face (f
, menu
);
2199 popup_activated_flag
= 1;
2201 /* Process events that apply to the menu. */
2202 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
);
2204 #ifdef LESSTIF_VERSION
2205 /* Nov 1998: For an unknown reason a button grab remains active
2206 after the popup menu has gone. */
2207 XUngrabButton (XtDisplay (f
->output_data
.x
->widget
),
2208 AnyButton
, AnyModifier
,
2209 XtWindow (f
->output_data
.x
->widget
));
2210 XUngrabButton (XtDisplay (f
->output_data
.x
->edit_widget
),
2211 AnyButton
, AnyModifier
,
2212 XtWindow (f
->output_data
.x
->edit_widget
));
2213 #endif /* LESSTIF_VERSION */
2215 /* fp turned off the following statement and wrote a comment
2216 that it is unnecessary--that the menu has already disappeared.
2217 Nowadays the menu disappears ok, all right, but
2218 we need to delete the widgets or multiple ones will pile up. */
2219 lw_destroy_all_widgets (menu_id
);
2221 /* Find the selected item, and its pane, to return
2222 the proper value. */
2223 if (menu_item_selection
!= 0)
2225 Lisp_Object prefix
, entry
;
2229 while (i
< menu_items_used
)
2231 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2233 subprefix_stack
[submenu_depth
++] = prefix
;
2237 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2239 prefix
= subprefix_stack
[--submenu_depth
];
2242 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2245 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2246 i
+= MENU_ITEMS_PANE_LENGTH
;
2248 /* Ignore a nil in the item list.
2249 It's meaningful only for dialog boxes. */
2250 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2255 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2256 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2262 entry
= Fcons (entry
, Qnil
);
2264 entry
= Fcons (prefix
, entry
);
2265 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2266 if (!NILP (subprefix_stack
[j
]))
2267 entry
= Fcons (subprefix_stack
[j
], entry
);
2271 i
+= MENU_ITEMS_ITEM_LENGTH
;
2280 dialog_selection_callback (widget
, id
, client_data
)
2283 XtPointer client_data
;
2285 /* The EMACS_INT cast avoids a warning. There's no problem
2286 as long as pointers have enough bits to hold small integers. */
2287 if ((int) (EMACS_INT
) client_data
!= -1)
2288 menu_item_selection
= (Lisp_Object
*) client_data
;
2290 lw_destroy_all_widgets (id
);
2292 popup_activated_flag
= 0;
2295 static char * button_names
[] = {
2296 "button1", "button2", "button3", "button4", "button5",
2297 "button6", "button7", "button8", "button9", "button10" };
2300 xdialog_show (f
, keymaps
, title
, error
)
2306 int i
, nb_buttons
=0;
2309 char dialog_name
[6];
2311 widget_value
*wv
, *first_wv
= 0, *prev_wv
= 0;
2313 /* Number of elements seen so far, before boundary. */
2315 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2316 int boundary_seen
= 0;
2320 if (menu_items_n_panes
> 1)
2322 *error
= "Multiple panes in dialog box";
2326 /* Create a tree of widget_value objects
2327 representing the text label and buttons. */
2329 Lisp_Object pane_name
, prefix
;
2331 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2332 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2333 pane_string
= (NILP (pane_name
)
2334 ? "" : (char *) XSTRING (pane_name
)->data
);
2335 prev_wv
= xmalloc_widget_value ();
2336 prev_wv
->value
= pane_string
;
2337 if (keymaps
&& !NILP (prefix
))
2339 prev_wv
->enabled
= 1;
2340 prev_wv
->name
= "message";
2343 /* Loop over all panes and items, filling in the tree. */
2344 i
= MENU_ITEMS_PANE_LENGTH
;
2345 while (i
< menu_items_used
)
2348 /* Create a new item within current pane. */
2349 Lisp_Object item_name
, enable
, descrip
;
2350 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2351 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2353 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2355 if (NILP (item_name
))
2357 free_menubar_widget_value_tree (first_wv
);
2358 *error
= "Submenu in dialog items";
2361 if (EQ (item_name
, Qquote
))
2363 /* This is the boundary between left-side elts
2364 and right-side elts. Stop incrementing right_count. */
2369 if (nb_buttons
>= 9)
2371 free_menubar_widget_value_tree (first_wv
);
2372 *error
= "Too many dialog items";
2376 wv
= xmalloc_widget_value ();
2378 wv
->name
= (char *) button_names
[nb_buttons
];
2379 if (!NILP (descrip
))
2380 wv
->key
= (char *) XSTRING (descrip
)->data
;
2381 wv
->value
= (char *) XSTRING (item_name
)->data
;
2382 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2383 wv
->enabled
= !NILP (enable
);
2386 if (! boundary_seen
)
2390 i
+= MENU_ITEMS_ITEM_LENGTH
;
2393 /* If the boundary was not specified,
2394 by default put half on the left and half on the right. */
2395 if (! boundary_seen
)
2396 left_count
= nb_buttons
- nb_buttons
/ 2;
2398 wv
= xmalloc_widget_value ();
2399 wv
->name
= dialog_name
;
2401 /* Dialog boxes use a really stupid name encoding
2402 which specifies how many buttons to use
2403 and how many buttons are on the right.
2404 The Q means something also. */
2405 dialog_name
[0] = 'Q';
2406 dialog_name
[1] = '0' + nb_buttons
;
2407 dialog_name
[2] = 'B';
2408 dialog_name
[3] = 'R';
2409 /* Number of buttons to put on the right. */
2410 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2412 wv
->contents
= first_wv
;
2416 /* Actually create the dialog. */
2417 dialog_id
= widget_id_tick
++;
2418 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2419 f
->output_data
.x
->widget
, 1, 0,
2420 dialog_selection_callback
, 0, 0);
2421 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2422 /* Free the widget_value objects we used to specify the contents. */
2423 free_menubar_widget_value_tree (first_wv
);
2425 /* No selection has been chosen yet. */
2426 menu_item_selection
= 0;
2428 /* Display the menu. */
2429 lw_pop_up_all_widgets (dialog_id
);
2430 popup_activated_flag
= 1;
2432 /* Process events that apply to the menu. */
2433 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
);
2435 lw_destroy_all_widgets (dialog_id
);
2437 /* Find the selected item, and its pane, to return
2438 the proper value. */
2439 if (menu_item_selection
!= 0)
2445 while (i
< menu_items_used
)
2449 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2452 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2453 i
+= MENU_ITEMS_PANE_LENGTH
;
2458 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2459 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2463 entry
= Fcons (entry
, Qnil
);
2465 entry
= Fcons (prefix
, entry
);
2469 i
+= MENU_ITEMS_ITEM_LENGTH
;
2476 #else /* not USE_X_TOOLKIT */
2478 /* The frame of the last activated non-toolkit menu bar.
2479 Used to generate menu help events. */
2481 static struct frame
*menu_help_frame
;
2484 /* Show help HELP_STRING, or clear help if HELP_STRING is null. This
2485 cannot be done with generating a HELP_EVENT because XMenuActivate
2486 contains a loop that doesn't let Emacs process keyboard events. */
2489 menu_help_callback (help_string
)
2492 show_help_echo (help_string
? build_string (help_string
) : Qnil
, 1);
2497 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2507 int pane
, selidx
, lpane
, status
;
2508 Lisp_Object entry
, pane_prefix
;
2510 int ulx
, uly
, width
, height
;
2511 int dispwidth
, dispheight
;
2515 unsigned int dummy_uint
;
2518 if (menu_items_n_panes
== 0)
2521 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2523 *error
= "Empty menu";
2527 /* Figure out which root window F is on. */
2528 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2529 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2530 &dummy_uint
, &dummy_uint
);
2532 /* Make the menu on that window. */
2533 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2536 *error
= "Can't create menu";
2540 #ifdef HAVE_X_WINDOWS
2541 /* Adjust coordinates to relative to the outer (window manager) window. */
2544 int win_x
= 0, win_y
= 0;
2546 /* Find the position of the outside upper-left corner of
2547 the inner window, with respect to the outer window. */
2548 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2551 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2553 /* From-window, to-window. */
2554 f
->output_data
.x
->window_desc
,
2555 f
->output_data
.x
->parent_desc
,
2557 /* From-position, to-position. */
2558 0, 0, &win_x
, &win_y
,
2560 /* Child of window. */
2567 #endif /* HAVE_X_WINDOWS */
2569 /* Adjust coordinates to be root-window-relative. */
2570 x
+= f
->output_data
.x
->left_pos
;
2571 y
+= f
->output_data
.x
->top_pos
;
2573 /* Create all the necessary panes and their items. */
2575 while (i
< menu_items_used
)
2577 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2579 /* Create a new pane. */
2580 Lisp_Object pane_name
, prefix
;
2583 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2584 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2585 pane_string
= (NILP (pane_name
)
2586 ? "" : (char *) XSTRING (pane_name
)->data
);
2587 if (keymaps
&& !NILP (prefix
))
2590 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2591 if (lpane
== XM_FAILURE
)
2593 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2594 *error
= "Can't create pane";
2597 i
+= MENU_ITEMS_PANE_LENGTH
;
2599 /* Find the width of the widest item in this pane. */
2602 while (j
< menu_items_used
)
2605 item
= XVECTOR (menu_items
)->contents
[j
];
2613 width
= STRING_BYTES (XSTRING (item
));
2614 if (width
> maxwidth
)
2617 j
+= MENU_ITEMS_ITEM_LENGTH
;
2620 /* Ignore a nil in the item list.
2621 It's meaningful only for dialog boxes. */
2622 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2626 /* Create a new item within current pane. */
2627 Lisp_Object item_name
, enable
, descrip
, help
;
2628 unsigned char *item_data
;
2631 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2632 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2634 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2635 help
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_HELP
];
2636 help_string
= STRINGP (help
) ? XSTRING (help
)->data
: NULL
;
2638 if (!NILP (descrip
))
2640 int gap
= maxwidth
- STRING_BYTES (XSTRING (item_name
));
2643 spacer
= Fmake_string (make_number (gap
), make_number (' '));
2644 item_name
= concat2 (item_name
, spacer
);
2645 item_name
= concat2 (item_name
, descrip
);
2646 item_data
= XSTRING (item_name
)->data
;
2648 /* if alloca is fast, use that to make the space,
2649 to reduce gc needs. */
2651 = (unsigned char *) alloca (maxwidth
2652 + STRING_BYTES (XSTRING (descrip
)) + 1);
2653 bcopy (XSTRING (item_name
)->data
, item_data
,
2654 STRING_BYTES (XSTRING (item_name
)));
2655 for (j
= XSTRING (item_name
)->size
; j
< maxwidth
; j
++)
2657 bcopy (XSTRING (descrip
)->data
, item_data
+ j
,
2658 STRING_BYTES (XSTRING (descrip
)));
2659 item_data
[j
+ STRING_BYTES (XSTRING (descrip
))] = 0;
2663 item_data
= XSTRING (item_name
)->data
;
2665 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2666 menu
, lpane
, 0, item_data
,
2667 !NILP (enable
), help_string
)
2670 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2671 *error
= "Can't add selection to menu";
2674 i
+= MENU_ITEMS_ITEM_LENGTH
;
2678 /* All set and ready to fly. */
2679 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2680 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
),
2681 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2682 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
),
2683 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2684 x
= min (x
, dispwidth
);
2685 y
= min (y
, dispheight
);
2688 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2689 &ulx
, &uly
, &width
, &height
);
2690 if (ulx
+width
> dispwidth
)
2692 x
-= (ulx
+ width
) - dispwidth
;
2693 ulx
= dispwidth
- width
;
2695 if (uly
+height
> dispheight
)
2697 y
-= (uly
+ height
) - dispheight
;
2698 uly
= dispheight
- height
;
2700 if (ulx
< 0) x
-= ulx
;
2701 if (uly
< 0) y
-= uly
;
2703 XMenuSetAEQ (menu
, TRUE
);
2704 XMenuSetFreeze (menu
, TRUE
);
2707 /* Help display under X won't work because XMenuActivate contains
2708 a loop that doesn't give Emacs a chance to process it. */
2709 menu_help_frame
= f
;
2710 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2711 x
, y
, ButtonReleaseMask
, &datap
,
2712 menu_help_callback
);
2715 #ifdef HAVE_X_WINDOWS
2716 /* Assume the mouse has moved out of the X window.
2717 If it has actually moved in, we will get an EnterNotify. */
2718 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2725 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2728 /* Find the item number SELIDX in pane number PANE. */
2730 while (i
< menu_items_used
)
2732 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2736 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2738 i
+= MENU_ITEMS_PANE_LENGTH
;
2747 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2750 entry
= Fcons (entry
, Qnil
);
2751 if (!NILP (pane_prefix
))
2752 entry
= Fcons (pane_prefix
, entry
);
2758 i
+= MENU_ITEMS_ITEM_LENGTH
;
2764 *error
= "Can't activate menu";
2770 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2772 #ifdef HAVE_X_WINDOWS
2773 /* State that no mouse buttons are now held.
2774 (The oldXMenu code doesn't track this info for us.)
2775 That is not necessarily true, but the fiction leads to reasonable
2776 results, and it is a pain to ask which are actually held now. */
2777 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2783 #endif /* not USE_X_TOOLKIT */
2785 #endif /* HAVE_MENUS */
2790 staticpro (&menu_items
);
2793 Qdebug_on_next_call
= intern ("debug-on-next-call");
2794 staticpro (&Qdebug_on_next_call
);
2796 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
2797 "Frame for which we are updating a menu.\n\
2798 The enable predicate for a menu command should check this variable.");
2799 Vmenu_updating_frame
= Qnil
;
2801 #ifdef USE_X_TOOLKIT
2802 widget_id_tick
= (1<<16);
2803 next_menubar_widget_id
= 1;
2806 defsubr (&Sx_popup_menu
);
2808 defsubr (&Sx_popup_dialog
);