static int
sel_skin_button (WButton * button, int action)
{
int result;
WListbox *skin_list;
WDialog *skin_dlg;
const gchar *skin_name;
int lxx, lyy;
unsigned int i;
unsigned int pos = 1;
(void) action;
lxx = COLS / 2;
lyy = (LINES - 13) / 2;
skin_dlg =
dlg_create (TRUE, lyy, lxx, 13, 24, dialog_colors, NULL, NULL, "[Appearance]", _("Skins"),
DLG_COMPACT);
skin_list = listbox_new (1, 1, 11, 22, FALSE, NULL);
skin_name = "default";
listbox_add_item (skin_list, LISTBOX_APPEND_AT_END, 0, skin_name_to_label (skin_name),
(void *) skin_name);
if (strcmp (skin_name, current_skin_name) == 0)
listbox_select_entry (skin_list, 0);
for (i = 0; i < skin_names->len; i++)
{
skin_name = g_ptr_array_index (skin_names, i);
if (strcmp (skin_name, "default") != 0)
{
listbox_add_item (skin_list, LISTBOX_APPEND_AT_END, 0, skin_name_to_label (skin_name),
(void *) skin_name);
if (strcmp (skin_name, current_skin_name) == 0)
listbox_select_entry (skin_list, pos);
pos++;
}
}
add_widget (skin_dlg, skin_list);
result = dlg_run (skin_dlg);
if (result == B_ENTER)
{
Widget *w;
gchar *skin_label;
listbox_get_current (skin_list, &skin_label, (void **) &skin_name);
g_free (current_skin_name);
current_skin_name = g_strdup (skin_name);
skin_apply (skin_name);
w = dlg_find_by_id (WIDGET (button)->owner, skin_name_id);
button_set_text (BUTTON (w), str_fit_to_term (skin_label, 20, J_LEFT_FIT));
}
dlg_destroy (skin_dlg);
return 0;
}
static void
listbox_run_hotkey (WListbox * l, int pos)
{
listbox_select_entry (l, pos);
listbox_on_change (l);
listbox_do_action (l);
}
static char *
collect_new_format (void)
{
char *newformat;
int i;
char *last;
char *text, *extra;
newformat = g_malloc (1024);
if (radio_genwidth->sel)
strcpy (newformat, "full ");
else
strcpy (newformat, "half ");
if (radio_columns->sel)
strcat (newformat, "2 ");
last = NULL;
for (i = 0;; i++)
{
listbox_select_entry (l_listmode, i);
listbox_get_current (l_listmode, &text, &extra);
if (text == last)
break;
if (last != NULL)
strcat (newformat, ",");
strcat (newformat, text);
last = text;
}
return newformat;
}
/* Return MSG_HANDLED if we want a redraw */
static cb_ret_t
listbox_key (WListbox * l, int key)
{
unsigned long command;
if (l->list == NULL)
return MSG_NOT_HANDLED;
/* focus on listbox item N by '0'..'9' keys */
if (key >= '0' && key <= '9')
{
int oldpos = l->pos;
listbox_select_entry (l, key - '0');
/* need scroll to item? */
if (abs (oldpos - l->pos) > WIDGET (l)->lines)
l->top = l->pos;
return MSG_HANDLED;
}
command = keybind_lookup_keymap_command (listbox_map, key);
if (command == CK_IgnoreKey)
return MSG_NOT_HANDLED;
return listbox_execute_cmd (l, command);
}
static void
listbox_fwd (WListbox * l)
{
if ((guint) l->pos + 1 >= g_queue_get_length (l->list))
listbox_select_first (l);
else
listbox_select_entry (l, l->pos + 1);
}
static void
listbox_fwd (WListbox * l, gboolean wrap)
{
if ((guint) l->pos + 1 < g_queue_get_length (l->list))
listbox_select_entry (l, l->pos + 1);
else if (wrap)
listbox_select_first (l);
}
static void
listbox_back (WListbox * l)
{
if (l->pos <= 0)
listbox_select_last (l);
else
listbox_select_entry (l, l->pos - 1);
}
static void
listbox_back (WListbox * l, gboolean wrap)
{
if (l->pos > 0)
listbox_select_entry (l, l->pos - 1);
else if (wrap)
listbox_select_last (l);
}
static void
listbox_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event)
{
WListbox *l = LISTBOX (w);
int old_pos;
old_pos = l->pos;
switch (msg)
{
case MSG_MOUSE_DOWN:
widget_select (w);
listbox_select_entry (l, listbox_y_pos (l, event->y));
break;
case MSG_MOUSE_SCROLL_UP:
listbox_back (l, FALSE);
break;
case MSG_MOUSE_SCROLL_DOWN:
listbox_fwd (l, FALSE);
break;
case MSG_MOUSE_DRAG:
event->result.repeat = TRUE; /* It'd be functional even without this. */
listbox_select_entry (l, listbox_y_pos (l, event->y));
break;
case MSG_MOUSE_CLICK:
/* We don't call listbox_select_entry() here: MSG_MOUSE_DOWN/DRAG did this already. */
if (event->count == GPM_DOUBLE) /* Double click */
listbox_do_action (l);
break;
default:
break;
}
/* If the selection has changed, we redraw the widget and notify the dialog. */
if (l->pos != old_pos)
listbox_on_change (l);
}
static void
edit_window_list (const Dlg_head * h)
{
const size_t offset = 2; /* skip menu and buttonbar */
const size_t dlg_num = g_list_length (h->widgets) - offset;
int lines, cols;
Listbox *listbox;
GList *w;
int i = 0;
int rv;
lines = min ((size_t) (LINES * 2 / 3), dlg_num);
cols = COLS * 2 / 3;
listbox = create_listbox_window (lines, cols, _("Open files"), "[Open files]");
for (w = h->widgets; w != NULL; w = g_list_next (w))
if (edit_widget_is_editor ((Widget *) w->data))
{
WEdit *e = (WEdit *) w->data;
char *fname;
if (e->filename_vpath == NULL)
fname = g_strdup_printf ("%c [%s]", e->modified ? '*' : ' ', _("NoName"));
else
{
char *fname2;
fname2 = vfs_path_to_str (e->filename_vpath);
fname = g_strdup_printf ("%c%s", e->modified ? '*' : ' ', fname2);
g_free (fname2);
}
listbox_add_item (listbox->list, LISTBOX_APPEND_AT_END, get_hotkey (i++),
str_term_trim (fname, listbox->list->widget.cols - 2), NULL);
g_free (fname);
}
rv = g_list_position (h->widgets, h->current) - offset;
listbox_select_entry (listbox->list, rv);
rv = run_listbox (listbox);
if (rv >= 0)
{
w = g_list_nth (h->widgets, rv + offset);
dlg_set_top_widget (w->data);
}
}
void
dialog_switch_list (void)
{
const size_t dlg_num = g_list_length (mc_dialogs);
int lines, cols;
Listbox *listbox;
GList *h;
int i = 0;
int rv;
if (mc_global.widget.midnight_shutdown || mc_current == NULL)
return;
lines = min ((size_t) (LINES * 2 / 3), dlg_num);
cols = COLS * 2 / 3;
listbox = create_listbox_window (lines, cols, _("Screens"), "[Screen selector]");
for (h = mc_dialogs; h != NULL; h = g_list_next (h))
{
Dlg_head *dlg;
char *title;
dlg = (Dlg_head *) h->data;
if ((dlg != NULL) && (dlg->get_title != NULL))
title = dlg->get_title (dlg, listbox->list->widget.cols - 2); /* FIXME! */
else
title = g_strdup ("");
listbox_add_item (listbox->list, LISTBOX_APPEND_BEFORE, get_hotkey (i++), title, NULL);
g_free (title);
}
listbox_select_entry (listbox->list, dlg_num - 1 - g_list_position (mc_dialogs, mc_current));
rv = run_listbox (listbox);
if (rv >= 0)
{
h = g_list_nth (mc_dialogs, dlg_num - 1 - rv);
dialog_switch_goto (h);
}
}
/* Return MSG_HANDLED if we want a redraw */
static cb_ret_t
listbox_key (WListbox * l, int key)
{
long command;
if (l->list == NULL)
return MSG_NOT_HANDLED;
/* focus on listbox item N by '0'..'9' keys */
if (key >= '0' && key <= '9')
{
listbox_select_entry (l, key - '0');
return MSG_HANDLED;
}
command = keybind_lookup_keymap_command (listbox_map, key);
if (command == CK_IgnoreKey)
return MSG_NOT_HANDLED;
return listbox_execute_cmd (l, command);
}
static int
exec_edit_syntax_dialog (const GPtrArray * names, const char *current_syntax)
{
size_t i;
Listbox *syntaxlist;
syntaxlist = create_listbox_window (LIST_LINES, MAX_ENTRY_LEN,
_("Choose syntax highlighting"), NULL);
LISTBOX_APPEND_TEXT (syntaxlist, 'A', _("< Auto >"), NULL);
LISTBOX_APPEND_TEXT (syntaxlist, 'R', _("< Reload Current Syntax >"), NULL);
for (i = 0; i < names->len; i++)
{
const char *name;
name = g_ptr_array_index (names, i);
LISTBOX_APPEND_TEXT (syntaxlist, 0, name, NULL);
if (current_syntax != NULL && strcmp (name, current_syntax) == 0)
listbox_select_entry (syntaxlist->list, i + N_DFLT_ENTRIES);
}
return run_listbox (syntaxlist);
}
static cb_ret_t
query_callback (Dlg_head *h, dlg_msg_t msg, int parm)
{
switch (msg) {
case DLG_KEY:
switch (parm) {
case KEY_LEFT:
case KEY_RIGHT:
h->ret_value = 0;
dlg_stop (h);
return 1;
case KEY_BACKSPACE:
if (end == min_end) {
h->ret_value = 0;
dlg_stop (h);
return 1;
} else {
WLEntry *e, *e1;
e1 = e = ((WListbox *) (h->current))->list;
do {
if (!strncmp
(input->buffer + start, e1->text,
end - start - 1)) {
listbox_select_entry ((WListbox *) (h->current),
e1);
handle_char (input, parm);
end--;
send_message (h->current, WIDGET_DRAW, 0);
break;
}
e1 = e1->next;
} while (e != e1);
}
return 1;
default:
if (parm > 0xff || !is_printable (parm)) {
if (is_in_input_map (input, parm) == 2) {
if (end == min_end)
return 1;
h->ret_value = B_USER; /* This means we want to refill the
list box and start again */
dlg_stop (h);
return 1;
} else
return 0;
} else {
WLEntry *e, *e1;
int need_redraw = 0;
int low = 4096;
char *last_text = NULL;
e1 = e = ((WListbox *) (h->current))->list;
do {
if (!strncmp
(input->buffer + start, e1->text, end - start)) {
if (e1->text[end - start] == parm) {
if (need_redraw) {
register int c1, c2, si;
for (si = end - start + 1;
(c1 = last_text[si])
&& (c2 = e1->text[si]); si++)
if (c1 != c2)
break;
if (low > si)
low = si;
last_text = e1->text;
need_redraw = 2;
} else {
need_redraw = 1;
listbox_select_entry ((WListbox *) (h->
current),
e1);
last_text = e1->text;
}
}
}
e1 = e1->next;
} while (e != e1);
if (need_redraw == 2) {
insert_text (input, last_text, low);
send_message (h->current, WIDGET_DRAW, 0);
} else if (need_redraw == 1) {
h->ret_value = B_ENTER;
dlg_stop (h);
}
}
return MSG_HANDLED;
}
break;
default:
return default_dlg_callback (h, msg, parm);
}
}
static void
listbox_back_n (WListbox * l, int n)
{
listbox_select_entry (l, MAX (l->pos - n, 0));
}
void
chown_cmd (void)
{
char *fname;
struct stat sf_stat;
uid_t new_user;
gid_t new_group;
char buffer[BUF_TINY];
chown_i18n ();
do
{ /* do while any files remaining */
vfs_path_t *vpath;
WDialog *ch_dlg;
ch_dlg = init_chown ();
new_user = new_group = -1;
if (current_panel->marked)
fname = next_file (); /* next marked file */
else
fname = selection (current_panel)->fname; /* single file */
vpath = vfs_path_from_str (fname);
if (mc_stat (vpath, &sf_stat) != 0)
{ /* get status of file */
dlg_destroy (ch_dlg);
vfs_path_free (vpath);
break;
}
vfs_path_free (vpath);
/* select in listboxes */
listbox_select_entry (l_user, listbox_search_text (l_user, get_owner (sf_stat.st_uid)));
listbox_select_entry (l_group, listbox_search_text (l_group, get_group (sf_stat.st_gid)));
chown_label (0, str_trunc (fname, GW - 4));
chown_label (1, str_trunc (get_owner (sf_stat.st_uid), GW - 4));
chown_label (2, str_trunc (get_group (sf_stat.st_gid), GW - 4));
size_trunc_len (buffer, GW - 4, sf_stat.st_size, 0, panels_options.kilobyte_si);
chown_label (3, buffer);
chown_label (4, string_perm (sf_stat.st_mode));
switch (dlg_run (ch_dlg))
{
case B_CANCEL:
end_chown = 1;
break;
case B_SETUSR:
{
struct passwd *user;
char *text;
listbox_get_current (l_user, &text, NULL);
user = getpwnam (text);
if (user)
{
new_user = user->pw_uid;
apply_chowns (new_user, new_group);
}
break;
}
case B_SETGRP:
{
struct group *grp;
char *text;
listbox_get_current (l_group, &text, NULL);
grp = getgrnam (text);
if (grp)
{
new_group = grp->gr_gid;
apply_chowns (new_user, new_group);
}
break;
}
case B_SETALL:
case B_ENTER:
{
struct group *grp;
struct passwd *user;
char *text;
listbox_get_current (l_group, &text, NULL);
grp = getgrnam (text);
if (grp)
new_group = grp->gr_gid;
listbox_get_current (l_user, &text, NULL);
user = getpwnam (text);
if (user)
new_user = user->pw_uid;
if (ch_dlg->ret_value == B_ENTER)
{
vfs_path_t *fname_vpath;
fname_vpath = vfs_path_from_str (fname);
need_update = 1;
if (mc_chown (fname_vpath, new_user, new_group) == -1)
message (D_ERROR, MSG_ERROR, _("Cannot chown \"%s\"\n%s"),
fname, unix_error_string (errno));
vfs_path_free (fname_vpath);
}
else
apply_chowns (new_user, new_group);
break;
}
} /* switch */
if (current_panel->marked && ch_dlg->ret_value != B_CANCEL)
{
do_file_mark (current_panel, current_file, 0);
need_update = 1;
}
dlg_destroy (ch_dlg);
}
while (current_panel->marked && !end_chown);
chown_done ();
}
static cb_ret_t
query_callback (Dlg_head * h, Widget * sender, dlg_msg_t msg, int parm, void *data)
{
static char buff[MB_LEN_MAX] = "";
static int bl = 0;
switch (msg)
{
case DLG_KEY:
switch (parm)
{
case KEY_LEFT:
case KEY_RIGHT:
bl = 0;
h->ret_value = 0;
dlg_stop (h);
return MSG_HANDLED;
case KEY_BACKSPACE:
bl = 0;
/* exit from completion list if input line is empty */
if (end == 0)
{
h->ret_value = 0;
dlg_stop (h);
}
/* Refill the list box and start again */
else if (end == min_end)
{
end = str_get_prev_char (&input->buffer[end]) - input->buffer;
input_handle_char (input, parm);
h->ret_value = B_USER;
dlg_stop (h);
return MSG_HANDLED;
}
else
{
int new_end;
int i;
GList *e;
new_end = str_get_prev_char (&input->buffer[end]) - input->buffer;
for (i = 0, e = ((WListbox *) h->current->data)->list;
e != NULL; i++, e = g_list_next (e))
{
WLEntry *le = (WLEntry *) e->data;
if (strncmp (input->buffer + start, le->text, new_end - start) == 0)
{
listbox_select_entry ((WListbox *) h->current->data, i);
end = new_end;
input_handle_char (input, parm);
send_message ((Widget *) h->current->data, WIDGET_DRAW, 0);
break;
}
}
}
return MSG_HANDLED;
default:
if (parm < 32 || parm > 255)
{
bl = 0;
if (input_key_is_in_map (input, parm) != 2)
return MSG_NOT_HANDLED;
if (end == min_end)
return MSG_HANDLED;
/* This means we want to refill the list box and start again */
h->ret_value = B_USER;
dlg_stop (h);
return MSG_HANDLED;
}
else
{
GList *e;
int i;
int need_redraw = 0;
int low = 4096;
char *last_text = NULL;
buff[bl++] = (char) parm;
buff[bl] = '\0';
switch (str_is_valid_char (buff, bl))
{
case -1:
bl = 0;
/* fallthrough */
case -2:
return MSG_HANDLED;
}
for (i = 0, e = ((WListbox *) h->current->data)->list;
e != NULL; i++, e = g_list_next (e))
{
WLEntry *le = (WLEntry *) e->data;
if (strncmp (input->buffer + start, le->text, end - start) == 0
&& strncmp (&le->text[end - start], buff, bl) == 0)
{
if (need_redraw == 0)
{
need_redraw = 1;
listbox_select_entry ((WListbox *) h->current->data, i);
last_text = le->text;
}
else
{
char *si, *sl;
int si_num = 0;
int sl_num = 0;
/* count symbols between start and end */
for (si = le->text + start; si < le->text + end;
str_next_char (&si), si_num++)
;
for (sl = last_text + start; sl < last_text + end;
str_next_char (&sl), sl_num++)
;
/* pointers to next symbols */
si = &le->text[str_offset_to_pos (le->text, ++si_num)];
sl = &last_text[str_offset_to_pos (last_text, ++sl_num)];
while (si[0] != '\0' && sl[0] != '\0')
{
char *nexti, *nextl;
nexti = str_get_next_char (si);
nextl = str_get_next_char (sl);
if (nexti - si != nextl - sl || strncmp (si, sl, nexti - si) != 0)
break;
si = nexti;
sl = nextl;
si_num++;
}
last_text = le->text;
si = &last_text[str_offset_to_pos (last_text, si_num)];
if (low > si - last_text)
low = si - last_text;
need_redraw = 2;
}
}
}
if (need_redraw == 2)
{
insert_text (input, last_text, low);
send_message ((Widget *) h->current->data, WIDGET_DRAW, 0);
}
else if (need_redraw == 1)
{
h->ret_value = B_ENTER;
dlg_stop (h);
}
bl = 0;
}
return MSG_HANDLED;
}
break;
default:
return default_dlg_callback (h, sender, msg, parm, data);
}
}
char *
history_show (GList ** history, Widget * widget, int current)
{
GList *z, *hlist = NULL, *hi;
size_t maxlen, i, count = 0;
char *r = NULL;
Dlg_head *query_dlg;
WListbox *query_list;
history_dlg_data hist_data;
if (*history == NULL)
return NULL;
maxlen = str_term_width1 (_("History")) + 2;
for (z = *history; z != NULL; z = g_list_previous (z))
{
WLEntry *entry;
i = str_term_width1 ((char *) z->data);
maxlen = max (maxlen, i);
count++;
entry = g_new0 (WLEntry, 1);
/* history is being reverted here */
entry->text = g_strdup ((char *) z->data);
hlist = g_list_prepend (hlist, entry);
}
hist_data.widget = widget;
hist_data.count = count;
hist_data.maxlen = maxlen;
query_dlg =
create_dlg (TRUE, 0, 0, 4, 4, dialog_colors, history_dlg_callback, NULL,
"[History-query]", _("History"), DLG_COMPACT);
query_dlg->data = &hist_data;
query_list = listbox_new (1, 1, 2, 2, TRUE, NULL);
/* this call makes list stick to all sides of dialog, effectively make
it be resized with dialog */
add_widget_autopos (query_dlg, query_list, WPOS_KEEP_ALL, NULL);
/* to avoid diplicating of (calculating sizes in two places)
code, call dlg_hist_callback function here, to set dialog and
controls positions.
The main idea - create 4x4 dialog and add 2x2 list in
center of it, and let dialog function resize it to needed
size. */
history_dlg_callback (query_dlg, NULL, DLG_RESIZE, 0, NULL);
if (query_dlg->y < widget->y)
{
/* draw list entries from bottom upto top */
listbox_set_list (query_list, hlist);
if (current < 0 || (size_t) current >= count)
listbox_select_last (query_list);
else
listbox_select_entry (query_list, count - 1 - (size_t) current);
}
else
{
/* draw list entries from top downto bottom */
/* revert history direction */
hlist = g_list_reverse (hlist);
listbox_set_list (query_list, hlist);
if (current > 0)
listbox_select_entry (query_list, current);
}
if (run_dlg (query_dlg) != B_CANCEL)
{
char *q;
listbox_get_current (query_list, &q, NULL);
r = g_strdup (q);
}
/* get modified history from dialog */
z = NULL;
for (hi = query_list->list; hi != NULL; hi = g_list_next (hi))
{
WLEntry *entry;
entry = (WLEntry *) hi->data;
/* history is being reverted here again */
z = g_list_prepend (z, entry->text);
entry->text = NULL;
}
/* restore history direction */
if (query_dlg->y < widget->y)
z = g_list_reverse (z);
destroy_dlg (query_dlg);
g_list_foreach (*history, (GFunc) g_free, NULL);
g_list_free (*history);
*history = g_list_last (z);
return r;
}
gboolean
user_menu_cmd (struct WEdit * edit_widget, const char *menu_file, int selected_entry)
{
char *p;
char *data, **entries;
int max_cols, menu_lines, menu_limit;
int col, i, accept_entry = 1;
int selected, old_patterns;
gboolean res = FALSE;
gboolean interactive = TRUE;
if (!vfs_current_is_local ())
{
message (D_ERROR, MSG_ERROR, "%s", _("Cannot execute commands on non-local filesystems"));
return FALSE;
}
if (menu_file != NULL)
menu = g_strdup (menu_file);
else
menu = g_strdup (edit_widget ? EDIT_LOCAL_MENU : MC_LOCAL_MENU);
if (!exist_file (menu) || !menu_file_own (menu))
{
if (menu_file != NULL)
{
message (D_ERROR, MSG_ERROR, _("Cannot open file %s\n%s"), menu,
unix_error_string (errno));
MC_PTR_FREE (menu);
return FALSE;
}
g_free (menu);
if (edit_widget)
menu = mc_config_get_full_path (EDIT_HOME_MENU);
else
menu = mc_config_get_full_path (MC_USERMENU_FILE);
if (!exist_file (menu))
{
g_free (menu);
menu =
mc_build_filename (mc_config_get_home_dir (),
edit_widget ? EDIT_GLOBAL_MENU : MC_GLOBAL_MENU, NULL);
if (!exist_file (menu))
{
g_free (menu);
menu =
mc_build_filename (mc_global.sysconfig_dir,
edit_widget ? EDIT_GLOBAL_MENU : MC_GLOBAL_MENU, NULL);
if (!exist_file (menu))
{
g_free (menu);
menu = mc_build_filename
(mc_global.share_data_dir, edit_widget ? EDIT_GLOBAL_MENU : MC_GLOBAL_MENU,
NULL);
}
}
}
}
if (!g_file_get_contents (menu, &data, NULL, NULL))
{
message (D_ERROR, MSG_ERROR, _("Cannot open file%s\n%s"), menu, unix_error_string (errno));
MC_PTR_FREE (menu);
return FALSE;
}
max_cols = 0;
selected = 0;
menu_limit = 0;
entries = 0;
/* Parse the menu file */
old_patterns = easy_patterns;
p = check_patterns (data);
for (menu_lines = col = 0; *p; str_next_char (&p))
{
if (menu_lines >= menu_limit)
{
char **new_entries;
menu_limit += MAX_ENTRIES;
new_entries = g_try_realloc (entries, sizeof (new_entries[0]) * menu_limit);
if (new_entries == NULL)
break;
entries = new_entries;
new_entries += menu_limit;
while (--new_entries >= &entries[menu_lines])
*new_entries = NULL;
}
if (col == 0 && !entries[menu_lines])
{
if (*p == '#')
{
/* show prompt if first line of external script is #interactive */
if (selected_entry >= 0 && strncmp (p, "#silent", 7) == 0)
interactive = FALSE;
/* A commented menu entry */
accept_entry = 1;
}
else if (*p == '+')
{
if (*(p + 1) == '=')
{
/* Combined adding and default */
p = test_line (edit_widget, p + 1, &accept_entry);
if (selected == 0 && accept_entry)
selected = menu_lines;
}
else
{
/* A condition for adding the entry */
p = test_line (edit_widget, p, &accept_entry);
}
}
else if (*p == '=')
{
if (*(p + 1) == '+')
{
/* Combined adding and default */
p = test_line (edit_widget, p + 1, &accept_entry);
if (selected == 0 && accept_entry)
selected = menu_lines;
}
else
{
/* A condition for making the entry default */
i = 1;
p = test_line (edit_widget, p, &i);
if (selected == 0 && i)
selected = menu_lines;
}
}
else if (*p != ' ' && *p != '\t' && str_isprint (p))
{
/* A menu entry title line */
if (accept_entry)
entries[menu_lines] = p;
else
accept_entry = 1;
}
}
if (*p == '\n')
{
if (entries[menu_lines])
{
menu_lines++;
accept_entry = 1;
}
max_cols = max (max_cols, col);
col = 0;
}
else
{
if (*p == '\t')
*p = ' ';
col++;
}
}
if (menu_lines == 0)
{
message (D_ERROR, MSG_ERROR, _("No suitable entries found in %s"), menu);
res = FALSE;
}
else
{
if (selected_entry >= 0)
selected = selected_entry;
else
{
Listbox *listbox;
max_cols = min (max (max_cols, col), MAX_ENTRY_LEN);
/* Create listbox */
listbox = create_listbox_window (menu_lines, max_cols + 2, _("User menu"),
"[Menu File Edit]");
/* insert all the items found */
for (i = 0; i < menu_lines; i++)
{
p = entries[i];
LISTBOX_APPEND_TEXT (listbox, (unsigned char) p[0],
extract_line (p, p + MAX_ENTRY_LEN), p);
}
/* Select the default entry */
listbox_select_entry (listbox->list, selected);
selected = run_listbox (listbox);
}
if (selected >= 0)
{
execute_menu_command (edit_widget, entries[selected], interactive);
res = TRUE;
}
do_refresh ();
}
easy_patterns = old_patterns;
MC_PTR_FREE (menu);
g_free (entries);
g_free (data);
return res;
}
static void
init_panelize (void)
{
int i, panelize_cols = COLS - 6;
struct panelize *current = panelize;
#ifdef ENABLE_NLS
static int i18n_flag = 0;
static int maxlen = 0;
if (!i18n_flag)
{
i = sizeof (panelize_but) / sizeof (panelize_but[0]);
while (i--)
{
panelize_but[i].text = _(panelize_but[i].text);
maxlen += str_term_width1 (panelize_but[i].text) + 5;
}
maxlen += 10;
i18n_flag = 1;
}
panelize_cols = max (panelize_cols, maxlen);
panelize_but[2].x = panelize_but[3].x + str_term_width1 (panelize_but[3].text) + 7;
panelize_but[1].x = panelize_but[2].x + str_term_width1 (panelize_but[2].text) + 5;
panelize_but[0].x = panelize_cols - str_term_width1 (panelize_but[0].text) - 8 - BX;
#endif /* ENABLE_NLS */
last_listitem = 0;
do_refresh ();
panelize_dlg =
create_dlg (TRUE, 0, 0, 22, panelize_cols, dialog_colors,
panelize_callback, "[External panelize]",
_("External panelize"), DLG_CENTER | DLG_REVERSE);
for (i = 0; i < BUTTONS; i++)
add_widget (panelize_dlg,
button_new (BY + panelize_but[i].y,
BX + panelize_but[i].x,
panelize_but[i].ret_cmd,
panelize_but[i].flags, panelize_but[i].text, 0));
pname =
input_new (UY + 14, UX, input_get_default_colors (),
panelize_dlg->cols - 10, "", "in", INPUT_COMPLETE_DEFAULT);
add_widget (panelize_dlg, pname);
add_widget (panelize_dlg, label_new (UY + 13, UX, _("Command")));
/* get new listbox */
l_panelize = listbox_new (UY + 1, UX + 1, 10, panelize_dlg->cols - 12, FALSE, NULL);
while (current)
{
listbox_add_item (l_panelize, LISTBOX_APPEND_AT_END, 0, current->label, current);
current = current->next;
}
/* add listbox to the dialogs */
add_widget (panelize_dlg, l_panelize);
listbox_select_entry (l_panelize, listbox_search_text (l_panelize, _("Other command")));
}
void
chown_cmd (void)
{
char *fname;
struct stat sf_stat;
WLEntry *fe;
uid_t new_user;
gid_t new_group;
char buffer [15];
#if 0
/* Please no */
if (!vfs_current_is_local ()) {
if (vfs_current_is_extfs ()) {
message (1, _(" Oops... "),
_(" I can't run the Chown command on an extfs "));
return;
} else if (vfs_current_is_tarfs ()) {
message (1, _(" Oops... "),
_(" I can't run the Chown command on a tarfs "));
return;
}
}
#endif
do { /* do while any files remaining */
init_chown ();
new_user = new_group = -1;
if (cpanel->marked)
fname = next_file (); /* next marked file */
else
fname = selection (cpanel)->fname; /* single file */
if (!stat_file (fname, &sf_stat)){ /* get status of file */
destroy_dlg (ch_dlg);
break;
}
/* select in listboxes */
fe = listbox_search_text (l_user, get_owner(sf_stat.st_uid));
if (fe)
listbox_select_entry (l_user, fe);
fe = listbox_search_text (l_group, get_group(sf_stat.st_gid));
if (fe)
listbox_select_entry (l_group, fe);
chown_label (0, name_trunc (fname, 15));
chown_label (1, name_trunc (get_owner (sf_stat.st_uid), 15));
chown_label (2, name_trunc (get_group (sf_stat.st_gid), 15));
sprintf (buffer, "%d", c_fsize);
chown_label (3, buffer);
chown_label (4, string_perm (sf_stat.st_mode));
run_dlg (ch_dlg);
switch (ch_dlg->ret_value) {
case B_CANCEL:
end_chown = 1;
break;
case B_SETUSR:
{
struct passwd *user;
user = getpwnam (l_user->current->text);
if (user){
new_user = user->pw_uid;
apply_chowns (new_user, new_group);
}
break;
}
case B_SETGRP:
{
struct group *grp;
grp = getgrnam (l_group->current->text);
if (grp){
new_group = grp->gr_gid;
apply_chowns (new_user, new_group);
}
break;
}
case B_SETALL:
case B_ENTER:
{
struct group *grp;
struct passwd *user;
grp = getgrnam (l_group->current->text);
if (grp)
new_group = grp->gr_gid;
user = getpwnam (l_user->current->text);
if (user)
new_user = user->pw_uid;
if (ch_dlg->ret_value==B_ENTER) {
need_update = 1;
if (mc_chown (fname, new_user, new_group) == -1)
message (1, MSG_ERROR, _(" Couldn't chown \"%s\" \n %s "),
fname, unix_error_string (errno));
} else
apply_chowns (new_user, new_group);
break;
}
}
if (cpanel->marked && ch_dlg->ret_value != B_CANCEL){
do_file_mark (cpanel, current_file, 0);
need_update = 1;
}
destroy_dlg (ch_dlg);
} while (cpanel->marked && !end_chown);
chown_done ();
}
static cb_ret_t
listbox_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
{
WListbox *l = LISTBOX (w);
WDialog *h = w->owner;
cb_ret_t ret_code;
switch (msg)
{
case MSG_INIT:
return MSG_HANDLED;
case MSG_HOTKEY:
{
int pos, action;
pos = listbox_check_hotkey (l, parm);
if (pos < 0)
return MSG_NOT_HANDLED;
listbox_select_entry (l, pos);
send_message (h, w, MSG_ACTION, l->pos, NULL);
if (l->callback != NULL)
action = l->callback (l);
else
action = LISTBOX_DONE;
if (action == LISTBOX_DONE)
{
h->ret_value = B_ENTER;
dlg_stop (h);
}
return MSG_HANDLED;
}
case MSG_KEY:
ret_code = listbox_key (l, parm);
if (ret_code != MSG_NOT_HANDLED)
{
listbox_draw (l, TRUE);
send_message (h, w, MSG_ACTION, l->pos, NULL);
}
return ret_code;
case MSG_ACTION:
return listbox_execute_cmd (l, parm);
case MSG_CURSOR:
widget_move (l, l->cursor_y, 0);
send_message (h, w, MSG_ACTION, l->pos, NULL);
return MSG_HANDLED;
case MSG_FOCUS:
case MSG_UNFOCUS:
case MSG_DRAW:
listbox_draw (l, msg != MSG_UNFOCUS);
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);
}
}
static void
init_panelize (void)
{
struct
{
int ret_cmd;
button_flags_t flags;
const char *text;
} panelize_but[] =
{
/* *INDENT-OFF* */
{ B_ENTER, DEFPUSH_BUTTON, N_("Pane&lize") },
{ B_REMOVE, NORMAL_BUTTON, N_("&Remove") },
{ B_ADD, NORMAL_BUTTON, N_("&Add new") },
{ B_CANCEL, NORMAL_BUTTON, N_("&Cancel") }
/* *INDENT-ON* */
};
size_t i;
int blen;
int panelize_cols;
struct panelize *current;
int x, y;
last_listitem = 0;
do_refresh ();
i = G_N_ELEMENTS (panelize_but);
blen = i - 1; /* gaps between buttons */
while (i-- != 0)
{
#ifdef ENABLE_NLS
panelize_but[i].text = _(panelize_but[i].text);
#endif
blen += str_term_width1 (panelize_but[i].text) + 3 + 1;
if (panelize_but[i].flags == DEFPUSH_BUTTON)
blen += 2;
}
panelize_cols = COLS - 6;
panelize_cols = max (panelize_cols, blen + 4);
panelize_dlg =
dlg_create (TRUE, 0, 0, 20, panelize_cols, dialog_colors, panelize_callback, NULL,
"[External panelize]", _("External panelize"), DLG_CENTER);
/* add listbox to the dialogs */
y = UY;
add_widget (panelize_dlg, groupbox_new (y++, UX, 12, panelize_cols - UX * 2, ""));
l_panelize = listbox_new (y, UX + 1, 10, panelize_cols - UX * 2 - 2, FALSE, NULL);
for (current = panelize; current != NULL; current = current->next)
listbox_add_item (l_panelize, LISTBOX_APPEND_AT_END, 0, current->label, current);
listbox_select_entry (l_panelize, listbox_search_text (l_panelize, _("Other command")));
add_widget (panelize_dlg, l_panelize);
y += WIDGET (l_panelize)->lines + 1;
add_widget (panelize_dlg, label_new (y++, UX, _("Command")));
pname =
input_new (y++, UX, input_colors, panelize_cols - UX * 2, "", "in",
INPUT_COMPLETE_FILENAMES | INPUT_COMPLETE_HOSTNAMES | INPUT_COMPLETE_COMMANDS |
INPUT_COMPLETE_VARIABLES | INPUT_COMPLETE_USERNAMES | INPUT_COMPLETE_CD |
INPUT_COMPLETE_SHELL_ESC);
add_widget (panelize_dlg, pname);
add_widget (panelize_dlg, hline_new (y++, -1, -1));
x = (panelize_cols - blen) / 2;
for (i = 0; i < G_N_ELEMENTS (panelize_but); i++)
{
WButton *b;
b = button_new (y, x,
panelize_but[i].ret_cmd, panelize_but[i].flags, panelize_but[i].text, NULL);
add_widget (panelize_dlg, b);
x += button_get_len (b) + 1;
}
dlg_select_widget (l_panelize);
}
void
chown_cmd (void)
{
char *fname;
struct stat sf_stat;
WLEntry *fe;
Dlg_head *ch_dlg;
uid_t new_user;
gid_t new_group;
char buffer [BUF_TINY];
do { /* do while any files remaining */
ch_dlg = init_chown ();
new_user = new_group = -1;
if (current_panel->marked)
fname = next_file (); /* next marked file */
else
fname = selection (current_panel)->fname; /* single file */
if (mc_stat (fname, &sf_stat) != 0) { /* get status of file */
destroy_dlg (ch_dlg);
break;
}
/* select in listboxes */
fe = listbox_search_text (l_user, get_owner(sf_stat.st_uid));
if (fe)
listbox_select_entry (l_user, fe);
fe = listbox_search_text (l_group, get_group(sf_stat.st_gid));
if (fe)
listbox_select_entry (l_group, fe);
chown_label (0, name_trunc (fname, 15));
chown_label (1, name_trunc (get_owner (sf_stat.st_uid), 15));
chown_label (2, name_trunc (get_group (sf_stat.st_gid), 15));
size_trunc_len (buffer, 15, sf_stat.st_size, 0);
chown_label (3, buffer);
chown_label (4, string_perm (sf_stat.st_mode));
run_dlg (ch_dlg);
switch (ch_dlg->ret_value) {
case B_CANCEL:
end_chown = 1;
break;
case B_SETUSR:
{
struct passwd *user;
user = getpwnam (l_user->current->text);
if (user){
new_user = user->pw_uid;
apply_chowns (new_user, new_group);
}
break;
}
case B_SETGRP:
{
struct group *grp;
grp = getgrnam (l_group->current->text);
if (grp){
new_group = grp->gr_gid;
apply_chowns (new_user, new_group);
}
break;
}
case B_SETALL:
case B_ENTER:
{
struct group *grp;
struct passwd *user;
grp = getgrnam (l_group->current->text);
if (grp)
new_group = grp->gr_gid;
user = getpwnam (l_user->current->text);
if (user)
new_user = user->pw_uid;
if (ch_dlg->ret_value==B_ENTER) {
need_update = 1;
if (mc_chown (fname, new_user, new_group) == -1)
message (1, MSG_ERROR, _(" Cannot chown \"%s\" \n %s "),
fname, unix_error_string (errno));
} else
apply_chowns (new_user, new_group);
break;
}
}
if (current_panel->marked && ch_dlg->ret_value != B_CANCEL){
do_file_mark (current_panel, current_file, 0);
need_update = 1;
}
destroy_dlg (ch_dlg);
} while (current_panel->marked && !end_chown);
chown_done ();
}
static void
do_enter_key (WDialog * h, int f_pos)
{
WListbox *chl_list;
struct passwd *chl_pass;
struct group *chl_grp;
int fe;
gboolean chl_end, is_owner;
do
{
int result;
WDialog *chl_dlg;
const char *title;
int lxx, lyy, b_pos;
is_owner = (f_pos == 3);
title = is_owner ? _("owner") : _("group");
lxx = (COLS - 74) / 2 + (is_owner ? 35 : 53);
lyy = (LINES - 13) / 2;
chl_end = FALSE;
chl_dlg =
dlg_create (TRUE, lyy, lxx, 13, 17, WPOS_KEEP_DEFAULT, TRUE, dialog_colors,
chl_callback, NULL, "[Advanced Chown]", title);
/* get new listboxes */
chl_list = listbox_new (1, 1, 11, 15, FALSE, NULL);
listbox_add_item (chl_list, LISTBOX_APPEND_AT_END, 0, "<Unknown>", NULL, FALSE);
if (is_owner)
{
/* get and put user names in the listbox */
setpwent ();
while ((chl_pass = getpwent ()) != NULL)
listbox_add_item (chl_list, LISTBOX_APPEND_SORTED, 0, chl_pass->pw_name, NULL,
FALSE);
endpwent ();
fe = listbox_search_text (chl_list, get_owner (sf_stat->st_uid));
}
else
{
/* get and put group names in the listbox */
setgrent ();
while ((chl_grp = getgrent ()) != NULL)
listbox_add_item (chl_list, LISTBOX_APPEND_SORTED, 0, chl_grp->gr_name, NULL,
FALSE);
endgrent ();
fe = listbox_search_text (chl_list, get_group (sf_stat->st_gid));
}
listbox_select_entry (chl_list, fe);
b_pos = chl_list->pos;
add_widget (chl_dlg, chl_list);
result = dlg_run (chl_dlg);
if (result != B_CANCEL)
{
if (b_pos != chl_list->pos)
{
gboolean ok = FALSE;
char *text;
listbox_get_current (chl_list, &text, NULL);
if (is_owner)
{
chl_pass = getpwnam (text);
if (chl_pass != NULL)
{
ok = TRUE;
sf_stat->st_uid = chl_pass->pw_uid;
}
}
else
{
chl_grp = getgrnam (text);
if (chl_grp != NULL)
{
sf_stat->st_gid = chl_grp->gr_gid;
ok = TRUE;
}
}
if (ok)
{
ch_flags[f_pos + 6] = '+';
update_ownership ();
}
dlg_focus (h);
if (ok)
print_flags ();
}
if (result == KEY_LEFT)
{
if (!is_owner)
chl_end = TRUE;
dlg_one_up (ch_dlg);
f_pos--;
}
else if (result == KEY_RIGHT)
{
if (is_owner)
chl_end = TRUE;
dlg_one_down (ch_dlg);
f_pos++;
}
}
/* Here we used to redraw the window */
dlg_destroy (chl_dlg);
}
while (chl_end);
}
static void
listbox_fwd_n (WListbox * l, int n)
{
listbox_select_entry (l, MIN (l->pos + n, LISTBOX_LAST (l)));
}
static int
listbox_event (Gpm_Event * event, void *data)
{
WListbox *l = LISTBOX (data);
Widget *w = WIDGET (data);
if (!mouse_global_in_widget (event, w))
return MOU_UNHANDLED;
/* Single click */
if ((event->type & GPM_DOWN) != 0)
dlg_select_widget (l);
if (listbox_is_empty (l))
return MOU_NORMAL;
if ((event->type & (GPM_DOWN | GPM_DRAG)) != 0)
{
int ret = MOU_REPEAT;
Gpm_Event local;
int i;
local = mouse_get_local (event, w);
if (local.y < 1)
for (i = -local.y; i >= 0; i--)
listbox_back (l);
else if (local.y > w->lines)
for (i = local.y - w->lines; i > 0; i--)
listbox_fwd (l);
else if ((local.buttons & GPM_B_UP) != 0)
{
listbox_back (l);
ret = MOU_NORMAL;
}
else if ((local.buttons & GPM_B_DOWN) != 0)
{
listbox_fwd (l);
ret = MOU_NORMAL;
}
else
listbox_select_entry (l, listbox_select_pos (l, l->top, local.y - 1));
/* We need to refresh ourselves since the dialog manager doesn't */
/* know about this event */
listbox_draw (l, TRUE);
return ret;
}
/* Double click */
if ((event->type & (GPM_DOUBLE | GPM_UP)) == (GPM_UP | GPM_DOUBLE))
{
Gpm_Event local;
int action;
local = mouse_get_local (event, w);
dlg_select_widget (l);
listbox_select_entry (l, listbox_select_pos (l, l->top, local.y - 1));
if (l->callback != NULL)
action = l->callback (l);
else
action = LISTBOX_DONE;
if (action == LISTBOX_DONE)
{
w->owner->ret_value = B_ENTER;
dlg_stop (w->owner);
}
}
return MOU_NORMAL;
}
static void
do_enter_key (Dlg_head * h, int f_pos)
{
Dlg_head *chl_dlg;
WListbox *chl_list;
struct passwd *chl_pass;
struct group *chl_grp;
WLEntry *fe;
int lxx, lyy, chl_end, b_pos;
int is_owner;
const char *title;
do {
is_owner = (f_pos == 3);
title = is_owner ? _("owner") : _("group");
lxx = (COLS - 74) / 2 + (is_owner ? 35 : 53);
lyy = (LINES - 13) / 2;
chl_end = 0;
chl_dlg =
create_dlg (lyy, lxx, 13, 17, dialog_colors, chl_callback,
"[Advanced Chown]", title, DLG_COMPACT | DLG_REVERSE);
/* get new listboxes */
chl_list = listbox_new (1, 1, 11, 15, NULL);
listbox_add_item (chl_list, LISTBOX_APPEND_AT_END, 0,
"<Unknown>", NULL);
if (is_owner) {
/* get and put user names in the listbox */
setpwent ();
while ((chl_pass = getpwent ())) {
listbox_add_item (chl_list, LISTBOX_APPEND_SORTED, 0,
chl_pass->pw_name, NULL);
}
endpwent ();
fe = listbox_search_text (chl_list,
get_owner (sf_stat->st_uid));
} else {
/* get and put group names in the listbox */
setgrent ();
while ((chl_grp = getgrent ())) {
listbox_add_item (chl_list, LISTBOX_APPEND_SORTED, 0,
chl_grp->gr_name, NULL);
}
endgrent ();
fe = listbox_search_text (chl_list,
get_group (sf_stat->st_gid));
}
if (fe)
listbox_select_entry (chl_list, fe);
b_pos = chl_list->pos;
add_widget (chl_dlg, chl_list);
run_dlg (chl_dlg);
if (b_pos != chl_list->pos) {
int ok = 0;
if (is_owner) {
chl_pass = getpwnam (chl_list->current->text);
if (chl_pass) {
ok = 1;
sf_stat->st_uid = chl_pass->pw_uid;
}
} else {
chl_grp = getgrnam (chl_list->current->text);
if (chl_grp) {
sf_stat->st_gid = chl_grp->gr_gid;
ok = 1;
}
}
if (ok) {
ch_flags[f_pos + 6] = '+';
update_ownership ();
}
dlg_focus (h);
if (ok)
print_flags ();
}
if (chl_dlg->ret_value == KEY_LEFT) {
if (!is_owner)
chl_end = 1;
dlg_one_up (ch_dlg);
f_pos--;
} else if (chl_dlg->ret_value == KEY_RIGHT) {
if (is_owner)
chl_end = 1;
dlg_one_down (ch_dlg);
f_pos++;
}
/* Here we used to redraw the window */
destroy_dlg (chl_dlg);
} while (chl_end);
}
