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
 584 /** Handle mouse click */
 585 static void
 586 tree_mouse_click (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 (tree->selected_ptr->name, 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 tree_event (Gpm_Event * event, void *data)
 634 {
 635     WTree *tree = (WTree *) data;
 636     Widget *w = (Widget *) data;
 637     Gpm_Event local;
 638
 639     if (!mouse_global_in_widget (event, w))
 640         return MOU_UNHANDLED;
 641
 642     /* rest of the upper frame - call menu */
 643     if (tree->is_panel && (event->type & GPM_DOWN) != 0 && event->y == w->owner->y + 1)
 644         return MOU_UNHANDLED;
 645
 646     local = mouse_get_local (event, w);
 647
 648     if ((local.type & GPM_UP) == 0)
 649         return MOU_NORMAL;
 650
 651     if (tree->is_panel)
 652         local.y--;
 653
 654     local.y--;
 655
 656     if (!tree->active)
 657         change_panel ();
 658
 659     if (local.y < 0)
 660     {
 661         tree_move_backward (tree, tlines (tree) - 1);
 662         show_tree (tree);
 663     }
 664     else if (local.y >= tlines (tree))
 665     {
 666         tree_move_forward (tree, tlines (tree) - 1);
 667         show_tree (tree);
 668     }
 669     else
 670     {
 671         tree_mouse_click (tree, local.y);
 672         if ((local.type & (GPM_UP | GPM_DOUBLE)) == (GPM_UP | GPM_DOUBLE))
 673             tree_chdir_sel (tree);
 674     }
 675
 676     return MOU_NORMAL;
 677 }
 678
 679 /* --------------------------------------------------------------------------------------------- */
 680 /** Search tree for text */
 681
 682 static int
 683 search_tree (WTree * tree, char *text)
 684 {
 685     tree_entry *current;
 686     int len;
 687     int wrapped = 0;
 688     int found = 0;
 689
 690     len = strlen (text);
 691     current = tree->selected_ptr;
 692     found = 0;
 693     while (!wrapped || current != tree->selected_ptr)
 694     {
 695         if (strncmp (current->subname, text, len) == 0)
 696         {
 697             tree->selected_ptr = current;
 698             found = 1;
 699             break;
 700         }
 701         current = current->next;
 702         if (!current)
 703         {
 704             current = tree->store->tree_first;
 705             wrapped = 1;
 706         }
 707         tree->topdiff++;
 708     }
 709     tree_check_focus (tree);
 710     return found;
 711 }
 712
 713 /* --------------------------------------------------------------------------------------------- */
 714
 715 static void
 716 tree_do_search (WTree * tree, int key)
 717 {
 718     size_t l;
 719
 720     l = strlen (tree->search_buffer);
 721     if ((l != 0) && (key == KEY_BACKSPACE))
 722         tree->search_buffer[--l] = '\0';
 723     else if (key && l < sizeof (tree->search_buffer))
 724     {
 725         tree->search_buffer[l] = key;
 726         tree->search_buffer[++l] = '\0';
 727     }
 728
 729     if (!search_tree (tree, tree->search_buffer))
 730         tree->search_buffer[--l] = 0;
 731
 732     show_tree (tree);
 733     maybe_chdir (tree);
 734 }
 735
 736 /* --------------------------------------------------------------------------------------------- */
 737
 738 static void
 739 tree_rescan (void *data)
 740 {
 741     WTree *tree = data;
 742     vfs_path_t *old_vpath;
 743
 744     old_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
 745     if (old_vpath == NULL)
 746         return;
 747
 748     if (tree->selected_ptr != NULL && mc_chdir (tree->selected_ptr->name) == 0)
 749     {
 750         tree_store_rescan (tree->selected_ptr->name);
 751         mc_chdir (old_vpath);
 752     }
 753     vfs_path_free (old_vpath);
 754 }
 755
 756 /* --------------------------------------------------------------------------------------------- */
 757
 758 static void
 759 tree_forget (void *data)
 760 {
 761     WTree *tree = data;
 762     if (tree->selected_ptr)
 763         tree_remove_entry (tree, tree->selected_ptr->name);
 764 }
 765
 766 /* --------------------------------------------------------------------------------------------- */
 767
 768 static void
 769 tree_copy (WTree * tree, const char *default_dest)
 770 {
 771     char msg[BUF_MEDIUM];
 772     char *dest, *selected_ptr_name;
 773
 774     if (tree->selected_ptr == NULL)
 775         return;
 776
 777     selected_ptr_name = vfs_path_to_str (tree->selected_ptr->name);
 778
 779     g_snprintf (msg, sizeof (msg), _("Copy \"%s\" directory to:"),
 780                 str_trunc (selected_ptr_name, 50));
 781     dest = input_expand_dialog (Q_ ("DialogTitle|Copy"),
 782                                 msg, MC_HISTORY_FM_TREE_COPY, default_dest);
 783
 784     if (dest != NULL && *dest != '\0')
 785     {
 786         FileOpContext *ctx;
 787         FileOpTotalContext *tctx;
 788
 789         ctx = file_op_context_new (OP_COPY);
 790         tctx = file_op_total_context_new ();
 791         file_op_context_create_ui (ctx, FALSE, FILEGUI_DIALOG_MULTI_ITEM);
 792         tctx->ask_overwrite = FALSE;
 793         copy_dir_dir (tctx, ctx, selected_ptr_name, dest, TRUE, FALSE, FALSE, NULL);
 794         file_op_total_context_destroy (tctx);
 795         file_op_context_destroy (ctx);
 796     }
 797
 798     g_free (dest);
 799     g_free (selected_ptr_name);
 800 }
 801
 802 /* --------------------------------------------------------------------------------------------- */
 803
 804 static void
 805 tree_move (WTree * tree, const char *default_dest)
 806 {
 807     char msg[BUF_MEDIUM];
 808     char *dest, *selected_ptr_name;
 809     struct stat buf;
 810     FileOpContext *ctx;
 811     FileOpTotalContext *tctx;
 812
 813     if (tree->selected_ptr == NULL)
 814         return;
 815
 816     selected_ptr_name = vfs_path_to_str (tree->selected_ptr->name);
 817
 818     g_snprintf (msg, sizeof (msg), _("Move \"%s\" directory to:"),
 819                 str_trunc (selected_ptr_name, 50));
 820     dest =
 821         input_expand_dialog (Q_ ("DialogTitle|Move"), msg, MC_HISTORY_FM_TREE_MOVE, default_dest);
 822
 823     if (dest == NULL || *dest == '\0')
 824         goto ret;
 825
 826     if (stat (dest, &buf))
 827     {
 828         message (D_ERROR, MSG_ERROR, _("Cannot stat the destination\n%s"),
 829                  unix_error_string (errno));
 830         goto ret;
 831     }
 832
 833     if (!S_ISDIR (buf.st_mode))
 834     {
 835         file_error (_("Destination \"%s\" must be a directory\n%s"), dest);
 836         goto ret;
 837     }
 838
 839     ctx = file_op_context_new (OP_MOVE);
 840     tctx = file_op_total_context_new ();
 841     file_op_context_create_ui (ctx, FALSE, FILEGUI_DIALOG_ONE_ITEM);
 842     move_dir_dir (tctx, ctx, selected_ptr_name, dest);
 843     file_op_total_context_destroy (tctx);
 844     file_op_context_destroy (ctx);
 845
 846   ret:
 847     g_free (selected_ptr_name);
 848     g_free (dest);
 849 }
 850
 851 /* --------------------------------------------------------------------------------------------- */
 852
 853 #if 0
 854 static void
 855 tree_mkdir (WTree * tree)
 856 {
 857     char old_dir[MC_MAXPATHLEN];
 858
 859     if (!tree->selected_ptr)
 860         return;
 861     if (chdir (tree->selected_ptr->name))
 862         return;
 863     /* FIXME
 864        mkdir_cmd (tree);
 865      */
 866     tree_rescan (tree);
 867     chdir (old_dir);
 868 }
 869 #endif
 870
 871 /* --------------------------------------------------------------------------------------------- */
 872
 873 static void
 874 tree_rmdir (void *data)
 875 {
 876     WTree *tree = data;
 877     FileOpContext *ctx;
 878     FileOpTotalContext *tctx;
 879
 880     if (!tree->selected_ptr)
 881         return;
 882
 883     if (confirm_delete)
 884     {
 885         char *buf;
 886         int result;
 887         char *selected_ptr_name;
 888
 889         selected_ptr_name = vfs_path_to_str (tree->selected_ptr->name);
 890         buf = g_strdup_printf (_("Delete %s?"), selected_ptr_name);
 891         g_free (selected_ptr_name);
 892
 893         result = query_dialog (Q_ ("DialogTitle|Delete"), buf, D_ERROR, 2, _("&Yes"), _("&No"));
 894         g_free (buf);
 895         if (result != 0)
 896             return;
 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, tree->selected_ptr->name) == FILE_CONT)
 904         tree_forget (tree);
 905     file_op_total_context_destroy (tctx);
 906     file_op_context_destroy (ctx);
 907 }
 908
 909 /* --------------------------------------------------------------------------------------------- */
 910
 911 static inline void
 912 tree_move_up (WTree * tree)
 913 {
 914     tree_move_backward (tree, 1);
 915     show_tree (tree);
 916     maybe_chdir (tree);
 917 }
 918
 919 /* --------------------------------------------------------------------------------------------- */
 920
 921 static inline void
 922 tree_move_down (WTree * tree)
 923 {
 924     tree_move_forward (tree, 1);
 925     show_tree (tree);
 926     maybe_chdir (tree);
 927 }
 928
 929 /* --------------------------------------------------------------------------------------------- */
 930
 931 static inline void
 932 tree_move_home (WTree * tree)
 933 {
 934     tree_move_to_top (tree);
 935     show_tree (tree);
 936     maybe_chdir (tree);
 937 }
 938
 939 /* --------------------------------------------------------------------------------------------- */
 940
 941 static inline void
 942 tree_move_end (WTree * tree)
 943 {
 944     tree_move_to_bottom (tree);
 945     show_tree (tree);
 946     maybe_chdir (tree);
 947 }
 948
 949 /* --------------------------------------------------------------------------------------------- */
 950
 951 static void
 952 tree_move_pgup (WTree * tree)
 953 {
 954     tree_move_backward (tree, tlines (tree) - 1);
 955     show_tree (tree);
 956     maybe_chdir (tree);
 957 }
 958
 959 /* --------------------------------------------------------------------------------------------- */
 960
 961 static void
 962 tree_move_pgdn (WTree * tree)
 963 {
 964     tree_move_forward (tree, tlines (tree) - 1);
 965     show_tree (tree);
 966     maybe_chdir (tree);
 967 }
 968
 969 /* --------------------------------------------------------------------------------------------- */
 970
 971 static gboolean
 972 tree_move_left (WTree * tree)
 973 {
 974     gboolean v = FALSE;
 975
 976     if (tree_navigation_flag)
 977     {
 978         v = tree_move_to_parent (tree);
 979         show_tree (tree);
 980         maybe_chdir (tree);
 981     }
 982
 983     return v;
 984 }
 985
 986 /* --------------------------------------------------------------------------------------------- */
 987
 988 static gboolean
 989 tree_move_right (WTree * tree)
 990 {
 991     gboolean v = FALSE;
 992
 993     if (tree_navigation_flag)
 994     {
 995         tree_move_to_child (tree);
 996         show_tree (tree);
 997         maybe_chdir (tree);
 998         v = TRUE;
 999     }
1000
1001     return v;
1002 }
1003
1004 /* --------------------------------------------------------------------------------------------- */
1005
1006 static void
1007 tree_start_search (WTree * tree)
1008 {
1009     gboolean i;
1010
1011     if (tree->searching)
1012     {
1013         if (tree->selected_ptr == tree->store->tree_last)
1014             tree_move_to_top (tree);
1015         else
1016         {
1017             /* set navigation mode temporarily to 'Static' because in
1018              * dynamic navigation mode tree_move_forward will not move
1019              * to a lower sublevel if necessary (sequent searches must
1020              * start with the directory followed the last found directory)
1021              */
1022             i = tree_navigation_flag;
1023             tree_navigation_flag = 0;
1024             tree_move_forward (tree, 1);
1025             tree_navigation_flag = i;
1026         }
1027         tree_do_search (tree, 0);
1028     }
1029     else
1030     {
1031         tree->searching = 1;
1032         tree->search_buffer[0] = 0;
1033     }
1034 }
1035
1036 /* --------------------------------------------------------------------------------------------- */
1037
1038 static void
1039 tree_toggle_navig (WTree * tree)
1040 {
1041     tree_navigation_flag = !tree_navigation_flag;
1042     buttonbar_set_label (find_buttonbar (tree->widget.owner), 4,
1043                          tree_navigation_flag ? Q_ ("ButtonBar|Static")
1044                          : Q_ ("ButtonBar|Dynamc"), tree_map, (Widget *) tree);
1045 }
1046
1047 /* --------------------------------------------------------------------------------------------- */
1048
1049 static cb_ret_t
1050 tree_execute_cmd (WTree * tree, unsigned long command)
1051 {
1052     cb_ret_t res = MSG_HANDLED;
1053
1054     if (command != CK_Search)
1055         tree->searching = 0;
1056
1057     switch (command)
1058     {
1059     case CK_Help:
1060         {
1061             ev_help_t event_data = { NULL, "[Directory Tree]" };
1062             mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
1063         }
1064         break;
1065     case CK_Forget:
1066         tree_forget (tree);
1067         break;
1068     case CK_ToggleNavigation:
1069         tree_toggle_navig (tree);
1070         break;
1071     case CK_Copy:
1072         tree_copy (tree, "");
1073         break;
1074     case CK_Move:
1075         tree_move (tree, "");
1076         break;
1077     case CK_Up:
1078         tree_move_up (tree);
1079         break;
1080     case CK_Down:
1081         tree_move_down (tree);
1082         break;
1083     case CK_Top:
1084         tree_move_home (tree);
1085         break;
1086     case CK_Bottom:
1087         tree_move_end (tree);
1088         break;
1089     case CK_PageUp:
1090         tree_move_pgup (tree);
1091         break;
1092     case CK_PageDown:
1093         tree_move_pgdn (tree);
1094         break;
1095     case CK_Enter:
1096         tree_chdir_sel (tree);
1097         break;
1098     case CK_Reread:
1099         tree_rescan (tree);
1100         break;
1101     case CK_Search:
1102         tree_start_search (tree);
1103         break;
1104     case CK_Delete:
1105         tree_rmdir (tree);
1106         break;
1107     case CK_Quit:
1108         if (!tree->is_panel)
1109             dlg_stop (((Widget *) tree)->owner);
1110         return res;
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, tree_event);
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 /* --------------------------------------------------------------------------------------------- */