src/filemanager/cmd.c

   1 /*
   2    Routines invoked by a function key
   3    They normally operate on the current panel.
   4
   5    Copyright (C) 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   6    2005, 2006, 2007, 2009, 2011
   7    The Free Software Foundation, Inc.
   8
   9    This file is part of the Midnight Commander.
  10
  11    The Midnight Commander is free software: you can redistribute it
  12    and/or modify it under the terms of the GNU General Public License as
  13    published by the Free Software Foundation, either version 3 of the License,
  14    or (at your option) any later version.
  15
  16    The Midnight Commander is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 /** \file cmd.c
  26  *  \brief Source: routines invoked by a function key
  27  *
  28  *  They normally operate on the current panel.
  29  */
  30
  31 #include <config.h>
  32
  33 #include <errno.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #ifdef HAVE_MMAP
  40 #include <sys/mman.h>
  41 #endif
  42 #ifdef ENABLE_VFS_NET
  43 #include <netdb.h>
  44 #endif
  45 #include <unistd.h>
  46 #include <stdlib.h>
  47 #include <fcntl.h>
  48 #include <pwd.h>
  49 #include <grp.h>
  50 #include <sys/time.h>
  51
  52 #include "lib/global.h"
  53
  54 #include "lib/tty/tty.h"        /* LINES, tty_touch_screen() */
  55 #include "lib/tty/key.h"        /* ALT() macro */
  56 #include "lib/tty/win.h"        /* do_enter_ca_mode() */
  57 #include "lib/mcconfig.h"
  58 #include "lib/search.h"
  59 #include "lib/filehighlight.h"  /* MC_FHL_INI_FILE */
  60 #include "lib/vfs/vfs.h"
  61 #include "lib/fileloc.h"
  62 #include "lib/strutil.h"
  63 #include "lib/util.h"
  64 #include "lib/widget.h"
  65 #include "lib/keybind.h"        /* CK_Down, CK_History */
  66 #include "lib/event.h"          /* mc_event_raise() */
  67
  68 #include "src/viewer/mcviewer.h"
  69 #include "src/setup.h"
  70 #include "src/execute.h"        /* toggle_panels() */
  71 #include "src/history.h"
  72 #include "src/util.h"           /* check_for_default() */
  73
  74 #ifdef USE_INTERNAL_EDIT
  75 #include "src/editor/edit.h"
  76 #endif
  77
  78 #ifdef USE_DIFF_VIEW
  79 #include "src/diffviewer/ydiff.h"
  80 #endif
  81
  82 #include "fileopctx.h"
  83 #include "file.h"               /* file operation routines */
  84 #include "find.h"               /* find_file() */
  85 #include "filenot.h"
  86 #include "hotlist.h"            /* hotlist_show() */
  87 #include "panel.h"              /* WPanel */
  88 #include "tree.h"               /* tree_chdir() */
  89 #include "midnight.h"           /* change_panel() */
  90 #include "usermenu.h"           /* MC_GLOBAL_MENU */
  91 #include "command.h"            /* cmdline */
  92 #include "layout.h"             /* get_current_type() */
  93 #include "ext.h"                /* regex_command() */
  94 #include "boxes.h"              /* cd_dialog() */
  95 #include "dir.h"
  96
  97 #include "cmd.h"                /* Our definitions */
  98
  99 /*** global variables ****************************************************************************/
 100
 101 int select_flags = SELECT_MATCH_CASE | SELECT_SHELL_PATTERNS;
 102
 103 /*** file scope macro definitions ****************************************************************/
 104
 105 #ifndef MAP_FILE
 106 #define MAP_FILE 0
 107 #endif
 108
 109 /*** file scope type declarations ****************************************************************/
 110
 111 enum CompareMode
 112 {
 113     compare_quick, compare_size_only, compare_thourough
 114 };
 115
 116 /*** file scope variables ************************************************************************/
 117
 118 #ifdef ENABLE_VFS_NET
 119 static const char *machine_str = N_("Enter machine name (F1 for details):");
 120 #endif /* ENABLE_VFS_NET */
 121
 122 /*** file scope functions ************************************************************************/
 123 /* --------------------------------------------------------------------------------------------- */
 124
 125 /** scan_for_file (panel, idx, direction)
 126  *
 127  * Inputs:
 128  *   panel:     pointer to the panel on which we operate
 129  *   idx:       starting file.
 130  *   direction: 1, or -1
 131  */
 132
 133 static int
 134 scan_for_file (WPanel * panel, int idx, int direction)
 135 {
 136     int i = idx + direction;
 137
 138     while (i != idx)
 139     {
 140         if (i < 0)
 141             i = panel->count - 1;
 142         if (i == panel->count)
 143             i = 0;
 144         if (!S_ISDIR (panel->dir.list[i].st.st_mode))
 145             return i;
 146         i += direction;
 147     }
 148     return i;
 149 }
 150
 151 /* --------------------------------------------------------------------------------------------- */
 152 /**
 153  * Run viewer (internal or external) on the currently selected file.
 154  * If normal is TRUE, force internal viewer and raw mode (used for F13).
 155  */
 156 static void
 157 do_view_cmd (gboolean normal)
 158 {
 159     /* Directories are viewed by changing to them */
 160     if (S_ISDIR (selection (current_panel)->st.st_mode) || link_isdir (selection (current_panel)))
 161     {
 162         vfs_path_t *fname_vpath;
 163
 164         if (confirm_view_dir && (current_panel->marked || current_panel->dirs_marked))
 165         {
 166             if (query_dialog
 167                 (_("Confirmation"), _("Files tagged, want to cd?"), D_NORMAL, 2,
 168                  _("&Yes"), _("&No")) != 0)
 169             {
 170                 return;
 171             }
 172         }
 173         fname_vpath = vfs_path_from_str (selection (current_panel)->fname);
 174         if (!do_cd (fname_vpath, cd_exact))
 175             message (D_ERROR, MSG_ERROR, _("Cannot change directory"));
 176         vfs_path_free (fname_vpath);
 177     }
 178     else
 179     {
 180         int file_idx;
 181
 182         file_idx = current_panel->selected;
 183
 184         while (TRUE)
 185         {
 186             char *filename;
 187             int dir;
 188
 189             filename = current_panel->dir.list[file_idx].fname;
 190             dir = view_file (filename, normal, use_internal_view);
 191             if (dir == 0)
 192                 break;
 193             file_idx = scan_for_file (current_panel, file_idx, dir);
 194         }
 195     }
 196
 197     repaint_screen ();
 198 }
 199
 200 /* --------------------------------------------------------------------------------------------- */
 201
 202 static inline void
 203 do_edit (const vfs_path_t * what_vpath)
 204 {
 205     do_edit_at_line (what_vpath, use_internal_edit, 0);
 206 }
 207
 208 /* --------------------------------------------------------------------------------------------- */
 209
 210 static void
 211 set_panel_filter_to (WPanel * p, char *allocated_filter_string)
 212 {
 213     g_free (p->filter);
 214     p->filter = 0;
 215
 216     if (!(allocated_filter_string[0] == '*' && allocated_filter_string[1] == 0))
 217         p->filter = allocated_filter_string;
 218     else
 219         g_free (allocated_filter_string);
 220     reread_cmd ();
 221 }
 222
 223 /* --------------------------------------------------------------------------------------------- */
 224 /** Set a given panel filter expression */
 225
 226 static void
 227 set_panel_filter (WPanel * p)
 228 {
 229     char *reg_exp;
 230     const char *x;
 231
 232     x = p->filter ? p->filter : easy_patterns ? "*" : ".";
 233
 234     reg_exp = input_dialog_help (_("Filter"),
 235                                  _("Set expression for filtering filenames"),
 236                                  "[Filter...]", MC_HISTORY_FM_PANEL_FILTER, x);
 237     if (!reg_exp)
 238         return;
 239     set_panel_filter_to (p, reg_exp);
 240 }
 241
 242 /* --------------------------------------------------------------------------------------------- */
 243
 244 static void
 245 select_unselect_cmd (const char *title, const char *history_name, gboolean do_select)
 246 {
 247     /* dialog sizes */
 248     const int DX = 50;
 249     const int DY = 7;
 250
 251     int files_only = (select_flags & SELECT_FILES_ONLY) != 0;
 252     int case_sens = (select_flags & SELECT_MATCH_CASE) != 0;
 253     int shell_patterns = (select_flags & SELECT_SHELL_PATTERNS) != 0;
 254
 255     char *reg_exp;
 256     mc_search_t *search;
 257     int i;
 258
 259     QuickWidget quick_widgets[] = {
 260         QUICK_CHECKBOX (3, DX, DY - 3, DY, N_("&Using shell patterns"), &shell_patterns),
 261         QUICK_CHECKBOX (DX / 2 + 1, DX, DY - 4, DY, N_("&Case sensitive"), &case_sens),
 262         QUICK_CHECKBOX (3, DX, DY - 4, DY, N_("&Files only"), &files_only),
 263         QUICK_INPUT (3, DX, DY - 5, DY, INPUT_LAST_TEXT, DX - 6, 0, history_name, &reg_exp),
 264         QUICK_END
 265     };
 266
 267     QuickDialog quick_dlg = {
 268         DX, DY, -1, -1, title,
 269         "[Select/Unselect Files]", quick_widgets, NULL, FALSE
 270     };
 271
 272     if (quick_dialog (&quick_dlg) == B_CANCEL)
 273         return;
 274
 275     if (!reg_exp)
 276         return;
 277     if (!*reg_exp)
 278     {
 279         g_free (reg_exp);
 280         return;
 281     }
 282     search = mc_search_new (reg_exp, -1);
 283     search->search_type = (shell_patterns != 0) ? MC_SEARCH_T_GLOB : MC_SEARCH_T_REGEX;
 284     search->is_entire_line = TRUE;
 285     search->is_case_sensitive = case_sens != 0;
 286
 287     for (i = 0; i < current_panel->count; i++)
 288     {
 289         if (strcmp (current_panel->dir.list[i].fname, "..") == 0)
 290             continue;
 291         if (S_ISDIR (current_panel->dir.list[i].st.st_mode) && files_only != 0)
 292             continue;
 293
 294         if (mc_search_run (search, current_panel->dir.list[i].fname,
 295                            0, current_panel->dir.list[i].fnamelen, NULL))
 296             do_file_mark (current_panel, i, do_select);
 297     }
 298
 299     mc_search_free (search);
 300     g_free (reg_exp);
 301
 302     /* result flags */
 303     select_flags = 0;
 304     if (case_sens != 0)
 305         select_flags |= SELECT_MATCH_CASE;
 306     if (files_only != 0)
 307         select_flags |= SELECT_FILES_ONLY;
 308     if (shell_patterns != 0)
 309         select_flags |= SELECT_SHELL_PATTERNS;
 310 }
 311
 312 /* --------------------------------------------------------------------------------------------- */
 313
 314 static int
 315 compare_files (const vfs_path_t * vpath1, const vfs_path_t * vpath2, off_t size)
 316 {
 317     int file1, file2;
 318     char *name;
 319     int result = -1;            /* Different by default */
 320
 321     if (size == 0)
 322         return 0;
 323
 324     name = vfs_path_to_str (vpath1);
 325     file1 = open (name, O_RDONLY);
 326     g_free (name);
 327     if (file1 >= 0)
 328     {
 329         name = vfs_path_to_str (vpath2);
 330         file2 = open (name, O_RDONLY);
 331         g_free (name);
 332         if (file2 >= 0)
 333         {
 334 #ifdef HAVE_MMAP
 335             char *data1, *data2;
 336             /* Ugly if jungle */
 337             data1 = mmap (0, size, PROT_READ, MAP_FILE | MAP_PRIVATE, file1, 0);
 338             if (data1 != (char *) -1)
 339             {
 340                 data2 = mmap (0, size, PROT_READ, MAP_FILE | MAP_PRIVATE, file2, 0);
 341                 if (data2 != (char *) -1)
 342                 {
 343                     rotate_dash ();
 344                     result = memcmp (data1, data2, size);
 345                     munmap (data2, size);
 346                 }
 347                 munmap (data1, size);
 348             }
 349 #else
 350             /* Don't have mmap() :( Even more ugly :) */
 351             char buf1[BUFSIZ], buf2[BUFSIZ];
 352             int n1, n2;
 353             rotate_dash ();
 354             do
 355             {
 356                 while ((n1 = read (file1, buf1, BUFSIZ)) == -1 && errno == EINTR);
 357                 while ((n2 = read (file2, buf2, BUFSIZ)) == -1 && errno == EINTR);
 358             }
 359             while (n1 == n2 && n1 == BUFSIZ && !memcmp (buf1, buf2, BUFSIZ));
 360             result = (n1 != n2) || memcmp (buf1, buf2, n1);
 361 #endif /* !HAVE_MMAP */
 362             close (file2);
 363         }
 364         close (file1);
 365     }
 366     return result;
 367 }
 368
 369 /* --------------------------------------------------------------------------------------------- */
 370
 371 static void
 372 compare_dir (WPanel * panel, WPanel * other, enum CompareMode mode)
 373 {
 374     int i, j;
 375
 376     /* No marks by default */
 377     panel->marked = 0;
 378     panel->total = 0;
 379     panel->dirs_marked = 0;
 380
 381     /* Handle all files in the panel */
 382     for (i = 0; i < panel->count; i++)
 383     {
 384         file_entry *source = &panel->dir.list[i];
 385
 386         /* Default: unmarked */
 387         file_mark (panel, i, 0);
 388
 389         /* Skip directories */
 390         if (S_ISDIR (source->st.st_mode))
 391             continue;
 392
 393         /* Search the corresponding entry from the other panel */
 394         for (j = 0; j < other->count; j++)
 395         {
 396             if (strcmp (source->fname, other->dir.list[j].fname) == 0)
 397                 break;
 398         }
 399         if (j >= other->count)
 400             /* Not found -> mark */
 401             do_file_mark (panel, i, 1);
 402         else
 403         {
 404             /* Found */
 405             file_entry *target = &other->dir.list[j];
 406
 407             if (mode != compare_size_only)
 408             {
 409                 /* Older version is not marked */
 410                 if (source->st.st_mtime < target->st.st_mtime)
 411                     continue;
 412             }
 413
 414             /* Newer version with different size is marked */
 415             if (source->st.st_size != target->st.st_size)
 416             {
 417                 do_file_mark (panel, i, 1);
 418                 continue;
 419
 420             }
 421             if (mode == compare_size_only)
 422                 continue;
 423
 424             if (mode == compare_quick)
 425             {
 426                 /* Thorough compare off, compare only time stamps */
 427                 /* Mark newer version, don't mark version with the same date */
 428                 if (source->st.st_mtime > target->st.st_mtime)
 429                 {
 430                     do_file_mark (panel, i, 1);
 431                 }
 432                 continue;
 433             }
 434
 435             /* Thorough compare on, do byte-by-byte comparison */
 436             {
 437                 vfs_path_t *src_name, *dst_name;
 438
 439                 src_name = vfs_path_append_new (panel->cwd_vpath, source->fname, NULL);
 440                 dst_name = vfs_path_append_new (other->cwd_vpath, target->fname, NULL);
 441                 if (compare_files (src_name, dst_name, source->st.st_size))
 442                     do_file_mark (panel, i, 1);
 443                 vfs_path_free (src_name);
 444                 vfs_path_free (dst_name);
 445             }
 446         }
 447     }                           /* for (i ...) */
 448 }
 449
 450 /* --------------------------------------------------------------------------------------------- */
 451
 452 static void
 453 do_link (link_type_t link_type, const char *fname)
 454 {
 455     char *dest = NULL, *src = NULL;
 456     vfs_path_t *fname_vpath, *dest_vpath = NULL;
 457
 458     fname_vpath = vfs_path_from_str (fname);
 459     if (link_type == LINK_HARDLINK)
 460     {
 461         src = g_strdup_printf (_("Link %s to:"), str_trunc (fname, 46));
 462         dest = input_expand_dialog (_("Link"), src, MC_HISTORY_FM_LINK, "");
 463         if (!dest || !*dest)
 464             goto cleanup;
 465         save_cwds_stat ();
 466         dest_vpath = vfs_path_from_str (dest);
 467         if (-1 == mc_link (fname_vpath, dest_vpath))
 468             message (D_ERROR, MSG_ERROR, _("link: %s"), unix_error_string (errno));
 469     }
 470     else
 471     {
 472         vfs_path_t *s, *d;
 473
 474         /* suggest the full path for symlink, and either the full or
 475            relative path to the file it points to  */
 476         s = vfs_path_append_new (current_panel->cwd_vpath, fname, NULL);
 477
 478         if (get_other_type () == view_listing)
 479             d = vfs_path_append_new (other_panel->cwd_vpath, fname, NULL);
 480         else
 481             d = vfs_path_from_str (fname);
 482
 483         if (link_type == LINK_SYMLINK_RELATIVE)
 484         {
 485             char *s_str;
 486
 487             s_str = diff_two_paths (other_panel->cwd_vpath, s);
 488             vfs_path_free (s);
 489             s = vfs_path_from_str_flags (s_str, VPF_NO_CANON);
 490             g_free (s_str);
 491         }
 492
 493         symlink_dialog (s, d, &dest, &src);
 494         vfs_path_free (d);
 495         vfs_path_free (s);
 496
 497         if (!dest || !*dest || !src || !*src)
 498             goto cleanup;
 499         save_cwds_stat ();
 500
 501         dest_vpath = vfs_path_from_str_flags (dest, VPF_NO_CANON);
 502
 503         s = vfs_path_from_str (src);
 504         if (mc_symlink (dest_vpath, s) == -1)
 505             message (D_ERROR, MSG_ERROR, _("symlink: %s"), unix_error_string (errno));
 506         vfs_path_free (s);
 507     }
 508
 509     update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 510     repaint_screen ();
 511
 512   cleanup:
 513     vfs_path_free (fname_vpath);
 514     vfs_path_free (dest_vpath);
 515     g_free (src);
 516     g_free (dest);
 517 }
 518
 519 /* --------------------------------------------------------------------------------------------- */
 520
 521 #if defined(ENABLE_VFS_UNDELFS) || defined(ENABLE_VFS_NET)
 522
 523 static const char *
 524 transform_prefix (const char *prefix)
 525 {
 526     static char buffer[BUF_TINY];
 527     size_t prefix_len = strlen (prefix);
 528
 529     if (prefix_len < 3)
 530         return prefix;
 531
 532     strcpy (buffer, prefix + 2);
 533     strcpy (buffer + prefix_len - 3, VFS_PATH_URL_DELIMITER);
 534     return buffer;
 535 }
 536
 537 /* --------------------------------------------------------------------------------------------- */
 538
 539 static void
 540 nice_cd (const char *text, const char *xtext, const char *help,
 541          const char *history_name, const char *prefix, int to_home)
 542 {
 543     char *machine;
 544     char *cd_path;
 545
 546     if (!SELECTED_IS_PANEL)
 547         return;
 548
 549     machine = input_dialog_help (text, xtext, help, history_name, "");
 550     if (!machine)
 551         return;
 552
 553     to_home = 0;                /* FIXME: how to solve going to home nicely? /~/ is
 554                                    ugly as hell and leads to problems in vfs layer */
 555
 556     /* default prefix in old-style format. */
 557     if (strncmp (prefix, machine, strlen (prefix)) != 0)
 558         prefix = transform_prefix (prefix);     /* Convert prefix to URL-style format */
 559
 560     if (strncmp (prefix, machine, strlen (prefix)) == 0)
 561         cd_path = g_strconcat (machine, to_home ? "/~/" : (char *) NULL, (char *) NULL);
 562     else
 563         cd_path = g_strconcat (prefix, machine, to_home ? "/~/" : (char *) NULL, (char *) NULL);
 564
 565     if (*cd_path != PATH_SEP)
 566     {
 567         char *tmp = cd_path;
 568
 569         cd_path = g_strconcat (PATH_SEP_STR, tmp, (char *) NULL);
 570         g_free (tmp);
 571     }
 572
 573     {
 574         vfs_path_t *cd_vpath;
 575
 576         cd_vpath = vfs_path_from_str (cd_path);
 577         if (!do_panel_cd (MENU_PANEL, cd_vpath, cd_parse_command))
 578             message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\""), cd_path);
 579         vfs_path_free (cd_vpath);
 580     }
 581     g_free (cd_path);
 582     g_free (machine);
 583 }
 584 #endif /* ENABLE_VFS_UNDELFS || ENABLE_VFS_NET */
 585
 586 /* --------------------------------------------------------------------------------------------- */
 587
 588 static void
 589 configure_panel_listing (WPanel * p, int list_type, int use_msformat, char *user, char *status)
 590 {
 591     p->user_mini_status = use_msformat;
 592     p->list_type = list_type;
 593
 594     if (list_type == list_user || use_msformat)
 595     {
 596         g_free (p->user_format);
 597         p->user_format = user;
 598
 599         g_free (p->user_status_format[list_type]);
 600         p->user_status_format[list_type] = status;
 601
 602         set_panel_formats (p);
 603     }
 604     else
 605     {
 606         g_free (user);
 607         g_free (status);
 608     }
 609
 610     set_panel_formats (p);
 611     do_refresh ();
 612 }
 613
 614 /* --------------------------------------------------------------------------------------------- */
 615
 616 static void
 617 switch_to_listing (int panel_index)
 618 {
 619     if (get_display_type (panel_index) != view_listing)
 620         set_display_type (panel_index, view_listing);
 621     else
 622     {
 623         WPanel *p;
 624
 625         p = (WPanel *) get_panel_widget (panel_index);
 626         if (p->is_panelized)
 627         {
 628             p->is_panelized = FALSE;
 629             panel_reload (p);
 630         }
 631     }
 632 }
 633
 634 /* --------------------------------------------------------------------------------------------- */
 635 /** Handle the tree internal listing modes switching */
 636
 637 static gboolean
 638 set_basic_panel_listing_to (int panel_index, int listing_mode)
 639 {
 640     WPanel *p = (WPanel *) get_panel_widget (panel_index);
 641     gboolean ok;
 642
 643     switch_to_listing (panel_index);
 644     p->list_type = listing_mode;
 645
 646     ok = set_panel_formats (p) == 0;
 647
 648     if (ok)
 649         do_refresh ();
 650
 651     return ok;
 652 }
 653
 654 /* --------------------------------------------------------------------------------------------- */
 655 /*** public functions ****************************************************************************/
 656 /* --------------------------------------------------------------------------------------------- */
 657
 658 int
 659 view_file_at_line (const char *filename, int plain_view, int internal, int start_line)
 660 {
 661     static const char *viewer = NULL;
 662     int move_dir = 0;
 663
 664     if (plain_view)
 665     {
 666         int changed_hex_mode = 0;
 667         int changed_nroff_flag = 0;
 668         int changed_magic_flag = 0;
 669
 670         mcview_altered_hex_mode = 0;
 671         mcview_altered_nroff_flag = 0;
 672         mcview_altered_magic_flag = 0;
 673         if (mcview_default_hex_mode)
 674             changed_hex_mode = 1;
 675         if (mcview_default_nroff_flag)
 676             changed_nroff_flag = 1;
 677         if (mcview_default_magic_flag)
 678             changed_magic_flag = 1;
 679         mcview_default_hex_mode = 0;
 680         mcview_default_nroff_flag = 0;
 681         mcview_default_magic_flag = 0;
 682
 683         switch (mcview_viewer (NULL, filename, start_line))
 684         {
 685         case MCVIEW_WANT_NEXT:
 686             move_dir = 1;
 687             break;
 688         case MCVIEW_WANT_PREV:
 689             move_dir = -1;
 690             break;
 691         default:
 692             move_dir = 0;
 693         }
 694
 695         if (changed_hex_mode && !mcview_altered_hex_mode)
 696             mcview_default_hex_mode = 1;
 697         if (changed_nroff_flag && !mcview_altered_nroff_flag)
 698             mcview_default_nroff_flag = 1;
 699         if (changed_magic_flag && !mcview_altered_magic_flag)
 700             mcview_default_magic_flag = 1;
 701
 702         dialog_switch_process_pending ();
 703     }
 704     else if (internal)
 705     {
 706         char view_entry[BUF_TINY];
 707
 708         if (start_line != 0)
 709             g_snprintf (view_entry, sizeof (view_entry), "View:%d", start_line);
 710         else
 711             strcpy (view_entry, "View");
 712
 713         if (regex_command (filename, view_entry, &move_dir) == 0)
 714         {
 715             switch (mcview_viewer (NULL, filename, start_line))
 716             {
 717             case MCVIEW_WANT_NEXT:
 718                 move_dir = 1;
 719                 break;
 720             case MCVIEW_WANT_PREV:
 721                 move_dir = -1;
 722                 break;
 723             default:
 724                 move_dir = 0;
 725             }
 726
 727             dialog_switch_process_pending ();
 728         }
 729     }
 730     else
 731     {
 732         if (viewer == NULL)
 733         {
 734             viewer = getenv ("VIEWER");
 735             if (viewer == NULL)
 736                 viewer = getenv ("PAGER");
 737             if (viewer == NULL)
 738                 viewer = "view";
 739         }
 740
 741         execute_with_vfs_arg (viewer, filename);
 742     }
 743
 744     return move_dir;
 745 }
 746
 747 /* --------------------------------------------------------------------------------------------- */
 748 /** view_file (filename, plain_view, internal)
 749  *
 750  * Inputs:
 751  *   filename:   The file name to view
 752  *   plain_view: If set does not do any fancy pre-processing (no filtering) and
 753  *               always invokes the internal viewer.
 754  *   internal:   If set uses the internal viewer, otherwise an external viewer.
 755  */
 756
 757 int
 758 view_file (const char *filename, int plain_view, int internal)
 759 {
 760     return view_file_at_line (filename, plain_view, internal, 0);
 761 }
 762
 763
 764 /* --------------------------------------------------------------------------------------------- */
 765 /** Run user's preferred viewer on the currently selected file */
 766
 767 void
 768 view_cmd (void)
 769 {
 770     do_view_cmd (FALSE);
 771 }
 772
 773 /* --------------------------------------------------------------------------------------------- */
 774 /** Ask for file and run user's preferred viewer on it */
 775
 776 void
 777 view_file_cmd (void)
 778 {
 779     char *filename;
 780
 781     filename =
 782         input_expand_dialog (_("View file"), _("Filename:"),
 783                              MC_HISTORY_FM_VIEW_FILE, selection (current_panel)->fname);
 784     if (!filename)
 785         return;
 786
 787     view_file (filename, 0, use_internal_view);
 788     g_free (filename);
 789 }
 790
 791 /* --------------------------------------------------------------------------------------------- */
 792 /** Run plain internal viewer on the currently selected file */
 793 void
 794 view_raw_cmd (void)
 795 {
 796     do_view_cmd (TRUE);
 797 }
 798
 799 /* --------------------------------------------------------------------------------------------- */
 800
 801 void
 802 view_filtered_cmd (void)
 803 {
 804     char *command;
 805     const char *initial_command;
 806
 807     if (cmdline->buffer[0] == '\0')
 808         initial_command = selection (current_panel)->fname;
 809     else
 810         initial_command = cmdline->buffer;
 811
 812     command =
 813         input_dialog (_("Filtered view"),
 814                       _("Filter command and arguments:"),
 815                       MC_HISTORY_FM_FILTERED_VIEW, initial_command);
 816
 817     if (command != NULL)
 818     {
 819         mcview_viewer (command, "", 0);
 820         g_free (command);
 821         dialog_switch_process_pending ();
 822     }
 823 }
 824
 825 /* --------------------------------------------------------------------------------------------- */
 826
 827 void
 828 do_edit_at_line (const vfs_path_t * what_vpath, gboolean internal, int start_line)
 829 {
 830     static const char *editor = NULL;
 831
 832 #ifdef USE_INTERNAL_EDIT
 833     if (internal)
 834         edit_file (what_vpath, start_line);
 835     else
 836 #else
 837     (void) start_line;
 838 #endif /* USE_INTERNAL_EDIT */
 839     {
 840         char *what;
 841
 842         what = vfs_path_to_str (what_vpath);
 843         if (editor == NULL)
 844         {
 845             editor = getenv ("EDITOR");
 846             if (editor == NULL)
 847                 editor = get_default_editor ();
 848         }
 849         execute_with_vfs_arg (editor, what);
 850         g_free (what);
 851     }
 852
 853     if (mc_global.mc_run_mode == MC_RUN_FULL)
 854         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 855
 856 #ifdef USE_INTERNAL_EDIT
 857     if (use_internal_edit)
 858         dialog_switch_process_pending ();
 859     else
 860 #endif /* USE_INTERNAL_EDIT */
 861         repaint_screen ();
 862 }
 863
 864 /* --------------------------------------------------------------------------------------------- */
 865
 866 void
 867 edit_cmd (void)
 868 {
 869     if (regex_command (selection (current_panel)->fname, "Edit", NULL) == 0)
 870     {
 871         vfs_path_t *fname;
 872
 873         fname = vfs_path_from_str (selection (current_panel)->fname);
 874         do_edit (fname);
 875         vfs_path_free (fname);
 876     }
 877 }
 878
 879 /* --------------------------------------------------------------------------------------------- */
 880
 881 #ifdef USE_INTERNAL_EDIT
 882 void
 883 edit_cmd_force_internal (void)
 884 {
 885     if (regex_command (selection (current_panel)->fname, "Edit", NULL) == 0)
 886     {
 887         vfs_path_t *fname;
 888
 889         fname = vfs_path_from_str (selection (current_panel)->fname);
 890         do_edit_at_line (fname, TRUE, 0);
 891         vfs_path_free (fname);
 892     }
 893 }
 894 #endif
 895
 896 /* --------------------------------------------------------------------------------------------- */
 897
 898 void
 899 edit_cmd_new (void)
 900 {
 901 #if HAVE_CHARSET
 902     mc_global.source_codepage = default_source_codepage;
 903 #endif
 904     do_edit (NULL);
 905 }
 906
 907 /* --------------------------------------------------------------------------------------------- */
 908 /** Invoked by F5.  Copy, default to the other panel.  */
 909
 910 void
 911 copy_cmd (void)
 912 {
 913     save_cwds_stat ();
 914     if (panel_operate (current_panel, OP_COPY, FALSE))
 915     {
 916         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 917         repaint_screen ();
 918     }
 919 }
 920
 921 /* --------------------------------------------------------------------------------------------- */
 922 /** Invoked by F6.  Move/rename, default to the other panel, ignore marks.  */
 923
 924 void
 925 rename_cmd (void)
 926 {
 927     save_cwds_stat ();
 928     if (panel_operate (current_panel, OP_MOVE, FALSE))
 929     {
 930         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 931         repaint_screen ();
 932     }
 933 }
 934
 935 /* --------------------------------------------------------------------------------------------- */
 936 /** Invoked by F15.  Copy, default to the same panel, ignore marks.  */
 937
 938 void
 939 copy_cmd_local (void)
 940 {
 941     save_cwds_stat ();
 942     if (panel_operate (current_panel, OP_COPY, TRUE))
 943     {
 944         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 945         repaint_screen ();
 946     }
 947 }
 948
 949 /* --------------------------------------------------------------------------------------------- */
 950 /** Invoked by F16.  Move/rename, default to the same panel.  */
 951
 952 void
 953 rename_cmd_local (void)
 954 {
 955     save_cwds_stat ();
 956     if (panel_operate (current_panel, OP_MOVE, TRUE))
 957     {
 958         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 959         repaint_screen ();
 960     }
 961 }
 962
 963 /* --------------------------------------------------------------------------------------------- */
 964
 965 void
 966 mkdir_cmd (void)
 967 {
 968     char *dir;
 969     const char *name = "";
 970
 971     /* If 'on' then automatically fills name with current selected item name */
 972     if (auto_fill_mkdir_name && strcmp (selection (current_panel)->fname, "..") != 0)
 973         name = selection (current_panel)->fname;
 974
 975     dir =
 976         input_expand_dialog (_("Create a new Directory"),
 977                              _("Enter directory name:"), MC_HISTORY_FM_MKDIR, name);
 978
 979     if (!dir)
 980         return;
 981
 982     if (*dir)
 983     {
 984         vfs_path_t *absdir;
 985         if (dir[0] == '/' || dir[0] == '~')
 986             absdir = vfs_path_from_str (dir);
 987         else
 988             absdir = vfs_path_append_new (current_panel->cwd_vpath, dir, NULL);
 989
 990         save_cwds_stat ();
 991         if (my_mkdir (absdir, 0777) == 0)
 992         {
 993             update_panels (UP_OPTIMIZE, dir);
 994             repaint_screen ();
 995             select_item (current_panel);
 996         }
 997         else
 998         {
 999             message (D_ERROR, MSG_ERROR, "%s", unix_error_string (errno));
1000         }
1001         vfs_path_free (absdir);
1002     }
1003     g_free (dir);
1004 }
1005
1006 /* --------------------------------------------------------------------------------------------- */
1007
1008 void
1009 delete_cmd (void)
1010 {
1011     save_cwds_stat ();
1012
1013     if (panel_operate (current_panel, OP_DELETE, FALSE))
1014     {
1015         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
1016         repaint_screen ();
1017     }
1018 }
1019
1020 /* --------------------------------------------------------------------------------------------- */
1021 /** Invoked by F18.  Remove selected file, regardless of marked files.  */
1022
1023 void
1024 delete_cmd_local (void)
1025 {
1026     save_cwds_stat ();
1027
1028     if (panel_operate (current_panel, OP_DELETE, TRUE))
1029     {
1030         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
1031         repaint_screen ();
1032     }
1033 }
1034
1035 /* --------------------------------------------------------------------------------------------- */
1036
1037 void
1038 find_cmd (void)
1039 {
1040     find_file ();
1041 }
1042
1043 /* --------------------------------------------------------------------------------------------- */
1044 /** Invoked from the left/right menus */
1045
1046 void
1047 filter_cmd (void)
1048 {
1049     WPanel *p;
1050
1051     if (!SELECTED_IS_PANEL)
1052         return;
1053
1054     p = MENU_PANEL;
1055     set_panel_filter (p);
1056 }
1057
1058 /* --------------------------------------------------------------------------------------------- */
1059
1060 void
1061 reread_cmd (void)
1062 {
1063     panel_update_flags_t flag = UP_ONLY_CURRENT;
1064
1065     if (get_current_type () == view_listing && get_other_type () == view_listing)
1066     {
1067         char *c_cwd, *o_cwd;
1068
1069         c_cwd = vfs_path_to_str (current_panel->cwd_vpath);
1070         o_cwd = vfs_path_to_str (other_panel->cwd_vpath);
1071
1072         if (strcmp (c_cwd, o_cwd) == 0)
1073             flag = UP_OPTIMIZE;
1074
1075         g_free (c_cwd);
1076         g_free (o_cwd);
1077     }
1078
1079     update_panels (UP_RELOAD | flag, UP_KEEPSEL);
1080     repaint_screen ();
1081 }
1082
1083 /* --------------------------------------------------------------------------------------------- */
1084
1085 void
1086 select_invert_cmd (void)
1087 {
1088     int i;
1089     file_entry *file;
1090
1091     for (i = 0; i < current_panel->count; i++)
1092     {
1093         file = &current_panel->dir.list[i];
1094         if (!panels_options.reverse_files_only || !S_ISDIR (file->st.st_mode))
1095             do_file_mark (current_panel, i, !file->f.marked);
1096     }
1097 }
1098
1099 /* --------------------------------------------------------------------------------------------- */
1100
1101 void
1102 select_cmd (void)
1103 {
1104     select_unselect_cmd (_("Select"), ":select_cmd: Select ", TRUE);
1105 }
1106
1107 /* --------------------------------------------------------------------------------------------- */
1108
1109 void
1110 unselect_cmd (void)
1111 {
1112     select_unselect_cmd (_("Unselect"), ":unselect_cmd: Unselect ", FALSE);
1113 }
1114
1115 /* --------------------------------------------------------------------------------------------- */
1116
1117 void
1118 ext_cmd (void)
1119 {
1120     vfs_path_t *buffer_vpath;
1121     vfs_path_t *extdir_vpath;
1122     int dir;
1123
1124     dir = 0;
1125     if (geteuid () == 0)
1126     {
1127         dir = query_dialog (_("Extension file edit"),
1128                             _("Which extension file you want to edit?"), D_NORMAL, 2,
1129                             _("&User"), _("&System Wide"));
1130     }
1131     extdir_vpath = vfs_path_build_filename (mc_global.sysconfig_dir, MC_LIB_EXT, NULL);
1132
1133     if (dir == 0)
1134     {
1135         buffer_vpath = mc_config_get_full_vpath (MC_FILEBIND_FILE);
1136         check_for_default (extdir_vpath, buffer_vpath);
1137         do_edit (buffer_vpath);
1138         vfs_path_free (buffer_vpath);
1139     }
1140     else if (dir == 1)
1141     {
1142         if (!exist_file (vfs_path_get_last_path_str (extdir_vpath)))
1143         {
1144             vfs_path_free (extdir_vpath);
1145             extdir_vpath = vfs_path_build_filename (mc_global.share_data_dir, MC_LIB_EXT, NULL);
1146         }
1147         do_edit (extdir_vpath);
1148     }
1149     vfs_path_free (extdir_vpath);
1150     flush_extension_file ();
1151 }
1152
1153 /* --------------------------------------------------------------------------------------------- */
1154 /** edit file menu for mc */
1155
1156 void
1157 edit_mc_menu_cmd (void)
1158 {
1159     vfs_path_t *buffer_vpath;
1160     vfs_path_t *menufile_vpath;
1161     int dir = 0;
1162
1163     dir = query_dialog (_("Menu edit"),
1164                         _("Which menu file do you want to edit?"),
1165                         D_NORMAL, geteuid ()? 2 : 3, _("&Local"), _("&User"), _("&System Wide"));
1166
1167     menufile_vpath = vfs_path_build_filename (mc_global.sysconfig_dir, MC_GLOBAL_MENU, NULL);
1168
1169     if (!exist_file (vfs_path_get_last_path_str (menufile_vpath)))
1170     {
1171         vfs_path_free (menufile_vpath);
1172         menufile_vpath = vfs_path_build_filename (mc_global.share_data_dir, MC_GLOBAL_MENU, NULL);
1173     }
1174
1175     switch (dir)
1176     {
1177     case 0:
1178         buffer_vpath = vfs_path_from_str (MC_LOCAL_MENU);
1179         check_for_default (menufile_vpath, buffer_vpath);
1180         chmod (vfs_path_get_last_path_str (buffer_vpath), 0600);
1181         break;
1182
1183     case 1:
1184         buffer_vpath = mc_config_get_full_vpath (MC_USERMENU_FILE);
1185         check_for_default (menufile_vpath, buffer_vpath);
1186         break;
1187
1188     case 2:
1189         buffer_vpath = vfs_path_build_filename (mc_global.sysconfig_dir, MC_GLOBAL_MENU, NULL);
1190         if (!exist_file (vfs_path_get_last_path_str (buffer_vpath)))
1191         {
1192             vfs_path_free (buffer_vpath);
1193             buffer_vpath = vfs_path_build_filename (mc_global.share_data_dir, MC_GLOBAL_MENU, NULL);
1194         }
1195         break;
1196
1197     default:
1198         vfs_path_free (menufile_vpath);
1199         return;
1200     }
1201
1202     do_edit (buffer_vpath);
1203
1204     vfs_path_free (buffer_vpath);
1205     vfs_path_free (menufile_vpath);
1206 }
1207
1208 /* --------------------------------------------------------------------------------------------- */
1209
1210 void
1211 edit_fhl_cmd (void)
1212 {
1213     vfs_path_t *buffer_vpath = NULL;
1214     vfs_path_t *fhlfile_vpath = NULL;
1215
1216     int dir;
1217
1218     dir = 0;
1219     if (geteuid () == 0)
1220     {
1221         dir = query_dialog (_("Highlighting groups file edit"),
1222                             _("Which highlighting file you want to edit?"), D_NORMAL, 2,
1223                             _("&User"), _("&System Wide"));
1224     }
1225     fhlfile_vpath = vfs_path_build_filename (mc_global.sysconfig_dir, MC_FHL_INI_FILE, NULL);
1226
1227     if (dir == 0)
1228     {
1229         buffer_vpath = mc_config_get_full_vpath (MC_FHL_INI_FILE);
1230         check_for_default (fhlfile_vpath, buffer_vpath);
1231         do_edit (buffer_vpath);
1232         vfs_path_free (buffer_vpath);
1233     }
1234     else if (dir == 1)
1235     {
1236         if (!exist_file (vfs_path_get_last_path_str (fhlfile_vpath)))
1237         {
1238             vfs_path_free (fhlfile_vpath);
1239             fhlfile_vpath =
1240                 vfs_path_build_filename (mc_global.sysconfig_dir, MC_FHL_INI_FILE, NULL);
1241         }
1242         do_edit (fhlfile_vpath);
1243     }
1244     vfs_path_free (fhlfile_vpath);
1245
1246     /* refresh highlighting rules */
1247     mc_fhl_free (&mc_filehighlight);
1248     mc_filehighlight = mc_fhl_new (TRUE);
1249 }
1250
1251 /* --------------------------------------------------------------------------------------------- */
1252
1253 void
1254 hotlist_cmd (void)
1255 {
1256     char *target;
1257
1258     target = hotlist_show (LIST_HOTLIST);
1259     if (!target)
1260         return;
1261
1262     if (get_current_type () == view_tree)
1263         tree_chdir (the_tree, target);
1264     else
1265     {
1266         char *cmd = g_strconcat ("cd ", target, (char *) NULL);
1267         do_cd_command (cmd);
1268         g_free (cmd);
1269     }
1270     g_free (target);
1271 }
1272
1273 #ifdef ENABLE_VFS
1274 void
1275 vfs_list (void)
1276 {
1277     char *target;
1278     vfs_path_t *target_vpath;
1279
1280     target = hotlist_show (LIST_VFSLIST);
1281     if (!target)
1282         return;
1283
1284     target_vpath = vfs_path_from_str (target);
1285     if (!do_cd (target_vpath, cd_exact))
1286         message (D_ERROR, MSG_ERROR, _("Cannot change directory"));
1287     vfs_path_free (target_vpath);
1288     g_free (target);
1289 }
1290 #endif /* ENABLE_VFS */
1291
1292 /* --------------------------------------------------------------------------------------------- */
1293
1294 void
1295 compare_dirs_cmd (void)
1296 {
1297     int choice;
1298     enum CompareMode thorough_flag;
1299
1300     choice =
1301         query_dialog (_("Compare directories"),
1302                       _("Select compare method:"), D_NORMAL, 4,
1303                       _("&Quick"), _("&Size only"), _("&Thorough"), _("&Cancel"));
1304
1305     if (choice < 0 || choice > 2)
1306         return;
1307
1308     thorough_flag = choice;
1309
1310     if (get_current_type () == view_listing && get_other_type () == view_listing)
1311     {
1312         compare_dir (current_panel, other_panel, thorough_flag);
1313         compare_dir (other_panel, current_panel, thorough_flag);
1314     }
1315     else
1316     {
1317         message (D_ERROR, MSG_ERROR,
1318                  _("Both panels should be in the listing mode\nto use this command"));
1319     }
1320 }
1321
1322 /* --------------------------------------------------------------------------------------------- */
1323
1324 #ifdef USE_DIFF_VIEW
1325 void
1326 diff_view_cmd (void)
1327 {
1328     dview_diff_cmd ();
1329
1330     if (mc_global.mc_run_mode == MC_RUN_FULL)
1331         update_panels (UP_OPTIMIZE, UP_KEEPSEL);
1332
1333     dialog_switch_process_pending ();
1334 }
1335 #endif
1336
1337 /* --------------------------------------------------------------------------------------------- */
1338
1339 void
1340 swap_cmd (void)
1341 {
1342     swap_panels ();
1343     tty_touch_screen ();
1344     repaint_screen ();
1345 }
1346
1347 /* --------------------------------------------------------------------------------------------- */
1348
1349 void
1350 view_other_cmd (void)
1351 {
1352     static int message_flag = TRUE;
1353
1354     if (!mc_global.tty.xterm_flag && mc_global.tty.console_flag == '\0'
1355         && !mc_global.tty.use_subshell && !output_starts_shell)
1356     {
1357         if (message_flag)
1358             message (D_ERROR, MSG_ERROR,
1359                      _("Not an xterm or Linux console;\nthe panels cannot be toggled."));
1360         message_flag = FALSE;
1361     }
1362     else
1363     {
1364         toggle_panels ();
1365     }
1366 }
1367
1368 /* --------------------------------------------------------------------------------------------- */
1369
1370 void
1371 link_cmd (link_type_t link_type)
1372 {
1373     char *filename = selection (current_panel)->fname;
1374
1375     if (filename != NULL)
1376         do_link (link_type, filename);
1377 }
1378
1379 /* --------------------------------------------------------------------------------------------- */
1380
1381 void
1382 edit_symlink_cmd (void)
1383 {
1384     if (S_ISLNK (selection (current_panel)->st.st_mode))
1385     {
1386         char buffer[MC_MAXPATHLEN];
1387         char *p = NULL;
1388         int i;
1389         char *dest, *q;
1390         vfs_path_t *p_vpath;
1391
1392         p = selection (current_panel)->fname;
1393         p_vpath = vfs_path_from_str (p);
1394
1395         q = g_strdup_printf (_("Symlink `%s\' points to:"), str_trunc (p, 32));
1396
1397         i = readlink (p, buffer, MC_MAXPATHLEN - 1);
1398         if (i > 0)
1399         {
1400             buffer[i] = 0;
1401             dest = input_expand_dialog (_("Edit symlink"), q, MC_HISTORY_FM_EDIT_LINK, buffer);
1402             if (dest)
1403             {
1404                 if (*dest && strcmp (buffer, dest))
1405                 {
1406                     save_cwds_stat ();
1407                     if (mc_unlink (p_vpath) == -1)
1408                     {
1409                         message (D_ERROR, MSG_ERROR, _("edit symlink, unable to remove %s: %s"),
1410                                  p, unix_error_string (errno));
1411                     }
1412                     else
1413                     {
1414                         vfs_path_t *dest_vpath;
1415
1416                         dest_vpath = vfs_path_from_str_flags (dest, VPF_NO_CANON);
1417                         if (mc_symlink (dest_vpath, p_vpath) == -1)
1418                             message (D_ERROR, MSG_ERROR, _("edit symlink: %s"),
1419                                      unix_error_string (errno));
1420                         vfs_path_free (dest_vpath);
1421                     }
1422                     update_panels (UP_OPTIMIZE, UP_KEEPSEL);
1423                     repaint_screen ();
1424                 }
1425                 g_free (dest);
1426             }
1427         }
1428         g_free (q);
1429         vfs_path_free (p_vpath);
1430     }
1431     else
1432     {
1433         message (D_ERROR, MSG_ERROR, _("`%s' is not a symbolic link"),
1434                  selection (current_panel)->fname);
1435     }
1436 }
1437
1438 /* --------------------------------------------------------------------------------------------- */
1439
1440 void
1441 help_cmd (void)
1442 {
1443     ev_help_t event_data = { NULL, NULL };
1444
1445     if (current_panel->searching)
1446         event_data.node = "[Quick search]";
1447     else
1448         event_data.node = "[main]";
1449
1450     mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
1451 }
1452
1453 /* --------------------------------------------------------------------------------------------- */
1454
1455 void
1456 user_file_menu_cmd (void)
1457 {
1458     (void) user_menu_cmd (NULL, NULL, -1);
1459 }
1460
1461 /* --------------------------------------------------------------------------------------------- */
1462 /**
1463  * Return a random hint.  If force is not 0, ignore the timeout.
1464  */
1465
1466 char *
1467 get_random_hint (int force)
1468 {
1469     char *data, *result = NULL, *eol;
1470     int len;
1471     int start;
1472     static int last_sec;
1473     static struct timeval tv;
1474     GIConv conv;
1475     GString *buffer;
1476
1477     /* Do not change hints more often than one minute */
1478     gettimeofday (&tv, NULL);
1479     if (!force && !(tv.tv_sec > last_sec + 60))
1480         return g_strdup ("");
1481     last_sec = tv.tv_sec;
1482
1483     data = load_mc_home_file (mc_global.share_data_dir, MC_HINT, NULL);
1484     if (data == NULL)
1485         return NULL;
1486
1487     /* get a random entry */
1488     srand (tv.tv_sec);
1489     len = strlen (data);
1490     start = rand () % len;
1491
1492     for (; start != 0; start--)
1493         if (data[start] == '\n')
1494         {
1495             start++;
1496             break;
1497         }
1498
1499     eol = strchr (data + start, '\n');
1500     if (eol != NULL)
1501         *eol = '\0';
1502
1503     /* hint files are stored in utf-8 */
1504     /* try convert hint file from utf-8 to terminal encoding */
1505     conv = str_crt_conv_from ("UTF-8");
1506     if (conv != INVALID_CONV)
1507     {
1508         buffer = g_string_new ("");
1509         if (str_convert (conv, &data[start], buffer) != ESTR_FAILURE)
1510             result = g_strdup (buffer->str);
1511         g_string_free (buffer, TRUE);
1512         str_close_conv (conv);
1513     }
1514
1515     g_free (data);
1516     return result;
1517 }
1518
1519 /* --------------------------------------------------------------------------------------------- */
1520
1521 #ifdef ENABLE_VFS_NET
1522 #ifdef ENABLE_VFS_FTP
1523 void
1524 ftplink_cmd (void)
1525 {
1526     nice_cd (_("FTP to machine"), _(machine_str),
1527              "[FTP File System]", ":ftplink_cmd: FTP to machine ", "/#ftp:", 1);
1528 }
1529 #endif /* ENABLE_VFS_FTP */
1530
1531 /* --------------------------------------------------------------------------------------------- */
1532
1533 #ifdef ENABLE_VFS_FISH
1534 void
1535 fishlink_cmd (void)
1536 {
1537     nice_cd (_("Shell link to machine"), _(machine_str),
1538              "[FIle transfer over SHell filesystem]", ":fishlink_cmd: Shell link to machine ",
1539              "/#sh:", 1);
1540 }
1541 #endif /* ENABLE_VFS_FISH */
1542
1543 /* --------------------------------------------------------------------------------------------- */
1544
1545 #ifdef ENABLE_VFS_SMB
1546 void
1547 smblink_cmd (void)
1548 {
1549     nice_cd (_("SMB link to machine"), _(machine_str),
1550              "[SMB File System]", ":smblink_cmd: SMB link to machine ", "/#smb:", 0);
1551 }
1552 #endif /* ENABLE_VFS_SMB */
1553 #endif /* ENABLE_VFS_NET */
1554
1555 /* --------------------------------------------------------------------------------------------- */
1556
1557 #ifdef ENABLE_VFS_UNDELFS
1558 void
1559 undelete_cmd (void)
1560 {
1561     nice_cd (_("Undelete files on an ext2 file system"),
1562              _("Enter device (without /dev/) to undelete\nfiles on: (F1 for details)"),
1563              "[Undelete File System]", ":undelete_cmd: Undel on ext2 fs ", "/#undel:", 0);
1564 }
1565 #endif /* ENABLE_VFS_UNDELFS */
1566
1567 /* --------------------------------------------------------------------------------------------- */
1568
1569 void
1570 quick_cd_cmd (void)
1571 {
1572     char *p = cd_dialog ();
1573
1574     if (p && *p)
1575     {
1576         char *q = g_strconcat ("cd ", p, (char *) NULL);
1577
1578         do_cd_command (q);
1579         g_free (q);
1580     }
1581     g_free (p);
1582 }
1583
1584 /* --------------------------------------------------------------------------------------------- */
1585 /*!
1586    \brief calculate dirs sizes
1587
1588    calculate dirs sizes and resort panel:
1589    dirs_selected = show size for selected dirs,
1590    otherwise = show size for dir under cursor:
1591    dir under cursor ".." = show size for all dirs,
1592    otherwise = show size for dir under cursor
1593  */
1594
1595 void
1596 smart_dirsize_cmd (void)
1597 {
1598     WPanel *panel = current_panel;
1599     file_entry *entry;
1600
1601     entry = &(panel->dir.list[panel->selected]);
1602     if ((S_ISDIR (entry->st.st_mode) && (strcmp (entry->fname, "..") == 0)) || panel->dirs_marked)
1603         dirsizes_cmd ();
1604     else
1605         single_dirsize_cmd ();
1606 }
1607
1608 /* --------------------------------------------------------------------------------------------- */
1609
1610 void
1611 single_dirsize_cmd (void)
1612 {
1613     WPanel *panel = current_panel;
1614     file_entry *entry;
1615
1616     entry = &(panel->dir.list[panel->selected]);
1617     if (S_ISDIR (entry->st.st_mode) && strcmp (entry->fname, "..") != 0)
1618     {
1619         size_t marked = 0;
1620         uintmax_t total = 0;
1621         ComputeDirSizeUI *ui;
1622         vfs_path_t *p;
1623
1624         ui = compute_dir_size_create_ui ();
1625         p = vfs_path_from_str_flags (entry->fname, VPF_NO_CANON);
1626
1627         if (compute_dir_size (p, ui, compute_dir_size_update_ui, &marked, &total, TRUE) == FILE_CONT)
1628         {
1629             entry->st.st_size = (off_t) total;
1630             entry->f.dir_size_computed = 1;
1631         }
1632
1633         vfs_path_free (p);
1634         compute_dir_size_destroy_ui (ui);
1635     }
1636
1637     if (panels_options.mark_moves_down)
1638         send_message ((Widget *) panel, WIDGET_COMMAND, CK_Down);
1639
1640     recalculate_panel_summary (panel);
1641
1642     if (current_panel->sort_info.sort_field->sort_routine == (sortfn *) sort_size)
1643         panel_re_sort (panel);
1644
1645     panel->dirty = 1;
1646 }
1647
1648 /* --------------------------------------------------------------------------------------------- */
1649
1650 void
1651 dirsizes_cmd (void)
1652 {
1653     WPanel *panel = current_panel;
1654     int i;
1655     ComputeDirSizeUI *ui;
1656
1657     ui = compute_dir_size_create_ui ();
1658
1659     for (i = 0; i < panel->count; i++)
1660         if (S_ISDIR (panel->dir.list[i].st.st_mode)
1661             && ((panel->dirs_marked && panel->dir.list[i].f.marked)
1662                 || !panel->dirs_marked) && strcmp (panel->dir.list[i].fname, "..") != 0)
1663         {
1664             vfs_path_t *p;
1665             size_t marked = 0;
1666             uintmax_t total = 0;
1667             gboolean ok;
1668
1669             p = vfs_path_from_str_flags (panel->dir.list[i].fname, VPF_NO_CANON);
1670             ok = compute_dir_size (p, ui, compute_dir_size_update_ui, &marked, &total,
1671                                    TRUE) != FILE_CONT;
1672             vfs_path_free (p);
1673
1674             if (ok)
1675                 break;
1676
1677             panel->dir.list[i].st.st_size = (off_t) total;
1678             panel->dir.list[i].f.dir_size_computed = 1;
1679         }
1680
1681     compute_dir_size_destroy_ui (ui);
1682
1683     recalculate_panel_summary (panel);
1684
1685     if (current_panel->sort_info.sort_field->sort_routine == (sortfn *) sort_size)
1686         panel_re_sort (panel);
1687
1688     panel->dirty = 1;
1689 }
1690
1691 /* --------------------------------------------------------------------------------------------- */
1692
1693 void
1694 save_setup_cmd (void)
1695 {
1696     vfs_path_t *vpath;
1697     char *path;
1698
1699     vpath = mc_config_get_full_vpath (MC_CONFIG_FILE);
1700     path = vfs_path_to_str_flags (vpath, 0, VPF_STRIP_HOME);
1701     vfs_path_free (vpath);
1702
1703     if (save_setup (TRUE, TRUE))
1704         message (D_NORMAL, _("Setup"), _("Setup saved to %s"), path);
1705     else
1706         message (D_ERROR, _("Setup"), _("Unable to save setup to %s"), path);
1707     g_free (path);
1708 }
1709
1710 /* --------------------------------------------------------------------------------------------- */
1711
1712 void
1713 info_cmd_no_menu (void)
1714 {
1715     if (get_display_type (0) == view_info)
1716         set_display_type (0, view_listing);
1717     else if (get_display_type (1) == view_info)
1718         set_display_type (1, view_listing);
1719     else
1720         set_display_type (current_panel == left_panel ? 1 : 0, view_info);
1721 }
1722
1723 /* --------------------------------------------------------------------------------------------- */
1724
1725 void
1726 quick_cmd_no_menu (void)
1727 {
1728     if (get_display_type (0) == view_quick)
1729         set_display_type (0, view_listing);
1730     else if (get_display_type (1) == view_quick)
1731         set_display_type (1, view_listing);
1732     else
1733         set_display_type (current_panel == left_panel ? 1 : 0, view_quick);
1734 }
1735
1736 /* --------------------------------------------------------------------------------------------- */
1737
1738 void
1739 listing_cmd (void)
1740 {
1741     switch_to_listing (MENU_PANEL_IDX);
1742 }
1743
1744 /* --------------------------------------------------------------------------------------------- */
1745
1746 void
1747 change_listing_cmd (void)
1748 {
1749     int list_type;
1750     int use_msformat;
1751     char *user, *status;
1752     WPanel *p = NULL;
1753
1754     if (get_display_type (MENU_PANEL_IDX) == view_listing)
1755         p = MENU_PANEL_IDX == 0 ? left_panel : right_panel;
1756
1757     list_type = display_box (p, &user, &status, &use_msformat, MENU_PANEL_IDX);
1758
1759     if (list_type != -1)
1760     {
1761         switch_to_listing (MENU_PANEL_IDX);
1762         p = MENU_PANEL_IDX == 0 ? left_panel : right_panel;
1763         configure_panel_listing (p, list_type, use_msformat, user, status);
1764     }
1765 }
1766
1767 /* --------------------------------------------------------------------------------------------- */
1768
1769 void
1770 panel_tree_cmd (void)
1771 {
1772     set_display_type (MENU_PANEL_IDX, view_tree);
1773 }
1774
1775 /* --------------------------------------------------------------------------------------------- */
1776
1777 void
1778 info_cmd (void)
1779 {
1780     set_display_type (MENU_PANEL_IDX, view_info);
1781 }
1782
1783 /* --------------------------------------------------------------------------------------------- */
1784
1785 void
1786 quick_view_cmd (void)
1787 {
1788     if ((WPanel *) get_panel_widget (MENU_PANEL_IDX) == current_panel)
1789         change_panel ();
1790     set_display_type (MENU_PANEL_IDX, view_quick);
1791 }
1792
1793 /* --------------------------------------------------------------------------------------------- */
1794
1795 void
1796 toggle_listing_cmd (void)
1797 {
1798     int current = get_current_index ();
1799     WPanel *p = (WPanel *) get_panel_widget (current);
1800
1801     set_basic_panel_listing_to (current, (p->list_type + 1) % LIST_TYPES);
1802 }
1803
1804 /* --------------------------------------------------------------------------------------------- */
1805
1806 void
1807 encoding_cmd (void)
1808 {
1809     if (SELECTED_IS_PANEL)
1810         panel_change_encoding (MENU_PANEL);
1811 }
1812
1813 /* --------------------------------------------------------------------------------------------- */