1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1986, 1988, 1993, 1994, 1996 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* X pop-up deck-of-cards menu facility for gnuemacs.
23 * Written by Jon Arnold and Roman Budzianowski
24 * Mods and rewrite by Robert Krawitz
28 /* Modified by Fred Pierresteguy on December 93
29 to make the popup menus and menubar use the Xt. */
31 /* Rewritten for clarity and GC protection by rms in Feb 94. */
33 /* On 4.3 this loses if it comes after xterm.h. */
39 #include "termhooks.h"
43 #include "blockinput.h"
51 /* This may include sys/types.h, and that somehow loses
52 if this is not done before the other system files. */
56 /* Load sys/types.h if not already loaded.
57 In some systems loading it twice is suicidal. */
59 #include <sys/types.h>
62 #include "dispextern.h"
67 #include <X11/IntrinsicP.h>
68 #include <X11/CoreP.h>
69 #include <X11/StringDefs.h>
70 #include <X11/Shell.h>
72 #include <X11/Xaw/Paned.h>
73 #endif /* USE_LUCID */
74 #include "../lwlib/lwlib.h"
75 #else /* not USE_X_TOOLKIT */
76 #include "../oldXMenu/XMenu.h"
77 #endif /* not USE_X_TOOLKIT */
78 #endif /* HAVE_X_WINDOWS */
80 #define min(x,y) (((x) < (y)) ? (x) : (y))
81 #define max(x,y) (((x) > (y)) ? (x) : (y))
88 Lisp_Object Vmenu_updating_frame
;
90 Lisp_Object Qdebug_on_next_call
;
92 extern Lisp_Object Qmenu_bar
;
93 extern Lisp_Object Qmouse_click
, Qevent_kind
;
95 extern Lisp_Object QCtoggle
, QCradio
;
97 extern Lisp_Object Voverriding_local_map
;
98 extern Lisp_Object Voverriding_local_map_menu_flag
;
100 extern Lisp_Object Qoverriding_local_map
, Qoverriding_terminal_local_map
;
102 extern Lisp_Object Qmenu_bar_update_hook
;
105 extern void set_frame_menubar ();
106 extern void process_expose_from_menu ();
107 extern XtAppContext Xt_app_con
;
109 static Lisp_Object
xdialog_show ();
110 void popup_get_selection ();
113 static Lisp_Object
xmenu_show ();
114 static void keymap_panes ();
115 static void single_keymap_panes ();
116 static void single_menu_item ();
117 static void list_of_panes ();
118 static void list_of_items ();
120 /* This holds a Lisp vector that holds the results of decoding
121 the keymaps or alist-of-alists that specify a menu.
123 It describes the panes and items within the panes.
125 Each pane is described by 3 elements in the vector:
126 t, the pane name, the pane's prefix key.
127 Then follow the pane's items, with 5 elements per item:
128 the item string, the enable flag, the item's value,
129 the definition, and the equivalent keyboard key's description string.
131 In some cases, multiple levels of menus may be described.
132 A single vector slot containing nil indicates the start of a submenu.
133 A single vector slot containing lambda indicates the end of a submenu.
134 The submenu follows a menu item which is the way to reach the submenu.
136 A single vector slot containing quote indicates that the
137 following items should appear on the right of a dialog box.
139 Using a Lisp vector to hold this information while we decode it
140 takes care of protecting all the data from GC. */
142 #define MENU_ITEMS_PANE_NAME 1
143 #define MENU_ITEMS_PANE_PREFIX 2
144 #define MENU_ITEMS_PANE_LENGTH 3
146 #define MENU_ITEMS_ITEM_NAME 0
147 #define MENU_ITEMS_ITEM_ENABLE 1
148 #define MENU_ITEMS_ITEM_VALUE 2
149 #define MENU_ITEMS_ITEM_EQUIV_KEY 3
150 #define MENU_ITEMS_ITEM_DEFINITION 4
151 #define MENU_ITEMS_ITEM_LENGTH 5
153 static Lisp_Object menu_items
;
155 /* Number of slots currently allocated in menu_items. */
156 static int menu_items_allocated
;
158 /* This is the index in menu_items of the first empty slot. */
159 static int menu_items_used
;
161 /* The number of panes currently recorded in menu_items,
162 excluding those within submenus. */
163 static int menu_items_n_panes
;
165 /* Current depth within submenus. */
166 static int menu_items_submenu_depth
;
168 /* Flag which when set indicates a dialog or menu has been posted by
169 Xt on behalf of one of the widget sets. */
170 static int popup_activated_flag
;
172 static int next_menubar_widget_id
;
174 /* This is set nonzero after the user activates the menu bar, and set
175 to zero again after the menu bars are redisplayed by prepare_menu_bar.
176 While it is nonzero, all calls to set_frame_menubar go deep.
178 I don't understand why this is needed, but it does seem to be
179 needed on Motif, according to Marcus Daniels <marcus@sysc.pdx.edu>. */
181 int pending_menu_activation
;
185 /* Return the frame whose ->output_data.x->id equals ID, or 0 if none. */
187 static struct frame
*
188 menubar_id_to_frame (id
)
191 Lisp_Object tail
, frame
;
194 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCONS (tail
)->cdr
)
196 frame
= XCONS (tail
)->car
;
197 if (!GC_FRAMEP (frame
))
200 if (f
->output_data
.nothing
== 1)
202 if (f
->output_data
.x
->id
== id
)
210 /* Initialize the menu_items structure if we haven't already done so.
211 Also mark it as currently empty. */
216 if (NILP (menu_items
))
218 menu_items_allocated
= 60;
219 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
223 menu_items_n_panes
= 0;
224 menu_items_submenu_depth
= 0;
227 /* Call at the end of generating the data in menu_items.
228 This fills in the number of items in the last pane. */
235 /* Call when finished using the data for the current menu
239 discard_menu_items ()
241 /* Free the structure if it is especially large.
242 Otherwise, hold on to it, to save time. */
243 if (menu_items_allocated
> 200)
246 menu_items_allocated
= 0;
250 /* Make the menu_items vector twice as large. */
256 int old_size
= menu_items_allocated
;
259 menu_items_allocated
*= 2;
260 menu_items
= Fmake_vector (make_number (menu_items_allocated
), Qnil
);
261 bcopy (XVECTOR (old
)->contents
, XVECTOR (menu_items
)->contents
,
262 old_size
* sizeof (Lisp_Object
));
265 /* Begin a submenu. */
268 push_submenu_start ()
270 if (menu_items_used
+ 1 > menu_items_allocated
)
273 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qnil
;
274 menu_items_submenu_depth
++;
282 if (menu_items_used
+ 1 > menu_items_allocated
)
285 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qlambda
;
286 menu_items_submenu_depth
--;
289 /* Indicate boundary between left and right. */
292 push_left_right_boundary ()
294 if (menu_items_used
+ 1 > menu_items_allocated
)
297 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qquote
;
300 /* Start a new menu pane in menu_items..
301 NAME is the pane name. PREFIX_VEC is a prefix key for this pane. */
304 push_menu_pane (name
, prefix_vec
)
305 Lisp_Object name
, prefix_vec
;
307 if (menu_items_used
+ MENU_ITEMS_PANE_LENGTH
> menu_items_allocated
)
310 if (menu_items_submenu_depth
== 0)
311 menu_items_n_panes
++;
312 XVECTOR (menu_items
)->contents
[menu_items_used
++] = Qt
;
313 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
314 XVECTOR (menu_items
)->contents
[menu_items_used
++] = prefix_vec
;
317 /* Push one menu item into the current pane.
318 NAME is the string to display. ENABLE if non-nil means
319 this item can be selected. KEY is the key generated by
320 choosing this item, or nil if this item doesn't really have a definition.
321 DEF is the definition of this item.
322 EQUIV is the textual description of the keyboard equivalent for
323 this item (or nil if none). */
326 push_menu_item (name
, enable
, key
, def
, equiv
)
327 Lisp_Object name
, enable
, key
, def
, equiv
;
329 if (menu_items_used
+ MENU_ITEMS_ITEM_LENGTH
> menu_items_allocated
)
332 XVECTOR (menu_items
)->contents
[menu_items_used
++] = name
;
333 XVECTOR (menu_items
)->contents
[menu_items_used
++] = enable
;
334 XVECTOR (menu_items
)->contents
[menu_items_used
++] = key
;
335 XVECTOR (menu_items
)->contents
[menu_items_used
++] = equiv
;
336 XVECTOR (menu_items
)->contents
[menu_items_used
++] = def
;
339 /* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
340 and generate menu panes for them in menu_items.
341 If NOTREAL is nonzero,
342 don't bother really computing whether an item is enabled. */
345 keymap_panes (keymaps
, nmaps
, notreal
)
346 Lisp_Object
*keymaps
;
354 /* Loop over the given keymaps, making a pane for each map.
355 But don't make a pane that is empty--ignore that map instead.
356 P is the number of panes we have made so far. */
357 for (mapno
= 0; mapno
< nmaps
; mapno
++)
358 single_keymap_panes (keymaps
[mapno
], Qnil
, Qnil
, notreal
, 10);
360 finish_menu_items ();
363 /* This is a recursive subroutine of keymap_panes.
364 It handles one keymap, KEYMAP.
365 The other arguments are passed along
366 or point to local variables of the previous function.
367 If NOTREAL is nonzero, only check for equivalent key bindings, don't
368 evaluate expressions in menu items and don't make any menu.
370 If we encounter submenus deeper than MAXDEPTH levels, ignore them. */
373 single_keymap_panes (keymap
, pane_name
, prefix
, notreal
, maxdepth
)
375 Lisp_Object pane_name
;
380 Lisp_Object pending_maps
= Qnil
;
381 Lisp_Object tail
, item
;
382 struct gcpro gcpro1
, gcpro2
;
388 push_menu_pane (pane_name
, prefix
);
391 /* Remember index for first item in this pane so we can go back and
392 add a prefix when (if) we see the first button. After that, notbuttons
393 is set to 0, to mark that we have seen a button and all non button
394 items need a prefix. */
395 notbuttons
= menu_items_used
;
398 for (tail
= keymap
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
400 GCPRO2 (keymap
, pending_maps
);
401 /* Look at each key binding, and if it is a menu item add it
403 item
= XCONS (tail
)->car
;
405 single_menu_item (XCONS (item
)->car
, XCONS (item
)->cdr
,
406 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
407 else if (VECTORP (item
))
409 /* Loop over the char values represented in the vector. */
410 int len
= XVECTOR (item
)->size
;
412 for (c
= 0; c
< len
; c
++)
414 Lisp_Object character
;
415 XSETFASTINT (character
, c
);
416 single_menu_item (character
, XVECTOR (item
)->contents
[c
],
417 &pending_maps
, notreal
, maxdepth
, ¬buttons
);
423 /* Process now any submenus which want to be panes at this level. */
424 while (!NILP (pending_maps
))
426 Lisp_Object elt
, eltcdr
, string
;
427 elt
= Fcar (pending_maps
);
428 eltcdr
= XCONS (elt
)->cdr
;
429 string
= XCONS (eltcdr
)->car
;
430 /* We no longer discard the @ from the beginning of the string here.
431 Instead, we do this in xmenu_show. */
432 single_keymap_panes (Fcar (elt
), string
,
433 XCONS (eltcdr
)->cdr
, notreal
, maxdepth
- 1);
434 pending_maps
= Fcdr (pending_maps
);
438 /* This is a subroutine of single_keymap_panes that handles one
440 KEY is a key in a keymap and ITEM is its binding.
441 PENDING_MAPS_PTR points to a list of keymaps waiting to be made into
443 If NOTREAL is nonzero, only check for equivalent key bindings, don't
444 evaluate expressions in menu items and don't make any menu.
445 If we encounter submenus deeper than MAXDEPTH levels, ignore them.
446 NOTBUTTONS_PTR is only used when simulating toggle boxes and radio
447 buttons. It points to variable notbuttons in single_keymap_panes,
448 which keeps track of if we have seen a button in this menu or not. */
451 single_menu_item (key
, item
, pending_maps_ptr
, notreal
, maxdepth
,
453 Lisp_Object key
, item
;
454 Lisp_Object
*pending_maps_ptr
;
455 int maxdepth
, notreal
;
458 Lisp_Object def
, map
, item_string
, enabled
;
459 struct gcpro gcpro1
, gcpro2
;
462 /* Parse the menu item and leave the result in item_properties. */
464 res
= parse_menu_item (item
, notreal
, 0);
467 return; /* Not a menu item. */
469 map
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_MAP
];
473 /* We don't want to make a menu, just traverse the keymaps to
474 precompute equivalent key bindings. */
476 single_keymap_panes (map
, Qnil
, key
, 1, maxdepth
- 1);
480 enabled
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_ENABLE
];
481 item_string
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
483 if (!NILP (map
) && XSTRING (item_string
)->data
[0] == '@')
486 /* An enabled separate pane. Remember this to handle it later. */
487 *pending_maps_ptr
= Fcons (Fcons (map
, Fcons (item_string
, key
)),
493 /* Simulate radio buttons and toggle boxes by putting a prefix in
496 Lisp_Object prefix
= Qnil
;
497 Lisp_Object type
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
501 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
504 /* The first button. Line up previous items in this menu. */
506 int index
= *notbuttons_ptr
; /* Index for first item this menu. */
509 while (index
< menu_items_used
)
512 = XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
];
516 submenu
++; /* Skip sub menu. */
518 else if (EQ (tem
, Qlambda
))
521 submenu
--; /* End sub menu. */
523 else if (EQ (tem
, Qt
))
524 index
+= 3; /* Skip new pane marker. */
525 else if (EQ (tem
, Qquote
))
526 index
++; /* Skip a left, right divider. */
529 if (!submenu
&& XSTRING (tem
)->data
[0] != '\0'
530 && XSTRING (tem
)->data
[0] != '-')
531 XVECTOR (menu_items
)->contents
[index
+ MENU_ITEMS_ITEM_NAME
]
532 = concat2 (build_string (" "), tem
);
533 index
+= MENU_ITEMS_ITEM_LENGTH
;
539 /* Calculate prefix, if any, for this item. */
540 if (EQ (type
, QCtoggle
))
541 prefix
= build_string (NILP (selected
) ? "[ ] " : "[X] ");
542 else if (EQ (type
, QCradio
))
543 prefix
= build_string (NILP (selected
) ? "( ) " : "(*) ");
545 /* Not a button. If we have earlier buttons, then we need a prefix. */
546 else if (!*notbuttons_ptr
&& XSTRING (item_string
)->data
[0] != '\0'
547 && XSTRING (item_string
)->data
[0] != '-')
548 prefix
= build_string (" ");
551 item_string
= concat2 (prefix
, item_string
);
553 #endif /* not HAVE_BOXES */
555 #ifndef USE_X_TOOLKIT
557 /* Indicate visually that this is a submenu. */
558 item_string
= concat2 (item_string
, build_string (" >"));
561 push_menu_item (item_string
, enabled
, key
,
562 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
],
563 XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
]);
566 /* Display a submenu using the toolkit. */
567 if (! (NILP (map
) || NILP (enabled
)))
569 push_submenu_start ();
570 single_keymap_panes (map
, Qnil
, key
, 0, maxdepth
- 1);
576 /* Push all the panes and items of a menu described by the
577 alist-of-alists MENU.
578 This handles old-fashioned calls to x-popup-menu. */
588 for (tail
= menu
; !NILP (tail
); tail
= Fcdr (tail
))
590 Lisp_Object elt
, pane_name
, pane_data
;
592 pane_name
= Fcar (elt
);
593 CHECK_STRING (pane_name
, 0);
594 push_menu_pane (pane_name
, Qnil
);
595 pane_data
= Fcdr (elt
);
596 CHECK_CONS (pane_data
, 0);
597 list_of_items (pane_data
);
600 finish_menu_items ();
603 /* Push the items in a single pane defined by the alist PANE. */
609 Lisp_Object tail
, item
, item1
;
611 for (tail
= pane
; !NILP (tail
); tail
= Fcdr (tail
))
615 push_menu_item (item
, Qnil
, Qnil
, Qt
, Qnil
);
616 else if (NILP (item
))
617 push_left_right_boundary ();
620 CHECK_CONS (item
, 0);
622 CHECK_STRING (item1
, 1);
623 push_menu_item (item1
, Qt
, Fcdr (item
), Qt
, Qnil
);
628 DEFUN ("x-popup-menu", Fx_popup_menu
, Sx_popup_menu
, 2, 2, 0,
629 "Pop up a deck-of-cards menu and return user's selection.\n\
630 POSITION is a position specification. This is either a mouse button event\n\
631 or a list ((XOFFSET YOFFSET) WINDOW)\n\
632 where XOFFSET and YOFFSET are positions in pixels from the top left\n\
633 corner of WINDOW's frame. (WINDOW may be a frame object instead of a window.)\n\
634 This controls the position of the center of the first line\n\
635 in the first pane of the menu, not the top left of the menu as a whole.\n\
636 If POSITION is t, it means to use the current mouse position.\n\
638 MENU is a specifier for a menu. For the simplest case, MENU is a keymap.\n\
639 The menu items come from key bindings that have a menu string as well as\n\
640 a definition; actually, the \"definition\" in such a key binding looks like\n\
641 \(STRING . REAL-DEFINITION). To give the menu a title, put a string into\n\
642 the keymap as a top-level element.\n\n\
643 If REAL-DEFINITION is nil, that puts a nonselectable string in the menu.\n\
644 Otherwise, REAL-DEFINITION should be a valid key binding definition.\n\
646 You can also use a list of keymaps as MENU.\n\
647 Then each keymap makes a separate pane.\n\
648 When MENU is a keymap or a list of keymaps, the return value\n\
649 is a list of events.\n\n\
651 Alternatively, you can specify a menu of multiple panes\n\
652 with a list of the form (TITLE PANE1 PANE2...),\n\
653 where each pane is a list of form (TITLE ITEM1 ITEM2...).\n\
654 Each ITEM is normally a cons cell (STRING . VALUE);\n\
655 but a string can appear as an item--that makes a nonselectable line\n\
657 With this form of menu, the return value is VALUE from the chosen item.\n\
659 If POSITION is nil, don't display the menu at all, just precalculate the\n\
660 cached information about equivalent key sequences.")
662 Lisp_Object position
, menu
;
664 int number_of_panes
, panes
;
665 Lisp_Object keymap
, tem
;
669 Lisp_Object selection
;
672 Lisp_Object x
, y
, window
;
678 if (! NILP (position
))
682 /* Decode the first argument: find the window and the coordinates. */
683 if (EQ (position
, Qt
)
684 || (CONSP (position
) && EQ (XCONS (position
)->car
, Qmenu_bar
)))
686 /* Use the mouse's current position. */
687 FRAME_PTR new_f
= selected_frame
;
688 Lisp_Object bar_window
;
692 if (mouse_position_hook
)
693 (*mouse_position_hook
) (&new_f
, 1, &bar_window
,
694 &part
, &x
, &y
, &time
);
696 XSETFRAME (window
, new_f
);
699 window
= selected_window
;
706 tem
= Fcar (position
);
709 window
= Fcar (Fcdr (position
));
711 y
= Fcar (Fcdr (tem
));
716 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
717 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
718 tem
= Fcar (Fcdr (Fcdr (tem
))); /* POSN_WINDOW_POSN (tem) */
727 /* Decode where to put the menu. */
735 else if (WINDOWP (window
))
737 CHECK_LIVE_WINDOW (window
, 0);
738 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
740 xpos
= (FONT_WIDTH (f
->output_data
.x
->font
)
741 * XFASTINT (XWINDOW (window
)->left
));
742 ypos
= (f
->output_data
.x
->line_height
743 * XFASTINT (XWINDOW (window
)->top
));
746 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
747 but I don't want to make one now. */
748 CHECK_WINDOW (window
, 0);
753 XSETFRAME (Vmenu_updating_frame
, f
);
755 Vmenu_updating_frame
= Qnil
;
756 #endif /* HAVE_MENUS */
761 /* Decode the menu items from what was specified. */
763 keymap
= Fkeymapp (menu
);
766 tem
= Fkeymapp (Fcar (menu
));
769 /* We were given a keymap. Extract menu info from the keymap. */
771 keymap
= get_keymap (menu
);
773 /* Extract the detailed info to make one pane. */
774 keymap_panes (&menu
, 1, NILP (position
));
776 /* Search for a string appearing directly as an element of the keymap.
777 That string is the title of the menu. */
778 prompt
= map_prompt (keymap
);
779 if (NILP (title
) && !NILP (prompt
))
782 /* Make that be the pane title of the first pane. */
783 if (!NILP (prompt
) && menu_items_n_panes
>= 0)
784 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = prompt
;
788 else if (!NILP (tem
))
790 /* We were given a list of keymaps. */
791 int nmaps
= XFASTINT (Flength (menu
));
793 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
798 /* The first keymap that has a prompt string
799 supplies the menu title. */
800 for (tem
= menu
, i
= 0; CONSP (tem
); tem
= Fcdr (tem
))
804 maps
[i
++] = keymap
= get_keymap (Fcar (tem
));
806 prompt
= map_prompt (keymap
);
807 if (NILP (title
) && !NILP (prompt
))
811 /* Extract the detailed info to make one pane. */
812 keymap_panes (maps
, nmaps
, NILP (position
));
814 /* Make the title be the pane title of the first pane. */
815 if (!NILP (title
) && menu_items_n_panes
>= 0)
816 XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
] = title
;
822 /* We were given an old-fashioned menu. */
824 CHECK_STRING (title
, 1);
826 list_of_panes (Fcdr (menu
));
833 discard_menu_items ();
839 /* Display them in a menu. */
842 selection
= xmenu_show (f
, xpos
, ypos
, for_click
,
843 keymaps
, title
, &error_name
);
846 discard_menu_items ();
849 #endif /* HAVE_MENUS */
851 if (error_name
) error (error_name
);
857 DEFUN ("x-popup-dialog", Fx_popup_dialog
, Sx_popup_dialog
, 2, 2, 0,
858 "Pop up a dialog box and return user's selection.\n\
859 POSITION specifies which frame to use.\n\
860 This is normally a mouse button event or a window or frame.\n\
861 If POSITION is t, it means to use the frame the mouse is on.\n\
862 The dialog box appears in the middle of the specified frame.\n\
864 CONTENTS specifies the alternatives to display in the dialog box.\n\
865 It is a list of the form (TITLE ITEM1 ITEM2...).\n\
866 Each ITEM is a cons cell (STRING . VALUE).\n\
867 The return value is VALUE from the chosen item.\n\n\
868 An ITEM may also be just a string--that makes a nonselectable item.\n\
869 An ITEM may also be nil--that means to put all preceding items\n\
870 on the left of the dialog box and all following items on the right.\n\
871 \(By default, approximately half appear on each side.)")
873 Lisp_Object position
, contents
;
880 /* Decode the first argument: find the window or frame to use. */
881 if (EQ (position
, Qt
)
882 || (CONSP (position
) && EQ (XCONS (position
)->car
, Qmenu_bar
)))
884 #if 0 /* Using the frame the mouse is on may not be right. */
885 /* Use the mouse's current position. */
886 FRAME_PTR new_f
= selected_frame
;
887 Lisp_Object bar_window
;
892 (*mouse_position_hook
) (&new_f
, 1, &bar_window
, &part
, &x
, &y
, &time
);
895 XSETFRAME (window
, new_f
);
897 window
= selected_window
;
899 window
= selected_window
;
901 else if (CONSP (position
))
904 tem
= Fcar (position
);
906 window
= Fcar (Fcdr (position
));
909 tem
= Fcar (Fcdr (position
)); /* EVENT_START (position) */
910 window
= Fcar (tem
); /* POSN_WINDOW (tem) */
913 else if (WINDOWP (position
) || FRAMEP (position
))
918 /* Decode where to put the menu. */
922 else if (WINDOWP (window
))
924 CHECK_LIVE_WINDOW (window
, 0);
925 f
= XFRAME (WINDOW_FRAME (XWINDOW (window
)));
928 /* ??? Not really clean; should be CHECK_WINDOW_OR_FRAME,
929 but I don't want to make one now. */
930 CHECK_WINDOW (window
, 0);
932 #ifndef USE_X_TOOLKIT
933 /* Display a menu with these alternatives
934 in the middle of frame F. */
936 Lisp_Object x
, y
, frame
, newpos
;
937 XSETFRAME (frame
, f
);
938 XSETINT (x
, x_pixel_width (f
) / 2);
939 XSETINT (y
, x_pixel_height (f
) / 2);
940 newpos
= Fcons (Fcons (x
, Fcons (y
, Qnil
)), Fcons (frame
, Qnil
));
942 return Fx_popup_menu (newpos
,
943 Fcons (Fcar (contents
), Fcons (contents
, Qnil
)));
949 Lisp_Object selection
;
951 /* Decode the dialog items from what was specified. */
952 title
= Fcar (contents
);
953 CHECK_STRING (title
, 1);
955 list_of_panes (Fcons (contents
, Qnil
));
957 /* Display them in a dialog box. */
959 selection
= xdialog_show (f
, 0, title
, &error_name
);
962 discard_menu_items ();
964 if (error_name
) error (error_name
);
972 /* Loop in Xt until the menu pulldown or dialog popup has been
973 popped down (deactivated). This is used for x-popup-menu
974 and x-popup-dialog; it is not used for the menu bar any more.
976 NOTE: All calls to popup_get_selection should be protected
977 with BLOCK_INPUT, UNBLOCK_INPUT wrappers. */
980 popup_get_selection (initial_event
, dpyinfo
, id
)
981 XEvent
*initial_event
;
982 struct x_display_info
*dpyinfo
;
987 /* Define a queue to save up for later unreading
988 all X events that don't pertain to the menu. */
992 struct event_queue
*next
;
995 struct event_queue
*queue
= NULL
;
996 struct event_queue
*queue_tmp
;
999 event
= *initial_event
;
1001 XtAppNextEvent (Xt_app_con
, &event
);
1005 /* Handle expose events for editor frames right away. */
1006 if (event
.type
== Expose
)
1007 process_expose_from_menu (event
);
1008 /* Make sure we don't consider buttons grabbed after menu goes.
1009 And make sure to deactivate for any ButtonRelease,
1010 even if XtDispatchEvent doesn't do that. */
1011 else if (event
.type
== ButtonRelease
1012 && dpyinfo
->display
== event
.xbutton
.display
)
1014 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
1015 popup_activated_flag
= 0;
1016 #ifdef USE_MOTIF /* Pretending that the event came from a
1017 Btn1Down seems the only way to convince Motif to
1018 activate its callbacks; setting the XmNmenuPost
1019 isn't working. --marcus@sysc.pdx.edu. */
1020 event
.xbutton
.button
= 1;
1023 /* If the user presses a key, deactivate the menu.
1024 The user is likely to do that if we get wedged. */
1025 else if (event
.type
== KeyPress
1026 && dpyinfo
->display
== event
.xbutton
.display
)
1028 KeySym keysym
= XLookupKeysym (&event
.xkey
, 0);
1029 if (!IsModifierKey (keysym
))
1031 popup_activated_flag
= 0;
1035 /* Button presses outside the menu also pop it down. */
1036 else if (event
.type
== ButtonPress
1037 && event
.xany
.display
== dpyinfo
->display
1038 && x_any_window_to_frame (dpyinfo
, event
.xany
.window
))
1040 popup_activated_flag
= 0;
1044 /* Queue all events not for this popup,
1045 except for Expose, which we've already handled, and ButtonRelease.
1046 Note that the X window is associated with the frame if this
1047 is a menu bar popup, but not if it's a dialog box. So we use
1048 x_non_menubar_window_to_frame, not x_any_window_to_frame. */
1049 if (event
.type
!= Expose
1050 && !(event
.type
== ButtonRelease
1051 && dpyinfo
->display
== event
.xbutton
.display
)
1052 && (event
.xany
.display
!= dpyinfo
->display
1053 || x_non_menubar_window_to_frame (dpyinfo
, event
.xany
.window
)))
1055 queue_tmp
= (struct event_queue
*) malloc (sizeof (struct event_queue
));
1057 if (queue_tmp
!= NULL
)
1059 queue_tmp
->event
= event
;
1060 queue_tmp
->next
= queue
;
1065 XtDispatchEvent (&event
);
1067 if (!popup_activated ())
1069 XtAppNextEvent (Xt_app_con
, &event
);
1072 /* Unread any events that we got but did not handle. */
1073 while (queue
!= NULL
)
1076 XPutBackEvent (queue_tmp
->event
.xany
.display
, &queue_tmp
->event
);
1077 queue
= queue_tmp
->next
;
1078 free ((char *)queue_tmp
);
1079 /* Cause these events to get read as soon as we UNBLOCK_INPUT. */
1080 interrupt_input_pending
= 1;
1084 /* Activate the menu bar of frame F.
1085 This is called from keyboard.c when it gets the
1086 menu_bar_activate_event out of the Emacs event queue.
1088 To activate the menu bar, we use the X button-press event
1089 that was saved in saved_menu_event.
1090 That makes the toolkit do its thing.
1092 But first we recompute the menu bar contents (the whole tree).
1094 The reason for saving the button event until here, instead of
1095 passing it to the toolkit right away, is that we can safely
1096 execute Lisp code. */
1098 x_activate_menubar (f
)
1101 if (!f
->output_data
.x
->saved_menu_event
->type
)
1104 set_frame_menubar (f
, 0, 1);
1106 XtDispatchEvent ((XEvent
*) f
->output_data
.x
->saved_menu_event
);
1109 if (f
->output_data
.x
->saved_menu_event
->type
== ButtonRelease
)
1110 pending_menu_activation
= 1;
1113 /* Ignore this if we get it a second time. */
1114 f
->output_data
.x
->saved_menu_event
->type
= 0;
1117 /* Detect if a dialog or menu has been posted. */
1122 return popup_activated_flag
;
1126 /* This callback is invoked when the user selects a menubar cascade
1127 pushbutton, but before the pulldown menu is posted. */
1130 popup_activate_callback (widget
, id
, client_data
)
1133 XtPointer client_data
;
1135 popup_activated_flag
= 1;
1138 /* This callback is called from the menu bar pulldown menu
1139 when the user makes a selection.
1140 Figure out what the user chose
1141 and put the appropriate events into the keyboard buffer. */
1144 menubar_selection_callback (widget
, id
, client_data
)
1147 XtPointer client_data
;
1149 Lisp_Object prefix
, entry
;
1150 FRAME_PTR f
= menubar_id_to_frame (id
);
1152 Lisp_Object
*subprefix_stack
;
1153 int submenu_depth
= 0;
1158 subprefix_stack
= (Lisp_Object
*) alloca (f
->menu_bar_items_used
* sizeof (Lisp_Object
));
1159 vector
= f
->menu_bar_vector
;
1162 while (i
< f
->menu_bar_items_used
)
1164 if (EQ (XVECTOR (vector
)->contents
[i
], Qnil
))
1166 subprefix_stack
[submenu_depth
++] = prefix
;
1170 else if (EQ (XVECTOR (vector
)->contents
[i
], Qlambda
))
1172 prefix
= subprefix_stack
[--submenu_depth
];
1175 else if (EQ (XVECTOR (vector
)->contents
[i
], Qt
))
1177 prefix
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1178 i
+= MENU_ITEMS_PANE_LENGTH
;
1182 entry
= XVECTOR (vector
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
1183 /* The EMACS_INT cast avoids a warning. There's no problem
1184 as long as pointers have enough bits to hold small integers. */
1185 if ((int) (EMACS_INT
) client_data
== i
)
1188 struct input_event buf
;
1191 XSETFRAME (frame
, f
);
1192 buf
.kind
= menu_bar_event
;
1193 buf
.frame_or_window
= Fcons (frame
, Fcons (Qmenu_bar
, Qnil
));
1194 kbd_buffer_store_event (&buf
);
1196 for (j
= 0; j
< submenu_depth
; j
++)
1197 if (!NILP (subprefix_stack
[j
]))
1199 buf
.kind
= menu_bar_event
;
1200 buf
.frame_or_window
= Fcons (frame
, subprefix_stack
[j
]);
1201 kbd_buffer_store_event (&buf
);
1206 buf
.kind
= menu_bar_event
;
1207 buf
.frame_or_window
= Fcons (frame
, prefix
);
1208 kbd_buffer_store_event (&buf
);
1211 buf
.kind
= menu_bar_event
;
1212 buf
.frame_or_window
= Fcons (frame
, entry
);
1213 kbd_buffer_store_event (&buf
);
1217 i
+= MENU_ITEMS_ITEM_LENGTH
;
1222 /* This callback is invoked when a dialog or menu is finished being
1223 used and has been unposted. */
1226 popup_deactivate_callback (widget
, id
, client_data
)
1229 XtPointer client_data
;
1231 popup_activated_flag
= 0;
1234 /* Allocate a widget_value, blocking input. */
1237 xmalloc_widget_value ()
1239 widget_value
*value
;
1242 value
= malloc_widget_value ();
1248 /* This recursively calls free_widget_value on the tree of widgets.
1249 It must free all data that was malloc'ed for these widget_values.
1250 In Emacs, many slots are pointers into the data of Lisp_Strings, and
1251 must be left alone. */
1254 free_menubar_widget_value_tree (wv
)
1259 wv
->name
= wv
->value
= wv
->key
= (char *) 0xDEADBEEF;
1261 if (wv
->contents
&& (wv
->contents
!= (widget_value
*)1))
1263 free_menubar_widget_value_tree (wv
->contents
);
1264 wv
->contents
= (widget_value
*) 0xDEADBEEF;
1268 free_menubar_widget_value_tree (wv
->next
);
1269 wv
->next
= (widget_value
*) 0xDEADBEEF;
1272 free_widget_value (wv
);
1276 /* Return a tree of widget_value structures for a menu bar item
1277 whose event type is ITEM_KEY (with string ITEM_NAME)
1278 and whose contents come from the list of keymaps MAPS. */
1280 static widget_value
*
1281 single_submenu (item_key
, item_name
, maps
)
1282 Lisp_Object item_key
, item_name
, maps
;
1284 widget_value
*wv
, *prev_wv
, *save_wv
, *first_wv
;
1286 int submenu_depth
= 0;
1289 Lisp_Object
*mapvec
;
1290 widget_value
**submenu_stack
;
1292 int previous_items
= menu_items_used
;
1293 int top_level_items
= 0;
1295 length
= Flength (maps
);
1296 len
= XINT (length
);
1298 /* Convert the list MAPS into a vector MAPVEC. */
1299 mapvec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1300 for (i
= 0; i
< len
; i
++)
1302 mapvec
[i
] = Fcar (maps
);
1306 menu_items_n_panes
= 0;
1308 /* Loop over the given keymaps, making a pane for each map.
1309 But don't make a pane that is empty--ignore that map instead. */
1310 for (i
= 0; i
< len
; i
++)
1312 if (SYMBOLP (mapvec
[i
])
1313 || (CONSP (mapvec
[i
])
1314 && NILP (Fkeymapp (mapvec
[i
]))))
1316 /* Here we have a command at top level in the menu bar
1317 as opposed to a submenu. */
1318 top_level_items
= 1;
1319 push_menu_pane (Qnil
, Qnil
);
1320 push_menu_item (item_name
, Qt
, item_key
, mapvec
[i
], Qnil
);
1323 single_keymap_panes (mapvec
[i
], item_name
, item_key
, 0, 10);
1326 /* Create a tree of widget_value objects
1327 representing the panes and their items. */
1330 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1331 wv
= xmalloc_widget_value ();
1339 /* Loop over all panes and items made during this call
1340 and construct a tree of widget_value objects.
1341 Ignore the panes and items made by previous calls to
1342 single_submenu, even though those are also in menu_items. */
1344 while (i
< menu_items_used
)
1346 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1348 submenu_stack
[submenu_depth
++] = save_wv
;
1353 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1356 save_wv
= submenu_stack
[--submenu_depth
];
1359 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1360 && submenu_depth
!= 0)
1361 i
+= MENU_ITEMS_PANE_LENGTH
;
1362 /* Ignore a nil in the item list.
1363 It's meaningful only for dialog boxes. */
1364 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1366 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1368 /* Create a new pane. */
1369 Lisp_Object pane_name
, prefix
;
1371 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1372 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1373 pane_string
= (NILP (pane_name
)
1374 ? "" : (char *) XSTRING (pane_name
)->data
);
1375 /* If there is just one top-level pane, put all its items directly
1376 under the top-level menu. */
1377 if (menu_items_n_panes
== 1)
1380 /* If the pane has a meaningful name,
1381 make the pane a top-level menu item
1382 with its items as a submenu beneath it. */
1383 if (strcmp (pane_string
, ""))
1385 wv
= xmalloc_widget_value ();
1389 first_wv
->contents
= wv
;
1390 wv
->name
= pane_string
;
1391 /* Ignore the @ that means "separate pane".
1392 This is a kludge, but this isn't worth more time. */
1393 if (!NILP (prefix
) && wv
->name
[0] == '@')
1400 i
+= MENU_ITEMS_PANE_LENGTH
;
1404 /* Create a new item within current pane. */
1405 Lisp_Object item_name
, enable
, descrip
, def
;
1406 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1407 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1409 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1410 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
1412 wv
= xmalloc_widget_value ();
1416 save_wv
->contents
= wv
;
1418 wv
->name
= (char *) XSTRING (item_name
)->data
;
1419 if (!NILP (descrip
))
1420 wv
->key
= (char *) XSTRING (descrip
)->data
;
1422 /* The EMACS_INT cast avoids a warning. There's no problem
1423 as long as pointers have enough bits to hold small integers. */
1424 wv
->call_data
= (!NILP (def
) ? (void *) (EMACS_INT
) i
: 0);
1425 wv
->enabled
= !NILP (enable
);
1428 i
+= MENU_ITEMS_ITEM_LENGTH
;
1432 /* If we have just one "menu item"
1433 that was originally a button, return it by itself. */
1434 if (top_level_items
&& first_wv
->contents
&& first_wv
->contents
->next
== 0)
1436 wv
= first_wv
->contents
;
1437 free_widget_value (first_wv
);
1444 extern void EmacsFrameSetCharSize ();
1446 /* Recompute all the widgets of frame F, when the menu bar
1447 has been changed. */
1450 update_frame_menubar (f
)
1453 struct x_output
*x
= f
->output_data
.x
;
1455 int menubar_changed
;
1457 Dimension shell_height
;
1459 /* We assume the menubar contents has changed if the global flag is set,
1460 or if the current buffer has changed, or if the menubar has never
1461 been updated before.
1463 menubar_changed
= (x
->menubar_widget
1464 && !XtIsManaged (x
->menubar_widget
));
1466 if (! (menubar_changed
))
1470 /* Save the size of the frame because the pane widget doesn't accept to
1471 resize itself. So force it. */
1475 /* Do the voodoo which means "I'm changing lots of things, don't try to
1476 refigure sizes until I'm done." */
1477 lw_refigure_widget (x
->column_widget
, False
);
1479 /* the order in which children are managed is the top to
1480 bottom order in which they are displayed in the paned window.
1481 First, remove the text-area widget.
1483 XtUnmanageChild (x
->edit_widget
);
1485 /* remove the menubar that is there now, and put up the menubar that
1488 if (menubar_changed
)
1490 XtManageChild (x
->menubar_widget
);
1491 XtMapWidget (x
->menubar_widget
);
1492 XtVaSetValues (x
->menubar_widget
, XtNmappedWhenManaged
, 1, 0);
1495 /* Re-manage the text-area widget, and then thrash the sizes. */
1496 XtManageChild (x
->edit_widget
);
1497 lw_refigure_widget (x
->column_widget
, True
);
1499 /* Force the pane widget to resize itself with the right values. */
1500 EmacsFrameSetCharSize (x
->edit_widget
, columns
, rows
);
1505 /* Set the contents of the menubar widgets of frame F.
1506 The argument FIRST_TIME is currently ignored;
1507 it is set the first time this is called, from initialize_frame_menubar. */
1510 set_frame_menubar (f
, first_time
, deep_p
)
1515 Widget menubar_widget
= f
->output_data
.x
->menubar_widget
;
1516 Lisp_Object tail
, items
, frame
;
1517 widget_value
*wv
, *first_wv
, *prev_wv
= 0;
1521 XSETFRAME (Vmenu_updating_frame
, f
);
1523 if (f
->output_data
.x
->id
== 0)
1524 f
->output_data
.x
->id
= next_menubar_widget_id
++;
1525 id
= f
->output_data
.x
->id
;
1527 if (! menubar_widget
)
1529 else if (pending_menu_activation
&& !deep_p
)
1531 /* Make the first call for any given frame always go deep. */
1532 else if (!f
->output_data
.x
->saved_menu_event
&& !deep_p
)
1535 f
->output_data
.x
->saved_menu_event
= (XEvent
*)xmalloc (sizeof (XEvent
));
1536 f
->output_data
.x
->saved_menu_event
->type
= 0;
1539 wv
= xmalloc_widget_value ();
1540 wv
->name
= "menubar";
1547 /* Make a widget-value tree representing the entire menu trees. */
1549 struct buffer
*prev
= current_buffer
;
1551 int specpdl_count
= specpdl_ptr
- specpdl
;
1552 int previous_menu_items_used
= f
->menu_bar_items_used
;
1553 Lisp_Object
*previous_items
1554 = (Lisp_Object
*) alloca (previous_menu_items_used
1555 * sizeof (Lisp_Object
));
1557 /* If we are making a new widget, its contents are empty,
1558 do always reinitialize them. */
1559 if (! menubar_widget
)
1560 previous_menu_items_used
= 0;
1562 buffer
= XWINDOW (FRAME_SELECTED_WINDOW (f
))->buffer
;
1563 specbind (Qinhibit_quit
, Qt
);
1564 /* Don't let the debugger step into this code
1565 because it is not reentrant. */
1566 specbind (Qdebug_on_next_call
, Qnil
);
1568 record_unwind_protect (Fset_match_data
, Fmatch_data (Qnil
, Qnil
));
1569 if (NILP (Voverriding_local_map_menu_flag
))
1571 specbind (Qoverriding_terminal_local_map
, Qnil
);
1572 specbind (Qoverriding_local_map
, Qnil
);
1575 set_buffer_internal_1 (XBUFFER (buffer
));
1577 /* Run the Lucid hook. */
1578 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
1579 /* If it has changed current-menubar from previous value,
1580 really recompute the menubar from the value. */
1581 if (! NILP (Vlucid_menu_bar_dirty_flag
))
1582 call0 (Qrecompute_lucid_menubar
);
1583 safe_run_hooks (Qmenu_bar_update_hook
);
1584 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1586 items
= FRAME_MENU_BAR_ITEMS (f
);
1588 inhibit_garbage_collection ();
1590 /* Save the frame's previous menu bar contents data. */
1591 bcopy (XVECTOR (f
->menu_bar_vector
)->contents
, previous_items
,
1592 previous_menu_items_used
* sizeof (Lisp_Object
));
1594 /* Fill in the current menu bar contents. */
1595 menu_items
= f
->menu_bar_vector
;
1596 menu_items_allocated
= XVECTOR (menu_items
)->size
;
1598 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1600 Lisp_Object key
, string
, maps
;
1602 key
= XVECTOR (items
)->contents
[i
];
1603 string
= XVECTOR (items
)->contents
[i
+ 1];
1604 maps
= XVECTOR (items
)->contents
[i
+ 2];
1608 wv
= single_submenu (key
, string
, maps
);
1612 first_wv
->contents
= wv
;
1613 /* Don't set wv->name here; GC during the loop might relocate it. */
1618 finish_menu_items ();
1620 set_buffer_internal_1 (prev
);
1621 unbind_to (specpdl_count
, Qnil
);
1623 /* If there has been no change in the Lisp-level contents
1624 of the menu bar, skip redisplaying it. Just exit. */
1626 for (i
= 0; i
< previous_menu_items_used
; i
++)
1627 if (menu_items_used
== i
1628 || (!EQ (previous_items
[i
], XVECTOR (menu_items
)->contents
[i
])))
1630 if (i
== menu_items_used
&& i
== previous_menu_items_used
&& i
!= 0)
1632 free_menubar_widget_value_tree (first_wv
);
1638 /* Now GC cannot happen during the lifetime of the widget_value,
1639 so it's safe to store data from a Lisp_String. */
1640 wv
= first_wv
->contents
;
1641 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1644 string
= XVECTOR (items
)->contents
[i
+ 1];
1647 wv
->name
= (char *) XSTRING (string
)->data
;
1651 f
->menu_bar_vector
= menu_items
;
1652 f
->menu_bar_items_used
= menu_items_used
;
1657 /* Make a widget-value tree containing
1658 just the top level menu bar strings. */
1660 items
= FRAME_MENU_BAR_ITEMS (f
);
1661 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
1665 string
= XVECTOR (items
)->contents
[i
+ 1];
1669 wv
= xmalloc_widget_value ();
1670 wv
->name
= (char *) XSTRING (string
)->data
;
1673 /* This prevents lwlib from assuming this
1674 menu item is really supposed to be empty. */
1675 /* The EMACS_INT cast avoids a warning.
1676 This value just has to be different from small integers. */
1677 wv
->call_data
= (void *) (EMACS_INT
) (-1);
1682 first_wv
->contents
= wv
;
1686 /* Forget what we thought we knew about what is in the
1687 detailed contents of the menu bar menus.
1688 Changing the top level always destroys the contents. */
1689 f
->menu_bar_items_used
= 0;
1692 /* Create or update the menu bar widget. */
1698 /* Disable resizing (done for Motif!) */
1699 lw_allow_resizing (f
->output_data
.x
->widget
, False
);
1701 /* The third arg is DEEP_P, which says to consider the entire
1702 menu trees we supply, rather than just the menu bar item names. */
1703 lw_modify_all_widgets (id
, first_wv
, deep_p
);
1705 /* Re-enable the edit widget to resize. */
1706 lw_allow_resizing (f
->output_data
.x
->widget
, True
);
1710 menubar_widget
= lw_create_widget ("menubar", "menubar", id
, first_wv
,
1711 f
->output_data
.x
->column_widget
,
1713 popup_activate_callback
,
1714 menubar_selection_callback
,
1715 popup_deactivate_callback
);
1716 f
->output_data
.x
->menubar_widget
= menubar_widget
;
1721 = (f
->output_data
.x
->menubar_widget
1722 ? (f
->output_data
.x
->menubar_widget
->core
.height
1723 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
1726 #if 0 /* Experimentally, we now get the right results
1727 for -geometry -0-0 without this. 24 Aug 96, rms. */
1729 if (FRAME_EXTERNAL_MENU_BAR (f
))
1732 XtVaGetValues (f
->output_data
.x
->column_widget
,
1733 XtNinternalBorderWidth
, &ibw
, NULL
);
1734 menubar_size
+= ibw
;
1736 #endif /* USE_LUCID */
1739 f
->output_data
.x
->menubar_height
= menubar_size
;
1742 free_menubar_widget_value_tree (first_wv
);
1744 update_frame_menubar (f
);
1749 /* Called from Fx_create_frame to create the initial menubar of a frame
1750 before it is mapped, so that the window is mapped with the menubar already
1751 there instead of us tacking it on later and thrashing the window after it
1755 initialize_frame_menubar (f
)
1758 /* This function is called before the first chance to redisplay
1759 the frame. It has to be, so the frame will have the right size. */
1760 FRAME_MENU_BAR_ITEMS (f
) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f
));
1761 set_frame_menubar (f
, 1, 1);
1764 /* Get rid of the menu bar of frame F, and free its storage.
1765 This is used when deleting a frame, and when turning off the menu bar. */
1768 free_frame_menubar (f
)
1771 Widget menubar_widget
;
1774 menubar_widget
= f
->output_data
.x
->menubar_widget
;
1776 f
->output_data
.x
->menubar_height
= 0;
1781 lw_destroy_all_widgets ((LWLIB_ID
) f
->output_data
.x
->id
);
1786 #endif /* USE_X_TOOLKIT */
1788 /* xmenu_show actually displays a menu using the panes and items in menu_items
1789 and returns the value selected from it.
1790 There are two versions of xmenu_show, one for Xt and one for Xlib.
1791 Both assume input is blocked by the caller. */
1793 /* F is the frame the menu is for.
1794 X and Y are the frame-relative specified position,
1795 relative to the inside upper left corner of the frame F.
1796 FOR_CLICK is nonzero if this menu was invoked for a mouse click.
1797 KEYMAPS is 1 if this menu was specified with keymaps;
1798 in that case, we return a list containing the chosen item's value
1799 and perhaps also the pane's prefix.
1800 TITLE is the specified menu title.
1801 ERROR is a place to store an error message string in case of failure.
1802 (We return nil on failure, but the value doesn't actually matter.) */
1804 #ifdef USE_X_TOOLKIT
1806 /* We need a unique id for each widget handled by the Lucid Widget
1809 For the main windows, and popup menus, we use this counter,
1810 which we increment each time after use. This starts from 1<<16.
1812 For menu bars, we use numbers starting at 0, counted in
1813 next_menubar_widget_id. */
1814 LWLIB_ID widget_id_tick
;
1817 static Lisp_Object
*volatile menu_item_selection
;
1819 static Lisp_Object
*menu_item_selection
;
1823 popup_selection_callback (widget
, id
, client_data
)
1826 XtPointer client_data
;
1828 menu_item_selection
= (Lisp_Object
*) client_data
;
1832 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
1846 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
1847 widget_value
**submenu_stack
1848 = (widget_value
**) alloca (menu_items_used
* sizeof (widget_value
*));
1849 Lisp_Object
*subprefix_stack
1850 = (Lisp_Object
*) alloca (menu_items_used
* sizeof (Lisp_Object
));
1851 int submenu_depth
= 0;
1852 XButtonPressedEvent dummy
;
1855 int next_release_must_exit
= 0;
1859 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
1861 *error
= "Empty menu";
1865 /* Create a tree of widget_value objects
1866 representing the panes and their items. */
1867 wv
= xmalloc_widget_value ();
1874 /* Loop over all panes and items, filling in the tree. */
1876 while (i
< menu_items_used
)
1878 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
1880 submenu_stack
[submenu_depth
++] = save_wv
;
1886 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
1889 save_wv
= submenu_stack
[--submenu_depth
];
1893 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
)
1894 && submenu_depth
!= 0)
1895 i
+= MENU_ITEMS_PANE_LENGTH
;
1896 /* Ignore a nil in the item list.
1897 It's meaningful only for dialog boxes. */
1898 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
1900 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
1902 /* Create a new pane. */
1903 Lisp_Object pane_name
, prefix
;
1905 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
1906 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
1907 pane_string
= (NILP (pane_name
)
1908 ? "" : (char *) XSTRING (pane_name
)->data
);
1909 /* If there is just one top-level pane, put all its items directly
1910 under the top-level menu. */
1911 if (menu_items_n_panes
== 1)
1914 /* If the pane has a meaningful name,
1915 make the pane a top-level menu item
1916 with its items as a submenu beneath it. */
1917 if (!keymaps
&& strcmp (pane_string
, ""))
1919 wv
= xmalloc_widget_value ();
1923 first_wv
->contents
= wv
;
1924 wv
->name
= pane_string
;
1925 if (keymaps
&& !NILP (prefix
))
1932 else if (first_pane
)
1938 i
+= MENU_ITEMS_PANE_LENGTH
;
1942 /* Create a new item within current pane. */
1943 Lisp_Object item_name
, enable
, descrip
, def
;
1944 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
1945 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
1947 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
1948 def
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_DEFINITION
];
1950 wv
= xmalloc_widget_value ();
1954 save_wv
->contents
= wv
;
1955 wv
->name
= (char *) XSTRING (item_name
)->data
;
1956 if (!NILP (descrip
))
1957 wv
->key
= (char *) XSTRING (descrip
)->data
;
1959 /* If this item has a null value,
1960 make the call_data null so that it won't display a box
1961 when the mouse is on it. */
1963 = (!NILP (def
) ? (void *) &XVECTOR (menu_items
)->contents
[i
] : 0);
1964 wv
->enabled
= !NILP (enable
);
1967 i
+= MENU_ITEMS_ITEM_LENGTH
;
1971 /* Deal with the title, if it is non-nil. */
1974 widget_value
*wv_title
= xmalloc_widget_value ();
1975 widget_value
*wv_sep1
= xmalloc_widget_value ();
1976 widget_value
*wv_sep2
= xmalloc_widget_value ();
1978 wv_sep2
->name
= "--";
1979 wv_sep2
->next
= first_wv
->contents
;
1981 wv_sep1
->name
= "--";
1982 wv_sep1
->next
= wv_sep2
;
1984 wv_title
->name
= (char *) XSTRING (title
)->data
;
1985 wv_title
->enabled
= True
;
1986 wv_title
->next
= wv_sep1
;
1987 first_wv
->contents
= wv_title
;
1990 /* Actually create the menu. */
1991 menu_id
= widget_id_tick
++;
1992 menu
= lw_create_widget ("popup", first_wv
->name
, menu_id
, first_wv
,
1993 f
->output_data
.x
->widget
, 1, 0,
1994 popup_selection_callback
,
1995 popup_deactivate_callback
);
1997 /* Adjust coordinates to relative to the outer (window manager) window. */
2000 int win_x
= 0, win_y
= 0;
2002 /* Find the position of the outside upper-left corner of
2003 the inner window, with respect to the outer window. */
2004 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2007 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2009 /* From-window, to-window. */
2010 f
->output_data
.x
->window_desc
,
2011 f
->output_data
.x
->parent_desc
,
2013 /* From-position, to-position. */
2014 0, 0, &win_x
, &win_y
,
2016 /* Child of window. */
2024 /* Adjust coordinates to be root-window-relative. */
2025 x
+= f
->output_data
.x
->left_pos
;
2026 y
+= f
->output_data
.x
->top_pos
;
2028 dummy
.type
= ButtonPress
;
2030 dummy
.send_event
= 0;
2031 dummy
.display
= FRAME_X_DISPLAY (f
);
2032 dummy
.time
= CurrentTime
;
2033 dummy
.root
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
2034 dummy
.window
= dummy
.root
;
2035 dummy
.subwindow
= dummy
.root
;
2040 dummy
.state
= (FRAME_X_DISPLAY_INFO (f
)->grabbed
>> 1) * Button1Mask
;
2042 for (i
= 0; i
< 5; i
++)
2043 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
& (1 << i
))
2046 /* Don't allow any geometry request from the user. */
2047 XtSetArg (av
[ac
], XtNgeometry
, 0); ac
++;
2048 XtSetValues (menu
, av
, ac
);
2050 /* Free the widget_value objects we used to specify the contents. */
2051 free_menubar_widget_value_tree (first_wv
);
2053 /* No selection has been chosen yet. */
2054 menu_item_selection
= 0;
2056 /* Display the menu. */
2057 lw_popup_menu (menu
, &dummy
);
2058 popup_activated_flag
= 1;
2060 /* Process events that apply to the menu. */
2061 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), menu_id
);
2063 /* fp turned off the following statement and wrote a comment
2064 that it is unnecessary--that the menu has already disappeared.
2065 Nowadays the menu disappears ok, all right, but
2066 we need to delete the widgets or multiple ones will pile up. */
2067 lw_destroy_all_widgets (menu_id
);
2069 /* Find the selected item, and its pane, to return
2070 the proper value. */
2071 if (menu_item_selection
!= 0)
2073 Lisp_Object prefix
, entry
;
2077 while (i
< menu_items_used
)
2079 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qnil
))
2081 subprefix_stack
[submenu_depth
++] = prefix
;
2085 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qlambda
))
2087 prefix
= subprefix_stack
[--submenu_depth
];
2090 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2093 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2094 i
+= MENU_ITEMS_PANE_LENGTH
;
2096 /* Ignore a nil in the item list.
2097 It's meaningful only for dialog boxes. */
2098 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2103 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2104 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2110 entry
= Fcons (entry
, Qnil
);
2112 entry
= Fcons (prefix
, entry
);
2113 for (j
= submenu_depth
- 1; j
>= 0; j
--)
2114 if (!NILP (subprefix_stack
[j
]))
2115 entry
= Fcons (subprefix_stack
[j
], entry
);
2119 i
+= MENU_ITEMS_ITEM_LENGTH
;
2128 dialog_selection_callback (widget
, id
, client_data
)
2131 XtPointer client_data
;
2133 /* The EMACS_INT cast avoids a warning. There's no problem
2134 as long as pointers have enough bits to hold small integers. */
2135 if ((int) (EMACS_INT
) client_data
!= -1)
2136 menu_item_selection
= (Lisp_Object
*) client_data
;
2138 lw_destroy_all_widgets (id
);
2140 popup_activated_flag
= 0;
2143 static char * button_names
[] = {
2144 "button1", "button2", "button3", "button4", "button5",
2145 "button6", "button7", "button8", "button9", "button10" };
2148 xdialog_show (f
, keymaps
, title
, error
)
2154 int i
, nb_buttons
=0;
2157 char dialog_name
[6];
2159 widget_value
*wv
, *save_wv
= 0, *first_wv
= 0, *prev_wv
= 0;
2161 /* Number of elements seen so far, before boundary. */
2163 /* 1 means we've seen the boundary between left-hand elts and right-hand. */
2164 int boundary_seen
= 0;
2168 if (menu_items_n_panes
> 1)
2170 *error
= "Multiple panes in dialog box";
2174 /* Create a tree of widget_value objects
2175 representing the text label and buttons. */
2177 Lisp_Object pane_name
, prefix
;
2179 pane_name
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_NAME
];
2180 prefix
= XVECTOR (menu_items
)->contents
[MENU_ITEMS_PANE_PREFIX
];
2181 pane_string
= (NILP (pane_name
)
2182 ? "" : (char *) XSTRING (pane_name
)->data
);
2183 prev_wv
= xmalloc_widget_value ();
2184 prev_wv
->value
= pane_string
;
2185 if (keymaps
&& !NILP (prefix
))
2187 prev_wv
->enabled
= 1;
2188 prev_wv
->name
= "message";
2191 /* Loop over all panes and items, filling in the tree. */
2192 i
= MENU_ITEMS_PANE_LENGTH
;
2193 while (i
< menu_items_used
)
2196 /* Create a new item within current pane. */
2197 Lisp_Object item_name
, enable
, descrip
;
2198 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2199 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2201 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2203 if (NILP (item_name
))
2205 free_menubar_widget_value_tree (first_wv
);
2206 *error
= "Submenu in dialog items";
2209 if (EQ (item_name
, Qquote
))
2211 /* This is the boundary between left-side elts
2212 and right-side elts. Stop incrementing right_count. */
2217 if (nb_buttons
>= 9)
2219 free_menubar_widget_value_tree (first_wv
);
2220 *error
= "Too many dialog items";
2224 wv
= xmalloc_widget_value ();
2226 wv
->name
= (char *) button_names
[nb_buttons
];
2227 if (!NILP (descrip
))
2228 wv
->key
= (char *) XSTRING (descrip
)->data
;
2229 wv
->value
= (char *) XSTRING (item_name
)->data
;
2230 wv
->call_data
= (void *) &XVECTOR (menu_items
)->contents
[i
];
2231 wv
->enabled
= !NILP (enable
);
2234 if (! boundary_seen
)
2238 i
+= MENU_ITEMS_ITEM_LENGTH
;
2241 /* If the boundary was not specified,
2242 by default put half on the left and half on the right. */
2243 if (! boundary_seen
)
2244 left_count
= nb_buttons
- nb_buttons
/ 2;
2246 wv
= xmalloc_widget_value ();
2247 wv
->name
= dialog_name
;
2249 /* Dialog boxes use a really stupid name encoding
2250 which specifies how many buttons to use
2251 and how many buttons are on the right.
2252 The Q means something also. */
2253 dialog_name
[0] = 'Q';
2254 dialog_name
[1] = '0' + nb_buttons
;
2255 dialog_name
[2] = 'B';
2256 dialog_name
[3] = 'R';
2257 /* Number of buttons to put on the right. */
2258 dialog_name
[4] = '0' + nb_buttons
- left_count
;
2260 wv
->contents
= first_wv
;
2264 /* Actually create the dialog. */
2265 dialog_id
= widget_id_tick
++;
2266 menu
= lw_create_widget (first_wv
->name
, "dialog", dialog_id
, first_wv
,
2267 f
->output_data
.x
->widget
, 1, 0,
2268 dialog_selection_callback
, 0);
2269 lw_modify_all_widgets (dialog_id
, first_wv
->contents
, True
);
2270 /* Free the widget_value objects we used to specify the contents. */
2271 free_menubar_widget_value_tree (first_wv
);
2273 /* No selection has been chosen yet. */
2274 menu_item_selection
= 0;
2276 /* Display the menu. */
2277 lw_pop_up_all_widgets (dialog_id
);
2278 popup_activated_flag
= 1;
2280 /* Process events that apply to the menu. */
2281 popup_get_selection ((XEvent
*) 0, FRAME_X_DISPLAY_INFO (f
), dialog_id
);
2283 lw_destroy_all_widgets (dialog_id
);
2285 /* Find the selected item, and its pane, to return
2286 the proper value. */
2287 if (menu_item_selection
!= 0)
2293 while (i
< menu_items_used
)
2297 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2300 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2301 i
+= MENU_ITEMS_PANE_LENGTH
;
2306 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2307 if (menu_item_selection
== &XVECTOR (menu_items
)->contents
[i
])
2311 entry
= Fcons (entry
, Qnil
);
2313 entry
= Fcons (prefix
, entry
);
2317 i
+= MENU_ITEMS_ITEM_LENGTH
;
2324 #else /* not USE_X_TOOLKIT */
2327 xmenu_show (f
, x
, y
, for_click
, keymaps
, title
, error
)
2337 int pane
, selidx
, lpane
, status
;
2338 Lisp_Object entry
, pane_prefix
;
2340 int ulx
, uly
, width
, height
;
2341 int dispwidth
, dispheight
;
2345 unsigned int dummy_uint
;
2348 if (menu_items_n_panes
== 0)
2351 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
2353 *error
= "Empty menu";
2357 /* Figure out which root window F is on. */
2358 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &root
,
2359 &dummy_int
, &dummy_int
, &dummy_uint
, &dummy_uint
,
2360 &dummy_uint
, &dummy_uint
);
2362 /* Make the menu on that window. */
2363 menu
= XMenuCreate (FRAME_X_DISPLAY (f
), root
, "emacs");
2366 *error
= "Can't create menu";
2370 #ifdef HAVE_X_WINDOWS
2371 /* Adjust coordinates to relative to the outer (window manager) window. */
2374 int win_x
= 0, win_y
= 0;
2376 /* Find the position of the outside upper-left corner of
2377 the inner window, with respect to the outer window. */
2378 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
2381 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
2383 /* From-window, to-window. */
2384 f
->output_data
.x
->window_desc
,
2385 f
->output_data
.x
->parent_desc
,
2387 /* From-position, to-position. */
2388 0, 0, &win_x
, &win_y
,
2390 /* Child of window. */
2397 #endif /* HAVE_X_WINDOWS */
2399 /* Adjust coordinates to be root-window-relative. */
2400 x
+= f
->output_data
.x
->left_pos
;
2401 y
+= f
->output_data
.x
->top_pos
;
2403 /* Create all the necessary panes and their items. */
2405 while (i
< menu_items_used
)
2407 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2409 /* Create a new pane. */
2410 Lisp_Object pane_name
, prefix
;
2413 pane_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_NAME
];
2414 prefix
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2415 pane_string
= (NILP (pane_name
)
2416 ? "" : (char *) XSTRING (pane_name
)->data
);
2417 if (keymaps
&& !NILP (prefix
))
2420 lpane
= XMenuAddPane (FRAME_X_DISPLAY (f
), menu
, pane_string
, TRUE
);
2421 if (lpane
== XM_FAILURE
)
2423 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2424 *error
= "Can't create pane";
2427 i
+= MENU_ITEMS_PANE_LENGTH
;
2429 /* Find the width of the widest item in this pane. */
2432 while (j
< menu_items_used
)
2435 item
= XVECTOR (menu_items
)->contents
[j
];
2443 width
= STRING_BYTES (XSTRING (item
));
2444 if (width
> maxwidth
)
2447 j
+= MENU_ITEMS_ITEM_LENGTH
;
2450 /* Ignore a nil in the item list.
2451 It's meaningful only for dialog boxes. */
2452 else if (EQ (XVECTOR (menu_items
)->contents
[i
], Qquote
))
2456 /* Create a new item within current pane. */
2457 Lisp_Object item_name
, enable
, descrip
;
2458 unsigned char *item_data
;
2460 item_name
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_NAME
];
2461 enable
= XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_ENABLE
];
2463 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_EQUIV_KEY
];
2464 if (!NILP (descrip
))
2466 int gap
= maxwidth
- STRING_BYTES (XSTRING (item_name
));
2469 spacer
= Fmake_string (make_number (gap
), make_number (' '));
2470 item_name
= concat2 (item_name
, spacer
);
2471 item_name
= concat2 (item_name
, descrip
);
2472 item_data
= XSTRING (item_name
)->data
;
2474 /* if alloca is fast, use that to make the space,
2475 to reduce gc needs. */
2477 = (unsigned char *) alloca (maxwidth
2478 + STRING_BYTES (XSTRING (descrip
)) + 1);
2479 bcopy (XSTRING (item_name
)->data
, item_data
,
2480 STRING_BYTES (XSTRING (item_name
)));
2481 for (j
= XSTRING (item_name
)->size
; j
< maxwidth
; j
++)
2483 bcopy (XSTRING (descrip
)->data
, item_data
+ j
,
2484 STRING_BYTES (XSTRING (descrip
)));
2485 item_data
[j
+ STRING_BYTES (XSTRING (descrip
))] = 0;
2489 item_data
= XSTRING (item_name
)->data
;
2491 if (XMenuAddSelection (FRAME_X_DISPLAY (f
),
2492 menu
, lpane
, 0, item_data
,
2496 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2497 *error
= "Can't add selection to menu";
2500 i
+= MENU_ITEMS_ITEM_LENGTH
;
2504 /* All set and ready to fly. */
2505 XMenuRecompute (FRAME_X_DISPLAY (f
), menu
);
2506 dispwidth
= DisplayWidth (FRAME_X_DISPLAY (f
),
2507 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2508 dispheight
= DisplayHeight (FRAME_X_DISPLAY (f
),
2509 XScreenNumberOfScreen (FRAME_X_SCREEN (f
)));
2510 x
= min (x
, dispwidth
);
2511 y
= min (y
, dispheight
);
2514 XMenuLocate (FRAME_X_DISPLAY (f
), menu
, 0, 0, x
, y
,
2515 &ulx
, &uly
, &width
, &height
);
2516 if (ulx
+width
> dispwidth
)
2518 x
-= (ulx
+ width
) - dispwidth
;
2519 ulx
= dispwidth
- width
;
2521 if (uly
+height
> dispheight
)
2523 y
-= (uly
+ height
) - dispheight
;
2524 uly
= dispheight
- height
;
2526 if (ulx
< 0) x
-= ulx
;
2527 if (uly
< 0) y
-= uly
;
2529 XMenuSetAEQ (menu
, TRUE
);
2530 XMenuSetFreeze (menu
, TRUE
);
2533 status
= XMenuActivate (FRAME_X_DISPLAY (f
), menu
, &pane
, &selidx
,
2534 x
, y
, ButtonReleaseMask
, &datap
);
2537 #ifdef HAVE_X_WINDOWS
2538 /* Assume the mouse has moved out of the X window.
2539 If it has actually moved in, we will get an EnterNotify. */
2540 x_mouse_leave (FRAME_X_DISPLAY_INFO (f
));
2547 fprintf (stderr
, "pane= %d line = %d\n", panes
, selidx
);
2550 /* Find the item number SELIDX in pane number PANE. */
2552 while (i
< menu_items_used
)
2554 if (EQ (XVECTOR (menu_items
)->contents
[i
], Qt
))
2558 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_PANE_PREFIX
];
2560 i
+= MENU_ITEMS_PANE_LENGTH
;
2569 = XVECTOR (menu_items
)->contents
[i
+ MENU_ITEMS_ITEM_VALUE
];
2572 entry
= Fcons (entry
, Qnil
);
2573 if (!NILP (pane_prefix
))
2574 entry
= Fcons (pane_prefix
, entry
);
2580 i
+= MENU_ITEMS_ITEM_LENGTH
;
2586 *error
= "Can't activate menu";
2592 XMenuDestroy (FRAME_X_DISPLAY (f
), menu
);
2594 #ifdef HAVE_X_WINDOWS
2595 /* State that no mouse buttons are now held.
2596 (The oldXMenu code doesn't track this info for us.)
2597 That is not necessarily true, but the fiction leads to reasonable
2598 results, and it is a pain to ask which are actually held now. */
2599 FRAME_X_DISPLAY_INFO (f
)->grabbed
= 0;
2605 #endif /* not USE_X_TOOLKIT */
2607 #endif /* HAVE_MENUS */
2611 staticpro (&menu_items
);
2614 Qdebug_on_next_call
= intern ("debug-on-next-call");
2615 staticpro (&Qdebug_on_next_call
);
2617 DEFVAR_LISP ("menu-updating-frame", &Vmenu_updating_frame
,
2618 "Frame for which we are updating a menu.\n\
2619 The enable predicate for a menu command should check this variable.");
2620 Vmenu_updating_frame
= Qnil
;
2622 #ifdef USE_X_TOOLKIT
2623 widget_id_tick
= (1<<16);
2624 next_menubar_widget_id
= 1;
2627 defsubr (&Sx_popup_menu
);
2629 defsubr (&Sx_popup_dialog
);