mirrors/mc
1
0
Fork 0
mirror of https://github.com/MidnightCommander/mc synced 2024-12-22 20:36:50 +03:00
Code Issues Packages Projects Releases Wiki Activity
5047d4d114
mc/lib/widget/menu.c
Andrew Borodin 6718b3ec26 Indentation using GNU indent-2.2.13. 
Signed-off-by: Andrew Borodin <aborodin@vmail.ru>
2024-06-02 12:49:13 +03:00

1100 lines
30 KiB
C
Raw Blame History

/*
Pulldown menu code
Copyright (C) 1994-2024
Free Software Foundation, Inc.
Written by:
Andrew Borodin <aborodin@vmail.ru>, 2012-2022
This file is part of the Midnight Commander.
The Midnight Commander 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.
The Midnight Commander 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \file menu.c
* \brief Source: pulldown menu code
*/
#include <config.h>
#include <ctype.h>
#include <stdarg.h>
#include <string.h>
#include <sys/types.h>
#include "lib/global.h"
#include "lib/tty/tty.h"
#include "lib/skin.h"
#include "lib/tty/key.h" /* key macros */
#include "lib/strutil.h"
#include "lib/widget.h"
#include "lib/event.h" /* mc_event_raise() */
/*** global variables ****************************************************************************/
const global_keymap_t *menu_map = NULL;
/*** file scope macro definitions ****************************************************************/
#define MENUENTRY(x) ((menu_entry_t *)(x))
#define MENU(x) ((menu_t *)(x))
/*** file scope type declarations ****************************************************************/
struct menu_entry_t
{
unsigned char first_letter;
hotkey_t text;
long command;
char *shortcut;
};
struct menu_t
{
int start_x; /* position relative to menubar start */
hotkey_t text;
GList *entries;
size_t max_entry_len; /* cached max length of entry texts (text + shortcut) */
size_t max_hotkey_len; /* cached max length of shortcuts */
unsigned int current; /* pointer to current menu entry */
char *help_node;
};
/*** forward declarations (file scope functions) *************************************************/
/*** file scope variables ************************************************************************/
/* --------------------------------------------------------------------------------------------- */
/*** file scope functions ************************************************************************/
/* --------------------------------------------------------------------------------------------- */
static void
menu_arrange (menu_t *menu, dlg_shortcut_str get_shortcut)
{
if (menu != NULL)
{
GList *i;
size_t max_shortcut_len = 0;
menu->max_entry_len = 1;
menu->max_hotkey_len = 1;
for (i = menu->entries; i != NULL; i = g_list_next (i))
{
menu_entry_t *entry = MENUENTRY (i->data);
if (entry != NULL)
{
size_t len;
len = (size_t) hotkey_width (entry->text);
menu->max_hotkey_len = MAX (menu->max_hotkey_len, len);
if (get_shortcut != NULL)
entry->shortcut = get_shortcut (entry->command);
if (entry->shortcut != NULL)
{
len = (size_t) str_term_width1 (entry->shortcut);
max_shortcut_len = MAX (max_shortcut_len, len);
}
}
}
menu->max_entry_len = menu->max_hotkey_len + max_shortcut_len;
}
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_paint_idx (const WMenuBar *menubar, unsigned int idx, int color)
{
const WRect *w = &CONST_WIDGET (menubar)->rect;
const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
const menu_entry_t *entry = MENUENTRY (g_list_nth_data (menu->entries, idx));
const int y = 2 + idx;
int x = menu->start_x;
if (x + menu->max_entry_len + 4 > (gsize) w->cols)
x = w->cols - menu->max_entry_len - 4;
if (entry == NULL)
{
/* menu separator */
tty_setcolor (MENU_ENTRY_COLOR);
widget_gotoyx (menubar, y, x - 1);
tty_print_alt_char (ACS_LTEE, FALSE);
tty_draw_hline (w->y + y, w->x + x, ACS_HLINE, menu->max_entry_len + 3);
widget_gotoyx (menubar, y, x + menu->max_entry_len + 3);
tty_print_alt_char (ACS_RTEE, FALSE);
}
else
{
int yt, xt;
/* menu text */
tty_setcolor (color);
widget_gotoyx (menubar, y, x);
tty_print_char ((unsigned char) entry->first_letter);
tty_getyx (&yt, &xt);
tty_draw_hline (yt, xt, ' ', menu->max_entry_len + 2); /* clear line */
tty_print_string (entry->text.start);
if (entry->text.hotkey != NULL)
{
tty_setcolor (color == MENU_SELECTED_COLOR ? MENU_HOTSEL_COLOR : MENU_HOT_COLOR);
tty_print_string (entry->text.hotkey);
tty_setcolor (color);
}
if (entry->text.end != NULL)
tty_print_string (entry->text.end);
if (entry->shortcut != NULL)
{
widget_gotoyx (menubar, y, x + menu->max_hotkey_len + 3);
tty_print_string (entry->shortcut);
}
/* move cursor to the start of entry text */
widget_gotoyx (menubar, y, x + 1);
}
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_draw_drop (const WMenuBar *menubar)
{
const WRect *w = &CONST_WIDGET (menubar)->rect;
const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
const unsigned int count = g_list_length (menu->entries);
int column = menu->start_x - 1;
unsigned int i;
if (column + menu->max_entry_len + 5 > (gsize) w->cols)
column = w->cols - menu->max_entry_len - 5;
if (mc_global.tty.shadows)
tty_draw_box_shadow (w->y + 1, w->x + column, count + 2, menu->max_entry_len + 5,
SHADOW_COLOR);
tty_setcolor (MENU_ENTRY_COLOR);
tty_draw_box (w->y + 1, w->x + column, count + 2, menu->max_entry_len + 5, FALSE);
for (i = 0; i < count; i++)
menubar_paint_idx (menubar, i, i == menu->current ? MENU_SELECTED_COLOR : MENU_ENTRY_COLOR);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_set_color (const WMenuBar *menubar, gboolean current, gboolean hotkey)
{
if (!widget_get_state (CONST_WIDGET (menubar), WST_FOCUSED))
tty_setcolor (MENU_INACTIVE_COLOR);
else if (current)
tty_setcolor (hotkey ? MENU_HOTSEL_COLOR : MENU_SELECTED_COLOR);
else
tty_setcolor (hotkey ? MENU_HOT_COLOR : MENU_ENTRY_COLOR);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_draw (const WMenuBar *menubar)
{
const WRect *w = &CONST_WIDGET (menubar)->rect;
GList *i;
/* First draw the complete menubar */
tty_setcolor (widget_get_state (WIDGET (menubar), WST_FOCUSED) ? MENU_ENTRY_COLOR :
MENU_INACTIVE_COLOR);
tty_draw_hline (w->y, w->x, ' ', w->cols);
/* Now each one of the entries */
for (i = menubar->menu; i != NULL; i = g_list_next (i))
{
menu_t *menu = MENU (i->data);
gboolean is_selected = (menubar->current == (gsize) g_list_position (menubar->menu, i));
menubar_set_color (menubar, is_selected, FALSE);
widget_gotoyx (menubar, 0, menu->start_x);
tty_print_char (' ');
tty_print_string (menu->text.start);
if (menu->text.hotkey != NULL)
{
menubar_set_color (menubar, is_selected, TRUE);
tty_print_string (menu->text.hotkey);
menubar_set_color (menubar, is_selected, FALSE);
}
if (menu->text.end != NULL)
tty_print_string (menu->text.end);
tty_print_char (' ');
}
if (menubar->is_dropped)
menubar_draw_drop (menubar);
else
widget_gotoyx (menubar, 0,
MENU (g_list_nth_data (menubar->menu, menubar->current))->start_x);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_remove (WMenuBar *menubar)
{
Widget *g;
if (!menubar->is_dropped)
return;
/* HACK: before refresh the dialog, change the current widget to keep the order
of overlapped widgets. This is useful in multi-window editor.
In general, menubar should be a special object, not an ordinary widget
in the current dialog. */
g = WIDGET (WIDGET (menubar)->owner);
GROUP (g)->current = widget_find (g, widget_find_by_id (g, menubar->previous_widget));
menubar->is_dropped = FALSE;
do_refresh ();
menubar->is_dropped = TRUE;
/* restore current widget */
GROUP (g)->current = widget_find (g, WIDGET (menubar));
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_left (WMenuBar *menubar)
{
menubar_remove (menubar);
if (menubar->current == 0)
menubar->current = g_list_length (menubar->menu) - 1;
else
menubar->current--;
menubar_draw (menubar);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_right (WMenuBar *menubar)
{
menubar_remove (menubar);
menubar->current = (menubar->current + 1) % g_list_length (menubar->menu);
menubar_draw (menubar);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_finish (WMenuBar *menubar)
{
Widget *w = WIDGET (menubar);
menubar->is_dropped = FALSE;
w->rect.lines = 1;
widget_want_hotkey (w, FALSE);
widget_set_options (w, WOP_SELECTABLE, FALSE);
if (!mc_global.keybar_visible)
widget_hide (w);
else
{
/* Move the menubar to the bottom so that widgets displayed on top of
* an "invisible" menubar get the first chance to respond to mouse events. */
widget_set_bottom (w);
}
/* background must be bottom */
if (DIALOG (w->owner)->bg != NULL)
widget_set_bottom (WIDGET (DIALOG (w->owner)->bg));
group_select_widget_by_id (w->owner, menubar->previous_widget);
do_refresh ();
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_drop (WMenuBar *menubar, unsigned int selected)
{
menubar->is_dropped = TRUE;
menubar->current = selected;
menubar_draw (menubar);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_execute (WMenuBar *menubar)
{
const menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
const menu_entry_t *entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
if ((entry != NULL) && (entry->command != CK_IgnoreKey))
{
Widget *w = WIDGET (menubar);
mc_global.widget.is_right = (menubar->current != 0);
menubar_finish (menubar);
send_message (w->owner, w, MSG_ACTION, entry->command, NULL);
do_refresh ();
}
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_down (WMenuBar *menubar)
{
menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
const unsigned int len = g_list_length (menu->entries);
menu_entry_t *entry;
menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
do
{
menu->current = (menu->current + 1) % len;
entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
}
while ((entry == NULL) || (entry->command == CK_IgnoreKey));
menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_up (WMenuBar *menubar)
{
menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
const unsigned int len = g_list_length (menu->entries);
menu_entry_t *entry;
menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
do
{
if (menu->current == 0)
menu->current = len - 1;
else
menu->current--;
entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
}
while ((entry == NULL) || (entry->command == CK_IgnoreKey));
menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_first (WMenuBar *menubar)
{
if (menubar->is_dropped)
{
menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
if (menu->current == 0)
return;
menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
menu->current = 0;
while (TRUE)
{
menu_entry_t *entry;
entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
if ((entry == NULL) || (entry->command == CK_IgnoreKey))
menu->current++;
else
break;
}
menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
}
else
{
menubar->current = 0;
menubar_draw (menubar);
}
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_last (WMenuBar *menubar)
{
if (menubar->is_dropped)
{
menu_t *menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
const unsigned int len = g_list_length (menu->entries);
menu_entry_t *entry;
if (menu->current == len - 1)
return;
menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
menu->current = len;
do
{
menu->current--;
entry = MENUENTRY (g_list_nth_data (menu->entries, menu->current));
}
while ((entry == NULL) || (entry->command == CK_IgnoreKey));
menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
}
else
{
menubar->current = g_list_length (menubar->menu) - 1;
menubar_draw (menubar);
}
}
/* --------------------------------------------------------------------------------------------- */
static cb_ret_t
menubar_try_drop_menu (WMenuBar *menubar, int hotkey)
{
GList *i;
for (i = menubar->menu; i != NULL; i = g_list_next (i))
{
menu_t *menu = MENU (i->data);
if (menu->text.hotkey != NULL && hotkey == g_ascii_tolower (menu->text.hotkey[0]))
{
menubar_drop (menubar, g_list_position (menubar->menu, i));
return MSG_HANDLED;
}
}
return MSG_NOT_HANDLED;
}
/* --------------------------------------------------------------------------------------------- */
static cb_ret_t
menubar_try_exec_menu (WMenuBar *menubar, int hotkey)
{
menu_t *menu;
GList *i;
menu = g_list_nth_data (menubar->menu, menubar->current);
for (i = menu->entries; i != NULL; i = g_list_next (i))
{
const menu_entry_t *entry = MENUENTRY (i->data);
if (entry != NULL && entry->text.hotkey != NULL
&& hotkey == g_ascii_tolower (entry->text.hotkey[0]))
{
menu->current = g_list_position (menu->entries, i);
menubar_execute (menubar);
return MSG_HANDLED;
}
}
return MSG_NOT_HANDLED;
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_help (const WMenuBar *menubar)
{
ev_help_t event_data;
event_data.filename = NULL;
if (menubar->is_dropped)
event_data.node = MENU (g_list_nth_data (menubar->menu, menubar->current))->help_node;
else
event_data.node = "[Menu Bar]";
mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
menubar_draw (menubar);
}
/* --------------------------------------------------------------------------------------------- */
static cb_ret_t
menubar_execute_cmd (WMenuBar *menubar, long command)
{
cb_ret_t ret = MSG_HANDLED;
switch (command)
{
case CK_Help:
menubar_help (menubar);
break;
case CK_Left:
menubar_left (menubar);
break;
case CK_Right:
menubar_right (menubar);
break;
case CK_Up:
if (menubar->is_dropped)
menubar_up (menubar);
break;
case CK_Down:
if (menubar->is_dropped)
menubar_down (menubar);
else
menubar_drop (menubar, menubar->current);
break;
case CK_Home:
menubar_first (menubar);
break;
case CK_End:
menubar_last (menubar);
break;
case CK_Enter:
if (menubar->is_dropped)
menubar_execute (menubar);
else
menubar_drop (menubar, menubar->current);
break;
case CK_Quit:
menubar_finish (menubar);
break;
default:
ret = MSG_NOT_HANDLED;
break;
}
return ret;
}
/* --------------------------------------------------------------------------------------------- */
static int
menubar_handle_key (WMenuBar *menubar, int key)
{
long cmd;
cb_ret_t ret = MSG_NOT_HANDLED;
cmd = widget_lookup_key (WIDGET (menubar), key);
if (cmd != CK_IgnoreKey)
ret = menubar_execute_cmd (menubar, cmd);
if (ret != MSG_HANDLED)
{
if (menubar->is_dropped)
ret = menubar_try_exec_menu (menubar, key);
else
ret = menubar_try_drop_menu (menubar, key);
}
return ret;
}
/* --------------------------------------------------------------------------------------------- */
static gboolean
menubar_refresh (WMenuBar *menubar)
{
Widget *w = WIDGET (menubar);
if (!widget_get_state (w, WST_FOCUSED))
return FALSE;
/* Trick to get all the mouse events */
w->rect.lines = LINES;
/* Trick to get all of the hotkeys */
widget_want_hotkey (w, TRUE);
return TRUE;
}
/* --------------------------------------------------------------------------------------------- */
static inline void
menubar_free_menu (WMenuBar *menubar)
{
g_clear_list (&menubar->menu, (GDestroyNotify) menu_free);
}
/* --------------------------------------------------------------------------------------------- */
static cb_ret_t
menubar_callback (Widget *w, Widget *sender, widget_msg_t msg, int parm, void *data)
{
WMenuBar *menubar = MENUBAR (w);
switch (msg)
{
/* We do not want the focus unless we have been activated */
case MSG_FOCUS:
if (menubar_refresh (menubar))
{
menubar_draw (menubar);
return MSG_HANDLED;
}
return MSG_NOT_HANDLED;
case MSG_UNFOCUS:
return widget_get_state (w, WST_FOCUSED) ? MSG_NOT_HANDLED : MSG_HANDLED;
/* We don't want the buttonbar to activate while using the menubar */
case MSG_HOTKEY:
case MSG_KEY:
if (widget_get_state (w, WST_FOCUSED))
{
menubar_handle_key (menubar, parm);
return MSG_HANDLED;
}
return MSG_NOT_HANDLED;
case MSG_CURSOR:
/* Put the cursor in a suitable place */
return MSG_NOT_HANDLED;
case MSG_DRAW:
if (widget_get_state (w, WST_VISIBLE) || menubar_refresh (menubar))
menubar_draw (menubar);
return MSG_HANDLED;
case MSG_RESIZE:
/* try show menu after screen resize */
widget_default_callback (w, NULL, MSG_RESIZE, 0, data);
menubar_refresh (menubar);
return MSG_HANDLED;
case MSG_DESTROY:
menubar_free_menu (menubar);
return MSG_HANDLED;
default:
return widget_default_callback (w, sender, msg, parm, data);
}
}
/* --------------------------------------------------------------------------------------------- */
static unsigned int
menubar_get_menu_by_x_coord (const WMenuBar *menubar, int x)
{
unsigned int i;
GList *menu;
for (i = 0, menu = menubar->menu;
menu != NULL && x >= MENU (menu->data)->start_x; i++, menu = g_list_next (menu))
;
/* Don't set the invalid value -1 */
if (i != 0)
i--;
return i;
}
/* --------------------------------------------------------------------------------------------- */
static gboolean
menubar_mouse_on_menu (const WMenuBar *menubar, int y, int x)
{
const WRect *w = &CONST_WIDGET (menubar)->rect;
menu_t *menu;
int left_x, right_x, bottom_y;
if (!menubar->is_dropped)
return FALSE;
menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
left_x = menu->start_x;
right_x = left_x + menu->max_entry_len + 3;
if (right_x > w->cols)
{
left_x = w->cols - (menu->max_entry_len + 3);
right_x = w->cols;
}
bottom_y = g_list_length (menu->entries) + 2; /* skip bar and top frame */
return (x >= left_x && x < right_x && y > 1 && y < bottom_y);
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_change_selected_item (WMenuBar *menubar, int y)
{
menu_t *menu;
menu_entry_t *entry;
y -= 2; /* skip bar and top frame */
menu = MENU (g_list_nth_data (menubar->menu, menubar->current));
entry = MENUENTRY (g_list_nth_data (menu->entries, y));
if (entry != NULL && entry->command != CK_IgnoreKey)
{
menubar_paint_idx (menubar, menu->current, MENU_ENTRY_COLOR);
menu->current = y;
menubar_paint_idx (menubar, menu->current, MENU_SELECTED_COLOR);
}
}
/* --------------------------------------------------------------------------------------------- */
static void
menubar_mouse_callback (Widget *w, mouse_msg_t msg, mouse_event_t *event)
{
static gboolean was_drag = FALSE;
WMenuBar *menubar = MENUBAR (w);
gboolean mouse_on_drop;
mouse_on_drop = menubar_mouse_on_menu (menubar, event->y, event->x);
switch (msg)
{
case MSG_MOUSE_DOWN:
was_drag = FALSE;
if (event->y == 0)
{
/* events on menubar */
unsigned int selected;
selected = menubar_get_menu_by_x_coord (menubar, event->x);
menubar_activate (menubar, TRUE, selected);
menubar_remove (menubar); /* if already shown */
menubar_drop (menubar, selected);
}
else if (mouse_on_drop)
menubar_change_selected_item (menubar, event->y);
else
{
/* mouse click outside menubar or dropdown -- close menu */
menubar_finish (menubar);
/*
* @FIXME.
*
* Unless we clear the 'capture' flag, we'll receive MSG_MOUSE_DRAG
* events belonging to this click (in case the user drags the mouse,
* of course).
*
* For the time being, we mark this with FIXME as this flag should
* preferably be regarded as "implementation detail" and not be
* touched by us. We should think of some other way of communicating
* this to the system.
*/
w->mouse.capture = FALSE;
}
break;
case MSG_MOUSE_UP:
if (was_drag && mouse_on_drop)
menubar_execute (menubar);
was_drag = FALSE;
break;
case MSG_MOUSE_CLICK:
was_drag = FALSE;
if ((event->buttons & GPM_B_MIDDLE) != 0 && event->y > 0 && menubar->is_dropped)
{
/* middle click -- everywhere */
menubar_execute (menubar);
}
else if (mouse_on_drop)
menubar_execute (menubar);
else if (event->y > 0)
/* releasing the mouse button outside the menu -- close menu */
menubar_finish (menubar);
break;
case MSG_MOUSE_DRAG:
if (event->y == 0)
{
menubar_remove (menubar);
menubar_drop (menubar, menubar_get_menu_by_x_coord (menubar, event->x));
}
else if (mouse_on_drop)
menubar_change_selected_item (menubar, event->y);
was_drag = TRUE;
break;
case MSG_MOUSE_SCROLL_UP:
case MSG_MOUSE_SCROLL_DOWN:
was_drag = FALSE;
if (widget_get_state (w, WST_FOCUSED))
{
if (event->y == 0)
{
/* menubar: left/right */
if (msg == MSG_MOUSE_SCROLL_UP)
menubar_left (menubar);
else
menubar_right (menubar);
}
else if (mouse_on_drop)
{
/* drop-down menu: up/down */
if (msg == MSG_MOUSE_SCROLL_UP)
menubar_up (menubar);
else
menubar_down (menubar);
}
}
break;
default:
was_drag = FALSE;
break;
}
}
/* --------------------------------------------------------------------------------------------- */
/*** public functions ****************************************************************************/
/* --------------------------------------------------------------------------------------------- */
menu_entry_t *
menu_entry_new (const char *name, long command)
{
menu_entry_t *entry;
entry = g_new (menu_entry_t, 1);
entry->first_letter = ' ';
entry->text = hotkey_new (name);
entry->command = command;
entry->shortcut = NULL;
return entry;
}
/* --------------------------------------------------------------------------------------------- */
void
menu_entry_free (menu_entry_t *entry)
{
if (entry != NULL)
{
hotkey_free (entry->text);
g_free (entry->shortcut);
g_free (entry);
}
}
/* --------------------------------------------------------------------------------------------- */
menu_t *
menu_new (const char *name, GList *entries, const char *help_node)
{
menu_t *menu;
menu = g_new (menu_t, 1);
menu->start_x = 0;
menu->text = hotkey_new (name);
menu->entries = entries;
menu->max_entry_len = 1;
menu->max_hotkey_len = 0;
menu->current = 0;
menu->help_node = g_strdup (help_node);
return menu;
}
/* --------------------------------------------------------------------------------------------- */
void
menu_set_name (menu_t *menu, const char *name)
{
hotkey_free (menu->text);
menu->text = hotkey_new (name);
}
/* --------------------------------------------------------------------------------------------- */
void
menu_free (menu_t *menu)
{
hotkey_free (menu->text);
g_list_free_full (menu->entries, (GDestroyNotify) menu_entry_free);
g_free (menu->help_node);
g_free (menu);
}
/* --------------------------------------------------------------------------------------------- */
WMenuBar *
menubar_new (GList *menu)
{
WRect r = { 0, 0, 1, COLS };
WMenuBar *menubar;
Widget *w;
menubar = g_new0 (WMenuBar, 1);
w = WIDGET (menubar);
widget_init (w, &r, menubar_callback, menubar_mouse_callback);
w->pos_flags = WPOS_KEEP_HORZ | WPOS_KEEP_TOP;
w->options |= WOP_TOP_SELECT;
w->keymap = menu_map;
menubar_set_menu (menubar, menu);
return menubar;
}
/* --------------------------------------------------------------------------------------------- */
void
menubar_set_menu (WMenuBar *menubar, GList *menu)
{
/* delete previous menu */
menubar_free_menu (menubar);
/* add new menu */
menubar->is_dropped = FALSE;
menubar->menu = menu;
menubar->current = 0;
menubar_arrange (menubar);
widget_set_state (WIDGET (menubar), WST_FOCUSED, FALSE);
}
/* --------------------------------------------------------------------------------------------- */
void
menubar_add_menu (WMenuBar *menubar, menu_t *menu)
{
if (menu != NULL)
{
menu_arrange (menu, DIALOG (WIDGET (menubar)->owner)->get_shortcut);
menubar->menu = g_list_append (menubar->menu, menu);
}
menubar_arrange (menubar);
}
/* --------------------------------------------------------------------------------------------- */
/**
* Properly space menubar items. Should be called when menubar is created
* and also when widget width is changed (i.e. upon xterm resize).
*/
void
menubar_arrange (WMenuBar *menubar)
{
int start_x = 1;
GList *i;
int gap;
if (menubar->menu == NULL)
return;
gap = WIDGET (menubar)->rect.cols - 2;
/* First, calculate gap between items... */
for (i = menubar->menu; i != NULL; i = g_list_next (i))
{
menu_t *menu = MENU (i->data);
/* preserve length here, to be used below */
menu->start_x = hotkey_width (menu->text) + 2;
gap -= menu->start_x;
}
if (g_list_next (menubar->menu) == NULL)
gap = 1;
else
gap /= (g_list_length (menubar->menu) - 1);
if (gap <= 0)
{
/* We are out of luck - window is too narrow... */
gap = 1;
}
else if (gap >= 3)
gap = 3;
/* ...and now fix start positions of menubar items */
for (i = menubar->menu; i != NULL; i = g_list_next (i))
{
menu_t *menu = MENU (i->data);
int len = menu->start_x;
menu->start_x = start_x;
start_x += len + gap;
}
}
/* --------------------------------------------------------------------------------------------- */
/** Find MenuBar widget in the dialog */
WMenuBar *
menubar_find (const WDialog *h)
{
return MENUBAR (widget_find_by_type (CONST_WIDGET (h), menubar_callback));
}
/* --------------------------------------------------------------------------------------------- */
/**
* Activate menu bar.
*
* @param menubar menu bar object
* @param dropped whether dropdown menus should be drooped or not
* @which number of active dropdown menu
*/
void
menubar_activate (WMenuBar *menubar, gboolean dropped, int which)
{
Widget *w = WIDGET (menubar);
widget_show (w);
if (!widget_get_state (w, WST_FOCUSED))
{
widget_set_options (w, WOP_SELECTABLE, TRUE);
menubar->is_dropped = dropped;
if (which >= 0)
menubar->current = (guint) which;
menubar->previous_widget = group_get_current_widget_id (w->owner);
/* Bring it to the top so it receives all mouse events before any other widget.
* See also comment in menubar_finish(). */
widget_select (w);
}
}
/* --------------------------------------------------------------------------------------------- */
Reference in New Issue View Git Blame Copy Permalink