1998-02-27 07:54:42 +03:00
|
|
|
/* Directory tree browser for the Midnight Commander
|
|
|
|
Copyright (C) 1994, 1995, 1996, 1997 The Free Software Foundation
|
|
|
|
|
|
|
|
Written: 1994, 1996 Janne Kukonlehto
|
|
|
|
1997 Norbert Warmuth
|
|
|
|
1996 Miguel de Icaza
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
|
|
|
|
This module has been converted to be a widget.
|
|
|
|
|
|
|
|
The program load and saves the tree each time the tree widget is
|
|
|
|
created and destroyed. This is required for the future vfs layer,
|
|
|
|
it will be possible to have tree views over virtual file systems.
|
|
|
|
|
|
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h> /* For free() and atoi() */
|
|
|
|
#include <string.h>
|
|
|
|
#include "tty.h"
|
|
|
|
#include "mad.h"
|
|
|
|
#include "global.h"
|
|
|
|
#include "util.h"
|
|
|
|
#include "color.h"
|
|
|
|
#include "dialog.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "dlg.h"
|
|
|
|
#include "widget.h"
|
|
|
|
#include "panel.h"
|
|
|
|
#include "mouse.h"
|
|
|
|
#include "main.h"
|
|
|
|
#include "file.h" /* For copy_dir_dir(), move_dir_dir(), erase_dir() */
|
|
|
|
#include "help.h"
|
|
|
|
#include "key.h" /* For mi_getch() */
|
|
|
|
#include "tree.h"
|
|
|
|
#include "cmd.h"
|
|
|
|
#include "../vfs/vfs.h"
|
1998-03-30 02:23:24 +04:00
|
|
|
#ifdef OS2_NT
|
|
|
|
# include <io.h>
|
|
|
|
#endif
|
1998-02-27 07:54:42 +03:00
|
|
|
|
|
|
|
extern int command_prompt;
|
|
|
|
|
|
|
|
#define TREE_NORMALC HOT_FOCUSC
|
|
|
|
|
|
|
|
/* Specifies the display mode: 1d or 2d */
|
|
|
|
int tree_navigation_flag;
|
|
|
|
|
|
|
|
/* If this is true, then when browsing the tree the other window will
|
|
|
|
* automatically reload it's directory with the contents of the currently
|
|
|
|
* selected directory.
|
|
|
|
*/
|
|
|
|
int xtree_mode = 0;
|
|
|
|
|
|
|
|
/* Forwards */
|
|
|
|
static int tree_callback (Dlg_head *h, WTree *tree, int msg, int par);
|
|
|
|
#define tcallback (callback_fn) tree_callback
|
|
|
|
|
|
|
|
/* "$Id$" */
|
|
|
|
|
|
|
|
/* Returns number of common characters */
|
|
|
|
static inline int str_common (char *s1, char *s2)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
while (*s1++ == *s2++)
|
|
|
|
result++;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static tree_entry *back_ptr (tree_entry *ptr, int *count)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while (ptr && ptr->prev && i < *count){
|
|
|
|
ptr = ptr->prev;
|
|
|
|
i ++;
|
|
|
|
}
|
|
|
|
*count = i;
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static tree_entry *forw_ptr (tree_entry *ptr, int *count)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
while (ptr && ptr->next && i < *count){
|
|
|
|
ptr = ptr->next;
|
|
|
|
i ++;
|
|
|
|
}
|
|
|
|
*count = i;
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The directory names are arranged in a single linked list in the same
|
|
|
|
order as they are displayed. When the tree is displayed the expected
|
|
|
|
order is like this:
|
|
|
|
/
|
|
|
|
/bin
|
|
|
|
/etc
|
|
|
|
/etc/X11
|
|
|
|
/etc/rc.d
|
|
|
|
/etc.old/X11
|
|
|
|
/etc.old/rc.d
|
|
|
|
/usr
|
|
|
|
|
|
|
|
i.e. the required collating sequence when comparing two directory names is
|
|
|
|
'\0' < PATH_SEP < all-other-characters-in-encoding-order
|
|
|
|
|
|
|
|
Since strcmp doesn't fulfil this requirement we use pathcmp when
|
|
|
|
inserting directory names into the list. The meaning of the return value
|
|
|
|
of pathcmp and strcmp are the same (an integer less than, equal to, or
|
|
|
|
greater than zero if p1 is found to be less than, to match, or be greater
|
|
|
|
than p2.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
pathcmp (const char *p1, const char *p2)
|
|
|
|
{
|
|
|
|
for ( ;*p1 == *p2; p1++, p2++)
|
|
|
|
if (*p1 == '\0' )
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (*p1 == '\0')
|
|
|
|
return -1;
|
|
|
|
if (*p2 == '\0')
|
|
|
|
return 1;
|
|
|
|
if (*p1 == PATH_SEP)
|
|
|
|
return -1;
|
|
|
|
if (*p2 == PATH_SEP)
|
|
|
|
return 1;
|
|
|
|
return (*p1 - *p2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Searches for specified directory */
|
|
|
|
static tree_entry *whereis (WTree *tree, char *name)
|
|
|
|
{
|
|
|
|
tree_entry *current = tree->tree_first;
|
|
|
|
int flag = -1;
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
if (tree->tree_last){
|
|
|
|
flag = strcmp (tree->tree_last->name, name);
|
|
|
|
if (flag <= 0){
|
|
|
|
current = tree->tree_last;
|
|
|
|
} else if (tree->selected_ptr){
|
|
|
|
flag = strcmp (tree->selected_ptr->name, name);
|
|
|
|
if (flag <= 0){
|
|
|
|
current = tree->selected_ptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
while (current && (flag = pathcmp (current->name, name)) < 0)
|
|
|
|
current = current->next;
|
|
|
|
|
|
|
|
if (flag == 0)
|
|
|
|
return current;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add a directory to the list of directories */
|
|
|
|
tree_entry *tree_add_entry (WTree *tree, char *name)
|
|
|
|
{
|
|
|
|
int flag = -1;
|
|
|
|
tree_entry *current = tree->tree_first;
|
|
|
|
tree_entry *old = NULL;
|
|
|
|
tree_entry *new;
|
|
|
|
int i, len;
|
|
|
|
int submask = 0;
|
|
|
|
|
|
|
|
if (!tree)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (tree->tree_last && tree->tree_last->next)
|
|
|
|
abort ();
|
|
|
|
#if 0
|
|
|
|
if (tree->tree_last){
|
|
|
|
flag = strcmp (tree->tree_last->name, name);
|
|
|
|
if (flag <= 0){
|
|
|
|
current = tree->tree_last;
|
|
|
|
old = current->prev;
|
|
|
|
} else if (tree->selected_ptr){
|
|
|
|
flag = strcmp (tree->selected_ptr->name, name);
|
|
|
|
if (flag <= 0){
|
|
|
|
current = tree->selected_ptr;
|
|
|
|
old = current->prev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Search for the correct place */
|
|
|
|
while (current && (flag = pathcmp (current->name, name)) < 0){
|
|
|
|
old = current;
|
|
|
|
current = current->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flag == 0)
|
|
|
|
return current; /* Already in the list */
|
|
|
|
|
|
|
|
/* Not in the list -> add it */
|
|
|
|
new = xmalloc (sizeof (tree_entry), "tree, tree_entry");
|
|
|
|
if (!current){
|
|
|
|
/* Append to the end of the list */
|
|
|
|
if (!tree->tree_first){
|
|
|
|
/* Empty list */
|
|
|
|
tree->tree_first = new;
|
|
|
|
new->prev = NULL;
|
|
|
|
} else {
|
|
|
|
old->next = new;
|
|
|
|
new->prev = old;
|
|
|
|
}
|
|
|
|
new->next = NULL;
|
|
|
|
tree->tree_last = new;
|
|
|
|
} else {
|
|
|
|
/* Insert in to the middle of the list */
|
|
|
|
new->prev = old;
|
|
|
|
if (old){
|
|
|
|
/* Yes, in the middle */
|
|
|
|
new->next = old->next;
|
|
|
|
old->next = new;
|
|
|
|
} else {
|
|
|
|
/* Nope, in the beginning of the list */
|
|
|
|
new->next = tree->tree_first;
|
|
|
|
tree->tree_first = new;
|
|
|
|
}
|
|
|
|
new->next->prev = new;
|
|
|
|
}
|
|
|
|
/* tree_count++; */
|
|
|
|
|
|
|
|
/* Calculate attributes */
|
|
|
|
new->name = strdup (name);
|
|
|
|
len = strlen (new->name);
|
|
|
|
new->sublevel = 0;
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (new->name [i] == PATH_SEP){
|
|
|
|
new->sublevel++;
|
|
|
|
new->subname = new->name + i + 1;
|
|
|
|
}
|
|
|
|
if (new->next)
|
|
|
|
submask = new->next->submask;
|
|
|
|
else
|
|
|
|
submask = 0;
|
|
|
|
submask |= 1 << new->sublevel;
|
|
|
|
submask &= (2 << new->sublevel) - 1;
|
|
|
|
new->submask = submask;
|
|
|
|
new->mark = 0;
|
|
|
|
|
|
|
|
/* Correct the submasks of the previous entries */
|
|
|
|
current = new->prev;
|
|
|
|
while (current && current->sublevel > new->sublevel){
|
|
|
|
current->submask |= 1 << new->sublevel;
|
|
|
|
current = current->prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The entry has now been added */
|
|
|
|
|
|
|
|
if (new->sublevel > 1){
|
|
|
|
/* Let's check if the parent directory is in the tree */
|
|
|
|
char *parent = strdup (new->name);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = strlen (parent) - 1; i > 1; i--){
|
|
|
|
if (parent [i] == PATH_SEP){
|
|
|
|
parent [i] = 0;
|
|
|
|
tree_add_entry (tree, parent);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free (parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/* Append a directory to the list of directories */
|
|
|
|
static tree_entry *tree_append_entry (WTree *tree, char *name)
|
|
|
|
{
|
|
|
|
tree_entry *current, *new;
|
|
|
|
int i, len;
|
|
|
|
int submask = 0;
|
|
|
|
|
|
|
|
/* We assume the directory is not yet in the list */
|
|
|
|
|
|
|
|
new = xmalloc (sizeof (tree_entry), "tree, tree_entry");
|
|
|
|
if (!tree->tree_first){
|
|
|
|
/* Empty list */
|
|
|
|
tree->tree_first = new;
|
|
|
|
new->prev = NULL;
|
|
|
|
} else {
|
|
|
|
tree->tree_last->next = new;
|
|
|
|
new->prev = tree->tree_last;
|
|
|
|
}
|
|
|
|
new->next = NULL;
|
|
|
|
tree->tree_last = new;
|
|
|
|
|
|
|
|
/* Calculate attributes */
|
|
|
|
new->name = strdup (name);
|
|
|
|
len = strlen (new->name);
|
|
|
|
new->sublevel = 0;
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (new->name [i] == PATH_SEP){
|
|
|
|
new->sublevel++;
|
|
|
|
new->subname = new->name + i + 1;
|
|
|
|
}
|
|
|
|
submask = 1 << new->sublevel;
|
|
|
|
submask &= (2 << new->sublevel) - 1;
|
|
|
|
new->submask = submask;
|
|
|
|
new->mark = 0;
|
|
|
|
|
|
|
|
/* Correct the submasks of the previous entries */
|
|
|
|
current = new->prev;
|
|
|
|
while (current && current->sublevel > new->sublevel){
|
|
|
|
current->submask |= 1 << new->sublevel;
|
|
|
|
current = current->prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The entry has now been appended */
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void remove_entry (WTree *tree, tree_entry *entry)
|
|
|
|
{
|
|
|
|
tree_entry *current = entry->prev;
|
|
|
|
long submask = 0;
|
|
|
|
|
|
|
|
if (tree->selected_ptr == entry){
|
|
|
|
if (tree->selected_ptr->next)
|
|
|
|
tree->selected_ptr = tree->selected_ptr->next;
|
|
|
|
else
|
|
|
|
tree->selected_ptr = tree->selected_ptr->prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Correct the submasks of the previous entries */
|
|
|
|
if (entry->next)
|
|
|
|
submask = entry->next->submask;
|
|
|
|
while (current && current->sublevel > entry->sublevel){
|
|
|
|
submask |= 1 << current->sublevel;
|
|
|
|
submask &= (2 << current->sublevel) - 1;
|
|
|
|
current->submask = submask;
|
|
|
|
current = current->prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unlink the entry from the list */
|
|
|
|
if (entry->prev)
|
|
|
|
entry->prev->next = entry->next;
|
|
|
|
else
|
|
|
|
tree->tree_first = entry->next;
|
|
|
|
if (entry->next)
|
|
|
|
entry->next->prev = entry->prev;
|
|
|
|
else
|
|
|
|
tree->tree_last = entry->prev;
|
|
|
|
/* tree_count--; */
|
|
|
|
|
|
|
|
/* Free the memory used by the entry */
|
|
|
|
free (entry->name);
|
|
|
|
free (entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_remove_entry (WTree *tree, char *name)
|
|
|
|
{
|
|
|
|
tree_entry *current, *base, *old;
|
|
|
|
int len, base_sublevel;
|
|
|
|
|
|
|
|
/* Miguel Ugly hack */
|
|
|
|
if (name [0] == PATH_SEP && name [1] == 0)
|
|
|
|
return;
|
|
|
|
/* Miguel Ugly hack end */
|
|
|
|
|
|
|
|
base = whereis (tree, name);
|
|
|
|
if (!base)
|
|
|
|
return; /* Doesn't exist */
|
|
|
|
if (tree->check_name [0] == PATH_SEP && tree->check_name [1] == 0)
|
|
|
|
base_sublevel = base->sublevel;
|
|
|
|
else
|
|
|
|
base_sublevel = base->sublevel + 1;
|
|
|
|
len = strlen (base->name);
|
|
|
|
current = base->next;
|
|
|
|
while (current
|
|
|
|
&& strncmp (current->name, base->name, len) == 0
|
|
|
|
&& (current->name[len] == '\0' || current->name[len] == PATH_SEP)){
|
|
|
|
old = current;
|
|
|
|
current = current->next;
|
|
|
|
remove_entry (tree, old);
|
|
|
|
}
|
|
|
|
remove_entry (tree, base);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_destroy (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_entry *current, *old;
|
|
|
|
|
|
|
|
save_tree (tree);
|
|
|
|
current = tree->tree_first;
|
|
|
|
while (current){
|
|
|
|
old = current;
|
|
|
|
current = current->next;
|
|
|
|
free (old->name);
|
|
|
|
free (old);
|
|
|
|
}
|
|
|
|
if (tree->tree_shown){
|
|
|
|
free (tree->tree_shown);
|
|
|
|
tree->tree_shown = 0;
|
|
|
|
}
|
|
|
|
tree->selected_ptr = tree->tree_first = tree->tree_last = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark the subdirectories of the current directory for delete */
|
|
|
|
void start_tree_check (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_entry *current;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!tree)
|
|
|
|
tree = (WTree *) find_widget_type (current_dlg, tcallback);
|
|
|
|
if (!tree)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Search for the start of subdirectories */
|
|
|
|
mc_get_current_wd (tree->check_name, MC_MAXPATHLEN);
|
|
|
|
tree->check_start = NULL;
|
|
|
|
current = whereis (tree, tree->check_name);
|
|
|
|
if (!current){
|
|
|
|
/* Cwd doesn't exist -> add it */
|
|
|
|
current = tree_add_entry (tree, tree->check_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark old subdirectories for delete */
|
|
|
|
tree->check_start = current->next;
|
|
|
|
len = strlen (tree->check_name);
|
|
|
|
|
|
|
|
current = tree->check_start;
|
|
|
|
while (current
|
|
|
|
&& strncmp (current->name, tree->check_name, len) == 0
|
|
|
|
&& (current->name[len] == '\0' || current->name[len] == PATH_SEP || len == 1)){
|
|
|
|
current->mark = 1;
|
|
|
|
current = current->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This subdirectory exists -> clear deletion mark */
|
|
|
|
void do_tree_check (WTree *tree, const char *subname)
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
tree_entry *current, *base;
|
|
|
|
int flag = 1, len;
|
|
|
|
|
|
|
|
/* Calculate the full name of the subdirectory */
|
|
|
|
if (subname [0] == '.' &&
|
|
|
|
(subname [1] == 0 || (subname [1] == '.' && subname [2] == 0)))
|
|
|
|
return;
|
|
|
|
if (tree->check_name [0] == PATH_SEP && tree->check_name [1] == 0)
|
|
|
|
name = copy_strings (PATH_SEP_STR, subname, 0);
|
|
|
|
else
|
|
|
|
name = concat_dir_and_file (tree->check_name, subname);
|
|
|
|
|
|
|
|
/* Search for the subdirectory */
|
|
|
|
current = tree->check_start;
|
|
|
|
while (current && (flag = pathcmp (current->name, name)) < 0)
|
|
|
|
current = current->next;
|
|
|
|
|
|
|
|
if (flag != 0)
|
|
|
|
/* Doesn't exist -> add it */
|
|
|
|
current = tree_add_entry (tree, name);
|
|
|
|
free (name);
|
|
|
|
|
|
|
|
/* Clear the deletion mark from the subdirectory and its children */
|
|
|
|
base = current;
|
|
|
|
if (base){
|
|
|
|
len = strlen (base->name);
|
|
|
|
base->mark = 0;
|
|
|
|
current = base->next;
|
|
|
|
while (current
|
|
|
|
&& strncmp (current->name, base->name, len) == 0
|
|
|
|
&& (current->name[len] == '\0' || current->name[len] == PATH_SEP || len == 1)){
|
|
|
|
current->mark = 0;
|
|
|
|
current = current->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tree check searchs a tree widget in the current dialog and
|
|
|
|
* if it finds it, it calls do_tree_check on the subname
|
|
|
|
*/
|
|
|
|
void tree_check (const char *subname)
|
|
|
|
{
|
|
|
|
WTree *tree;
|
|
|
|
|
|
|
|
tree = (WTree *) find_widget_type (current_dlg, tcallback);
|
|
|
|
if (!tree)
|
|
|
|
return;
|
|
|
|
do_tree_check (tree, subname);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Delete subdirectories which still have the deletion mark */
|
|
|
|
void end_tree_check (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_entry *current, *old;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!tree)
|
|
|
|
tree = (WTree *) find_widget_type (current_dlg, tcallback);
|
|
|
|
if (!tree)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Check delete marks and delete if found */
|
|
|
|
len = strlen (tree->check_name);
|
|
|
|
|
|
|
|
current = tree->check_start;
|
|
|
|
while (current
|
|
|
|
&& strncmp (current->name, tree->check_name, len) == 0
|
|
|
|
&& (current->name[len] == '\0' || current->name[len] == PATH_SEP || len == 1)){
|
|
|
|
old = current;
|
|
|
|
current = current->next;
|
|
|
|
if (old->mark)
|
|
|
|
remove_entry (tree, old);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Loads the .mc.tree file */
|
|
|
|
void load_tree (WTree *tree)
|
|
|
|
{
|
|
|
|
char *filename;
|
|
|
|
FILE *file;
|
|
|
|
char name [MC_MAXPATHLEN], oldname[MC_MAXPATHLEN];
|
|
|
|
char *different;
|
|
|
|
int len, common;
|
|
|
|
|
|
|
|
filename = concat_dir_and_file (home_dir, MC_TREE);
|
|
|
|
file = fopen (filename, "r");
|
|
|
|
free (filename);
|
|
|
|
if (!file){
|
|
|
|
/* No new tree file -> let's try the old file */
|
|
|
|
filename = concat_dir_and_file (home_dir, MC_TREE);
|
|
|
|
file = fopen (filename, "r");
|
|
|
|
free (filename);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (file){
|
|
|
|
/* File open -> read contents */
|
|
|
|
oldname [0] = 0;
|
|
|
|
while (fgets (name, MC_MAXPATHLEN, file)){
|
|
|
|
len = strlen (name);
|
|
|
|
if (name [len - 1] == '\n'){
|
|
|
|
name [--len] = 0;
|
|
|
|
}
|
|
|
|
#ifdef OS2_NT
|
|
|
|
/* .ado: Drives for NT and OS/2 */
|
|
|
|
if ((len > 2) &&
|
|
|
|
isalpha(name[0]) &&
|
|
|
|
(name[1] == ':') &&
|
|
|
|
(name[2] == '\\')) {
|
|
|
|
tree_add_entry (tree, name);
|
|
|
|
strcpy (oldname, name);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
/* UNIX Version */
|
|
|
|
if (name [0] != PATH_SEP){
|
|
|
|
/* Clear-text decompression */
|
|
|
|
char *s = strtok (name, " ");
|
|
|
|
|
|
|
|
if (s){
|
|
|
|
common = atoi (s);
|
|
|
|
different = strtok (NULL, "");
|
|
|
|
if (different){
|
|
|
|
strcpy (oldname + common, different);
|
|
|
|
tree_add_entry (tree, oldname);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
tree_add_entry (tree, name);
|
|
|
|
strcpy (oldname, name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose (file);
|
|
|
|
}
|
|
|
|
if (!tree->tree_first){
|
|
|
|
/* Nothing loaded -> let's add some standard directories */
|
|
|
|
tree_add_entry (tree, PATH_SEP_STR);
|
|
|
|
tree->selected_ptr = tree->tree_first;
|
|
|
|
tree_rescan_cmd (tree);
|
|
|
|
tree_add_entry (tree, home_dir);
|
|
|
|
tree_chdir (tree, home_dir);
|
|
|
|
tree_rescan_cmd (tree);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Save the .mc.tree file */
|
|
|
|
void save_tree (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_entry *current;
|
|
|
|
char *filename;
|
|
|
|
FILE *file;
|
|
|
|
int i, common;
|
|
|
|
|
|
|
|
filename = concat_dir_and_file (home_dir, MC_TREE);
|
|
|
|
file = fopen (filename, "w");
|
|
|
|
free (filename);
|
|
|
|
if (!file){
|
1998-03-25 08:16:00 +03:00
|
|
|
fprintf (stderr, _("Can't open the %s file for writing:\n%s\n"), MC_TREE,
|
1998-02-27 07:54:42 +03:00
|
|
|
unix_error_string (errno));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
current = tree->tree_first;
|
|
|
|
while (current){
|
|
|
|
if (current->prev && (common = str_common (current->prev->name, current->name)) > 2)
|
|
|
|
/* Clear-text compression */
|
|
|
|
i = fprintf (file, "%d %s\n", common, current->name + common);
|
|
|
|
else
|
|
|
|
i = fprintf (file, "%s\n", current->name);
|
|
|
|
if (i == EOF){
|
1998-03-25 08:16:00 +03:00
|
|
|
fprintf (stderr, _("Can't write to the %s file:\n%s\n"), MC_TREE,
|
1998-02-27 07:54:42 +03:00
|
|
|
unix_error_string (errno));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
current = current->next;
|
|
|
|
}
|
|
|
|
fclose (file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tree_show_mini_info (WTree *tree, int tree_lines, int tree_cols)
|
|
|
|
{
|
|
|
|
Dlg_head *h = tree->widget.parent;
|
|
|
|
int line;
|
|
|
|
|
|
|
|
/* Show mini info */
|
|
|
|
if (tree->is_panel){
|
|
|
|
if (!show_mini_info)
|
|
|
|
return;
|
|
|
|
line = tree_lines+2;
|
|
|
|
} else
|
|
|
|
line = tree_lines+1;
|
|
|
|
|
|
|
|
widget_move (&tree->widget, line, 1);
|
|
|
|
hline (' ', tree_cols);
|
|
|
|
widget_move (&tree->widget, line, 1);
|
|
|
|
|
|
|
|
if (tree->searching){
|
|
|
|
/* Show search string */
|
|
|
|
attrset (TREE_NORMALC);
|
|
|
|
attrset (FOCUSC);
|
|
|
|
addch (PATH_SEP);
|
|
|
|
|
|
|
|
addstr (name_trunc (tree->search_buffer, tree_cols-2));
|
|
|
|
addch (' ');
|
|
|
|
attrset (FOCUSC);
|
|
|
|
} else {
|
|
|
|
/* Show full name of selected directory */
|
|
|
|
addstr (name_trunc (tree->selected_ptr->name, tree_cols));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void show_tree (WTree *tree)
|
|
|
|
{
|
|
|
|
Dlg_head *h = tree->widget.parent;
|
|
|
|
tree_entry *current;
|
|
|
|
int i, j, topsublevel;
|
|
|
|
int x, y;
|
|
|
|
int tree_lines, tree_cols;
|
|
|
|
|
|
|
|
/* Initialize */
|
|
|
|
x = y = 0;
|
|
|
|
tree_lines = tlines (tree);
|
|
|
|
tree_cols = tree->widget.cols;
|
|
|
|
|
|
|
|
attrset (TREE_NORMALC);
|
|
|
|
widget_move ((Widget*)tree, y, x);
|
|
|
|
if (tree->is_panel){
|
|
|
|
tree_cols -= 2;
|
|
|
|
x = y = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree->tree_shown)
|
|
|
|
free (tree->tree_shown);
|
|
|
|
tree->tree_shown = (tree_entry**)xmalloc (sizeof (tree_entry*)*tree_lines,
|
|
|
|
"tree, show_tree");
|
|
|
|
for (i = 0; i < tree_lines; i++)
|
|
|
|
tree->tree_shown [i] = NULL;
|
|
|
|
if (tree->tree_first)
|
|
|
|
topsublevel = tree->tree_first->sublevel;
|
|
|
|
else
|
|
|
|
topsublevel = 0;
|
|
|
|
if (!tree->selected_ptr){
|
|
|
|
tree->selected_ptr = tree->tree_first;
|
|
|
|
tree->topdiff = 0;
|
|
|
|
}
|
|
|
|
current = tree->selected_ptr;
|
|
|
|
|
|
|
|
/* Calculate the directory which is to be shown on the topmost line */
|
|
|
|
if (tree_navigation_flag){
|
|
|
|
i = 0;
|
|
|
|
while (current->prev && i < tree->topdiff){
|
|
|
|
current = current->prev;
|
|
|
|
if (current->sublevel < tree->selected_ptr->sublevel){
|
|
|
|
if (strncmp (current->name, tree->selected_ptr->name,
|
|
|
|
strlen (current->name)) == 0)
|
|
|
|
i++;
|
|
|
|
} else if (current->sublevel == tree->selected_ptr->sublevel){
|
|
|
|
for (j = strlen (current->name) - 1; current->name [j] != PATH_SEP; j--);
|
|
|
|
if (strncmp (current->name, tree->selected_ptr->name, j) == 0)
|
|
|
|
i++;
|
|
|
|
} else if (current->sublevel == tree->selected_ptr->sublevel + 1
|
|
|
|
&& strlen (tree->selected_ptr->name) > 1){
|
|
|
|
if (strncmp (current->name, tree->selected_ptr->name,
|
|
|
|
strlen (tree->selected_ptr->name)) == 0)
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tree->topdiff = i;
|
|
|
|
} else
|
|
|
|
current = back_ptr (current, &tree->topdiff);
|
|
|
|
|
|
|
|
/* Loop for every line */
|
|
|
|
for (i = 0; i < tree_lines; i++){
|
|
|
|
/* Move to the beginning of the line */
|
|
|
|
widget_move (&tree->widget, y+i, x);
|
|
|
|
|
|
|
|
hline (' ', tree_cols);
|
|
|
|
widget_move (&tree->widget, y+i, x);
|
|
|
|
|
|
|
|
if (!current)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
tree->tree_shown [i] = current;
|
|
|
|
if (current->sublevel == topsublevel){
|
|
|
|
|
|
|
|
/* Top level directory */
|
|
|
|
if (tree->active && current == tree->selected_ptr)
|
|
|
|
if (!use_colors && !tree->is_panel)
|
|
|
|
attrset (MARKED_COLOR);
|
|
|
|
else
|
|
|
|
attrset (SELECTED_COLOR);
|
|
|
|
|
|
|
|
/* Show full name */
|
|
|
|
addstr (name_trunc (current->name, tree_cols - 6));
|
|
|
|
} else{
|
|
|
|
/* Sub level directory */
|
|
|
|
|
|
|
|
acs ();
|
|
|
|
/* Output branch parts */
|
|
|
|
for (j = 0; j < current->sublevel - topsublevel - 1; j++){
|
|
|
|
if (tree_cols - 8 - 3 * j < 9)
|
|
|
|
break;
|
|
|
|
addch (' ');
|
|
|
|
if (current->submask & (1 << (j + topsublevel + 1)))
|
|
|
|
addch (ACS_VLINE);
|
|
|
|
else
|
|
|
|
addch (' ');
|
|
|
|
addch (' ');
|
|
|
|
}
|
|
|
|
addch (' '); j++;
|
|
|
|
if (!current->next || !(current->next->submask & (1 << current->sublevel)))
|
|
|
|
addch (ACS_LLCORNER);
|
|
|
|
else
|
|
|
|
addch (ACS_LTEE);
|
|
|
|
addch (ACS_HLINE);
|
|
|
|
noacs ();
|
|
|
|
|
|
|
|
if (tree->active && current == tree->selected_ptr)
|
|
|
|
/* Selected directory -> change color */
|
|
|
|
if (!use_colors && !tree->is_panel)
|
|
|
|
attrset (MARKED_COLOR);
|
|
|
|
else
|
|
|
|
attrset (SELECTED_COLOR);
|
|
|
|
|
|
|
|
/* Show sub-name */
|
|
|
|
addch (' ');
|
|
|
|
addstr (name_trunc (current->subname,
|
|
|
|
tree_cols - 2 - 4 - 3 * j));
|
|
|
|
}
|
|
|
|
addch (' ');
|
|
|
|
|
|
|
|
/* Return to normal color */
|
|
|
|
attrset (TREE_NORMALC);
|
|
|
|
|
|
|
|
/* Calculate the next value for current */
|
|
|
|
if (tree_navigation_flag){
|
|
|
|
current = current->next;
|
|
|
|
while (current){
|
|
|
|
if (current->sublevel < tree->selected_ptr->sublevel){
|
|
|
|
if (strncmp (current->name, tree->selected_ptr->name,
|
|
|
|
strlen (current->name)) == 0)
|
|
|
|
break;
|
|
|
|
} else if (current->sublevel == tree->selected_ptr->sublevel){
|
|
|
|
for (j = strlen (current->name) - 1; current->name [j] != PATH_SEP; j--);
|
|
|
|
if (strncmp (current->name,tree->selected_ptr->name,j)== 0)
|
|
|
|
break;
|
|
|
|
} else if (current->sublevel == tree->selected_ptr->sublevel+1
|
|
|
|
&& strlen (tree->selected_ptr->name) > 1){
|
|
|
|
if (strncmp (current->name, tree->selected_ptr->name,
|
|
|
|
strlen (tree->selected_ptr->name)) == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
current = current->next;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
current = current->next;
|
|
|
|
}
|
|
|
|
tree_show_mini_info (tree, tree_lines, tree_cols);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void check_focus (WTree *tree)
|
|
|
|
{
|
|
|
|
if (tree->topdiff < 3)
|
|
|
|
tree->topdiff = 3;
|
|
|
|
else if (tree->topdiff >= tlines (tree) - 3)
|
|
|
|
tree->topdiff = tlines (tree) - 3 - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_move_backward (WTree *tree, int i)
|
|
|
|
{
|
|
|
|
tree_entry *current;
|
|
|
|
int j = 0;
|
|
|
|
|
|
|
|
if (tree_navigation_flag){
|
|
|
|
current = tree->selected_ptr;
|
|
|
|
while (j < i && current->prev
|
|
|
|
&& current->prev->sublevel >= tree->selected_ptr->sublevel){
|
|
|
|
current = current->prev;
|
|
|
|
if (current->sublevel == tree->selected_ptr->sublevel){
|
|
|
|
tree->selected_ptr = current;
|
|
|
|
j ++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i = j;
|
|
|
|
} else
|
|
|
|
tree->selected_ptr = back_ptr (tree->selected_ptr, &i);
|
|
|
|
tree->topdiff -= i;
|
|
|
|
check_focus (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_move_forward (WTree *tree, int i)
|
|
|
|
{
|
|
|
|
tree_entry *current;
|
|
|
|
int j = 0;
|
|
|
|
|
|
|
|
if (tree_navigation_flag){
|
|
|
|
current = tree->selected_ptr;
|
|
|
|
while (j < i && current->next
|
|
|
|
&& current->next->sublevel >= tree->selected_ptr->sublevel){
|
|
|
|
current = current->next;
|
|
|
|
if (current->sublevel == tree->selected_ptr->sublevel){
|
|
|
|
tree->selected_ptr = current;
|
|
|
|
j ++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i = j;
|
|
|
|
} else
|
|
|
|
tree->selected_ptr = forw_ptr (tree->selected_ptr, &i);
|
|
|
|
tree->topdiff += i;
|
|
|
|
check_focus (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_move_to_child (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_entry *current;
|
|
|
|
|
|
|
|
/* Do we have a starting point? */
|
|
|
|
if (!tree->selected_ptr)
|
|
|
|
return;
|
|
|
|
/* Take the next entry */
|
|
|
|
current = tree->selected_ptr->next;
|
|
|
|
/* Is it the child of the selected entry */
|
|
|
|
if (current && current->sublevel > tree->selected_ptr->sublevel){
|
|
|
|
/* Yes -> select this entry */
|
|
|
|
tree->selected_ptr = current;
|
|
|
|
tree->topdiff++;
|
|
|
|
check_focus (tree);
|
|
|
|
} else {
|
|
|
|
/* No -> rescan and try again */
|
|
|
|
tree_rescan_cmd (tree);
|
|
|
|
current = tree->selected_ptr->next;
|
|
|
|
if (current && current->sublevel > tree->selected_ptr->sublevel){
|
|
|
|
tree->selected_ptr = current;
|
|
|
|
tree->topdiff++;
|
|
|
|
check_focus (tree);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int tree_move_to_parent (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_entry *current;
|
|
|
|
tree_entry *old;
|
|
|
|
|
|
|
|
if (!tree->selected_ptr)
|
|
|
|
return 0;
|
|
|
|
old = tree->selected_ptr;
|
|
|
|
current = tree->selected_ptr->prev;
|
|
|
|
while (current && current->sublevel >= tree->selected_ptr->sublevel){
|
|
|
|
current = current->prev;
|
|
|
|
tree->topdiff--;
|
|
|
|
}
|
|
|
|
if (!current)
|
|
|
|
current = tree->tree_first;
|
|
|
|
tree->selected_ptr = current;
|
|
|
|
check_focus (tree);
|
|
|
|
return tree->selected_ptr != old;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_move_to_top (WTree *tree)
|
|
|
|
{
|
|
|
|
tree->selected_ptr = tree->tree_first;
|
|
|
|
tree->topdiff = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_move_to_bottom (WTree *tree)
|
|
|
|
{
|
|
|
|
tree->selected_ptr = tree->tree_last;
|
|
|
|
tree->topdiff = tlines (tree) - 3 - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_chdir (WTree *tree, char *dir)
|
|
|
|
{
|
|
|
|
tree_entry *current;
|
|
|
|
|
|
|
|
current = whereis (tree, dir);
|
|
|
|
if (current){
|
|
|
|
tree->selected_ptr = current;
|
|
|
|
check_focus (tree);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle mouse click */
|
|
|
|
void tree_event (WTree *tree, int y)
|
|
|
|
{
|
|
|
|
if (tree->tree_shown [y]){
|
|
|
|
tree->selected_ptr = tree->tree_shown [y];
|
|
|
|
tree->topdiff = y;
|
|
|
|
}
|
|
|
|
show_tree (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void chdir_sel (WTree *tree);
|
|
|
|
|
|
|
|
static void maybe_chdir (WTree *tree)
|
|
|
|
{
|
|
|
|
if (!(xtree_mode && tree->is_panel))
|
|
|
|
return;
|
|
|
|
if (is_idle ())
|
|
|
|
chdir_sel (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mouse callback */
|
|
|
|
static int event_callback (Gpm_Event *event, WTree *tree)
|
|
|
|
{
|
|
|
|
if (!(event->type & GPM_UP))
|
|
|
|
return MOU_ENDLOOP;
|
|
|
|
|
|
|
|
if (tree->is_panel)
|
|
|
|
event->y--;
|
|
|
|
|
|
|
|
event->y--;
|
|
|
|
|
|
|
|
if (!tree->active)
|
|
|
|
change_panel ();
|
|
|
|
|
|
|
|
if (event->y < 0){
|
|
|
|
tree_move_backward (tree, tlines (tree) - 1);
|
|
|
|
show_tree (tree);
|
|
|
|
}
|
|
|
|
else if (event->y >= tlines (tree)){
|
|
|
|
tree_move_forward (tree, tlines (tree) - 1);
|
|
|
|
show_tree (tree);
|
|
|
|
} else {
|
|
|
|
tree_event (tree, event->y);
|
|
|
|
if ((event->type & (GPM_UP|GPM_DOUBLE)) == (GPM_UP|GPM_DOUBLE)){
|
|
|
|
chdir_sel (tree);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return MOU_ENDLOOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Search tree for text */
|
|
|
|
int search_tree (WTree *tree, char *text)
|
|
|
|
{
|
|
|
|
tree_entry *current;
|
|
|
|
int len;
|
|
|
|
int wrapped = 0;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
len = strlen (text);
|
|
|
|
current = tree->selected_ptr;
|
|
|
|
found = 0;
|
|
|
|
while (!wrapped || current != tree->selected_ptr){
|
|
|
|
if (strncmp (current->subname, text, len) == 0){
|
|
|
|
tree->selected_ptr = current;
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
current = current->next;
|
|
|
|
if (!current){
|
|
|
|
current = tree->tree_first;
|
|
|
|
wrapped = 1;
|
|
|
|
}
|
|
|
|
tree->topdiff++;
|
|
|
|
}
|
|
|
|
check_focus (tree);
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tree_do_search (WTree *tree, int key)
|
|
|
|
{
|
|
|
|
int l;
|
|
|
|
|
|
|
|
l = strlen (tree->search_buffer);
|
|
|
|
if (l && (key == 8 || key == 0177 || key == KEY_BACKSPACE))
|
|
|
|
tree->search_buffer [--l] = 0;
|
|
|
|
else {
|
|
|
|
if (key && l < sizeof (tree->search_buffer)){
|
|
|
|
tree->search_buffer [l] = key;
|
|
|
|
tree->search_buffer [l+1] = 0;
|
|
|
|
l++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!search_tree (tree, tree->search_buffer))
|
|
|
|
tree->search_buffer [--l] = 0;
|
|
|
|
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_rescan_cmd (WTree *tree)
|
|
|
|
{
|
|
|
|
DIR *dirp;
|
|
|
|
struct dirent *dp;
|
|
|
|
struct stat buf;
|
|
|
|
char old_dir [MC_MAXPATHLEN];
|
|
|
|
|
|
|
|
if (!tree->selected_ptr || !mc_get_current_wd (old_dir, MC_MAXPATHLEN) ||
|
|
|
|
mc_chdir (tree->selected_ptr->name))
|
|
|
|
return;
|
|
|
|
|
|
|
|
start_tree_check (tree);
|
|
|
|
dirp = opendir (".");
|
|
|
|
if (dirp){
|
|
|
|
for (dp = readdir (dirp); dp; dp = readdir (dirp)){
|
|
|
|
lstat (dp->d_name, &buf);
|
|
|
|
if (S_ISDIR (buf.st_mode))
|
|
|
|
do_tree_check (tree, dp->d_name);
|
|
|
|
}
|
|
|
|
closedir (dirp);
|
|
|
|
}
|
|
|
|
end_tree_check (tree);
|
|
|
|
mc_chdir (old_dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
int tree_forget_cmd (WTree *tree)
|
|
|
|
{
|
|
|
|
if (tree->selected_ptr)
|
|
|
|
tree_remove_entry (tree, tree->selected_ptr->name);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static int toggle_nav_mode (void)
|
|
|
|
{
|
|
|
|
tree_navigation_flag = 1 - tree_navigation_flag;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void tree_copy (WTree *tree, char *default_dest)
|
|
|
|
{
|
|
|
|
char *dest;
|
|
|
|
|
|
|
|
if (!tree->selected_ptr)
|
|
|
|
return;
|
1998-03-25 08:16:00 +03:00
|
|
|
sprintf (cmd_buf, _("Copy \"%s\" directory to:"),
|
1998-02-27 07:54:42 +03:00
|
|
|
name_trunc (tree->selected_ptr->name, 50));
|
1998-03-25 08:16:00 +03:00
|
|
|
dest = input_expand_dialog (_(" Copy "), cmd_buf, default_dest);
|
1998-02-27 07:54:42 +03:00
|
|
|
if (!dest || !*dest){
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
create_op_win (OP_COPY, 0);
|
|
|
|
file_mask_defaults ();
|
1998-04-17 04:21:53 +04:00
|
|
|
copy_dir_dir (tree->selected_ptr->name, dest, 1, 0, 0, 0);
|
1998-02-27 07:54:42 +03:00
|
|
|
destroy_op_win ();
|
|
|
|
free (dest);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tree_help_cmd (void)
|
|
|
|
{
|
|
|
|
char *hlpfile = concat_dir_and_file (mc_home, "mc.hlp");
|
|
|
|
interactive_display (hlpfile, "[Directory Tree]");
|
|
|
|
free (hlpfile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tree_copy_cmd (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_copy (tree, "");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void tree_move (WTree *tree, char *default_dest)
|
|
|
|
{
|
|
|
|
char *dest;
|
|
|
|
struct stat buf;
|
|
|
|
|
|
|
|
if (!tree->selected_ptr)
|
|
|
|
return;
|
1998-03-25 08:16:00 +03:00
|
|
|
sprintf (cmd_buf, _("Move \"%s\" directory to:"),
|
1998-02-27 07:54:42 +03:00
|
|
|
name_trunc (tree->selected_ptr->name, 50));
|
1998-03-25 08:16:00 +03:00
|
|
|
dest = input_expand_dialog (_(" Move "), cmd_buf, default_dest);
|
1998-02-27 07:54:42 +03:00
|
|
|
if (!dest || !*dest){
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (stat (dest, &buf)){
|
1998-03-25 08:16:00 +03:00
|
|
|
message (1, _(" Error "), _(" Can't stat the destination \n %s "),
|
1998-02-27 07:54:42 +03:00
|
|
|
unix_error_string (errno));
|
|
|
|
free (dest);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!S_ISDIR (buf.st_mode)){
|
1998-03-25 08:16:00 +03:00
|
|
|
message (1, _(" Error "), _(" The destination isn't a directory "));
|
1998-02-27 07:54:42 +03:00
|
|
|
free (dest);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
create_op_win (OP_MOVE, 0);
|
|
|
|
file_mask_defaults ();
|
|
|
|
move_dir_dir (tree->selected_ptr->name, dest);
|
|
|
|
destroy_op_win ();
|
|
|
|
free (dest);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tree_move_cmd (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_move (tree, "");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tree_mkdir_cmd (WTree *tree)
|
|
|
|
{
|
|
|
|
char old_dir [MC_MAXPATHLEN];
|
|
|
|
|
|
|
|
if (!tree->selected_ptr)
|
|
|
|
return 0;
|
|
|
|
if (!mc_get_current_wd (old_dir, MC_MAXPATHLEN))
|
|
|
|
return 0;
|
|
|
|
if (chdir (tree->selected_ptr->name))
|
|
|
|
return 0;
|
|
|
|
/* FIXME
|
|
|
|
mkdir_cmd (tree);
|
|
|
|
*/
|
|
|
|
tree_rescan_cmd (tree);
|
|
|
|
chdir (old_dir);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
1998-03-16 22:09:24 +03:00
|
|
|
static void tree_rmdir_cmd (WTree *tree)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
|
|
|
char old_dir [MC_MAXPATHLEN];
|
|
|
|
|
|
|
|
if (tree->selected_ptr){
|
|
|
|
if (!mc_get_current_wd (old_dir, MC_MAXPATHLEN))
|
1998-03-16 22:09:24 +03:00
|
|
|
return;
|
1998-02-27 07:54:42 +03:00
|
|
|
if (mc_chdir (PATH_SEP_STR))
|
1998-03-16 22:09:24 +03:00
|
|
|
return;
|
1998-02-27 07:54:42 +03:00
|
|
|
if (confirm_delete){
|
|
|
|
char *cmd_buf;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
cmd_buf = xmalloc (strlen (tree->selected_ptr->name) + 20,
|
|
|
|
"tree, rmdir_cmd");
|
1998-03-25 08:16:00 +03:00
|
|
|
sprintf (cmd_buf, _(" Delete %s? "), tree->selected_ptr->name);
|
|
|
|
result = query_dialog (_(" Delete "), cmd_buf, 3, 2, _("&Yes"), _("&No"));
|
1998-02-27 07:54:42 +03:00
|
|
|
free (cmd_buf);
|
|
|
|
if (result != 0){
|
1998-03-16 22:09:24 +03:00
|
|
|
return;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
create_op_win (OP_DELETE, 0);
|
|
|
|
if (erase_dir (tree->selected_ptr->name) == FILE_CONT)
|
|
|
|
tree_forget_cmd (tree);
|
|
|
|
destroy_op_win ();
|
|
|
|
mc_chdir (old_dir);
|
1998-03-16 22:09:24 +03:00
|
|
|
return;
|
1998-02-27 07:54:42 +03:00
|
|
|
} else
|
1998-03-16 22:09:24 +03:00
|
|
|
return;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static int tree_quit_cmd (void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
FIXME
|
|
|
|
return done = 1;
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void set_navig_label (Dlg_head *h);
|
|
|
|
static void tree_toggle_navig (Dlg_head *h)
|
|
|
|
{
|
|
|
|
tree_navigation_flag = 1 - tree_navigation_flag;
|
|
|
|
set_navig_label (h);
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_navig_label (Dlg_head *h)
|
|
|
|
{
|
|
|
|
define_label_data (h, (Widget *)tree,
|
1998-03-25 08:16:00 +03:00
|
|
|
4, tree_navigation_flag ? _("Static") : _("Dynamc"),
|
|
|
|
(void (*)(void *))tree_toggle_navig, h);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void move_down (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_move_forward (tree, 1);
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void move_up (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_move_backward (tree, 1);
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void move_home (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_move_to_top (tree);
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void move_end (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_move_to_bottom (tree);
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int move_left (WTree *tree)
|
|
|
|
{
|
|
|
|
int v;
|
|
|
|
|
|
|
|
if (tree_navigation_flag){
|
|
|
|
v = tree_move_to_parent (tree);
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int move_right (WTree *tree)
|
|
|
|
{
|
|
|
|
if (tree_navigation_flag){
|
|
|
|
tree_move_to_child (tree);
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void move_prevp (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_move_backward (tree, tlines (tree) - 1);
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void move_nextp (WTree *tree)
|
|
|
|
{
|
|
|
|
tree_move_forward (tree, tlines (tree) - 1);
|
|
|
|
show_tree (tree);
|
|
|
|
maybe_chdir (tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void chdir_sel (WTree *tree)
|
|
|
|
{
|
|
|
|
if (!tree->is_panel){
|
|
|
|
tree->done = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
change_panel ();
|
|
|
|
if (do_cd (tree->selected_ptr->name, cd_exact)){
|
|
|
|
paint_panel (cpanel);
|
|
|
|
select_item (cpanel);
|
|
|
|
} else {
|
1998-03-25 08:16:00 +03:00
|
|
|
message (1, MSG_ERROR, _(" Can't chdir to \"%s\" \n %s "),
|
1998-02-27 07:54:42 +03:00
|
|
|
tree->selected_ptr->name, unix_error_string (errno));
|
|
|
|
}
|
|
|
|
change_panel ();
|
|
|
|
show_tree (tree);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void start_search (WTree *tree)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (tree->searching){
|
|
|
|
|
|
|
|
if (tree->selected_ptr == tree->tree_last)
|
|
|
|
tree_move_to_top(tree);
|
|
|
|
else {
|
|
|
|
/* set navigation mode temporarily to 'Static' because in
|
|
|
|
* dynamic navigation mode tree_move_forward will not move
|
|
|
|
* to a lower sublevel if necessary (sequent searches must
|
|
|
|
* start with the directory followed the last found directory)
|
|
|
|
*/
|
|
|
|
i = tree_navigation_flag;
|
|
|
|
tree_navigation_flag = 0;
|
|
|
|
tree_move_forward (tree, 1);
|
|
|
|
tree_navigation_flag = i;
|
|
|
|
}
|
|
|
|
tree_do_search (tree, 0);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
tree->searching = 1;
|
|
|
|
tree->search_buffer[0] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static key_map tree_keymap [] = {
|
|
|
|
{ XCTRL('n'), move_down },
|
|
|
|
{ XCTRL('p'), move_up },
|
|
|
|
{ KEY_DOWN, move_down },
|
|
|
|
{ KEY_UP, move_up },
|
|
|
|
{ '\n', chdir_sel },
|
|
|
|
{ KEY_ENTER, chdir_sel },
|
|
|
|
{ KEY_HOME, move_home },
|
|
|
|
{ KEY_C1, move_end },
|
|
|
|
{ KEY_END, move_end },
|
|
|
|
{ KEY_A1, move_home },
|
|
|
|
{ KEY_NPAGE, move_nextp },
|
|
|
|
{ KEY_PPAGE, move_prevp },
|
|
|
|
{ XCTRL('v'), move_nextp },
|
|
|
|
{ ALT('v'), move_prevp },
|
|
|
|
{ XCTRL('p'), move_up },
|
|
|
|
{ XCTRL('p'), move_down },
|
|
|
|
{ XCTRL('s'), start_search },
|
|
|
|
{ ALT('s'), start_search },
|
|
|
|
{ XCTRL('r'), tree_rescan_cmd },
|
1998-03-02 21:09:16 +03:00
|
|
|
{ KEY_DC, tree_rmdir_cmd },
|
1998-02-27 07:54:42 +03:00
|
|
|
{ 0, 0 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline int tree_key (WTree *tree, int key)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; tree_keymap [i].key_code; i++){
|
|
|
|
if (key == tree_keymap [i].key_code){
|
|
|
|
if (tree_keymap [i].fn != start_search)
|
|
|
|
tree->searching = 0;
|
|
|
|
(*tree_keymap [i].fn)(tree);
|
|
|
|
show_tree (tree);
|
1998-03-02 21:09:16 +03:00
|
|
|
return 1;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
1998-03-02 21:09:16 +03:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
/* We do not want to use them if we do not need to */
|
|
|
|
/* Input line may want to take the motion key event */
|
|
|
|
if (key == KEY_LEFT)
|
|
|
|
return move_left (tree);
|
|
|
|
|
|
|
|
if (key == KEY_RIGHT)
|
1998-03-02 21:09:16 +03:00
|
|
|
return move_right (tree);
|
1998-02-27 07:54:42 +03:00
|
|
|
|
|
|
|
if (is_abort_char (key)) {
|
1998-03-02 21:09:16 +03:00
|
|
|
if (tree->is_panel) {
|
|
|
|
tree->searching = 0;
|
|
|
|
show_tree (tree);
|
|
|
|
return 1; /* eat abort char */
|
|
|
|
}
|
|
|
|
return 0; /* modal tree dialog: let upper layer see the
|
|
|
|
abort character and close the dialog */
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
1998-03-02 21:09:16 +03:00
|
|
|
/* Do not eat characters not meant for the tree below ' ' (e.g. C-l). */
|
|
|
|
if ((key >= ' '&& key <= 255) || key == 8 || key == KEY_BACKSPACE) {
|
|
|
|
if (tree->searching){
|
|
|
|
tree_do_search (tree, key);
|
|
|
|
show_tree (tree);
|
|
|
|
return 1;
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
|
1998-03-02 21:09:16 +03:00
|
|
|
if (!command_prompt) {
|
|
|
|
start_search (tree);
|
|
|
|
tree_do_search (tree, key);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return tree->is_panel;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
1998-03-02 21:09:16 +03:00
|
|
|
|
|
|
|
return 0;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void tree_frame (Dlg_head *h, WTree *tree)
|
|
|
|
{
|
|
|
|
attrset (NORMAL_COLOR);
|
|
|
|
widget_erase ((Widget*) tree);
|
|
|
|
if (tree->is_panel)
|
|
|
|
draw_double_box (h, tree->widget.y, tree->widget.x, tree->widget.lines,
|
|
|
|
tree->widget.cols);
|
|
|
|
|
|
|
|
if (show_mini_info && tree->is_panel){
|
|
|
|
widget_move (tree, tlines (tree) + 1, 1);
|
|
|
|
hline (ACS_HLINE, tree->widget.cols - 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int tree_callback (Dlg_head *h, WTree *tree, int msg, int par)
|
|
|
|
{
|
|
|
|
switch (msg){
|
|
|
|
case WIDGET_DRAW:
|
|
|
|
tree_frame (h, tree);
|
|
|
|
show_tree (tree);
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case WIDGET_KEY:
|
|
|
|
return tree_key (tree, par);
|
|
|
|
|
|
|
|
case WIDGET_FOCUS:
|
|
|
|
tree->active = 1;
|
1998-03-25 08:16:00 +03:00
|
|
|
define_label (h, (Widget *)tree, 1, _("Help"), (voidfn) tree_help_cmd);
|
1998-02-27 07:54:42 +03:00
|
|
|
define_label_data (h, (Widget *)tree,
|
1998-03-25 08:16:00 +03:00
|
|
|
2, _("Rescan"), (buttonbarfn)tree_rescan_cmd, tree);
|
1998-02-27 07:54:42 +03:00
|
|
|
define_label_data (h, (Widget *)tree,
|
1998-03-25 08:16:00 +03:00
|
|
|
3, _("Forget"), (buttonbarfn)tree_forget_cmd, tree);
|
1998-02-27 07:54:42 +03:00
|
|
|
define_label_data (h, (Widget *)tree,
|
1998-03-25 08:16:00 +03:00
|
|
|
5, _("Copy"), (buttonbarfn) tree_copy_cmd, tree);
|
1998-02-27 07:54:42 +03:00
|
|
|
define_label_data (h, (Widget *)tree,
|
1998-03-25 08:16:00 +03:00
|
|
|
6, _("RenMov"), (buttonbarfn) tree_move_cmd, tree);
|
1998-02-27 07:54:42 +03:00
|
|
|
#if 0
|
|
|
|
/* FIXME: mkdir is currently defunct */
|
|
|
|
define_label_data (h, (Widget *)tree,
|
1998-03-25 08:16:00 +03:00
|
|
|
7, _("Mkdir"), (buttonbarfn) tree_mkdir_cmd, tree);
|
1998-02-27 07:54:42 +03:00
|
|
|
#else
|
|
|
|
define_label (h, (Widget *)tree, 7, "", 0);
|
|
|
|
#endif
|
|
|
|
define_label_data (h, (Widget *)tree,
|
1998-03-25 08:16:00 +03:00
|
|
|
8, _("Rmdir"), (buttonbarfn) tree_rmdir_cmd, tree);
|
1998-02-27 07:54:42 +03:00
|
|
|
set_navig_label (h);
|
|
|
|
redraw_labels (h, (Widget *)tree);
|
|
|
|
|
|
|
|
|
|
|
|
/* FIXME: Should find a better way of only displaying the
|
|
|
|
currently selected item */
|
|
|
|
show_tree (tree);
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* FIXME: Should find a better way of changing the color of the
|
|
|
|
selected item */
|
|
|
|
case WIDGET_UNFOCUS:
|
|
|
|
tree->active = 0;
|
|
|
|
show_tree (tree);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return default_proc (h, msg, par);
|
|
|
|
}
|
|
|
|
|
|
|
|
WTree *tree_new (int is_panel, int y, int x, int lines, int cols)
|
|
|
|
{
|
|
|
|
WTree *tree = xmalloc (sizeof (WTree), "tree_new");
|
|
|
|
|
|
|
|
init_widget (&tree->widget, y, x, lines, cols, tcallback,
|
|
|
|
(destroy_fn) tree_destroy, (mouse_h) event_callback, NULL);
|
|
|
|
tree->is_panel = is_panel;
|
|
|
|
tree->selected_ptr = 0;
|
|
|
|
tree->tree_shown = 0;
|
|
|
|
tree->search_buffer [0] = 0;
|
|
|
|
tree->tree_first = tree->tree_last = 0;
|
|
|
|
tree->topdiff = tree->widget.lines / 2;
|
|
|
|
tree->searching = 0;
|
|
|
|
tree->done = 0;
|
|
|
|
tree->active = 0;
|
|
|
|
|
|
|
|
/* We do not want to keep the cursor */
|
|
|
|
widget_want_cursor (tree->widget, 0);
|
|
|
|
load_tree (tree);
|
|
|
|
return tree;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *get_absolute_name (char *file)
|
|
|
|
{
|
|
|
|
char dir [MC_MAXPATHLEN];
|
|
|
|
|
|
|
|
if (file [0] == PATH_SEP)
|
|
|
|
return strdup (file);
|
|
|
|
mc_get_current_wd (dir, MC_MAXPATHLEN);
|
|
|
|
return get_full_name (dir, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int my_mkdir_rec (char *s, mode_t mode)
|
|
|
|
{
|
|
|
|
char *p, *q;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (!mc_mkdir (s, mode))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* FIXME: should check instead if s is at the root of that filesystem */
|
|
|
|
if (!vfs_file_is_local (s))
|
|
|
|
return -1;
|
|
|
|
if (!strcmp (vfs_path(s), PATH_SEP_STR))
|
|
|
|
return ENOTDIR;
|
|
|
|
p = concat_dir_and_file (s, "..");
|
|
|
|
q = vfs_canon (p);
|
|
|
|
free (p);
|
|
|
|
if (!(result = my_mkdir_rec (q, mode))) {
|
|
|
|
result = mc_mkdir (s, mode);
|
|
|
|
}
|
|
|
|
free (q);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
int my_mkdir (char *s, mode_t mode)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
#if FIXME
|
|
|
|
WTree *tree = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
result = mc_mkdir (s, mode);
|
|
|
|
#ifdef OS2_NT
|
|
|
|
/* .ado: it will be disabled in OS/2 and NT */
|
|
|
|
/* otherwise crash if directory already exists. */
|
|
|
|
return result;
|
|
|
|
#endif
|
|
|
|
if (result) {
|
|
|
|
char *p = vfs_canon (s);
|
|
|
|
|
|
|
|
result = my_mkdir_rec (p, mode);
|
|
|
|
free (p);
|
|
|
|
}
|
|
|
|
if (result == 0){
|
|
|
|
s = get_absolute_name (s);
|
|
|
|
#if FIXME
|
|
|
|
/* FIXME: Should receive a Wtree! */
|
|
|
|
|
|
|
|
tree_add_entry (tree, s);
|
|
|
|
#endif
|
|
|
|
free (s);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
int my_rmdir (char *s)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
#if FIXME
|
|
|
|
WTree *tree = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* FIXME: Should receive a Wtree! */
|
|
|
|
result = mc_rmdir (s);
|
|
|
|
if (result == 0){
|
|
|
|
s = get_absolute_name (s);
|
|
|
|
#if FIXME
|
|
|
|
tree_remove_entry (tree, s);
|
|
|
|
#endif
|
|
|
|
free (s);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|