#include <config.h>
#include <signal.h>
#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 "w32term.h"
#ifndef makedev
#include <sys/types.h>
#endif
#include "dispextern.h"
#undef HAVE_DIALOGS
typedef void * XtPointer;
typedef char Boolean;
enum button_type
{
BUTTON_TYPE_NONE,
BUTTON_TYPE_TOGGLE,
BUTTON_TYPE_RADIO
};
typedef struct _widget_value
{
Lisp_Object lname;
char* name;
char* value;
Lisp_Object lkey;
char* key;
Lisp_Object help;
Boolean enabled;
Boolean selected;
enum button_type button_type;
Boolean title;
#if 0
Boolean edited;
change_type change;
change_type this_one_change;
#endif
struct _widget_value* contents;
XtPointer call_data;
struct _widget_value* next;
#if 0
void* toolkit_data;
Boolean free_toolkit_data;
struct _widget_value *free_list;
#endif
} widget_value;
#define local_heap (GetProcessHeap ())
#define local_alloc(n) (HeapAlloc (local_heap, HEAP_ZERO_MEMORY, (n)))
#define local_free(p) (HeapFree (local_heap, 0, ((LPVOID) (p))))
#define malloc_widget_value() ((widget_value *) local_alloc (sizeof (widget_value)))
#define free_widget_value(wv) (local_free ((wv)))
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
HMENU current_popup_menu;
void syms_of_w32menu ();
void globals_of_w32menu ();
typedef BOOL (WINAPI * GetMenuItemInfoA_Proc) (
IN HMENU,
IN UINT,
IN BOOL,
IN OUT LPMENUITEMINFOA);
typedef BOOL (WINAPI * SetMenuItemInfoA_Proc) (
IN HMENU,
IN UINT,
IN BOOL,
IN LPCMENUITEMINFOA);
GetMenuItemInfoA_Proc get_menu_item_info = NULL;
SetMenuItemInfoA_Proc set_menu_item_info = NULL;
AppendMenuW_Proc unicode_append_menu = NULL;
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;
void set_frame_menubar ();
static void push_menu_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object));
#ifdef HAVE_DIALOGS
static Lisp_Object w32_dialog_show ();
#endif
static Lisp_Object w32_menu_show ();
static void keymap_panes ();
static void single_keymap_panes ();
static void single_menu_item ();
static void list_of_panes ();
static void list_of_items ();
void w32_free_menu_strings (HWND);
#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 int menu_items_allocated;
static int menu_items_used;
static int menu_items_n_panes;
static int menu_items_submenu_depth;
static int next_menubar_widget_id;
int pending_menu_activation;
static struct frame *
menubar_id_to_frame (id)
HMENU 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.w32->menubar_widget == id)
return f;
}
return 0;
}
static void
init_menu_items ()
{
if (NILP (menu_items))
{
menu_items_allocated = 60;
menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
}
menu_items_used = 0;
menu_items_n_panes = 0;
menu_items_submenu_depth = 0;
}
static void
finish_menu_items ()
{
}
static void
discard_menu_items ()
{
if (menu_items_allocated > 200)
{
menu_items = Qnil;
menu_items_allocated = 0;
}
}
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 ();
ASET (menu_items, menu_items_used++, Qnil);
menu_items_submenu_depth++;
}
static void
push_submenu_end ()
{
if (menu_items_used + 1 > menu_items_allocated)
grow_menu_items ();
ASET (menu_items, 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 ();
ASET (menu_items, 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++;
ASET (menu_items, menu_items_used++, Qt);
ASET (menu_items, menu_items_used++, name);
ASET (menu_items, 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 ();
ASET (menu_items, menu_items_used++, name);
ASET (menu_items, menu_items_used++, enable);
ASET (menu_items, menu_items_used++, key);
ASET (menu_items, menu_items_used++, equiv);
ASET (menu_items, menu_items_used++, def);
ASET (menu_items, menu_items_used++, type);
ASET (menu_items, menu_items_used++, selected);
ASET (menu_items, 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 ();
}
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;
{
Lisp_Object pending_maps = Qnil;
Lisp_Object tail, item;
struct gcpro gcpro1, gcpro2;
if (maxdepth <= 0)
return;
push_menu_pane (pane_name, prefix);
for (tail = keymap; CONSP (tail); tail = XCDR (tail))
{
GCPRO2 (keymap, pending_maps);
item = XCAR (tail);
if (CONSP (item))
single_menu_item (XCAR (item), XCDR (item),
&pending_maps, notreal, maxdepth);
else if (VECTORP (item))
{
int len = ASIZE (item);
int c;
for (c = 0; c < len; c++)
{
Lisp_Object character;
XSETFASTINT (character, c);
single_menu_item (character, AREF (item, c),
&pending_maps, notreal, maxdepth);
}
}
UNGCPRO;
}
while (!NILP (pending_maps))
{
Lisp_Object elt, eltcdr, string;
elt = Fcar (pending_maps);
eltcdr = XCDR (elt);
string = XCAR (eltcdr);
single_keymap_panes (Fcar (elt), string,
XCDR (eltcdr), notreal, maxdepth - 1);
pending_maps = Fcdr (pending_maps);
}
}
static void
single_menu_item (key, item, pending_maps_ptr, notreal, maxdepth)
Lisp_Object key, item;
Lisp_Object *pending_maps_ptr;
int maxdepth, notreal;
{
Lisp_Object map, item_string, enabled;
struct gcpro gcpro1, gcpro2;
int res;
GCPRO2 (key, item);
res = parse_menu_item (item, notreal, 0);
UNGCPRO;
if (!res)
return;
map = AREF (item_properties, ITEM_PROPERTY_MAP);
if (notreal)
{
if (!NILP (map))
single_keymap_panes (map, Qnil, key, 1, maxdepth - 1);
return;
}
enabled = AREF (item_properties, ITEM_PROPERTY_ENABLE);
item_string = AREF (item_properties, ITEM_PROPERTY_NAME);
if (!NILP (map) && SREF (item_string, 0) == '@')
{
if (!NILP (enabled))
*pending_maps_ptr = Fcons (Fcons (map, Fcons (item_string, key)),
*pending_maps_ptr);
return;
}
push_menu_item (item_string, enabled, key,
AREF (item_properties, ITEM_PROPERTY_DEF),
AREF (item_properties, ITEM_PROPERTY_KEYEQ),
AREF (item_properties, ITEM_PROPERTY_TYPE),
AREF (item_properties, ITEM_PROPERTY_SELECTED),
AREF (item_properties, ITEM_PROPERTY_HELP));
if (! (NILP (map) || NILP (enabled)))
{
push_submenu_start ();
single_keymap_panes (map, Qnil, key, 0, maxdepth - 1);
push_submenu_end ();
}
}
static void
list_of_panes (menu)
Lisp_Object menu;
{
Lisp_Object tail;
init_menu_items ();
for (tail = menu; !NILP (tail); tail = Fcdr (tail))
{
Lisp_Object elt, pane_name, pane_data;
elt = Fcar (tail);
pane_name = Fcar (elt);
CHECK_STRING (pane_name);
push_menu_pane (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; !NILP (tail); tail = Fcdr (tail))
{
item = Fcar (tail);
if (STRINGP (item))
push_menu_item (item, Qnil, Qnil, Qt, Qnil, Qnil, Qnil, Qnil);
else if (NILP (item))
push_left_right_boundary ();
else
{
CHECK_CONS (item);
item1 = Fcar (item);
CHECK_STRING (item1);
push_menu_item (item1, Qt, Fcdr (item), Qt, Qnil, Qnil, Qnil, Qnil);
}
}
}
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;
Lisp_Object selection;
FRAME_PTR f = NULL;
Lisp_Object x, y, window;
int keymaps = 0;
int for_click = 0;
struct gcpro gcpro1;
#ifdef HAVE_MENUS
if (! NILP (position))
{
check_w32 ();
if (EQ (position, Qt)
|| (CONSP (position) && (EQ (XCAR (position), Qmenu_bar)
|| EQ (XCAR (position), Qtool_bar))))
{
FRAME_PTR new_f = SELECTED_FRAME ();
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);
if (new_f != 0)
XSETFRAME (window, new_f);
else
{
window = selected_window;
XSETFASTINT (x, 0);
XSETFASTINT (y, 0);
}
}
else
{
tem = Fcar (position);
if (CONSP (tem))
{
window = Fcar (Fcdr (position));
x = Fcar (tem);
y = Fcar (Fcdr (tem));
}
else
{
for_click = 1;
tem = Fcar (Fcdr (position));
window = Fcar (tem);
tem = Fcar (Fcdr (Fcdr (tem)));
x = Fcar (tem);
y = Fcdr (tem);
}
}
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
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)
ASET (menu_items, 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 = Fcdr (tem))
{
Lisp_Object prompt;
maps[i++] = keymap = get_keymap (Fcar (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)
ASET (menu_items, MENU_ITEMS_PANE_NAME, title);
keymaps = 1;
}
else
{
title = Fcar (menu);
CHECK_STRING (title);
list_of_panes (Fcdr (menu));
keymaps = 0;
}
if (NILP (position))
{
discard_menu_items ();
UNGCPRO;
return Qnil;
}
#ifdef HAVE_MENUS
if (current_popup_menu)
{
discard_menu_items ();
UNGCPRO;
return Qnil;
}
BLOCK_INPUT;
selection = w32_menu_show (f, xpos, ypos, for_click,
keymaps, title, &error_name);
UNBLOCK_INPUT;
discard_menu_items ();
#endif
UNGCPRO;
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_w32 ();
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);
#ifndef HAVE_DIALOGS
{
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;
title = Fcar (contents);
CHECK_STRING (title);
list_of_panes (Fcons (contents, Qnil));
BLOCK_INPUT;
selection = w32_dialog_show (f, 0, title, header, &error_name);
UNBLOCK_INPUT;
discard_menu_items ();
if (error_name) error (error_name);
return selection;
}
#endif
}
void
x_activate_menubar (f)
FRAME_PTR f;
{
set_frame_menubar (f, 0, 1);
f->output_data.w32->menubar_active = 1;
complete_deferred_msg (FRAME_W32_WINDOW (f), WM_INITMENU, 0);
}
void
menubar_selection_callback (FRAME_PTR f, void * client_data)
{
Lisp_Object prefix, entry;
Lisp_Object vector;
Lisp_Object *subprefix_stack;
int submenu_depth = 0;
int i;
if (!f)
return;
entry = Qnil;
subprefix_stack = (Lisp_Object *) alloca (f->menu_bar_items_used * sizeof (Lisp_Object));
vector = f->menu_bar_vector;
prefix = Qnil;
i = 0;
while (i < f->menu_bar_items_used)
{
if (EQ (AREF (vector, i), Qnil))
{
subprefix_stack[submenu_depth++] = prefix;
prefix = entry;
i++;
}
else if (EQ (AREF (vector, i), Qlambda))
{
prefix = subprefix_stack[--submenu_depth];
i++;
}
else if (EQ (AREF (vector, i), Qt))
{
prefix = AREF (vector, i + MENU_ITEMS_PANE_PREFIX);
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
entry = AREF (vector, 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;
w32_free_menu_strings (FRAME_W32_WINDOW (f));
kbd_buffer_store_event (&buf);
f->output_data.w32->menubar_active = 0;
return;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
w32_free_menu_strings (FRAME_W32_WINDOW (f));
f->output_data.w32->menubar_active = 0;
}
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 (SYMBOLP (mapvec[i])
|| (CONSP (mapvec[i]) && !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;
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 (AREF (menu_items, i), Qnil))
{
submenu_stack[submenu_depth++] = save_wv;
save_wv = prev_wv;
prev_wv = 0;
i++;
}
else if (EQ (AREF (menu_items, i), Qlambda))
{
prev_wv = save_wv;
save_wv = submenu_stack[--submenu_depth];
i++;
}
else if (EQ (AREF (menu_items, i), Qt)
&& submenu_depth != 0)
i += MENU_ITEMS_PANE_LENGTH;
else if (EQ (AREF (menu_items, i), Qquote))
i += 1;
else if (EQ (AREF (menu_items, 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);
if (STRINGP (pane_name))
{
if (unicode_append_menu)
pane_name = ENCODE_UTF_8 (pane_name);
else if (STRING_MULTIBYTE (pane_name))
pane_name = ENCODE_SYSTEM (pane_name);
ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
}
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;
prev_wv = 0;
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
Lisp_Object item_name, enable, descrip, def, type, selected;
Lisp_Object 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);
if (STRINGP (item_name))
{
if (unicode_append_menu)
item_name = ENCODE_UTF_8 (item_name);
else if (STRING_MULTIBYTE (item_name))
item_name = ENCODE_SYSTEM (item_name);
ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
}
if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
{
descrip = ENCODE_SYSTEM (descrip);
ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
}
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 (wv->lname && ! NILP (wv->lname))
{
wv->name = SDATA (wv->lname);
if (wv->value == (char *)1)
{
if (wv->name[0] == '@')
wv->name++;
wv->value = 0;
}
}
if (wv->lkey && ! NILP (wv->lkey))
wv->key = SDATA (wv->lkey);
if (wv->contents)
update_submenu_strings (wv->contents);
}
}
void
set_frame_menubar (f, first_time, deep_p)
FRAME_PTR f;
int first_time;
int deep_p;
{
HMENU menubar_widget = f->output_data.w32->menubar_widget;
Lisp_Object items;
widget_value *wv, *first_wv, *prev_wv = 0;
int i, last_i;
int *submenu_start, *submenu_end;
int *submenu_top_level_items, *submenu_n_panes;
if (f->output_data.w32->menubar_active)
return;
XSETFRAME (Vmenu_updating_frame, f);
if (! menubar_widget)
deep_p = 1;
else if (pending_menu_activation && !deep_p)
deep_p = 1;
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));
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 < ASIZE (items); i += 4)
{
Lisp_Object key, string, maps;
last_i = i;
key = AREF (items, i);
string = AREF (items, i + 1);
maps = AREF (items, 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);
unbind_to (specpdl_count, Qnil);
for (i = 0; i < previous_menu_items_used; i++)
if (menu_items_used == i
|| (!EQ (previous_items[i], AREF (menu_items, i))))
break;
if (i == menu_items_used && i == previous_menu_items_used && i != 0)
{
free_menubar_widget_value_tree (first_wv);
menu_items = Qnil;
return;
}
wv = first_wv->contents;
for (i = 0; i < ASIZE (items); i += 4)
{
Lisp_Object string;
string = AREF (items, i + 1);
if (NILP (string))
break;
wv->name = (char *) SDATA (string);
update_submenu_strings (wv->contents);
wv = wv->next;
}
f->menu_bar_vector = menu_items;
f->menu_bar_items_used = menu_items_used;
menu_items = Qnil;
}
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 < ASIZE (items); i += 4)
{
Lisp_Object string;
string = AREF (items, 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;
if (menubar_widget)
{
while (DeleteMenu (menubar_widget, 0, MF_BYPOSITION))
;
}
else
{
menubar_widget = CreateMenu ();
}
fill_in_menu (menubar_widget, first_wv->contents);
free_menubar_widget_value_tree (first_wv);
{
HMENU old_widget = f->output_data.w32->menubar_widget;
f->output_data.w32->menubar_widget = menubar_widget;
SetMenu (FRAME_W32_WINDOW (f), f->output_data.w32->menubar_widget);
if (old_widget == NULL)
x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
}
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);
}
void
free_frame_menubar (f)
FRAME_PTR f;
{
BLOCK_INPUT;
{
HMENU old = GetMenu (FRAME_W32_WINDOW (f));
SetMenu (FRAME_W32_WINDOW (f), NULL);
f->output_data.w32->menubar_widget = NULL;
DestroyMenu (old);
}
UNBLOCK_INPUT;
}
static Lisp_Object
w32_menu_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;
int menu_item_selection;
HMENU menu;
POINT pos;
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 (AREF (menu_items, i), Qnil))
{
submenu_stack[submenu_depth++] = save_wv;
save_wv = prev_wv;
prev_wv = 0;
first_pane = 1;
i++;
}
else if (EQ (AREF (menu_items, i), Qlambda))
{
prev_wv = save_wv;
save_wv = submenu_stack[--submenu_depth];
first_pane = 0;
i++;
}
else if (EQ (AREF (menu_items, i), Qt)
&& submenu_depth != 0)
i += MENU_ITEMS_PANE_LENGTH;
else if (EQ (AREF (menu_items, i), Qquote))
i += 1;
else if (EQ (AREF (menu_items, 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);
if (STRINGP (pane_name))
{
if (unicode_append_menu)
pane_name = ENCODE_UTF_8 (pane_name);
else if (STRING_MULTIBYTE (pane_name))
pane_name = ENCODE_SYSTEM (pane_name);
ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
}
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);
if (STRINGP (item_name))
{
if (unicode_append_menu)
item_name = ENCODE_UTF_8 (item_name);
else if (STRING_MULTIBYTE (item_name))
item_name = ENCODE_SYSTEM (item_name);
ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
}
if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
{
descrip = ENCODE_SYSTEM (descrip);
ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
}
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 *) (EMACS_INT) 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_sep = xmalloc_widget_value ();
wv_sep->name = "--";
wv_sep->next = first_wv->contents;
wv_sep->help = Qnil;
if (unicode_append_menu)
title = ENCODE_UTF_8 (title);
else if (STRING_MULTIBYTE (title))
title = ENCODE_SYSTEM (title);
wv_title->name = (char *) SDATA (title);
wv_title->enabled = TRUE;
wv_title->title = TRUE;
wv_title->button_type = BUTTON_TYPE_NONE;
wv_title->help = Qnil;
wv_title->next = wv_sep;
first_wv->contents = wv_title;
}
current_popup_menu = menu = CreatePopupMenu ();
fill_in_menu (menu, first_wv->contents);
pos.x = x;
pos.y = y;
ClientToScreen (FRAME_W32_WINDOW (f), &pos);
menu_item_selection = 0;
menu_item_selection = SendMessage (FRAME_W32_WINDOW (f),
WM_EMACS_TRACKPOPUPMENU,
(WPARAM)menu, (LPARAM)&pos);
discard_mouse_events ();
free_menubar_widget_value_tree (first_wv);
DestroyMenu (menu);
w32_free_menu_strings (FRAME_W32_WINDOW (f));
f->output_data.w32->menubar_active = 0;
if (menu_item_selection != 0)
{
Lisp_Object prefix, entry;
prefix = entry = Qnil;
i = 0;
while (i < menu_items_used)
{
if (EQ (AREF (menu_items, i), Qnil))
{
subprefix_stack[submenu_depth++] = prefix;
prefix = entry;
i++;
}
else if (EQ (AREF (menu_items, i), Qlambda))
{
prefix = subprefix_stack[--submenu_depth];
i++;
}
else if (EQ (AREF (menu_items, i), Qt))
{
prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
i += MENU_ITEMS_PANE_LENGTH;
}
else if (EQ (AREF (menu_items, i), Qquote))
i += 1;
else
{
entry = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
if (menu_item_selection == 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 HAVE_DIALOGS
static char * button_names [] = {
"button1", "button2", "button3", "button4", "button5",
"button6", "button7", "button8", "button9", "button10" };
static Lisp_Object
w32_dialog_show (f, keymaps, title, header, error)
FRAME_PTR f;
int keymaps;
Lisp_Object title, header;
char **error;
{
int i, nb_buttons=0;
char dialog_name[6];
int menu_item_selection;
widget_value *wv, *first_wv = 0, *prev_wv = 0;
int left_count = 0;
int boundary_seen = 0;
*error = NULL;
if (menu_items_n_panes > 1)
{
*error = "Multiple panes in dialog box";
return Qnil;
}
{
Lisp_Object pane_name, prefix;
char *pane_string;
pane_name = AREF (menu_items, MENU_ITEMS_PANE_NAME);
prefix = AREF (menu_items, 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, 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);
help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
if (NILP (item_name))
{
free_menubar_widget_value_tree (first_wv);
*error = "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 = "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 *) &AREF (menu_items, 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;
}
dialog_id = widget_id_tick++;
menu = lw_create_widget (first_wv->name, "dialog", dialog_id, first_wv,
f->output_data.w32->widget, 1, 0,
dialog_selection_callback, 0);
lw_modify_all_widgets (dialog_id, first_wv->contents, TRUE);
free_menubar_widget_value_tree (first_wv);
menu_item_selection = 0;
lw_pop_up_all_widgets (dialog_id);
popup_get_selection ((XEvent *) 0, FRAME_X_DISPLAY_INFO (f), dialog_id);
lw_destroy_all_widgets (dialog_id);
if (menu_item_selection != 0)
{
Lisp_Object prefix;
prefix = Qnil;
i = 0;
while (i < menu_items_used)
{
Lisp_Object entry;
if (EQ (AREF (menu_items, i), Qt))
{
prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
entry = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
if (menu_item_selection == 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;
}
#endif
static int
name_is_separator (name)
char *name;
{
char *start = name;
while (*name == '-') name++;
return (*name == '\0' || start + 2 == name);
}
static int
add_left_right_boundary (HMENU menu)
{
return AppendMenu (menu, MF_MENUBARBREAK, 0, NULL);
}
static void
utf8to16 (unsigned char * src, int len, WCHAR * dest)
{
while (len > 0)
{
int utf16;
if (*src < 0x80)
{
*dest = (WCHAR) *src;
dest++; src++; len--;
}
else if (*src < 0xC0)
{
src++; len--;
}
else if (*src < 0xE0)
{
*dest = (WCHAR) (((*src & 0x1f) << 6)
| (*(src + 1) & 0x3f));
src += 2; len -= 2; dest++;
}
else if (*src < 0xF0)
{
*dest = (WCHAR) (((*src & 0x0f) << 12)
| ((*(src + 1) & 0x3f) << 6)
| (*(src + 2) & 0x3f));
src += 3; len -= 3; dest++;
}
else
{
*dest = (WCHAR) 0xfffd;
src++; len--; dest++;
}
}
*dest = 0;
}
static int
add_menu_item (HMENU menu, widget_value *wv, HMENU item)
{
UINT fuFlags;
char *out_string;
int return_value;
if (name_is_separator (wv->name))
{
fuFlags = MF_SEPARATOR;
out_string = NULL;
}
else
{
if (wv->enabled)
fuFlags = MF_STRING;
else
fuFlags = MF_STRING | MF_GRAYED;
if (wv->key != NULL)
{
out_string = alloca (strlen (wv->name) + strlen (wv->key) + 2);
strcpy (out_string, wv->name);
strcat (out_string, "\t");
strcat (out_string, wv->key);
}
else
out_string = wv->name;
if (item != NULL)
fuFlags = MF_POPUP;
else if (wv->title || wv->call_data == 0)
{
if (get_menu_item_info)
{
out_string = (char *) local_alloc (strlen (wv->name) + 1);
strcpy (out_string, wv->name);
#ifdef MENU_DEBUG
DebPrint ("Menu: allocing %ld for owner-draw", out_string);
#endif
fuFlags = MF_OWNERDRAW | MF_DISABLED;
}
else
fuFlags = MF_DISABLED;
}
else if (wv->selected && (wv->button_type == BUTTON_TYPE_TOGGLE ||
wv->button_type == BUTTON_TYPE_RADIO))
fuFlags |= MF_CHECKED;
else
fuFlags |= MF_UNCHECKED;
}
if (unicode_append_menu && out_string)
{
int utf8_len = strlen (out_string);
WCHAR * utf16_string;
if (fuFlags & MF_OWNERDRAW)
utf16_string = local_alloc ((utf8_len + 1) * sizeof (WCHAR));
else
utf16_string = alloca ((utf8_len + 1) * sizeof (WCHAR));
utf8to16 (out_string, utf8_len, utf16_string);
return_value = unicode_append_menu (menu, fuFlags,
item != NULL ? (UINT) item
: (UINT) wv->call_data,
utf16_string);
if (!return_value)
{
return_value =
AppendMenu (menu, fuFlags,
item != NULL ? (UINT) item: (UINT) wv->call_data,
out_string);
unicode_append_menu = NULL;
}
if (unicode_append_menu && (fuFlags & MF_OWNERDRAW))
local_free (out_string);
}
else
{
return_value =
AppendMenu (menu,
fuFlags,
item != NULL ? (UINT) item : (UINT) wv->call_data,
out_string );
}
if (!wv->title && wv->call_data != 0)
{
if (set_menu_item_info)
{
MENUITEMINFO info;
bzero (&info, sizeof (info));
info.cbSize = sizeof (info);
info.fMask = MIIM_DATA;
if (!NILP (wv->help))
#ifdef USE_LISP_UNION_TYPE
info.dwItemData = (DWORD) (wv->help).i;
#else
info.dwItemData = (DWORD) (wv->help);
#endif
if (wv->button_type == BUTTON_TYPE_RADIO)
{
info.fMask |= MIIM_TYPE | MIIM_STATE;
info.fType = MFT_RADIOCHECK | MFT_STRING;
info.dwTypeData = out_string;
info.fState = wv->selected ? MFS_CHECKED : MFS_UNCHECKED;
}
set_menu_item_info (menu,
item != NULL ? (UINT) item : (UINT) wv->call_data,
FALSE, &info);
}
}
return return_value;
}
int
fill_in_menu (HMENU menu, widget_value *wv)
{
int items_added = 0;
for ( ; wv != NULL; wv = wv->next)
{
if (wv->contents)
{
HMENU sub_menu = CreatePopupMenu ();
if (sub_menu == NULL)
return 0;
if (!fill_in_menu (sub_menu, wv->contents) ||
!add_menu_item (menu, wv, sub_menu))
{
DestroyMenu (sub_menu);
return 0;
}
}
else
{
if (!add_menu_item (menu, wv, NULL))
return 0;
}
}
return 1;
}
void
w32_menu_display_help (HWND owner, HMENU menu, UINT item, UINT flags)
{
if (get_menu_item_info)
{
struct frame *f = x_window_to_frame (&one_w32_display_info, owner);
Lisp_Object frame, help;
if (flags & MF_OWNERDRAW || flags & MF_POPUP
|| !(flags & MF_MOUSESELECT))
help = Qnil;
else
{
MENUITEMINFO info;
bzero (&info, sizeof (info));
info.cbSize = sizeof (info);
info.fMask = MIIM_DATA;
get_menu_item_info (menu, item, FALSE, &info);
#ifdef USE_LISP_UNION_TYPE
help = info.dwItemData ? (Lisp_Object) ((EMACS_INT) info.dwItemData)
: Qnil;
#else
help = info.dwItemData ? (Lisp_Object) info.dwItemData : Qnil;
#endif
}
if (f)
{
XSETFRAME (frame, f);
kbd_buffer_store_help_event (frame, help);
}
else
show_help_echo (help, Qnil, Qnil, Qnil, 1);
}
}
static void
w32_free_submenu_strings (menu)
HMENU menu;
{
int i, num = GetMenuItemCount (menu);
for (i = 0; i < num; i++)
{
MENUITEMINFO info;
bzero (&info, sizeof (info));
info.cbSize = sizeof (info);
info.fMask = MIIM_DATA | MIIM_TYPE | MIIM_SUBMENU;
get_menu_item_info (menu, i, TRUE, &info);
if ((info.fType & MF_OWNERDRAW) && info.dwItemData)
{
#ifdef MENU_DEBUG
DebPrint ("Menu: freeing %ld for owner-draw", info.dwItemData);
#endif
local_free (info.dwItemData);
}
if (info.hSubMenu)
w32_free_submenu_strings (info.hSubMenu);
}
}
void
w32_free_menu_strings (hwnd)
HWND hwnd;
{
HMENU menu = current_popup_menu;
if (get_menu_item_info)
{
if (!menu)
menu = GetMenu (hwnd);
if (menu)
w32_free_submenu_strings (menu);
}
current_popup_menu = NULL;
}
#endif
DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_p, 0, 0, 0,
doc: )
()
{
#ifdef HAVE_MENUS
FRAME_PTR f;
f = SELECTED_FRAME ();
return (f->output_data.w32->menubar_active > 0) ? Qt : Qnil;
#else
return Qnil;
#endif
}
void syms_of_w32menu ()
{
globals_of_w32menu ();
staticpro (&menu_items);
menu_items = Qnil;
current_popup_menu = NULL;
Qdebug_on_next_call = intern ("debug-on-next-call");
staticpro (&Qdebug_on_next_call);
defsubr (&Sx_popup_menu);
defsubr (&Smenu_or_popup_active_p);
#ifdef HAVE_MENUS
defsubr (&Sx_popup_dialog);
#endif
}
void globals_of_w32menu ()
{
HMODULE user32 = GetModuleHandle ("user32.dll");
get_menu_item_info = (GetMenuItemInfoA_Proc) GetProcAddress (user32, "GetMenuItemInfoA");
set_menu_item_info = (SetMenuItemInfoA_Proc) GetProcAddress (user32, "SetMenuItemInfoA");
unicode_append_menu = (AppendMenuW_Proc) GetProcAddress (user32, "AppendMenuW");
}