void
update_cursor (WDialog * h)
{
GList *p = h->current;
if (p != NULL && widget_get_state (WIDGET (h), WST_ACTIVE))
{
Widget *w = WIDGET (p->data);
if (!widget_get_state (w, WST_DISABLED) && widget_get_options (w, WOP_WANT_CURSOR))
send_message (w, NULL, MSG_CURSOR, 0, NULL);
else
do
{
p = dlg_get_widget_next_of (p);
if (p == h->current)
break;
w = WIDGET (p->data);
if (!widget_get_state (w, WST_DISABLED) && widget_get_options (w, WOP_WANT_CURSOR)
&& send_message (w, NULL, MSG_CURSOR, 0, NULL) == MSG_HANDLED)
break;
}
while (TRUE);
}
}
void
dlg_init (WDialog * h)
{
Widget *wh = WIDGET (h);
if (top_dlg != NULL && widget_get_state (WIDGET (top_dlg->data), WST_MODAL))
widget_set_state (wh, WST_MODAL, TRUE);
/* add dialog to the stack */
top_dlg = g_list_prepend (top_dlg, h);
/* Initialize dialog manager and widgets */
if (widget_get_state (wh, WST_CONSTRUCT))
{
if (!widget_get_state (wh, WST_MODAL))
dialog_switch_add (h);
send_message (h, NULL, MSG_INIT, 0, NULL);
dlg_broadcast_msg (h, MSG_INIT);
dlg_read_history (h);
}
/* Select the first widget that takes focus */
while (h->current != NULL && !widget_get_options (WIDGET (h->current->data), WOP_SELECTABLE)
&& !widget_get_state (WIDGET (h->current->data), WST_DISABLED))
dlg_set_current_widget_next (h);
widget_set_state (wh, WST_ACTIVE, TRUE);
dlg_redraw (h);
/* focus found widget */
if (h->current != NULL)
widget_set_state (WIDGET (h->current->data), WST_FOCUSED, TRUE);
h->ret_value = 0;
}
/**
* Modify state of widget.
*
* @param w widget
* @param state widget state flag to modify
* @param enable specifies whether to turn the flag on (TRUE) or off (FALSE).
* Only one flag per call can be modified.
* @return MSG_HANDLED if set was handled successfully, MSG_NOT_HANDLED otherwise.
*/
cb_ret_t
widget_set_state (Widget * w, widget_state_t state, gboolean enable)
{
gboolean ret = MSG_HANDLED;
if (enable)
w->state |= state;
else
w->state &= ~state;
if (enable)
{
/* exclusive bits */
if ((state & WST_CONSTRUCT) != 0)
w->state &= ~(WST_ACTIVE | WST_SUSPENDED | WST_CLOSED);
else if ((state & WST_ACTIVE) != 0)
w->state &= ~(WST_CONSTRUCT | WST_SUSPENDED | WST_CLOSED);
else if ((state & WST_SUSPENDED) != 0)
w->state &= ~(WST_CONSTRUCT | WST_ACTIVE | WST_CLOSED);
else if ((state & WST_CLOSED) != 0)
w->state &= ~(WST_CONSTRUCT | WST_ACTIVE | WST_SUSPENDED);
}
if (w->owner == NULL)
return MSG_NOT_HANDLED;
switch (state)
{
case WST_DISABLED:
ret = send_message (w, NULL, enable ? MSG_DISABLE : MSG_ENABLE, 0, NULL);
if (ret == MSG_HANDLED && widget_get_state (WIDGET (w->owner), WST_ACTIVE))
ret = send_message (w, NULL, MSG_DRAW, 0, NULL);
break;
case WST_FOCUSED:
{
widget_msg_t msg;
msg = enable ? MSG_FOCUS : MSG_UNFOCUS;
ret = send_message (w, NULL, msg, 0, NULL);
if (ret == MSG_HANDLED && widget_get_state (WIDGET (w->owner), WST_ACTIVE))
{
send_message (w, NULL, MSG_DRAW, 0, NULL);
/* Notify owner that focus was moved from one widget to another */
send_message (w->owner, w, MSG_CHANGED_FOCUS, 0, NULL);
}
}
break;
default:
break;
}
return ret;
}
void
dlg_run_done (WDialog * h)
{
top_dlg = g_list_remove (top_dlg, h);
if (widget_get_state (WIDGET (h), WST_CLOSED))
{
send_message (h, h->current == NULL ? NULL : WIDGET (h->current->data), MSG_END, 0, NULL);
if (!widget_get_state (WIDGET (h), WST_MODAL))
dialog_switch_remove (h);
}
}
void
widget_replace (Widget * old_w, Widget * new_w)
{
WDialog *h = old_w->owner;
gboolean should_focus = FALSE;
GList *holder;
if (h->widgets == NULL)
return;
if (h->current == NULL)
h->current = h->widgets;
/* locate widget position in the list */
if (old_w == h->current->data)
holder = h->current;
else
holder = g_list_find (h->widgets, old_w);
/* if old widget is focused, we should focus the new one... */
if (widget_get_state (old_w, WST_FOCUSED))
should_focus = TRUE;
/* ...but if new widget isn't selectable, we cannot focus it */
if (!widget_get_options (new_w, WOP_SELECTABLE))
should_focus = FALSE;
/* if new widget isn't selectable, select other widget before replace */
if (!should_focus)
{
GList *l;
for (l = dlg_get_widget_next_of (holder);
!widget_get_options (WIDGET (l->data), WOP_SELECTABLE)
&& !widget_get_state (WIDGET (l->data), WST_DISABLED); l = dlg_get_widget_next_of (l))
;
widget_select (WIDGET (l->data));
}
/* replace widget */
new_w->owner = h;
new_w->id = old_w->id;
holder->data = new_w;
send_message (old_w, NULL, MSG_DESTROY, 0, NULL);
send_message (new_w, NULL, MSG_INIT, 0, NULL);
if (should_focus)
widget_select (new_w);
else
widget_redraw (new_w);
}
/** delete widget from dialog */
void
del_widget (void *w)
{
WDialog *h;
GList *d;
/* Don't accept NULL widget. This shouldn't happen */
if (w == NULL)
abort ();
h = WIDGET (w)->owner;
d = g_list_find (h->widgets, w);
if (d == h->current)
dlg_set_current_widget_next (h);
h->widgets = g_list_remove_link (h->widgets, d);
if (h->widgets == NULL)
h->current = NULL;
send_message (d->data, NULL, MSG_DESTROY, 0, NULL);
g_free (d->data);
g_list_free_1 (d);
/* widget has been deleted in runtime */
if (widget_get_state (WIDGET (h), WST_ACTIVE))
{
dlg_redraw (h);
dlg_select_current_widget (h);
}
}
void
widget_selectcolor (Widget * w, gboolean focused, gboolean hotkey)
{
WDialog *h = w->owner;
int color;
if (widget_get_state (w, WST_DISABLED))
color = DISABLED_COLOR;
else if (hotkey)
{
if (focused)
color = h->color[DLG_COLOR_HOT_FOCUS];
else
color = h->color[DLG_COLOR_HOT_NORMAL];
}
else
{
if (focused)
color = h->color[DLG_COLOR_FOCUS];
else
color = h->color[DLG_COLOR_NORMAL];
}
tty_setcolor (color);
}
static cb_ret_t
groupbox_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
{
WGroupbox *g = GROUPBOX (w);
switch (msg)
{
case MSG_DRAW:
{
WDialog *h = w->owner;
gboolean disabled;
disabled = widget_get_state (w, WST_DISABLED);
tty_setcolor (disabled ? DISABLED_COLOR : h->color[DLG_COLOR_NORMAL]);
tty_draw_box (w->y, w->x, w->lines, w->cols, TRUE);
if (g->title != NULL)
{
tty_setcolor (disabled ? DISABLED_COLOR : h->color[DLG_COLOR_TITLE]);
widget_move (w, 0, 1);
tty_print_string (g->title);
}
return MSG_HANDLED;
}
case MSG_DESTROY:
g_free (g->title);
return MSG_HANDLED;
default:
return widget_default_callback (w, sender, msg, parm, data);
}
}
gboolean
mcview_viewer (const char *command, const vfs_path_t * file_vpath, int start_line,
off_t search_start, off_t search_end)
{
gboolean succeeded;
WView *lc_mcview;
WDialog *view_dlg;
/* Create dialog and widgets, put them on the dialog */
view_dlg = dlg_create (FALSE, 0, 0, 1, 1, WPOS_FULLSCREEN, FALSE, NULL, mcview_dialog_callback,
NULL, "[Internal File Viewer]", NULL);
widget_want_tab (WIDGET (view_dlg), TRUE);
lc_mcview = mcview_new (0, 0, LINES - 1, COLS, FALSE);
add_widget (view_dlg, lc_mcview);
add_widget (view_dlg, buttonbar_new (TRUE));
view_dlg->get_title = mcview_get_title;
succeeded =
mcview_load (lc_mcview, command, vfs_path_as_str (file_vpath), start_line, search_start,
search_end);
if (succeeded)
dlg_run (view_dlg);
else
dlg_stop (view_dlg);
if (widget_get_state (WIDGET (view_dlg), WST_CLOSED))
dlg_destroy (view_dlg);
return succeeded;
}
static void
frontend_dlg_run (WDialog * h)
{
Widget *wh = WIDGET (h);
Gpm_Event event;
event.x = -1;
/* close opened editors, viewers, etc */
if (!widget_get_state (wh, WST_MODAL) && mc_global.midnight_shutdown)
{
send_message (h, NULL, MSG_VALIDATE, 0, NULL);
return;
}
while (widget_get_state (wh, WST_ACTIVE))
{
int d_key;
if (mc_global.tty.winch_flag != 0)
dialog_change_screen_size ();
if (is_idle ())
{
if (idle_hook)
execute_hooks (idle_hook);
while (widget_get_state (wh, WST_IDLE) && is_idle ())
send_message (wh, NULL, MSG_IDLE, 0, NULL);
/* Allow terminating the dialog from the idle handler */
if (!widget_get_state (wh, WST_ACTIVE))
break;
}
update_cursor (h);
/* Clear interrupt flag */
tty_got_interrupt ();
d_key = tty_get_event (&event, h->mouse_status == MOU_REPEAT, TRUE);
dlg_process_event (h, d_key, &event);
if (widget_get_state (wh, WST_CLOSED))
send_message (h, NULL, MSG_VALIDATE, 0, NULL);
}
}
unsigned long
add_widget_autopos (WDialog * h, void *w, widget_pos_flags_t pos_flags, const void *before)
{
Widget *wh = WIDGET (h);
Widget *widget;
GList *new_current;
/* Don't accept 0 widgets */
if (w == NULL)
abort ();
widget = WIDGET (w);
if ((pos_flags & WPOS_CENTER_HORZ) != 0)
widget->x = (wh->cols - widget->cols) / 2;
widget->x += wh->x;
if ((pos_flags & WPOS_CENTER_VERT) != 0)
widget->y = (wh->lines - widget->lines) / 2;
widget->y += wh->y;
widget->owner = h;
widget->pos_flags = pos_flags;
widget->id = h->widget_id++;
if (h->widgets == NULL || before == NULL)
{
h->widgets = g_list_append (h->widgets, widget);
new_current = g_list_last (h->widgets);
}
else
{
GList *b;
b = g_list_find (h->widgets, before);
/* don't accept widget not from dialog. This shouldn't happen */
if (b == NULL)
abort ();
b = g_list_next (b);
h->widgets = g_list_insert_before (h->widgets, b, widget);
if (b != NULL)
new_current = g_list_previous (b);
else
new_current = g_list_last (h->widgets);
}
/* widget has been added at runtime */
if (widget_get_state (wh, WST_ACTIVE))
{
send_message (widget, NULL, MSG_INIT, 0, NULL);
widget_select (widget);
}
else
h->current = new_current;
return widget->id;
}
void
dlg_erase (WDialog * h)
{
Widget *wh = WIDGET (h);
if (wh != NULL && widget_get_state (wh, WST_ACTIVE))
tty_fill_region (wh->y, wh->x, wh->lines, wh->cols, ' ');
}
static cb_ret_t
tree_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
{
WTree *tree = (WTree *) w;
WDialog *h = w->owner;
WButtonBar *b;
switch (msg)
{
case MSG_DRAW:
tree_frame (h, tree);
show_tree (tree);
if (widget_get_state (w, WST_FOCUSED))
{
b = find_buttonbar (h);
widget_redraw (WIDGET (b));
}
return MSG_HANDLED;
case MSG_FOCUS:
b = find_buttonbar (h);
buttonbar_set_label (b, 1, Q_ ("ButtonBar|Help"), tree_map, w);
buttonbar_set_label (b, 2, Q_ ("ButtonBar|Rescan"), tree_map, w);
buttonbar_set_label (b, 3, Q_ ("ButtonBar|Forget"), tree_map, w);
buttonbar_set_label (b, 4, tree_navigation_flag ? Q_ ("ButtonBar|Static")
: Q_ ("ButtonBar|Dynamc"), tree_map, w);
buttonbar_set_label (b, 5, Q_ ("ButtonBar|Copy"), tree_map, w);
buttonbar_set_label (b, 6, Q_ ("ButtonBar|RenMov"), tree_map, w);
#if 0
/* FIXME: mkdir is currently defunct */
buttonbar_set_label (b, 7, Q_ ("ButtonBar|Mkdir"), tree_map, w);
#else
buttonbar_clear_label (b, 7, w);
#endif
buttonbar_set_label (b, 8, Q_ ("ButtonBar|Rmdir"), tree_map, w);
return MSG_HANDLED;
case MSG_UNFOCUS:
tree->searching = 0;
return MSG_HANDLED;
case MSG_KEY:
return tree_key (tree, parm);
case MSG_ACTION:
/* command from buttonbar */
return tree_execute_cmd (tree, parm);
case MSG_DESTROY:
tree_destroy (tree);
return MSG_HANDLED;
default:
return widget_default_callback (w, sender, msg, parm, data);
}
}
/**
* Handle mouse events of editor screen.
*
* @param w Widget object (the editor)
* @param msg mouse event message
* @param event mouse event data
*/
static void
edit_dialog_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event)
{
gboolean unhandled = TRUE;
if (msg == MSG_MOUSE_DOWN && event->y == 0)
{
WDialog *h = DIALOG (w);
WMenuBar *b;
b = find_menubar (h);
if (!widget_get_state (WIDGET (b), WST_FOCUSED))
{
/* menubar */
GList *l;
GList *top = NULL;
int x;
/* Try find top fullscreen window */
for (l = h->widgets; l != NULL; l = g_list_next (l))
if (edit_widget_is_editor (CONST_WIDGET (l->data))
&& ((WEdit *) l->data)->fullscreen)
top = l;
/* Handle fullscreen/close buttons in the top line */
x = w->cols - 6;
if (top != NULL && event->x >= x)
{
WEdit *e = (WEdit *) top->data;
if (top != h->current)
{
/* Window is not active. Activate it */
widget_select (WIDGET (e));
}
/* Handle buttons */
if (event->x - x <= 2)
edit_toggle_fullscreen (e);
else
send_message (h, NULL, MSG_ACTION, CK_Close, NULL);
unhandled = FALSE;
}
if (unhandled)
menubar_activate (b, drop_menus, -1);
}
}
/* Continue handling of unhandled event in window or menu */
event->result.abort = unhandled;
}
void
widget_set_size (Widget * widget, int y, int x, int lines, int cols)
{
widget->x = x;
widget->y = y;
widget->cols = cols;
widget->lines = lines;
send_message (widget, NULL, MSG_RESIZE, 0, NULL);
if (widget->owner != NULL && widget_get_state (WIDGET (widget->owner), WST_ACTIVE))
send_message (widget, NULL, MSG_DRAW, 0, NULL);
}
void
widget_redraw (Widget * w)
{
if (w != NULL)
{
WDialog *h = w->owner;
if (h != NULL && widget_get_state (WIDGET (h), WST_ACTIVE))
w->callback (w, NULL, MSG_DRAW, 0, NULL);
}
}
static void
widget_focus (Widget * w)
{
WDialog *h = DIALOG (w->owner);
if (h == NULL)
return;
if (WIDGET (h->current->data) != w)
{
widget_do_focus (WIDGET (h->current->data), FALSE);
/* Test if focus lost was allowed and focus has really been loose */
if (h->current == NULL || !widget_get_state (WIDGET (h->current->data), WST_FOCUSED))
{
widget_do_focus (w, TRUE);
h->current = dlg_find (h, w);
}
}
else if (!widget_get_state (w, WST_FOCUSED))
widget_do_focus (w, TRUE);
}
static int
dlg_mouse_event (WDialog * h, Gpm_Event * event)
{
Widget *wh = WIDGET (h);
GList *p;
/* close the dialog by mouse left click out of dialog area */
if (mouse_close_dialog && (wh->pos_flags & WPOS_FULLSCREEN) == 0
&& ((event->buttons & GPM_B_LEFT) != 0) && ((event->type & GPM_DOWN) != 0)
&& !mouse_global_in_widget (event, wh))
{
h->ret_value = B_CANCEL;
dlg_stop (h);
return MOU_NORMAL;
}
if (wh->mouse_callback != NULL)
{
int mou;
mou = dlg_mouse_translator (event, wh);
if (mou != MOU_UNHANDLED)
return mou;
}
if (h->widgets == NULL)
return MOU_UNHANDLED;
/* send the event to widgets in reverse Z-order */
p = g_list_last (h->widgets);
do
{
Widget *w = WIDGET (p->data);
if (!widget_get_state (w, WST_DISABLED) && w->mouse_callback != NULL)
{
/* put global cursor position to the widget */
int ret;
ret = dlg_mouse_translator (event, w);
if (ret != MOU_UNHANDLED)
return ret;
}
p = g_list_previous (p);
}
while (p != NULL);
return MOU_UNHANDLED;
}
static cb_ret_t
listbox_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
{
WListbox *l = LISTBOX (w);
cb_ret_t ret_code;
switch (msg)
{
case MSG_HOTKEY:
{
int pos;
pos = listbox_check_hotkey (l, parm);
if (pos < 0)
return MSG_NOT_HANDLED;
listbox_run_hotkey (l, pos);
return MSG_HANDLED;
}
case MSG_KEY:
ret_code = listbox_key (l, parm);
if (ret_code != MSG_NOT_HANDLED)
listbox_on_change (l);
return ret_code;
case MSG_ACTION:
return listbox_execute_cmd (l, parm);
case MSG_CURSOR:
widget_move (l, l->cursor_y, 0);
return MSG_HANDLED;
case MSG_DRAW:
listbox_draw (l, widget_get_state (w, WST_FOCUSED));
return MSG_HANDLED;
case MSG_DESTROY:
listbox_destroy (l);
return MSG_HANDLED;
case MSG_RESIZE:
return MSG_HANDLED;
default:
return widget_default_callback (w, sender, msg, parm, data);
}
}
void
dlg_redraw (WDialog * h)
{
if (!widget_get_state (WIDGET (h), WST_ACTIVE))
return;
if (h->winch_pending)
{
h->winch_pending = FALSE;
send_message (h, NULL, MSG_RESIZE, 0, NULL);
}
send_message (h, NULL, MSG_DRAW, 0, NULL);
dlg_broadcast_msg (h, MSG_DRAW);
update_cursor (h);
}
static void
dlg_select_next_or_prev (WDialog * h, gboolean next)
{
if (h->widgets != NULL && h->current != NULL)
{
GList *l = h->current;
Widget *w;
do
{
l = dlg_get_next_or_prev_of (l, next);
w = WIDGET (l->data);
}
while ((widget_get_state (w, WST_DISABLED) || !widget_get_options (w, WOP_SELECTABLE))
&& l != h->current);
widget_select (l->data);
}
}
void
edit_update_screen (WEdit * e)
{
WDialog *h = WIDGET (e)->owner;
edit_scroll_screen_over_cursor (e);
edit_update_curs_col (e);
edit_status (e, widget_get_state (WIDGET (e), WST_FOCUSED));
/* pop all events for this window for internal handling */
if (!is_idle ())
e->force |= REDRAW_PAGE;
else
{
if ((e->force & REDRAW_COMPLETELY) != 0)
e->force |= REDRAW_PAGE;
edit_render_keypress (e);
}
widget_redraw (WIDGET (find_buttonbar (h)));
}
/** Clean the dialog area, draw the frame and the title */
void
dlg_default_repaint (WDialog * h)
{
Widget *wh = WIDGET (h);
int space;
if (!widget_get_state (wh, WST_ACTIVE))
return;
space = h->compact ? 0 : 1;
tty_setcolor (h->color[DLG_COLOR_NORMAL]);
dlg_erase (h);
tty_draw_box (wh->y + space, wh->x + space, wh->lines - 2 * space, wh->cols - 2 * space, FALSE);
if (h->title != NULL)
{
/* TODO: truncate long title */
tty_setcolor (h->color[DLG_COLOR_TITLE]);
widget_move (h, space, (wh->cols - str_term_width1 (h->title)) / 2);
tty_print_string (h->title);
}
}
static void
draw_history_button (WInput * in)
{
char c;
gboolean disabled;
if (g_list_next (in->history.current) == NULL)
c = '^';
else if (g_list_previous (in->history.current) == NULL)
c = 'v';
else
c = '|';
widget_move (in, 0, WIDGET (in)->cols - HISTORY_BUTTON_WIDTH);
disabled = widget_get_state (WIDGET (in), WST_DISABLED);
tty_setcolor (disabled ? DISABLED_COLOR : in->color[WINPUTC_HISTORY]);
#ifdef LARGE_HISTORY_BUTTON
tty_print_string ("[ ]");
widget_move (in, 0, WIDGET (in)->cols - HISTORY_BUTTON_WIDTH + 1);
#endif
tty_print_char (c);
}
gboolean
edit_files (const GList * files)
{
static gboolean made_directory = FALSE;
WDialog *edit_dlg;
WMenuBar *menubar;
const GList *file;
gboolean ok = FALSE;
if (!made_directory)
{
char *dir;
dir = mc_build_filename (mc_config_get_cache_path (), EDIT_DIR, (char *) NULL);
made_directory = (mkdir (dir, 0700) != -1 || errno == EEXIST);
g_free (dir);
dir = mc_build_filename (mc_config_get_path (), EDIT_DIR, (char *) NULL);
made_directory = (mkdir (dir, 0700) != -1 || errno == EEXIST);
g_free (dir);
dir = mc_build_filename (mc_config_get_data_path (), EDIT_DIR, (char *) NULL);
made_directory = (mkdir (dir, 0700) != -1 || errno == EEXIST);
g_free (dir);
}
/* Create a new dialog and add it widgets to it */
edit_dlg =
dlg_create (FALSE, 0, 0, 1, 1, WPOS_FULLSCREEN, FALSE, NULL, edit_dialog_callback,
edit_dialog_mouse_callback, "[Internal File Editor]", NULL);
widget_want_tab (WIDGET (edit_dlg), TRUE);
edit_dlg->get_shortcut = edit_get_shortcut;
edit_dlg->get_title = edit_get_title;
menubar = menubar_new (0, 0, COLS, NULL, TRUE);
add_widget (edit_dlg, menubar);
edit_init_menu (menubar);
add_widget (edit_dlg, buttonbar_new (TRUE));
for (file = files; file != NULL; file = g_list_next (file))
{
Widget *w = WIDGET (edit_dlg);
mcedit_arg_t *f = (mcedit_arg_t *) file->data;
gboolean f_ok;
f_ok = edit_add_window (edit_dlg, w->y + 1, w->x, w->lines - 2, w->cols, f->file_vpath,
f->line_number);
/* at least one file has been opened succefully */
ok = ok || f_ok;
}
if (ok)
dlg_run (edit_dlg);
if (!ok || widget_get_state (WIDGET (edit_dlg), WST_CLOSED))
dlg_destroy (edit_dlg);
return ok;
}
static void
listbox_draw (WListbox * l, gboolean focused)
{
Widget *w = WIDGET (l);
const WDialog *h = w->owner;
gboolean disabled;
int normalc, selc;
int length = 0;
GList *le = NULL;
int pos;
int i;
int sel_line = -1;
disabled = widget_get_state (w, WST_DISABLED);
normalc = disabled ? DISABLED_COLOR : h->color[DLG_COLOR_NORMAL];
/* *INDENT-OFF* */
selc = disabled
? DISABLED_COLOR
: focused
? h->color[DLG_COLOR_HOT_FOCUS]
: h->color[DLG_COLOR_FOCUS];
/* *INDENT-ON* */
if (l->list != NULL)
{
length = g_queue_get_length (l->list);
le = g_queue_peek_nth_link (l->list, (guint) l->top);
}
/* pos = (le == NULL) ? 0 : g_list_position (l->list, le); */
pos = (le == NULL) ? 0 : l->top;
for (i = 0; i < w->lines; i++)
{
const char *text = "";
/* Display the entry */
if (pos == l->pos && sel_line == -1)
{
sel_line = i;
tty_setcolor (selc);
}
else
tty_setcolor (normalc);
widget_move (l, i, 1);
if (l->list != NULL && le != NULL && (i == 0 || pos < length))
{
WLEntry *e = LENTRY (le->data);
text = e->text;
le = g_list_next (le);
pos++;
}
tty_print_string (str_fit_to_term (text, w->cols - 2, J_LEFT_FIT));
}
l->cursor_y = sel_line;
if (l->scrollbar && length > w->lines)
{
tty_setcolor (normalc);
listbox_drawscroll (l);
}
}
static void
show_tree (WTree * tree)
{
Widget *w = WIDGET (tree);
WDialog *h = w->owner;
tree_entry *current;
int i, j, topsublevel;
int x = 0, y = 0;
int tree_lines, tree_cols;
/* Initialize */
tree_lines = tlines (tree);
tree_cols = w->cols;
widget_move (w, y, x);
if (tree->is_panel)
{
tree_cols -= 2;
x = y = 1;
}
g_free (tree->tree_shown);
tree->tree_shown = g_new0 (tree_entry *, tree_lines);
if (tree->store->tree_first)
topsublevel = tree->store->tree_first->sublevel;
else
topsublevel = 0;
if (!tree->selected_ptr)
{
tree->selected_ptr = tree->store->tree_first;
tree->topdiff = 0;
}
current = tree->selected_ptr;
/* Calculate the directory which is to be shown on the topmost line */
if (!tree_navigation_flag)
current = back_ptr (current, &tree->topdiff);
else
{
i = 0;
while (current->prev && i < tree->topdiff)
{
current = current->prev;
if (current->sublevel < tree->selected_ptr->sublevel)
{
if (vfs_path_equal (current->name, tree->selected_ptr->name))
i++;
}
else if (current->sublevel == tree->selected_ptr->sublevel)
{
const char *cname;
cname = vfs_path_as_str (current->name);
for (j = strlen (cname) - 1; !IS_PATH_SEP (cname[j]); j--)
;
if (vfs_path_equal_len (current->name, tree->selected_ptr->name, j))
i++;
}
else if (current->sublevel == tree->selected_ptr->sublevel + 1)
{
j = vfs_path_len (tree->selected_ptr->name);
if (j > 1 && vfs_path_equal_len (current->name, tree->selected_ptr->name, j))
i++;
}
}
tree->topdiff = i;
}
/* Loop for every line */
for (i = 0; i < tree_lines; i++)
{
tty_setcolor (tree->is_panel ? NORMAL_COLOR : TREE_NORMALC (h));
/* Move to the beginning of the line */
tty_draw_hline (w->y + y + i, w->x + x, ' ', tree_cols);
if (current == NULL)
continue;
if (tree->is_panel)
tty_setcolor (widget_get_state (w, WST_FOCUSED) && current == tree->selected_ptr
? SELECTED_COLOR : NORMAL_COLOR);
else
tty_setcolor (current == tree->selected_ptr ? TREE_CURRENTC (h) : TREE_NORMALC (h));
tree->tree_shown[i] = current;
if (current->sublevel == topsublevel)
/* Show full name */
tty_print_string (str_fit_to_term
(vfs_path_as_str (current->name),
tree_cols + (tree->is_panel ? 0 : 1), J_LEFT_FIT));
else
{
/* Sub level directory */
tty_set_alt_charset (TRUE);
/* Output branch parts */
for (j = 0; j < current->sublevel - topsublevel - 1; j++)
{
if (tree_cols - 8 - 3 * j < 9)
break;
tty_print_char (' ');
if (current->submask & (1 << (j + topsublevel + 1)))
tty_print_char (ACS_VLINE);
else
tty_print_char (' ');
tty_print_char (' ');
}
tty_print_char (' ');
j++;
if (!current->next || !(current->next->submask & (1 << current->sublevel)))
tty_print_char (ACS_LLCORNER);
else
tty_print_char (ACS_LTEE);
tty_print_char (ACS_HLINE);
tty_set_alt_charset (FALSE);
/* Show sub-name */
tty_print_char (' ');
tty_print_string (str_fit_to_term
(current->subname, tree_cols - x - 3 * j, J_LEFT_FIT));
}
/* Calculate the next value for current */
current = current->next;
if (tree_navigation_flag)
{
while (current != NULL)
{
if (current->sublevel < tree->selected_ptr->sublevel)
{
if (vfs_path_equal_len (current->name, tree->selected_ptr->name,
vfs_path_len (current->name)))
break;
}
else if (current->sublevel == tree->selected_ptr->sublevel)
{
const char *cname;
cname = vfs_path_as_str (current->name);
for (j = strlen (cname) - 1; !IS_PATH_SEP (cname[j]); j--)
;
if (vfs_path_equal_len (current->name, tree->selected_ptr->name, j))
break;
}
else if (current->sublevel == tree->selected_ptr->sublevel + 1
&& vfs_path_len (tree->selected_ptr->name) > 1)
{
if (vfs_path_equal_len (current->name, tree->selected_ptr->name,
vfs_path_len (tree->selected_ptr->name)))
break;
}
current = current->next;
}
}
}
tree_show_mini_info (tree, tree_lines, tree_cols);
}
/**
* Mouse callback
*/
static void
tree_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event)
{
WTree *tree = (WTree *) w;
int y;
y = event->y;
if (tree->is_panel)
y--;
switch (msg)
{
case MSG_MOUSE_DOWN:
/* rest of the upper frame - call menu */
if (tree->is_panel && event->y == WIDGET (w->owner)->y)
{
/* return MOU_UNHANDLED */
event->result.abort = TRUE;
}
else if (!widget_get_state (w, WST_FOCUSED))
change_panel ();
break;
case MSG_MOUSE_CLICK:
{
int lines;
lines = tlines (tree);
if (y < 0)
{
tree_move_backward (tree, lines - 1);
show_tree (tree);
}
else if (y >= lines)
{
tree_move_forward (tree, lines - 1);
show_tree (tree);
}
else if ((event->count & GPM_DOUBLE) != 0)
{
if (tree->tree_shown[y] != NULL)
{
tree->selected_ptr = tree->tree_shown[y];
tree->topdiff = y;
}
tree_chdir_sel (tree);
}
}
break;
case MSG_MOUSE_SCROLL_UP:
case MSG_MOUSE_SCROLL_DOWN:
/* TODO: Ticket #2218 */
break;
default:
break;
}
}
static void
widget_do_focus (Widget * w, gboolean enable)
{
if (w != NULL && widget_get_state (WIDGET (w->owner), WST_FOCUSED))
widget_set_state (w, WST_FOCUSED, enable);
}
static cb_ret_t
dlg_try_hotkey (WDialog * h, int d_key)
{
GList *hot_cur;
Widget *current;
cb_ret_t handled;
int c;
if (h->widgets == NULL)
return MSG_NOT_HANDLED;
if (h->current == NULL)
h->current = h->widgets;
/*
* Explanation: we don't send letter hotkeys to other widgets if
* the currently selected widget is an input line
*/
current = WIDGET (h->current->data);
if (widget_get_state (current, WST_DISABLED))
return MSG_NOT_HANDLED;
if (widget_get_options (current, WOP_IS_INPUT))
{
/* skip ascii control characters, anything else can valid character in
* some encoding */
if (d_key >= 32 && d_key < 256)
return MSG_NOT_HANDLED;
}
/* If it's an alt key, send the message */
c = d_key & ~ALT (0);
if (d_key & ALT (0) && g_ascii_isalpha (c))
d_key = g_ascii_tolower (c);
handled = MSG_NOT_HANDLED;
if (widget_get_options (current, WOP_WANT_HOTKEY))
handled = send_message (current, NULL, MSG_HOTKEY, d_key, NULL);
/* If not used, send hotkey to other widgets */
if (handled == MSG_HANDLED)
return MSG_HANDLED;
hot_cur = dlg_get_widget_next_of (h->current);
/* send it to all widgets */
while (h->current != hot_cur && handled == MSG_NOT_HANDLED)
{
current = WIDGET (hot_cur->data);
if (widget_get_options (current, WOP_WANT_HOTKEY)
&& !widget_get_state (current, WST_DISABLED))
handled = send_message (current, NULL, MSG_HOTKEY, d_key, NULL);
if (handled == MSG_NOT_HANDLED)
hot_cur = dlg_get_widget_next_of (hot_cur);
}
if (handled == MSG_HANDLED)
widget_select (WIDGET (hot_cur->data));
return handled;
}
