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