1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* X pop-up deck-of-cards menu facility for gnuemacs.
22 * Written by Jon Arnold and Roman Budzianowski
23 * Mods and rewrite by Robert Krawitz
27 /* Modified by Fred Pierresteguy on December 93
28 to make the popup menus and menubar use the Xt. */
30 /* Rewritten for clarity and GC protection by rms in Feb 94. */
34 /* On 4.3 this loses if it comes after xterm.h. */
38 #include "termhooks.h"
42 #include "blockinput.h"
44 /* This may include sys/types.h, and that somehow loses
45 if this is not done before the other system files. */
48 /* Load sys/types.h if not already loaded.
49 In some systems loading it twice is suicidal. */
51 #include <sys/types.h>
54 #include "dispextern.h"
57 #include "../oldXMenu/XMenu.h"
64 #include <X11/IntrinsicP.h>
65 #include <X11/CoreP.h>
66 #include <X11/StringDefs.h>
67 #include <X11/Xaw/Paned.h>
68 #include "../lwlib/lwlib.h"
69 #include "../lwlib/xlwmenuP.h"
70 #endif /* USE_X_TOOLKIT */
72 #define min(x,y) (((x) < (y)) ? (x) : (y))
73 #define max(x,y) (((x) > (y)) ? (x) : (y))
81 extern Display
*x_current_display
;
83 #define ButtonReleaseMask ButtonReleased
84 #endif /* not HAVE_X11 */
86 /* We need a unique id for each popup menu and dialog box. */
87 static unsigned int popup_id_tick
;
89 extern Lisp_Object Qmenu_enable
;
90 extern Lisp_Object Qmenu_bar
;
93 extern void process_expose_from_menu ();
94 extern XtAppContext Xt_app_con
;
96 static int string_width ();
97 static Lisp_Object
xdialog_show ();
100 static Lisp_Object
xmenu_show ();
101 static void keymap_panes ();
102 static void single_keymap_panes ();
103 static void list_of_panes ();
104 static void list_of_items ();
106 /* This holds a Lisp vector that holds the results of decoding
107 the keymaps or alist-of-alists that specify a menu.
109 It describes the panes and items within the panes.
111 Each pane is described by 3 elements in the vector:
112 t, the pane name, the pane's prefix key.
113 Then follow the pane's items, with 4 elements per item:
114 the item string, the enable flag, the item's value,
115 and the equivalent keyboard key's description string.
117 In some cases, multiple levels of menus may be described.
118 A single vector slot containing nil indicates the start of a submenu.
119 A single vector slot containing lambda indicates the end of a submenu.
120 The submenu follows a menu item which is the way to reach the submenu.
122 Using a Lisp vector to hold this information while we decode it
123 takes care of protecting all the data from GC. */
125 #define MENU_ITEMS_PANE_NAME 1
126 #define MENU_ITEMS_PANE_PREFIX 2
127 #define MENU_ITEMS_PANE_LENGTH 3
129 #define MENU_ITEMS_ITEM_NAME 0
130 #define MENU_ITEMS_ITEM_ENABLE 1
131 #define MENU_ITEMS_ITEM_VALUE 2
132 #define MENU_ITEMS_ITEM_EQUIV_KEY 3
133 #define MENU_ITEMS_ITEM_LENGTH 4
135 static Lisp_Object menu_items
;
137 /* Number of slots currently allocated in menu_items. */
138 static int menu_items_allocated
;
140 /* This is the index in menu_items of the first empty slot. */
141 static int menu_items_used
;
143 /* The number of panes currently recorded in menu_items,
144 excluding those within submenus. */
145 static int menu_items_n_panes
;
147 /* Current depth within submenus. */
148 static int menu_items_submenu_depth
;
150 /* Initialize the menu_items structure if we haven't already done so.
151 Also mark it as currently empty. */
156 if (NILP (menu_items
))
158 menu_items_allocated
= 60;
159 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
163 menu_items_n_panes
= 0;
164 menu_items_submenu_depth
= 0;
167 /* Call at the end of generating the data in menu_items.
168 This fills in the number of items in the last pane. */
175 /* Call when finished using the data for the current menu
179 discard_menu_items ()
181 /* Free the structure if it is especially large.
182 Otherwise, hold on to it, to save time. */
183 if (menu_items_allocated
> 200)
186 menu_items_allocated
= 0;
190 /* Make the menu_items vector twice as large. */
196 int old_size
= menu_items_allocated
;
199 menu_items_allocated
*= 2;
200 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
201 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
202 old_size
* sizeof (Lisp_Object
));
205 /* Begin a submenu. */
208 push_submenu_start ()
210 if (menu_items_used
+ 1 > menu_items_allocated
)
213 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
214 menu_items_submenu_depth
++;
222 if (menu_items_used
+ 1 > menu_items_allocated
)
225 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
226 menu_items_submenu_depth
--;
229 /* Start a new menu pane in menu_items..
230 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
233 push_menu_pane (name
, prefix_vec
)
234 Lisp_Object name
, prefix_vec
;
236 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
239 if (menu_items_submenu_depth
== 0)
240 menu_items_n_panes
++;
241 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
242 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
243 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
246 /* Push one menu item into the current pane.
247 NAME is the string to display. ENABLE if non-nil means
248 this item can be selected. KEY is the key generated by
249 choosing this item. EQUIV is the textual description
250 of the keyboard equivalent for this item (or nil if none). */
253 push_menu_item (name
, enable
, key
, equiv
)
254 Lisp_Object name
, enable
, key
, equiv
;
256 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
259 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
260 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
261 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
262 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
265 /* Figure out the current keyboard equivalent of a menu item ITEM1.
266 The item string for menu display should be ITEM_STRING.
267 Store the equivalent keyboard key sequence's
268 textual description into *DESCRIP_PTR.
269 Also cache them in the item itself.
270 Return the real definition to execute. */
273 menu_item_equiv_key (item_string
, item1
, descrip_ptr
)
274 Lisp_Object item_string
;
276 Lisp_Object
*descrip_ptr
;
278 /* This is the real definition--the function to run. */
280 /* This is the sublist that records cached equiv key data
281 so we can save time. */
282 Lisp_Object cachelist
;
283 /* These are the saved equivalent keyboard key sequence
284 and its key-description. */
285 Lisp_Object savedkey
, descrip
;
289 /* If a help string follows the item string, skip it. */
290 if (CONSP (XCONS (item1
)->cdr
)
291 && STRINGP (XCONS (XCONS (item1
)->cdr
)->car
))
292 item1
= XCONS (item1
)->cdr
;
296 /* Get out the saved equivalent-keyboard-key info. */
297 cachelist
= savedkey
= descrip
= Qnil
;
298 if (CONSP (def
) && CONSP (XCONS (def
)->car
)
299 && (NILP (XCONS (XCONS (def
)->car
)->car
)
300 || VECTORP (XCONS (XCONS (def
)->car
)->car
)))
302 cachelist
= XCONS (def
)->car
;
303 def
= XCONS (def
)->cdr
;
304 savedkey
= XCONS (cachelist
)->car
;
305 descrip
= XCONS (cachelist
)->cdr
;
308 /* Is it still valid? */
310 if (!NILP (savedkey
))
311 def1
= Fkey_binding (savedkey
, Qnil
);
312 /* If not, update it. */
314 /* If something had no key binding before, don't recheck it--
315 doing that takes too much time and makes menus too slow. */
316 && !(!NILP (cachelist
) && NILP (savedkey
)))
320 savedkey
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
);
321 if (VECTORP (savedkey
)
322 && EQ (XVECTOR (savedkey
)->contents
[0], Qmenu_bar
))
324 if (!NILP (savedkey
))
326 descrip
= Fkey_description (savedkey
);
327 descrip
= concat2 (make_string (" (", 3), descrip
);
328 descrip
= concat2 (descrip
, make_string (")", 1));
332 /* Cache the data we just got in a sublist of the menu binding. */
333 if (NILP (cachelist
))
334 XCONS (item1
)->cdr
= Fcons (Fcons (savedkey
, descrip
), def
);
337 XCONS (cachelist
)->car
= savedkey
;
338 XCONS (cachelist
)->cdr
= descrip
;
341 *descrip_ptr
= descrip
;
345 /* This is used as the handler when calling internal_condition_case_1. */
348 menu_item_enabled_p_1 (arg
)
354 /* Return non-nil if the command DEF is enabled when used as a menu item.
355 This is based on looking for a menu-enable property.
356 If NOTREAL is set, don't bother really computing this. */
359 menu_item_enabled_p (def
, notreal
)
362 Lisp_Object enabled
, tem
;
367 if (XTYPE (def
) == Lisp_Symbol
)
369 /* No property, or nil, means enable.
370 Otherwise, enable if value is not nil. */
371 tem
= Fget (def
, Qmenu_enable
);
373 /* (condition-case nil (eval tem)
375 enabled
= internal_condition_case_1 (Feval
, tem
, Qerror
,
376 menu_item_enabled_p_1
);
381 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
382 and generate menu panes for them in menu_items.
383 If NOTREAL is nonzero,
384 don't bother really computing whether an item is enabled. */
387 keymap_panes (keymaps
, nmaps
, notreal
)
388 Lisp_Object
*keymaps
;
396 /* Loop over the given keymaps, making a pane for each map.
397 But don't make a pane that is empty--ignore that map instead.
398 P is the number of panes we have made so far. */
399 for (mapno
= 0; mapno
< nmaps
; mapno
++)
400 single_keymap_panes (keymaps
[mapno
], Qnil
, Qnil
, notreal
);
402 finish_menu_items ();
405 /* This is a recursive subroutine of keymap_panes.
406 It handles one keymap, KEYMAP.
407 The other arguments are passed along
408 or point to local variables of the previous function.
409 If NOTREAL is nonzero,
410 don't bother really computing whether an item is enabled. */
413 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
)
415 Lisp_Object pane_name
;
419 Lisp_Object pending_maps
;
420 Lisp_Object tail
, item
, item1
, item_string
, table
;
421 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
425 push_menu_pane (pane_name
, prefix
);
427 for (tail
= keymap
; XTYPE (tail
) == Lisp_Cons
; tail
= XCONS (tail
)->cdr
)
429 /* Look at each key binding, and if it has a menu string,
430 make a menu item from it. */
431 item
= XCONS (tail
)->car
;
432 if (XTYPE (item
) == Lisp_Cons
)
434 item1
= XCONS (item
)->cdr
;
435 if (XTYPE (item1
) == Lisp_Cons
)
437 item_string
= XCONS (item1
)->car
;
438 if (XTYPE (item_string
) == Lisp_String
)
440 /* This is the real definition--the function to run. */
442 /* These are the saved equivalent keyboard key sequence
443 and its key-description. */
445 Lisp_Object tem
, enabled
;
447 def
= menu_item_equiv_key (item_string
, item1
, &descrip
);
449 /* GCPRO because we will call eval.
450 Protecting KEYMAP preserves everything we use;
451 aside from that, must protect whatever might be
452 a string. Since there's no GCPRO5, we refetch
453 item_string instead of protecting it. */
454 GCPRO4 (keymap
, pending_maps
, def
, descrip
);
455 enabled
= menu_item_enabled_p (def
, notreal
);
459 item_string
= XCONS (item1
)->car
;
461 tem
= Fkeymapp (def
);
462 if (XSTRING (item_string
)->data
[0] == '@' && !NILP (tem
))
463 pending_maps
= Fcons (Fcons (def
, Fcons (item_string
, XCONS (item
)->car
)),
468 submap
= get_keymap_1 (def
, 0, 1);
469 #ifndef USE_X_TOOLKIT
470 /* Indicate visually that this is a submenu. */
472 item_string
= concat2 (item_string
,
473 build_string (" >"));
475 push_menu_item (item_string
, enabled
, XCONS (item
)->car
,
478 /* Display a submenu using the toolkit. */
481 push_submenu_start ();
482 single_keymap_panes (submap
, Qnil
,
483 XCONS (item
)->car
, notreal
);
491 else if (XTYPE (item
) == Lisp_Vector
)
493 /* Loop over the char values represented in the vector. */
494 int len
= XVECTOR (item
)->size
;
496 for (c
= 0; c
< len
; c
++)
498 Lisp_Object character
;
499 XFASTINT (character
) = c
;
500 item1
= XVECTOR (item
)->contents
[c
];
501 if (XTYPE (item1
) == Lisp_Cons
)
503 item_string
= XCONS (item1
)->car
;
504 if (XTYPE (item_string
) == Lisp_String
)
508 /* These are the saved equivalent keyboard key sequence
509 and its key-description. */
511 Lisp_Object tem
, enabled
;
513 def
= menu_item_equiv_key (item_string
, item1
, &descrip
);
515 /* GCPRO because we will call eval.
516 Protecting KEYMAP preserves everything we use;
517 aside from that, must protect whatever might be
518 a string. Since there's no GCPRO5, we refetch
519 item_string instead of protecting it. */
520 GCPRO4 (keymap
, pending_maps
, def
, descrip
);
521 enabled
= menu_item_enabled_p (def
, notreal
);
524 item_string
= XCONS (item1
)->car
;
526 tem
= Fkeymapp (def
);
527 if (XSTRING (item_string
)->data
[0] == '@' && !NILP (tem
))
528 pending_maps
= Fcons (Fcons (def
, Fcons (item_string
, character
)),
533 submap
= get_keymap_1 (def
, 0, 1);
534 #ifndef USE_X_TOOLKIT
536 item_string
= concat2 (item_string
,
537 build_string (" >"));
539 push_menu_item (item_string
, enabled
, character
,
544 push_submenu_start ();
545 single_keymap_panes (submap
, Qnil
,
557 /* Process now any submenus which want to be panes at this level. */
558 while (!NILP (pending_maps
))
560 Lisp_Object elt
, eltcdr
, string
;
561 elt
= Fcar (pending_maps
);
562 eltcdr
= XCONS (elt
)->cdr
;
563 string
= XCONS (eltcdr
)->car
;
564 /* We no longer discard the @ from the beginning of the string here.
565 Instead, we do this in xmenu_show. */
566 single_keymap_panes (Fcar (elt
), string
,
567 XCONS (eltcdr
)->cdr
, notreal
);
568 pending_maps
= Fcdr (pending_maps
);
572 /* Push all the panes and items of a menu decsribed by the
573 alist-of-alists MENU.
574 This handles old-fashioned calls to x-popup-menu. */
584 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
586 Lisp_Object elt
, pane_name
, pane_data
;
588 pane_name
= Fcar (elt
);
589 CHECK_STRING (pane_name
, 0);
590 push_menu_pane (pane_name
, Qnil
);
591 pane_data
= Fcdr (elt
);
592 CHECK_CONS (pane_data
, 0);
593 list_of_items (pane_data
);
596 finish_menu_items ();
599 /* Push the items in a single pane defined by the alist PANE. */
605 Lisp_Object tail
, item
, item1
;
607 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
611 push_menu_item (item
, Qnil
, Qnil
);
614 CHECK_CONS (item
, 0);
616 CHECK_STRING (item1
, 1);
617 push_menu_item (item1
, Qt
, Fcdr (item
), Qnil
);
622 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 1, 2, 0,
623 "Pop up a deck-of-cards menu and return user's selection.\n\
624 POSITION is a position specification. This is either a mouse button event\n\
625 or a list ((XOFFSET YOFFSET) WINDOW)\n\
626 where XOFFSET and YOFFSET are positions in characters from the top left\n\
627 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
628 This controls the position of the center of the first line\n\
629 in the first pane of the menu, not the top left of the menu as a whole.\n\
630 If POSITION is t, it means to use the current mouse position.\n\
632 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
633 The menu items come from key bindings that have a menu string as well as\n\
634 a definition; actually, the \"definition\" in such a key binding looks like\n\
635 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
636 the keymap as a top-level element.\n\n\
637 You can also use a list of keymaps as MENU.\n\
638 Then each keymap makes a separate pane.\n\
639 When MENU is a keymap or a list of keymaps, the return value\n\
640 is a list of events.\n\n\
641 Alternatively, you can specify a menu of multiple panes\n\
642 with a list of the form (TITLE PANE1 PANE2...),\n\
643 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
644 Each ITEM is normally a cons cell (STRING . VALUE);\n\
645 but a string can appear as an item--that makes a nonselectable line\n\
647 With this form of menu, the return value is VALUE from the chosen item.\n\
649 If POSITION is nil, don't display the menu at all, just precalculate the\n\
650 cached information about equivalent key sequences.")
652 Lisp_Object position
, menu
;
654 int number_of_panes
, panes
;
655 Lisp_Object keymap
, tem
;
659 Lisp_Object selection
;
662 Lisp_Object x
, y
, window
;
667 if (! NILP (position
))
671 /* Decode the first argument: find the window and the coordinates. */
672 if (EQ (position
, Qt
))
674 /* Use the mouse's current position. */
676 Lisp_Object bar_window
;
680 (*mouse_position_hook
) (&new_f
, &bar_window
, &part
, &x
, &y
, &time
);
681 XSET (window
, Lisp_Frame
, new_f
);
685 tem
= Fcar (position
);
686 if (XTYPE (tem
) == Lisp_Cons
)
688 window
= Fcar (Fcdr (position
));
690 y
= Fcar (Fcdr (tem
));
694 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
695 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
696 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
700 /* Determine whether this menu is handling a menu bar click. */
701 tem
= Fcar (Fcdr (Fcar (Fcdr (position
))));
702 if (XTYPE (Fcar (position
)) != Lisp_Cons
704 && EQ (Fcar (tem
), Qmenu_bar
))
712 /* Decode where to put the menu. */
714 if (XTYPE (window
) == Lisp_Frame
)
721 else if (XTYPE (window
) == Lisp_Window
)
723 CHECK_LIVE_WINDOW (window
, 0);
724 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
726 xpos
= (FONT_WIDTH (f
->display
.x
->font
) * XWINDOW (window
)->left
);
727 ypos
= (FONT_HEIGHT (f
->display
.x
->font
) * XWINDOW (window
)->top
);
730 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
731 but I don't want to make one now. */
732 CHECK_WINDOW (window
, 0);
741 /* Decode the menu items from what was specified. */
743 keymap
= Fkeymapp (menu
);
745 if (XTYPE (menu
) == Lisp_Cons
)
746 tem
= Fkeymapp (Fcar (menu
));
749 /* We were given a keymap. Extract menu info from the keymap. */
751 keymap
= get_keymap (menu
);
753 /* Extract the detailed info to make one pane. */
754 keymap_panes (&menu
, 1, NILP (position
));
756 /* Search for a string appearing directly as an element of the keymap.
757 That string is the title of the menu. */
758 prompt
= map_prompt (keymap
);
760 /* Make that be the pane title of the first pane. */
761 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
762 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
766 else if (!NILP (tem
))
768 /* We were given a list of keymaps. */
769 int nmaps
= XFASTINT (Flength (menu
));
771 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
776 /* The first keymap that has a prompt string
777 supplies the menu title. */
778 for (tem
= menu
, i
= 0; XTYPE (tem
) == Lisp_Cons
; tem
= Fcdr (tem
))
782 maps
[i
++] = keymap
= get_keymap (Fcar (tem
));
784 prompt
= map_prompt (keymap
);
785 if (NILP (title
) && !NILP (prompt
))
789 /* Extract the detailed info to make one pane. */
790 keymap_panes (maps
, nmaps
, NILP (position
));
792 /* Make the title be the pane title of the first pane. */
793 if (!NILP (title
) && menu_items_n_panes
>= 0)
794 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
800 /* We were given an old-fashioned menu. */
802 CHECK_STRING (title
, 1);
804 list_of_panes (Fcdr (menu
));
811 discard_menu_items ();
816 /* Display them in a menu. */
819 selection
= xmenu_show (f
, xpos
, ypos
, menubarp
,
820 keymaps
, title
, &error_name
);
823 discard_menu_items ();
827 if (error_name
) error (error_name
);
833 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 1, 2, 0,
834 "Pop up a dialog box and return user's selection.\n\
835 POSITION is a position specification. This is either a mouse button event\n\
836 or a list ((XOFFSET YOFFSET) WINDOW)\n\
837 where XOFFSET and YOFFSET are positions in characters from the top left\n\
838 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
839 This controls the position of the center of the first line\n\
840 in the first pane of the menu, not the top left of the menu as a whole.\n\
841 If POSITION is t, it means to use the current mouse position.\n\
843 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
844 The menu items come from key bindings that have a menu string as well as\n\
845 a definition; actually, the \"definition\" in such a key binding looks like\n\
846 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
847 the keymap as a top-level element.\n\n\
848 You can also use a list of keymaps as MENU.\n\
849 Then each keymap makes a separate pane.\n\
850 When MENU is a keymap or a list of keymaps, the return value\n\
851 is a list of events.\n\n\
852 Alternatively, you can specify a menu of multiple panes\n\
853 with a list of the form (TITLE PANE1 PANE2...),\n\
854 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
855 Each ITEM is normally a cons cell (STRING . VALUE);\n\
856 but a string can appear as an item--that makes a nonselectable line\n\
858 With this form of menu, the return value is VALUE from the chosen item.\n\
860 If POSITION is nil, don't display the menu at all, just precalculate the\n\
861 cached information about equivalent key sequences.")
863 Lisp_Object position
, menu
;
865 int number_of_panes
, panes
;
866 Lisp_Object keymap
, tem
;
870 Lisp_Object selection
;
873 Lisp_Object x
, y
, window
;
880 if (! NILP (position
))
882 /* Decode the first argument: find the window and the coordinates. */
883 if (EQ (position
, Qt
))
885 /* Use the mouse's current position. */
887 Lisp_Object bar_window
;
891 (*mouse_position_hook
) (&new_f
, &bar_window
, &part
, &x
, &y
, &time
);
892 XSET (window
, Lisp_Frame
, new_f
);
898 /* Decode where to put the menu. */
900 if (XTYPE (window
) == Lisp_Frame
)
907 else if (XTYPE (window
) == Lisp_Window
)
909 CHECK_LIVE_WINDOW (window
, 0);
910 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
912 xpos
= (FONT_WIDTH (f
->display
.x
->font
) * XWINDOW (window
)->left
);
913 ypos
= (FONT_HEIGHT (f
->display
.x
->font
) * XWINDOW (window
)->top
);
916 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
917 but I don't want to make one now. */
918 CHECK_WINDOW (window
, 0);
927 /* Decode the dialog items from what was specified. */
929 /* We were given an old-fashioned menu. */
931 CHECK_STRING (title
, 1);
933 list_of_panes (Fcdr (menu
));
940 discard_menu_items ();
945 /* Display them in a dialog box. */
948 selection
= xdialog_show (f
, xpos
, ypos
, menubarp
,
949 keymaps
, title
, &error_name
);
952 discard_menu_items ();
956 if (error_name
) error (error_name
);
964 dispatch_dummy_expose (w
, x
, y
)
972 dummy
.window
= XtWindow (w
);
975 dummy
.send_event
= 0;
976 dummy
.display
= XtDisplay (w
);
980 XtDispatchEvent (&dummy
);
991 XTextExtents (mw
->menu
.font
, s
, strlen (s
), &drop
, &drop
, &drop
, &xcs
);
996 event_is_in_menu_item (mw
, event
, name
, string_w
)
998 struct input_event
*event
;
1002 *string_w
+= (string_width (mw
, name
)
1003 + 2 * (mw
->menu
.horizontal_spacing
1004 + mw
->menu
.shadow_thickness
));
1005 return XINT (event
->x
) < *string_w
;
1009 /* Return the menu bar key which corresponds to event EVENT in frame F. */
1012 map_event_to_object (event
, f
)
1013 struct input_event
*event
;
1018 XlwMenuWidget mw
= (XlwMenuWidget
) f
->display
.x
->menubar_widget
;
1023 /* Find the window */
1024 for (val
= mw
->menu
.old_stack
[0]->contents
; val
; val
= val
->next
)
1026 ws
= &mw
->menu
.windows
[0];
1027 if (ws
&& event_is_in_menu_item (mw
, event
, val
->name
, &string_w
))
1032 items
= FRAME_MENU_BAR_ITEMS (f
);
1034 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 3)
1036 Lisp_Object pos
, string
, item
;
1037 item
= XVECTOR (items
)->contents
[i
];
1038 string
= XVECTOR (items
)->contents
[i
+ 1];
1039 pos
= XVECTOR (items
)->contents
[i
+ 2];
1043 if (!strcmp (val
->name
, XSTRING (string
)->data
))
1051 static Lisp_Object
*menu_item_selection
;
1054 popup_selection_callback (widget
, id
, client_data
)
1057 XtPointer client_data
;
1059 menu_item_selection
= (Lisp_Object
*) client_data
;
1063 popup_down_callback (widget
, id
, client_data
)
1066 XtPointer client_data
;
1069 lw_destroy_all_widgets (id
);
1074 dialog_selection_callback (widget
, id
, client_data
)
1077 XtPointer client_data
;
1079 if ((int)client_data
!= -1)
1080 menu_item_selection
= (Lisp_Object
*) client_data
;
1082 lw_destroy_all_widgets (id
);
1086 /* This recursively calls free_widget_value() on the tree of widgets.
1087 It must free all data that was malloc'ed for these widget_values.
1088 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1089 must be left alone. */
1092 free_menubar_widget_value_tree (wv
)
1097 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1099 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1101 free_menubar_widget_value_tree (wv
->contents
);
1102 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1106 free_menubar_widget_value_tree (wv
->next
);
1107 wv
->next
= (widget_value
*) 0xDEADBEEF;
1110 free_widget_value (wv
);
1114 extern void EmacsFrameSetCharSize ();
1117 update_one_frame_psheets (f
)
1120 struct x_display
*x
= f
->display
.x
;
1122 int menubar_changed
;
1124 menubar_changed
= (x
->menubar_widget
1125 && !XtIsManaged (x
->menubar_widget
));
1127 if (! (menubar_changed
))
1131 /* Save the size of the frame because the pane widget doesn't accept to
1132 resize itself. So force it. */
1137 XawPanedSetRefigureMode (x
->column_widget
, 0);
1139 /* the order in which children are managed is the top to
1140 bottom order in which they are displayed in the paned window.
1141 First, remove the text-area widget.
1143 XtUnmanageChild (x
->edit_widget
);
1145 /* remove the menubar that is there now, and put up the menubar that
1148 if (menubar_changed
)
1150 XtManageChild (x
->menubar_widget
);
1151 XtMapWidget (x
->menubar_widget
);
1152 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, 0);
1156 /* Re-manage the text-area widget */
1157 XtManageChild (x
->edit_widget
);
1159 /* and now thrash the sizes */
1160 XawPanedSetRefigureMode (x
->column_widget
, 1);
1162 /* Force the pane widget to resize itself with the right values. */
1163 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1169 set_frame_menubar (f
)
1172 Widget menubar_widget
= f
->display
.x
->menubar_widget
;
1174 Lisp_Object tail
, items
;
1175 widget_value
*wv
, *save_wv
, *first_wv
, *prev_wv
= 0;
1180 wv
= malloc_widget_value ();
1181 wv
->name
= "menubar";
1184 save_wv
= first_wv
= wv
;
1186 items
= FRAME_MENU_BAR_ITEMS (f
);
1188 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 3)
1192 string
= XVECTOR (items
)->contents
[i
+ 1];
1196 wv
= malloc_widget_value ();
1200 save_wv
->contents
= wv
;
1201 wv
->name
= XSTRING (string
)->data
;
1208 lw_modify_all_widgets (id
, first_wv
, False
);
1211 menubar_widget
= lw_create_widget ("menubar", "menubar",
1213 f
->display
.x
->column_widget
,
1216 f
->display
.x
->menubar_widget
= menubar_widget
;
1217 XtVaSetValues (menubar_widget
,
1219 XtNresizeToPreferred
, 1,
1224 free_menubar_widget_value_tree (first_wv
);
1226 update_one_frame_psheets (f
);
1232 free_frame_menubar (f
)
1235 Widget menubar_widget
;
1238 menubar_widget
= f
->display
.x
->menubar_widget
;
1244 lw_destroy_all_widgets (id
);
1249 /* Nonzero if position X, Y relative to inside of frame F
1250 is in some other menu bar item. */
1252 static int this_menu_bar_item_beg
;
1253 static int this_menu_bar_item_end
;
1256 other_menu_bar_item_p (f
, x
, y
)
1261 && y
< f
->display
.x
->menubar_widget
->core
.height
1263 && x
< f
->display
.x
->menubar_widget
->core
.width
1264 && (x
>= this_menu_bar_item_end
1265 || x
< this_menu_bar_item_beg
));
1268 /* Unread a button-press event in the menu bar of frame F
1269 at x position XPOS relative to the inside of the frame. */
1272 unread_menu_bar_button (f
, xpos
)
1278 event
.type
= ButtonPress
;
1279 event
.xbutton
.display
= x_current_display
;
1280 event
.xbutton
.serial
= 0;
1281 event
.xbutton
.send_event
= 0;
1282 event
.xbutton
.time
= CurrentTime
;
1283 event
.xbutton
.button
= Button1
;
1284 event
.xbutton
.window
= XtWindow (f
->display
.x
->menubar_widget
);
1285 event
.xbutton
.x
= xpos
;
1286 XPutBackEvent (XDISPLAY
&event
);
1289 /* If the mouse has moved to another menu bar item,
1290 return 1 and unread a button press event for that item.
1291 Otherwise return 0. */
1294 check_mouse_other_menu_bar (f
)
1298 Lisp_Object bar_window
;
1303 (*mouse_position_hook
) (&new_f
, &bar_window
, &part
, &x
, &y
, &time
);
1305 if (f
== new_f
&& other_menu_bar_item_p (f
, x
, y
))
1307 unread_menu_bar_button (f
, x
);
1313 #endif /* USE_X_TOOLKIT */
1315 /* xmenu_show actually displays a menu using the panes and items in menu_items
1316 and returns the value selected from it.
1317 There are two versions of xmenu_show, one for Xt and one for Xlib.
1318 Both assume input is blocked by the caller. */
1320 /* F is the frame the menu is for.
1321 X and Y are the frame-relative specified position,
1322 relative to the inside upper left corner of the frame F.
1323 MENUBARP is 1 if the click that asked for this menu came from the menu bar.
1324 KEYMAPS is 1 if this menu was specified with keymaps;
1325 in that case, we return a list containing the chosen item's value
1326 and perhaps also the pane's prefix.
1327 TITLE is the specified menu title.
1328 ERROR is a place to store an error message string in case of failure.
1329 (We return nil on failure, but the value doesn't actually matter.) */
1331 #ifdef USE_X_TOOLKIT
1333 extern unsigned int x_mouse_grabbed
;
1334 extern Lisp_Object Vmouse_depressed
;
1337 xmenu_show (f
, x
, y
, menubarp
, keymaps
, title
, error
)
1349 XlwMenuWidget menubar
= (XlwMenuWidget
) f
->display
.x
->menubar_widget
;
1351 /* This is the menu bar item (if any) that led to this menu. */
1352 widget_value
*menubar_item
= 0;
1354 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1355 widget_value
**submenu_stack
1356 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1357 Lisp_Object
*subprefix_stack
1358 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1359 int submenu_depth
= 0;
1361 /* Define a queue to save up for later unreading
1362 all X events that don't pertain to the menu. */
1366 struct event_queue
*next
;
1369 struct event_queue
*queue
= NULL
;
1370 struct event_queue
*queue_tmp
;
1374 this_menu_bar_item_beg
= -1;
1375 this_menu_bar_item_end
= -1;
1377 /* Figure out which menu bar item, if any, this menu is for. */
1383 for (menubar_item
= menubar
->menu
.old_stack
[0]->contents
;
1385 menubar_item
= menubar_item
->next
)
1388 xend
+= (string_width (menubar
, menubar_item
->name
)
1389 + 2 * (menubar
->menu
.horizontal_spacing
1390 + menubar
->menu
.shadow_thickness
));
1395 /* Arrange to show a different menu if we move in the menu bar
1396 to a different item. */
1397 this_menu_bar_item_beg
= xbeg
;
1398 this_menu_bar_item_end
= xend
;
1403 if (menubar_item
== 0)
1406 /* Offset the coordinates to root-relative. */
1407 x
+= (f
->display
.x
->widget
->core
.x
1408 + f
->display
.x
->widget
->core
.border_width
);
1409 y
+= (f
->display
.x
->widget
->core
.y
1410 + f
->display
.x
->widget
->core
.border_width
1411 + f
->display
.x
->menubar_widget
->core
.height
);
1413 /* Create a tree of widget_value objects
1414 representing the panes and their items. */
1415 wv
= malloc_widget_value ();
1421 /* Loop over all panes and items, filling in the tree. */
1423 while (i
< menu_items_used
)
1425 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1427 submenu_stack
[submenu_depth
++] = save_wv
;
1432 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1435 save_wv
= submenu_stack
[--submenu_depth
];
1438 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1439 && submenu_depth
!= 0)
1440 i
+= MENU_ITEMS_PANE_LENGTH
;
1441 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1443 /* Create a new pane. */
1444 Lisp_Object pane_name
, prefix
;
1446 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1447 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1448 pane_string
= (NILP (pane_name
)
1449 ? "" : (char *) XSTRING (pane_name
)->data
);
1450 /* If there is just one top-level pane, put all its items directly
1451 under the top-level menu. */
1452 if (menu_items_n_panes
== 1)
1455 /* If the pane has a meaningful name,
1456 make the pane a top-level menu item
1457 with its items as a submenu beneath it. */
1458 if (strcmp (pane_string
, ""))
1460 wv
= malloc_widget_value ();
1464 first_wv
->contents
= wv
;
1465 wv
->name
= pane_string
;
1466 if (keymaps
&& !NILP (prefix
))
1473 i
+= MENU_ITEMS_PANE_LENGTH
;
1477 /* Create a new item within current pane. */
1478 Lisp_Object item_name
, enable
, descrip
;
1479 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1480 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1482 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1484 wv
= malloc_widget_value ();
1488 save_wv
->contents
= wv
;
1489 wv
->name
= XSTRING (item_name
)->data
;
1490 if (!NILP (descrip
))
1491 wv
->key
= XSTRING (descrip
)->data
;
1493 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
1494 wv
->enabled
= !NILP (enable
);
1497 i
+= MENU_ITEMS_ITEM_LENGTH
;
1501 /* Actually create the menu. */
1502 menu_id
= ++popup_id_tick
;
1503 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1504 f
->display
.x
->widget
, 1, 0,
1505 popup_selection_callback
, popup_down_callback
);
1506 /* Free the widget_value objects we used to specify the contents. */
1507 free_menubar_widget_value_tree (first_wv
);
1509 /* No selection has been chosen yet. */
1510 menu_item_selection
= 0;
1512 /* If the mouse moves out of the menu before we show the menu,
1513 don't show it at all. */
1514 if (check_mouse_other_menu_bar (f
))
1516 lw_destroy_all_widgets (menu_id
);
1521 /* Highlight the menu bar item (if any) that led to this menu. */
1524 menubar_item
->call_data
= (XtPointer
) 1;
1525 dispatch_dummy_expose (f
->display
.x
->menubar_widget
, x
, y
);
1528 /* Display the menu. */
1530 XButtonPressedEvent dummy
;
1533 mw
= (XlwMenuWidget
) ((CompositeWidget
)menu
)->composite
.children
[0];
1535 dummy
.type
= ButtonPress
;
1537 dummy
.send_event
= 0;
1538 dummy
.display
= XtDisplay (menu
);
1539 dummy
.window
= XtWindow (XtParent (menu
));
1540 dummy
.time
= CurrentTime
;
1545 /* We activate directly the lucid implementation. */
1546 pop_up_menu (mw
, &dummy
);
1549 /* No need to check a second time since this is done in the XEvent loop.
1550 This slows done the execution. */
1552 /* Check again whether the mouse has moved to another menu bar item. */
1553 if (check_mouse_other_menu_bar (f
))
1555 /* The mouse moved into a different menu bar item.
1556 We should bring up that item's menu instead.
1557 First pop down this menu. */
1558 XtUngrabPointer ((Widget
)
1560 ((CompositeWidget
)menu
)->composite
.children
[0]),
1562 lw_destroy_all_widgets (menu_id
);
1567 /* Process events that apply to the menu. */
1572 XtAppNextEvent (Xt_app_con
, &event
);
1573 if (event
.type
== ButtonRelease
)
1575 XtDispatchEvent (&event
);
1578 /* Do the work of construct_mouse_click since it can't
1579 be called. Initially, the popup menu has been called
1580 from a ButtonPress in the edit_widget. Then the mouse
1581 has been set to grabbed. Reset it now. */
1582 x_mouse_grabbed
&= ~(1 << event
.xbutton
.button
);
1583 if (!x_mouse_grabbed
)
1584 Vmouse_depressed
= Qnil
;
1588 else if (event
.type
== Expose
)
1589 process_expose_from_menu (event
);
1590 else if (event
.type
== MotionNotify
)
1592 int event_x
= (event
.xmotion
.x_root
1593 - (f
->display
.x
->widget
->core
.x
1594 + f
->display
.x
->widget
->core
.border_width
));
1595 int event_y
= (event
.xmotion
.y_root
1596 - (f
->display
.x
->widget
->core
.y
1597 + f
->display
.x
->widget
->core
.border_width
));
1599 if (other_menu_bar_item_p (f
, event_x
, event_y
))
1601 /* The mouse moved into a different menu bar item.
1602 We should bring up that item's menu instead.
1603 First pop down this menu. */
1604 XtUngrabPointer ((Widget
)
1606 ((CompositeWidget
)menu
)->composite
.children
[0]),
1607 event
.xbutton
.time
);
1608 lw_destroy_all_widgets (menu_id
);
1610 /* Put back an event that will bring up the other item's menu. */
1611 unread_menu_bar_button (f
, event_x
);
1612 /* Don't let us select anything in this case. */
1613 menu_item_selection
= 0;
1618 XtDispatchEvent (&event
);
1619 if (XtWindowToWidget(XDISPLAY event
.xany
.window
) != menu
)
1622 = (struct event_queue
*) malloc (sizeof (struct event_queue
));
1624 if (queue_tmp
!= NULL
)
1626 queue_tmp
->event
= event
;
1627 queue_tmp
->next
= queue
;
1634 /* Unhighlight the menu bar item (if any) that led to this menu. */
1637 menubar_item
->call_data
= (XtPointer
) 0;
1638 dispatch_dummy_expose (f
->display
.x
->menubar_widget
, x
, y
);
1641 #if 0 /* No need to do that. The menu has disappeared. */
1642 /* Make sure the menu disappears. */
1643 lw_destroy_all_widgets (menu_id
);
1646 /* Unread any events that we got but did not handle. */
1647 while (queue
!= NULL
)
1650 XPutBackEvent (XDISPLAY
&queue_tmp
->event
);
1651 queue
= queue_tmp
->next
;
1652 free ((char *)queue_tmp
);
1655 /* Find the selected item, and its pane, to return
1656 the proper value. */
1657 if (menu_item_selection
!= 0)
1663 while (i
< menu_items_used
)
1667 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1669 subprefix_stack
[submenu_depth
++] = prefix
;
1673 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1675 prefix
= subprefix_stack
[--submenu_depth
];
1678 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1681 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1682 i
+= MENU_ITEMS_PANE_LENGTH
;
1687 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1688 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
1694 entry
= Fcons (entry
, Qnil
);
1696 entry
= Fcons (prefix
, entry
);
1697 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1698 entry
= Fcons (subprefix_stack
[j
], entry
);
1702 i
+= MENU_ITEMS_ITEM_LENGTH
;
1710 static char * button_names
[] = {
1711 "button1", "button2", "button3", "button4", "button5",
1712 "button6", "button7", "button8", "button9", "button10" };
1715 xdialog_show (f
, x
, y
, menubarp
, keymaps
, title
, error
)
1724 int i
, nb_buttons
=0;
1727 XlwMenuWidget menubar
= (XlwMenuWidget
) f
->display
.x
->menubar_widget
;
1729 /* This is the menu bar item (if any) that led to this menu. */
1730 widget_value
*menubar_item
= 0;
1732 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1734 /* Define a queue to save up for later unreading
1735 all X events that don't pertain to the menu. */
1739 struct event_queue
*next
;
1742 struct event_queue
*queue
= NULL
;
1743 struct event_queue
*queue_tmp
;
1747 /* Create a tree of widget_value objects
1748 representing the text label and buttons. */
1750 Lisp_Object pane_name
, prefix
;
1752 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
1753 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
1754 pane_string
= (NILP (pane_name
)
1755 ? "" : (char *) XSTRING (pane_name
)->data
);
1756 prev_wv
= malloc_widget_value ();
1757 prev_wv
->value
= pane_string
;
1758 if (keymaps
&& !NILP (prefix
))
1760 prev_wv
->enabled
= 1;
1761 prev_wv
->name
= "message";
1764 /* Loop over all panes and items, filling in the tree. */
1765 i
= MENU_ITEMS_PANE_LENGTH
;
1766 while (i
< menu_items_used
)
1769 /* Create a new item within current pane. */
1770 Lisp_Object item_name
, enable
, descrip
;
1771 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1772 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1774 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1776 wv
= malloc_widget_value ();
1778 wv
->name
= (char *) button_names
[nb_buttons
];
1779 if (!NILP (descrip
))
1780 wv
->key
= XSTRING (descrip
)->data
;
1781 wv
->value
= XSTRING (item_name
)->data
;
1782 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
1783 wv
->enabled
= !NILP (enable
);
1787 i
+= MENU_ITEMS_ITEM_LENGTH
;
1790 wv
= malloc_widget_value ();
1792 wv
->contents
= first_wv
;
1797 /* Actually create the dialog. */
1798 dialog_id
= ++popup_id_tick
;
1799 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1800 f
->display
.x
->widget
, 1, 0,
1801 dialog_selection_callback
, 0);
1802 lw_modify_all_widgets (dialog_id
, first_wv
, True
);
1803 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1804 /* Free the widget_value objects we used to specify the contents. */
1805 free_menubar_widget_value_tree (first_wv
);
1807 /* No selection has been chosen yet. */
1808 menu_item_selection
= 0;
1811 /* Display the menu. */
1812 lw_pop_up_all_widgets (dialog_id
);
1814 /* Process events that apply to the menu. */
1819 XtAppNextEvent (Xt_app_con
, &event
);
1820 if (event
.type
== ButtonRelease
)
1822 XtDispatchEvent (&event
);
1825 else if (event
.type
== Expose
)
1826 process_expose_from_menu (event
);
1827 XtDispatchEvent (&event
);
1828 if (XtWindowToWidget(XDISPLAY event
.xany
.window
) != menu
)
1830 queue_tmp
= (struct event_queue
*) malloc (sizeof (struct event_queue
));
1832 if (queue_tmp
!= NULL
)
1834 queue_tmp
->event
= event
;
1835 queue_tmp
->next
= queue
;
1842 /* Unread any events that we got but did not handle. */
1843 while (queue
!= NULL
)
1846 XPutBackEvent (XDISPLAY
&queue_tmp
->event
);
1847 queue
= queue_tmp
->next
;
1848 free ((char *)queue_tmp
);
1851 /* Find the selected item, and its pane, to return
1852 the proper value. */
1853 if (menu_item_selection
!= 0)
1859 while (i
< menu_items_used
)
1863 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1866 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1867 i
+= MENU_ITEMS_PANE_LENGTH
;
1872 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1873 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
1877 entry
= Fcons (entry
, Qnil
);
1879 entry
= Fcons (prefix
, entry
);
1883 i
+= MENU_ITEMS_ITEM_LENGTH
;
1890 #else /* not USE_X_TOOLKIT */
1893 xmenu_show (f
, x
, y
, menubarp
, keymaps
, title
, error
)
1903 int pane
, selidx
, lpane
, status
;
1904 Lisp_Object entry
, pane_prefix
;
1906 int ulx
, uly
, width
, height
;
1907 int dispwidth
, dispheight
;
1910 unsigned int dummy_uint
;
1913 if (menu_items_n_panes
== 0)
1916 /* Figure out which root window F is on. */
1917 XGetGeometry (x_current_display
, FRAME_X_WINDOW (f
), &root
,
1918 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
1919 &dummy_uint
, &dummy_uint
);
1921 /* Make the menu on that window. */
1922 menu
= XMenuCreate (XDISPLAY root
, "emacs");
1925 *error
= "Can't create menu";
1929 /* Adjust coordinates to relative to the outer (window manager) window. */
1933 int win_x
= 0, win_y
= 0;
1935 /* Find the position of the outside upper-left corner of
1936 the inner window, with respect to the outer window. */
1937 if (f
->display
.x
->parent_desc
!= ROOT_WINDOW
)
1940 XTranslateCoordinates (x_current_display
,
1942 /* From-window, to-window. */
1943 f
->display
.x
->window_desc
,
1944 f
->display
.x
->parent_desc
,
1946 /* From-position, to-position. */
1947 0, 0, &win_x
, &win_y
,
1949 /* Child of window. */
1956 #endif /* HAVE_X11 */
1958 /* Adjust coordinates to be root-window-relative. */
1959 x
+= f
->display
.x
->left_pos
;
1960 y
+= f
->display
.x
->top_pos
;
1962 /* Create all the necessary panes and their items. */
1964 while (i
< menu_items_used
)
1966 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1968 /* Create a new pane. */
1969 Lisp_Object pane_name
, prefix
;
1972 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1973 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1974 pane_string
= (NILP (pane_name
)
1975 ? "" : (char *) XSTRING (pane_name
)->data
);
1976 if (keymaps
&& !NILP (prefix
))
1979 lpane
= XMenuAddPane (XDISPLAY menu
, pane_string
, TRUE
);
1980 if (lpane
== XM_FAILURE
)
1982 XMenuDestroy (XDISPLAY menu
);
1983 *error
= "Can't create pane";
1986 i
+= MENU_ITEMS_PANE_LENGTH
;
1990 /* Create a new item within current pane. */
1991 Lisp_Object item_name
, enable
, descrip
;
1993 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1994 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1996 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1997 if (!NILP (descrip
))
1998 item_name
= concat2 (item_name
, descrip
);
2000 if (XMenuAddSelection (XDISPLAY menu
, lpane
, 0,
2001 XSTRING (item_name
)->data
,
2005 XMenuDestroy (XDISPLAY menu
);
2006 *error
= "Can't add selection to menu";
2009 i
+= MENU_ITEMS_ITEM_LENGTH
;
2013 /* All set and ready to fly. */
2014 XMenuRecompute (XDISPLAY menu
);
2015 dispwidth
= DisplayWidth (x_current_display
, XDefaultScreen (x_current_display
));
2016 dispheight
= DisplayHeight (x_current_display
, XDefaultScreen (x_current_display
));
2017 x
= min (x
, dispwidth
);
2018 y
= min (y
, dispheight
);
2021 XMenuLocate (XDISPLAY menu
, 0, 0, x
, y
,
2022 &ulx
, &uly
, &width
, &height
);
2023 if (ulx
+width
> dispwidth
)
2025 x
-= (ulx
+ width
) - dispwidth
;
2026 ulx
= dispwidth
- width
;
2028 if (uly
+height
> dispheight
)
2030 y
-= (uly
+ height
) - dispheight
;
2031 uly
= dispheight
- height
;
2033 if (ulx
< 0) x
-= ulx
;
2034 if (uly
< 0) y
-= uly
;
2036 XMenuSetFreeze (menu
, TRUE
);
2039 status
= XMenuActivate (XDISPLAY menu
, &pane
, &selidx
,
2040 x
, y
, ButtonReleaseMask
, &datap
);
2045 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2048 /* Find the item number SELIDX in pane number PANE. */
2050 while (i
< menu_items_used
)
2052 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2056 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2058 i
+= MENU_ITEMS_PANE_LENGTH
;
2067 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2070 entry
= Fcons (entry
, Qnil
);
2071 if (!NILP (pane_prefix
))
2072 entry
= Fcons (pane_prefix
, entry
);
2078 i
+= MENU_ITEMS_ITEM_LENGTH
;
2084 XMenuDestroy (XDISPLAY menu
);
2085 *error
= "Can't activate menu";
2091 XMenuDestroy (XDISPLAY menu
);
2094 #endif /* not USE_X_TOOLKIT */
2098 staticpro (&menu_items
);
2101 popup_id_tick
= (1<<16);
2102 defsubr (&Sx_popup_menu
);
2103 #ifdef USE_X_TOOLKIT
2104 defsubr (&Sx_popup_dialog
);