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