mirrors/mc
1
0
Fork 0
mirror of https://github.com/MidnightCommander/mc synced 2025-01-08 20:41:59 +03:00
Code Issues Packages Projects Releases Wiki Activity

Changed type of WPanel::cwd (char *) and WPanel::lwd (char *)

Browse Source 
...to WPanel::cwd_vpath (vfs_path_tr *) and WPanel::lwd_vpath (vfs_path_t *).

Signed-off-by: Slava Zanko <slavazanko@gmail.com>
This commit is contained in:
Slava Zanko 2011-09-27 22:13:50 +03:00
parent fdedfb5d3b
commit 5dafd4d809
30 changed files with 669 additions and 487 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
lib/util.c
View File

@ -1061,21 +1061,28 @@ convert_controls (const char *p)
*/ */
char * char *
diff_two_paths (const char *first, const char *second) diff_two_paths (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
{ {
char *p, *q, *r, *s, *buf = NULL; char *p, *q, *r, *s, *buf = NULL;
int i, j, prevlen = -1, currlen; int i, j, prevlen = -1, currlen;
char *my_first = NULL, *my_second = NULL; char *my_first = NULL, *my_second = NULL;
char *path_str;
my_first = resolve_symlinks (first); path_str = vfs_path_to_str (vpath1);
my_first = resolve_symlinks (path_str);
g_free (path_str);
if (my_first == NULL) if (my_first == NULL)
return NULL; return NULL;
my_second = resolve_symlinks (second);
path_str = vfs_path_to_str (vpath2);
my_second = resolve_symlinks (path_str);
g_free (path_str);
if (my_second == NULL) if (my_second == NULL)
{ {
g_free (my_first); g_free (my_first);
return NULL; return NULL;
} }
for (j = 0; j < 2; j++) for (j = 0; j < 2; j++)
{ {
p = my_first; p = my_first;

6
lib/util.h
View File

@ -12,6 +12,8 @@
#include <inttypes.h> /* uintmax_t */ #include <inttypes.h> /* uintmax_t */
#include <unistd.h> #include <unistd.h>
#include "lib/vfs/vfs.h"
/*** typedefs(not structures) and defined constants **********************************************/ /*** typedefs(not structures) and defined constants **********************************************/
#ifndef MAXSYMLINKS #ifndef MAXSYMLINKS
@ -128,7 +130,7 @@ char *convert_controls (const char *s);
/* overwrites passwd with '\0's and frees it. */ /* overwrites passwd with '\0's and frees it. */
void wipe_password (char *passwd); void wipe_password (char *passwd);
char *diff_two_paths (const char *first, const char *second); char *diff_two_paths (const vfs_path_t * vpath1, const vfs_path_t * vpath2);
/* Returns the basename of fname. The result is a pointer into fname. */ /* Returns the basename of fname. The result is a pointer into fname. */
const char *x_basename (const char *fname); const char *x_basename (const char *fname);
@ -163,7 +165,7 @@ void custom_canonicalize_pathname (char *, CANON_PATH_FLAGS);
void canonicalize_pathname (char *); void canonicalize_pathname (char *);
/* Misc Unix functions */ /* Misc Unix functions */
int my_mkdir (const char *s, mode_t mode); int my_mkdir (const vfs_path_t * s, mode_t mode);
int my_rmdir (const char *s); int my_rmdir (const char *s);
#ifdef HAVE_REALPATH #ifdef HAVE_REALPATH

17
lib/vfs/interface.c
View File

@ -597,23 +597,6 @@ mc_fstat (int handle, struct stat *buf)
return result; return result;
} }
/* --------------------------------------------------------------------------------------------- */
/**
* Return current directory. If it's local, reread the current directory
* from the OS. Put directory to the provided buffer.
*/
char *
mc_get_current_wd (char *buffer, size_t size)
{
char *cwd = _vfs_get_cwd ();
g_strlcpy (buffer, cwd, size);
g_free (cwd);
return buffer;
}
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
vfs_path_t * vfs_path_t *

22
lib/vfs/vfs.c
View File

@ -438,7 +438,7 @@ vfs_setup_work_dir (void)
{ {
vfs_path_element_t *path_element; vfs_path_element_t *path_element;
g_free (_vfs_get_cwd ()); vfs_setup_cwd ();
/* FIXME: is we really need for this check? */ /* FIXME: is we really need for this check? */
/* /*
@ -518,12 +518,12 @@ vfs_print_message (const char *msg, ...)
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
/** /**
* Return current directory. If it's local, reread the current directory * If it's local, reread the current directory
* from the OS. You must g_strdup() whatever this function returns. * from the OS.
*/ */
char * void
_vfs_get_cwd (void) vfs_setup_cwd (void)
{ {
vfs_path_element_t *path_element; vfs_path_element_t *path_element;
@ -561,6 +561,18 @@ _vfs_get_cwd (void)
vfs_path_free (tmp_vpath); vfs_path_free (tmp_vpath);
} }
} }
}
/* --------------------------------------------------------------------------------------------- */
/**
* Return current directory. If it's local, reread the current directory
* from the OS.
*/
char *
_vfs_get_cwd (void)
{
vfs_setup_cwd ();
return vfs_path_to_str (vfs_get_raw_current_dir ()); return vfs_path_to_str (vfs_get_raw_current_dir ());
} }

3
lib/vfs/vfs.h
View File

@ -267,6 +267,7 @@ void *vfs_class_data_find_by_handle (int handle);
void vfs_free_handle (int handle); void vfs_free_handle (int handle);
void vfs_setup_cwd (void);
char *_vfs_get_cwd (void); char *_vfs_get_cwd (void);
vfs_path_t *vfs_change_encoding (vfs_path_t * vpath, const char *encoding); vfs_path_t *vfs_change_encoding (vfs_path_t * vpath, const char *encoding);
@ -301,7 +302,6 @@ int mc_unlink (const vfs_path_t * vpath);
int mc_ctl (int fd, int ctlop, void *arg); int mc_ctl (int fd, int ctlop, void *arg);
int mc_setctl (const vfs_path_t * vpath, int ctlop, void *arg); int mc_setctl (const vfs_path_t * vpath, int ctlop, void *arg);
int mc_open (const vfs_path_t * vpath, int flags, ...); int mc_open (const vfs_path_t * vpath, int flags, ...);
char *mc_get_current_wd (char *buffer, size_t bufsize);
vfs_path_t *mc_getlocalcopy (const vfs_path_t * pathname_vpath); vfs_path_t *mc_getlocalcopy (const vfs_path_t * pathname_vpath);
int mc_ungetlocalcopy (const vfs_path_t * pathname_vpath, const vfs_path_t * local_vpath, int mc_ungetlocalcopy (const vfs_path_t * pathname_vpath, const vfs_path_t * local_vpath,
gboolean has_changed); gboolean has_changed);
@ -312,4 +312,5 @@ const char *mc_tmpdir (void);
/*** inline functions ****************************************************************************/ /*** inline functions ****************************************************************************/
#endif /* MC_VFS_VFS_H */ #endif /* MC_VFS_VFS_H */

4
src/diffviewer/ydiff.c
View File

@ -3383,8 +3383,8 @@ dview_diff_cmd (void)
panel0 = other_panel; panel0 = other_panel;
panel1 = current_panel; panel1 = current_panel;
} }
file0 = vfs_path_build_filename (panel0->cwd, selection (panel0)->fname, NULL); file0 = vfs_path_append_new (panel0->cwd_vpath, selection (panel0)->fname, NULL);
file1 = vfs_path_build_filename (panel1->cwd, selection (panel1)->fname, NULL); file1 = vfs_path_append_new (panel1->cwd_vpath, selection (panel1)->fname, NULL);
is_dir0 = S_ISDIR (selection (panel0)->st.st_mode); is_dir0 = S_ISDIR (selection (panel0)->st.st_mode);
is_dir1 = S_ISDIR (selection (panel1)->st.st_mode); is_dir1 = S_ISDIR (selection (panel1)->st.st_mode);
} }

8
src/filemanager/boxes.c
View File

