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