/* 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, 1999 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 <string.h>
#include <errno.h>
#include <stdio.h>
#include "tty.h"
#include "global.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 "fileopctx.h"
#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;

/* 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.19 1999/01/27 01:09:30 timur Exp $" */

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

/* Add a directory to the list of directories */
tree_entry *tree_add_entry (WTree *tree, char *name)
{
    if (!tree)
	return 0;
    
    return tree_store_add_entry (name);
}

#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 = g_new (tree_entry, 1);
    if (!tree->store->tree_first){
        /* Empty list */
        tree->store->tree_first = new;
        new->prev = NULL;
    } else {
        tree->tree_last->next = new;
        new->prev = tree->tree_last;
    }
    new->next = NULL;
    tree->store->tree_last = new;

    /* Calculate attributes */
    new->name = g_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

void
remove_callback (tree_entry *entry, void *data)
{
	WTree *tree = data;

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

void tree_remove_entry (WTree *tree, char *name)
{
    tree_store_remove_entry (name);
}

void tree_destroy (WTree *tree)
{
    tree_store_remove_entry_remove_hook (remove_callback);
    save_tree (tree);
    tree_store_destroy ();
    
    if (tree->tree_shown){
	g_free (tree->tree_shown);
	tree->tree_shown = 0;
    }
    tree->selected_ptr = NULL;
}

/* Loads the .mc.tree file */
void load_tree (WTree *tree)
{
    char *filename;
    int v;
    
    filename = concat_dir_and_file (home_dir, MC_TREE);
    v = tree_store_load (filename);
    g_free (filename);

    tree->selected_ptr = tree->store->tree_first;
    
    tree_chdir (tree, home_dir);
}

/* Save the .mc.tree file */
void save_tree (WTree *tree)
{
    int error;
    char *filename;
    
    filename = concat_dir_and_file (home_dir, MC_TREE);
    error = tree_store_save (filename);
   g_free (filename);

    if (error){
	fprintf (stderr, _("Can't open the %s file for writing:\n%s\n"), MC_TREE,
		 unix_error_string (error));
	return;
    }
}

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)
	g_free (tree->tree_shown);
    tree->tree_shown = g_new (tree_entry*, tree_lines);

    for (i = 0; i < tree_lines; i++)
	tree->tree_shown [i] = NULL;
    if (tree->store->tree_first)
	topsublevel = tree->store->tree_first->sublevel;
    else
	topsublevel = 0;
    if (!tree->selected_ptr){
	tree->selected_ptr = tree->store->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->store->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->store->tree_first;
    tree->topdiff = 0;
}

void tree_move_to_bottom (WTree *tree)
{
    tree->selected_ptr = tree->store->tree_last;
    tree->topdiff = tlines (tree) - 3 - 1;
}

void tree_chdir (WTree *tree, char *dir)
{
    tree_entry *current;

    current = tree_store_whereis (dir);
    if (current){
	tree->selected_ptr = current;
	check_focus (tree);
    }
}

void
sync_tree (char *path)
{
    tree_chdir (the_tree, path);
}

/* 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->store->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)
{
    char old_dir [MC_MAXPATHLEN];

    if (!tree->selected_ptr || !mc_get_current_wd (old_dir, MC_MAXPATHLEN) ||
	mc_chdir (tree->selected_ptr->name))
	return;

    tree_store_rescan (tree->selected_ptr->name);
    mc_chdir (old_dir);
}

int tree_forget_cmd (WTree *tree)
{
    if (tree->selected_ptr)
	tree_remove_entry (tree, tree->selected_ptr->name);
    return 1;
}

void tree_copy (WTree *tree, char *default_dest)
{
    char   *dest;
    long   count = 0;
    double bytes = 0;
    FileOpContext *ctx;
    
    if (!tree->selected_ptr)
	return;
    g_snprintf (cmd_buf, sizeof(cmd_buf), _("Copy \"%s\" directory to:"),
	     name_trunc (tree->selected_ptr->name, 50));
    dest = input_expand_dialog (_(" Copy "), cmd_buf, default_dest);
    if (!dest || !*dest){
	return;
    }

    ctx = file_op_context_new ();
    file_op_context_create_ui (ctx, OP_COPY, FALSE);
    copy_dir_dir (ctx, tree->selected_ptr->name, dest, 1, 0, 0, 0, &count, &bytes);
    file_op_context_destroy (ctx);

    g_free (dest);
}

static void tree_help_cmd (void)
{
    char *hlpfile = concat_dir_and_file (mc_home, "mc.hlp");
    interactive_display (hlpfile,  "[Directory Tree]");
    g_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;
    double bytes = 0;
    long   count = 0;
    FileOpContext *ctx;

    if (!tree->selected_ptr)
	return;
    g_snprintf (cmd_buf, sizeof (cmd_buf), _("Move \"%s\" directory to:"),
	     name_trunc (tree->selected_ptr->name, 50));
    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));
	g_free (dest);
	return;
    }
    if (!S_ISDIR (buf.st_mode)){
	message (1, _(" Error "), _(" The destination isn't a directory "));
	g_free (dest);
	return;
    }

    ctx = file_op_context_new ();
    file_op_context_create_ui (ctx, OP_MOVE, FALSE);
    move_dir_dir (ctx, tree->selected_ptr->name, dest, &count, &bytes);
    file_op_context_destroy (ctx);

    g_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 void
tree_rmdir_cmd (WTree *tree)
{
    char old_dir [MC_MAXPATHLEN];
    long count = 0;
    double bytes = 0;
    FileOpContext *ctx;
    
    if (tree->selected_ptr){
	if (!mc_get_current_wd (old_dir, MC_MAXPATHLEN))
	    return;
	if (mc_chdir (PATH_SEP_STR))
	    return;
	if (confirm_delete){
	    char *buf;
	    int result;

	    buf = g_strdup_printf (_("  Delete %s?  "), tree->selected_ptr->name);
	    result = query_dialog (_(" Delete "), buf, 3, 2, _("&Yes"), _("&No"));
	    g_free (buf);
	    if (result != 0){
		return;
	    }
	}

	ctx = file_op_context_new ();
	file_op_context_create_ui (ctx, OP_DELETE, FALSE);
	if (erase_dir (ctx, tree->selected_ptr->name, &count, &bytes) == FILE_CONT)
	    tree_forget_cmd (tree);
	file_op_context_destroy (ctx);
	mc_chdir (old_dir);
	return;
    } else
	return;
}

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,
		       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, cd_exact)){
	paint_panel (cpanel);
	select_item (cpanel);
    } else {
	message (1, MSG_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)
{
    int i;

    if (tree->searching){
    
	if (tree->selected_ptr == tree->store->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 },
    { KEY_DC,     tree_rmdir_cmd },
    { 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);
	    return 1;
	}
    }

    /* 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)
	return move_right (tree);

    if (is_abort_char (key)) {
	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 */
    }

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

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

    return 0;
}

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;
	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);
#if 0
	/* FIXME: mkdir is currently defunct */
	define_label_data (h, (Widget *)tree, 
	    7, _("Mkdir"),  (buttonbarfn) tree_mkdir_cmd, tree);
#else
        define_label (h, (Widget *)tree, 7, "", 0);
#endif
	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 = g_new (WTree, 1);

    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->store = tree_store_init ();
    tree_store_add_entry_remove_hook (remove_callback, tree);
    tree->tree_shown = 0;
    tree->search_buffer [0] = 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;
}



