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
);
831 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 1, 2, 0,
832 "Pop up a dialog box and return user's selection.\n\
833 POSITION is a position specification. This is either a mouse button event\n\
834 or a list ((XOFFSET YOFFSET) WINDOW)\n\
835 where XOFFSET and YOFFSET are positions in characters from the top left\n\
836 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
837 This controls the position of the center of the first line\n\
838 in the first pane of the menu, not the top left of the menu as a whole.\n\
839 If POSITION is t, it means to use the current mouse position.\n\
841 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
842 The menu items come from key bindings that have a menu string as well as\n\
843 a definition; actually, the \"definition\" in such a key binding looks like\n\
844 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
845 the keymap as a top-level element.\n\n\
846 You can also use a list of keymaps as MENU.\n\
847 Then each keymap makes a separate pane.\n\
848 When MENU is a keymap or a list of keymaps, the return value\n\
849 is a list of events.\n\n\
850 Alternatively, you can specify a menu of multiple panes\n\
851 with a list of the form (TITLE PANE1 PANE2...),\n\
852 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
853 Each ITEM is normally a cons cell (STRING . VALUE);\n\
854 but a string can appear as an item--that makes a nonselectable line\n\
856 With this form of menu, the return value is VALUE from the chosen item.\n\
858 If POSITION is nil, don't display the menu at all, just precalculate the\n\
859 cached information about equivalent key sequences.")
861 Lisp_Object position
, menu
;
863 int number_of_panes
, panes
;
864 Lisp_Object keymap
, tem
;
868 Lisp_Object selection
;
871 Lisp_Object x
, y
, window
;
878 if (! NILP (position
))
880 /* Decode the first argument: find the window and the coordinates. */
881 if (EQ (position
, Qt
))
883 /* Use the mouse's current position. */
885 Lisp_Object bar_window
;
889 (*mouse_position_hook
) (&new_f
, &bar_window
, &part
, &x
, &y
, &time
);
890 XSET (window
, Lisp_Frame
, new_f
);
896 /* Decode where to put the menu. */
898 if (XTYPE (window
) == Lisp_Frame
)
905 else if (XTYPE (window
) == Lisp_Window
)
907 CHECK_LIVE_WINDOW (window
, 0);
908 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
910 xpos
= (FONT_WIDTH (f
->display
.x
->font
) * XWINDOW (window
)->left
);
911 ypos
= (FONT_HEIGHT (f
->display
.x
->font
) * XWINDOW (window
)->top
);
914 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
915 but I don't want to make one now. */
916 CHECK_WINDOW (window
, 0);
925 /* Decode the dialog items from what was specified. */
927 /* We were given an old-fashioned menu. */
929 CHECK_STRING (title
, 1);
931 list_of_panes (Fcdr (menu
));
938 discard_menu_items ();
943 /* Display them in a dialog box. */
946 selection
= xdialog_show (f
, xpos
, ypos
, menubarp
,
947 keymaps
, title
, &error_name
);
950 discard_menu_items ();
954 if (error_name
) error (error_name
);
961 dispatch_dummy_expose (w
, x
, y
)
969 dummy
.window
= XtWindow (w
);
972 dummy
.send_event
= 0;
973 dummy
.display
= XtDisplay (w
);
977 XtDispatchEvent (&dummy
);
988 XTextExtents (mw
->menu
.font
, s
, strlen (s
), &drop
, &drop
, &drop
, &xcs
);
993 event_is_in_menu_item (mw
, event
, name
, string_w
)
995 struct input_event
*event
;
999 *string_w
+= (string_width (mw
, name
)
1000 + 2 * (mw
->menu
.horizontal_spacing
1001 + mw
->menu
.shadow_thickness
));
1002 return XINT (event
->x
) < *string_w
;
1006 /* Return the menu bar key which corresponds to event EVENT in frame F. */
1009 map_event_to_object (event
, f
)
1010 struct input_event
*event
;
1015 XlwMenuWidget mw
= (XlwMenuWidget
) f
->display
.x
->menubar_widget
;
1020 /* Find the window */
1021 for (val
= mw
->menu
.old_stack
[0]->contents
; val
; val
= val
->next
)
1023 ws
= &mw
->menu
.windows
[0];
1024 if (ws
&& event_is_in_menu_item (mw
, event
, val
->name
, &string_w
))
1029 items
= FRAME_MENU_BAR_ITEMS (f
);
1031 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 3)
1033 Lisp_Object pos
, string
, item
;
1034 item
= XVECTOR (items
)->contents
[i
];
1035 string
= XVECTOR (items
)->contents
[i
+ 1];
1036 pos
= XVECTOR (items
)->contents
[i
+ 2];
1040 if (!strcmp (val
->name
, XSTRING (string
)->data
))
1048 static Lisp_Object
*menu_item_selection
;
1051 popup_selection_callback (widget
, id
, client_data
)
1054 XtPointer client_data
;
1056 menu_item_selection
= (Lisp_Object
*) client_data
;
1060 popup_down_callback (widget
, id
, client_data
)
1063 XtPointer client_data
;
1066 lw_destroy_all_widgets (id
);
1071 dialog_selection_callback (widget
, id
, client_data
)
1074 XtPointer client_data
;
1076 if ((int)client_data
!= -1)
1077 menu_item_selection
= (Lisp_Object
*) client_data
;
1079 lw_destroy_all_widgets (id
);
1083 /* This recursively calls free_widget_value() on the tree of widgets.
1084 It must free all data that was malloc'ed for these widget_values.
1085 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1086 must be left alone. */
1089 free_menubar_widget_value_tree (wv
)
1094 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1096 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1098 free_menubar_widget_value_tree (wv
->contents
);
1099 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1103 free_menubar_widget_value_tree (wv
->next
);
1104 wv
->next
= (widget_value
*) 0xDEADBEEF;
1107 free_widget_value (wv
);
1111 extern void EmacsFrameSetCharSize ();
1114 update_one_frame_psheets (f
)
1117 struct x_display
*x
= f
->display
.x
;
1119 int menubar_changed
;
1121 menubar_changed
= (x
->menubar_widget
1122 && !XtIsManaged (x
->menubar_widget
));
1124 if (! (menubar_changed
))
1128 /* Save the size of the frame because the pane widget doesn't accept to
1129 resize itself. So force it. */
1134 XawPanedSetRefigureMode (x
->column_widget
, 0);
1136 /* the order in which children are managed is the top to
1137 bottom order in which they are displayed in the paned window.
1138 First, remove the text-area widget.
1140 XtUnmanageChild (x
->edit_widget
);
1142 /* remove the menubar that is there now, and put up the menubar that
1145 if (menubar_changed
)
1147 XtManageChild (x
->menubar_widget
);
1148 XtMapWidget (x
->menubar_widget
);
1149 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, 0);
1153 /* Re-manage the text-area widget */
1154 XtManageChild (x
->edit_widget
);
1156 /* and now thrash the sizes */
1157 XawPanedSetRefigureMode (x
->column_widget
, 1);
1159 /* Force the pane widget to resize itself with the right values. */
1160 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1166 set_frame_menubar (f
)
1169 Widget menubar_widget
= f
->display
.x
->menubar_widget
;
1171 Lisp_Object tail
, items
;
1172 widget_value
*wv
, *save_wv
, *first_wv
, *prev_wv
= 0;
1177 wv
= malloc_widget_value ();
1178 wv
->name
= "menubar";
1181 save_wv
= first_wv
= wv
;
1183 items
= FRAME_MENU_BAR_ITEMS (f
);
1185 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 3)
1189 string
= XVECTOR (items
)->contents
[i
+ 1];
1193 wv
= malloc_widget_value ();
1197 save_wv
->contents
= wv
;
1198 wv
->name
= XSTRING (string
)->data
;
1205 lw_modify_all_widgets (id
, first_wv
, False
);
1208 menubar_widget
= lw_create_widget ("menubar", "menubar",
1210 f
->display
.x
->column_widget
,
1213 f
->display
.x
->menubar_widget
= menubar_widget
;
1214 XtVaSetValues (menubar_widget
,
1216 XtNresizeToPreferred
, 1,
1221 free_menubar_widget_value_tree (first_wv
);
1223 update_one_frame_psheets (f
);
1229 free_frame_menubar (f
)
1232 Widget menubar_widget
;
1235 menubar_widget
= f
->display
.x
->menubar_widget
;
1241 lw_destroy_all_widgets (id
);
1246 /* Nonzero if position X, Y relative to inside of frame F
1247 is in some other menu bar item. */
1249 static int this_menu_bar_item_beg
;
1250 static int this_menu_bar_item_end
;
1253 other_menu_bar_item_p (f
, x
, y
)
1258 && y
< f
->display
.x
->menubar_widget
->core
.height
1260 && x
< f
->display
.x
->menubar_widget
->core
.width
1261 && (x
>= this_menu_bar_item_end
1262 || x
< this_menu_bar_item_beg
));
1265 /* Unread a button-press event in the menu bar of frame F
1266 at x position XPOS relative to the inside of the frame. */
1269 unread_menu_bar_button (f
, xpos
)
1275 event
.type
= ButtonPress
;
1276 event
.xbutton
.display
= x_current_display
;
1277 event
.xbutton
.serial
= 0;
1278 event
.xbutton
.send_event
= 0;
1279 event
.xbutton
.time
= CurrentTime
;
1280 event
.xbutton
.button
= Button1
;
1281 event
.xbutton
.window
= XtWindow (f
->display
.x
->menubar_widget
);
1282 event
.xbutton
.x
= xpos
;
1283 XPutBackEvent (XDISPLAY
&event
);
1286 /* If the mouse has moved to another menu bar item,
1287 return 1 and unread a button press event for that item.
1288 Otherwise return 0. */
1291 check_mouse_other_menu_bar (f
)
1295 Lisp_Object bar_window
;
1300 (*mouse_position_hook
) (&new_f
, &bar_window
, &part
, &x
, &y
, &time
);
1302 if (f
== new_f
&& other_menu_bar_item_p (f
, x
, y
))
1304 unread_menu_bar_button (f
, x
);
1310 #endif /* USE_X_TOOLKIT */
1312 /* xmenu_show actually displays a menu using the panes and items in menu_items
1313 and returns the value selected from it.
1314 There are two versions of xmenu_show, one for Xt and one for Xlib.
1315 Both assume input is blocked by the caller. */
1317 /* F is the frame the menu is for.
1318 X and Y are the frame-relative specified position,
1319 relative to the inside upper left corner of the frame F.
1320 MENUBARP is 1 if the click that asked for this menu came from the menu bar.
1321 KEYMAPS is 1 if this menu was specified with keymaps;
1322 in that case, we return a list containing the chosen item's value
1323 and perhaps also the pane's prefix.
1324 TITLE is the specified menu title.
1325 ERROR is a place to store an error message string in case of failure.
1326 (We return nil on failure, but the value doesn't actually matter.) */
1328 #ifdef USE_X_TOOLKIT
1330 extern unsigned int x_mouse_grabbed
;
1331 extern Lisp_Object Vmouse_depressed
;
1334 xmenu_show (f
, x
, y
, menubarp
, keymaps
, title
, error
)
1346 XlwMenuWidget menubar
= (XlwMenuWidget
) f
->display
.x
->menubar_widget
;
1348 /* This is the menu bar item (if any) that led to this menu. */
1349 widget_value
*menubar_item
= 0;
1351 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1352 widget_value
**submenu_stack
1353 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1354 Lisp_Object
*subprefix_stack
1355 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1356 int submenu_depth
= 0;
1358 /* Define a queue to save up for later unreading
1359 all X events that don't pertain to the menu. */
1363 struct event_queue
*next
;
1366 struct event_queue
*queue
= NULL
;
1367 struct event_queue
*queue_tmp
;
1371 this_menu_bar_item_beg
= -1;
1372 this_menu_bar_item_end
= -1;
1374 /* Figure out which menu bar item, if any, this menu is for. */
1380 for (menubar_item
= menubar
->menu
.old_stack
[0]->contents
;
1382 menubar_item
= menubar_item
->next
)
1385 xend
+= (string_width (menubar
, menubar_item
->name
)
1386 + 2 * (menubar
->menu
.horizontal_spacing
1387 + menubar
->menu
.shadow_thickness
));
1392 /* Arrange to show a different menu if we move in the menu bar
1393 to a different item. */
1394 this_menu_bar_item_beg
= xbeg
;
1395 this_menu_bar_item_end
= xend
;
1400 if (menubar_item
== 0)
1403 /* Offset the coordinates to root-relative. */
1404 x
+= (f
->display
.x
->widget
->core
.x
1405 + f
->display
.x
->widget
->core
.border_width
);
1406 y
+= (f
->display
.x
->widget
->core
.y
1407 + f
->display
.x
->widget
->core
.border_width
1408 + f
->display
.x
->menubar_widget
->core
.height
);
1410 /* Create a tree of widget_value objects
1411 representing the panes and their items. */
1412 wv
= malloc_widget_value ();
1418 /* Loop over all panes and items, filling in the tree. */
1420 while (i
< menu_items_used
)
1422 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1424 submenu_stack
[submenu_depth
++] = save_wv
;
1429 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1432 save_wv
= submenu_stack
[--submenu_depth
];
1435 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1436 && submenu_depth
!= 0)
1437 i
+= MENU_ITEMS_PANE_LENGTH
;
1438 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1440 /* Create a new pane. */
1441 Lisp_Object pane_name
, prefix
;
1443 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1444 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1445 pane_string
= (NILP (pane_name
)
1446 ? "" : (char *) XSTRING (pane_name
)->data
);
1447 /* If there is just one top-level pane, put all its items directly
1448 under the top-level menu. */
1449 if (menu_items_n_panes
== 1)
1452 /* If the pane has a meaningful name,
1453 make the pane a top-level menu item
1454 with its items as a submenu beneath it. */
1455 if (strcmp (pane_string
, ""))
1457 wv
= malloc_widget_value ();
1461 first_wv
->contents
= wv
;
1462 wv
->name
= pane_string
;
1463 if (keymaps
&& !NILP (prefix
))
1470 i
+= MENU_ITEMS_PANE_LENGTH
;
1474 /* Create a new item within current pane. */
1475 Lisp_Object item_name
, enable
, descrip
;
1476 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1477 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1479 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1481 wv
= malloc_widget_value ();
1485 save_wv
->contents
= wv
;
1486 wv
->name
= XSTRING (item_name
)->data
;
1487 if (!NILP (descrip
))
1488 wv
->key
= XSTRING (descrip
)->data
;
1490 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
1491 wv
->enabled
= !NILP (enable
);
1494 i
+= MENU_ITEMS_ITEM_LENGTH
;
1498 /* Actually create the menu. */
1499 menu_id
= ++popup_id_tick
;
1500 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1501 f
->display
.x
->widget
, 1, 0,
1502 popup_selection_callback
, popup_down_callback
);
1503 /* Free the widget_value objects we used to specify the contents. */
1504 free_menubar_widget_value_tree (first_wv
);
1506 /* No selection has been chosen yet. */
1507 menu_item_selection
= 0;
1509 /* If the mouse moves out of the menu before we show the menu,
1510 don't show it at all. */
1511 if (check_mouse_other_menu_bar (f
))
1513 lw_destroy_all_widgets (menu_id
);
1518 /* Highlight the menu bar item (if any) that led to this menu. */
1521 menubar_item
->call_data
= (XtPointer
) 1;
1522 dispatch_dummy_expose (f
->display
.x
->menubar_widget
, x
, y
);
1525 /* Display the menu. */
1527 XButtonPressedEvent dummy
;
1530 mw
= (XlwMenuWidget
) ((CompositeWidget
)menu
)->composite
.children
[0];
1532 dummy
.type
= ButtonPress
;
1534 dummy
.send_event
= 0;
1535 dummy
.display
= XtDisplay (menu
);
1536 dummy
.window
= XtWindow (XtParent (menu
));
1537 dummy
.time
= CurrentTime
;
1542 /* We activate directly the lucid implementation. */
1543 pop_up_menu (mw
, &dummy
);
1546 /* No need to check a second time since this is done in the XEvent loop.
1547 This slows done the execution. */
1549 /* Check again whether the mouse has moved to another menu bar item. */
1550 if (check_mouse_other_menu_bar (f
))
1552 /* The mouse moved into a different menu bar item.
1553 We should bring up that item's menu instead.
1554 First pop down this menu. */
1555 XtUngrabPointer ((Widget
)
1557 ((CompositeWidget
)menu
)->composite
.children
[0]),
1559 lw_destroy_all_widgets (menu_id
);
1564 /* Process events that apply to the menu. */
1569 XtAppNextEvent (Xt_app_con
, &event
);
1570 if (event
.type
== ButtonRelease
)
1572 XtDispatchEvent (&event
);
1575 /* Do the work of construct_mouse_click since it can't
1576 be called. Initially, the popup menu has been called
1577 from a ButtonPress in the edit_widget. Then the mouse
1578 has been set to grabbed. Reset it now. */
1579 x_mouse_grabbed
&= ~(1 << event
.xbutton
.button
);
1580 if (!x_mouse_grabbed
)
1581 Vmouse_depressed
= Qnil
;
1585 else if (event
.type
== Expose
)
1586 process_expose_from_menu (event
);
1587 else if (event
.type
== MotionNotify
)
1589 int event_x
= (event
.xmotion
.x_root
1590 - (f
->display
.x
->widget
->core
.x
1591 + f
->display
.x
->widget
->core
.border_width
));
1592 int event_y
= (event
.xmotion
.y_root
1593 - (f
->display
.x
->widget
->core
.y
1594 + f
->display
.x
->widget
->core
.border_width
));
1596 if (other_menu_bar_item_p (f
, event_x
, event_y
))
1598 /* The mouse moved into a different menu bar item.
1599 We should bring up that item's menu instead.
1600 First pop down this menu. */
1601 XtUngrabPointer ((Widget
)
1603 ((CompositeWidget
)menu
)->composite
.children
[0]),
1604 event
.xbutton
.time
);
1605 lw_destroy_all_widgets (menu_id
);
1607 /* Put back an event that will bring up the other item's menu. */
1608 unread_menu_bar_button (f
, event_x
);
1609 /* Don't let us select anything in this case. */
1610 menu_item_selection
= 0;
1615 XtDispatchEvent (&event
);
1616 if (XtWindowToWidget(XDISPLAY event
.xany
.window
) != menu
)
1619 = (struct event_queue
*) malloc (sizeof (struct event_queue
));
1621 if (queue_tmp
!= NULL
)
1623 queue_tmp
->event
= event
;
1624 queue_tmp
->next
= queue
;
1631 /* Unhighlight the menu bar item (if any) that led to this menu. */
1634 menubar_item
->call_data
= (XtPointer
) 0;
1635 dispatch_dummy_expose (f
->display
.x
->menubar_widget
, x
, y
);
1638 #if 0 /* No need to do that. The menu has disappeared. */
1639 /* Make sure the menu disappears. */
1640 lw_destroy_all_widgets (menu_id
);
1643 /* Unread any events that we got but did not handle. */
1644 while (queue
!= NULL
)
1647 XPutBackEvent (XDISPLAY
&queue_tmp
->event
);
1648 queue
= queue_tmp
->next
;
1649 free ((char *)queue_tmp
);
1652 /* Find the selected item, and its pane, to return
1653 the proper value. */
1654 if (menu_item_selection
!= 0)
1660 while (i
< menu_items_used
)
1664 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1666 subprefix_stack
[submenu_depth
++] = prefix
;
1670 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1672 prefix
= subprefix_stack
[--submenu_depth
];
1675 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1678 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1679 i
+= MENU_ITEMS_PANE_LENGTH
;
1684 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1685 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
1691 entry
= Fcons (entry
, Qnil
);
1693 entry
= Fcons (prefix
, entry
);
1694 for (j
= submenu_depth
- 1; j
>= 0; j
--)
1695 entry
= Fcons (subprefix_stack
[j
], entry
);
1699 i
+= MENU_ITEMS_ITEM_LENGTH
;
1707 static char * button_names
[] = {
1708 "button1", "button2", "button3", "button4", "button5",
1709 "button6", "button7", "button8", "button9", "button10" };
1712 xdialog_show (f
, x
, y
, menubarp
, keymaps
, title
, error
)
1721 int i
, nb_buttons
=0;
1724 XlwMenuWidget menubar
= (XlwMenuWidget
) f
->display
.x
->menubar_widget
;
1726 /* This is the menu bar item (if any) that led to this menu. */
1727 widget_value
*menubar_item
= 0;
1729 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1731 /* Define a queue to save up for later unreading
1732 all X events that don't pertain to the menu. */
1736 struct event_queue
*next
;
1739 struct event_queue
*queue
= NULL
;
1740 struct event_queue
*queue_tmp
;
1744 /* Create a tree of widget_value objects
1745 representing the text label and buttons. */
1747 Lisp_Object pane_name
, prefix
;
1749 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
1750 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
1751 pane_string
= (NILP (pane_name
)
1752 ? "" : (char *) XSTRING (pane_name
)->data
);
1753 prev_wv
= malloc_widget_value ();
1754 prev_wv
->value
= pane_string
;
1755 if (keymaps
&& !NILP (prefix
))
1757 prev_wv
->enabled
= 1;
1758 prev_wv
->name
= "message";
1761 /* Loop over all panes and items, filling in the tree. */
1762 i
= MENU_ITEMS_PANE_LENGTH
;
1763 while (i
< menu_items_used
)
1766 /* Create a new item within current pane. */
1767 Lisp_Object item_name
, enable
, descrip
;
1768 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1769 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1771 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1773 wv
= malloc_widget_value ();
1775 wv
->name
= (char *) button_names
[nb_buttons
];
1776 if (!NILP (descrip
))
1777 wv
->key
= XSTRING (descrip
)->data
;
1778 wv
->value
= XSTRING (item_name
)->data
;
1779 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
1780 wv
->enabled
= !NILP (enable
);
1784 i
+= MENU_ITEMS_ITEM_LENGTH
;
1787 wv
= malloc_widget_value ();
1789 wv
->contents
= first_wv
;
1794 /* Actually create the dialog. */
1795 dialog_id
= ++popup_id_tick
;
1796 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
1797 f
->display
.x
->widget
, 1, 0,
1798 dialog_selection_callback
, 0);
1799 lw_modify_all_widgets (dialog_id
, first_wv
, True
);
1800 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
1801 /* Free the widget_value objects we used to specify the contents. */
1802 free_menubar_widget_value_tree (first_wv
);
1804 /* No selection has been chosen yet. */
1805 menu_item_selection
= 0;
1808 /* Display the menu. */
1809 lw_pop_up_all_widgets (dialog_id
);
1811 /* Process events that apply to the menu. */
1816 XtAppNextEvent (Xt_app_con
, &event
);
1817 if (event
.type
== ButtonRelease
)
1819 XtDispatchEvent (&event
);
1822 else if (event
.type
== Expose
)
1823 process_expose_from_menu (event
);
1824 XtDispatchEvent (&event
);
1825 if (XtWindowToWidget(XDISPLAY event
.xany
.window
) != menu
)
1827 queue_tmp
= (struct event_queue
*) malloc (sizeof (struct event_queue
));
1829 if (queue_tmp
!= NULL
)
1831 queue_tmp
->event
= event
;
1832 queue_tmp
->next
= queue
;
1839 /* Unread any events that we got but did not handle. */
1840 while (queue
!= NULL
)
1843 XPutBackEvent (XDISPLAY
&queue_tmp
->event
);
1844 queue
= queue_tmp
->next
;
1845 free ((char *)queue_tmp
);
1848 /* Find the selected item, and its pane, to return
1849 the proper value. */
1850 if (menu_item_selection
!= 0)
1856 while (i
< menu_items_used
)
1860 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1863 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1864 i
+= MENU_ITEMS_PANE_LENGTH
;
1869 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1870 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
1874 entry
= Fcons (entry
, Qnil
);
1876 entry
= Fcons (prefix
, entry
);
1880 i
+= MENU_ITEMS_ITEM_LENGTH
;
1887 #else /* not USE_X_TOOLKIT */
1890 xmenu_show (f
, x
, y
, menubarp
, keymaps
, title
, error
)
1900 int pane
, selidx
, lpane
, status
;
1901 Lisp_Object entry
, pane_prefix
;
1903 int ulx
, uly
, width
, height
;
1904 int dispwidth
, dispheight
;
1907 unsigned int dummy_uint
;
1910 if (menu_items_n_panes
== 0)
1913 /* Figure out which root window F is on. */
1914 XGetGeometry (x_current_display
, FRAME_X_WINDOW (f
), &root
,
1915 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
1916 &dummy_uint
, &dummy_uint
);
1918 /* Make the menu on that window. */
1919 menu
= XMenuCreate (XDISPLAY root
, "emacs");
1922 *error
= "Can't create menu";
1926 /* Adjust coordinates to relative to the outer (window manager) window. */
1930 int win_x
= 0, win_y
= 0;
1932 /* Find the position of the outside upper-left corner of
1933 the inner window, with respect to the outer window. */
1934 if (f
->display
.x
->parent_desc
!= ROOT_WINDOW
)
1937 XTranslateCoordinates (x_current_display
,
1939 /* From-window, to-window. */
1940 f
->display
.x
->window_desc
,
1941 f
->display
.x
->parent_desc
,
1943 /* From-position, to-position. */
1944 0, 0, &win_x
, &win_y
,
1946 /* Child of window. */
1953 #endif /* HAVE_X11 */
1955 /* Adjust coordinates to be root-window-relative. */
1956 x
+= f
->display
.x
->left_pos
;
1957 y
+= f
->display
.x
->top_pos
;
1959 /* Create all the necessary panes and their items. */
1961 while (i
< menu_items_used
)
1963 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1965 /* Create a new pane. */
1966 Lisp_Object pane_name
, prefix
;
1969 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1970 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1971 pane_string
= (NILP (pane_name
)
1972 ? "" : (char *) XSTRING (pane_name
)->data
);
1973 if (keymaps
&& !NILP (prefix
))
1976 lpane
= XMenuAddPane (XDISPLAY menu
, pane_string
, TRUE
);
1977 if (lpane
== XM_FAILURE
)
1979 XMenuDestroy (XDISPLAY menu
);
1980 *error
= "Can't create pane";
1983 i
+= MENU_ITEMS_PANE_LENGTH
;
1987 /* Create a new item within current pane. */
1988 Lisp_Object item_name
, enable
, descrip
;
1990 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1991 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1993 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1994 if (!NILP (descrip
))
1995 item_name
= concat2 (item_name
, descrip
);
1997 if (XMenuAddSelection (XDISPLAY menu
, lpane
, 0,
1998 XSTRING (item_name
)->data
,
2002 XMenuDestroy (XDISPLAY menu
);
2003 *error
= "Can't add selection to menu";
2006 i
+= MENU_ITEMS_ITEM_LENGTH
;
2010 /* All set and ready to fly. */
2011 XMenuRecompute (XDISPLAY menu
);
2012 dispwidth
= DisplayWidth (x_current_display
, XDefaultScreen (x_current_display
));
2013 dispheight
= DisplayHeight (x_current_display
, XDefaultScreen (x_current_display
));
2014 x
= min (x
, dispwidth
);
2015 y
= min (y
, dispheight
);
2018 XMenuLocate (XDISPLAY menu
, 0, 0, x
, y
,
2019 &ulx
, &uly
, &width
, &height
);
2020 if (ulx
+width
> dispwidth
)
2022 x
-= (ulx
+ width
) - dispwidth
;
2023 ulx
= dispwidth
- width
;
2025 if (uly
+height
> dispheight
)
2027 y
-= (uly
+ height
) - dispheight
;
2028 uly
= dispheight
- height
;
2030 if (ulx
< 0) x
-= ulx
;
2031 if (uly
< 0) y
-= uly
;
2033 XMenuSetFreeze (menu
, TRUE
);
2036 status
= XMenuActivate (XDISPLAY menu
, &pane
, &selidx
,
2037 x
, y
, ButtonReleaseMask
, &datap
);
2042 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2045 /* Find the item number SELIDX in pane number PANE. */
2047 while (i
< menu_items_used
)
2049 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2053 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2055 i
+= MENU_ITEMS_PANE_LENGTH
;
2064 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2067 entry
= Fcons (entry
, Qnil
);
2068 if (!NILP (pane_prefix
))
2069 entry
= Fcons (pane_prefix
, entry
);
2075 i
+= MENU_ITEMS_ITEM_LENGTH
;
2081 XMenuDestroy (XDISPLAY menu
);
2082 *error
= "Can't activate menu";
2088 XMenuDestroy (XDISPLAY menu
);
2091 #endif /* not USE_X_TOOLKIT */
2095 staticpro (&menu_items
);
2098 popup_id_tick
= (1<<16);
2099 defsubr (&Sx_popup_menu
);
2100 defsubr (&Sx_popup_dialog
);