@ -1043,8 +1043,12 @@ cd_dialog (void)
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
void void
symlink_dialog (const char *existing, const char *new, char **ret_existing, char **ret_new) symlink_dialog (const vfs_path_t * existing_vpath, const vfs_path_t * new_vpath,
char **ret_existing, char **ret_new)
{ {
char *existing = vfs_path_to_str (existing_vpath);
char *new = vfs_path_to_str (new_vpath);
QuickWidget quick_widgets[] = { QuickWidget quick_widgets[] = {
/* 0 */ QUICK_BUTTON (50, 80, 6, 8, N_("&Cancel"), B_CANCEL, NULL), /* 0 */ QUICK_BUTTON (50, 80, 6, 8, N_("&Cancel"), B_CANCEL, NULL),
/* 1 */ QUICK_BUTTON (16, 80, 6, 8, N_("&OK"), B_ENTER, NULL), /* 1 */ QUICK_BUTTON (16, 80, 6, 8, N_("&OK"), B_ENTER, NULL),
@ -1066,6 +1070,8 @@ symlink_dialog (const char *existing, const char *new, char **ret_existing, char
*ret_new = NULL; *ret_new = NULL;
*ret_existing = NULL; *ret_existing = NULL;
} }
g_free (existing);
g_free (new);
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */

5
src/filemanager/boxes.h
View File

@ -19,13 +19,14 @@
/*** declarations of public functions ************************************************************/ /*** declarations of public functions ************************************************************/
int display_box (WPanel * p, char **user, char **mini, int *use_msformat, int num); int display_box (WPanel * p, char **user, char **mini, int *use_msformat, int num);
const panel_field_t *sort_box (panel_sort_info_t *info); const panel_field_t *sort_box (panel_sort_info_t * info);
void confirm_box (void); void confirm_box (void);
void display_bits_box (void); void display_bits_box (void);
void configure_vfs (void); void configure_vfs (void);
void jobs_cmd (void); void jobs_cmd (void);
char *cd_dialog (void); char *cd_dialog (void);
void symlink_dialog (const char *existing, const char *new, char **ret_existing, char **ret_new); void symlink_dialog (const vfs_path_t * existing_vpath, const vfs_path_t * new_vpath,
char **ret_existing, char **ret_new);
char *tree_box (const char *current_dir); char *tree_box (const char *current_dir);
/*** inline functions ****************************************************************************/ /*** inline functions ****************************************************************************/

102
src/filemanager/cmd.c
View File

@ -307,18 +307,23 @@ select_unselect_cmd (const char *title, const char *history_name, gboolean do_se
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
static int static int
compare_files (char *name1, char *name2, off_t size) compare_files (const vfs_path_t * vpath1, const vfs_path_t * vpath2, off_t size)
{ {
int file1, file2; int file1, file2;
char *name;
int result = -1; /* Different by default */ int result = -1; /* Different by default */
if (size == 0) if (size == 0)
return 0; return 0;
file1 = open (name1, O_RDONLY); name = vfs_path_to_str (vpath1);
file1 = open (name, O_RDONLY);
g_free (name);
if (file1 >= 0) if (file1 >= 0)
{ {
file2 = open (name2, O_RDONLY); name = vfs_path_to_str (vpath2);
file2 = open (name, O_RDONLY);
g_free (name);
if (file2 >= 0) if (file2 >= 0)
{ {
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
@ -362,7 +367,6 @@ static void
compare_dir (WPanel * panel, WPanel * other, enum CompareMode mode) compare_dir (WPanel * panel, WPanel * other, enum CompareMode mode)
{ {
int i, j; int i, j;
char *src_name, *dst_name;
/* No marks by default */ /* No marks by default */
panel->marked = 0; panel->marked = 0;
@ -424,12 +428,16 @@ compare_dir (WPanel * panel, WPanel * other, enum CompareMode mode)
} }
/* Thorough compare on, do byte-by-byte comparison */ /* Thorough compare on, do byte-by-byte comparison */
src_name = concat_dir_and_file (panel->cwd, source->fname); {
dst_name = concat_dir_and_file (other->cwd, target->fname); vfs_path_t *src_name, *dst_name;
if (compare_files (src_name, dst_name, source->st.st_size))
do_file_mark (panel, i, 1); src_name = vfs_path_append_new (panel->cwd_vpath, source->fname, NULL);
g_free (src_name); dst_name = vfs_path_append_new (other->cwd_vpath, target->fname, NULL);
g_free (dst_name); if (compare_files (src_name, dst_name, source->st.st_size))
do_file_mark (panel, i, 1);
vfs_path_free (src_name);
vfs_path_free (dst_name);
}
} }
} /* for (i ...) */ } /* for (i ...) */
} }
@ -456,35 +464,41 @@ do_link (link_type_t link_type, const char *fname)
} }
else else
{ {
char *s; vfs_path_t *s, *d;
char *d;
vfs_path_t *src_vpath;
/* suggest the full path for symlink, and either the full or /* suggest the full path for symlink, and either the full or
relative path to the file it points to */ relative path to the file it points to */
s = concat_dir_and_file (current_panel->cwd, fname); s = vfs_path_append_new (current_panel->cwd_vpath, fname, NULL);
if (get_other_type () == view_listing) if (get_other_type () == view_listing)
d = concat_dir_and_file (other_panel->cwd, fname); d = vfs_path_append_new (other_panel->cwd_vpath, fname, NULL);
else else
d = g_strdup (fname); d = vfs_path_from_str (fname);
if (link_type == LINK_SYMLINK_RELATIVE) if (link_type == LINK_SYMLINK_RELATIVE)
s = diff_two_paths (other_panel->cwd, s); {
char *s_str;
s_str = diff_two_paths (other_panel->cwd_vpath, s);
vfs_path_free (s);
s = vfs_path_from_str_flags (s_str, VPF_NO_CANON);
g_free (s_str);
}
symlink_dialog (s, d, &dest, &src); symlink_dialog (s, d, &dest, &src);
g_free (d); vfs_path_free (d);
g_free (s); vfs_path_free (s);
if (!dest || !*dest || !src || !*src) if (!dest || !*dest || !src || !*src)
goto cleanup; goto cleanup;
save_cwds_stat (); save_cwds_stat ();
dest_vpath = vfs_path_from_str_flags (dest, VPF_NO_CANON); dest_vpath = vfs_path_from_str_flags (dest, VPF_NO_CANON);
src_vpath = vfs_path_from_str (src);
if (mc_symlink (dest_vpath, src_vpath) == -1) s = vfs_path_from_str (src);
if (mc_symlink (dest_vpath, s) == -1)
message (D_ERROR, MSG_ERROR, _("symlink: %s"), unix_error_string (errno)); message (D_ERROR, MSG_ERROR, _("symlink: %s"), unix_error_string (errno));
vfs_path_free (src_vpath); vfs_path_free (s);
} }
update_panels (UP_OPTIMIZE, UP_KEEPSEL); update_panels (UP_OPTIMIZE, UP_KEEPSEL);
@ -923,7 +937,7 @@ rename_cmd_local (void)
void void
mkdir_cmd (void) mkdir_cmd (void)
{ {
char *dir, *absdir; char *dir;
const char *name = ""; const char *name = "";
/* If 'on' then automatically fills name with current selected item name */ /* If 'on' then automatically fills name with current selected item name */
@ -939,10 +953,11 @@ mkdir_cmd (void)
if (*dir) if (*dir)
{ {
vfs_path_t *absdir;
if (dir[0] == '/' || dir[0] == '~') if (dir[0] == '/' || dir[0] == '~')
absdir = g_strdup (dir); absdir = vfs_path_from_str (dir);
else else
absdir = concat_dir_and_file (current_panel->cwd, dir); absdir = vfs_path_append_new (current_panel->cwd_vpath, dir, NULL);
save_cwds_stat (); save_cwds_stat ();
if (my_mkdir (absdir, 0777) == 0) if (my_mkdir (absdir, 0777) == 0)
@ -955,7 +970,7 @@ mkdir_cmd (void)
{ {
message (D_ERROR, MSG_ERROR, "%s", unix_error_string (errno)); message (D_ERROR, MSG_ERROR, "%s", unix_error_string (errno));
} }
g_free (absdir); vfs_path_free (absdir);
} }
g_free (dir); g_free (dir);
} }
@ -1019,9 +1034,19 @@ reread_cmd (void)
{ {
panel_update_flags_t flag = UP_ONLY_CURRENT; panel_update_flags_t flag = UP_ONLY_CURRENT;
if (get_current_type () == view_listing && get_other_type () == view_listing if (get_current_type () == view_listing && get_other_type () == view_listing)
&& strcmp (current_panel->cwd, other_panel->cwd) == 0) {
flag = UP_OPTIMIZE; char *c_cwd, *o_cwd;
c_cwd = vfs_path_to_str (current_panel->cwd_vpath);
o_cwd = vfs_path_to_str (other_panel->cwd_vpath);
if (strcmp (c_cwd, o_cwd) == 0)
flag = UP_OPTIMIZE;
g_free (c_cwd);
g_free (o_cwd);
}
update_panels (UP_RELOAD | flag, UP_KEEPSEL); update_panels (UP_RELOAD | flag, UP_KEEPSEL);
repaint_screen (); repaint_screen ();
@ -1364,7 +1389,7 @@ edit_symlink_cmd (void)
if (mc_symlink (dest_vpath, p_vpath) == -1) if (mc_symlink (dest_vpath, p_vpath) == -1)
message (D_ERROR, MSG_ERROR, _("edit symlink: %s"), message (D_ERROR, MSG_ERROR, _("edit symlink: %s"),
unix_error_string (errno)); unix_error_string (errno));
vfs_path_free(dest_vpath); vfs_path_free (dest_vpath);
} }
update_panels (UP_OPTIMIZE, UP_KEEPSEL); update_panels (UP_OPTIMIZE, UP_KEEPSEL);
repaint_screen (); repaint_screen ();
@ -1568,16 +1593,18 @@ single_dirsize_cmd (void)
size_t marked = 0; size_t marked = 0;
uintmax_t total = 0; uintmax_t total = 0;
ComputeDirSizeUI *ui; ComputeDirSizeUI *ui;
vfs_path_t *p;
ui = compute_dir_size_create_ui (); ui = compute_dir_size_create_ui ();
p = vfs_path_from_str_flags (entry->fname, VPF_NO_CANON);
if (compute_dir_size (entry->fname, ui, compute_dir_size_update_ui, if (compute_dir_size (p, ui, compute_dir_size_update_ui, &marked, &total, TRUE) == FILE_CONT)
&marked, &total, TRUE) == FILE_CONT)
{ {
entry->st.st_size = (off_t) total; entry->st.st_size = (off_t) total;
entry->f.dir_size_computed = 1; entry->f.dir_size_computed = 1;
} }
vfs_path_free (p);
compute_dir_size_destroy_ui (ui); compute_dir_size_destroy_ui (ui);
} }
@ -1608,12 +1635,17 @@ dirsizes_cmd (void)
&& ((panel->dirs_marked && panel->dir.list[i].f.marked) && ((panel->dirs_marked && panel->dir.list[i].f.marked)
|| !panel->dirs_marked) && strcmp (panel->dir.list[i].fname, "..") != 0) || !panel->dirs_marked) && strcmp (panel->dir.list[i].fname, "..") != 0)
{ {
vfs_path_t *p;
size_t marked = 0; size_t marked = 0;
uintmax_t total = 0; uintmax_t total = 0;
gboolean ok;
if (compute_dir_size (panel->dir.list[i].fname, p = vfs_path_from_str_flags (panel->dir.list[i].fname, VPF_NO_CANON);
ui, compute_dir_size_update_ui, &marked, &total, ok = compute_dir_size (p, ui, compute_dir_size_update_ui, &marked, &total,
TRUE) != FILE_CONT) TRUE) != FILE_CONT;
vfs_path_free (p);
if (ok)
break; break;
panel->dir.list[i].st.st_size = (off_t) total; panel->dir.list[i].st.st_size = (off_t) total;

35
src/filemanager/command.c
View File

@ -384,14 +384,20 @@ do_cd_command (char *orig_cmd)
} }
else if (strcmp (cmd + operand_pos, "..") == 0) else if (strcmp (cmd + operand_pos, "..") == 0)
{ {
char *dir = current_panel->cwd; char *str_path;
len = strlen (dir);
while (len && dir[--len] != PATH_SEP); if (vfs_path_elements_count (current_panel->cwd_vpath) != 1 ||
dir[len] = 0; strlen (vfs_path_get_by_index (current_panel->cwd_vpath, 0)->path) > 1)
if (len) {
sync_tree (dir); vfs_path_t *tmp_vpath = current_panel->cwd_vpath;
else
sync_tree (PATH_SEP_STR); current_panel->cwd_vpath =
vfs_path_vtokens_get (tmp_vpath, 0, vfs_path_tokens_count (tmp_vpath) - 1);
vfs_path_free (tmp_vpath);
}
str_path = vfs_path_to_str (current_panel->cwd_vpath);
sync_tree (str_path);
g_free (str_path);
} }
else if (cmd[operand_pos] == PATH_SEP) else if (cmd[operand_pos] == PATH_SEP)
{ {
@ -399,11 +405,14 @@ do_cd_command (char *orig_cmd)
} }
else else
{ {
char *old = current_panel->cwd; char *str_path;
char *new; vfs_path_t *new_vpath;
new = concat_dir_and_file (old, cmd + operand_pos);
sync_tree (new); new_vpath = vfs_path_append_new (current_panel->cwd_vpath, cmd + operand_pos, NULL);
g_free (new); str_path = vfs_path_to_str (new_vpath);
vfs_path_free (new_vpath);
sync_tree (str_path);
g_free (str_path);
} }
} }
else else

236
src/filemanager/file.c
View File

