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