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