/* Directory tree browser for the Midnight Commander
   Copyright (C) 1994, 1995 Janne Kukonlehto
   
   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"

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: tree.c,v 1.3 1995/02/21 19:07:24 miguel Exp $" */

/* 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;
}

/* 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 < 0
	   && (flag = strcmp (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 < 0
	   && (flag = strcmp (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;
}

/* 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;
}

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->sublevel >= base_sublevel){
	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);
    }
    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 */
    /* Here is the bug reported by Michael */
    tree->check_start = current->next;
    len = strlen (tree->check_name);
    if (tree->check_name [0] == PATH_SEP && tree->check_name [1] == 0)
	tree->check_sublevel = current->sublevel;
    else
	tree->check_sublevel = current->sublevel + 1;

    current = tree->check_start;
    while (current
	   && strncmp (current->name, tree->check_name, len) == 0
	   && current->sublevel >= tree->check_sublevel){
	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 = 0, 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 = copy_strings (tree->check_name, PATH_SEP_STR, subname, 0);

    /* Search for the subdirectory */
    current = tree->check_start;
    while (current && (flag = strcmp (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->sublevel >= tree->check_sublevel){
	    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->sublevel >= tree->check_sublevel){
	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 = copy_strings (home_dir, PATH_SEP_STR ".mc.tree", 0);
    file = fopen (filename, "r");
    free (filename);
    if (!file){
	/* No new tree file -> let's try the old file */
	filename = copy_strings (home_dir, PATH_SEP_STR ".mc.tree.", 0);
	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;
	    }
	    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_append_entry (tree, oldname);
		    }
		}
	    } else {
		tree_append_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 = copy_strings (home_dir, PATH_SEP_STR ".mc.tree", 0);
    file = fopen (filename, "w");
    free (filename);
    if (!file){
	fprintf (stderr, "Can't open the .mc.tree file for writing:\n%s\n",
		 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){
	    fprintf (stderr, "Can't write to the .mc.tree file:\n%s\n",
		 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) set_attr (0, 1);
		else set_attr (1, 0);
	    /* 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) set_attr (0, 1);
		else set_attr (1, 0);

	    /* 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 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);
}

int tree_rescan_cmd (WTree *tree)
{
    DIR *dirp;
    struct dirent *dp;
    struct stat buf;
    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;
    
    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);
    chdir (old_dir);
    return 1;
}

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;
    sprintf (cmd_buf, "Copy \"%s\" directory to:",
	     name_trunc (tree->selected_ptr->name, 60));
    dest = input_expand_dialog (" Copy ", cmd_buf, default_dest);
    if (!dest || !*dest){
	return;
    }
    create_op_win (OP_COPY);
    copy_dir_dir (tree->selected_ptr->name, dest, 1, 0);
    destroy_op_win ();
    free (dest);
}

static void tree_help_cmd (void)
{
    interactive_display (LIBDIR "mc.hlp", "[Directory Tree]");
}

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;
    sprintf (cmd_buf, "Move \"%s\" directory to:",
	     name_trunc (tree->selected_ptr->name, 60));
    dest = input_expand_dialog (" Move ", cmd_buf, default_dest);
    if (!dest || !*dest){
	return;
    }
    if (stat (dest, &buf)){
	message (1, " Error ", " Can't stat the destination \n %s ",
		 unix_error_string (errno));
	free (dest);
	return;
    }
    if (!S_ISDIR (buf.st_mode)){
	message (1, " Error ", " The destination isn't a directory ");
	free (dest);
	return;
    }
    create_op_win (OP_MOVE);
    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;
}

static int tree_rmdir_cmd (WTree *tree)
{
    char old_dir [MC_MAXPATHLEN];

    if (tree->selected_ptr){
	if (!mc_get_current_wd (old_dir, MC_MAXPATHLEN))
	    return 0;
	if (chdir (PATH_SEP_STR))
	    return 0;
	if (confirm_delete){
	    char *cmd_buf;
	    int result;

	    cmd_buf = xmalloc (strlen (tree->selected_ptr->name) + 20,
			       "tree, rmdir_cmd");
	    sprintf (cmd_buf, "  Delete %s?  ", tree->selected_ptr->name);
	    result = query_dialog (" Delete ", cmd_buf, 3, 2, " Yes ", " No ");
	    free (cmd_buf);
	    if (result != 0){
		return 0;
	    }
	}
	create_op_win (OP_DELETE);
	if (erase_dir (tree->selected_ptr->name) == FILE_CONT)
	    tree_forget_cmd (tree);
	destroy_op_win ();
	chdir (old_dir);
	return 1;
    } else
	return 0;
}

#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 *) NULL,
        4, tree_navigation_flag ? "Static" : "Dynamc",
	(void (*)(void *))tree_toggle_navig, h);
}

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)){
	paint_panel (cpanel);
	select_item (cpanel);
    } else {
	message (1, " Error ", " Can't chdir to \"%s\" \n %s ",
		 tree->selected_ptr->name, unix_error_string (errno));
    }
    change_panel ();
    show_tree (tree);
    return;
}

static void start_search (WTree *tree)
{
    tree->searching = 1;
}

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 },
    };

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){
	    tree->search_buffer [0] = 0;
	    (*tree_keymap [i].fn)(tree);
	    show_tree (tree);
	    break;
	}
    }
    /* 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)
	move_right (tree);

    if (tree->searching){
	tree_do_search (tree, key);
	return 1;
    }
    if (!command_prompt)
	start_search (tree);

    if (key == -1)
	return 0;
    
    if (tree_keymap [i].key_code == 0){
	if (tree->search_buffer [0])
	    tree->search_buffer [0] = 0;
	show_tree (tree);
    }
    return  (key > ' ') ? tree->is_panel : 0;
}

static void tree_frame (Dlg_head *h, WTree *tree)
{
    set_attr (0, 0);
    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;
	define_label (h, (Widget *)tree, 1, "Help", (voidfn) tree_help_cmd);
	define_label_data (h, (Widget *)tree, 
	    2, "Rescan", (buttonbarfn)tree_rescan_cmd, tree);
	define_label_data (h, (Widget *)tree, 
	    3, "Forget", (buttonbarfn)tree_forget_cmd, tree);
	define_label_data (h, (Widget *)tree, 
	    5, "Copy",   (buttonbarfn) tree_copy_cmd, tree);
	define_label_data (h, (Widget *)tree, 
	    6, "RenMov", (buttonbarfn) tree_move_cmd, tree);
	define_label_data (h, (Widget *)tree, 
	    7, "Mkdir",  (buttonbarfn) tree_mkdir_cmd, tree);
	define_label_data (h, (Widget *)tree, 
	    8, "Rmdir",  (buttonbarfn) tree_rmdir_cmd, tree);
	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);
    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;
    
    /* 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;
    if (s [strlen (s) - 1] != PATH_SEP)
        p = copy_strings (s, PATH_SEP_STR "..", NULL);
    else
    	p = copy_strings (s, "..", NULL);
    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);
    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;
}


