src/filemanager/tree.c

   1 /*
   2    Directory tree browser for the Midnight Commander
   3    This module has been converted to be a widget.
   4
   5    The program load and saves the tree each time the tree widget is
   6    created and destroyed.  This is required for the future vfs layer,
   7    it will be possible to have tree views over virtual file systems.
   8
   9    Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
  10    2003, 2004, 2005, 2007, 2011
  11    The Free Software Foundation, Inc.
  12
  13    Written by:
  14    Janne Kukonlehto, 1994, 1996
  15    Norbert Warmuth, 1997
  16    Miguel de Icaza, 1996, 1999
  17
  18    This file is part of the Midnight Commander.
  19
  20    The Midnight Commander is free software: you can redistribute it
  21    and/or modify it under the terms of the GNU General Public License as
  22    published by the Free Software Foundation, either version 3 of the License,
  23    or (at your option) any later version.
  24
  25    The Midnight Commander is distributed in the hope that it will be useful,
  26    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28    GNU General Public License for more details.
  29
  30    You should have received a copy of the GNU General Public License
  31    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  32  */
  33
  34 /** \file tree.c
  35  *  \brief Source: directory tree browser
  36  */
  37
  38 #include <config.h>
  39
  40 #include <errno.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <sys/types.h>
  44
  45 #include "lib/global.h"
  46
  47 #include "lib/tty/tty.h"
  48 #include "lib/tty/mouse.h"
  49 #include "lib/tty/key.h"
  50 #include "lib/skin.h"
  51 #include "lib/vfs/vfs.h"
  52 #include "lib/fileloc.h"
  53 #include "lib/strutil.h"
  54 #include "lib/util.h"
  55 #include "lib/widget.h"
  56 #include "lib/event.h"          /* mc_event_raise() */
  57
  58
  59 #include "src/setup.h"          /* confirm_delete, panels_options */
  60 #include "src/keybind-defaults.h"
  61 #include "src/history.h"
  62
  63 #include "dir.h"
  64 #include "midnight.h"           /* the_menubar */
  65 #include "file.h"               /* copy_dir_dir(), move_dir_dir(), erase_dir() */
  66 #include "layout.h"             /* command_prompt */
  67 #include "treestore.h"
  68 #include "cmd.h"
  69 #include "filegui.h"
  70
  71 #include "tree.h"
  72
  73 /*** global variables ****************************************************************************/
  74
  75 /* The pointer to the tree */
  76 WTree *the_tree = NULL;
  77
  78 /* If this is true, then when browsing the tree the other window will
  79  * automatically reload it's directory with the contents of the currently
  80  * selected directory.
  81  */
  82 int xtree_mode = 0;
  83
  84 /*** file scope macro definitions ****************************************************************/
  85
  86 #define tlines(t) (t->is_panel ? t->widget.lines - 2 - (panels_options.show_mini_info ? 2 : 0) : t->widget.lines)
  87
  88 /* Use the color of the parent widget for the unselected entries */
  89 #define TREE_NORMALC(h) (h->color[DLG_COLOR_NORMAL])
  90 #define TREE_CURRENTC(h) (h->color[DLG_COLOR_FOCUS])
  91
  92 /*** file scope type declarations ****************************************************************/
  93
  94 struct WTree
  95 {
  96     Widget widget;
  97     struct TreeStore *store;
  98     tree_entry *selected_ptr;   /* The selected directory */
  99     char search_buffer[MC_MAXFILENAMELEN];      /* Current search string */
 100     tree_entry **tree_shown;    /* Entries currently on screen */
 101     int is_panel;               /* panel or plain widget flag */
 102     int active;                 /* if it's currently selected */
 103     int searching;              /* Are we on searching mode? */
 104     int topdiff;                /* The difference between the topmost
 105                                    shown and the selected */
 106 };
 107
 108 /*** file scope variables ************************************************************************/
 109
 110 /* Specifies the display mode: 1d or 2d */
 111 static gboolean tree_navigation_flag = FALSE;
 112
 113 /*** file scope functions ************************************************************************/
 114 /* --------------------------------------------------------------------------------------------- */
 115
 116 static void tree_rescan (void *data);
 117
 118 /* --------------------------------------------------------------------------------------------- */
 119
 120 static tree_entry *
 121 back_ptr (tree_entry * ptr, int *count)
 122 {
 123     int i = 0;
 124
 125     while (ptr && ptr->prev && i < *count)
 126     {
 127         ptr = ptr->prev;
 128         i++;
 129     }
 130     *count = i;
 131     return ptr;
 132 }
 133
 134 /* --------------------------------------------------------------------------------------------- */
 135
 136 static tree_entry *
 137 forw_ptr (tree_entry * ptr, int *count)
 138 {
 139     int i = 0;
 140
 141     while (ptr && ptr->next && i < *count)
 142     {
 143         ptr = ptr->next;
 144         i++;
 145     }
 146     *count = i;
 147     return ptr;
 148 }
 149
 150 /* --------------------------------------------------------------------------------------------- */
 151
 152 static void
 153 remove_callback (tree_entry * entry, void *data)
 154 {
 155     WTree *tree = data;
 156
 157     if (tree->selected_ptr == entry)
 158     {
 159         if (tree->selected_ptr->next)
 160             tree->selected_ptr = tree->selected_ptr->next;
 161         else
 162             tree->selected_ptr = tree->selected_ptr->prev;
 163     }
 164 }
 165
 166 /* --------------------------------------------------------------------------------------------- */
 167 /** Save the ${XDG_CACHE_HOME}/mc/Tree file */
 168
 169 static void
 170 save_tree (WTree * tree)
 171 {
 172     int error;
 173     char *tree_name;
 174
 175     (void) tree;
 176     error = tree_store_save ();
 177
 178
 179     if (error)
 180     {
 181         tree_name = mc_config_get_full_path (MC_TREESTORE_FILE);
 182         fprintf (stderr, _("Cannot open the %s file for writing:\n%s\n"), tree_name,
 183                  unix_error_string (error));
 184         g_free (tree_name);
 185     }
 186 }
 187
 188 /* --------------------------------------------------------------------------------------------- */
 189
 190 static void
 191 tree_remove_entry (WTree * tree, char *name)
 192 {
 193     (void) tree;
 194     tree_store_remove_entry (name);
 195 }
 196
 197 /* --------------------------------------------------------------------------------------------- */
 198
 199 static void
 200 tree_destroy (WTree * tree)
 201 {
 202     tree_store_remove_entry_remove_hook (remove_callback);
 203     save_tree (tree);
 204
 205     g_free (tree->tree_shown);
 206     tree->tree_shown = 0;
 207     tree->selected_ptr = NULL;
 208 }
 209
 210 /* --------------------------------------------------------------------------------------------- */
 211 /** Loads the .mc.tree file */
 212
 213 static void
 214 load_tree (WTree * tree)
 215 {
 216     tree_store_load ();
 217
 218     tree->selected_ptr = tree->store->tree_first;
 219     tree_chdir (tree, mc_config_get_home_dir ());
 220 }
 221
 222 /* --------------------------------------------------------------------------------------------- */
 223
 224 static void
 225 tree_show_mini_info (WTree * tree, int tree_lines, int tree_cols)
 226 {
 227     Dlg_head *h = tree->widget.owner;
 228     int line;
 229
 230     /* Show mini info */
 231     if (tree->is_panel)
 232     {
 233         if (!panels_options.show_mini_info)
 234             return;
 235         line = tree_lines + 2;
 236     }
 237     else
 238         line = tree_lines + 1;
 239
 240     if (tree->searching)
 241     {
 242         /* Show search string */
 243         tty_setcolor (INPUT_COLOR);
 244         tty_draw_hline (tree->widget.y + line, tree->widget.x + 1, ' ', tree_cols);
 245         widget_move (&tree->widget, line, 1);
 246         tty_print_char (PATH_SEP);
 247         tty_print_string (str_fit_to_term (tree->search_buffer, tree_cols - 2, J_LEFT_FIT));
 248         tty_print_char (' ');
 249     }
 250     else
 251     {
 252         /* Show full name of selected directory */
 253         tty_setcolor (tree->is_panel ? NORMAL_COLOR : TREE_NORMALC (h));
 254         tty_draw_hline (tree->widget.y + line, tree->widget.x + 1, ' ', tree_cols);
 255         widget_move (&tree->widget, line, 1);
 256         tty_print_string (str_fit_to_term (tree->selected_ptr->name, tree_cols, J_LEFT_FIT));
 257     }
 258 }
 259
 260 /* --------------------------------------------------------------------------------------------- */
 261
 262 static void
 263 show_tree (WTree * tree)
 264 {
 265     Dlg_head *h = tree->widget.owner;
 266     tree_entry *current;
 267     int i, j, topsublevel;
 268     int x = 0, y = 0;
 269     int tree_lines, tree_cols;
 270
 271     /* Initialize */
 272     tree_lines = tlines (tree);
 273     tree_cols = tree->widget.cols;
 274
 275     widget_move ((Widget *) tree, y, x);
 276     if (tree->is_panel)
 277     {
 278         tree_cols -= 2;
 279         x = y = 1;
 280     }
 281
 282     g_free (tree->tree_shown);
 283     tree->tree_shown = g_new0 (tree_entry *, tree_lines);
 284
 285     if (tree->store->tree_first)
 286         topsublevel = tree->store->tree_first->sublevel;
 287     else
 288         topsublevel = 0;
 289     if (!tree->selected_ptr)
 290     {
 291         tree->selected_ptr = tree->store->tree_first;
 292         tree->topdiff = 0;
 293     }
 294     current = tree->selected_ptr;
 295
 296     /* Calculate the directory which is to be shown on the topmost line */
 297     if (!tree_navigation_flag)
 298         current = back_ptr (current, &tree->topdiff);
 299     else
 300     {
 301         i = 0;
 302         while (current->prev && i < tree->topdiff)
 303         {
 304             current = current->prev;
 305             if (current->sublevel < tree->selected_ptr->sublevel)
 306             {
 307                 if (strncmp (current->name, tree->selected_ptr->name, strlen (current->name)) == 0)
 308                     i++;
 309             }
 310             else if (current->sublevel == tree->selected_ptr->sublevel)
 311             {
 312                 for (j = strlen (current->name) - 1; current->name[j] != PATH_SEP; j--);
 313                 if (strncmp (current->name, tree->selected_ptr->name, j) == 0)
 314                     i++;
 315             }
 316             else if (current->sublevel == tree->selected_ptr->sublevel + 1
 317                      && strlen (tree->selected_ptr->name) > 1)
 318             {
 319                 if (strncmp (current->name, tree->selected_ptr->name,
 320                              strlen (tree->selected_ptr->name)) == 0)
 321                     i++;
 322             }
 323         }
 324         tree->topdiff = i;
 325     }
 326
 327     /* Loop for every line */
 328     for (i = 0; i < tree_lines; i++)
 329     {
 330         tty_setcolor (tree->is_panel ? NORMAL_COLOR : TREE_NORMALC (h));
 331
 332         /* Move to the beginning of the line */
 333         tty_draw_hline (tree->widget.y + y + i, tree->widget.x + x, ' ', tree_cols);
 334
 335         if (current == NULL)
 336             continue;
 337
 338         if (tree->is_panel)
 339             tty_setcolor (tree->active && current == tree->selected_ptr
 340                           ? SELECTED_COLOR : NORMAL_COLOR);
 341         else
 342             tty_setcolor (current == tree->selected_ptr ? TREE_CURRENTC (h) : TREE_NORMALC (h));
 343
 344         tree->tree_shown[i] = current;
 345         if (current->sublevel == topsublevel)
 346         {
 347             /* Show full name */
 348             tty_print_string (str_fit_to_term
 349                               (current->name, tree_cols + (tree->is_panel ? 0 : 1), J_LEFT_FIT));
 350         }
 351         else
 352         {
 353             /* Sub level directory */
 354             tty_set_alt_charset (TRUE);
 355
 356             /* Output branch parts */
 357             for (j = 0; j < current->sublevel - topsublevel - 1; j++)
 358             {
 359                 if (tree_cols - 8 - 3 * j < 9)
 360                     break;
 361                 tty_print_char (' ');
 362                 if (current->submask & (1 << (j + topsublevel + 1)))
 363                     tty_print_char (ACS_VLINE);
 364                 else
 365                     tty_print_char (' ');
 366                 tty_print_char (' ');
 367             }
 368             tty_print_char (' ');
 369             j++;
 370             if (!current->next || !(current->next->submask & (1 << current->sublevel)))
 371                 tty_print_char (ACS_LLCORNER);
 372             else
 373                 tty_print_char (ACS_LTEE);
 374             tty_print_char (ACS_HLINE);
 375             tty_set_alt_charset (FALSE);
 376
 377             /* Show sub-name */
 378             tty_print_char (' ');
 379             tty_print_string (str_fit_to_term
 380                               (current->subname, tree_cols - x - 3 * j, J_LEFT_FIT));
 381         }
 382
 383         /* Calculate the next value for current */
 384         current = current->next;
 385         if (tree_navigation_flag)
 386         {
 387             while (current != NULL)
 388             {
 389                 if (current->sublevel < tree->selected_ptr->sublevel)
 390                 {
 391                     if (strncmp (current->name, tree->selected_ptr->name,
 392                                  strlen (current->name)) == 0)
 393                         break;
 394                 }
 395                 else if (current->sublevel == tree->selected_ptr->sublevel)
 396                 {
 397                     for (j = strlen (current->name) - 1; current->name[j] != PATH_SEP; j--)
 398                         ;
 399                     if (strncmp (current->name, tree->selected_ptr->name, j) == 0)
 400                         break;
 401                 }
 402                 else if (current->sublevel == tree->selected_ptr->sublevel + 1
 403                          && strlen (tree->selected_ptr->name) > 1)
 404                 {
 405                     if (strncmp (current->name, tree->selected_ptr->name,
 406                                  strlen (tree->selected_ptr->name)) == 0)
 407                         break;
 408                 }
 409                 current = current->next;
 410             }
 411         }
 412     }
 413
 414     tree_show_mini_info (tree, tree_lines, tree_cols);
 415 }
 416
 417 /* --------------------------------------------------------------------------------------------- */
 418
 419 static void
 420 tree_check_focus (WTree * tree)
 421 {
 422     if (tree->topdiff < 3)
 423         tree->topdiff = 3;
 424     else if (tree->topdiff >= tlines (tree) - 3)
 425         tree->topdiff = tlines (tree) - 3 - 1;
 426 }
 427
 428 /* --------------------------------------------------------------------------------------------- */
 429
 430 static void
 431 tree_move_backward (WTree * tree, int i)
 432 {
 433     if (!tree_navigation_flag)
 434         tree->selected_ptr = back_ptr (tree->selected_ptr, &i);
 435     else
 436     {
 437         tree_entry *current;
 438         int j = 0;
 439
 440         current = tree->selected_ptr;
 441         while (j < i && current->prev && current->prev->sublevel >= tree->selected_ptr->sublevel)
 442         {
 443             current = current->prev;
 444             if (current->sublevel == tree->selected_ptr->sublevel)
 445             {
 446                 tree->selected_ptr = current;
 447                 j++;
 448             }
 449         }
 450         i = j;
 451     }
 452
 453     tree->topdiff -= i;
 454     tree_check_focus (tree);
 455 }
 456
 457 /* --------------------------------------------------------------------------------------------- */
 458
 459 static void
 460 tree_move_forward (WTree * tree, int i)
 461 {
 462     if (!tree_navigation_flag)
 463         tree->selected_ptr = forw_ptr (tree->selected_ptr, &i);
 464     else
 465     {
 466         tree_entry *current;
 467         int j = 0;
 468
 469         current = tree->selected_ptr;
 470         while (j < i && current->next && current->next->sublevel >= tree->selected_ptr->sublevel)
 471         {
 472             current = current->next;
 473             if (current->sublevel == tree->selected_ptr->sublevel)
 474             {
 475                 tree->selected_ptr = current;
 476                 j++;
 477             }
 478         }
 479         i = j;
 480     }
 481
 482     tree->topdiff += i;
 483     tree_check_focus (tree);
 484 }
 485
 486 /* --------------------------------------------------------------------------------------------- */
 487
 488 static void
 489 tree_move_to_child (WTree * tree)
 490 {
 491     tree_entry *current;
 492
 493     /* Do we have a starting point? */
 494     if (!tree->selected_ptr)
 495         return;
 496     /* Take the next entry */
 497     current = tree->selected_ptr->next;
 498     /* Is it the child of the selected entry */
 499     if (current && current->sublevel > tree->selected_ptr->sublevel)
 500     {
 501         /* Yes -> select this entry */
 502         tree->selected_ptr = current;
 503         tree->topdiff++;
 504         tree_check_focus (tree);
 505     }
 506     else
 507     {
 508         /* No -> rescan and try again */
 509         tree_rescan (tree);
 510         current = tree->selected_ptr->next;
 511         if (current && current->sublevel > tree->selected_ptr->sublevel)
 512         {
 513             tree->selected_ptr = current;
 514             tree->topdiff++;
 515             tree_check_focus (tree);
 516         }
 517     }
 518 }
 519
 520 /* --------------------------------------------------------------------------------------------- */
 521
 522 static gboolean
 523 tree_move_to_parent (WTree * tree)
 524 {
 525     tree_entry *current;
 526     tree_entry *old;
 527
 528     if (!tree->selected_ptr)
 529         return FALSE;
 530
 531     old = tree->selected_ptr;
 532     current = tree->selected_ptr->prev;
 533     while (current && current->sublevel >= tree->selected_ptr->sublevel)
 534     {
 535         current = current->prev;
 536         tree->topdiff--;
 537     }
 538     if (!current)
 539         current = tree->store->tree_first;
 540     tree->selected_ptr = current;
 541     tree_check_focus (tree);
 542     return tree->selected_ptr != old;
 543 }
 544
 545 /* --------------------------------------------------------------------------------------------- */
 546
 547 static void
 548 tree_move_to_top (WTree * tree)
 549 {
 550     tree->selected_ptr = tree->store->tree_first;
 551     tree->topdiff = 0;
 552 }
 553
 554 /* --------------------------------------------------------------------------------------------- */
 555
 556 static void
 557 tree_move_to_bottom (WTree * tree)
 558 {
 559     tree->selected_ptr = tree->store->tree_last;
 560     tree->topdiff = tlines (tree) - 3 - 1;
 561 }
 562
 563 /* --------------------------------------------------------------------------------------------- */
 564 /** Handle mouse click */
 565
 566 static void
 567 tree_event (WTree * tree, int y)
 568 {
 569     if (tree->tree_shown[y])
 570     {
 571         tree->selected_ptr = tree->tree_shown[y];
 572         tree->topdiff = y;
 573     }
 574     show_tree (tree);
 575 }
 576
 577 /* --------------------------------------------------------------------------------------------- */
 578
 579 static void
 580 tree_chdir_sel (WTree * tree)
 581 {
 582     if (!tree->is_panel)
 583         return;
 584
 585     change_panel ();
 586
 587     if (do_cd (tree->selected_ptr->name, cd_exact))
 588         select_item (current_panel);
 589     else
 590         message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\"\n%s"),
 591                  tree->selected_ptr->name, unix_error_string (errno));
 592
 593     change_panel ();
 594     show_tree (tree);
 595 }
 596
 597 /* --------------------------------------------------------------------------------------------- */
 598
 599 static void
 600 maybe_chdir (WTree * tree)
 601 {
 602     if (xtree_mode && tree->is_panel && is_idle ())
 603         tree_chdir_sel (tree);
 604 }
 605
 606 /* --------------------------------------------------------------------------------------------- */
 607 /** Mouse callback */
 608
 609 static int
 610 event_callback (Gpm_Event * event, void *data)
 611 {
 612     WTree *tree = data;
 613
 614     /* rest of the upper frame, the menu is invisible - call menu */
 615     if (tree->is_panel && (event->type & GPM_DOWN) && event->y == 1 && !menubar_visible)
 616     {
 617         event->x += tree->widget.x;
 618         return the_menubar->widget.mouse (event, the_menubar);
 619     }
 620
 621     if (!(event->type & GPM_UP))
 622         return MOU_NORMAL;
 623
 624     if (tree->is_panel)
 625         event->y--;
 626
 627     event->y--;
 628
 629     if (!tree->active)
 630         change_panel ();
 631
 632     if (event->y < 0)
 633     {
 634         tree_move_backward (tree, tlines (tree) - 1);
 635         show_tree (tree);
 636     }
 637     else if (event->y >= tlines (tree))
 638     {
 639         tree_move_forward (tree, tlines (tree) - 1);
 640         show_tree (tree);
 641     }
 642     else
 643     {
 644         tree_event (tree, event->y);
 645         if ((event->type & (GPM_UP | GPM_DOUBLE)) == (GPM_UP | GPM_DOUBLE))
 646         {
 647             tree_chdir_sel (tree);
 648         }
 649     }
 650     return MOU_NORMAL;
 651 }
 652
 653 /* --------------------------------------------------------------------------------------------- */
 654 /** Search tree for text */
 655
 656 static int
 657 search_tree (WTree * tree, char *text)
 658 {
 659     tree_entry *current;
 660     int len;
 661     int wrapped = 0;
 662     int found = 0;
 663
 664     len = strlen (text);
 665     current = tree->selected_ptr;
 666     found = 0;
 667     while (!wrapped || current != tree->selected_ptr)
 668     {
 669         if (strncmp (current->subname, text, len) == 0)
 670         {
 671             tree->selected_ptr = current;
 672             found = 1;
 673             break;
 674         }
 675         current = current->next;
 676         if (!current)
 677         {
 678             current = tree->store->tree_first;
 679             wrapped = 1;
 680         }
 681         tree->topdiff++;
 682     }
 683     tree_check_focus (tree);
 684     return found;
 685 }
 686
 687 /* --------------------------------------------------------------------------------------------- */
 688
 689 static void
 690 tree_do_search (WTree * tree, int key)
 691 {
 692     size_t l;
 693
 694     l = strlen (tree->search_buffer);
 695     if ((l != 0) && (key == KEY_BACKSPACE))
 696         tree->search_buffer[--l] = '\0';
 697     else if (key && l < sizeof (tree->search_buffer))
 698     {
 699         tree->search_buffer[l] = key;
 700         tree->search_buffer[++l] = '\0';
 701     }
 702
 703     if (!search_tree (tree, tree->search_buffer))
 704         tree->search_buffer[--l] = 0;
 705
 706     show_tree (tree);
 707     maybe_chdir (tree);
 708 }
 709
 710 /* --------------------------------------------------------------------------------------------- */
 711
 712 static void
 713 tree_rescan (void *data)
 714 {
 715     WTree *tree = data;
 716     char old_dir[MC_MAXPATHLEN];
 717     vfs_path_t *vpath;
 718     int ret;
 719
 720     if (tree->selected_ptr == NULL || mc_get_current_wd (old_dir, MC_MAXPATHLEN) == NULL)
 721         return;
 722
 723     vpath = vfs_path_from_str (tree->selected_ptr->name);
 724     if (mc_chdir (vpath) != 0)
 725     {
 726         vfs_path_free (vpath);
 727         return;
 728     }
 729
 730     tree_store_rescan (vpath);
 731     vpath = vfs_path_from_str (old_dir);
 732     ret = mc_chdir (vpath);
 733     vfs_path_free (vpath);
 734 }
 735
 736 /* --------------------------------------------------------------------------------------------- */
 737
 738 static void
 739 tree_forget (void *data)
 740 {
 741     WTree *tree = data;
 742     if (tree->selected_ptr)
 743         tree_remove_entry (tree, tree->selected_ptr->name);
 744 }
 745
 746 /* --------------------------------------------------------------------------------------------- */
 747
 748 static void
 749 tree_copy (WTree * tree, const char *default_dest)
 750 {
 751     char msg[BUF_MEDIUM];
 752     char *dest;
 753
 754     if (tree->selected_ptr == NULL)
 755         return;
 756
 757     g_snprintf (msg, sizeof (msg), _("Copy \"%s\" directory to:"),
 758                 str_trunc (tree->selected_ptr->name, 50));
 759     dest = input_expand_dialog (Q_ ("DialogTitle|Copy"),
 760                                 msg, MC_HISTORY_FM_TREE_COPY, default_dest);
 761
 762     if (dest != NULL && *dest != '\0')
 763     {
 764         FileOpContext *ctx;
 765         FileOpTotalContext *tctx;
 766
 767         ctx = file_op_context_new (OP_COPY);
 768         tctx = file_op_total_context_new ();
 769         file_op_context_create_ui (ctx, FALSE, FILEGUI_DIALOG_MULTI_ITEM);
 770         tctx->ask_overwrite = FALSE;
 771         copy_dir_dir (tctx, ctx, tree->selected_ptr->name, dest, TRUE, FALSE, FALSE, NULL);
 772         file_op_total_context_destroy (tctx);
 773         file_op_context_destroy (ctx);
 774     }
 775
 776     g_free (dest);
 777 }
 778
 779 /* --------------------------------------------------------------------------------------------- */
 780
 781 static void
 782 tree_move (WTree * tree, const char *default_dest)
 783 {
 784     char msg[BUF_MEDIUM];
 785     char *dest;
 786     struct stat buf;
 787     FileOpContext *ctx;
 788     FileOpTotalContext *tctx;
 789
 790     if (tree->selected_ptr == NULL)
 791         return;
 792
 793     g_snprintf (msg, sizeof (msg), _("Move \"%s\" directory to:"),
 794                 str_trunc (tree->selected_ptr->name, 50));
 795     dest =
 796         input_expand_dialog (Q_ ("DialogTitle|Move"), msg, MC_HISTORY_FM_TREE_MOVE, default_dest);
 797
 798     if (dest == NULL || *dest == '\0')
 799     {
 800         g_free (dest);
 801         return;
 802     }
 803
 804     if (stat (dest, &buf))
 805     {
 806         message (D_ERROR, MSG_ERROR, _("Cannot stat the destination\n%s"),
 807                  unix_error_string (errno));
 808         g_free (dest);
 809         return;
 810     }
 811
 812     if (!S_ISDIR (buf.st_mode))
 813     {
 814         file_error (_("Destination \"%s\" must be a directory\n%s"), dest);
 815         g_free (dest);
 816         return;
 817     }
 818
 819     ctx = file_op_context_new (OP_MOVE);
 820     tctx = file_op_total_context_new ();
 821     file_op_context_create_ui (ctx, FALSE, FILEGUI_DIALOG_ONE_ITEM);
 822     move_dir_dir (tctx, ctx, tree->selected_ptr->name, dest);
 823     file_op_total_context_destroy (tctx);
 824     file_op_context_destroy (ctx);
 825
 826     g_free (dest);
 827 }
 828
 829 /* --------------------------------------------------------------------------------------------- */
 830
 831 #if 0
 832 static void
 833 tree_mkdir (WTree * tree)
 834 {
 835     char old_dir[MC_MAXPATHLEN];
 836
 837     if (!tree->selected_ptr)
 838         return;
 839     if (mc_get_current_wd (old_dir, MC_MAXPATHLEN) == NULL)
 840         return;
 841     if (chdir (tree->selected_ptr->name))
 842         return;
 843     /* FIXME
 844        mkdir_cmd (tree);
 845      */
 846     tree_rescan (tree);
 847     chdir (old_dir);
 848 }
 849 #endif
 850
 851 /* --------------------------------------------------------------------------------------------- */
 852
 853 static void
 854 tree_rmdir (void *data)
 855 {
 856     WTree *tree = data;
 857     FileOpContext *ctx;
 858     FileOpTotalContext *tctx;
 859
 860     if (!tree->selected_ptr)
 861         return;
 862
 863     if (confirm_delete)
 864     {
 865         char *buf;
 866         int result;
 867
 868         buf = g_strdup_printf (_("Delete %s?"), tree->selected_ptr->name);
 869         result = query_dialog (Q_ ("DialogTitle|Delete"), buf, D_ERROR, 2, _("&Yes"), _("&No"));
 870         g_free (buf);
 871         if (result != 0)
 872             return;
 873     }
 874
 875     ctx = file_op_context_new (OP_DELETE);
 876     tctx = file_op_total_context_new ();
 877
 878     file_op_context_create_ui (ctx, FALSE, FILEGUI_DIALOG_ONE_ITEM);
 879     if (erase_dir (tctx, ctx, tree->selected_ptr->name) == FILE_CONT)
 880         tree_forget (tree);
 881     file_op_total_context_destroy (tctx);
 882     file_op_context_destroy (ctx);
 883 }
 884
 885 /* --------------------------------------------------------------------------------------------- */
 886
 887 static inline void
 888 tree_move_up (WTree * tree)
 889 {
 890     tree_move_backward (tree, 1);
 891     show_tree (tree);
 892     maybe_chdir (tree);
 893 }
 894
 895 /* --------------------------------------------------------------------------------------------- */
 896
 897 static inline void
 898 tree_move_down (WTree * tree)
 899 {
 900     tree_move_forward (tree, 1);
 901     show_tree (tree);
 902     maybe_chdir (tree);
 903 }
 904
 905 /* --------------------------------------------------------------------------------------------- */
 906
 907 static inline void
 908 tree_move_home (WTree * tree)
 909 {
 910     tree_move_to_top (tree);
 911     show_tree (tree);
 912     maybe_chdir (tree);
 913 }
 914
 915 /* --------------------------------------------------------------------------------------------- */
 916
 917 static inline void
 918 tree_move_end (WTree * tree)
 919 {
 920     tree_move_to_bottom (tree);
 921     show_tree (tree);
 922     maybe_chdir (tree);
 923 }
 924
 925 /* --------------------------------------------------------------------------------------------- */
 926
 927 static void
 928 tree_move_pgup (WTree * tree)
 929 {
 930     tree_move_backward (tree, tlines (tree) - 1);
 931     show_tree (tree);
 932     maybe_chdir (tree);
 933 }
 934
 935 /* --------------------------------------------------------------------------------------------- */
 936
 937 static void
 938 tree_move_pgdn (WTree * tree)
 939 {
 940     tree_move_forward (tree, tlines (tree) - 1);
 941     show_tree (tree);
 942     maybe_chdir (tree);
 943 }
 944
 945 /* --------------------------------------------------------------------------------------------- */
 946
 947 static gboolean
 948 tree_move_left (WTree * tree)
 949 {
 950     gboolean v = FALSE;
 951
 952     if (tree_navigation_flag)
 953     {
 954         v = tree_move_to_parent (tree);
 955         show_tree (tree);
 956         maybe_chdir (tree);
 957     }
 958
 959     return v;
 960 }
 961
 962 /* --------------------------------------------------------------------------------------------- */
 963
 964 static gboolean
 965 tree_move_right (WTree * tree)
 966 {
 967     gboolean v = FALSE;
 968
 969     if (tree_navigation_flag)
 970     {
 971         tree_move_to_child (tree);
 972         show_tree (tree);
 973         maybe_chdir (tree);
 974         v = TRUE;
 975     }
 976
 977     return v;
 978 }
 979
 980 /* --------------------------------------------------------------------------------------------- */
 981
 982 static void
 983 tree_start_search (WTree * tree)
 984 {
 985     gboolean i;
 986
 987     if (tree->searching)
 988     {
 989         if (tree->selected_ptr == tree->store->tree_last)
 990             tree_move_to_top (tree);
 991         else
 992         {
 993             /* set navigation mode temporarily to 'Static' because in
 994              * dynamic navigation mode tree_move_forward will not move
 995              * to a lower sublevel if necessary (sequent searches must
 996              * start with the directory followed the last found directory)
 997              */
 998             i = tree_navigation_flag;
 999             tree_navigation_flag = 0;
1000             tree_move_forward (tree, 1);
1001             tree_navigation_flag = i;
1002         }
1003         tree_do_search (tree, 0);
1004     }
1005     else
1006     {
1007         tree->searching = 1;
1008         tree->search_buffer[0] = 0;
1009     }
1010 }
1011
1012 /* --------------------------------------------------------------------------------------------- */
1013
1014 static void
1015 tree_toggle_navig (WTree * tree)
1016 {
1017     tree_navigation_flag = !tree_navigation_flag;
1018     buttonbar_set_label (find_buttonbar (tree->widget.owner), 4,
1019                          tree_navigation_flag ? Q_ ("ButtonBar|Static")
1020                          : Q_ ("ButtonBar|Dynamc"), tree_map, (Widget *) tree);
1021 }
1022
1023 /* --------------------------------------------------------------------------------------------- */
1024
1025 static cb_ret_t
1026 tree_execute_cmd (WTree * tree, unsigned long command)
1027 {
1028     cb_ret_t res = MSG_HANDLED;
1029
1030     if (command != CK_Search)
1031         tree->searching = 0;
1032
1033     switch (command)
1034     {
1035     case CK_Help:
1036         {
1037             ev_help_t event_data = { NULL, "[Directory Tree]" };
1038             mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
1039         }
1040         break;
1041     case CK_Forget:
1042         tree_forget (tree);
1043         break;
1044     case CK_ToggleNavigation:
1045         tree_toggle_navig (tree);
1046         break;
1047     case CK_Copy:
1048         tree_copy (tree, "");
1049         break;
1050     case CK_Move:
1051         tree_move (tree, "");
1052         break;
1053     case CK_Up:
1054         tree_move_up (tree);
1055         break;
1056     case CK_Down:
1057         tree_move_down (tree);
1058         break;
1059     case CK_Top:
1060         tree_move_home (tree);
1061         break;
1062     case CK_Bottom:
1063         tree_move_end (tree);
1064         break;
1065     case CK_PageUp:
1066         tree_move_pgup (tree);
1067         break;
1068     case CK_PageDown:
1069         tree_move_pgdn (tree);
1070         break;
1071     case CK_Enter:
1072         tree_chdir_sel (tree);
1073         break;
1074     case CK_Reread:
1075         tree_rescan (tree);
1076         break;
1077     case CK_Search:
1078         tree_start_search (tree);
1079         break;
1080     case CK_Delete:
1081         tree_rmdir (tree);
1082         break;
1083     case CK_Cancel:
1084         /* don't close tree due to SIGINT */
1085         break;
1086     default:
1087         res = MSG_NOT_HANDLED;
1088     }
1089
1090     show_tree (tree);
1091
1092     return res;
1093 }
1094
1095 /* --------------------------------------------------------------------------------------------- */
1096
1097 static cb_ret_t
1098 tree_key (WTree * tree, int key)
1099 {
1100     size_t i;
1101
1102     if (is_abort_char (key))
1103     {
1104         if (tree->is_panel)
1105         {
1106             tree->searching = 0;
1107             show_tree (tree);
1108             return MSG_HANDLED; /* eat abort char */
1109         }
1110         /* modal tree dialog: let upper layer see the
1111            abort character and close the dialog */
1112         return MSG_NOT_HANDLED;
1113     }
1114
1115     if (tree->searching && ((key >= ' ' && key <= 255) || key == KEY_BACKSPACE))
1116     {
1117         tree_do_search (tree, key);
1118         show_tree (tree);
1119         return MSG_HANDLED;
1120     }
1121
1122     for (i = 0; tree_map[i].key != 0; i++)
1123         if (key == tree_map[i].key)
1124             switch (tree_map[i].command)
1125             {
1126             case CK_Left:
1127                 return tree_move_left (tree) ? MSG_HANDLED : MSG_NOT_HANDLED;
1128             case CK_Right:
1129                 return tree_move_right (tree) ? MSG_HANDLED : MSG_NOT_HANDLED;
1130             default:
1131                 tree_execute_cmd (tree, tree_map[i].command);
1132                 return MSG_HANDLED;
1133             }
1134
1135     /* Do not eat characters not meant for the tree below ' ' (e.g. C-l). */
1136     if (!command_prompt && ((key >= ' ' && key <= 255) || key == KEY_BACKSPACE))
1137     {
1138         tree_start_search (tree);
1139         tree_do_search (tree, key);
1140         return MSG_HANDLED;
1141     }
1142
1143     return MSG_NOT_HANDLED;
1144 }
1145
1146 /* --------------------------------------------------------------------------------------------- */
1147
1148 static void
1149 tree_frame (Dlg_head * h, WTree * tree)
1150 {
1151     tty_setcolor (NORMAL_COLOR);
1152     widget_erase ((Widget *) tree);
1153     if (tree->is_panel)
1154     {
1155         const char *title = _("Directory tree");
1156         const int len = str_term_width1 (title);
1157
1158         draw_box (h, tree->widget.y, tree->widget.x, tree->widget.lines, tree->widget.cols, FALSE);
1159
1160         widget_move (&tree->widget, 0, (tree->widget.cols - len - 2) / 2);
1161         tty_printf (" %s ", title);
1162
1163         if (panels_options.show_mini_info)
1164             widget_move (&tree->widget, tlines (tree) + 1, 0);
1165         tty_print_alt_char (ACS_LTEE, FALSE);
1166         widget_move (&tree->widget, tlines (tree) + 1, tree->widget.cols - 1);
1167         tty_print_alt_char (ACS_RTEE, FALSE);
1168         tty_draw_hline (tree->widget.y + tlines (tree) + 1,
1169                         tree->widget.x + 1, ACS_HLINE, tree->widget.cols - 2);
1170     }
1171 }
1172
1173 /* --------------------------------------------------------------------------------------------- */
1174
1175 static cb_ret_t
1176 tree_callback (Widget * w, widget_msg_t msg, int parm)
1177 {
1178     WTree *tree = (WTree *) w;
1179     Dlg_head *h = tree->widget.owner;
1180     WButtonBar *b = find_buttonbar (h);
1181
1182     switch (msg)
1183     {
1184     case WIDGET_DRAW:
1185         tree_frame (h, tree);
1186         show_tree (tree);
1187         return MSG_HANDLED;
1188
1189     case WIDGET_FOCUS:
1190         tree->active = 1;
1191         buttonbar_set_label (b, 1, Q_ ("ButtonBar|Help"), tree_map, (Widget *) tree);
1192         buttonbar_set_label (b, 2, Q_ ("ButtonBar|Rescan"), tree_map, (Widget *) tree);
1193         buttonbar_set_label (b, 3, Q_ ("ButtonBar|Forget"), tree_map, (Widget *) tree);
1194         buttonbar_set_label (b, 4, tree_navigation_flag ? Q_ ("ButtonBar|Static")
1195                              : Q_ ("ButtonBar|Dynamc"), tree_map, (Widget *) tree);
1196         buttonbar_set_label (b, 5, Q_ ("ButtonBar|Copy"), tree_map, (Widget *) tree);
1197         buttonbar_set_label (b, 6, Q_ ("ButtonBar|RenMov"), tree_map, (Widget *) tree);
1198 #if 0
1199         /* FIXME: mkdir is currently defunct */
1200         buttonbar_set_label (b, 7, Q_ ("ButtonBar|Mkdir"), tree_map, (Widget *) tree);
1201 #else
1202         buttonbar_clear_label (b, 7, (Widget *) tree);
1203 #endif
1204         buttonbar_set_label (b, 8, Q_ ("ButtonBar|Rmdir"), tree_map, (Widget *) tree);
1205         buttonbar_redraw (b);
1206
1207         /* FIXME: Should find a better way of only displaying the
1208            currently selected item */
1209         show_tree (tree);
1210         return MSG_HANDLED;
1211
1212         /* FIXME: Should find a better way of changing the color of the
1213            selected item */
1214
1215     case WIDGET_UNFOCUS:
1216         tree->active = 0;
1217         tree->searching = 0;
1218         show_tree (tree);
1219         return MSG_HANDLED;
1220
1221     case WIDGET_KEY:
1222         return tree_key (tree, parm);
1223
1224     case WIDGET_COMMAND:
1225         /* command from buttonbar */
1226         return tree_execute_cmd (tree, parm);
1227
1228     case WIDGET_DESTROY:
1229         tree_destroy (tree);
1230         return MSG_HANDLED;
1231
1232     default:
1233         return default_proc (msg, parm);
1234     }
1235 }
1236
1237 /* --------------------------------------------------------------------------------------------- */
1238 /*** public functions ****************************************************************************/
1239 /* --------------------------------------------------------------------------------------------- */
1240
1241 WTree *
1242 tree_new (int y, int x, int lines, int cols, gboolean is_panel)
1243 {
1244     WTree *tree = g_new (WTree, 1);
1245
1246     init_widget (&tree->widget, y, x, lines, cols, tree_callback, event_callback);
1247     tree->is_panel = is_panel;
1248     tree->selected_ptr = 0;
1249
1250     tree->store = tree_store_get ();
1251     tree_store_add_entry_remove_hook (remove_callback, tree);
1252     tree->tree_shown = 0;
1253     tree->search_buffer[0] = 0;
1254     tree->topdiff = tree->widget.lines / 2;
1255     tree->searching = 0;
1256     tree->active = 0;
1257
1258     /* We do not want to keep the cursor */
1259     widget_want_cursor (tree->widget, 0);
1260     load_tree (tree);
1261     return tree;
1262 }
1263
1264 /* --------------------------------------------------------------------------------------------- */
1265
1266 void
1267 tree_chdir (WTree * tree, const char *dir)
1268 {
1269     tree_entry *current;
1270
1271     current = tree_store_whereis (dir);
1272
1273     if (current != NULL)
1274     {
1275         tree->selected_ptr = current;
1276         tree_check_focus (tree);
1277     }
1278 }
1279
1280 /* --------------------------------------------------------------------------------------------- */
1281 /** Return name of the currently selected entry */
1282
1283 char *
1284 tree_selected_name (const WTree * tree)
1285 {
1286     return tree->selected_ptr->name;
1287 }
1288
1289 /* --------------------------------------------------------------------------------------------- */
1290
1291 void
1292 sync_tree (const char *path)
1293 {
1294     tree_chdir (the_tree, path);
1295 }
1296
1297 /* --------------------------------------------------------------------------------------------- */
1298
1299 WTree *
1300 find_tree (struct Dlg_head *h)
1301 {
1302     return (WTree *) find_widget_type (h, tree_callback);
1303 }
1304
1305 /* --------------------------------------------------------------------------------------------- */