#include <config.h>
#if 0
#include <signal.h>
#endif
#include <stdio.h>
#include "lisp.h"
#include "termhooks.h"
#include "keyboard.h"
#include "keymap.h"
#include "frame.h"
#include "window.h"
#include "blockinput.h"
#include "buffer.h"
#include "charset.h"
#include "coding.h"
#include "sysselect.h"
#ifdef MSDOS
#include "msdos.h"
#endif
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#endif
#ifndef makedev
#include <sys/types.h>
#endif
#include "dispextern.h"
#ifdef HAVE_X_WINDOWS
#undef HAVE_MULTILINGUAL_MENU
#ifdef USE_X_TOOLKIT
#include "widget.h"
#include <X11/Xlib.h>
#include <X11/IntrinsicP.h>
#include <X11/CoreP.h>
#include <X11/StringDefs.h>
#include <X11/Shell.h>
#ifdef USE_LUCID
#include <X11/Xaw/Paned.h>
#endif
#include "../lwlib/lwlib.h"
#else
#ifndef USE_GTK
#include "../oldXMenu/XMenu.h"
#endif
#endif
#endif
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
Lisp_Object Qdebug_on_next_call;
extern Lisp_Object Vmenu_updating_frame;
extern Lisp_Object Qmenu_bar;
extern Lisp_Object QCtoggle, QCradio;
extern Lisp_Object Voverriding_local_map;
extern Lisp_Object Voverriding_local_map_menu_flag;
extern Lisp_Object Qoverriding_local_map, Qoverriding_terminal_local_map;
extern Lisp_Object Qmenu_bar_update_hook;
#ifdef USE_X_TOOLKIT
extern void set_frame_menubar P_ ((FRAME_PTR, int, int));
extern XtAppContext Xt_app_con;
static Lisp_Object xdialog_show P_ ((FRAME_PTR, int, Lisp_Object, Lisp_Object,
char **));
static void popup_get_selection P_ ((XEvent *, struct x_display_info *,
LWLIB_ID, int));
#define HAVE_BOXES 1
#endif
#ifdef USE_GTK
#include "gtkutil.h"
#define HAVE_BOXES 1
extern void set_frame_menubar P_ ((FRAME_PTR, int, int));
static Lisp_Object xdialog_show P_ ((FRAME_PTR, int, Lisp_Object, Lisp_Object,
char **));
#endif
#ifdef USE_GTK
# define ENCODE_MENU_STRING(str) ENCODE_UTF_8 (str)
#elif defined HAVE_X_I18N
# define ENCODE_MENU_STRING(str) ENCODE_SYSTEM (str)
#else
# define ENCODE_MENU_STRING(str) string_make_unibyte (str)
#endif
static void push_menu_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object));
static int update_frame_menubar P_ ((struct frame *));
static Lisp_Object xmenu_show P_ ((struct frame *, int, int, int, int,
Lisp_Object, char **));
static void keymap_panes P_ ((Lisp_Object *, int, int));
static void single_keymap_panes P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
int, int));
static void list_of_panes P_ ((Lisp_Object));
static void list_of_items P_ ((Lisp_Object));
#define MENU_ITEMS_PANE_NAME 1
#define MENU_ITEMS_PANE_PREFIX 2
#define MENU_ITEMS_PANE_LENGTH 3
enum menu_item_idx
{
MENU_ITEMS_ITEM_NAME = 0,
MENU_ITEMS_ITEM_ENABLE,
MENU_ITEMS_ITEM_VALUE,
MENU_ITEMS_ITEM_EQUIV_KEY,
MENU_ITEMS_ITEM_DEFINITION,
MENU_ITEMS_ITEM_TYPE,
MENU_ITEMS_ITEM_SELECTED,
MENU_ITEMS_ITEM_HELP,
MENU_ITEMS_ITEM_LENGTH
};
static Lisp_Object menu_items;
static Lisp_Object menu_items_inuse;
static int menu_items_allocated;
static int menu_items_used;
static int menu_items_n_panes;
static int menu_items_submenu_depth;
static int popup_activated_flag;
static int next_menubar_widget_id;
int pending_menu_activation;
#ifdef USE_X_TOOLKIT
static struct frame *
menubar_id_to_frame (id)
LWLIB_ID id;
{
Lisp_Object tail, frame;
FRAME_PTR f;
for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
{
frame = XCAR (tail);
if (!GC_FRAMEP (frame))
continue;
f = XFRAME (frame);
if (!FRAME_WINDOW_P (f))
continue;
if (f->output_data.x->id == id)
return f;
}
return 0;
}
#endif
static void
init_menu_items ()
{
if (!NILP (menu_items_inuse))
error ("Trying to use a menu from within a menu-entry");
if (NILP (menu_items))
{
menu_items_allocated = 60;
menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
}
menu_items_inuse = Qt;
menu_items_used = 0;
menu_items_n_panes = 0;
menu_items_submenu_depth = 0;
}
static void
finish_menu_items ()
{
}
static Lisp_Object
unuse_menu_items (dummy)
Lisp_Object dummy;
{
return menu_items_inuse = Qnil;
}
static void
discard_menu_items ()
{
if (menu_items_allocated > 200)
{
menu_items = Qnil;
menu_items_allocated = 0;
}
xassert (NILP (menu_items_inuse));
}
static Lisp_Object
restore_menu_items (saved)
Lisp_Object saved;
{
menu_items = XCAR (saved);
menu_items_inuse = (! NILP (menu_items) ? Qt : Qnil);
menu_items_allocated = (VECTORP (menu_items) ? ASIZE (menu_items) : 0);
saved = XCDR (saved);
menu_items_used = XINT (XCAR (saved));
saved = XCDR (saved);
menu_items_n_panes = XINT (XCAR (saved));
saved = XCDR (saved);
menu_items_submenu_depth = XINT (XCAR (saved));
return Qnil;
}
static void
save_menu_items ()
{
Lisp_Object saved = list4 (!NILP (menu_items_inuse) ? menu_items : Qnil,
make_number (menu_items_used),
make_number (menu_items_n_panes),
make_number (menu_items_submenu_depth));
record_unwind_protect (restore_menu_items, saved);
menu_items_inuse = Qnil;
menu_items = Qnil;
}
static void
grow_menu_items ()
{
Lisp_Object old;
int old_size = menu_items_allocated;
old = menu_items;
menu_items_allocated *= 2;
menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
bcopy (XVECTOR (old)->contents, XVECTOR (menu_items)->contents,
old_size * sizeof (Lisp_Object));
}
static void
push_submenu_start ()
{
if (menu_items_used + 1 > menu_items_allocated)
grow_menu_items ();
XVECTOR (menu_items)->contents[menu_items_used++] = Qnil;
menu_items_submenu_depth++;
}
static void
push_submenu_end ()
{
if (menu_items_used + 1 > menu_items_allocated)
grow_menu_items ();
XVECTOR (menu_items)->contents[menu_items_used++] = Qlambda;
menu_items_submenu_depth--;
}
static void
push_left_right_boundary ()
{
if (menu_items_used + 1 > menu_items_allocated)
grow_menu_items ();
XVECTOR (menu_items)->contents[menu_items_used++] = Qquote;
}
static void
push_menu_pane (name, prefix_vec)
Lisp_Object name, prefix_vec;
{
if (menu_items_used + MENU_ITEMS_PANE_LENGTH > menu_items_allocated)
grow_menu_items ();
if (menu_items_submenu_depth == 0)
menu_items_n_panes++;
XVECTOR (menu_items)->contents[menu_items_used++] = Qt;
XVECTOR (menu_items)->contents[menu_items_used++] = name;
XVECTOR (menu_items)->contents[menu_items_used++] = prefix_vec;
}
static void
push_menu_item (name, enable, key, def, equiv, type, selected, help)
Lisp_Object name, enable, key, def, equiv, type, selected, help;
{
if (menu_items_used + MENU_ITEMS_ITEM_LENGTH > menu_items_allocated)
grow_menu_items ();
XVECTOR (menu_items)->contents[menu_items_used++] = name;
XVECTOR (menu_items)->contents[menu_items_used++] = enable;
XVECTOR (menu_items)->contents[menu_items_used++] = key;
XVECTOR (menu_items)->contents[menu_items_used++] = equiv;
XVECTOR (menu_items)->contents[menu_items_used++] = def;
XVECTOR (menu_items)->contents[menu_items_used++] = type;
XVECTOR (menu_items)->contents[menu_items_used++] = selected;
XVECTOR (menu_items)->contents[menu_items_used++] = help;
}
static void
keymap_panes (keymaps, nmaps, notreal)
Lisp_Object *keymaps;
int nmaps;
int notreal;
{
int mapno;
init_menu_items ();
for (mapno = 0; mapno < nmaps; mapno++)
single_keymap_panes (keymaps[mapno],
Fkeymap_prompt (keymaps[mapno]), Qnil, notreal, 10);
finish_menu_items ();
}
struct skp
{
Lisp_Object pending_maps;
int maxdepth, notreal;
int notbuttons;
};
static void single_menu_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
void *));
static void
single_keymap_panes (keymap, pane_name, prefix, notreal, maxdepth)
Lisp_Object keymap;
Lisp_Object pane_name;
Lisp_Object prefix;
int notreal;
int maxdepth;
{
struct skp skp;
struct gcpro gcpro1;
skp.pending_maps = Qnil;
skp.maxdepth = maxdepth;
skp.notreal = notreal;
skp.notbuttons = 0;
if (maxdepth <= 0)
return;
push_menu_pane (pane_name, prefix);
#ifndef HAVE_BOXES
skp.notbuttons = menu_items_used;
#endif
GCPRO1 (skp.pending_maps);
map_keymap (keymap, single_menu_item, Qnil, &skp, 1);
UNGCPRO;
while (CONSP (skp.pending_maps))
{
Lisp_Object elt, eltcdr, string;
elt = XCAR (skp.pending_maps);
eltcdr = XCDR (elt);
string = XCAR (eltcdr);
single_keymap_panes (Fcar (elt), string,
XCDR (eltcdr), notreal, maxdepth - 1);
skp.pending_maps = XCDR (skp.pending_maps);
}
}
static void
single_menu_item (key, item, dummy, skp_v)
Lisp_Object key, item, dummy;
void *skp_v;
{
Lisp_Object map, item_string, enabled;
struct gcpro gcpro1, gcpro2;
int res;
struct skp *skp = skp_v;
GCPRO2 (key, item);
res = parse_menu_item (item, skp->notreal, 0);
UNGCPRO;
if (!res)
return;
map = XVECTOR (item_properties)->contents[ITEM_PROPERTY_MAP];
if (skp->notreal)
{
if (!NILP (map))
single_keymap_panes (map, Qnil, key, 1, skp->maxdepth - 1);
return;
}
enabled = XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE];
item_string = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
if (!NILP (map) && SREF (item_string, 0) == '@')
{
if (!NILP (enabled))
skp->pending_maps = Fcons (Fcons (map, Fcons (item_string, key)),
skp->pending_maps);
return;
}
#ifndef HAVE_BOXES
{
Lisp_Object prefix = Qnil;
Lisp_Object type = XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE];
if (!NILP (type))
{
Lisp_Object selected
= XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED];
if (skp->notbuttons)
{
int index = skp->notbuttons;
int submenu = 0;
Lisp_Object tem;
while (index < menu_items_used)
{
tem
= XVECTOR (menu_items)->contents[index + MENU_ITEMS_ITEM_NAME];
if (NILP (tem))
{
index++;
submenu++;
}
else if (EQ (tem, Qlambda))
{
index++;
submenu--;
}
else if (EQ (tem, Qt))
index += 3;
else if (EQ (tem, Qquote))
index++;
else
{
if (!submenu && SREF (tem, 0) != '\0'
&& SREF (tem, 0) != '-')
XVECTOR (menu_items)->contents[index + MENU_ITEMS_ITEM_NAME]
= concat2 (build_string (" "), tem);
index += MENU_ITEMS_ITEM_LENGTH;
}
}
skp->notbuttons = 0;
}
if (EQ (type, QCtoggle))
prefix = build_string (NILP (selected) ? "[ ] " : "[X] ");
else if (EQ (type, QCradio))
prefix = build_string (NILP (selected) ? "( ) " : "(*) ");
}
else if (!skp->notbuttons && SREF (item_string, 0) != '\0'
&& SREF (item_string, 0) != '-')
prefix = build_string (" ");
if (!NILP (prefix))
item_string = concat2 (prefix, item_string);
}
#endif
#if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
if (!NILP (map))
item_string = concat2 (item_string, build_string (" >"));
#endif
push_menu_item (item_string, enabled, key,
XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF],
XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ],
XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE],
XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED],
XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP]);
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
if (! (NILP (map) || NILP (enabled)))
{
push_submenu_start ();
single_keymap_panes (map, Qnil, key, 0, skp->maxdepth - 1);
push_submenu_end ();
}
#endif
}
static void
list_of_panes (menu)
Lisp_Object menu;
{
Lisp_Object tail;
init_menu_items ();
for (tail = menu; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object elt, pane_name, pane_data;
elt = XCAR (tail);
pane_name = Fcar (elt);
CHECK_STRING (pane_name);
push_menu_pane (ENCODE_MENU_STRING (pane_name), Qnil);
pane_data = Fcdr (elt);
CHECK_CONS (pane_data);
list_of_items (pane_data);
}
finish_menu_items ();
}
static void
list_of_items (pane)
Lisp_Object pane;
{
Lisp_Object tail, item, item1;
for (tail = pane; CONSP (tail); tail = XCDR (tail))
{
item = XCAR (tail);
if (STRINGP (item))
push_menu_item (ENCODE_MENU_STRING (item), Qnil, Qnil, Qt,
Qnil, Qnil, Qnil, Qnil);
else if (CONSP (item))
{
item1 = XCAR (item);
CHECK_STRING (item1);
push_menu_item (ENCODE_MENU_STRING (item1), Qt, XCDR (item),
Qt, Qnil, Qnil, Qnil, Qnil);
}
else
push_left_right_boundary ();
}
}
#ifdef HAVE_X_WINDOWS
static void
mouse_position_for_popup (f, x, y)
FRAME_PTR f;
int *x;
int *y;
{
Window root, dummy_window;
int dummy;
BLOCK_INPUT;
XQueryPointer (FRAME_X_DISPLAY (f),
DefaultRootWindow (FRAME_X_DISPLAY (f)),
&root,
&dummy_window,
x, y,
&dummy, &dummy,
(unsigned int *) &dummy);
UNBLOCK_INPUT;
*x -= f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
*y -= f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
}
#endif
DEFUN ("x-popup-menu", Fx_popup_menu, Sx_popup_menu, 2, 2, 0,
doc: )
(position, menu)
Lisp_Object position, menu;
{
Lisp_Object keymap, tem;
int xpos = 0, ypos = 0;
Lisp_Object title;
char *error_name = NULL;
Lisp_Object selection = Qnil;
FRAME_PTR f = NULL;
Lisp_Object x, y, window;
int keymaps = 0;
int for_click = 0;
int specpdl_count = SPECPDL_INDEX ();
struct gcpro gcpro1;
#ifdef HAVE_MENUS
if (! NILP (position))
{
int get_current_pos_p = 0;
check_x ();
if (EQ (position, Qt)
|| (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
|| EQ (XCAR (position), Qtool_bar))))
{
get_current_pos_p = 1;
}
else
{
tem = Fcar (position);
if (CONSP (tem))
{
window = Fcar (Fcdr (position));
x = XCAR (tem);
y = Fcar (XCDR (tem));
}
else
{
for_click = 1;
tem = Fcar (Fcdr (position));
window = Fcar (tem);
tem = Fcar (Fcdr (Fcdr (tem)));
x = Fcar (tem);
y = Fcdr (tem);
}
if (NILP (x) && NILP (y))
get_current_pos_p = 1;
}
if (get_current_pos_p)
{
FRAME_PTR new_f = SELECTED_FRAME ();
#ifdef HAVE_X_WINDOWS
if (new_f != 0)
{
int cur_x, cur_y;
mouse_position_for_popup (new_f, &cur_x, &cur_y);
x = make_number (cur_x);
y = make_number (cur_y);
}
#else
Lisp_Object bar_window;
enum scroll_bar_part part;
unsigned long time;
if (mouse_position_hook)
(*mouse_position_hook) (&new_f, 1, &bar_window,
&part, &x, &y, &time);
#endif
if (new_f != 0)
XSETFRAME (window, new_f);
else
{
window = selected_window;
XSETFASTINT (x, 0);
XSETFASTINT (y, 0);
}
}
CHECK_NUMBER (x);
CHECK_NUMBER (y);
if (FRAMEP (window))
{
f = XFRAME (window);
xpos = 0;
ypos = 0;
}
else if (WINDOWP (window))
{
CHECK_LIVE_WINDOW (window);
f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
xpos = WINDOW_LEFT_EDGE_X (XWINDOW (window));
ypos = WINDOW_TOP_EDGE_Y (XWINDOW (window));
}
else
CHECK_WINDOW (window);
xpos += XINT (x);
ypos += XINT (y);
XSETFRAME (Vmenu_updating_frame, f);
}
else
Vmenu_updating_frame = Qnil;
#endif
record_unwind_protect (unuse_menu_items, Qnil);
title = Qnil;
GCPRO1 (title);
keymap = get_keymap (menu, 0, 0);
if (CONSP (keymap))
{
Lisp_Object prompt;
keymap_panes (&menu, 1, NILP (position));
prompt = Fkeymap_prompt (keymap);
if (NILP (title) && !NILP (prompt))
title = prompt;
if (!NILP (prompt) && menu_items_n_panes >= 0)
XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_NAME] = prompt;
keymaps = 1;
}
else if (CONSP (menu) && KEYMAPP (XCAR (menu)))
{
int nmaps = XFASTINT (Flength (menu));
Lisp_Object *maps
= (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
int i;
title = Qnil;
for (tem = menu, i = 0; CONSP (tem); tem = XCDR (tem))
{
Lisp_Object prompt;
maps[i++] = keymap = get_keymap (XCAR (tem), 1, 0);
prompt = Fkeymap_prompt (keymap);
if (NILP (title) && !NILP (prompt))
title = prompt;
}
keymap_panes (maps, nmaps, NILP (position));
if (!NILP (title) && menu_items_n_panes >= 0)
XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_NAME] = title;
keymaps = 1;
}
else
{
title = Fcar (menu);
CHECK_STRING (title);
list_of_panes (Fcdr (menu));
keymaps = 0;
}
unbind_to (specpdl_count, Qnil);
if (NILP (position))
{
discard_menu_items ();
UNGCPRO;
return Qnil;
}
#ifdef HAVE_MENUS
BLOCK_INPUT;
selection = xmenu_show (f, xpos, ypos, for_click,
keymaps, title, &error_name);
UNBLOCK_INPUT;
discard_menu_items ();
UNGCPRO;
#endif
if (error_name) error (error_name);
return selection;
}
#ifdef HAVE_MENUS
DEFUN ("x-popup-dialog", Fx_popup_dialog, Sx_popup_dialog, 2, 3, 0,
doc: )
(position, contents, header)
Lisp_Object position, contents, header;
{
FRAME_PTR f = NULL;
Lisp_Object window;
check_x ();
if (EQ (position, Qt)
|| (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
|| EQ (XCAR (position), Qtool_bar))))
{
#if 0
FRAME_PTR new_f = SELECTED_FRAME ();
Lisp_Object bar_window;
enum scroll_bar_part part;
unsigned long time;
Lisp_Object x, y;
(*mouse_position_hook) (&new_f, 1, &bar_window, &part, &x, &y, &time);
if (new_f != 0)
XSETFRAME (window, new_f);
else
window = selected_window;
#endif
window = selected_window;
}
else if (CONSP (position))
{
Lisp_Object tem;
tem = Fcar (position);
if (CONSP (tem))
window = Fcar (Fcdr (position));
else
{
tem = Fcar (Fcdr (position));
window = Fcar (tem);
}
}
else if (WINDOWP (position) || FRAMEP (position))
window = position;
else
window = Qnil;
if (FRAMEP (window))
f = XFRAME (window);
else if (WINDOWP (window))
{
CHECK_LIVE_WINDOW (window);
f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
}
else
CHECK_WINDOW (window);
#if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
{
Lisp_Object x, y, frame, newpos;
XSETFRAME (frame, f);
XSETINT (x, x_pixel_width (f) / 2);
XSETINT (y, x_pixel_height (f) / 2);
newpos = Fcons (Fcons (x, Fcons (y, Qnil)), Fcons (frame, Qnil));
return Fx_popup_menu (newpos,
Fcons (Fcar (contents), Fcons (contents, Qnil)));
}
#else
{
Lisp_Object title;
char *error_name;
Lisp_Object selection;
int specpdl_count = SPECPDL_INDEX ();
title = Fcar (contents);
CHECK_STRING (title);
record_unwind_protect (unuse_menu_items, Qnil);
if (NILP (Fcar (Fcdr (contents))))
contents = Fcons (title, Fcons (Fcons (build_string ("Ok"), Qt), Qnil));
list_of_panes (Fcons (contents, Qnil));
BLOCK_INPUT;
selection = xdialog_show (f, 0, title, header, &error_name);
UNBLOCK_INPUT;
unbind_to (specpdl_count, Qnil);
discard_menu_items ();
if (error_name) error (error_name);
return selection;
}
#endif
}
#ifndef MSDOS
void
x_menu_set_in_use (in_use)
int in_use;
{
menu_items_inuse = in_use ? Qt : Qnil;
popup_activated_flag = in_use;
#ifdef USE_X_TOOLKIT
if (popup_activated_flag)
x_activate_timeout_atimer ();
#endif
}
void
x_menu_wait_for_event (void *data)
{
extern EMACS_TIME timer_check P_ ((int));
while (
#ifdef USE_X_TOOLKIT
! XtAppPending (Xt_app_con)
#elif defined USE_GTK
! gtk_events_pending ()
#else
! XPending ((Display*) data)
#endif
)
{
EMACS_TIME next_time = timer_check (1);
long secs = EMACS_SECS (next_time);
long usecs = EMACS_USECS (next_time);
SELECT_TYPE read_fds;
struct x_display_info *dpyinfo;
int n = 0;
FD_ZERO (&read_fds);
for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
{
int fd = ConnectionNumber (dpyinfo->display);
FD_SET (fd, &read_fds);
if (fd > n) n = fd;
}
if (secs < 0 || (secs == 0 && usecs == 0))
{
EMACS_SET_SECS (next_time, 1);
EMACS_SET_USECS (next_time, 0);
}
select (n + 1, &read_fds, (SELECT_TYPE *)0, (SELECT_TYPE *)0, &next_time);
}
}
#endif
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
#ifdef USE_X_TOOLKIT
static void
popup_get_selection (initial_event, dpyinfo, id, do_timers)
XEvent *initial_event;
struct x_display_info *dpyinfo;
LWLIB_ID id;
int do_timers;
{
XEvent event;
while (popup_activated_flag)
{
if (initial_event)
{
event = *initial_event;
initial_event = 0;
}
else
{
if (do_timers) x_menu_wait_for_event (0);
XtAppNextEvent (Xt_app_con, &event);
}
if (event.type == ButtonRelease
&& dpyinfo->display == event.xbutton.display)
{
dpyinfo->grabbed &= ~(1 << event.xbutton.button);
#ifdef USE_MOTIF
event.xbutton.button = 1;
event.xbutton.state = 0;
#endif
}
else if (event.type == KeyPress
&& dpyinfo->display == event.xbutton.display)
{
KeySym keysym = XLookupKeysym (&event.xkey, 0);
if ((keysym == XK_g && (event.xkey.state & ControlMask) != 0)
|| keysym == XK_Escape)
popup_activated_flag = 0;
}
x_dispatch_event (&event, event.xany.display);
}
}
DEFUN ("menu-bar-open", Fmenu_bar_open, Smenu_bar_open, 0, 1, "i",
doc: )
(frame)
Lisp_Object frame;
{
XEvent ev;
FRAME_PTR f = check_x_frame (frame);
Widget menubar;
BLOCK_INPUT;
if (FRAME_EXTERNAL_MENU_BAR (f))
set_frame_menubar (f, 0, 1);
menubar = FRAME_X_OUTPUT (f)->menubar_widget;
if (menubar)
{
Window child;
int error_p = 0;
x_catch_errors (FRAME_X_DISPLAY (f));
memset (&ev, 0, sizeof ev);
ev.xbutton.display = FRAME_X_DISPLAY (f);
ev.xbutton.window = XtWindow (menubar);
ev.xbutton.root = FRAME_X_DISPLAY_INFO (f)->root_window;
ev.xbutton.time = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
ev.xbutton.button = Button1;
ev.xbutton.x = ev.xbutton.y = FRAME_MENUBAR_HEIGHT (f) / 2;
ev.xbutton.same_screen = True;
#ifdef USE_MOTIF
{
Arg al[2];
WidgetList list;
Cardinal nr;
XtSetArg (al[0], XtNchildren, &list);
XtSetArg (al[1], XtNnumChildren, &nr);
XtGetValues (menubar, al, 2);
ev.xbutton.window = XtWindow (list[0]);
}
#endif
XTranslateCoordinates (FRAME_X_DISPLAY (f),
ev.xbutton.window, ev.xbutton.root,
ev.xbutton.x, ev.xbutton.y,
&ev.xbutton.x_root, &ev.xbutton.y_root,
&child);
error_p = x_had_errors_p (FRAME_X_DISPLAY (f));
x_uncatch_errors ();
if (! error_p)
{
ev.type = ButtonPress;
ev.xbutton.state = 0;
XtDispatchEvent (&ev);
ev.xbutton.type = ButtonRelease;
ev.xbutton.state = Button1Mask;
XtDispatchEvent (&ev);
}
}
UNBLOCK_INPUT;
return Qnil;
}
#endif
#ifdef USE_GTK
DEFUN ("menu-bar-open", Fmenu_bar_open, Smenu_bar_open, 0, 1, "i",
doc: )
(frame)
Lisp_Object frame;
{
GtkWidget *menubar;
FRAME_PTR f;
BLOCK_INPUT;
f = check_x_frame (frame);
if (FRAME_EXTERNAL_MENU_BAR (f))
set_frame_menubar (f, 0, 1);
menubar = FRAME_X_OUTPUT (f)->menubar_widget;
if (menubar)
{
GList *children = gtk_container_get_children (GTK_CONTAINER (menubar));
gtk_menu_shell_select_item (GTK_MENU_SHELL (menubar),
GTK_WIDGET (children->data));
popup_activated_flag = 1;
g_list_free (children);
}
UNBLOCK_INPUT;
return Qnil;
}
static void
popup_widget_loop (do_timers, widget)
int do_timers;
GtkWidget *widget;
{
++popup_activated_flag;
while (popup_activated_flag)
{
if (do_timers) x_menu_wait_for_event (0);
gtk_main_iteration ();
}
}
#endif
void
x_activate_menubar (f)
FRAME_PTR f;
{
if (!f->output_data.x->saved_menu_event->type)
return;
#ifdef USE_GTK
if (! xg_win_to_widget (FRAME_X_DISPLAY (f),
f->output_data.x->saved_menu_event->xany.window))
return;
#endif
set_frame_menubar (f, 0, 1);
BLOCK_INPUT;
#ifdef USE_GTK
XPutBackEvent (f->output_data.x->display_info->display,
f->output_data.x->saved_menu_event);
popup_activated_flag = 1;
#else
XtDispatchEvent (f->output_data.x->saved_menu_event);
#endif
UNBLOCK_INPUT;
#ifdef USE_MOTIF
if (f->output_data.x->saved_menu_event->type == ButtonRelease)
pending_menu_activation = 1;
#endif
f->output_data.x->saved_menu_event->type = 0;
}
#ifndef USE_GTK
static void
popup_activate_callback (widget, id, client_data)
Widget widget;
LWLIB_ID id;
XtPointer client_data;
{
popup_activated_flag = 1;
#ifdef USE_X_TOOLKIT
x_activate_timeout_atimer ();
#endif
}
#endif
#ifdef USE_GTK
static void
popup_deactivate_callback (widget, client_data)
GtkWidget *widget;
gpointer client_data;
{
popup_activated_flag = 0;
}
#else
static void
popup_deactivate_callback (widget, id, client_data)
Widget widget;
LWLIB_ID id;
XtPointer client_data;
{
popup_activated_flag = 0;
}
#endif
static void
show_help_event (f, widget, help)
FRAME_PTR f;
xt_or_gtk_widget widget;
Lisp_Object help;
{
Lisp_Object frame;
if (f)
{
XSETFRAME (frame, f);
kbd_buffer_store_help_event (frame, help);
}
else
{
#if 0
xt_or_gtk_widget frame_widget = XtParent (widget);
Lisp_Object tail;
for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
{
frame = XCAR (tail);
if (GC_FRAMEP (frame)
&& (f = XFRAME (frame),
FRAME_X_P (f) && f->output_data.x->widget == frame_widget))
break;
}
#endif
show_help_echo (help, Qnil, Qnil, Qnil, 1);
}
}
#ifdef USE_GTK
void
menu_highlight_callback (widget, call_data)
GtkWidget *widget;
gpointer call_data;
{
xg_menu_item_cb_data *cb_data;
Lisp_Object help;
cb_data = (xg_menu_item_cb_data*) g_object_get_data (G_OBJECT (widget),
XG_ITEM_DATA);
if (! cb_data) return;
help = call_data ? cb_data->help : Qnil;
if (popup_activated_flag <= 1)
show_help_event (cb_data->cl_data->f, widget, help);
}
#else
void
menu_highlight_callback (widget, id, call_data)
Widget widget;
LWLIB_ID id;
void *call_data;
{
struct frame *f;
Lisp_Object help;
widget_value *wv = (widget_value *) call_data;
help = wv ? wv->help : Qnil;
f = menubar_id_to_frame (id);
show_help_event (f, widget, help);
}
#endif
static void
find_and_call_menu_selection (f, menu_bar_items_used, vector, client_data)
FRAME_PTR f;
int menu_bar_items_used;
Lisp_Object vector;
void *client_data;
{
Lisp_Object prefix, entry;
Lisp_Object *subprefix_stack;
int submenu_depth = 0;
int i;
entry = Qnil;
subprefix_stack = (Lisp_Object *) alloca (menu_bar_items_used * sizeof (Lisp_Object));
prefix = Qnil;
i = 0;
while (i < menu_bar_items_used)
{
if (EQ (XVECTOR (vector)->contents[i], Qnil))
{
subprefix_stack[submenu_depth++] = prefix;
prefix = entry;
i++;
}
else if (EQ (XVECTOR (vector)->contents[i], Qlambda))
{
prefix = subprefix_stack[--submenu_depth];
i++;
}
else if (EQ (XVECTOR (vector)->contents[i], Qt))
{
prefix = XVECTOR (vector)->contents[i + MENU_ITEMS_PANE_PREFIX];
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
entry = XVECTOR (vector)->contents[i + MENU_ITEMS_ITEM_VALUE];
if ((int) (EMACS_INT) client_data == i)
{
int j;
struct input_event buf;
Lisp_Object frame;
EVENT_INIT (buf);
XSETFRAME (frame, f);
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = frame;
kbd_buffer_store_event (&buf);
for (j = 0; j < submenu_depth; j++)
if (!NILP (subprefix_stack[j]))
{
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = subprefix_stack[j];
kbd_buffer_store_event (&buf);
}
if (!NILP (prefix))
{
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = prefix;
kbd_buffer_store_event (&buf);
}
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = entry;
kbd_buffer_store_event (&buf);
return;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
}
#ifdef USE_GTK
static int xg_crazy_callback_abort;
static void
menubar_selection_callback (widget, client_data)
GtkWidget *widget;
gpointer client_data;
{
xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
if (xg_crazy_callback_abort)
return;
if (! cb_data || ! cb_data->cl_data || ! cb_data->cl_data->f)
return;
if (GTK_IS_RADIO_MENU_ITEM (widget)
&& ! gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
return;
BLOCK_INPUT;
while (gtk_events_pending ())
gtk_main_iteration ();
UNBLOCK_INPUT;
find_and_call_menu_selection (cb_data->cl_data->f,
cb_data->cl_data->menu_bar_items_used,
cb_data->cl_data->menu_bar_vector,
cb_data->call_data);
}
#else
static void
menubar_selection_callback (widget, id, client_data)
Widget widget;
LWLIB_ID id;
XtPointer client_data;
{
FRAME_PTR f;
f = menubar_id_to_frame (id);
if (!f)
return;
find_and_call_menu_selection (f, f->menu_bar_items_used,
f->menu_bar_vector, client_data);
}
#endif
widget_value *
xmalloc_widget_value ()
{
widget_value *value;
BLOCK_INPUT;
value = malloc_widget_value ();
UNBLOCK_INPUT;
return value;
}
void
free_menubar_widget_value_tree (wv)
widget_value *wv;
{
if (! wv) return;
wv->name = wv->value = wv->key = (char *) 0xDEADBEEF;
if (wv->contents && (wv->contents != (widget_value*)1))
{
free_menubar_widget_value_tree (wv->contents);
wv->contents = (widget_value *) 0xDEADBEEF;
}
if (wv->next)
{
free_menubar_widget_value_tree (wv->next);
wv->next = (widget_value *) 0xDEADBEEF;
}
BLOCK_INPUT;
free_widget_value (wv);
UNBLOCK_INPUT;
}
static int
parse_single_submenu (item_key, item_name, maps)
Lisp_Object item_key, item_name, maps;
{
Lisp_Object length;
int len;
Lisp_Object *mapvec;
int i;
int top_level_items = 0;
length = Flength (maps);
len = XINT (length);
mapvec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
for (i = 0; i < len; i++)
{
mapvec[i] = Fcar (maps);
maps = Fcdr (maps);
}
for (i = 0; i < len; i++)
{
if (!KEYMAPP (mapvec[i]))
{
top_level_items = 1;
push_menu_pane (Qnil, Qnil);
push_menu_item (item_name, Qt, item_key, mapvec[i],
Qnil, Qnil, Qnil, Qnil);
}
else
{
Lisp_Object prompt;
prompt = Fkeymap_prompt (mapvec[i]);
single_keymap_panes (mapvec[i],
!NILP (prompt) ? prompt : item_name,
item_key, 0, 10);
}
}
return top_level_items;
}
static widget_value *
digest_single_submenu (start, end, top_level_items)
int start, end, top_level_items;
{
widget_value *wv, *prev_wv, *save_wv, *first_wv;
int i;
int submenu_depth = 0;
widget_value **submenu_stack;
int panes_seen = 0;
submenu_stack
= (widget_value **) alloca (menu_items_used * sizeof (widget_value *));
wv = xmalloc_widget_value ();
wv->name = "menu";
wv->value = 0;
wv->enabled = 1;
wv->button_type = BUTTON_TYPE_NONE;
wv->help = Qnil;
first_wv = wv;
save_wv = 0;
prev_wv = 0;
i = start;
while (i < end)
{
if (EQ (XVECTOR (menu_items)->contents[i], Qnil))
{
submenu_stack[submenu_depth++] = save_wv;
save_wv = prev_wv;
prev_wv = 0;
i++;
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qlambda))
{
prev_wv = save_wv;
save_wv = submenu_stack[--submenu_depth];
i++;
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qt)
&& submenu_depth != 0)
i += MENU_ITEMS_PANE_LENGTH;
else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
i += 1;
else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
{
Lisp_Object pane_name, prefix;
char *pane_string;
panes_seen++;
pane_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_NAME];
prefix = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
#ifndef HAVE_MULTILINGUAL_MENU
if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
{
pane_name = ENCODE_MENU_STRING (pane_name);
AREF (menu_items, i + MENU_ITEMS_PANE_NAME) = pane_name;
}
#endif
pane_string = (NILP (pane_name)
? "" : (char *) SDATA (pane_name));
if (menu_items_n_panes == 1)
pane_string = "";
if (strcmp (pane_string, ""))
{
wv = xmalloc_widget_value ();
if (save_wv)
save_wv->next = wv;
else
first_wv->contents = wv;
wv->lname = pane_name;
wv->value = (char *)1;
wv->enabled = 1;
wv->button_type = BUTTON_TYPE_NONE;
wv->help = Qnil;
save_wv = wv;
}
else
save_wv = first_wv;
prev_wv = 0;
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
Lisp_Object item_name, enable, descrip, def, type, selected;
Lisp_Object help;
if (panes_seen == 0)
abort ();
item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);
type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);
selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
#ifndef HAVE_MULTILINGUAL_MENU
if (STRING_MULTIBYTE (item_name))
{
item_name = ENCODE_MENU_STRING (item_name);
AREF (menu_items, i + MENU_ITEMS_ITEM_NAME) = item_name;
}
if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
{
descrip = ENCODE_MENU_STRING (descrip);
AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY) = descrip;
}
#endif
wv = xmalloc_widget_value ();
if (prev_wv)
prev_wv->next = wv;
else
save_wv->contents = wv;
wv->lname = item_name;
if (!NILP (descrip))
wv->lkey = descrip;
wv->value = 0;
wv->call_data = (!NILP (def) ? (void *) (EMACS_INT) i : 0);
wv->enabled = !NILP (enable);
if (NILP (type))
wv->button_type = BUTTON_TYPE_NONE;
else if (EQ (type, QCradio))
wv->button_type = BUTTON_TYPE_RADIO;
else if (EQ (type, QCtoggle))
wv->button_type = BUTTON_TYPE_TOGGLE;
else
abort ();
wv->selected = !NILP (selected);
if (! STRINGP (help))
help = Qnil;
wv->help = help;
prev_wv = wv;
i += MENU_ITEMS_ITEM_LENGTH;
}
}
if (top_level_items && first_wv->contents && first_wv->contents->next == 0)
{
wv = first_wv->contents;
free_widget_value (first_wv);
return wv;
}
return first_wv;
}
static void
update_submenu_strings (first_wv)
widget_value *first_wv;
{
widget_value *wv;
for (wv = first_wv; wv; wv = wv->next)
{
if (STRINGP (wv->lname))
{
wv->name = (char *) SDATA (wv->lname);
if (wv->value == (char *)1)
{
if (wv->name[0] == '@')
wv->name++;
wv->value = 0;
}
}
if (STRINGP (wv->lkey))
wv->key = (char *) SDATA (wv->lkey);
if (wv->contents)
update_submenu_strings (wv->contents);
}
}
static int
update_frame_menubar (f)
FRAME_PTR f;
{
#ifdef USE_GTK
return xg_update_frame_menubar (f);
#else
struct x_output *x = f->output_data.x;
int columns, rows;
if (!x->menubar_widget || XtIsManaged (x->menubar_widget))
return 0;
BLOCK_INPUT;
columns = FRAME_COLS (f);
rows = FRAME_LINES (f);
lw_refigure_widget (x->column_widget, False);
XtUnmanageChild (x->edit_widget);
XtManageChild (x->menubar_widget);
XtMapWidget (x->menubar_widget);
XtVaSetValues (x->menubar_widget, XtNmappedWhenManaged, 1, NULL);
XtManageChild (x->edit_widget);
lw_refigure_widget (x->column_widget, True);
EmacsFrameSetCharSize (x->edit_widget, columns, rows);
UNBLOCK_INPUT;
#endif
return 1;
}
void
set_frame_menubar (f, first_time, deep_p)
FRAME_PTR f;
int first_time;
int deep_p;
{
xt_or_gtk_widget menubar_widget = f->output_data.x->menubar_widget;
#ifdef USE_X_TOOLKIT
LWLIB_ID id;
#endif
Lisp_Object items;
widget_value *wv, *first_wv, *prev_wv = 0;
int i, last_i = 0;
int *submenu_start, *submenu_end;
int *submenu_top_level_items, *submenu_n_panes;
XSETFRAME (Vmenu_updating_frame, f);
#ifdef USE_X_TOOLKIT
if (f->output_data.x->id == 0)
f->output_data.x->id = next_menubar_widget_id++;
id = f->output_data.x->id;
#endif
if (! menubar_widget)
deep_p = 1;
else if (pending_menu_activation && !deep_p)
deep_p = 1;
else if (!f->output_data.x->saved_menu_event && !deep_p)
{
deep_p = 1;
f->output_data.x->saved_menu_event = (XEvent*)xmalloc (sizeof (XEvent));
f->output_data.x->saved_menu_event->type = 0;
}
#ifdef USE_GTK
deep_p = deep_p || xg_have_tear_offs ();
#endif
if (deep_p)
{
struct buffer *prev = current_buffer;
Lisp_Object buffer;
int specpdl_count = SPECPDL_INDEX ();
int previous_menu_items_used = f->menu_bar_items_used;
Lisp_Object *previous_items
= (Lisp_Object *) alloca (previous_menu_items_used
* sizeof (Lisp_Object));
if (! menubar_widget)
previous_menu_items_used = 0;
buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer;
specbind (Qinhibit_quit, Qt);
specbind (Qdebug_on_next_call, Qnil);
record_unwind_save_match_data ();
if (NILP (Voverriding_local_map_menu_flag))
{
specbind (Qoverriding_terminal_local_map, Qnil);
specbind (Qoverriding_local_map, Qnil);
}
set_buffer_internal_1 (XBUFFER (buffer));
safe_run_hooks (Qactivate_menubar_hook);
if (! NILP (Vlucid_menu_bar_dirty_flag))
call0 (Qrecompute_lucid_menubar);
safe_run_hooks (Qmenu_bar_update_hook);
FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
items = FRAME_MENU_BAR_ITEMS (f);
if (previous_menu_items_used)
bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
previous_menu_items_used * sizeof (Lisp_Object));
save_menu_items ();
menu_items = f->menu_bar_vector;
menu_items_allocated = VECTORP (menu_items) ? ASIZE (menu_items) : 0;
submenu_start = (int *) alloca (XVECTOR (items)->size * sizeof (int *));
submenu_end = (int *) alloca (XVECTOR (items)->size * sizeof (int *));
submenu_n_panes = (int *) alloca (XVECTOR (items)->size * sizeof (int));
submenu_top_level_items
= (int *) alloca (XVECTOR (items)->size * sizeof (int *));
init_menu_items ();
for (i = 0; i < XVECTOR (items)->size; i += 4)
{
Lisp_Object key, string, maps;
last_i = i;
key = XVECTOR (items)->contents[i];
string = XVECTOR (items)->contents[i + 1];
maps = XVECTOR (items)->contents[i + 2];
if (NILP (string))
break;
submenu_start[i] = menu_items_used;
menu_items_n_panes = 0;
submenu_top_level_items[i]
= parse_single_submenu (key, string, maps);
submenu_n_panes[i] = menu_items_n_panes;
submenu_end[i] = menu_items_used;
}
finish_menu_items ();
wv = xmalloc_widget_value ();
wv->name = "menubar";
wv->value = 0;
wv->enabled = 1;
wv->button_type = BUTTON_TYPE_NONE;
wv->help = Qnil;
first_wv = wv;
for (i = 0; i < last_i; i += 4)
{
menu_items_n_panes = submenu_n_panes[i];
wv = digest_single_submenu (submenu_start[i], submenu_end[i],
submenu_top_level_items[i]);
if (prev_wv)
prev_wv->next = wv;
else
first_wv->contents = wv;
wv->enabled = 1;
wv->button_type = BUTTON_TYPE_NONE;
prev_wv = wv;
}
set_buffer_internal_1 (prev);
for (i = 0; i < previous_menu_items_used; i++)
if (menu_items_used == i
|| (!EQ (previous_items[i], XVECTOR (menu_items)->contents[i])))
break;
if (i == menu_items_used && i == previous_menu_items_used && i != 0)
{
free_menubar_widget_value_tree (first_wv);
discard_menu_items ();
unbind_to (specpdl_count, Qnil);
return;
}
f->menu_bar_vector = menu_items;
f->menu_bar_items_used = menu_items_used;
unbind_to (specpdl_count, Qnil);
wv = first_wv->contents;
for (i = 0; i < XVECTOR (items)->size; i += 4)
{
Lisp_Object string;
string = XVECTOR (items)->contents[i + 1];
if (NILP (string))
break;
wv->name = (char *) SDATA (string);
update_submenu_strings (wv->contents);
wv = wv->next;
}
}
else
{
wv = xmalloc_widget_value ();
wv->name = "menubar";
wv->value = 0;
wv->enabled = 1;
wv->button_type = BUTTON_TYPE_NONE;
wv->help = Qnil;
first_wv = wv;
items = FRAME_MENU_BAR_ITEMS (f);
for (i = 0; i < XVECTOR (items)->size; i += 4)
{
Lisp_Object string;
string = XVECTOR (items)->contents[i + 1];
if (NILP (string))
break;
wv = xmalloc_widget_value ();
wv->name = (char *) SDATA (string);
wv->value = 0;
wv->enabled = 1;
wv->button_type = BUTTON_TYPE_NONE;
wv->help = Qnil;
wv->call_data = (void *) (EMACS_INT) (-1);
if (prev_wv)
prev_wv->next = wv;
else
first_wv->contents = wv;
prev_wv = wv;
}
f->menu_bar_items_used = 0;
}
BLOCK_INPUT;
#ifdef USE_GTK
xg_crazy_callback_abort = 1;
if (menubar_widget)
{
xg_modify_menubar_widgets (menubar_widget,
f,
first_wv,
deep_p,
G_CALLBACK (menubar_selection_callback),
G_CALLBACK (popup_deactivate_callback),
G_CALLBACK (menu_highlight_callback));
}
else
{
GtkWidget *wvbox = f->output_data.x->vbox_widget;
menubar_widget
= xg_create_widget ("menubar", "menubar", f, first_wv,
G_CALLBACK (menubar_selection_callback),
G_CALLBACK (popup_deactivate_callback),
G_CALLBACK (menu_highlight_callback));
f->output_data.x->menubar_widget = menubar_widget;
}
#else
if (menubar_widget)
{
lw_allow_resizing (f->output_data.x->widget, False);
lw_modify_all_widgets (id, first_wv, deep_p);
lw_allow_resizing (f->output_data.x->widget, True);
}
else
{
char menuOverride[] = "Ctrl<KeyPress>g: MenuGadgetEscape()";
XtTranslations override = XtParseTranslationTable (menuOverride);
menubar_widget = lw_create_widget ("menubar", "menubar", id, first_wv,
f->output_data.x->column_widget,
0,
popup_activate_callback,
menubar_selection_callback,
popup_deactivate_callback,
menu_highlight_callback);
f->output_data.x->menubar_widget = menubar_widget;
XtOverrideTranslations (menubar_widget, override);
}
{
int menubar_size
= (f->output_data.x->menubar_widget
? (f->output_data.x->menubar_widget->core.height
+ f->output_data.x->menubar_widget->core.border_width)
: 0);
#if 0
#ifdef USE_LUCID
if (FRAME_EXTERNAL_MENU_BAR (f))
{
Dimension ibw = 0;
XtVaGetValues (f->output_data.x->column_widget,
XtNinternalBorderWidth, &ibw, NULL);
menubar_size += ibw;
}
#endif
#endif
f->output_data.x->menubar_height = menubar_size;
}
#endif
free_menubar_widget_value_tree (first_wv);
update_frame_menubar (f);
#ifdef USE_GTK
xg_crazy_callback_abort = 0;
#endif
UNBLOCK_INPUT;
}
void
initialize_frame_menubar (f)
FRAME_PTR f;
{
FRAME_MENU_BAR_ITEMS (f) = menu_bar_items (FRAME_MENU_BAR_ITEMS (f));
set_frame_menubar (f, 1, 1);
}
#ifndef USE_GTK
void
free_frame_menubar (f)
FRAME_PTR f;
{
Widget menubar_widget;
menubar_widget = f->output_data.x->menubar_widget;
f->output_data.x->menubar_height = 0;
if (menubar_widget)
{
#ifdef USE_MOTIF
Position x0, y0, x1, y1;
#endif
BLOCK_INPUT;
#ifdef USE_MOTIF
if (f->output_data.x->widget)
XtVaGetValues (f->output_data.x->widget, XtNx, &x0, XtNy, &y0, NULL);
#endif
lw_destroy_all_widgets ((LWLIB_ID) f->output_data.x->id);
f->output_data.x->menubar_widget = NULL;
#ifdef USE_MOTIF
if (f->output_data.x->widget)
{
XtVaGetValues (f->output_data.x->widget, XtNx, &x1, XtNy, &y1, NULL);
if (x1 == 0 && y1 == 0)
XtVaSetValues (f->output_data.x->widget, XtNx, x0, XtNy, y0, NULL);
}
#endif
UNBLOCK_INPUT;
}
}
#endif
#endif
#if defined (USE_X_TOOLKIT) || defined (USE_GTK)
static Lisp_Object *volatile menu_item_selection;
#ifdef USE_GTK
struct next_popup_x_y
{
FRAME_PTR f;
int x;
int y;
};
static void
menu_position_func (menu, x, y, push_in, user_data)
GtkMenu *menu;
gint *x;
gint *y;
gboolean *push_in;
gpointer user_data;
{
struct next_popup_x_y* data = (struct next_popup_x_y*)user_data;
GtkRequisition req;
int disp_width = FRAME_X_DISPLAY_INFO (data->f)->width;
int disp_height = FRAME_X_DISPLAY_INFO (data->f)->height;
*x = data->x;
*y = data->y;
gtk_widget_size_request (GTK_WIDGET (menu), &req);
if (data->x + req.width > disp_width)
*x -= data->x + req.width - disp_width;
if (data->y + req.height > disp_height)
*y -= data->y + req.height - disp_height;
}
static void
popup_selection_callback (widget, client_data)
GtkWidget *widget;
gpointer client_data;
{
xg_menu_item_cb_data *cb_data = (xg_menu_item_cb_data*) client_data;
if (xg_crazy_callback_abort) return;
if (cb_data) menu_item_selection = (Lisp_Object *) cb_data->call_data;
}
static Lisp_Object
pop_down_menu (arg)
Lisp_Object arg;
{
struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
popup_activated_flag = 0;
BLOCK_INPUT;
gtk_widget_destroy (GTK_WIDGET (p->pointer));
UNBLOCK_INPUT;
return Qnil;
}
static void
create_and_show_popup_menu (f, first_wv, x, y, for_click)
FRAME_PTR f;
widget_value *first_wv;
int x;
int y;
int for_click;
{
int i;
GtkWidget *menu;
GtkMenuPositionFunc pos_func = 0;
struct next_popup_x_y popup_x_y;
int specpdl_count = SPECPDL_INDEX ();
xg_crazy_callback_abort = 1;
menu = xg_create_widget ("popup", first_wv->name, f, first_wv,
G_CALLBACK (popup_selection_callback),
G_CALLBACK (popup_deactivate_callback),
G_CALLBACK (menu_highlight_callback));
xg_crazy_callback_abort = 0;
if (! for_click)
{
pos_func = menu_position_func;
x += f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
y += f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
popup_x_y.x = x;
popup_x_y.y = y;
popup_x_y.f = f;
i = 0;
}
else
{
for (i = 0; i < 5; i++)
if (FRAME_X_DISPLAY_INFO (f)->grabbed & (1 << i))
break;
}
gtk_widget_show_all (menu);
gtk_menu_popup (GTK_MENU (menu), 0, 0, pos_func, &popup_x_y, i, 0);
record_unwind_protect (pop_down_menu, make_save_value (menu, 0));
if (GTK_WIDGET_MAPPED (menu))
{
popup_activated_flag = 1;
popup_widget_loop (1, menu);
}
unbind_to (specpdl_count, Qnil);
FRAME_X_DISPLAY_INFO (f)->grabbed = 0;
}
#else
LWLIB_ID widget_id_tick;
static void
popup_selection_callback (widget, id, client_data)
Widget widget;
LWLIB_ID id;
XtPointer client_data;
{
menu_item_selection = (Lisp_Object *) client_data;
}
static Lisp_Object
pop_down_menu (arg)
Lisp_Object arg;
{
LWLIB_ID id = (XINT (XCAR (arg)) << 4 * sizeof (LWLIB_ID)
| XINT (XCDR (arg)));
BLOCK_INPUT;
lw_destroy_all_widgets (id);
UNBLOCK_INPUT;
popup_activated_flag = 0;
return Qnil;
}
static void
create_and_show_popup_menu (f, first_wv, x, y, for_click)
FRAME_PTR f;
widget_value *first_wv;
int x;
int y;
int for_click;
{
int i;
Arg av[2];
int ac = 0;
XButtonPressedEvent dummy;
LWLIB_ID menu_id;
Widget menu;
menu_id = widget_id_tick++;
menu = lw_create_widget ("popup", first_wv->name, menu_id, first_wv,
f->output_data.x->widget, 1, 0,
popup_selection_callback,
popup_deactivate_callback,
menu_highlight_callback);
dummy.type = ButtonPress;
dummy.serial = 0;
dummy.send_event = 0;
dummy.display = FRAME_X_DISPLAY (f);
dummy.time = CurrentTime;
dummy.root = FRAME_X_DISPLAY_INFO (f)->root_window;
dummy.window = dummy.root;
dummy.subwindow = dummy.root;
dummy.x = x;
dummy.y = y;
x += f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
y += f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
dummy.x_root = x;
dummy.y_root = y;
dummy.state = 0;
dummy.button = 0;
for (i = 0; i < 5; i++)
if (FRAME_X_DISPLAY_INFO (f)->grabbed & (1 << i))
dummy.button = i;
XtSetArg (av[ac], XtNgeometry, 0); ac++;
XtSetValues (menu, av, ac);
lw_popup_menu (menu, (XEvent *) &dummy);
popup_activated_flag = 1;
x_activate_timeout_atimer ();
{
int fact = 4 * sizeof (LWLIB_ID);
int specpdl_count = SPECPDL_INDEX ();
record_unwind_protect (pop_down_menu,
Fcons (make_number (menu_id >> (fact)),
make_number (menu_id & ~(-1 << (fact)))));
popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f), menu_id, 1);
unbind_to (specpdl_count, Qnil);
}
}
#endif
static Lisp_Object
xmenu_show (f, x, y, for_click, keymaps, title, error)
FRAME_PTR f;
int x;
int y;
int for_click;
int keymaps;
Lisp_Object title;
char **error;
{
int i;
widget_value *wv, *save_wv = 0, *first_wv = 0, *prev_wv = 0;
widget_value **submenu_stack
= (widget_value **) alloca (menu_items_used * sizeof (widget_value *));
Lisp_Object *subprefix_stack
= (Lisp_Object *) alloca (menu_items_used * sizeof (Lisp_Object));
int submenu_depth = 0;
int first_pane;
*error = NULL;
if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)
{
*error = "Empty menu";
return Qnil;
}
wv = xmalloc_widget_value ();
wv->name = "menu";
wv->value = 0;
wv->enabled = 1;
wv->button_type = BUTTON_TYPE_NONE;
wv->help =Qnil;
first_wv = wv;
first_pane = 1;
i = 0;
while (i < menu_items_used)
{
if (EQ (XVECTOR (menu_items)->contents[i], Qnil))
{
submenu_stack[submenu_depth++] = save_wv;
save_wv = prev_wv;
prev_wv = 0;
first_pane = 1;
i++;
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qlambda))
{
prev_wv = save_wv;
save_wv = submenu_stack[--submenu_depth];
first_pane = 0;
i++;
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qt)
&& submenu_depth != 0)
i += MENU_ITEMS_PANE_LENGTH;
else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
i += 1;
else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
{
Lisp_Object pane_name, prefix;
char *pane_string;
pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
#ifndef HAVE_MULTILINGUAL_MENU
if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
{
pane_name = ENCODE_MENU_STRING (pane_name);
AREF (menu_items, i + MENU_ITEMS_PANE_NAME) = pane_name;
}
#endif
pane_string = (NILP (pane_name)
? "" : (char *) SDATA (pane_name));
if (menu_items_n_panes == 1)
pane_string = "";
if (!keymaps && strcmp (pane_string, ""))
{
wv = xmalloc_widget_value ();
if (save_wv)
save_wv->next = wv;
else
first_wv->contents = wv;
wv->name = pane_string;
if (keymaps && !NILP (prefix))
wv->name++;
wv->value = 0;
wv->enabled = 1;
wv->button_type = BUTTON_TYPE_NONE;
wv->help = Qnil;
save_wv = wv;
prev_wv = 0;
}
else if (first_pane)
{
save_wv = wv;
prev_wv = 0;
}
first_pane = 0;
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
Lisp_Object item_name, enable, descrip, def, type, selected, help;
item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);
enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);
descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);
def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);
type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);
selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
#ifndef HAVE_MULTILINGUAL_MENU
if (STRINGP (item_name) && STRING_MULTIBYTE (item_name))
{
item_name = ENCODE_MENU_STRING (item_name);
AREF (menu_items, i + MENU_ITEMS_ITEM_NAME) = item_name;
}
if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
{
descrip = ENCODE_MENU_STRING (descrip);
AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY) = descrip;
}
#endif
wv = xmalloc_widget_value ();
if (prev_wv)
prev_wv->next = wv;
else
save_wv->contents = wv;
wv->name = (char *) SDATA (item_name);
if (!NILP (descrip))
wv->key = (char *) SDATA (descrip);
wv->value = 0;
wv->call_data
= (!NILP (def) ? (void *) &XVECTOR (menu_items)->contents[i] : 0);
wv->enabled = !NILP (enable);
if (NILP (type))
wv->button_type = BUTTON_TYPE_NONE;
else if (EQ (type, QCtoggle))
wv->button_type = BUTTON_TYPE_TOGGLE;
else if (EQ (type, QCradio))
wv->button_type = BUTTON_TYPE_RADIO;
else
abort ();
wv->selected = !NILP (selected);
if (! STRINGP (help))
help = Qnil;
wv->help = help;
prev_wv = wv;
i += MENU_ITEMS_ITEM_LENGTH;
}
}
if (!NILP (title))
{
widget_value *wv_title = xmalloc_widget_value ();
widget_value *wv_sep1 = xmalloc_widget_value ();
widget_value *wv_sep2 = xmalloc_widget_value ();
wv_sep2->name = "--";
wv_sep2->next = first_wv->contents;
wv_sep2->help = Qnil;
wv_sep1->name = "--";
wv_sep1->next = wv_sep2;
wv_sep1->help = Qnil;
#ifndef HAVE_MULTILINGUAL_MENU
if (STRING_MULTIBYTE (title))
title = ENCODE_MENU_STRING (title);
#endif
wv_title->name = (char *) SDATA (title);
wv_title->enabled = TRUE;
wv_title->button_type = BUTTON_TYPE_NONE;
wv_title->next = wv_sep1;
wv_title->help = Qnil;
first_wv->contents = wv_title;
}
menu_item_selection = 0;
create_and_show_popup_menu (f, first_wv, x, y, for_click);
free_menubar_widget_value_tree (first_wv);
if (menu_item_selection != 0)
{
Lisp_Object prefix, entry;
prefix = entry = Qnil;
i = 0;
while (i < menu_items_used)
{
if (EQ (XVECTOR (menu_items)->contents[i], Qnil))
{
subprefix_stack[submenu_depth++] = prefix;
prefix = entry;
i++;
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qlambda))
{
prefix = subprefix_stack[--submenu_depth];
i++;
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
{
prefix
= XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
i += MENU_ITEMS_PANE_LENGTH;
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
i += 1;
else
{
entry
= XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
if (menu_item_selection == &XVECTOR (menu_items)->contents[i])
{
if (keymaps != 0)
{
int j;
entry = Fcons (entry, Qnil);
if (!NILP (prefix))
entry = Fcons (prefix, entry);
for (j = submenu_depth - 1; j >= 0; j--)
if (!NILP (subprefix_stack[j]))
entry = Fcons (subprefix_stack[j], entry);
}
return entry;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
}
else if (!for_click)
Fsignal (Qquit, Qnil);
return Qnil;
}
#ifdef USE_GTK
static void
dialog_selection_callback (widget, client_data)
GtkWidget *widget;
gpointer client_data;
{
if ((int) (EMACS_INT) client_data != -1)
menu_item_selection = (Lisp_Object *) client_data;
popup_activated_flag = 0;
}
static void
create_and_show_dialog (f, first_wv)
FRAME_PTR f;
widget_value *first_wv;
{
GtkWidget *menu;
menu = xg_create_widget ("dialog", first_wv->name, f, first_wv,
G_CALLBACK (dialog_selection_callback),
G_CALLBACK (popup_deactivate_callback),
0);
if (menu)
{
int specpdl_count = SPECPDL_INDEX ();
record_unwind_protect (pop_down_menu, make_save_value (menu, 0));
gtk_widget_show_all (menu);
popup_widget_loop (1, menu);
unbind_to (specpdl_count, Qnil);
}
}
#else
static void
dialog_selection_callback (widget, id, client_data)
Widget widget;
LWLIB_ID id;
XtPointer client_data;
{
if ((int) (EMACS_INT) client_data != -1)
menu_item_selection = (Lisp_Object *) client_data;
BLOCK_INPUT;
lw_destroy_all_widgets (id);
UNBLOCK_INPUT;
popup_activated_flag = 0;
}
static void
create_and_show_dialog (f, first_wv)
FRAME_PTR f;
widget_value *first_wv;
{
LWLIB_ID dialog_id;
dialog_id = widget_id_tick++;
lw_create_widget (first_wv->name, "dialog", dialog_id, first_wv,
f->output_data.x->widget, 1, 0,
dialog_selection_callback, 0, 0);
lw_modify_all_widgets (dialog_id, first_wv->contents, True);
lw_pop_up_all_widgets (dialog_id);
popup_activated_flag = 1;
x_activate_timeout_atimer ();
{
int count = SPECPDL_INDEX ();
int fact = 4 * sizeof (LWLIB_ID);
record_unwind_protect (pop_down_menu,
Fcons (make_number (dialog_id >> (fact)),
make_number (dialog_id & ~(-1 << (fact)))));
popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f),
dialog_id, 1);
unbind_to (count, Qnil);
}
}
#endif
static char * button_names [] = {
"button1", "button2", "button3", "button4", "button5",
"button6", "button7", "button8", "button9", "button10" };
static Lisp_Object
xdialog_show (f, keymaps, title, header, error_name)
FRAME_PTR f;
int keymaps;
Lisp_Object title, header;
char **error_name;
{
int i, nb_buttons=0;
char dialog_name[6];
widget_value *wv, *first_wv = 0, *prev_wv = 0;
int left_count = 0;
int boundary_seen = 0;
*error_name = NULL;
if (menu_items_n_panes > 1)
{
*error_name = "Multiple panes in dialog box";
return Qnil;
}
{
Lisp_Object pane_name, prefix;
char *pane_string;
pane_name = XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_NAME];
prefix = XVECTOR (menu_items)->contents[MENU_ITEMS_PANE_PREFIX];
pane_string = (NILP (pane_name)
? "" : (char *) SDATA (pane_name));
prev_wv = xmalloc_widget_value ();
prev_wv->value = pane_string;
if (keymaps && !NILP (prefix))
prev_wv->name++;
prev_wv->enabled = 1;
prev_wv->name = "message";
prev_wv->help = Qnil;
first_wv = prev_wv;
i = MENU_ITEMS_PANE_LENGTH;
while (i < menu_items_used)
{
Lisp_Object item_name, enable, descrip;
item_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_NAME];
enable = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_ENABLE];
descrip
= XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_EQUIV_KEY];
if (NILP (item_name))
{
free_menubar_widget_value_tree (first_wv);
*error_name = "Submenu in dialog items";
return Qnil;
}
if (EQ (item_name, Qquote))
{
boundary_seen = 1;
i++;
continue;
}
if (nb_buttons >= 9)
{
free_menubar_widget_value_tree (first_wv);
*error_name = "Too many dialog items";
return Qnil;
}
wv = xmalloc_widget_value ();
prev_wv->next = wv;
wv->name = (char *) button_names[nb_buttons];
if (!NILP (descrip))
wv->key = (char *) SDATA (descrip);
wv->value = (char *) SDATA (item_name);
wv->call_data = (void *) &XVECTOR (menu_items)->contents[i];
wv->enabled = !NILP (enable);
wv->help = Qnil;
prev_wv = wv;
if (! boundary_seen)
left_count++;
nb_buttons++;
i += MENU_ITEMS_ITEM_LENGTH;
}
if (! boundary_seen)
left_count = nb_buttons - nb_buttons / 2;
wv = xmalloc_widget_value ();
wv->name = dialog_name;
wv->help = Qnil;
if (NILP(header))
dialog_name[0] = 'Q';
else
dialog_name[0] = 'I';
dialog_name[1] = '0' + nb_buttons;
dialog_name[2] = 'B';
dialog_name[3] = 'R';
dialog_name[4] = '0' + nb_buttons - left_count;
dialog_name[5] = 0;
wv->contents = first_wv;
first_wv = wv;
}
menu_item_selection = 0;
Fredisplay (Qt);
create_and_show_dialog (f, first_wv);
free_menubar_widget_value_tree (first_wv);
if (menu_item_selection != 0)
{
Lisp_Object prefix;
prefix = Qnil;
i = 0;
while (i < menu_items_used)
{
Lisp_Object entry;
if (EQ (XVECTOR (menu_items)->contents[i], Qt))
{
prefix
= XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
i += MENU_ITEMS_PANE_LENGTH;
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
{
++i;
}
else
{
entry
= XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
if (menu_item_selection == &XVECTOR (menu_items)->contents[i])
{
if (keymaps != 0)
{
entry = Fcons (entry, Qnil);
if (!NILP (prefix))
entry = Fcons (prefix, entry);
}
return entry;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
}
else
Fsignal (Qquit, Qnil);
return Qnil;
}
#else
static struct frame *menu_help_frame;
static void
menu_help_callback (help_string, pane, item)
char *help_string;
int pane, item;
{
extern Lisp_Object Qmenu_item;
Lisp_Object *first_item;
Lisp_Object pane_name;
Lisp_Object menu_object;
first_item = XVECTOR (menu_items)->contents;
if (EQ (first_item[0], Qt))
pane_name = first_item[MENU_ITEMS_PANE_NAME];
else if (EQ (first_item[0], Qquote))
pane_name = empty_string;
else
pane_name = first_item[MENU_ITEMS_ITEM_NAME];
menu_object = Fcons (Qmenu_item,
Fcons (pane_name,
Fcons (make_number (pane), Qnil)));
show_help_echo (help_string ? build_string (help_string) : Qnil,
Qnil, menu_object, make_number (item), 1);
}
static Lisp_Object
pop_down_menu (arg)
Lisp_Object arg;
{
struct Lisp_Save_Value *p1 = XSAVE_VALUE (Fcar (arg));
struct Lisp_Save_Value *p2 = XSAVE_VALUE (Fcdr (arg));
FRAME_PTR f = p1->pointer;
XMenu *menu = p2->pointer;
BLOCK_INPUT;
#ifndef MSDOS
XUngrabPointer (FRAME_X_DISPLAY (f), CurrentTime);
XUngrabKeyboard (FRAME_X_DISPLAY (f), CurrentTime);
#endif
XMenuDestroy (FRAME_X_DISPLAY (f), menu);
#ifdef HAVE_X_WINDOWS
x_mouse_leave (FRAME_X_DISPLAY_INFO (f));
FRAME_X_DISPLAY_INFO (f)->grabbed = 0;
#endif
UNBLOCK_INPUT;
return Qnil;
}
static Lisp_Object
xmenu_show (f, x, y, for_click, keymaps, title, error)
FRAME_PTR f;
int x, y;
int for_click;
int keymaps;
Lisp_Object title;
char **error;
{
Window root;
XMenu *menu;
int pane, selidx, lpane, status;
Lisp_Object entry, pane_prefix;
char *datap;
int ulx, uly, width, height;
int dispwidth, dispheight;
int i, j, lines, maxlines;
int maxwidth;
int dummy_int;
unsigned int dummy_uint;
int specpdl_count = SPECPDL_INDEX ();
*error = 0;
if (menu_items_n_panes == 0)
return Qnil;
if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)
{
*error = "Empty menu";
return Qnil;
}
XGetGeometry (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &root,
&dummy_int, &dummy_int, &dummy_uint, &dummy_uint,
&dummy_uint, &dummy_uint);
menu = XMenuCreate (FRAME_X_DISPLAY (f), root, "emacs");
if (menu == NULL)
{
*error = "Can't create menu";
return Qnil;
}
inhibit_garbage_collection ();
#ifdef HAVE_X_WINDOWS
x += FRAME_OUTER_TO_INNER_DIFF_X (f);
y += FRAME_OUTER_TO_INNER_DIFF_Y (f);
#endif
x += f->left_pos;
y += f->top_pos;
maxlines = lines = i = 0;
while (i < menu_items_used)
{
if (EQ (XVECTOR (menu_items)->contents[i], Qt))
{
Lisp_Object pane_name, prefix;
char *pane_string;
maxlines = max (maxlines, lines);
lines = 0;
pane_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_NAME];
prefix = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
pane_string = (NILP (pane_name)
? "" : (char *) SDATA (pane_name));
if (keymaps && !NILP (prefix))
pane_string++;
lpane = XMenuAddPane (FRAME_X_DISPLAY (f), menu, pane_string, TRUE);
if (lpane == XM_FAILURE)
{
XMenuDestroy (FRAME_X_DISPLAY (f), menu);
*error = "Can't create pane";
return Qnil;
}
i += MENU_ITEMS_PANE_LENGTH;
maxwidth = 0;
j = i;
while (j < menu_items_used)
{
Lisp_Object item;
item = XVECTOR (menu_items)->contents[j];
if (EQ (item, Qt))
break;
if (NILP (item))
{
j++;
continue;
}
width = SBYTES (item);
if (width > maxwidth)
maxwidth = width;
j += MENU_ITEMS_ITEM_LENGTH;
}
}
else if (EQ (XVECTOR (menu_items)->contents[i], Qquote))
i += 1;
else
{
Lisp_Object item_name, enable, descrip, help;
unsigned char *item_data;
char *help_string;
item_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_NAME];
enable = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_ENABLE];
descrip
= XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_EQUIV_KEY];
help = XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_HELP];
help_string = STRINGP (help) ? SDATA (help) : NULL;
if (!NILP (descrip))
{
int gap = maxwidth - SBYTES (item_name);
#ifdef C_ALLOCA
Lisp_Object spacer;
spacer = Fmake_string (make_number (gap), make_number (' '));
item_name = concat2 (item_name, spacer);
item_name = concat2 (item_name, descrip);
item_data = SDATA (item_name);
#else
item_data
= (unsigned char *) alloca (maxwidth
+ SBYTES (descrip) + 1);
bcopy (SDATA (item_name), item_data,
SBYTES (item_name));
for (j = SCHARS (item_name); j < maxwidth; j++)
item_data[j] = ' ';
bcopy (SDATA (descrip), item_data + j,
SBYTES (descrip));
item_data[j + SBYTES (descrip)] = 0;
#endif
}
else
item_data = SDATA (item_name);
if (XMenuAddSelection (FRAME_X_DISPLAY (f),
menu, lpane, 0, item_data,
!NILP (enable), help_string)
== XM_FAILURE)
{
XMenuDestroy (FRAME_X_DISPLAY (f), menu);
*error = "Can't add selection to menu";
return Qnil;
}
i += MENU_ITEMS_ITEM_LENGTH;
lines++;
}
}
maxlines = max (maxlines, lines);
XMenuRecompute (FRAME_X_DISPLAY (f), menu);
dispwidth = DisplayWidth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
dispheight = DisplayHeight (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
x = min (x, dispwidth);
y = min (y, dispheight);
x = max (x, 1);
y = max (y, 1);
XMenuLocate (FRAME_X_DISPLAY (f), menu, 0, 0, x, y,
&ulx, &uly, &width, &height);
if (ulx+width > dispwidth)
{
x -= (ulx + width) - dispwidth;
ulx = dispwidth - width;
}
if (uly+height > dispheight)
{
y -= (uly + height) - dispheight;
uly = dispheight - height;
}
if (ulx < 0) x -= ulx;
if (uly < 0) y -= uly;
if (! for_click)
{
x += width/2;
y += 1.5*height/(maxlines+2);
}
XMenuSetAEQ (menu, TRUE);
XMenuSetFreeze (menu, TRUE);
pane = selidx = 0;
#ifndef MSDOS
XMenuActivateSetWaitFunction (x_menu_wait_for_event, FRAME_X_DISPLAY (f));
#endif
record_unwind_protect (pop_down_menu,
Fcons (make_save_value (f, 0),
make_save_value (menu, 0)));
menu_help_frame = f;
status = XMenuActivate (FRAME_X_DISPLAY (f), menu, &pane, &selidx,
x, y, ButtonReleaseMask, &datap,
menu_help_callback);
switch (status)
{
case XM_SUCCESS:
#ifdef XDEBUG
fprintf (stderr, "pane= %d line = %d\n", panes, selidx);
#endif
i = 0;
while (i < menu_items_used)
{
if (EQ (XVECTOR (menu_items)->contents[i], Qt))
{
if (pane == 0)
pane_prefix
= XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
pane--;
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
if (pane == -1)
{
if (selidx == 0)
{
entry
= XVECTOR (menu_items)->contents[i + MENU_ITEMS_ITEM_VALUE];
if (keymaps != 0)
{
entry = Fcons (entry, Qnil);
if (!NILP (pane_prefix))
entry = Fcons (pane_prefix, entry);
}
break;
}
selidx--;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
break;
case XM_FAILURE:
*error = "Can't activate menu";
case XM_IA_SELECT:
entry = Qnil;
break;
case XM_NO_SELECT:
if (! for_click)
Fsignal (Qquit, Qnil);
entry = Qnil;
break;
}
unbind_to (specpdl_count, Qnil);
return entry;
}
#endif
#endif
int
popup_activated ()
{
return popup_activated_flag;
}
DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_p, 0, 0, 0,
doc: )
()
{
#ifdef HAVE_MENUS
return (popup_activated ()) ? Qt : Qnil;
#else
return Qnil;
#endif
}
void
syms_of_xmenu ()
{
staticpro (&menu_items);
menu_items = Qnil;
menu_items_inuse = Qnil;
Qdebug_on_next_call = intern ("debug-on-next-call");
staticpro (&Qdebug_on_next_call);
#ifdef USE_X_TOOLKIT
widget_id_tick = (1<<16);
next_menubar_widget_id = 1;
#endif
defsubr (&Sx_popup_menu);
defsubr (&Smenu_or_popup_active_p);
#if defined (USE_GTK) || defined (USE_X_TOOLKIT)
defsubr (&Smenu_bar_open);
Ffset (intern ("accelerate-menu"), intern (Smenu_bar_open.symbol_name));
#endif
#ifdef HAVE_MENUS
defsubr (&Sx_popup_dialog);
#endif
}