void
print_search_next_msg(const FileView *view, int backward)
{
const int match_number = get_current_entry(view)->search_match;
const char search_type = backward ? '?' : '/';
status_bar_messagef("(%d of %d) %c%s", match_number, view->matches,
search_type, cfg_get_last_search_pattern());
}
/* Expands view macros to be displayed on the status line according to the
* format string. Returns expanded line and attribute line, the latter one
* contains a character in the set [0-9 ] (space included) per utf-8 character
* of the former that specifies which user highlight group should be used
* starting with that character. */
TSTATIC LineWithAttrs
expand_status_line_macros(view_t *view, const char format[])
{
const dir_entry_t *const curr = get_current_entry(view);
if(curr == NULL || fentry_is_fake(curr))
{
/* Fake entries don't have valid information. */
LineWithAttrs result = { .line = strdup(""), .attrs = strdup("") };
return result;
}
return parse_view_macros(view, &format, "nrtTfaAugsEdD-xlLSz%[]{*", 0); //mod by sim1
}
void
print_search_msg(const FileView *view, int backward)
{
if(view->matches == 0)
{
print_search_fail_msg(view, backward);
}
else
{
status_bar_messagef("%d of %d matching file%s for: %s",
get_current_entry(view)->search_match, view->matches,
(view->matches == 1) ? "" : "s", cfg_get_last_search_pattern());
}
}
void
enter_file_info_mode(FileView *v)
{
if(fentry_is_fake(get_current_entry(v)))
{
show_error_msg("File info", "Entry doesn't correspond to a file.");
return;
}
vle_mode_set(FILE_INFO_MODE, VMT_PRIMARY);
view = v;
setup_menu();
redraw_file_info_dialog();
was_redraw = 0;
}
/* Clones one view into another. Path specifies location of active pane and can
* be NULL. The destination view is assumed to not own any resources. */
static void
clone_view(view_t *dst, view_t *src, const char path[])
{
strcpy(dst->curr_dir, path == NULL ? flist_get_dir(src) : path);
dst->timestamps_mutex = src->timestamps_mutex;
dst->win = src->win;
dst->title = src->title;
flist_init_view(dst);
dst->dir_entry[0].origin = src->curr_dir;
clone_local_options(src, dst, 1);
matcher_free(dst->manual_filter);
dst->manual_filter = matcher_clone(src->manual_filter);
filter_assign(&dst->auto_filter, &src->auto_filter);
dst->prev_invert = src->prev_invert;
dst->invert = src->invert;
/* Clone current entry even though we populate file list later to give
* reloading reference point for cursor. */
replace_dir_entries(dst, &dst->dir_entry, &dst->list_rows,
get_current_entry(src), 1);
dst->list_pos = 0;
/* Clone viewport configuration. */
dst->curr_line = src->curr_line;
dst->top_line = src->top_line;
dst->window_rows = src->window_rows;
dst->window_cols = src->window_cols;
dst->window_cells = src->window_cells;
flist_hist_resize(dst, cfg.history_len);
flist_hist_clone(dst, src);
if(path != NULL && !flist_custom_active(src))
{
/* Record location we're leaving. */
flist_hist_save(dst, src->curr_dir, get_current_file_name(src),
src->list_pos - src->top_line);
}
(void)populate_dir_list(dst, path == NULL);
/* XXX: do we need to update origins or is this a leftover from before list
* population was introduced? */
flist_update_origins(dst, &dst->curr_dir[0], &src->curr_dir[0]);
/* Record new location. */
flist_hist_save(dst, NULL, NULL, -1);
}
int
run_with_filetype(FileView *view, const char beginning[], int background)
{
char *const typed_fname = get_typed_entry_fpath(get_current_entry(view));
assoc_records_t ft = ft_get_all_programs(typed_fname);
assoc_records_t magic = get_magic_handlers(typed_fname);
free(typed_fname);
if(try_run_with_filetype(view, ft, beginning, background))
{
ft_assoc_records_free(&ft);
return 0;
}
ft_assoc_records_free(&ft);
return !try_run_with_filetype(view, magic, beginning, background);
}
TSTATIC char *
append_selected_files(FileView *view, char expanded[], int under_cursor,
int quotes, const char mod[], int for_shell)
{
const PathType type = (view == other_view)
? PT_FULL
: (flist_custom_active(view) ? PT_REL : PT_NAME);
#ifdef _WIN32
size_t old_len = strlen(expanded);
#endif
if(view->selected_files && !under_cursor)
{
int n = 0;
dir_entry_t *entry = NULL;
while(iter_selected_entries(view, &entry))
{
expanded = append_entry(view, expanded, type, entry, quotes, mod,
for_shell);
if(++n != view->selected_files)
{
expanded = append_to_expanded(expanded, " ");
}
}
}
else
{
expanded = append_entry(view, expanded, type, get_current_entry(view),
quotes, mod, for_shell);
}
#ifdef _WIN32
if(for_shell && curr_stats.shell_type == ST_CMD)
{
to_back_slash(expanded + old_len);
}
#endif
return expanded;
}
/* Clones one view into another. The destination view is assumed to not own any
* resources. */
static void
clone_view(view_t *dst, view_t *src)
{
strcpy(dst->curr_dir, flist_get_dir(src));
dst->timestamps_mutex = src->timestamps_mutex;
dst->win = src->win;
dst->title = src->title;
flist_init_view(dst);
dst->dir_entry[0].origin = src->curr_dir;
clone_local_options(src, dst, 1);
matcher_free(dst->manual_filter);
dst->manual_filter = matcher_clone(src->manual_filter);
filter_assign(&dst->auto_filter, &src->auto_filter);
dst->prev_invert = src->prev_invert;
dst->invert = src->invert;
/* Clone current entry even though we populate file list later to give
* reloading reference point for cursor. */
replace_dir_entries(dst, &dst->dir_entry, &dst->list_rows,
get_current_entry(src), 1);
dst->list_pos = 0;
/* Clone viewport configuration. */
dst->curr_line = src->curr_line;
dst->top_line = src->top_line;
dst->window_rows = src->window_rows;
dst->window_cols = src->window_cols;
dst->window_cells = src->window_cells;
flist_hist_resize(dst, cfg.history_len);
flist_hist_clone(dst, src);
(void)populate_dir_list(dst, 1);
flist_update_origins(dst, &dst->curr_dir[0], &src->curr_dir[0]);
}
static void
run_file(FileView *view, int dont_execute)
{
/* TODO: refactor this function run_file() */
char *typed_fname;
const char *multi_prog_cmd;
int undef;
int same;
dir_entry_t *entry;
int no_multi_run;
if(!view->dir_entry[view->list_pos].selected)
{
clean_selected_files(view);
}
typed_fname = get_typed_entry_fpath(get_current_entry(view));
multi_prog_cmd = ft_get_program(typed_fname);
free(typed_fname);
no_multi_run = !is_multi_run_compat(view, multi_prog_cmd);
undef = 0;
same = 1;
entry = NULL;
while(iter_selected_entries(view, &entry))
{
char *typed_fname;
const char *entry_prog_cmd;
if(!path_exists_at(entry->origin, entry->name, DEREF))
{
show_error_msgf("Broken Link", "Destination of \"%s\" link doesn't exist",
entry->name);
return;
}
typed_fname = get_typed_entry_fpath(entry);
entry_prog_cmd = ft_get_program(typed_fname);
free(typed_fname);
if(entry_prog_cmd == NULL)
{
++undef;
continue;
}
no_multi_run += !is_multi_run_compat(view, entry_prog_cmd);
if(multi_prog_cmd == NULL)
{
multi_prog_cmd = entry_prog_cmd;
}
else if(strcmp(entry_prog_cmd, multi_prog_cmd) != 0)
{
same = 0;
}
}
if(!same && undef == 0 && no_multi_run)
{
show_error_msg("Run error", "Handlers of selected files are incompatible.");
return;
}
if(undef > 0)
{
multi_prog_cmd = NULL;
}
/* Check for a filetype */
/* vi is set as the default for any extension without a program */
if(multi_prog_cmd == NULL)
{
run_with_defaults(view);
return;
}
if(no_multi_run)
{
run_using_prog(view, multi_prog_cmd, dont_execute, 0);
}
else
{
run_selection_separately(view, dont_execute);
}
}
/* Returns increment for curr_y. */
static int
show_file_type(FileView *view, int curr_y)
{
const dir_entry_t *curr;
int x;
int old_curr_y = curr_y;
x = getmaxx(menu_win);
curr = get_current_entry(view);
mvwaddstr(menu_win, curr_y, 2, "Type: ");
if(curr->type == FT_LINK)
{
char full_path[PATH_MAX];
char linkto[PATH_MAX + NAME_MAX];
get_current_full_path(view, sizeof(full_path), full_path);
mvwaddstr(menu_win, curr_y, 8, "Link");
curr_y += 2;
mvwaddstr(menu_win, curr_y, 2, "Link To: ");
if(get_link_target(full_path, linkto, sizeof(linkto)) == 0)
{
mvwaddnstr(menu_win, curr_y, 11, linkto, x - 11);
if(!path_exists(linkto, DEREF))
{
mvwaddstr(menu_win, curr_y - 2, 12, " (BROKEN)");
}
}
else
{
mvwaddstr(menu_win, curr_y, 11, "Couldn't Resolve Link");
}
}
else if(curr->type == FT_EXEC || curr->type == FT_REG)
{
#ifdef HAVE_FILE_PROG
char full_path[PATH_MAX];
FILE *pipe;
char command[1024];
char buf[NAME_MAX];
char *escaped_full_path;
get_current_full_path(view, sizeof(full_path), full_path);
/* Use the file command to get file information. */
escaped_full_path = shell_like_escape(full_path, 0);
snprintf(command, sizeof(command), "file %s -b", escaped_full_path);
free(escaped_full_path);
if((pipe = popen(command, "r")) == NULL)
{
mvwaddstr(menu_win, curr_y, 8, "Unable to open pipe to read file");
return 2;
}
if(fgets(buf, sizeof(buf), pipe) != buf)
strcpy(buf, "Pipe read error");
pclose(pipe);
mvwaddnstr(menu_win, curr_y, 8, buf, x - 9);
if(x > 9 && strlen(buf) > (size_t)(x - 9))
{
mvwaddnstr(menu_win, curr_y + 1, 8, buf + x - 9, x - 9);
}
#else /* #ifdef HAVE_FILE_PROG */
if(curr->type == FT_EXEC)
mvwaddstr(menu_win, curr_y, 8, "Executable");
else
mvwaddstr(menu_win, curr_y, 8, "Regular File");
#endif /* #ifdef HAVE_FILE_PROG */
}
else if(curr->type == FT_DIR)
{
mvwaddstr(menu_win, curr_y, 8, "Directory");
}
#ifndef _WIN32
else if(curr->type == FT_CHAR_DEV || curr->type == FT_BLOCK_DEV)
{
const char *const type = (curr->type == FT_CHAR_DEV)
? "Character Device"
: "Block Device";
char full_path[PATH_MAX];
struct stat st;
mvwaddstr(menu_win, curr_y, 8, type);
get_current_full_path(view, sizeof(full_path), full_path);
if(os_stat(full_path, &st) == 0)
{
char info[64];
snprintf(info, sizeof(info), "Device Id: 0x%x:0x%x", major(st.st_rdev),
minor(st.st_rdev));
curr_y += 2;
mvwaddstr(menu_win, curr_y, 2, info);
}
}
else if(curr->type == FT_SOCK)
{
mvwaddstr(menu_win, curr_y, 8, "Socket");
}
#endif
else if(curr->type == FT_FIFO)
{
mvwaddstr(menu_win, curr_y, 8, "Fifo Pipe");
}
else
{
mvwaddstr(menu_win, curr_y, 8, "Unknown");
}
curr_y += 2;
return curr_y - old_curr_y;
}
void
redraw_file_info_dialog(void)
{
const dir_entry_t *curr;
char perm_buf[26];
char size_buf[56];
char buf[256];
#ifndef _WIN32
char id_buf[26];
#endif
int curr_y;
uint64_t size;
int size_not_precise;
assert(view != NULL);
if(resize_for_menu_like() != 0)
{
return;
}
werase(menu_win);
curr = get_current_entry(view);
size = DCACHE_UNKNOWN;
if(curr->type == FT_DIR)
{
dcache_get_of(curr, &size, NULL);
}
if(size == DCACHE_UNKNOWN)
{
size = curr->size;
}
size_not_precise = friendly_size_notation(size, sizeof(size_buf), size_buf);
curr_y = 2;
curr_y += print_item("Path: ", curr->origin, curr_y);
curr_y += print_item("Name: ", curr->name, curr_y);
mvwaddstr(menu_win, curr_y, 2, "Size: ");
mvwaddstr(menu_win, curr_y, 8, size_buf);
if(size_not_precise)
{
snprintf(size_buf, sizeof(size_buf), " (%" PRId64 " bytes)", size);
waddstr(menu_win, size_buf);
}
curr_y += 2;
curr_y += show_file_type(view, curr_y);
curr_y += show_mime_type(view, curr_y);
#ifndef _WIN32
get_perm_string(perm_buf, sizeof(perm_buf), curr->mode);
curr_y += print_item("Permissions: ", perm_buf, curr_y);
#else
copy_str(perm_buf, sizeof(perm_buf), attr_str_long(curr->attrs));
curr_y += print_item("Attributes: ", perm_buf, curr_y);
#endif
format_time(curr->mtime, buf, sizeof(buf));
curr_y += print_item("Modified: ", buf, curr_y);
format_time(curr->atime, buf, sizeof(buf));
curr_y += print_item("Accessed: ", buf, curr_y);
format_time(curr->ctime, buf, sizeof(buf));
#ifndef _WIN32
curr_y += print_item("Changed: ", buf, curr_y);
#else
curr_y += print_item("Created: ", buf, curr_y);
#endif
#ifndef _WIN32
get_uid_string(curr, 0, sizeof(id_buf), id_buf);
curr_y += print_item("Owner: ", id_buf, curr_y);
get_gid_string(curr, 0, sizeof(id_buf), id_buf);
curr_y += print_item("Group: ", id_buf, curr_y);
#endif
/* Fake use after last assignment. */
(void)curr_y;
box(menu_win, 0, 0);
checked_wmove(menu_win, 0, 3);
wprint(menu_win, " File Information ");
wrefresh(menu_win);
checked_wmove(menu_win, 2, 2);
was_redraw = 1;
}
static void
read_path(FILE *fob, mxArray **data, double dbu_to_uu)
{
mxArray *pstruct;
mxArray *pprop = NULL;
mxArray *pc;
tList xylist;
uint16_t rtype, rlen;
int nprop = 0;
int nle, k;
element_t path;
const char *fields[] = {"internal", "xy", "prop"};
/* initialize element */
init_element(&path, GDS_PATH);
/* output data structure */
pstruct = mxCreateStructMatrix(1,1, 3, fields);
/* create a list for the XY data record(s) */
if ( create_list(&xylist) == -1 )
mexErrMsgTxt("gds_read_element (path) : could not create list for XY records.");
/* read element properties */
while (1) {
if ( read_record_hdr(fob, &rtype, &rlen) )
mexErrMsgTxt("gds_read_element (path) : could not read record header.");
if (rtype == ENDEL)
break;
switch (rtype) {
case XY:
if ( list_insert(xylist, read_xy(fob, rlen, dbu_to_uu), AFTER) == -1)
mexErrMsgTxt("gds_read_element (path) : list insertion failed.");
break;
case LAYER:
path.layer = read_layer(fob);
break;
case PATHTYPE:
path.ptype = read_type(fob);
path.has |= HAS_PTYPE;
break;
case WIDTH:
path.width = dbu_to_uu * (double)read_width(fob);
path.has |= HAS_WIDTH;
break;
case BGNEXTN:
path.bgnextn = dbu_to_uu * read_extn(fob);
path.has |= HAS_BGNEXTN;
break;
case ENDEXTN:
path.endextn = dbu_to_uu * read_extn(fob);
path.has |= HAS_ENDEXTN;
break;
case DATATYPE:
path.dtype = read_type(fob);
break;
case ELFLAGS:
path.elflags = read_elflags(fob);
path.has |= HAS_ELFLAGS;
break;
case PLEX:
path.plex = read_plex(fob);
path.has |= HAS_PLEX;
break;
case PROPATTR:
pprop = resize_property_structure(pprop, nprop+1);
mxSetFieldByNumber(pprop, nprop, 0, read_propattr(fob));
break;
case PROPVALUE:
mxSetFieldByNumber(pprop, nprop, 1, read_propvalue(fob,rlen));
nprop += 1;
break;
default:
mexPrintf("Unknown record id: 0x%x\n", rtype);
mexErrMsgTxt("PATH : found unknown element property.");
}
}
/* cell array with XY records */
nle = list_entries(xylist);
if ( !nle )
mexErrMsgTxt("gds_read_element (path) : element has no XY record.");
pc = mxCreateCellMatrix(1, nle);
list_head(xylist);
for (k=0; k<nle; k++)
mxSetCell(pc, k, (mxArray *)get_current_entry(xylist, NULL));
mxSetFieldByNumber(pstruct, 0, 1, pc);
/* set prop field */
if ( nprop ) {
mxSetFieldByNumber(pstruct, 0, 2, pprop);
}
else {
mxSetFieldByNumber(pstruct, 0, 2, empty_matrix());
}
/* store structure with element data */
mxSetFieldByNumber(pstruct, 0, 0, copy_element_to_array(&path));
/* return data */
*data = pstruct;
}
/* Expands macros in the *format string advancing the pointer as it goes. The
* opt represents conditional expression state, should be zero for non-recursive
* calls. Returns newly allocated string, which should be freed by the
* caller. */
static LineWithAttrs
parse_view_macros(view_t *view, const char **format, const char macros[],
int opt)
{
const dir_entry_t *const curr = get_current_entry(view);
LineWithAttrs result = { .line = strdup(""), .attrs = strdup("") };
char c;
int nexpansions = 0;
int has_expander = 0;
if(curr == NULL)
{
return result;
}
while((c = **format) != '\0')
{
size_t width = 0;
int left_align = 0;
char buf[PATH_MAX + 1];
const char *const next = ++*format;
int skip, ok;
if(c != '%' ||
(!char_is_one_of(macros, *next) && !isdigit(*next) &&
(*next != '=' || has_expander)))
{
if(strappendch(&result.line, &result.line_len, c) != 0)
{
break;
}
continue;
}
if(*next == '=')
{
(void)sync_attrs(&result, 0);
if(strappend(&result.line, &result.line_len, "%=") != 0 ||
strappendch(&result.attrs, &result.attrs_len, '=') != 0)
{
break;
}
++*format;
has_expander = 1;
continue;
}
if(*next == '-')
{
left_align = 1;
++*format;
}
while(isdigit(**format))
{
width = width*10 + *(*format)++ - '0';
}
c = *(*format)++;
skip = 0;
ok = 1;
buf[0] = '\0';
switch(c)
{
case 'a':
friendly_size_notation(get_free_space(curr_view->curr_dir), sizeof(buf),
buf);
break;
case 't':
format_entry_name(curr, NF_FULL, sizeof(buf), buf);
break;
case 'T':
if(curr->type == FT_LINK)
{
char full_path[PATH_MAX + 1];
char link_path[PATH_MAX + 1]; //add by sim1
get_full_path_of(curr, sizeof(full_path), full_path);
//mod by sim1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
if(get_link_target(full_path, link_path, sizeof(link_path)) != 0)
{
copy_str(buf, sizeof(buf), "Failed to resolve link");
}
else
{
snprintf(buf, sizeof(buf), " -> %s", link_path);
}
//mod by sim1 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
}
break;
case 'f':
get_short_path_of(view, curr, NF_FULL, 0, sizeof(buf), buf);
break;
case 'A':
#ifndef _WIN32
get_perm_string(buf, sizeof(buf), curr->mode);
#else
copy_str(buf, sizeof(buf), attr_str_long(curr->attrs));
#endif
break;
case 'u':
get_uid_string(curr, 0, sizeof(buf), buf);
break;
case 'g':
get_gid_string(curr, 0, sizeof(buf), buf);
break;
case 's':
friendly_size_notation(fentry_get_size(view, curr), sizeof(buf), buf);
break;
//add by sim1 ************************************************
case 'r':
{
char path[PATH_MAX] = {0};
get_full_path_at(view, view->list_pos, sizeof(path), path);
(void)get_rating_string(buf, sizeof(buf), path);
}
break;
case 'n':
{
int nitems = !fentry_is_dir(curr) ? 0 : (int)fentry_get_nitems(view, curr);
snprintf(buf, sizeof(buf), "%d", nitems);
}
break;
//add by sim1 ************************************************
case 'E':
{
uint64_t size = 0U;
typedef int (*iter_f)(view_t *view, dir_entry_t **entry);
/* No current element for visual mode, since it can contain truly
* empty selection when cursor is on ../ directory. */
iter_f iter = vle_mode_is(VISUAL_MODE) ? &iter_selected_entries
: &iter_selection_or_current;
dir_entry_t *entry = NULL;
while(iter(view, &entry))
{
size += fentry_get_size(view, entry);
}
friendly_size_notation(size, sizeof(buf), buf);
}
break;
case 'd':
{
struct tm *tm_ptr = localtime(&curr->mtime);
strftime(buf, sizeof(buf), cfg.time_format, tm_ptr);
}
break;
case '-':
case 'x':
skip = expand_num(buf, sizeof(buf), view->filtered);
break;
case 'l':
skip = expand_num(buf, sizeof(buf), view->list_pos + 1);
break;
case 'L':
skip = expand_num(buf, sizeof(buf), view->list_rows + view->filtered);
break;
case 'S':
skip = expand_num(buf, sizeof(buf), view->list_rows);
break;
case '%':
copy_str(buf, sizeof(buf), "%");
break;
case 'z':
copy_str(buf, sizeof(buf), get_tip());
break;
case 'D':
if(curr_stats.number_of_windows == 1)
{
view_t *const other = (view == curr_view) ? other_view : curr_view;
//mod by sim1
//copy_str(buf, sizeof(buf), replace_home_part(other->curr_dir));
snprintf(buf, sizeof(buf), " ‖ %s", replace_home_part(other->curr_dir));
}
break;
case '[':
{
LineWithAttrs opt = parse_view_macros(view, format, macros, 1);
copy_str(buf, sizeof(buf), opt.line);
free(opt.line);
char *attrs = opt.attrs;
if(sync_attrs(&result, 0) && opt.attrs_len > 0U)
{
if(*attrs != ' ')
{
result.attrs[result.attrs_len - 1U] = *attrs;
}
++attrs;
}
strappend(&result.attrs, &result.attrs_len, attrs);
free(opt.attrs);
break;
}
case ']':
if(opt)
{
if(nexpansions == 0)
{
replace_string(&result.line, "");
replace_string(&result.attrs, "");
result.line_len = 0U;
result.attrs_len = 0U;
}
if(sync_attrs(&result, 0))
{
result.attrs[--result.attrs_len] = '\0';
}
return result;
}
LOG_INFO_MSG("Unmatched %%]");
ok = 0;
break;
case '{':
{
/* Try to find matching closing bracket
* TODO: implement the way to escape it, so that the expr may contain
* closing brackets */
const char *e = strchr(*format, '}');
char *expr = NULL, *resstr = NULL;
var_t res = var_false();
ParsingErrors parsing_error;
/* If there's no matching closing bracket, just add the opening one
* literally */
if(e == NULL)
{
ok = 0;
break;
}
/* Create a NULL-terminated copy of the given expr.
* TODO: we could temporarily use buf for that, to avoid extra
* allocation, but explicitly named variable reads better. */
expr = calloc(e - (*format) + 1 /* NUL-term */, 1);
memcpy(expr, *format, e - (*format));
/* Try to parse expr, and convert the res to string if succeed. */
parsing_error = parse(expr, 0, &res);
if(parsing_error == PE_NO_ERROR)
{
resstr = var_to_str(res);
}
if(resstr != NULL)
{
copy_str(buf, sizeof(buf), resstr);
}
else
{
copy_str(buf, sizeof(buf), "<Invalid expr>");
}
var_free(res);
free(resstr);
free(expr);
*format = e + 1 /* closing bracket */;
}
break;
case '*':
if(width > 9)
{
snprintf(buf, sizeof(buf), "%%%d*", (int)width);
width = 0;
break;
}
(void)sync_attrs(&result, 1);
result.attrs[result.attrs_len - 1] = '0' + width;
width = 0;
break;
default:
LOG_INFO_MSG("Unexpected %%-sequence: %%%c", c);
ok = 0;
break;
}
if(char_is_one_of("tTAugsEd", c) && fentry_is_fake(curr))
{
buf[0] = '\0';
}
if(!ok)
{
*format = next;
if(strappendch(&result.line, &result.line_len, '%') != 0)
{
break;
}
continue;
}
check_expanded_str(buf, skip, &nexpansions);
stralign(buf, width, ' ', left_align);
if(strappend(&result.line, &result.line_len, buf) != 0)
{
break;
}
}
/* Unmatched %[. */
if(opt)
{
(void)strprepend(&result.line, &result.line_len, "%[");
}
if(sync_attrs(&result, 0))
{
result.attrs[--result.attrs_len] = '\0';
}
return result;
}
/* Makes sure that result->attrs has at least as many elements as result->line
* contains characters + extra_width. Returns non-zero if result->attrs has
* extra characters compared to result->line. */
static int
sync_attrs(LineWithAttrs *result, int extra_width)
{
const size_t nchars = utf8_strsw(result->line) + extra_width;
if(result->attrs_len < nchars)
{
char *const new_attrs = format_str("%s%*s", result->attrs,
(int)(nchars - result->attrs_len), "");
free(result->attrs);
result->attrs = new_attrs;
result->attrs_len = nchars;
}
return (result->attrs_len > nchars);
}
/* Prints number into the buffer. Returns non-zero if numeric value is
* "empty" (zero). */
static int
expand_num(char buf[], size_t buf_len, int val)
{
snprintf(buf, buf_len, "%d", val);
return (val == 0);
}
/* Formats status line in the "old way" (before introduction of 'statusline'
* option). */
static void
update_stat_window_old(view_t *view, int lazy_redraw)
{
const dir_entry_t *const curr = get_current_entry(view);
char name_buf[160*2 + 1];
char perm_buf[26];
char size_buf[64];
char id_buf[52];
int x;
int cur_x;
size_t print_width;
char *filename;
if(curr == NULL || fentry_is_fake(curr))
{
werase(stat_win);
refresh_window(stat_win, lazy_redraw);
return;
}
x = getmaxx(stdscr);
wresize(stat_win, 1, x);
ui_set_bg(stat_win, &cfg.cs.color[STATUS_LINE_COLOR],
cfg.cs.pair[STATUS_LINE_COLOR]);
filename = get_current_file_name(view);
print_width = utf8_strsnlen(filename, 20 + MAX(0, x - 83));
copy_str(name_buf, MIN(sizeof(name_buf), print_width + 1), filename);
friendly_size_notation(fentry_get_size(view, curr), sizeof(size_buf),
size_buf);
get_uid_string(curr, 0, sizeof(id_buf), id_buf);
if(id_buf[0] != '\0')
strcat(id_buf, ":");
get_gid_string(curr, 0, sizeof(id_buf) - strlen(id_buf),
id_buf + strlen(id_buf));
#ifndef _WIN32
get_perm_string(perm_buf, sizeof(perm_buf), curr->mode);
#else
copy_str(perm_buf, sizeof(perm_buf), attr_str_long(curr->attrs));
#endif
werase(stat_win);
cur_x = 2;
checked_wmove(stat_win, 0, cur_x);
wprint(stat_win, name_buf);
cur_x += 22;
if(x > 83)
cur_x += x - 83;
mvwaddstr(stat_win, 0, cur_x, size_buf);
cur_x += 12;
mvwaddstr(stat_win, 0, cur_x, perm_buf);
cur_x += 11;
snprintf(name_buf, sizeof(name_buf), "%d %s filtered", view->filtered,
(view->filtered == 1) ? "file" : "files");
if(view->filtered > 0)
mvwaddstr(stat_win, 0, x - (strlen(name_buf) + 2), name_buf);
if(cur_x + strlen(id_buf) + 1 > x - (strlen(name_buf) + 2))
break_at(id_buf, ':');
if(cur_x + strlen(id_buf) + 1 > x - (strlen(name_buf) + 2))
id_buf[0] = '\0';
mvwaddstr(stat_win, 0, cur_x, id_buf);
refresh_window(stat_win, lazy_redraw);
}
void playlist_position (int argc, char * * argv)
{
fauxdtool_report ("%d", get_current_entry () + 1);
}
