mirrors
/
emacs
mirror of https://github.com/emacs-mirror/emacs.git
0
0
Fork 0
Code Issues Projects Releases Wiki Activity
emacs/src/haikumenu.c

849 lines
22 KiB
C
Raw Permalink Blame History

/* Haiku window system support
Copyright (C) 2021-2024 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
#include <config.h>
#include "lisp.h"
#include "frame.h"
#include "keyboard.h"
#include "menu.h"
#include "buffer.h"
#include "blockinput.h"
#include "haikuterm.h"
#include "haiku_support.h"
static Lisp_Object *volatile menu_item_selection;
static struct timespec menu_timer_timespec;
int popup_activated_p = 0;
static void
digest_menu_items (void *first_menu, int start, int menu_items_used,
bool is_menu_bar)
{
void **menus, **panes;
ssize_t menu_len;
ssize_t pane_len;
int i, menu_depth;
void *menu, *window, *view;
Lisp_Object pane_name, prefix;
const char *pane_string;
Lisp_Object item_name, enable, descrip, def, selected, help;
USE_SAFE_ALLOCA;
menu_len = (menu_items_used + 1 - start) * sizeof *menus;
pane_len = (menu_items_used + 1 - start) * sizeof *panes;
menu = first_menu;
i = start;
menu_depth = 0;
menus = SAFE_ALLOCA (menu_len);
panes = SAFE_ALLOCA (pane_len);
memset (menus, 0, menu_len);
memset (panes, 0, pane_len);
menus[0] = first_menu;
window = NULL;
view = NULL;
if (FRAMEP (Vmenu_updating_frame) &&
FRAME_LIVE_P (XFRAME (Vmenu_updating_frame)) &&
FRAME_HAIKU_P (XFRAME (Vmenu_updating_frame)))
{
window = FRAME_HAIKU_WINDOW (XFRAME (Vmenu_updating_frame));
view = FRAME_HAIKU_VIEW (XFRAME (Vmenu_updating_frame));
}
if (view)
BView_draw_lock (view, false, 0, 0, 0, 0);
while (i < menu_items_used)
{
if (NILP (AREF (menu_items, i)))
{
menus[++menu_depth] = menu;
i++;
}
else if (EQ (AREF (menu_items, i), Qlambda))
{
panes[menu_depth] = NULL;
menu = panes[--menu_depth] ? panes[menu_depth] : menus[menu_depth];
i++;
}
else if (EQ (AREF (menu_items, i), Qquote))
i += 1;
else if (EQ (AREF (menu_items, i), Qt))
{
if (menu_items_n_panes == 1)
{
i += MENU_ITEMS_PANE_LENGTH;
continue;
}
pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);
prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);
if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))
{
pane_name = ENCODE_UTF_8 (pane_name);
ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);
}
pane_string = (NILP (pane_name)
? "" : SSDATA (pane_name));
if (!NILP (prefix))
pane_string++;
if (strcmp (pane_string, ""))
{
panes[menu_depth] =
menu = BMenu_new_submenu (menus[menu_depth], pane_string, 1);
}
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
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);
selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);
help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);
if (STRINGP (item_name) && STRING_MULTIBYTE (item_name))
{
item_name = ENCODE_UTF_8 (item_name);
ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);
}
if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))
{
descrip = ENCODE_UTF_8 (descrip);
ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);
}
if (STRINGP (help) && STRING_MULTIBYTE (help))
help = ENCODE_UTF_8 (help);
if (i + MENU_ITEMS_ITEM_LENGTH < menu_items_used &&
NILP (AREF (menu_items, i + MENU_ITEMS_ITEM_LENGTH)))
menu = BMenu_new_submenu (menu, SSDATA (item_name), !NILP (enable));
else if (NILP (def) && menu_separator_name_p (SSDATA (item_name)))
BMenu_add_separator (menu);
else if (!is_menu_bar)
{
if (!use_system_tooltips || NILP (Fsymbol_value (Qtooltip_mode)))
BMenu_add_item (menu, SSDATA (item_name),
!NILP (def) ? aref_addr (menu_items, i) : NULL,
!NILP (enable), !NILP (selected), 0, window,
!NILP (descrip) ? SSDATA (descrip) : NULL,
NULL);
else
BMenu_add_item (menu, SSDATA (item_name),
!NILP (def) ? aref_addr (menu_items, i) : NULL,
!NILP (enable), !NILP (selected), 0, window,
!NILP (descrip) ? SSDATA (descrip) : NULL,
STRINGP (help) ? SSDATA (help) : NULL);
}
else if (!use_system_tooltips || NILP (Fsymbol_value (Qtooltip_mode)))
BMenu_add_item (menu, SSDATA (item_name),
!NILP (def) ? (void *) (intptr_t) i : NULL,
!NILP (enable), !NILP (selected), 1, window,
!NILP (descrip) ? SSDATA (descrip) : NULL,
NULL);
else
BMenu_add_item (menu, SSDATA (item_name),
!NILP (def) ? (void *) (intptr_t) i : NULL,
!NILP (enable), !NILP (selected), 1, window,
!NILP (descrip) ? SSDATA (descrip) : NULL,
STRINGP (help) ? SSDATA (help) : NULL);
i += MENU_ITEMS_ITEM_LENGTH;
}
}
if (view)
BView_draw_unlock (view);
SAFE_FREE ();
}
static Lisp_Object
haiku_dialog_show (struct frame *f, Lisp_Object title,
Lisp_Object header, const char **error_name)
{
int i, nb_buttons = 0;
bool boundary_seen = false;
Lisp_Object pane_name, vals[10];
void *alert, *button;
bool enabled_item_seen_p = false;
int32 val;
*error_name = NULL;
if (menu_items_n_panes > 1)
{
*error_name = "Multiple panes in dialog box";
return Qnil;
}
pane_name = AREF (menu_items, MENU_ITEMS_PANE_NAME);
i = MENU_ITEMS_PANE_LENGTH;
if (STRING_MULTIBYTE (pane_name))
pane_name = ENCODE_UTF_8 (pane_name);
block_input ();
alert = BAlert_new (SSDATA (pane_name), NILP (header) ? HAIKU_INFO_ALERT :
HAIKU_IDEA_ALERT);
while (i < menu_items_used)
{
Lisp_Object item_name, enable, descrip, value;
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);
value = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
if (NILP (item_name))
{
BAlert_delete (alert);
*error_name = "Submenu in dialog items";
unblock_input ();
return Qnil;
}
if (EQ (item_name, Qquote))
{
if (nb_buttons)
boundary_seen = true;
i++;
continue;
}
if (nb_buttons >= 9)
{
BAlert_delete (alert);
*error_name = "Too many dialog items";
unblock_input ();
return Qnil;
}
if (STRING_MULTIBYTE (item_name))
item_name = ENCODE_UTF_8 (item_name);
if (!NILP (descrip) && STRING_MULTIBYTE (descrip))
descrip = ENCODE_UTF_8 (descrip);
button = BAlert_add_button (alert, SSDATA (item_name));
BButton_set_enabled (button, !NILP (enable));
enabled_item_seen_p |= !NILP (enable);
if (!NILP (descrip))
BView_set_tooltip (button, SSDATA (descrip));
vals[nb_buttons] = value;
++nb_buttons;
i += MENU_ITEMS_ITEM_LENGTH;
}
/* Haiku only lets us specify a single button to place on the
left. */
if (boundary_seen)
BAlert_set_offset_spacing (alert);
/* If there isn't a single enabled item, add an "Ok" button so the
popup can be dismissed. */
if (!enabled_item_seen_p)
BAlert_add_button (alert, "Ok");
unblock_input ();
unrequest_sigio ();
++popup_activated_p;
val = BAlert_go (alert, block_input, unblock_input,
process_pending_signals);
--popup_activated_p;
request_sigio ();
if (val < 0)
quit ();
else if (val < nb_buttons)
return vals[val];
/* The dialog was dismissed via the button appended to dismiss popup
dialogs without a single enabled item. */
if (nb_buttons)
quit ();
/* Otherwise, the Ok button was added because no buttons were seen
at all. */
else
return Qt;
emacs_abort ();
}
Lisp_Object
haiku_popup_dialog (struct frame *f, Lisp_Object header, Lisp_Object contents)
{
Lisp_Object title;
const char *error_name = NULL;
Lisp_Object selection;
specpdl_ref specpdl_count = SPECPDL_INDEX ();
check_window_system (f);
/* Decode the dialog items from what was specified. */
title = Fcar (contents);
CHECK_STRING (title);
record_unwind_protect_void (unuse_menu_items);
if (NILP (Fcar (Fcdr (contents))))
/* No buttons specified, add an "Ok" button so users can pop down
the dialog. Also, the lesstif/motif version crashes if there are
no buttons. */
contents = list2 (title, Fcons (build_string ("Ok"), Qt));
list_of_panes (list1 (contents));
/* Display them in a dialog box. */
selection = haiku_dialog_show (f, title, header, &error_name);
unbind_to (specpdl_count, Qnil);
discard_menu_items ();
if (error_name)
error ("%s", error_name);
return selection;
}
static void
haiku_menu_show_help (void *help, void *data)
{
Lisp_Object *id = (Lisp_Object *) help;
if (help)
show_help_echo (id[MENU_ITEMS_ITEM_HELP],
Qnil, Qnil, Qnil);
else
show_help_echo (Qnil, Qnil, Qnil, Qnil);
}
static Lisp_Object
haiku_process_pending_signals_for_menu_1 (void *ptr)
{
menu_timer_timespec = timer_check ();
return Qnil;
}
static Lisp_Object
haiku_process_pending_signals_for_menu_2 (enum nonlocal_exit exit, Lisp_Object error)
{
menu_timer_timespec.tv_sec = 0;
menu_timer_timespec.tv_nsec = -1;
return Qnil;
}
static struct timespec
haiku_process_pending_signals_for_menu (void)
{
process_pending_signals ();
/* The original idea was to let timers throw so that timeouts can
work correctly, but there's no way to pop down a BPopupMenu
that's currently popped up. */
internal_catch_all (haiku_process_pending_signals_for_menu_1, NULL,
haiku_process_pending_signals_for_menu_2);
return menu_timer_timespec;
}
Lisp_Object
haiku_menu_show (struct frame *f, int x, int y, int menuflags,
Lisp_Object title, const char **error_name)
{
int i, submenu_depth, j;
void *view, *menu;
Lisp_Object *subprefix_stack;
Lisp_Object prefix, entry;
USE_SAFE_ALLOCA;
view = FRAME_HAIKU_VIEW (f);
i = 0;
submenu_depth = 0;
subprefix_stack
= SAFE_ALLOCA (menu_items_used * sizeof (Lisp_Object));
eassert (FRAME_HAIKU_P (f));
*error_name = NULL;
if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)
{
*error_name = "Empty menu";
SAFE_FREE ();
return Qnil;
}
block_input ();
if (STRINGP (title) && STRING_MULTIBYTE (title))
title = ENCODE_UTF_8 (title);
menu = BPopUpMenu_new (STRINGP (title) ? SSDATA (title) : NULL);
if (STRINGP (title))
{
BMenu_add_title (menu, SSDATA (title));
BMenu_add_separator (menu);
}
digest_menu_items (menu, 0, menu_items_used, 0);
BView_convert_to_screen (view, &x, &y);
unblock_input ();
unrequest_sigio ();
popup_activated_p++;
menu_item_selection = BMenu_run (menu, x, y, haiku_menu_show_help,
block_input, unblock_input,
haiku_process_pending_signals_for_menu, NULL);
popup_activated_p--;
request_sigio ();
FRAME_DISPLAY_INFO (f)->grabbed = 0;
/* Clear the grab view manually. There is a race condition here if
the window thread receives a button press between here and the
end of BMenu_run. */
be_clear_grab_view ();
if (menu_item_selection)
{
prefix = entry = Qnil;
i = 0;
while (i < menu_items_used)
{
if (NILP (AREF (menu_items, i)))
{
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;
}
/* Ignore a nil in the item list.
It's meaningful only for dialog boxes. */
else if (EQ (AREF (menu_items, i), Qquote))
i += 1;
else
{
entry
= AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);
if (menu_item_selection == aref_addr (menu_items, i))
{
if (menuflags & MENU_KEYMAPS)
{
entry = list1 (entry);
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);
}
block_input ();
BPopUpMenu_delete (menu);
unblock_input ();
SAFE_FREE ();
return entry;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
}
else if (!(menuflags & MENU_FOR_CLICK))
{
block_input ();
BPopUpMenu_delete (menu);
unblock_input ();
quit ();
}
block_input ();
BPopUpMenu_delete (menu);
unblock_input ();
SAFE_FREE ();
return Qnil;
}
void
free_frame_menubar (struct frame *f)
{
void *mbar;
FRAME_MENU_BAR_LINES (f) = 0;
FRAME_MENU_BAR_HEIGHT (f) = 0;
FRAME_EXTERNAL_MENU_BAR (f) = 0;
block_input ();
mbar = FRAME_HAIKU_MENU_BAR (f);
FRAME_HAIKU_MENU_BAR (f) = NULL;
if (mbar)
BMenuBar_delete (mbar);
if (FRAME_OUTPUT_DATA (f)->menu_bar_open_p)
--popup_activated_p;
FRAME_OUTPUT_DATA (f)->menu_bar_open_p = 0;
unblock_input ();
adjust_frame_size (f, -1, -1, 2, false, Qmenu_bar_lines);
}
void
initialize_frame_menubar (struct frame *f)
{
/* This function is called before the first chance to redisplay
the frame. It has to be, so the frame will have the right size. */
fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
set_frame_menubar (f, true);
}
void
set_frame_menubar (struct frame *f, bool deep_p)
{
void *mbar = FRAME_HAIKU_MENU_BAR (f);
void *view = FRAME_HAIKU_VIEW (f);
bool first_time_p = false;
if (!mbar)
{
block_input ();
mbar = FRAME_HAIKU_MENU_BAR (f) = BMenuBar_new (view);
first_time_p = 1;
/* Now wait for the MENU_BAR_RESIZE event informing us of the
initial dimensions of that menu bar. */
if (FRAME_VISIBLE_P (f))
haiku_wait_for_event (f, MENU_BAR_RESIZE);
unblock_input ();
}
Lisp_Object items;
struct buffer *prev = current_buffer;
Lisp_Object buffer;
specpdl_ref specpdl_count = SPECPDL_INDEX ();
int previous_menu_items_used = f->menu_bar_items_used;
Lisp_Object *previous_items
= alloca (previous_menu_items_used * sizeof *previous_items);
int count;
ptrdiff_t subitems, i;
int *submenu_start, *submenu_end, *submenu_n_panes;
Lisp_Object *submenu_names;
XSETFRAME (Vmenu_updating_frame, f);
if (!deep_p)
{
items = FRAME_MENU_BAR_ITEMS (f);
Lisp_Object string;
block_input ();
int count = BMenu_count_items (mbar);
int i;
for (i = 0; i < ASIZE (items); i += 4)
{
string = AREF (items, i + 1);
if (!STRINGP (string))
break;
if (STRING_MULTIBYTE (string))
string = ENCODE_UTF_8 (string);
if (i / 4 < count)
{
void *it = BMenu_item_at (mbar, i / 4);
BMenu_item_set_label (it, SSDATA (string));
}
else
BMenu_new_menu_bar_submenu (mbar, SSDATA (string));
}
if (i / 4 < count)
BMenu_delete_from (mbar, i / 4, count - i / 4 + 1);
unblock_input ();
f->menu_bar_items_used = 0;
}
else
{
/* If we are making a new widget, its contents are empty,
do always reinitialize them. */
if (first_time_p)
previous_menu_items_used = 0;
buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->contents;
specbind (Qinhibit_quit, Qt);
/* Don't let the debugger step into this code
because it is not reentrant. */
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));
/* Run the Lucid hook. */
safe_run_hooks (Qactivate_menubar_hook);
/* If it has changed current-menubar from previous value,
really recompute the menubar from the value. */
safe_run_hooks (Qmenu_bar_update_hook);
fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
items = FRAME_MENU_BAR_ITEMS (f);
/* Save the frame's previous menu bar contents data. */
if (previous_menu_items_used)
memcpy (previous_items, xvector_contents (f->menu_bar_vector),
previous_menu_items_used * word_size);
/* Fill in menu_items with the current menu bar contents.
This can evaluate Lisp code. */
save_menu_items ();
menu_items = f->menu_bar_vector;
menu_items_allocated = VECTORP (menu_items) ? ASIZE (menu_items) : 0;
subitems = ASIZE (items) / 4;
submenu_start = alloca ((subitems + 1) * sizeof *submenu_start);
submenu_end = alloca (subitems * sizeof *submenu_end);
submenu_n_panes = alloca (subitems * sizeof *submenu_n_panes);
submenu_names = alloca (subitems * sizeof (Lisp_Object));
init_menu_items ();
for (i = 0; i < subitems; i++)
{
Lisp_Object key, string, maps;
key = AREF (items, 4 * i);
string = AREF (items, 4 * i + 1);
maps = AREF (items, 4 * i + 2);
if (NILP (string))
break;
if (STRINGP (string) && STRING_MULTIBYTE (string))
string = ENCODE_UTF_8 (string);
submenu_start[i] = menu_items_used;
menu_items_n_panes = 0;
parse_single_submenu (key, string, maps);
submenu_n_panes[i] = menu_items_n_panes;
submenu_end[i] = menu_items_used;
submenu_names[i] = string;
}
submenu_start[i] = -1;
finish_menu_items ();
set_buffer_internal_1 (prev);
/* If there has been no change in the Lisp-level contents
of the menu bar, skip redisplaying it. Just exit. */
/* Compare the new menu items with the ones computed last time. */
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)
{
/* The menu items have not changed. Don't bother updating
the menus in any form, since it would be a no-op. */
discard_menu_items ();
unbind_to (specpdl_count, Qnil);
return;
}
/* Convert menu_items into widget_value trees
to display the menu. This cannot evaluate Lisp code. */
block_input ();
count = BMenu_count_items (mbar);
for (i = 0; submenu_start[i] >= 0; ++i)
{
void *mn = NULL;
if (i < count)
mn = BMenu_item_get_menu (BMenu_item_at (mbar, i));
if (mn)
BMenu_delete_all (mn);
else
mn = BMenu_new_menu_bar_submenu (mbar, SSDATA (submenu_names[i]));
menu_items_n_panes = submenu_n_panes[i];
digest_menu_items (mn, submenu_start[i], submenu_end[i], 1);
}
unblock_input ();
/* The menu items are different, so store them in the frame. */
fset_menu_bar_vector (f, menu_items);
f->menu_bar_items_used = menu_items_used;
}
/* This undoes save_menu_items. */
unbind_to (specpdl_count, Qnil);
}
void
run_menu_bar_help_event (struct frame *f, int mb_idx)
{
Lisp_Object frame, vec, help;
XSETFRAME (frame, f);
block_input ();
if (mb_idx < 0)
{
kbd_buffer_store_help_event (frame, Qnil);
unblock_input ();
return;
}
vec = f->menu_bar_vector;
if ((mb_idx + MENU_ITEMS_ITEM_HELP) >= ASIZE (vec))
return;
help = AREF (vec, mb_idx + MENU_ITEMS_ITEM_HELP);
if (STRINGP (help) || NILP (help))
kbd_buffer_store_help_event (frame, help);
unblock_input ();
}
DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_p,
0, 0, 0, doc: /* SKIP: real doc in xmenu.c. */)
(void)
{
return popup_activated_p ? Qt : Qnil;
}
DEFUN ("haiku-menu-bar-open", Fhaiku_menu_bar_open, Shaiku_menu_bar_open, 0, 1, "i",
doc: /* Show and start key navigation of the menu bar in FRAME.
This initially opens the first menu bar item and you can then navigate
with the arrow keys, select a menu entry with the return key, or
cancel with the escape key. If FRAME is nil or not given, use the
selected frame. If FRAME has no menu bar, a pop-up is displayed at
the position of the last non-menu event instead. */)
(Lisp_Object frame)
{
struct frame *f = decode_window_system_frame (frame);
int rc;
if (FRAME_EXTERNAL_MENU_BAR (f))
{
block_input ();
set_frame_menubar (f, 1);
rc = BMenuBar_start_tracking (FRAME_HAIKU_MENU_BAR (f));
unblock_input ();
if (!rc)
return Qnil;
FRAME_OUTPUT_DATA (f)->menu_bar_open_p = 1;
popup_activated_p += 1;
}
else
return call2 (Qpopup_menu, call0 (Qmouse_menu_bar_map),
last_nonmenu_event);
return Qnil;
}
void
haiku_activate_menubar (struct frame *f)
{
int rc;
if (!FRAME_HAIKU_MENU_BAR (f))
return;
set_frame_menubar (f, true);
if (FRAME_OUTPUT_DATA (f)->saved_menu_event)
{
block_input ();
rc = be_replay_menu_bar_event (FRAME_HAIKU_MENU_BAR (f),
FRAME_OUTPUT_DATA (f)->saved_menu_event);
xfree (FRAME_OUTPUT_DATA (f)->saved_menu_event);
FRAME_OUTPUT_DATA (f)->saved_menu_event = NULL;
unblock_input ();
if (!rc)
return;
FRAME_OUTPUT_DATA (f)->menu_bar_open_p = 1;
popup_activated_p += 1;
}
else
{
block_input ();
rc = BMenuBar_start_tracking (FRAME_HAIKU_MENU_BAR (f));
unblock_input ();
if (!rc)
return;
FRAME_OUTPUT_DATA (f)->menu_bar_open_p = 1;
popup_activated_p += 1;
}
}
void
syms_of_haikumenu (void)
{
DEFSYM (Qdebug_on_next_call, "debug-on-next-call");
DEFSYM (Qpopup_menu, "popup-menu");
DEFSYM (Qmouse_menu_bar_map, "mouse-menu-bar-map");
DEFSYM (Qtooltip_mode, "tooltip-mode");
defsubr (&Smenu_or_popup_active_p);
defsubr (&Shaiku_menu_bar_open);
return;
}
Reference in New Issue View Git Blame Copy Permalink