@ -413,7 +413,8 @@ make_symlink (FileOpContext * ctx, const char *src_path, const char *dst_path)
if (ctx->stable_symlinks && !g_path_is_absolute (link_target)) if (ctx->stable_symlinks && !g_path_is_absolute (link_target))
{ {
char *p, *q, *s; char *p, *s;
vfs_path_t *q;
const char *r = strrchr (src_path, PATH_SEP); const char *r = strrchr (src_path, PATH_SEP);
@ -421,18 +422,23 @@ make_symlink (FileOpContext * ctx, const char *src_path, const char *dst_path)
{ {
p = g_strndup (src_path, r - src_path + 1); p = g_strndup (src_path, r - src_path + 1);
if (g_path_is_absolute (dst_path)) if (g_path_is_absolute (dst_path))
q = g_strdup (dst_path); q = vfs_path_from_str_flags (dst_path, VPF_NO_CANON);
else else
q = g_strconcat (p, dst_path, (char *) NULL); q = vfs_path_build_filename (p, dst_path, (char *) NULL);
s = strrchr (q, PATH_SEP);
if (s) if (vfs_path_tokens_count (q) > 1)
{ {
s[1] = 0; vfs_path_t *tmp_vpath1, *tmp_vpath2;
tmp_vpath1 = vfs_path_vtokens_get (q, -1, 1);
s = g_strconcat (p, link_target, (char *) NULL); s = g_strconcat (p, link_target, (char *) NULL);
g_free (p); g_free (p);
g_strlcpy (link_target, s, sizeof (link_target)); g_strlcpy (link_target, s, sizeof (link_target));
g_free (s); g_free (s);
s = diff_two_paths (q, link_target); tmp_vpath2 = vfs_path_from_str (link_target);
s = diff_two_paths (tmp_vpath1, tmp_vpath2);
vfs_path_free (tmp_vpath1);
vfs_path_free (tmp_vpath2);
if (s) if (s)
{ {
g_strlcpy (link_target, s, sizeof (link_target)); g_strlcpy (link_target, s, sizeof (link_target));
@ -441,7 +447,7 @@ make_symlink (FileOpContext * ctx, const char *src_path, const char *dst_path)
} }
else else
g_free (p); g_free (p);
g_free (q); vfs_path_free (q);
} }
} }
link_target_vpath = vfs_path_from_str_flags (link_target, VPF_NO_CANON); link_target_vpath = vfs_path_from_str_flags (link_target, VPF_NO_CANON);
@ -478,7 +484,7 @@ make_symlink (FileOpContext * ctx, const char *src_path, const char *dst_path)
goto retry_dst_symlink; goto retry_dst_symlink;
} }
ret: ret:
vfs_path_free (src_vpath); vfs_path_free (src_vpath);
vfs_path_free (dst_vpath); vfs_path_free (dst_vpath);
vfs_path_free (link_target_vpath); vfs_path_free (link_target_vpath);
@ -1216,16 +1222,15 @@ panel_compute_totals (const WPanel * panel, const void *ui,
if (S_ISDIR (s->st_mode)) if (S_ISDIR (s->st_mode))
{ {
char *dir_name; vfs_path_t *p;
size_t subdir_count = 0; size_t subdir_count = 0;
uintmax_t subdir_bytes = 0; uintmax_t subdir_bytes = 0;
FileProgressStatus status; FileProgressStatus status;
dir_name = concat_dir_and_file (panel->cwd, panel->dir.list[i].fname); p = vfs_path_append_new (panel->cwd_vpath, panel->dir.list[i].fname, NULL);
status =
status = compute_dir_size (dir_name, ui, cback, compute_dir_size (p, ui, cback, &subdir_count, &subdir_bytes, compute_symlinks);
&subdir_count, &subdir_bytes, compute_symlinks); vfs_path_free (p);
g_free (dir_name);
if (status != FILE_CONT) if (status != FILE_CONT)
return FILE_ABORT; return FILE_ABORT;
@ -1258,14 +1263,20 @@ panel_operate_init_totals (FileOperation operation,
ui = compute_dir_size_create_ui (); ui = compute_dir_size_create_ui ();
if (source != NULL) if (source == NULL)
status = compute_dir_size (source, ui, compute_dir_size_update_ui,
&ctx->progress_count, &ctx->progress_bytes,
ctx->follow_links);
else
status = panel_compute_totals (panel, ui, compute_dir_size_update_ui, status = panel_compute_totals (panel, ui, compute_dir_size_update_ui,
&ctx->progress_count, &ctx->progress_bytes, &ctx->progress_count, &ctx->progress_bytes,
ctx->follow_links); ctx->follow_links);
else
{
vfs_path_t *p;
p = vfs_path_from_str (source);
status = compute_dir_size (p, ui, compute_dir_size_update_ui,
&ctx->progress_count, &ctx->progress_bytes,
ctx->follow_links);
vfs_path_free (p);
}
compute_dir_size_destroy_ui (ui); compute_dir_size_destroy_ui (ui);
@ -2048,7 +2059,7 @@ copy_dir_dir (FileOpTotalContext * tctx, FileOpContext * ctx, const char *s, con
} }
} }
dest_dir_vpath = vfs_path_from_str (dest_dir); dest_dir_vpath = vfs_path_from_str (dest_dir);
while (my_mkdir (dest_dir, (cbuf.st_mode & ctx->umask_kill) | S_IRWXU)) while (my_mkdir (dest_dir_vpath, (cbuf.st_mode & ctx->umask_kill) | S_IRWXU) != 0)
{ {
if (ctx->skip_all) if (ctx->skip_all)
return_status = FILE_SKIPALL; return_status = FILE_SKIPALL;
@ -2436,16 +2447,19 @@ compute_dir_size_destroy_ui (ComputeDirSizeUI * ui)
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
FileProgressStatus FileProgressStatus
compute_dir_size_update_ui (const void *ui, const char *dirname) compute_dir_size_update_ui (const void *ui, const vfs_path_t * dirname_vpath)
{ {
const ComputeDirSizeUI *this = (const ComputeDirSizeUI *) ui; const ComputeDirSizeUI *this = (const ComputeDirSizeUI *) ui;
int c; int c;
Gpm_Event event; Gpm_Event event;
char *dirname;
if (ui == NULL) if (ui == NULL)
return FILE_CONT; return FILE_CONT;
dirname = vfs_path_to_str (dirname_vpath);
label_set_text (this->dirname, str_trunc (dirname, this->dlg->cols - 6)); label_set_text (this->dirname, str_trunc (dirname, this->dlg->cols - 6));
g_free (dirname);
event.x = -1; /* Don't show the GPM cursor */ event.x = -1; /* Don't show the GPM cursor */
c = tty_get_event (&event, FALSE, FALSE); c = tty_get_event (&event, FALSE, FALSE);
@ -2476,7 +2490,7 @@ compute_dir_size_update_ui (const void *ui, const char *dirname)
*/ */
FileProgressStatus FileProgressStatus
compute_dir_size (const char *dirname, const void *ui, compute_dir_size (const vfs_path_t * dirname_vpath, const void *ui,
compute_dir_size_callback cback, compute_dir_size_callback cback,
size_t * ret_marked, uintmax_t * ret_total, gboolean compute_symlinks) size_t * ret_marked, uintmax_t * ret_total, gboolean compute_symlinks)
{ {
@ -2485,36 +2499,32 @@ compute_dir_size (const char *dirname, const void *ui,
DIR *dir; DIR *dir;
struct dirent *dirent; struct dirent *dirent;
FileProgressStatus ret = FILE_CONT; FileProgressStatus ret = FILE_CONT;
vfs_path_t *vpath;
vpath = vfs_path_from_str (dirname);
if (!compute_symlinks) if (!compute_symlinks)
{ {
res = mc_lstat (vpath, &s); res = mc_lstat (dirname_vpath, &s);
if (res != 0) if (res != 0)
goto ret; return ret;
/* don't scan symlink to directory */ /* don't scan symlink to directory */
if (S_ISLNK (s.st_mode)) if (S_ISLNK (s.st_mode))
{ {
(*ret_marked)++; (*ret_marked)++;
*ret_total += (uintmax_t) s.st_size; *ret_total += (uintmax_t) s.st_size;
goto ret; return ret;
} }
} }
dir = mc_opendir (vpath); dir = mc_opendir (dirname_vpath);
if (dir == NULL) if (dir == NULL)
goto ret; return ret;
while ((dirent = mc_readdir (dir)) != NULL) while ((dirent = mc_readdir (dir)) != NULL)
{ {
char *fullname;
vfs_path_t *tmp_vpath; vfs_path_t *tmp_vpath;
ret = (cback != NULL) ? cback (ui, dirname) : FILE_CONT; ret = (cback != NULL) ? cback (ui, dirname_vpath) : FILE_CONT;
if (ret != FILE_CONT) if (ret != FILE_CONT)
break; break;
@ -2524,49 +2534,38 @@ compute_dir_size (const char *dirname, const void *ui,
if (strcmp (dirent->d_name, "..") == 0) if (strcmp (dirent->d_name, "..") == 0)
continue; continue;
fullname = concat_dir_and_file (dirname, dirent->d_name); tmp_vpath = vfs_path_append_new (dirname_vpath, dirent->d_name, NULL);
tmp_vpath = vfs_path_from_str (fullname);
res = mc_lstat (tmp_vpath, &s); res = mc_lstat (tmp_vpath, &s);
if (res == 0)
if (res != 0)
{ {
g_free (fullname); if (S_ISDIR (s.st_mode))
vfs_path_free (tmp_vpath);
continue;
}
if (S_ISDIR (s.st_mode))
{
size_t subdir_count = 0;
uintmax_t subdir_bytes = 0;
ret =
compute_dir_size (fullname, ui, cback, &subdir_count, &subdir_bytes,
compute_symlinks);
if (ret != FILE_CONT)
{ {
g_free (fullname); size_t subdir_count = 0;
vfs_path_free (tmp_vpath); uintmax_t subdir_bytes = 0;
break;
ret =
compute_dir_size (tmp_vpath, ui, cback, &subdir_count, &subdir_bytes,
compute_symlinks);
if (ret != FILE_CONT)
{
vfs_path_free (tmp_vpath);
break;
}
*ret_marked += subdir_count;
*ret_total += subdir_bytes;
}
else
{
(*ret_marked)++;
*ret_total += (uintmax_t) s.st_size;
} }
*ret_marked += subdir_count;
*ret_total += subdir_bytes;
} }
else
{
(*ret_marked)++;
*ret_total += (uintmax_t) s.st_size;
}
g_free (fullname);
vfs_path_free (tmp_vpath); vfs_path_free (tmp_vpath);
} }
mc_closedir (dir); mc_closedir (dir);
ret:
vfs_path_free (vpath);
return ret; return ret;
} }
@ -2593,7 +2592,8 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
char *source = NULL; char *source = NULL;
#ifdef WITH_FULL_PATHS #ifdef WITH_FULL_PATHS
char *source_with_path = NULL; vfs_path_t *source_with_vpath = NULL;
char *source_with_path_str = NULL;
#else #else
#define source_with_path source #define source_with_path source
#endif /* !WITH_FULL_PATHS */ #endif /* !WITH_FULL_PATHS */
@ -2666,34 +2666,34 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
/* Show confirmation dialog */ /* Show confirmation dialog */
if (operation != OP_DELETE) if (operation != OP_DELETE)
{ {
char *dest_dir; char *tmp_dest_dir, *dest_dir;
char *dest_dir_;
char *format; char *format;
/* Forced single operations default to the original name */ /* Forced single operations default to the original name */
if (force_single) if (force_single)
dest_dir = source; tmp_dest_dir = g_strdup (source);
else if (get_other_type () == view_listing) else if (get_other_type () == view_listing)
dest_dir = other_panel->cwd; tmp_dest_dir = vfs_path_to_str (other_panel->cwd_vpath);
else else
dest_dir = panel->cwd; tmp_dest_dir = vfs_path_to_str (panel->cwd_vpath);
/* /*
* Add trailing backslash only when do non-local ops. * Add trailing backslash only when do non-local ops.
* It saves user from occasional file renames (when destination * It saves user from occasional file renames (when destination
* dir is deleted) * dir is deleted)
*/ */
if (!force_single && dest_dir[0] != '\0' && dest_dir[strlen (dest_dir) - 1] != PATH_SEP) if (!force_single && tmp_dest_dir[0] != '\0'
&& tmp_dest_dir[strlen (tmp_dest_dir) - 1] != PATH_SEP)
{ {
/* add trailing separator */ /* add trailing separator */
dest_dir_ = g_strconcat (dest_dir, PATH_SEP_STR, (char *) NULL); dest_dir = g_strconcat (tmp_dest_dir, PATH_SEP_STR, (char *) NULL);
g_free (tmp_dest_dir);
} }
else else
{ {
/* just copy */ /* just copy */
dest_dir_ = g_strdup (dest_dir); dest_dir = tmp_dest_dir;
} }
if (dest_dir == NULL)
if (dest_dir_ == NULL)
{ {
ret_val = FALSE; ret_val = FALSE;
goto ret_fast; goto ret_fast;
@ -2704,10 +2704,10 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
dest = file_mask_dialog (ctx, operation, source != NULL, format, dest = file_mask_dialog (ctx, operation, source != NULL, format,
source != NULL ? (void *) source source != NULL ? (void *) source
: (void *) &panel->marked, dest_dir_, &do_bg); : (void *) &panel->marked, dest_dir, &do_bg);
g_free (format); g_free (format);
g_free (dest_dir_); g_free (dest_dir);
if (dest == NULL || dest[0] == '\0') if (dest == NULL || dest[0] == '\0')
{ {
@ -2777,17 +2777,18 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
if (do_bg) if (do_bg)
{ {
int v; int v;
char *cwd_str;
v = do_background (ctx, g_strconcat (op_names[operation], ": ", panel->cwd, (char *) NULL)); cwd_str = vfs_path_to_str (panel->cwd_vpath);
v = do_background (ctx, g_strconcat (op_names[operation], ": ", cwd_str, (char *) NULL));
g_free (cwd_str);
if (v == -1) if (v == -1)
message (D_ERROR, MSG_ERROR, _("Sorry, I could not put the job in background")); message (D_ERROR, MSG_ERROR, _("Sorry, I could not put the job in background"));
/* If we are the parent */ /* If we are the parent */
if (v == 1) if (v == 1)
{ {
tmp_vpath = vfs_path_from_str (panel->cwd); mc_setctl (panel->cwd_vpath, VFS_SETCTL_FORGET, NULL);
mc_setctl (tmp_vpath, VFS_SETCTL_FORGET, NULL);
vfs_path_free (tmp_vpath);
mc_setctl (dest_vpath, VFS_SETCTL_FORGET, NULL); mc_setctl (dest_vpath, VFS_SETCTL_FORGET, NULL);
vfs_path_free (dest_vpath); vfs_path_free (dest_vpath);
@ -2805,10 +2806,9 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
if ((dest != NULL) && (mc_setctl (dest_vpath, VFS_SETCTL_STALE_DATA, (void *) 1))) if ((dest != NULL) && (mc_setctl (dest_vpath, VFS_SETCTL_STALE_DATA, (void *) 1)))
save_dest = g_strdup (dest); save_dest = g_strdup (dest);
tmp_vpath = vfs_path_from_str (panel->cwd); if ((vfs_path_tokens_count (panel->cwd_vpath) != 0)
if ((panel->cwd[0] != '\0') && (mc_setctl (tmp_vpath, VFS_SETCTL_STALE_DATA, (void *) 1))) && (mc_setctl (panel->cwd_vpath, VFS_SETCTL_STALE_DATA, (void *) 1)))
save_cwd = g_strdup (panel->cwd); save_cwd = vfs_path_to_str (panel->cwd_vpath);
vfs_path_free (tmp_vpath);
/* Now, let's do the job */ /* Now, let's do the job */
@ -2836,23 +2836,23 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
/* The source and src_stat variables have been initialized before */ /* The source and src_stat variables have been initialized before */
#ifdef WITH_FULL_PATHS #ifdef WITH_FULL_PATHS
if (g_path_is_absolute (source)) if (g_path_is_absolute (source))
source_with_path = g_strdup (source); source_with_vpath = vfs_path_from_str (source);
else else
source_with_path = mc_build_filename (panel->cwd, source, (char *) NULL); source_with_vpath = vfs_path_append_new (panel->cwd_vpath, source, (char *) NULL);
source_with_path_str = vfs_path_to_str (source_with_vpath);
#endif /* WITH_FULL_PATHS */ #endif /* WITH_FULL_PATHS */
if (panel_operate_init_totals (operation, panel, source_with_path_str, ctx) == FILE_CONT)
if (panel_operate_init_totals (operation, panel, source_with_path, ctx) == FILE_CONT)
{ {
if (operation == OP_DELETE) if (operation == OP_DELETE)
{ {
if (S_ISDIR (src_stat.st_mode)) if (S_ISDIR (src_stat.st_mode))
value = erase_dir (tctx, ctx, source_with_path); value = erase_dir (tctx, ctx, source_with_path_str);
else else
value = erase_file (tctx, ctx, source_with_path); value = erase_file (tctx, ctx, source_with_path_str);
} }
else else
{ {
temp = transform_source (ctx, source_with_path); temp = transform_source (ctx, source_with_path_str);
if (temp == NULL) if (temp == NULL)
value = transform_error; value = transform_error;
else else
@ -2872,24 +2872,20 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
{ {
case OP_COPY: case OP_COPY:
/* we use file_mask_op_follow_links only with OP_COPY */ /* we use file_mask_op_follow_links only with OP_COPY */
{ ctx->stat_func (source_with_vpath, &src_stat);
vfs_path_t *vpath = vfs_path_from_str (source_with_path);
ctx->stat_func (vpath, &src_stat);
vfs_path_free (vpath);
}
if (S_ISDIR (src_stat.st_mode)) if (S_ISDIR (src_stat.st_mode))
value = copy_dir_dir (tctx, ctx, source_with_path, dest, value = copy_dir_dir (tctx, ctx, source_with_path_str, dest,
TRUE, FALSE, FALSE, NULL); TRUE, FALSE, FALSE, NULL);
else else
value = copy_file_file (tctx, ctx, source_with_path, dest); value = copy_file_file (tctx, ctx, source_with_path_str, dest);
break; break;
case OP_MOVE: case OP_MOVE:
if (S_ISDIR (src_stat.st_mode)) if (S_ISDIR (src_stat.st_mode))
value = move_dir_dir (tctx, ctx, source_with_path, dest); value = move_dir_dir (tctx, ctx, source_with_path_str, dest);
else else
value = move_file_file (tctx, ctx, source_with_path, dest); value = move_file_file (tctx, ctx, source_with_path_str, dest);
break; break;
default: default:
@ -2935,23 +2931,26 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
src_stat = panel->dir.list[i].st; src_stat = panel->dir.list[i].st;
#ifdef WITH_FULL_PATHS #ifdef WITH_FULL_PATHS
g_free (source_with_path); g_free (source_with_path_str);
vfs_path_free (source_with_vpath);
if (g_path_is_absolute (source)) if (g_path_is_absolute (source))
source_with_path = g_strdup (source); source_with_vpath = vfs_path_from_str (source);
else else
source_with_path = mc_build_filename (panel->cwd, source, (char *) NULL); source_with_vpath =
vfs_path_append_new (panel->cwd_vpath, source, (char *) NULL);
source_with_path_str = vfs_path_to_str (source_with_vpath);
#endif /* WITH_FULL_PATHS */ #endif /* WITH_FULL_PATHS */
if (operation == OP_DELETE) if (operation == OP_DELETE)
{ {
if (S_ISDIR (src_stat.st_mode)) if (S_ISDIR (src_stat.st_mode))
value = erase_dir (tctx, ctx, source_with_path); value = erase_dir (tctx, ctx, source_with_path_str);
else else
value = erase_file (tctx, ctx, source_with_path); value = erase_file (tctx, ctx, source_with_path_str);
} }
else else
{ {
temp = transform_source (ctx, source_with_path); temp = transform_source (ctx, source_with_path_str);
if (temp == NULL) if (temp == NULL)
value = transform_error; value = transform_error;
@ -2963,8 +2962,8 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
temp2 = concat_dir_and_file (repl_dest, temp); temp2 = concat_dir_and_file (repl_dest, temp);
g_free (temp); g_free (temp);
g_free (repl_dest); g_free (repl_dest);
temp3 = source_with_path; temp3 = source_with_path_str;
source_with_path = strutils_shell_unescape (source_with_path); source_with_path_str = strutils_shell_unescape (source_with_path_str);
g_free (temp3); g_free (temp3);
temp3 = temp2; temp3 = temp2;
temp2 = strutils_shell_unescape (temp2); temp2 = strutils_shell_unescape (temp2);
@ -2977,23 +2976,23 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
{ {
vfs_path_t *vpath; vfs_path_t *vpath;
vpath = vfs_path_from_str (source_with_path); vpath = vfs_path_from_str (source_with_path_str);
ctx->stat_func (vpath, &src_stat); ctx->stat_func (vpath, &src_stat);
vfs_path_free (vpath); vfs_path_free (vpath);
} }
if (S_ISDIR (src_stat.st_mode)) if (S_ISDIR (src_stat.st_mode))
value = copy_dir_dir (tctx, ctx, source_with_path, temp2, value = copy_dir_dir (tctx, ctx, source_with_path_str, temp2,
TRUE, FALSE, FALSE, NULL); TRUE, FALSE, FALSE, NULL);
else else
value = copy_file_file (tctx, ctx, source_with_path, temp2); value = copy_file_file (tctx, ctx, source_with_path_str, temp2);
free_linklist (&dest_dirs); free_linklist (&dest_dirs);
break; break;
case OP_MOVE: case OP_MOVE:
if (S_ISDIR (src_stat.st_mode)) if (S_ISDIR (src_stat.st_mode))
value = move_dir_dir (tctx, ctx, source_with_path, temp2); value = move_dir_dir (tctx, ctx, source_with_path_str, temp2);
else else
value = move_file_file (tctx, ctx, source_with_path, temp2); value = move_file_file (tctx, ctx, source_with_path_str, temp2);
break; break;
default: default:
@ -3049,7 +3048,8 @@ panel_operate (void *source_panel, FileOperation operation, gboolean force_singl
free_linklist (&linklist); free_linklist (&linklist);
free_linklist (&dest_dirs); free_linklist (&dest_dirs);
#ifdef WITH_FULL_PATHS #ifdef WITH_FULL_PATHS
g_free (source_with_path); g_free (source_with_path_str);
vfs_path_free (source_with_vpath);
#endif /* WITH_FULL_PATHS */ #endif /* WITH_FULL_PATHS */
g_free (dest); g_free (dest);
vfs_path_free (dest_vpath); vfs_path_free (dest_vpath);

11
src/filemanager/file.h
View File

@ -5,7 +5,7 @@
#ifndef MC__FILE_H #ifndef MC__FILE_H
#define MC__FILE_H #define MC__FILE_H
#include <inttypes.h> /* off_t, uintmax_t */ #include <inttypes.h> /* off_t, uintmax_t */
#include "lib/global.h" #include "lib/global.h"
#include "lib/widget.h" #include "lib/widget.h"
@ -16,7 +16,8 @@
/* Compute directory size */ /* Compute directory size */
/* callback to update status dialog */ /* callback to update status dialog */
typedef FileProgressStatus (*compute_dir_size_callback) (const void *ui, const char *dirname); typedef FileProgressStatus (*compute_dir_size_callback) (const void *ui,
const vfs_path_t * dirname_vpath);
/*** enums ***************************************************************************************/ /*** enums ***************************************************************************************/
@ -53,14 +54,14 @@ gboolean panel_operate (void *source_panel, FileOperation op, gboolean force_sin
FileProgressStatus file_error (const char *format, const char *file); FileProgressStatus file_error (const char *format, const char *file);
/* return value is FILE_CONT or FILE_ABORT */ /* return value is FILE_CONT or FILE_ABORT */
FileProgressStatus compute_dir_size (const char *dirname, const void *ui, FileProgressStatus compute_dir_size (const vfs_path_t * dirname_vpath, const void *ui,
compute_dir_size_callback cback, compute_dir_size_callback cback,
size_t * ret_marked, uintmax_t *ret_total, size_t * ret_marked, uintmax_t * ret_total,
gboolean compute_symlinks); gboolean compute_symlinks);
ComputeDirSizeUI *compute_dir_size_create_ui (void); ComputeDirSizeUI *compute_dir_size_create_ui (void);
void compute_dir_size_destroy_ui (ComputeDirSizeUI * ui); void compute_dir_size_destroy_ui (ComputeDirSizeUI * ui);
FileProgressStatus compute_dir_size_update_ui (const void *ui, const char *dirname); FileProgressStatus compute_dir_size_update_ui (const void *ui, const vfs_path_t * dirname_vpath);
/*** inline functions ****************************************************************************/ /*** inline functions ****************************************************************************/
#endif /* MC__FILE_H */ #endif /* MC__FILE_H */

8
src/filemanager/filegui.c
View File

@ -810,15 +810,17 @@ file_progress_show_source (FileOpContext * ctx, const char *s)
{ {
#ifdef WITH_FULL_PATHS #ifdef WITH_FULL_PATHS
size_t i; size_t i;
char *cwd_str;
i = strlen (current_panel->cwd); cwd_str = vfs_path_to_str (current_panel->cwd_vpath);
i = strlen (cwd_str);
/* We remove the full path we have added before */ /* We remove the full path we have added before */
if (strncmp (s, current_panel->cwd, i) == 0) if (strncmp (s, cwd_str, i) == 0)
if (s[i] == PATH_SEP) if (s[i] == PATH_SEP)
s += i + 1; s += i + 1;
g_free (cwd_str);
#endif /* WITH_FULL_PATHS */ #endif /* WITH_FULL_PATHS */
label_set_text (ui->file_label[0], _("Source")); label_set_text (ui->file_label[0], _("Source"));
label_set_text (ui->file_string[0], truncFileString (ui, s)); label_set_text (ui->file_string[0], truncFileString (ui, s));
} }

36
src/filemanager/filenot.c
View File

@ -54,15 +54,16 @@
/*** file scope functions ************************************************************************/ /*** file scope functions ************************************************************************/
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
static char * static vfs_path_t *
get_absolute_name (const char *file) get_absolute_name (const vfs_path_t * vpath)
{ {
char dir[MC_MAXPATHLEN]; if (vpath == NULL)
return NULL;
if (file[0] == PATH_SEP) if (*(vfs_path_get_by_index (vpath, 0)->path) == PATH_SEP)
return g_strdup (file); return vfs_path_clone (vpath);
mc_get_current_wd (dir, MC_MAXPATHLEN);
return concat_dir_and_file (dir, file); return vfs_path_append_vpath_new (vfs_get_raw_current_dir (), vpath);
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
@ -126,13 +127,10 @@ my_mkdir_rec (char *s, mode_t mode)
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
int int
my_mkdir (const char *s, mode_t mode) my_mkdir (const vfs_path_t * s_vpath, mode_t mode)
{ {
int result; int result;
char *my_s;
vfs_path_t *s_vpath;
s_vpath = vfs_path_from_str (s);
result = mc_mkdir (s_vpath, mode); result = mc_mkdir (s_vpath, mode);
if (result != 0) if (result != 0)
@ -145,15 +143,14 @@ my_mkdir (const char *s, mode_t mode)
} }
if (result == 0) if (result == 0)
{ {
my_s = get_absolute_name (s); vfs_path_t *my_s;
my_s = get_absolute_name (s_vpath);
#ifdef FIXME #ifdef FIXME
tree_add_entry (tree, my_s); tree_add_entry (tree, my_s);
#endif #endif
vfs_path_free (my_s);
g_free (my_s);
} }
vfs_path_free (s_vpath);
return result; return result;
} }
@ -163,24 +160,23 @@ int
my_rmdir (const char *s) my_rmdir (const char *s)
{ {
int result; int result;
char *my_s;
vfs_path_t *vpath; vfs_path_t *vpath;
#ifdef FIXME #ifdef FIXME
WTree *tree = 0; WTree *tree = 0;
#endif #endif
vpath = vfs_path_from_str (s); vpath = vfs_path_from_str_flags (s, VPF_NO_CANON);
/* FIXME: Should receive a Wtree! */ /* FIXME: Should receive a Wtree! */
result = mc_rmdir (vpath); result = mc_rmdir (vpath);
if (result == 0) if (result == 0)
{ {
my_s = get_absolute_name (s); vfs_path_t *my_s;
my_s = get_absolute_name (vpath);
#ifdef FIXME #ifdef FIXME
tree_remove_entry (tree, my_s); tree_remove_entry (tree, my_s);
#endif #endif
vfs_path_free (my_s);
g_free (my_s);
} }
vfs_path_free (vpath); vfs_path_free (vpath);
return result; return result;

29
src/filemanager/find.c
View File

@ -658,16 +658,21 @@ find_parameters (char **start_dir, ssize_t * start_dir_len,
case B_TREE: case B_TREE:
{ {
const char *temp_dir = in_start->buffer; char *temp_dir;
temp_dir = in_start->buffer;
if ((temp_dir[0] == '\0') || ((temp_dir[0] == '.') && (temp_dir[1] == '\0'))) if ((temp_dir[0] == '\0') || ((temp_dir[0] == '.') && (temp_dir[1] == '\0')))
temp_dir = current_panel->cwd; temp_dir = vfs_path_to_str (current_panel->cwd_vpath);
else
temp_dir = g_strdup (temp_dir);
if (in_start_dir != INPUT_LAST_TEXT) if (in_start_dir != INPUT_LAST_TEXT)
g_free (in_start_dir); g_free (in_start_dir);
in_start_dir = tree_box (temp_dir); in_start_dir = tree_box (temp_dir);
if (in_start_dir == NULL) if (in_start_dir == NULL)
in_start_dir = g_strdup (temp_dir); in_start_dir = temp_dir;
else
g_free (temp_dir);
input_assign_text (in_start, in_start_dir); input_assign_text (in_start, in_start_dir);
@ -709,10 +714,10 @@ find_parameters (char **start_dir, ssize_t * start_dir_len,
if (s[0] == '.' && s[1] == '\0') if (s[0] == '.' && s[1] == '\0')
{ {
*start_dir = g_strdup (current_panel->cwd); *start_dir = vfs_path_to_str (current_panel->cwd_vpath);
/* FIXME: is current_panel->cwd canonicalized? */ /* FIXME: is current_panel->cwd_vpath canonicalized? */
/* relative paths will be used in panelization */ /* relative paths will be used in panelization */
*start_dir_len = (ssize_t) strlen (current_panel->cwd); *start_dir_len = (ssize_t) strlen (*start_dir);
g_free (s); g_free (s);
} }
else if (g_path_is_absolute (s)) else if (g_path_is_absolute (s))
@ -723,8 +728,12 @@ find_parameters (char **start_dir, ssize_t * start_dir_len,
else else
{ {
/* relative paths will be used in panelization */ /* relative paths will be used in panelization */
*start_dir = mc_build_filename (current_panel->cwd, s, (char *) NULL); char *cwd_str;
*start_dir_len = (ssize_t) strlen (current_panel->cwd);
cwd_str = vfs_path_to_str (current_panel->cwd_vpath);
*start_dir = mc_build_filename (cwd_str, s, (char *) NULL);
*start_dir_len = (ssize_t) strlen (cwd_str);
g_free (cwd_str);
g_free (s); g_free (s);
} }
@ -1677,8 +1686,8 @@ do_find (const char *start_dir, ssize_t start_dir_len, const char *ignore_dirs,
if (start_dir_len < 0) if (start_dir_len < 0)
{ {
int ret; int ret;
vfs_path_free (current_panel->cwd_vpath);
strcpy (current_panel->cwd, PATH_SEP_STR); current_panel->cwd_vpath = vfs_path_from_str (PATH_SEP_STR);
ret = chdir (PATH_SEP_STR); ret = chdir (PATH_SEP_STR);
} }
panelize_save_panel (current_panel); panelize_save_panel (current_panel);

17
src/filemanager/hotlist.c
View File

@ -1092,7 +1092,7 @@ add_new_entry_cmd (void)
int ret; int ret;
/* Take current directory as default value for input fields */ /* Take current directory as default value for input fields */
to_free = title = url = strip_password (g_strdup (current_panel->cwd), 1); to_free = title = url = strip_password (vfs_path_to_str (current_panel->cwd_vpath), 1);
ret = add_new_entry_input (_("New hotlist entry"), _("Directory label:"), ret = add_new_entry_input (_("New hotlist entry"), _("Directory label:"),
_("Directory path:"), "[Hotlist]", &title, &url); _("Directory path:"), "[Hotlist]", &title, &url);
@ -1689,13 +1689,18 @@ void
add2hotlist_cmd (void) add2hotlist_cmd (void)
{ {
char *lc_prompt, *label; char *lc_prompt, *label;
const char *cp = _("Label for \"%s\":"); const char *cp = N_("Label for \"%s\":");
int l = str_term_width1 (cp); int l;
char *label_string = g_strdup (current_panel->cwd); char *label_string;
#ifdef ENABLE_NLS
cp = _(cp);
#endif
l = str_term_width1 (cp);
label_string = vfs_path_to_str (current_panel->cwd_vpath);
lc_prompt = g_strdup_printf (cp, path_trunc (label_string, COLS - 2 * UX - (l + 8)));
strip_password (label_string, 1); strip_password (label_string, 1);
lc_prompt = g_strdup_printf (cp, path_trunc (current_panel->cwd, COLS - 2 * UX - (l + 8)));
label = input_dialog (_("Add to hotlist"), lc_prompt, MC_HISTORY_HOTLIST_ADD, label_string); label = input_dialog (_("Add to hotlist"), lc_prompt, MC_HISTORY_HOTLIST_ADD, label_string);
g_free (lc_prompt); g_free (lc_prompt);

9
src/filemanager/info.c
View File

@ -119,7 +119,14 @@ info_show_info (struct WInfo *info)
if (get_current_type () != view_listing) if (get_current_type () != view_listing)
return; return;
my_statfs (&myfs_stats, current_panel->cwd); {
char *cwd_str;
cwd_str = vfs_path_to_str (current_panel->cwd_vpath);
my_statfs (&myfs_stats, cwd_str);
g_free (cwd_str);
}
st = current_panel->dir.list[current_panel->selected].st; st = current_panel->dir.list[current_panel->selected].st;
/* Print only lines which fit */ /* Print only lines which fit */

22
src/filemanager/layout.c
View File

@ -43,7 +43,7 @@
#include "lib/tty/key.h" #include "lib/tty/key.h"
#include "lib/tty/mouse.h" #include "lib/tty/mouse.h"
#include "lib/mcconfig.h" #include "lib/mcconfig.h"
#include "lib/vfs/vfs.h" /* For mc_get_current_wd() */ #include "lib/vfs/vfs.h" /* For _vfs_get_cwd () */
#include "lib/strutil.h" #include "lib/strutil.h"
#include "lib/widget.h" #include "lib/widget.h"
#include "lib/event.h" #include "lib/event.h"
@ -913,10 +913,11 @@ set_display_type (int num, panel_view_mode_t type)
/* when it's first creation (for example view_info) */ /* when it's first creation (for example view_info) */
if (old_widget == NULL && type != view_listing) if (old_widget == NULL && type != view_listing)
{ {
char panel_dir[MC_MAXPATHLEN]; char *panel_dir;
mc_get_current_wd (panel_dir, sizeof (panel_dir)); panel_dir = _vfs_get_cwd ();
panels[num].last_saved_dir = g_strdup (panel_dir); panels[num].last_saved_dir = g_strdup (panel_dir);
g_free (panel_dir);
} }
switch (type) switch (type)
@ -1034,8 +1035,8 @@ swap_panels (void)
/* Change content and related stuff */ /* Change content and related stuff */
panelswap (dir); panelswap (dir);
panelswap (active); panelswap (active);
panelswapstr (cwd); panelswap (cwd_vpath);
panelswapstr (lwd); panelswap (lwd_vpath);
panelswap (count); panelswap (count);
panelswap (marked); panelswap (marked);
panelswap (dirs_marked); panelswap (dirs_marked);
@ -1203,11 +1204,10 @@ save_panel_dir (int idx)
if ((type == view_listing) && (widget != NULL)) if ((type == view_listing) && (widget != NULL))
{ {
WPanel *w = (WPanel *) widget; WPanel *w = (WPanel *) widget;
char *widget_work_dir = w->cwd;
g_free (panels[idx].last_saved_dir); /* last path no needed */ g_free (panels[idx].last_saved_dir); /* last path no needed */
/* Because path can be nonlocal */ /* Because path can be nonlocal */
panels[idx].last_saved_dir = g_strdup (widget_work_dir); panels[idx].last_saved_dir = vfs_path_to_str (w->cwd_vpath);
} }
} }
@ -1215,7 +1215,7 @@ save_panel_dir (int idx)
/** Return working dir, if it's view_listing - cwd, /** Return working dir, if it's view_listing - cwd,
but for other types - last_saved_dir */ but for other types - last_saved_dir */
const char * char *
get_panel_dir_for (const WPanel * widget) get_panel_dir_for (const WPanel * widget)
{ {
int i; int i;
@ -1225,12 +1225,12 @@ get_panel_dir_for (const WPanel * widget)
break; break;
if (i >= MAX_VIEWS) if (i >= MAX_VIEWS)
return "."; return g_strdup (".");
if (get_display_type (i) == view_listing) if (get_display_type (i) == view_listing)
return ((WPanel *) get_panel_widget (i))->cwd; return vfs_path_to_str (((WPanel *) get_panel_widget (i))->cwd_vpath);
return panels[i].last_saved_dir; return g_strdup (panels[i].last_saved_dir);
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */

2
src/filemanager/layout.h
View File

@ -71,7 +71,7 @@ struct Widget *get_panel_widget (int idx);
struct WPanel *get_other_panel (void); struct WPanel *get_other_panel (void);
void save_panel_dir (int idx); void save_panel_dir (int idx);
const char *get_panel_dir_for (const struct WPanel * widget); char *get_panel_dir_for (const struct WPanel * widget);
void set_hintbar (const char *str); void set_hintbar (const char *str);

68
src/filemanager/midnight.c
View File

@ -436,7 +436,9 @@ midnight_get_title (const Dlg_head * h, size_t len)
(void) h; (void) h;
path = strip_home_and_password (current_panel->cwd); p = vfs_path_to_str (current_panel->cwd_vpath);
path = strip_home_and_password (p);
g_free (p);
res = gethostname (host, sizeof (host)); res = gethostname (host, sizeof (host));
if (res != 0) if (res != 0)
host[0] = '\0'; host[0] = '\0';
@ -477,24 +479,15 @@ check_panel_timestamp (const WPanel * panel, panel_view_mode_t mode, struct vfs_
{ {
if (mode == view_listing) if (mode == view_listing)
{ {
vfs_path_t *vpath;
vfs_path_element_t *path_element; vfs_path_element_t *path_element;
vpath = vfs_path_from_str (panel->cwd); path_element = vfs_path_get_by_index (panel->cwd_vpath, -1);
path_element = vfs_path_get_by_index (vpath, -1);
if (path_element->class != vclass) if (path_element->class != vclass)
{
vfs_path_free (vpath);
return FALSE; return FALSE;
}
if (vfs_getid (vpath) != id) if (vfs_getid (panel->cwd_vpath) != id)
{
vfs_path_free (vpath);
return FALSE; return FALSE;
}
vfs_path_free (vpath);
} }
return TRUE; return TRUE;
} }
@ -590,7 +583,7 @@ create_panels (void)
int current_index; int current_index;
int other_index; int other_index;
panel_view_mode_t current_mode, other_mode; panel_view_mode_t current_mode, other_mode;
char original_dir[BUF_1K] = "\0"; char *original_dir = NULL;
if (boot_current_is_left) if (boot_current_is_left)
{ {
@ -617,7 +610,7 @@ create_panels (void)
* since we may not be able to chdir to the proper * since we may not be able to chdir to the proper
* second directory later * second directory later
*/ */
mc_get_current_wd (original_dir, sizeof (original_dir) - 2); original_dir = vfs_get_current_dir ();
} }
vpath = vfs_path_from_str (mc_run_param0); vpath = vfs_path_from_str (mc_run_param0);
mc_chdir (vpath); mc_chdir (vpath);
@ -635,6 +628,7 @@ create_panels (void)
mc_chdir (vpath); mc_chdir (vpath);
vfs_path_free (vpath); vfs_path_free (vpath);
} }
g_free (original_dir);
set_display_type (other_index, other_mode); set_display_type (other_index, other_mode);
if (startup_left_mode == view_listing) if (startup_left_mode == view_listing)
@ -674,7 +668,7 @@ put_current_path (void)
if (!command_prompt) if (!command_prompt)
return; return;
cwd_path = remove_encoding_from_path (current_panel->cwd); cwd_path = remove_encoding_from_path (current_panel->cwd_vpath);
command_insert (cmdline, cwd_path, FALSE); command_insert (cmdline, cwd_path, FALSE);
if (cwd_path[strlen (cwd_path) - 1] != PATH_SEP) if (cwd_path[strlen (cwd_path) - 1] != PATH_SEP)
@ -695,7 +689,7 @@ put_other_path (void)
if (!command_prompt) if (!command_prompt)
return; return;
cwd_path = remove_encoding_from_path (other_panel->cwd); cwd_path = remove_encoding_from_path (other_panel->cwd_vpath);
command_insert (cmdline, cwd_path, FALSE); command_insert (cmdline, cwd_path, FALSE);
if (cwd_path[strlen (cwd_path) - 1] != PATH_SEP) if (cwd_path[strlen (cwd_path) - 1] != PATH_SEP)
@ -716,7 +710,7 @@ put_link (WPanel * panel)
vfs_path_t *vpath; vfs_path_t *vpath;
int i; int i;
vpath = vfs_path_build_filename (panel->cwd, selection (panel)->fname, NULL); vpath = vfs_path_append_new (panel->cwd_vpath, selection (panel)->fname, NULL);
i = mc_readlink (vpath, buffer, MC_MAXPATHLEN - 1); i = mc_readlink (vpath, buffer, MC_MAXPATHLEN - 1);
vfs_path_free (vpath); vfs_path_free (vpath);
@ -852,14 +846,15 @@ static void
setup_dummy_mc (void) setup_dummy_mc (void)
{ {
vfs_path_t *vpath; vfs_path_t *vpath;
char d[MC_MAXPATHLEN]; char *d;
int ret; int ret;
mc_get_current_wd (d, MC_MAXPATHLEN); d = _vfs_get_cwd ();
setup_mc (); setup_mc ();
vpath = vfs_path_from_str (d); vpath = vfs_path_from_str (d);
ret = mc_chdir (vpath); ret = mc_chdir (vpath);
vfs_path_free (vpath); vfs_path_free (vpath);
g_free (d);
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
@ -881,10 +876,22 @@ done_mc (void)
g_free (curr_dir); g_free (curr_dir);
if ((current_panel != NULL) && (get_current_type () == view_listing)) if ((current_panel != NULL) && (get_current_type () == view_listing))
vfs_stamp_path (current_panel->cwd); {
char *tmp_path;
tmp_path = vfs_path_to_str (current_panel->cwd_vpath);
vfs_stamp_path (tmp_path);
g_free (tmp_path);
}
if ((other_panel != NULL) && (get_other_type () == view_listing)) if ((other_panel != NULL) && (get_other_type () == view_listing))
vfs_stamp_path (other_panel->cwd); {
char *tmp_path;
tmp_path = vfs_path_to_str (other_panel->cwd_vpath);
vfs_stamp_path (tmp_path);
g_free (tmp_path);
}
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
@ -932,8 +939,7 @@ prepend_cwd_on_local (const char *filename)
} }
vfs_path_free (vpath); vfs_path_free (vpath);
d = g_malloc (MC_MAXPATHLEN + strlen (filename) + 2); d = _vfs_get_cwd ();
mc_get_current_wd (d, MC_MAXPATHLEN);
l = strlen (d); l = strlen (d);
d[l++] = PATH_SEP; d[l++] = PATH_SEP;
strcpy (d + l, filename); strcpy (d + l, filename);
@ -1628,17 +1634,9 @@ save_cwds_stat (void)
{ {
if (panels_options.fast_reload) if (panels_options.fast_reload)
{ {
vfs_path_t *vpath; mc_stat (current_panel->cwd_vpath, &(current_panel->dir_stat));
vpath = vfs_path_from_str (current_panel->cwd);
mc_stat (vpath, &(current_panel->dir_stat));
vfs_path_free (vpath);
if (get_other_type () == view_listing) if (get_other_type () == view_listing)
{ mc_stat (other_panel->cwd_vpath, &(other_panel->dir_stat));
vpath = vfs_path_from_str (other_panel->cwd);
mc_stat (vpath, &(other_panel->dir_stat));
vfs_path_free (vpath);
}
} }
} }
@ -1687,9 +1685,9 @@ do_nc (void)
create_panels_and_run_mc (); create_panels_and_run_mc ();
ret = TRUE; ret = TRUE;
/* destroy_dlg destroys even current_panel->cwd, so we have to save a copy :) */ /* destroy_dlg destroys even current_panel->cwd_vpath, so we have to save a copy :) */
if (mc_args__last_wd_file != NULL && vfs_current_is_local ()) if (mc_args__last_wd_file != NULL && vfs_current_is_local ())
last_wd_string = g_strdup (current_panel->cwd); last_wd_string = vfs_path_to_str (current_panel->cwd_vpath);
/* don't handle VFS timestamps for dirs opened in panels */ /* don't handle VFS timestamps for dirs opened in panels */
mc_event_destroy (MCEVENT_GROUP_CORE, "vfs_timestamp"); mc_event_destroy (MCEVENT_GROUP_CORE, "vfs_timestamp");

354
src/filemanager/panel.c
View File

@ -80,7 +80,9 @@
/* The hook list for the select file function */ /* The hook list for the select file function */
hook_t *select_file_hook = NULL; hook_t *select_file_hook = NULL;
/* *INDENT-OFF* */
panelized_panel_t panelized_panel = { { NULL, 0 }, -1, { '\0' } }; panelized_panel_t panelized_panel = { { NULL, 0 }, -1, { '\0' } };
/* *INDENT-ON* */
static const char *string_file_name (file_entry *, int); static const char *string_file_name (file_entry *, int);
static const char *string_file_size (file_entry *, int); static const char *string_file_size (file_entry *, int);
@ -906,7 +908,7 @@ display_mini_info (WPanel * panel)
int len; int len;
lc_link_vpath = lc_link_vpath =
vfs_path_build_filename (panel->cwd, panel->dir.list[panel->selected].fname, NULL); vfs_path_append_new (panel->cwd_vpath, panel->dir.list[panel->selected].fname, NULL);
len = mc_readlink (lc_link_vpath, link_target, MC_MAXPATHLEN - 1); len = mc_readlink (lc_link_vpath, link_target, MC_MAXPATHLEN - 1);
vfs_path_free (lc_link_vpath); vfs_path_free (lc_link_vpath);
if (len > 0) if (len > 0)
@ -1026,29 +1028,28 @@ show_free_space (WPanel * panel)
static struct my_statfs myfs_stats; static struct my_statfs myfs_stats;
/* Old current working directory for displaying free space */ /* Old current working directory for displaying free space */
static char *old_cwd = NULL; static char *old_cwd = NULL;
vfs_path_t *vpath = vfs_path_from_str (panel->cwd); char *tmp_path;
/* Don't try to stat non-local fs */ /* Don't try to stat non-local fs */
if (!vfs_file_is_local (vpath) || !free_space) if (!vfs_file_is_local (panel->cwd_vpath) || !free_space)
{
vfs_path_free (vpath);
return; return;
}
vfs_path_free (vpath);
if (old_cwd == NULL || strcmp (old_cwd, panel->cwd) != 0) tmp_path = vfs_path_to_str (panel->cwd_vpath);
if (old_cwd == NULL || strcmp (old_cwd, tmp_path) != 0)
{ {
char rpath[PATH_MAX]; char rpath[PATH_MAX];
init_my_statfs (); init_my_statfs ();
g_free (old_cwd); g_free (old_cwd);
old_cwd = g_strdup (panel->cwd); old_cwd = tmp_path;
tmp_path = NULL;
if (mc_realpath (panel->cwd, rpath) == NULL) if (mc_realpath (old_cwd, rpath) == NULL)
return; return;
my_statfs (&myfs_stats, rpath); my_statfs (&myfs_stats, rpath);
} }
g_free (tmp_path);
if (myfs_stats.avail != 0 || myfs_stats.total != 0) if (myfs_stats.avail != 0 || myfs_stats.total != 0)
{ {
@ -1105,9 +1106,15 @@ show_dir (WPanel * panel)
if (panel->is_panelized) if (panel->is_panelized)
tty_printf (" %s ", _("Panelize")); tty_printf (" %s ", _("Panelize"));
else else
{
char *tmp_path;
tmp_path = vfs_path_to_str (panel->cwd_vpath);
tty_printf (" %s ", tty_printf (" %s ",
str_term_trim (strip_home_and_password (panel->cwd), str_term_trim (strip_home_and_password (tmp_path),
min (max (panel->widget.cols - 12, 0), panel->widget.cols))); min (max (panel->widget.cols - 12, 0), panel->widget.cols)));
g_free (tmp_path);
}
if (!panels_options.show_mini_info) if (!panels_options.show_mini_info)
{ {
@ -1222,12 +1229,16 @@ panel_load_history (const gchar * event_group_name, const gchar * event_name,
if (ev->receiver == NULL || ev->receiver == (Widget *) p) if (ev->receiver == NULL || ev->receiver == (Widget *) p)
{ {
char *tmp_path;
tmp_path = vfs_path_to_str (p->cwd_vpath);
if (ev->cfg != NULL) if (ev->cfg != NULL)
p->dir_history = history_load (ev->cfg, p->hist_name); p->dir_history = history_load (ev->cfg, p->hist_name);
else else
p->dir_history = history_get (p->hist_name); p->dir_history = history_get (p->hist_name);
directory_history_add (p, p->cwd); directory_history_add (p, tmp_path);
g_free (tmp_path);
} }
return TRUE; return TRUE;
@ -1289,8 +1300,12 @@ panel_destroy (WPanel * p)
g_free (p->user_format); g_free (p->user_format);
for (i = 0; i < LIST_TYPES; i++) for (i = 0; i < LIST_TYPES; i++)
g_free (p->user_status_format[i]); g_free (p->user_status_format[i]);
g_free (p->dir.list); g_free (p->dir.list);
g_free (p->panel_name); g_free (p->panel_name);
vfs_path_free (p->lwd_vpath);
vfs_path_free (p->cwd_vpath);
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
@ -2341,7 +2356,13 @@ do_enter_on_file_entry (file_entry * fe)
return 1; return 1;
/* Check if the file is executable */ /* Check if the file is executable */
full_name = concat_dir_and_file (current_panel->cwd, fe->fname); {
char *tmp_path;
tmp_path = vfs_path_to_str (current_panel->cwd_vpath);
full_name = concat_dir_and_file (tmp_path, fe->fname);
g_free (tmp_path);
}
if (!is_exe (fe->st.st_mode) || !if_link_is_exe (full_name, fe)) if (!is_exe (fe->st.st_mode) || !if_link_is_exe (full_name, fe))
{ {
g_free (full_name); g_free (full_name);
@ -2402,19 +2423,22 @@ chdir_other_panel (WPanel * panel)
char *new_dir; char *new_dir;
char *sel_entry = NULL; char *sel_entry = NULL;
char *tmp_path;
if (get_other_type () != view_listing) if (get_other_type () != view_listing)
{ {
set_display_type (get_other_index (), view_listing); set_display_type (get_other_index (), view_listing);
} }
tmp_path = vfs_path_to_str (panel->cwd_vpath);
if (S_ISDIR (entry->st.st_mode) || entry->f.link_to_dir) if (S_ISDIR (entry->st.st_mode) || entry->f.link_to_dir)
new_dir = mc_build_filename (panel->cwd, entry->fname, (char *) NULL); new_dir = mc_build_filename (tmp_path, entry->fname, (char *) NULL);
else else
{ {
new_dir = mc_build_filename (panel->cwd, "..", (char *) NULL); new_dir = mc_build_filename (tmp_path, "..", (char *) NULL);
sel_entry = strrchr (panel->cwd, PATH_SEP); sel_entry = strrchr (tmp_path, PATH_SEP);
} }
g_free (tmp_path);
change_panel (); change_panel ();
do_cd (new_dir, cd_exact); do_cd (new_dir, cd_exact);
@ -2443,7 +2467,13 @@ panel_sync_other (const WPanel * panel)
set_display_type (get_other_index (), view_listing); set_display_type (get_other_index (), view_listing);
} }
do_panel_cd (other_panel, current_panel->cwd, cd_exact); {
char *tmp_path;
tmp_path = vfs_path_to_str (current_panel->cwd_vpath);
do_panel_cd (other_panel, tmp_path, cd_exact);
g_free (tmp_path);
}
/* try to select current filename on the other panel */ /* try to select current filename on the other panel */
if (!panel->is_panelized) if (!panel->is_panelized)
@ -2497,7 +2527,13 @@ chdir_to_readlink (WPanel * panel)
if (*buffer == PATH_SEP) if (*buffer == PATH_SEP)
new_dir = g_strdup (buffer); new_dir = g_strdup (buffer);
else else
new_dir = concat_dir_and_file (panel->cwd, buffer); {
char *tmp_path;
tmp_path = vfs_path_to_str (panel->cwd_vpath);
new_dir = concat_dir_and_file (tmp_path, buffer);
g_free (tmp_path);
}
change_panel (); change_panel ();
do_cd (new_dir, cd_exact); do_cd (new_dir, cd_exact);
@ -2727,11 +2763,11 @@ get_parent_dir_name (const char *cwd, const char *lwd)
/** Wrapper for do_subshell_chdir, check for availability of subshell */ /** Wrapper for do_subshell_chdir, check for availability of subshell */
static void static void
subshell_chdir (const char *directory) subshell_chdir (const vfs_path_t * vpath)
{ {
#ifdef HAVE_SUBSHELL_SUPPORT #ifdef HAVE_SUBSHELL_SUPPORT
if (mc_global.tty.use_subshell && vfs_current_is_local ()) if (mc_global.tty.use_subshell && vfs_current_is_local ())
do_subshell_chdir (directory, FALSE, TRUE); do_subshell_chdir (vpath, FALSE, TRUE);
#endif /* HAVE_SUBSHELL_SUPPORT */ #endif /* HAVE_SUBSHELL_SUPPORT */
} }
@ -2754,23 +2790,27 @@ _do_panel_cd (WPanel * panel, const char *new_dir, enum cd_enum cd_type)
new_dir++; new_dir++;
} }
olddir = g_strdup (panel->cwd); olddir = vfs_path_to_str (panel->cwd_vpath);
/* Convert *new_path to a suitable pathname, handle ~user */ /* Convert *new_path to a suitable pathname, handle ~user */
if (cd_type == cd_parse_command) if (cd_type == cd_parse_command)
{ {
if (!strcmp (new_dir, "-")) if (strcmp (new_dir, "-") == 0)
{ {
strcpy (temp, panel->lwd); char *tmp_path;
tmp_path = vfs_path_to_str (panel->lwd_vpath);
strcpy (temp, tmp_path);
new_dir = temp; new_dir = temp;
g_free (tmp_path);
} }
} }
vpath = vfs_path_from_str (*new_dir ? new_dir : mc_config_get_home_dir ()); vpath = vfs_path_from_str (*new_dir ? new_dir : mc_config_get_home_dir ());
if (mc_chdir (vpath) == -1) if (mc_chdir (vpath) == -1)
{ {
strcpy (panel->cwd, olddir); panel_set_cwd (panel, olddir);
g_free (olddir); g_free (olddir);
vfs_path_free (vpath); vfs_path_free (vpath);
return FALSE; return FALSE;
@ -2778,22 +2818,30 @@ _do_panel_cd (WPanel * panel, const char *new_dir, enum cd_enum cd_type)
vfs_path_free (vpath); vfs_path_free (vpath);
/* Success: save previous directory, shutdown status of previous dir */ /* Success: save previous directory, shutdown status of previous dir */
strcpy (panel->lwd, olddir); panel_set_lwd (panel, olddir);
input_free_completions (cmdline); input_free_completions (cmdline);
mc_get_current_wd (panel->cwd, sizeof (panel->cwd) - 2); vfs_path_free (panel->cwd_vpath);
vfs_setup_cwd ();
panel->cwd_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
vfs_release_path (olddir); vfs_release_path (olddir);
subshell_chdir (panel->cwd); subshell_chdir (panel->cwd_vpath);
/* Reload current panel */ /* Reload current panel */
panel_clean_dir (panel); panel_clean_dir (panel);
panel->count = {
do_load_dir (panel->cwd, &panel->dir, panel->sort_info.sort_field->sort_routine, char *tmp_path;
panel->sort_info.reverse, panel->sort_info.case_sensitive,
panel->sort_info.exec_first, panel->filter); tmp_path = vfs_path_to_str (panel->cwd_vpath);
try_to_select (panel, get_parent_dir_name (panel->cwd, olddir)); panel->count =
do_load_dir (tmp_path, &panel->dir, panel->sort_info.sort_field->sort_routine,
panel->sort_info.reverse, panel->sort_info.case_sensitive,
panel->sort_info.exec_first, panel->filter);
try_to_select (panel, get_parent_dir_name (tmp_path, olddir));
g_free (tmp_path);
}
load_hint (0); load_hint (0);
panel->dirty = 1; panel->dirty = 1;
update_xterm_title_path (); update_xterm_title_path ();
@ -2841,7 +2889,13 @@ directory_history_list (WPanel * panel)
if (s != NULL) if (s != NULL)
{ {
if (_do_panel_cd (panel, s, cd_exact)) if (_do_panel_cd (panel, s, cd_exact))
directory_history_add (panel, panel->cwd); {
char *tmp_path;
tmp_path = vfs_path_to_str (panel->cwd_vpath);
directory_history_add (panel, tmp_path);
g_free (tmp_path);
}
else else
message (D_ERROR, MSG_ERROR, _("Cannot change directory")); message (D_ERROR, MSG_ERROR, _("Cannot change directory"));
g_free (s); g_free (s);
@ -3060,7 +3114,6 @@ panel_key (WPanel * panel, int key)
static cb_ret_t static cb_ret_t
panel_callback (Widget * w, widget_msg_t msg, int parm) panel_callback (Widget * w, widget_msg_t msg, int parm)
{ {
vfs_path_t *vpath;
WPanel *panel = (WPanel *) w; WPanel *panel = (WPanel *) w;
WButtonBar *bb; WButtonBar *bb;
@ -3086,18 +3139,18 @@ panel_callback (Widget * w, widget_msg_t msg, int parm)
state_mark = -1; state_mark = -1;
current_panel = panel; current_panel = panel;
panel->active = 1; panel->active = 1;
vpath = vfs_path_from_str (panel->cwd); if (mc_chdir (panel->cwd_vpath) != 0)
if (mc_chdir (vpath) != 0)
{ {
char *cwd = strip_password (g_strdup (panel->cwd), 1); char *cwd;
cwd = strip_password (vfs_path_to_str (panel->cwd_vpath), 1);
message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\"\n%s"), message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\"\n%s"),
cwd, unix_error_string (errno)); cwd, unix_error_string (errno));
g_free (cwd); g_free (cwd);
} }
else else
subshell_chdir (panel->cwd); subshell_chdir (panel->cwd_vpath);
vfs_path_free (vpath);
update_xterm_title_path (); update_xterm_title_path ();
select_item (panel); select_item (panel);
show_dir (panel); show_dir (panel);
@ -3392,19 +3445,14 @@ reload_panelized (WPanel * panel)
{ {
int i, j; int i, j;
dir_list *list = &panel->dir; dir_list *list = &panel->dir;
vfs_path_t *vpath;
if (panel != current_panel) if (panel != current_panel)
{ (void) mc_chdir (panel->cwd_vpath);
int ret;
vpath = vfs_path_from_str (panel->cwd);
ret = mc_chdir (vpath);
vfs_path_free (vpath);
}
for (i = 0, j = 0; i < panel->count; i++) for (i = 0, j = 0; i < panel->count; i++)
{ {
vfs_path_t *vpath;
if (list->list[i].f.marked) if (list->list[i].f.marked)
{ {
/* Unmark the file in advance. In case the following mc_lstat /* Unmark the file in advance. In case the following mc_lstat
@ -3417,16 +3465,15 @@ reload_panelized (WPanel * panel)
} }
vpath = vfs_path_from_str (list->list[i].fname); vpath = vfs_path_from_str (list->list[i].fname);
if (mc_lstat (vpath, &list->list[i].st)) if (mc_lstat (vpath, &list->list[i].st))
{
g_free (list->list[i].fname); g_free (list->list[i].fname);
vfs_path_free (vpath); else
continue; {
if (list->list[i].f.marked)
do_file_mark (panel, i, 1);
if (j != i)
list->list[j] = list->list[i];
j++;
} }
if (list->list[i].f.marked)
do_file_mark (panel, i, 1);
if (j != i)
list->list[j] = list->list[i];
j++;
vfs_path_free (vpath); vfs_path_free (vpath);
} }
if (j == 0) if (j == 0)
@ -3435,13 +3482,7 @@ reload_panelized (WPanel * panel)
panel->count = j; panel->count = j;
if (panel != current_panel) if (panel != current_panel)
{ (void) mc_chdir (current_panel->cwd_vpath);
int ret;
vpath = vfs_path_from_str (current_panel->cwd);
ret = mc_chdir (vpath);
vfs_path_free (vpath);
}
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
@ -3454,12 +3495,8 @@ update_one_panel_widget (WPanel * panel, panel_update_flags_t flags, const char
if ((flags & UP_RELOAD) != 0) if ((flags & UP_RELOAD) != 0)
{ {
vfs_path_t *tmp_vpath;
tmp_vpath = vfs_path_from_str (panel->cwd);
panel->is_panelized = FALSE; panel->is_panelized = FALSE;
mc_setctl (tmp_vpath, VFS_SETCTL_FLUSH, 0); mc_setctl (panel->cwd_vpath, VFS_SETCTL_FLUSH, 0);
vfs_path_free (tmp_vpath);
memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat)); memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat));
} }
@ -3505,51 +3542,33 @@ update_one_panel (int which, panel_update_flags_t flags, const char *current_fil
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
char * char *
remove_encoding_from_path (const char *path) remove_encoding_from_path (const vfs_path_t * vpath)
{ {
GString *ret; GString *ret;
GString *tmp_path, *tmp_conv; GString *tmp_conv;
char *tmp; int indx;
ret = g_string_new (""); ret = g_string_new ("");
tmp_conv = g_string_new (""); tmp_conv = g_string_new ("");
tmp_path = g_string_new (path);
while ((tmp = g_strrstr (tmp_path->str, PATH_SEP_STR VFS_ENCODING_PREFIX)) != NULL) for (indx = 0; indx < vfs_path_elements_count (vpath); indx++)
{ {
vfs_path_element_t *path_element;
GIConv converter; GIConv converter;
char *tmp2;
vfs_path_t *vpath = vfs_path_from_str (tmp);
vfs_path_element_t *path_element = vfs_path_get_by_index (vpath, -1);
path_element = vfs_path_get_by_index (vpath, indx);
converter = converter =
path_element->encoding != path_element->encoding != NULL ?
NULL ? str_crt_conv_to (path_element->encoding) : str_cnv_to_term; str_crt_conv_to (path_element->encoding) : str_cnv_to_term;
vfs_path_free (vpath);
if (converter == INVALID_CONV) if (converter == INVALID_CONV)
converter = str_cnv_to_term; converter = str_cnv_to_term;
tmp2 = tmp + 1; str_vfs_convert_from (converter, path_element->path, tmp_conv);
while (*tmp2 != '\0' && *tmp2 != PATH_SEP) g_string_append (ret, tmp_conv->str);
tmp2++; g_string_set_size (tmp_conv, 0);
if (*tmp2 != '\0')
{
str_vfs_convert_from (converter, tmp2, tmp_conv);
g_string_prepend (ret, tmp_conv->str);
g_string_set_size (tmp_conv, 0);
}
g_string_set_size (tmp_path, tmp - tmp_path->str);
str_close_conv (converter); str_close_conv (converter);
} }
g_string_prepend (ret, tmp_path->str);
g_string_free (tmp_path, TRUE);
g_string_free (tmp_conv, TRUE); g_string_free (tmp_conv, TRUE);
return g_string_free (ret, FALSE); return g_string_free (ret, FALSE);
} }
@ -3698,6 +3717,36 @@ panel_clean_dir (WPanel * panel)
clean_dir (&panel->dir, count); clean_dir (&panel->dir, count);
} }
/* --------------------------------------------------------------------------------------------- */
/**
* Set Up panel's current dir object
*
* @param panel panel object
* @param path_str string contain path
*/
void
panel_set_cwd (WPanel * panel, const char *path_str)
{
vfs_path_free (panel->cwd_vpath);
panel->cwd_vpath = vfs_path_from_str (path_str);
}
/* --------------------------------------------------------------------------------------------- */
/**
* Set Up panel's last working dir object
*
* @param panel panel object
* @param path_str string contain path
*/
void
panel_set_lwd (WPanel * panel, const char *path_str)
{
vfs_path_free (panel->lwd_vpath);
panel->lwd_vpath = vfs_path_from_str (path_str);
}
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
/** Panel creation. /** Panel creation.
* @param panel_name the name of the panel for setup retieving * @param panel_name the name of the panel for setup retieving
@ -3723,7 +3772,7 @@ panel_new_with_dir (const char *panel_name, const char *wpath)
WPanel *panel; WPanel *panel;
char *section; char *section;
int i, err; int i, err;
char curdir[MC_MAXPATHLEN] = "\0"; char *curdir = NULL;
panel = g_new0 (WPanel, 1); panel = g_new0 (WPanel, 1);
@ -3735,13 +3784,16 @@ panel_new_with_dir (const char *panel_name, const char *wpath)
if (wpath != NULL) if (wpath != NULL)
{ {
g_strlcpy (panel->cwd, wpath, sizeof (panel->cwd)); curdir = _vfs_get_cwd ();
mc_get_current_wd (curdir, sizeof (curdir) - 2); panel_set_cwd (panel, wpath);
} }
else else
mc_get_current_wd (panel->cwd, sizeof (panel->cwd) - 2); {
vfs_setup_cwd ();
panel->cwd_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
}
strcpy (panel->lwd, "."); panel_set_lwd (panel, ".");
panel->hist_name = g_strconcat ("Dir Hist ", panel_name, (char *) NULL); panel->hist_name = g_strconcat ("Dir Hist ", panel_name, (char *) NULL);
/* directories history will be get later */ /* directories history will be get later */
@ -3791,36 +3843,36 @@ panel_new_with_dir (const char *panel_name, const char *wpath)
#ifdef HAVE_CHARSET #ifdef HAVE_CHARSET
{ {
vfs_path_t *vpath = vfs_path_from_str (panel->cwd); vfs_path_element_t *path_element;
vfs_path_element_t *path_element = vfs_path_get_by_index (vpath, -1);
path_element = vfs_path_get_by_index (panel->cwd_vpath, -1);
if (path_element->encoding != NULL) if (path_element->encoding != NULL)
panel->codepage = get_codepage_index (path_element->encoding); panel->codepage = get_codepage_index (path_element->encoding);
vfs_path_free (vpath);
} }
#endif #endif
if (mc_chdir (panel->cwd_vpath) != 0)
{ {
vfs_path_t *vpath; panel->codepage = SELECT_CHARSET_NO_TRANSLATE;
vfs_setup_cwd ();
vpath = vfs_path_from_str (panel->cwd); vfs_path_free (panel->cwd_vpath);
if (mc_chdir (vpath) != 0) panel->cwd_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
{
panel->codepage = SELECT_CHARSET_NO_TRANSLATE;
mc_get_current_wd (panel->cwd, sizeof (panel->cwd) - 2);
}
vfs_path_free (vpath);
} }
/* Load the default format */ /* Load the default format */
panel->count = {
do_load_dir (panel->cwd, &panel->dir, panel->sort_info.sort_field->sort_routine, char *tmp_path;
panel->sort_info.reverse, panel->sort_info.case_sensitive,
panel->sort_info.exec_first, panel->filter); tmp_path = vfs_path_to_str (panel->cwd_vpath);
panel->count =
do_load_dir (tmp_path, &panel->dir, panel->sort_info.sort_field->sort_routine,
panel->sort_info.reverse, panel->sort_info.case_sensitive,
panel->sort_info.exec_first, panel->filter);
g_free (tmp_path);
}
/* Restore old right path */ /* Restore old right path */
if (curdir[0] != '\0') if (curdir != NULL)
{ {
vfs_path_t *vpath; vfs_path_t *vpath;
@ -3828,6 +3880,7 @@ panel_new_with_dir (const char *panel_name, const char *wpath)
err = mc_chdir (vpath); err = mc_chdir (vpath);
vfs_path_free (vpath); vfs_path_free (vpath);
} }
g_free (curdir);
return panel; return panel;
} }
@ -3838,44 +3891,53 @@ void
panel_reload (WPanel * panel) panel_reload (WPanel * panel)
{ {
struct stat current_stat; struct stat current_stat;
char *tmp_path;
gboolean ok;
if (panels_options.fast_reload && !stat (panel->cwd, &current_stat) tmp_path = vfs_path_to_str (panel->cwd_vpath);
&& current_stat.st_ctime == panel->dir_stat.st_ctime ok = (panels_options.fast_reload && stat (tmp_path, &current_stat) == 0
&& current_stat.st_mtime == panel->dir_stat.st_mtime) && current_stat.st_ctime == panel->dir_stat.st_ctime
&& current_stat.st_mtime == panel->dir_stat.st_mtime);
g_free (tmp_path);
if (ok)
return; return;
do do
{ {
vfs_path_t *vpath;
gboolean ok;
char *last_slash; char *last_slash;
vpath = vfs_path_from_str (panel->cwd); if (mc_chdir (panel->cwd_vpath) != -1)
ok = (mc_chdir (vpath) != -1);
vfs_path_free (vpath);
if (ok)
break; break;
if (panel->cwd[0] == PATH_SEP && panel->cwd[1] == 0) tmp_path = vfs_path_to_str (panel->cwd_vpath);
if (tmp_path[0] == PATH_SEP && tmp_path[1] == 0)
{ {
panel_clean_dir (panel); panel_clean_dir (panel);
panel->count = set_zero_dir (&panel->dir) ? 1 : 0; panel->count = set_zero_dir (&panel->dir) ? 1 : 0;
g_free (tmp_path);
return; return;
} }
last_slash = strrchr (panel->cwd, PATH_SEP); last_slash = strrchr (tmp_path, PATH_SEP);
if (!last_slash || last_slash == panel->cwd) if (!last_slash || last_slash == tmp_path)
strcpy (panel->cwd, PATH_SEP_STR); {
vfs_path_free (panel->cwd_vpath);
panel->cwd_vpath = vfs_path_from_str (PATH_SEP_STR);
}
else else
*last_slash = 0; *last_slash = 0;
memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat)); memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat));
g_free (tmp_path);
show_dir (panel); show_dir (panel);
} }
while (TRUE); while (TRUE);
tmp_path = vfs_path_to_str (panel->cwd_vpath);
panel->count = panel->count =
do_reload_dir (panel->cwd, &panel->dir, panel->sort_info.sort_field->sort_routine, do_reload_dir (tmp_path, &panel->dir, panel->sort_info.sort_field->sort_routine,
panel->count, panel->sort_info.reverse, panel->sort_info.case_sensitive, panel->count, panel->sort_info.reverse, panel->sort_info.case_sensitive,
panel->sort_info.exec_first, panel->filter); panel->sort_info.exec_first, panel->filter);
g_free (tmp_path);
panel->dirty = 1; panel->dirty = 1;
if (panel->selected >= panel->count) if (panel->selected >= panel->count)
@ -4101,7 +4163,13 @@ do_panel_cd (struct WPanel *panel, const char *new_dir, enum cd_enum cd_type)
r = _do_panel_cd (panel, new_dir, cd_type); r = _do_panel_cd (panel, new_dir, cd_type);
if (r) if (r)
directory_history_add (panel, panel->cwd); {
char *tmp_path;
tmp_path = vfs_path_to_str (panel->cwd_vpath);
directory_history_add (panel, tmp_path);
g_free (tmp_path);
}
return r; return r;
} }
@ -4197,7 +4265,7 @@ panel_change_encoding (WPanel * panel)
{ {
/* No translation */ /* No translation */
g_free (init_translation_table (mc_global.display_codepage, mc_global.display_codepage)); g_free (init_translation_table (mc_global.display_codepage, mc_global.display_codepage));
cd_path = remove_encoding_from_path (panel->cwd); cd_path = remove_encoding_from_path (panel->cwd_vpath);
do_panel_cd (panel, cd_path, cd_parse_command); do_panel_cd (panel, cd_path, cd_parse_command);
g_free (cd_path); g_free (cd_path);
return; return;
@ -4215,16 +4283,12 @@ panel_change_encoding (WPanel * panel)
#endif #endif
if (encoding != NULL) if (encoding != NULL)
{ {
vfs_path_t *vpath = vfs_path_from_str (panel->cwd); vfs_change_encoding (panel->cwd_vpath, encoding);
vfs_change_encoding (vpath, encoding); cd_path = vfs_path_to_str (panel->cwd_vpath);
cd_path = vfs_path_to_str (vpath);
if (!do_panel_cd (panel, cd_path, cd_parse_command)) if (!do_panel_cd (panel, cd_path, cd_parse_command))
message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\""), cd_path); message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\""), cd_path);
g_free (cd_path); g_free (cd_path);
vfs_path_free (vpath);
} }
} }
@ -4244,8 +4308,6 @@ update_panels (panel_update_flags_t flags, const char *current_file)
{ {
gboolean reload_other = (flags & UP_ONLY_CURRENT) == 0; gboolean reload_other = (flags & UP_ONLY_CURRENT) == 0;
WPanel *panel; WPanel *panel;
vfs_path_t *vpath;
int ret;
update_one_panel (get_current_index (), flags, current_file); update_one_panel (get_current_index (), flags, current_file);
if (reload_other) if (reload_other)
@ -4257,11 +4319,7 @@ update_panels (panel_update_flags_t flags, const char *current_file)
panel = (WPanel *) get_panel_widget (get_other_index ()); panel = (WPanel *) get_panel_widget (get_other_index ());
if (!panel->is_panelized) if (!panel->is_panelized)
{ (void) mc_chdir (panel->cwd_vpath);
vpath = vfs_path_from_str (panel->cwd);
ret = mc_chdir (vpath);
vfs_path_free (vpath);
}
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */

20
src/filemanager/panel.h
View File

@ -43,8 +43,8 @@ typedef enum
typedef enum typedef enum
{ {
UP_OPTIMIZE = 0, UP_OPTIMIZE = 0,
UP_RELOAD = 1, UP_RELOAD = 1,
UP_ONLY_CURRENT = 2 UP_ONLY_CURRENT = 2
} panel_update_flags_t; } panel_update_flags_t;
@ -75,9 +75,9 @@ typedef struct
typedef struct panel_sort_info_struct typedef struct panel_sort_info_struct
{ {
gboolean reverse; /* Show listing in reverse? */ gboolean reverse; /* Show listing in reverse? */
gboolean case_sensitive; /* Listing is case sensitive? */ gboolean case_sensitive; /* Listing is case sensitive? */
gboolean exec_first; /* Show executable top in list? */ gboolean exec_first; /* Show executable top in list? */
const panel_field_t *sort_field; const panel_field_t *sort_field;
} panel_sort_info_t; } panel_sort_info_t;
@ -88,8 +88,10 @@ typedef struct WPanel
int list_type; /* listing type (was view_type) */ int list_type; /* listing type (was view_type) */
int active; /* If panel is currently selected */ int active; /* If panel is currently selected */
char cwd[MC_MAXPATHLEN]; /* Current Working Directory */ vfs_path_t *cwd_vpath;
char lwd[MC_MAXPATHLEN]; /* Last Working Directory */ vfs_path_t *lwd_vpath;
// char cwd[MC_MAXPATHLEN]; /* Current Working Directory */
// char lwd[MC_MAXPATHLEN]; /* Last Working Directory */
GList *dir_history; /* directory history */ GList *dir_history; /* directory history */
char *hist_name; /* directory history name for history file */ char *hist_name; /* directory history name for history file */
int count; /* Number of files in dir structure */ int count; /* Number of files in dir structure */
@ -163,7 +165,7 @@ gboolean do_panel_cd (struct WPanel *panel, const char *new_dir, enum cd_enum cd
void directory_history_add (struct WPanel *panel, const char *dir); void directory_history_add (struct WPanel *panel, const char *dir);
char *remove_encoding_from_path (const char *path); char *remove_encoding_from_path (const vfs_path_t * vpath);
gsize panel_get_num_of_sortable_fields (void); gsize panel_get_num_of_sortable_fields (void);
const char **panel_get_sortable_fields (gsize *); const char **panel_get_sortable_fields (gsize *);
@ -172,6 +174,8 @@ const panel_field_t *panel_get_field_by_title (const char *);
const panel_field_t *panel_get_field_by_title_hotkey (const char *); const panel_field_t *panel_get_field_by_title_hotkey (const char *);
gsize panel_get_num_of_user_possible_fields (void); gsize panel_get_num_of_user_possible_fields (void);
const char **panel_get_user_possible_fields (gsize *); const char **panel_get_user_possible_fields (gsize *);
void panel_set_cwd (WPanel * panel, const char *path_str);
void panel_set_lwd (WPanel * panel, const char *path_str);
void panel_init (void); void panel_init (void);
void panel_deinit (void); void panel_deinit (void);

32
src/filemanager/panelize.c
View File

@ -55,6 +55,7 @@
#include "panel.h" /* WPanel */ #include "panel.h" /* WPanel */
#include "panelize.h" #include "panelize.h"
#include "panel.h"
/*** global variables ****************************************************************************/ /*** global variables ****************************************************************************/
@ -317,6 +318,18 @@ remove_from_panelize (struct panelize *entry)
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
static void
panelize_strlcpy (char *buffer, const vfs_path_t * vpath, size_t max_len)
{
char *str_path;
str_path = vfs_path_to_str (vpath);
g_strlcpy (buffer, str_path, max_len);
g_free (str_path);
}
/* --------------------------------------------------------------------------------------------- */
static void static void
do_external_panelize (char *command) do_external_panelize (char *command)
{ {
@ -338,7 +351,7 @@ do_external_panelize (char *command)
/* Clear the counters and the directory list */ /* Clear the counters and the directory list */
panel_clean_dir (current_panel); panel_clean_dir (current_panel);
g_strlcpy (panelized_panel.root, current_panel->cwd, MC_MAXPATHLEN); panelize_strlcpy (panelized_panel.root, current_panel->cwd_vpath, MC_MAXPATHLEN);
if (set_zero_dir (list)) if (set_zero_dir (list))
next_free++; next_free++;
@ -387,7 +400,7 @@ do_external_panelize (char *command)
if (list->list[0].fname[0] == PATH_SEP) if (list->list[0].fname[0] == PATH_SEP)
{ {
int ret; int ret;
strcpy (current_panel->cwd, PATH_SEP_STR); panel_set_cwd (current_panel, PATH_SEP_STR);
ret = chdir (PATH_SEP_STR); ret = chdir (PATH_SEP_STR);
} }
} }
@ -413,7 +426,7 @@ do_panelize_cd (struct WPanel *panel)
clean_dir (list, panel->count); clean_dir (list, panel->count);
if (panelized_panel.root[0] == '\0') if (panelized_panel.root[0] == '\0')
g_strlcpy (panelized_panel.root, panel->cwd, MC_MAXPATHLEN); panelize_strlcpy (panelized_panel.root, panel->cwd_vpath, MC_MAXPATHLEN);
if (panelized_panel.count < 1) if (panelized_panel.count < 1)
{ {
@ -428,7 +441,13 @@ do_panelize_cd (struct WPanel *panel)
panel->count = panelized_panel.count; panel->count = panelized_panel.count;
panel->is_panelized = TRUE; panel->is_panelized = TRUE;
panelized_same = (strcmp (panelized_panel.root, panel->cwd) == 0); {
char *cwd_str;
cwd_str = vfs_path_to_str (panel->cwd_vpath);
panelized_same = (strcmp (panelized_panel.root, cwd_str) == 0);
g_free (cwd_str);
}
for (i = 0; i < panelized_panel.count; i++) for (i = 0; i < panelized_panel.count; i++)
{ {
@ -469,7 +488,7 @@ panelize_save_panel (struct WPanel *panel)
int i; int i;
dir_list *list = &panel->dir; dir_list *list = &panel->dir;
g_strlcpy (panelized_panel.root, panel->cwd, MC_MAXPATHLEN); panelize_strlcpy (panelized_panel.root, panel->cwd_vpath, MC_MAXPATHLEN);
if (panelized_panel.count > 0) if (panelized_panel.count > 0)
clean_dir (&panelized_panel.list, panelized_panel.count); clean_dir (&panelized_panel.list, panelized_panel.count);
@ -486,7 +505,8 @@ panelize_save_panel (struct WPanel *panel)
for (i = 0; i < panel->count; i++) for (i = 0; i < panel->count; i++)
{ {
panelized_panel.list.list[i].fnamelen = list->list[i].fnamelen; panelized_panel.list.list[i].fnamelen = list->list[i].fnamelen;
panelized_panel.list.list[i].fname = g_strndup (list->list[i].fname, list->list[i].fnamelen); panelized_panel.list.list[i].fname =
g_strndup (list->list[i].fname, list->list[i].fnamelen);
panelized_panel.list.list[i].f.link_to_dir = list->list[i].f.link_to_dir; panelized_panel.list.list[i].f.link_to_dir = list->list[i].f.link_to_dir;
panelized_panel.list.list[i].f.stale_link = list->list[i].f.stale_link; panelized_panel.list.list[i].f.stale_link = list->list[i].f.stale_link;
panelized_panel.list.list[i].f.dir_size_computed = list->list[i].f.dir_size_computed; panelized_panel.list.list[i].f.dir_size_computed = list->list[i].f.dir_size_computed;

23
src/filemanager/tree.c
View File

@ -713,24 +713,27 @@ static void
tree_rescan (void *data) tree_rescan (void *data)
{ {
WTree *tree = data; WTree *tree = data;
char old_dir[MC_MAXPATHLEN]; char *old_dir;
vfs_path_t *vpath; vfs_path_t *vpath = NULL;
int ret; int r;
if (tree->selected_ptr == NULL || mc_get_current_wd (old_dir, MC_MAXPATHLEN) == NULL) old_dir = vfs_get_current_dir ();
if (old_dir == NULL)
return; return;
if (tree->selected_ptr == NULL)
goto ret;
vpath = vfs_path_from_str (tree->selected_ptr->name); vpath = vfs_path_from_str (tree->selected_ptr->name);
if (mc_chdir (vpath) != 0) if (mc_chdir (vpath) != 0)
{ goto ret;
vfs_path_free (vpath);
return;
}
tree_store_rescan (vpath); tree_store_rescan (vpath);
vpath = vfs_path_from_str (old_dir); vpath = vfs_path_from_str (old_dir);
ret = mc_chdir (vpath); r = mc_chdir (vpath);
ret:
vfs_path_free (vpath); vfs_path_free (vpath);
g_free (old_dir);
} }
/* --------------------------------------------------------------------------------------------- */ /* --------------------------------------------------------------------------------------------- */
@ -836,8 +839,6 @@ tree_mkdir (WTree * tree)
if (!tree->selected_ptr) if (!tree->selected_ptr)
return; return;
if (mc_get_current_wd (old_dir, MC_MAXPATHLEN) == NULL)
return;
if (chdir (tree->selected_ptr->name)) if (chdir (tree->selected_ptr->name))
return; return;
/* FIXME /* FIXME

14
src/filemanager/usermenu.c
View File

@ -260,7 +260,13 @@ test_condition (WEdit * edit_widget, char *p, int *condition)
break; break;
case 'd': case 'd':
p = extract_arg (p, arg, sizeof (arg)); p = extract_arg (p, arg, sizeof (arg));
*condition = panel != NULL && mc_search (arg, panel->cwd, search_type) ? 1 : 0; {
char *cwd_str;
cwd_str = vfs_path_to_str (panel->cwd_vpath);
*condition = panel != NULL && mc_search (arg, cwd_str, search_type) ? 1 : 0;
g_free (cwd_str);
}
break; break;
case 't': case 't':
p = extract_arg (p, arg, sizeof (arg)); p = extract_arg (p, arg, sizeof (arg));
@ -772,12 +778,10 @@ expand_format (struct WEdit *edit_widget, char c, gboolean do_quote)
char *cwd; char *cwd;
char *qstr; char *qstr;
cwd = g_malloc (MC_MAXPATHLEN + 1);
if (panel) if (panel)
g_strlcpy (cwd, panel->cwd, MC_MAXPATHLEN + 1); cwd = vfs_path_to_str (panel->cwd_vpath);
else else
mc_get_current_wd (cwd, MC_MAXPATHLEN + 1); cwd = vfs_get_current_dir ();
qstr = (*quote_func) (cwd, 0); qstr = (*quote_func) (cwd, 0);

12
src/main.c
View File

@ -288,15 +288,13 @@ do_cd (const char *new_dir, enum cd_enum exact)
#ifdef HAVE_CHARSET #ifdef HAVE_CHARSET
if (res) if (res)
{ {
vfs_path_t *vpath = vfs_path_from_str (current_panel->cwd); vfs_path_element_t *path_element;
vfs_path_element_t *path_element = vfs_path_get_by_index (vpath, -1);
path_element = vfs_path_get_by_index (current_panel->cwd_vpath, -1);
if (path_element->encoding != NULL) if (path_element->encoding != NULL)
current_panel->codepage = get_codepage_index (path_element->encoding); current_panel->codepage = get_codepage_index (path_element->encoding);
else else
current_panel->codepage = SELECT_CHARSET_NO_TRANSLATE; current_panel->codepage = SELECT_CHARSET_NO_TRANSLATE;
vfs_path_free (vpath);
} }
#endif /* HAVE_CHARSET */ #endif /* HAVE_CHARSET */
@ -361,7 +359,11 @@ update_xterm_title_path (void)
if (mc_global.tty.xterm_flag && xterm_title) if (mc_global.tty.xterm_flag && xterm_title)
{ {
path = strip_home_and_password (current_panel->cwd); char *path_str;
path_str = vfs_path_to_str (current_panel->cwd_vpath);
path = strip_home_and_password (path_str);
g_free (path_str);
res = gethostname (host, sizeof (host)); res = gethostname (host, sizeof (host));
if (res) if (res)
{ /* On success, res = 0 */ { /* On success, res = 0 */

8
src/setup.c
View File

@ -790,7 +790,13 @@ save_panel_types (void)
if (type == view_listing) if (type == view_listing)
panel_save_setup (right_panel, right_panel->panel_name); panel_save_setup (right_panel, right_panel->panel_name);
mc_config_set_string (mc_panels_config, "Dirs", "other_dir", get_panel_dir_for (other_panel)); {
char *dirs;
dirs = get_panel_dir_for (other_panel);
mc_config_set_string (mc_panels_config, "Dirs", "other_dir", dirs);
g_free (dirs);
}
if (current_panel != NULL) if (current_panel != NULL)
mc_config_set_string (mc_panels_config, "Dirs", "current_is_left", mc_config_set_string (mc_panels_config, "Dirs", "current_is_left",

30
src/subshell.c
View File

@ -927,7 +927,7 @@ invoke_subshell (const char *command, int how, char **new_dir)
/* Make the subshell change to MC's working directory */ /* Make the subshell change to MC's working directory */
if (new_dir != NULL) if (new_dir != NULL)
do_subshell_chdir (current_panel->cwd, TRUE, TRUE); do_subshell_chdir (current_panel->cwd_vpath, TRUE, TRUE);
if (command == NULL) /* The user has done "C-o" from MC */ if (command == NULL) /* The user has done "C-o" from MC */
{ {
@ -953,7 +953,14 @@ invoke_subshell (const char *command, int how, char **new_dir)
feed_subshell (how, FALSE); feed_subshell (how, FALSE);
pcwd = vfs_translate_path_n (current_panel->cwd); {
char *cwd_str;
cwd_str = vfs_path_to_str (current_panel->cwd_vpath);
pcwd = vfs_translate_path_n (cwd_str);
g_free (cwd_str);
}
if (new_dir && subshell_alive && strcmp (subshell_cwd, pcwd)) if (new_dir && subshell_alive && strcmp (subshell_cwd, pcwd))
*new_dir = subshell_cwd; /* Make MC change to the subshell's CWD */ *new_dir = subshell_cwd; /* Make MC change to the subshell's CWD */
g_free (pcwd); g_free (pcwd);
@ -1161,13 +1168,15 @@ subshell_name_quote (const char *s)
/** If it actually changed the directory it returns true */ /** If it actually changed the directory it returns true */
void void
do_subshell_chdir (const char *directory, gboolean update_prompt, gboolean reset_prompt) do_subshell_chdir (const vfs_path_t * vpath, gboolean update_prompt, gboolean reset_prompt)
{ {
char *pcwd; char *pcwd, *cwd_str;
char *temp; char *temp;
char *translate; char *directory;
pcwd = vfs_translate_path_n (current_panel->cwd); cwd_str = vfs_path_to_str (current_panel->cwd_vpath);
pcwd = vfs_translate_path_n (cwd_str);
g_free (cwd_str);
if (!(subshell_state == INACTIVE && strcmp (subshell_cwd, pcwd) != 0)) if (!(subshell_state == INACTIVE && strcmp (subshell_cwd, pcwd) != 0))
{ {
@ -1184,10 +1193,14 @@ do_subshell_chdir (const char *directory, gboolean update_prompt, gboolean reset
/* The initial space keeps this out of the command history (in bash /* The initial space keeps this out of the command history (in bash
because we set "HISTCONTROL=ignorespace") */ because we set "HISTCONTROL=ignorespace") */
write_all (mc_global.tty.subshell_pty, " cd ", 4); write_all (mc_global.tty.subshell_pty, " cd ", 4);
if (*directory)
directory = vfs_path_to_str (vpath);
if (directory != '\0')
{ {
char *translate;
translate = vfs_translate_path_n (directory); translate = vfs_translate_path_n (directory);
if (translate) if (translate != NULL)
{ {
temp = subshell_name_quote (translate); temp = subshell_name_quote (translate);
if (temp) if (temp)
@ -1212,6 +1225,7 @@ do_subshell_chdir (const char *directory, gboolean update_prompt, gboolean reset
{ {
write_all (mc_global.tty.subshell_pty, "/", 1); write_all (mc_global.tty.subshell_pty, "/", 1);
} }
g_free (directory);
write_all (mc_global.tty.subshell_pty, "\n", 1); write_all (mc_global.tty.subshell_pty, "\n", 1);
subshell_state = RUNNING_COMMAND; subshell_state = RUNNING_COMMAND;

2
src/subshell.h
View File

@ -49,7 +49,7 @@ int invoke_subshell (const char *command, int how, char **new_dir);
int read_subshell_prompt (void); int read_subshell_prompt (void);
void do_update_prompt (void); void do_update_prompt (void);
int exit_subshell (void); int exit_subshell (void);
void do_subshell_chdir (const char *directory, gboolean update_prompt, gboolean reset_prompt); void do_subshell_chdir (const vfs_path_t * vpath, gboolean update_prompt, gboolean reset_prompt);
void subshell_get_console_attributes (void); void subshell_get_console_attributes (void);
void sigchld_handler (int sig); void sigchld_handler (int sig);

8
tests/lib/vfs/current_dir.c
View File

@ -71,16 +71,18 @@ test_chdir (const vfs_path_t * vpath)
vpath = vfs_path_from_str (cd_dir); \ vpath = vfs_path_from_str (cd_dir); \
mc_chdir(vpath); \ mc_chdir(vpath); \
vfs_path_free (vpath); \ vfs_path_free (vpath); \
buffer = _vfs_get_cwd (); \
fail_unless( \ fail_unless( \
strcmp(etalon, mc_get_current_wd(buffer,MC_MAXPATHLEN)) == 0, \ strcmp(etalon, buffer) == 0, \
"\n expected(%s) doesn't equal \nto actual(%s)", etalon, buffer); "\n expected(%s) doesn't equal \nto actual(%s)", etalon, buffer); \
g_free (buffer);
START_TEST (set_up_current_dir_url) START_TEST (set_up_current_dir_url)
{ {
vfs_path_t *vpath; vfs_path_t *vpath;
static struct vfs_s_subclass test_subclass; static struct vfs_s_subclass test_subclass;
static struct vfs_class vfs_test_ops; static struct vfs_class vfs_test_ops;
char buffer[MC_MAXPATHLEN]; char *buffer;
vfs_s_init_class (&vfs_test_ops, &test_subclass); vfs_s_init_class (&vfs_test_ops, &test_subclass);