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     char old_dir[MC_MAXPATHLEN];
 716     WTree *tree = data;
 717     int ret;
 718
 719     if (tree->selected_ptr == NULL || mc_get_current_wd (old_dir, MC_MAXPATHLEN) == NULL
 720         || mc_chdir (tree->selected_ptr->name))
 721         return;
 722
 723     tree_store_rescan (tree->selected_ptr->name);
 724     ret = mc_chdir (old_dir);
 725 }
 726
 727 /* --------------------------------------------------------------------------------------------- */
 728
 729 static void
 730 tree_forget (void *data)
 731 {
 732     WTree *tree = data;
 733     if (tree->selected_ptr)
 734         tree_remove_entry (tree, tree->selected_ptr->name);
 735 }
 736
 737 /* --------------------------------------------------------------------------------------------- */
 738
 739 static void
 740 tree_copy (WTree * tree, const char *default_dest)
 741 {
 742     char msg[BUF_MEDIUM];
 743     char *dest;
 744
 745     if (tree->selected_ptr == NULL)
 746         return;
 747
 748     g_snprintf (msg, sizeof (msg), _("Copy \"%s\" directory to:"),
 749                 str_trunc (tree->selected_ptr->name, 50));
 750     dest = input_expand_dialog (Q_ ("DialogTitle|Copy"),
 751                                 msg, MC_HISTORY_FM_TREE_COPY, default_dest);
 752
 753     if (dest != NULL && *dest != '\0')
 754     {
 755         FileOpContext *ctx;
 756         FileOpTotalContext *tctx;
 757
 758         ctx = file_op_context_new (OP_COPY);
 759         tctx = file_op_total_context_new ();
 760         file_op_context_create_ui (ctx, FALSE, FILEGUI_DIALOG_MULTI_ITEM);
 761         tctx->ask_overwrite = FALSE;
 762         tctx->is_toplevel_file = FALSE;
 763         copy_dir_dir (tctx, ctx, tree->selected_ptr->name, dest, TRUE, FALSE, FALSE, NULL);
 764         file_op_total_context_destroy (tctx);
 765         file_op_context_destroy (ctx);
 766     }
 767
 768     g_free (dest);
 769 }
 770
 771 /* --------------------------------------------------------------------------------------------- */
 772
 773 static void
 774 tree_move (WTree * tree, const char *default_dest)
 775 {
 776     char msg[BUF_MEDIUM];
 777     char *dest;
 778     struct stat buf;
 779     FileOpContext *ctx;
 780     FileOpTotalContext *tctx;
 781
 782     if (tree->selected_ptr == NULL)
 783         return;
 784
 785     g_snprintf (msg, sizeof (msg), _("Move \"%s\" directory to:"),
 786                 str_trunc (tree->selected_ptr->name, 50));
 787     dest =
 788         input_expand_dialog (Q_ ("DialogTitle|Move"), msg, MC_HISTORY_FM_TREE_MOVE, default_dest);
 789
 790     if (dest == NULL || *dest == '\0')
 791     {
 792         g_free (dest);
 793         return;
 794     }
 795
 796     if (stat (dest, &buf))
 797     {
 798         message (D_ERROR, MSG_ERROR, _("Cannot stat the destination\n%s"),
 799                  unix_error_string (errno));
 800         g_free (dest);
 801         return;
 802     }
 803
 804     if (!S_ISDIR (buf.st_mode))
 805     {
 806         file_error (_("Destination \"%s\" must be a directory\n%s"), dest);
 807         g_free (dest);
 808         return;
 809     }
 810
 811     ctx = file_op_context_new (OP_MOVE);
 812     tctx = file_op_total_context_new ();
 813     file_op_context_create_ui (ctx, FALSE, FILEGUI_DIALOG_ONE_ITEM);
 814     move_dir_dir (tctx, ctx, tree->selected_ptr->name, dest);
 815     file_op_total_context_destroy (tctx);
 816     file_op_context_destroy (ctx);
 817
 818     g_free (dest);
 819 }
 820
 821 /* --------------------------------------------------------------------------------------------- */
 822
 823 #if 0
 824 static void
 825 tree_mkdir (WTree * tree)
 826 {
 827     char old_dir[MC_MAXPATHLEN];
 828
 829     if (!tree->selected_ptr)
 830         return;
 831     if (mc_get_current_wd (old_dir, MC_MAXPATHLEN) == NULL)
 832         return;
 833     if (chdir (tree->selected_ptr->name))
 834         return;
 835     /* FIXME
 836        mkdir_cmd (tree);
 837      */
 838     tree_rescan (tree);
 839     chdir (old_dir);
 840 }
 841 #endif
 842
 843 /* --------------------------------------------------------------------------------------------- */
 844
 845 static void
 846 tree_rmdir (void *data)
 847 {
 848     WTree *tree = data;
 849     FileOpContext *ctx;
 850     FileOpTotalContext *tctx;
 851
 852     if (!tree->selected_ptr)
 853         return;
 854
 855     if (confirm_delete)
 856     {
 857         char *buf;
 858         int result;
 859
 860         buf = g_strdup_printf (_("Delete %s?"), tree->selected_ptr->name);
 861         result = query_dialog (Q_ ("DialogTitle|Delete"), buf, D_ERROR, 2, _("&Yes"), _("&No"));
 862         g_free (buf);
 863         if (result != 0)
 864             return;
 865     }
 866
 867     ctx = file_op_context_new (OP_DELETE);
 868     tctx = file_op_total_context_new ();
 869
 870     file_op_context_create_ui (ctx, FALSE, FILEGUI_DIALOG_ONE_ITEM);
 871     if (erase_dir (tctx, ctx, tree->selected_ptr->name) == FILE_CONT)
 872         tree_forget (tree);
 873     file_op_total_context_destroy (tctx);
 874     file_op_context_destroy (ctx);
 875 }
 876
 877 /* --------------------------------------------------------------------------------------------- */
 878
 879 static inline void
 880 tree_move_up (WTree * tree)
 881 {
 882     tree_move_backward (tree, 1);
 883     show_tree (tree);
 884     maybe_chdir (tree);
 885 }
 886
 887 /* --------------------------------------------------------------------------------------------- */
 888
 889 static inline void
 890 tree_move_down (WTree * tree)
 891 {
 892     tree_move_forward (tree, 1);
 893     show_tree (tree);
 894     maybe_chdir (tree);
 895 }
 896
 897 /* --------------------------------------------------------------------------------------------- */
 898
 899 static inline void
 900 tree_move_home (WTree * tree)
 901 {
 902     tree_move_to_top (tree);
 903     show_tree (tree);
 904     maybe_chdir (tree);
 905 }
 906
 907 /* --------------------------------------------------------------------------------------------- */
 908
 909 static inline void
 910 tree_move_end (WTree * tree)
 911 {
 912     tree_move_to_bottom (tree);
 913     show_tree (tree);
 914     maybe_chdir (tree);
 915 }
 916
 917 /* --------------------------------------------------------------------------------------------- */
 918
 919 static void
 920 tree_move_pgup (WTree * tree)
 921 {
 922     tree_move_backward (tree, tlines (tree) - 1);
 923     show_tree (tree);
 924     maybe_chdir (tree);
 925 }
 926
 927 /* --------------------------------------------------------------------------------------------- */
 928
 929 static void
 930 tree_move_pgdn (WTree * tree)
 931 {
 932     tree_move_forward (tree, tlines (tree) - 1);
 933     show_tree (tree);
 934     maybe_chdir (tree);
 935 }
 936
 937 /* --------------------------------------------------------------------------------------------- */
 938
 939 static gboolean
 940 tree_move_left (WTree * tree)
 941 {
 942     gboolean v = FALSE;
 943
 944     if (tree_navigation_flag)
 945     {
 946         v = tree_move_to_parent (tree);
 947         show_tree (tree);
 948         maybe_chdir (tree);
 949     }
 950
 951     return v;
 952 }
 953
 954 /* --------------------------------------------------------------------------------------------- */
 955
 956 static gboolean
 957 tree_move_right (WTree * tree)
 958 {
 959     gboolean v = FALSE;
 960
 961     if (tree_navigation_flag)
 962     {
 963         tree_move_to_child (tree);
 964         show_tree (tree);
 965         maybe_chdir (tree);
 966         v = TRUE;
 967     }
 968
 969     return v;
 970 }
 971
 972 /* --------------------------------------------------------------------------------------------- */
 973
 974 static void
 975 tree_start_search (WTree * tree)
 976 {
 977     gboolean i;
 978
 979     if (tree->searching)
 980     {
 981         if (tree->selected_ptr == tree->store->tree_last)
 982             tree_move_to_top (tree);
 983         else
 984         {
 985             /* set navigation mode temporarily to 'Static' because in
 986              * dynamic navigation mode tree_move_forward will not move
 987              * to a lower sublevel if necessary (sequent searches must
 988              * start with the directory followed the last found directory)
 989              */
 990             i = tree_navigation_flag;
 991             tree_navigation_flag = 0;
 992             tree_move_forward (tree, 1);
 993             tree_navigation_flag = i;
 994         }
 995         tree_do_search (tree, 0);
 996     }
 997     else
 998     {
 999         tree->searching = 1;
1000         tree->search_buffer[0] = 0;
1001     }
1002 }
1003
1004 /* --------------------------------------------------------------------------------------------- */
1005
1006 static void
1007 tree_toggle_navig (WTree * tree)
1008 {
1009     tree_navigation_flag = !tree_navigation_flag;
1010     buttonbar_set_label (find_buttonbar (tree->widget.owner), 4,
1011                          tree_navigation_flag ? Q_ ("ButtonBar|Static")
1012                          : Q_ ("ButtonBar|Dynamc"), tree_map, (Widget *) tree);
1013 }
1014
1015 /* --------------------------------------------------------------------------------------------- */
1016
1017 static cb_ret_t
1018 tree_execute_cmd (WTree * tree, unsigned long command)
1019 {
1020     cb_ret_t res = MSG_HANDLED;
1021
1022     if (command != CK_Search)
1023         tree->searching = 0;
1024
1025     switch (command)
1026     {
1027     case CK_Help:
1028         {
1029             ev_help_t event_data = { NULL, "[Directory Tree]" };
1030             mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
1031         }
1032         break;
1033     case CK_Forget:
1034         tree_forget (tree);
1035         break;
1036     case CK_ToggleNavigation:
1037         tree_toggle_navig (tree);
1038         break;
1039     case CK_Copy:
1040         tree_copy (tree, "");
1041         break;
1042     case CK_Move:
1043         tree_move (tree, "");
1044         break;
1045     case CK_Up:
1046         tree_move_up (tree);
1047         break;
1048     case CK_Down:
1049         tree_move_down (tree);
1050         break;
1051     case CK_Top:
1052         tree_move_home (tree);
1053         break;
1054     case CK_Bottom:
1055         tree_move_end (tree);
1056         break;
1057     case CK_PageUp:
1058         tree_move_pgup (tree);
1059         break;
1060     case CK_PageDown:
1061         tree_move_pgdn (tree);
1062         break;
1063     case CK_Enter:
1064         tree_chdir_sel (tree);
1065         break;
1066     case CK_Reread:
1067         tree_rescan (tree);
1068         break;
1069     case CK_Search:
1070         tree_start_search (tree);
1071         break;
1072     case CK_Delete:
1073         tree_rmdir (tree);
1074         break;
1075     case CK_Cancel:
1076         /* don't close tree due to SIGINT */
1077         break;
1078     default:
1079         res = MSG_NOT_HANDLED;
1080     }
1081
1082     show_tree (tree);
1083
1084     return res;
1085 }
1086
1087 /* --------------------------------------------------------------------------------------------- */
1088
1089 static cb_ret_t
1090 tree_key (WTree * tree, int key)
1091 {
1092     size_t i;
1093
1094     if (is_abort_char (key))
1095     {
1096         if (tree->is_panel)
1097         {
1098             tree->searching = 0;
1099             show_tree (tree);
1100             return MSG_HANDLED; /* eat abort char */
1101         }
1102         /* modal tree dialog: let upper layer see the
1103            abort character and close the dialog */
1104         return MSG_NOT_HANDLED;
1105     }
1106
1107     if (tree->searching && ((key >= ' ' && key <= 255) || key == KEY_BACKSPACE))
1108     {
1109         tree_do_search (tree, key);
1110         show_tree (tree);
1111         return MSG_HANDLED;
1112     }
1113
1114     for (i = 0; tree_map[i].key != 0; i++)
1115         if (key == tree_map[i].key)
1116             switch (tree_map[i].command)
1117             {
1118             case CK_Left:
1119                 return tree_move_left (tree) ? MSG_HANDLED : MSG_NOT_HANDLED;
1120             case CK_Right:
1121                 return tree_move_right (tree) ? MSG_HANDLED : MSG_NOT_HANDLED;
1122             default:
1123                 tree_execute_cmd (tree, tree_map[i].command);
1124                 return MSG_HANDLED;
1125             }
1126
1127     /* Do not eat characters not meant for the tree below ' ' (e.g. C-l). */
1128     if (!command_prompt && ((key >= ' ' && key <= 255) || key == KEY_BACKSPACE))
1129     {
1130         tree_start_search (tree);
1131         tree_do_search (tree, key);
1132         return MSG_HANDLED;
1133     }
1134
1135     return MSG_NOT_HANDLED;
1136 }
1137
1138 /* --------------------------------------------------------------------------------------------- */
1139
1140 static void
1141 tree_frame (Dlg_head * h, WTree * tree)
1142 {
1143     tty_setcolor (NORMAL_COLOR);
1144     widget_erase ((Widget *) tree);
1145     if (tree->is_panel)
1146     {
1147         const char *title = _("Directory tree");
1148         const int len = str_term_width1 (title);
1149
1150         draw_box (h, tree->widget.y, tree->widget.x, tree->widget.lines, tree->widget.cols, FALSE);
1151
1152         widget_move (&tree->widget, 0, (tree->widget.cols - len - 2) / 2);
1153         tty_printf (" %s ", title);
1154
1155         if (panels_options.show_mini_info)
1156             widget_move (&tree->widget, tlines (tree) + 1, 0);
1157         tty_print_alt_char (ACS_LTEE, FALSE);
1158         widget_move (&tree->widget, tlines (tree) + 1, tree->widget.cols - 1);
1159         tty_print_alt_char (ACS_RTEE, FALSE);
1160         tty_draw_hline (tree->widget.y + tlines (tree) + 1,
1161                         tree->widget.x + 1, ACS_HLINE, tree->widget.cols - 2);
1162     }
1163 }
1164
1165 /* --------------------------------------------------------------------------------------------- */
1166
1167 static cb_ret_t
1168 tree_callback (Widget * w, widget_msg_t msg, int parm)
1169 {
1170     WTree *tree = (WTree *) w;
1171     Dlg_head *h = tree->widget.owner;
1172     WButtonBar *b = find_buttonbar (h);
1173
1174     switch (msg)
1175     {
1176     case WIDGET_DRAW:
1177         tree_frame (h, tree);
1178         show_tree (tree);
1179         return MSG_HANDLED;
1180
1181     case WIDGET_FOCUS:
1182         tree->active = 1;
1183         buttonbar_set_label (b, 1, Q_ ("ButtonBar|Help"), tree_map, (Widget *) tree);
1184         buttonbar_set_label (b, 2, Q_ ("ButtonBar|Rescan"), tree_map, (Widget *) tree);
1185         buttonbar_set_label (b, 3, Q_ ("ButtonBar|Forget"), tree_map, (Widget *) tree);
1186         buttonbar_set_label (b, 4, tree_navigation_flag ? Q_ ("ButtonBar|Static")
1187                              : Q_ ("ButtonBar|Dynamc"), tree_map, (Widget *) tree);
1188         buttonbar_set_label (b, 5, Q_ ("ButtonBar|Copy"), tree_map, (Widget *) tree);
1189         buttonbar_set_label (b, 6, Q_ ("ButtonBar|RenMov"), tree_map, (Widget *) tree);
1190 #if 0
1191         /* FIXME: mkdir is currently defunct */
1192         buttonbar_set_label (b, 7, Q_ ("ButtonBar|Mkdir"), tree_map, (Widget *) tree);
1193 #else
1194         buttonbar_clear_label (b, 7, (Widget *) tree);
1195 #endif
1196         buttonbar_set_label (b, 8, Q_ ("ButtonBar|Rmdir"), tree_map, (Widget *) tree);
1197         buttonbar_redraw (b);
1198
1199         /* FIXME: Should find a better way of only displaying the
1200            currently selected item */
1201         show_tree (tree);
1202         return MSG_HANDLED;
1203
1204         /* FIXME: Should find a better way of changing the color of the
1205            selected item */
1206
1207     case WIDGET_UNFOCUS:
1208         tree->active = 0;
1209         tree->searching = 0;
1210         show_tree (tree);
1211         return MSG_HANDLED;
1212
1213     case WIDGET_KEY:
1214         return tree_key (tree, parm);
1215
1216     case WIDGET_COMMAND:
1217         /* command from buttonbar */
1218         return tree_execute_cmd (tree, parm);
1219
1220     case WIDGET_DESTROY:
1221         tree_destroy (tree);
1222         return MSG_HANDLED;
1223
1224     default:
1225         return default_proc (msg, parm);
1226     }
1227 }
1228
1229 /* --------------------------------------------------------------------------------------------- */
1230 /*** public functions ****************************************************************************/
1231 /* --------------------------------------------------------------------------------------------- */
1232
1233 WTree *
1234 tree_new (int y, int x, int lines, int cols, gboolean is_panel)
1235 {
1236     WTree *tree = g_new (WTree, 1);
1237
1238     init_widget (&tree->widget, y, x, lines, cols, tree_callback, event_callback);
1239     tree->is_panel = is_panel;
1240     tree->selected_ptr = 0;
1241
1242     tree->store = tree_store_get ();
1243     tree_store_add_entry_remove_hook (remove_callback, tree);
1244     tree->tree_shown = 0;
1245     tree->search_buffer[0] = 0;
1246     tree->topdiff = tree->widget.lines / 2;
1247     tree->searching = 0;
1248     tree->active = 0;
1249
1250     /* We do not want to keep the cursor */
1251     widget_want_cursor (tree->widget, 0);
1252     load_tree (tree);
1253     return tree;
1254 }
1255
1256 /* --------------------------------------------------------------------------------------------- */
1257
1258 void
1259 tree_chdir (WTree * tree, const char *dir)
1260 {
1261     tree_entry *current;
1262
1263     current = tree_store_whereis (dir);
1264
1265     if (current != NULL)
1266     {
1267         tree->selected_ptr = current;
1268         tree_check_focus (tree);
1269     }
1270 }
1271
1272 /* --------------------------------------------------------------------------------------------- */
1273 /** Return name of the currently selected entry */
1274
1275 char *
1276 tree_selected_name (const WTree * tree)
1277 {
1278     return tree->selected_ptr->name;
1279 }
1280
1281 /* --------------------------------------------------------------------------------------------- */
1282
1283 void
1284 sync_tree (const char *path)
1285 {
1286     tree_chdir (the_tree, path);
1287 }
1288
1289 /* --------------------------------------------------------------------------------------------- */
1290
1291 WTree *
1292 find_tree (struct Dlg_head *h)
1293 {
1294     return (WTree *) find_widget_type (h, tree_callback);
1295 }
1296
1297 /* --------------------------------------------------------------------------------------------- */