src/filemanager/panel.c

   1 /*
   2    Panel managing.
   3
   4    Copyright (C) 1994-2024
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Miguel de Icaza, 1995
   9    Timur Bakeyev, 1997, 1999
  10    Slava Zanko <slavazanko@gmail.com>, 2013
  11    Andrew Borodin <aborodin@vmail.ru>, 2013-2023
  12
  13    This file is part of the Midnight Commander.
  14
  15    The Midnight Commander is free software: you can redistribute it
  16    and/or modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation, either version 3 of the License,
  18    or (at your option) any later version.
  19
  20    The Midnight Commander is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23    GNU General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  27  */
  28
  29 /** \file panel.c
  30  *  \brief Source: panel managin module
  31  */
  32
  33 #include <config.h>
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #include "lib/global.h"
  40
  41 #include "lib/tty/tty.h"
  42 #include "lib/tty/key.h"        /* XCTRL and ALT macros  */
  43 #include "lib/skin.h"
  44 #include "lib/strutil.h"
  45 #include "lib/mcconfig.h"
  46 #include "lib/vfs/vfs.h"
  47 #include "lib/unixcompat.h"
  48 #include "lib/search.h"
  49 #include "lib/timefmt.h"        /* file_date() */
  50 #include "lib/util.h"
  51 #include "lib/widget.h"
  52 #ifdef HAVE_CHARSET
  53 #include "lib/charsets.h"       /* get_codepage_id () */
  54 #endif
  55 #include "lib/event.h"
  56
  57 #include "src/setup.h"          /* For loading/saving panel options */
  58 #include "src/execute.h"
  59 #ifdef HAVE_CHARSET
  60 #include "src/selcodepage.h"    /* select_charset (), SELECT_CHARSET_NO_TRANSLATE */
  61 #endif
  62 #include "src/keymap.h"         /* global_keymap_t */
  63 #include "src/history.h"
  64 #ifdef ENABLE_SUBSHELL
  65 #include "src/subshell/subshell.h"      /* do_subshell_chdir() */
  66 #endif
  67
  68 #include "src/usermenu.h"
  69
  70 #include "dir.h"
  71 #include "boxes.h"
  72 #include "tree.h"
  73 #include "ext.h"                /* regexp_command */
  74 #include "layout.h"             /* Most layout variables are here */
  75 #include "cmd.h"
  76 #include "command.h"            /* cmdline */
  77 #include "filemanager.h"
  78 #include "mountlist.h"          /* my_statfs */
  79 #include "cd.h"                 /* cd_error_message() */
  80
  81 #include "panel.h"
  82
  83 /*** global variables ****************************************************************************/
  84
  85 /* The hook list for the select file function */
  86 hook_t *select_file_hook = NULL;
  87
  88 mc_fhl_t *mc_filehighlight = NULL;
  89
  90 /*** file scope macro definitions ****************************************************************/
  91
  92 typedef enum
  93 {
  94     FATTR_NORMAL = 0,
  95     FATTR_CURRENT,
  96     FATTR_MARKED,
  97     FATTR_MARKED_CURRENT,
  98     FATTR_STATUS
  99 } file_attr_t;
 100
 101 /* select/unselect dialog results */
 102 #define SELECT_RESET ((mc_search_t *)(-1))
 103 #define SELECT_ERROR ((mc_search_t *)(-2))
 104
 105 /* mouse position relative to file list */
 106 #define MOUSE_UPPER_FILE_LIST (-1)
 107 #define MOUSE_BELOW_FILE_LIST (-2)
 108 #define MOUSE_AFTER_LAST_FILE (-3)
 109
 110 /*** file scope type declarations ****************************************************************/
 111
 112 typedef enum
 113 {
 114     MARK_DONT_MOVE = 0,
 115     MARK_DOWN = 1,
 116     MARK_FORCE_DOWN = 2,
 117     MARK_FORCE_UP = 3
 118 } mark_act_t;
 119
 120 /*
 121  * This describes a format item.  The parse_display_format routine parses
 122  * the user specified format and creates a linked list of format_item_t structures.
 123  */
 124 typedef struct format_item_t
 125 {
 126     int requested_field_len;
 127     int field_len;
 128     align_crt_t just_mode;
 129     gboolean expand;
 130     const char *(*string_fn) (file_entry_t *, int len);
 131     char *title;
 132     const char *id;
 133 } format_item_t;
 134
 135 /* File name scroll states */
 136 typedef enum
 137 {
 138     FILENAME_NOSCROLL = 1,
 139     FILENAME_SCROLL_LEFT = 2,
 140     FILENAME_SCROLL_RIGHT = 4
 141 } filename_scroll_flag_t;
 142
 143 /*** forward declarations (file scope functions) *************************************************/
 144
 145 static const char *string_file_name (file_entry_t * fe, int len);
 146 static const char *string_file_size (file_entry_t * fe, int len);
 147 static const char *string_file_size_brief (file_entry_t * fe, int len);
 148 static const char *string_file_type (file_entry_t * fe, int len);
 149 static const char *string_file_mtime (file_entry_t * fe, int len);
 150 static const char *string_file_atime (file_entry_t * fe, int len);
 151 static const char *string_file_ctime (file_entry_t * fe, int len);
 152 static const char *string_file_permission (file_entry_t * fe, int len);
 153 static const char *string_file_perm_octal (file_entry_t * fe, int len);
 154 static const char *string_file_nlinks (file_entry_t * fe, int len);
 155 static const char *string_inode (file_entry_t * fe, int len);
 156 static const char *string_file_nuid (file_entry_t * fe, int len);
 157 static const char *string_file_ngid (file_entry_t * fe, int len);
 158 static const char *string_file_owner (file_entry_t * fe, int len);
 159 static const char *string_file_group (file_entry_t * fe, int len);
 160 static const char *string_marked (file_entry_t * fe, int len);
 161 static const char *string_space (file_entry_t * fe, int len);
 162 static const char *string_dot (file_entry_t * fe, int len);
 163
 164 /*** file scope variables ************************************************************************/
 165
 166 /* *INDENT-OFF* */
 167 static panel_field_t panel_fields[] = {
 168     {
 169      "unsorted", 12, TRUE, J_LEFT_FIT,
 170      /* TRANSLATORS: one single character to represent 'unsorted' sort mode  */
 171      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 172      N_("sort|u"),
 173      N_("&Unsorted"), TRUE, FALSE,
 174      string_file_name,
 175      (GCompareFunc) unsorted
 176     }
 177     ,
 178     {
 179      "name", 12, TRUE, J_LEFT_FIT,
 180      /* TRANSLATORS: one single character to represent 'name' sort mode  */
 181      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 182      N_("sort|n"),
 183      N_("&Name"), TRUE, TRUE,
 184      string_file_name,
 185      (GCompareFunc) sort_name
 186     }
 187     ,
 188     {
 189      "version", 12, TRUE, J_LEFT_FIT,
 190      /* TRANSLATORS: one single character to represent 'version' sort mode  */
 191      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 192      N_("sort|v"),
 193      N_("&Version"), TRUE, FALSE,
 194      string_file_name,
 195      (GCompareFunc) sort_vers
 196     }
 197     ,
 198     {
 199      "extension", 12, TRUE, J_LEFT_FIT,
 200      /* TRANSLATORS: one single character to represent 'extension' sort mode  */
 201      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 202      N_("sort|e"),
 203      N_("E&xtension"), TRUE, FALSE,
 204      string_file_name,          /* TODO: string_file_ext */
 205      (GCompareFunc) sort_ext
 206     }
 207     ,
 208     {
 209      "size", 7, FALSE, J_RIGHT,
 210      /* TRANSLATORS: one single character to represent 'size' sort mode  */
 211      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 212      N_("sort|s"),
 213      N_("&Size"), TRUE, TRUE,
 214      string_file_size,
 215      (GCompareFunc) sort_size
 216     }
 217     ,
 218     {
 219      "bsize", 7, FALSE, J_RIGHT,
 220      "",
 221      N_("Block Size"), FALSE, FALSE,
 222      string_file_size_brief,
 223      (GCompareFunc) sort_size
 224     }
 225     ,
 226     {
 227      "type", 1, FALSE, J_LEFT,
 228      "",
 229      "", FALSE, TRUE,
 230      string_file_type,
 231      NULL
 232     }
 233     ,
 234     {
 235      "mtime", 12, FALSE, J_RIGHT,
 236      /* TRANSLATORS: one single character to represent 'Modify time' sort mode  */
 237      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 238      N_("sort|m"),
 239      N_("&Modify time"), TRUE, TRUE,
 240      string_file_mtime,
 241      (GCompareFunc) sort_time
 242     }
 243     ,
 244     {
 245      "atime", 12, FALSE, J_RIGHT,
 246      /* TRANSLATORS: one single character to represent 'Access time' sort mode  */
 247      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 248      N_("sort|a"),
 249      N_("&Access time"), TRUE, TRUE,
 250      string_file_atime,
 251      (GCompareFunc) sort_atime
 252     }
 253     ,
 254     {
 255      "ctime", 12, FALSE, J_RIGHT,
 256      /* TRANSLATORS: one single character to represent 'Change time' sort mode  */
 257      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 258      N_("sort|h"),
 259      N_("C&hange time"), TRUE, TRUE,
 260      string_file_ctime,
 261      (GCompareFunc) sort_ctime
 262     }
 263     ,
 264     {
 265      "perm", 10, FALSE, J_LEFT,
 266      "",
 267      N_("Permission"), FALSE, TRUE,
 268      string_file_permission,
 269      NULL
 270     }
 271     ,
 272     {
 273      "mode", 6, FALSE, J_RIGHT,
 274      "",
 275      N_("Perm"), FALSE, TRUE,
 276      string_file_perm_octal,
 277      NULL
 278     }
 279     ,
 280     {
 281      "nlink", 2, FALSE, J_RIGHT,
 282      "",
 283      N_("Nl"), FALSE, TRUE,
 284      string_file_nlinks, NULL
 285     }
 286     ,
 287     {
 288      "inode", 5, FALSE, J_RIGHT,
 289      /* TRANSLATORS: one single character to represent 'inode' sort mode  */
 290      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 291      N_("sort|i"),
 292      N_("&Inode"), TRUE, TRUE,
 293      string_inode,
 294      (GCompareFunc) sort_inode
 295     }
 296     ,
 297     {
 298      "nuid", 5, FALSE, J_RIGHT,
 299      "",
 300      N_("UID"), FALSE, FALSE,
 301      string_file_nuid,
 302      NULL
 303     }
 304     ,
 305     {
 306      "ngid", 5, FALSE, J_RIGHT,
 307      "",
 308      N_("GID"), FALSE, FALSE,
 309      string_file_ngid,
 310      NULL
 311     }
 312     ,
 313     {
 314      "owner", 8, FALSE, J_LEFT_FIT,
 315      "",
 316      N_("Owner"), FALSE, TRUE,
 317      string_file_owner,
 318      NULL
 319     }
 320     ,
 321     {
 322      "group", 8, FALSE, J_LEFT_FIT,
 323      "",
 324      N_("Group"), FALSE, TRUE,
 325      string_file_group,
 326      NULL
 327     }
 328     ,
 329     {
 330      "mark", 1, FALSE, J_RIGHT,
 331      "",
 332      " ", FALSE, TRUE,
 333      string_marked,
 334      NULL
 335     }
 336     ,
 337     {
 338      "|", 1, FALSE, J_RIGHT,
 339      "",
 340      " ", FALSE, TRUE,
 341      NULL,
 342      NULL
 343     }
 344     ,
 345     {
 346      "space", 1, FALSE, J_RIGHT,
 347      "",
 348      " ", FALSE, TRUE,
 349      string_space,
 350      NULL
 351     }
 352     ,
 353     {
 354      "dot", 1, FALSE, J_RIGHT,
 355      "",
 356      " ", FALSE, FALSE,
 357      string_dot,
 358      NULL
 359     }
 360     ,
 361     {
 362      NULL, 0, FALSE, J_RIGHT, NULL, NULL, FALSE, FALSE, NULL, NULL
 363     }
 364 };
 365 /* *INDENT-ON* */
 366
 367 static char *panel_sort_up_char = NULL;
 368 static char *panel_sort_down_char = NULL;
 369
 370 static char *panel_hiddenfiles_show_char = NULL;
 371 static char *panel_hiddenfiles_hide_char = NULL;
 372 static char *panel_history_prev_item_char = NULL;
 373 static char *panel_history_next_item_char = NULL;
 374 static char *panel_history_show_list_char = NULL;
 375 static char *panel_filename_scroll_left_char = NULL;
 376 static char *panel_filename_scroll_right_char = NULL;
 377
 378 /* Panel that selection started */
 379 static WPanel *mouse_mark_panel = NULL;
 380
 381 static gboolean mouse_marking = FALSE;
 382 static int state_mark = 0;
 383
 384 static GString *string_file_name_buffer;
 385
 386 /* --------------------------------------------------------------------------------------------- */
 387 /*** file scope functions ************************************************************************/
 388 /* --------------------------------------------------------------------------------------------- */
 389
 390 static panelized_descr_t *
 391 panelized_descr_new (void)
 392 {
 393     panelized_descr_t *p;
 394
 395     p = g_new0 (panelized_descr_t, 1);
 396     p->list.len = -1;
 397
 398     return p;
 399 }
 400
 401 /* --------------------------------------------------------------------------------------------- */
 402
 403 static void
 404 panelized_descr_free (panelized_descr_t * p)
 405 {
 406     if (p != NULL)
 407     {
 408         dir_list_free_list (&p->list);
 409         vfs_path_free (p->root_vpath, TRUE);
 410         g_free (p);
 411     }
 412 }
 413
 414 /* --------------------------------------------------------------------------------------------- */
 415
 416 static void
 417 set_colors (const WPanel * panel)
 418 {
 419     (void) panel;
 420
 421     tty_set_normal_attrs ();
 422     tty_setcolor (NORMAL_COLOR);
 423 }
 424
 425 /* --------------------------------------------------------------------------------------------- */
 426 /** Delete format_item_t object */
 427
 428 static void
 429 format_item_free (format_item_t * format)
 430 {
 431     g_free (format->title);
 432     g_free (format);
 433 }
 434
 435 /* --------------------------------------------------------------------------------------------- */
 436 /** Extract the number of available lines in a panel */
 437
 438 static int
 439 panel_lines (const WPanel * p)
 440 {
 441     /* 3 lines are: top frame, column header, button frame */
 442     return (CONST_WIDGET (p)->rect.lines - 3 - (panels_options.show_mini_info ? 2 : 0));
 443 }
 444
 445 /* --------------------------------------------------------------------------------------------- */
 446 /** This code relies on the default justification!!! */
 447
 448 static void
 449 add_permission_string (const char *dest, int width, file_entry_t * fe, file_attr_t attr, int color,
 450                        gboolean is_octal)
 451 {
 452     int i, r, l;
 453
 454     l = get_user_permissions (&fe->st);
 455
 456     if (is_octal)
 457     {
 458         /* Place of the access bit in octal mode */
 459         l = width + l - 3;
 460         r = l + 1;
 461     }
 462     else
 463     {
 464         /* The same to the triplet in string mode */
 465         l = l * 3 + 1;
 466         r = l + 3;
 467     }
 468
 469     for (i = 0; i < width; i++)
 470     {
 471         if (i >= l && i < r)
 472         {
 473             if (attr == FATTR_CURRENT || attr == FATTR_MARKED_CURRENT)
 474                 tty_setcolor (MARKED_SELECTED_COLOR);
 475             else
 476                 tty_setcolor (MARKED_COLOR);
 477         }
 478         else if (color >= 0)
 479             tty_setcolor (color);
 480         else
 481             tty_lowlevel_setcolor (-color);
 482
 483         tty_print_char (dest[i]);
 484     }
 485 }
 486
 487 /* --------------------------------------------------------------------------------------------- */
 488 /** String representations of various file attributes name */
 489
 490 static const char *
 491 string_file_name (file_entry_t * fe, int len)
 492 {
 493     (void) len;
 494
 495     mc_g_string_copy (string_file_name_buffer, fe->fname);
 496
 497     return string_file_name_buffer->str;
 498 }
 499
 500 /* --------------------------------------------------------------------------------------------- */
 501
 502 static unsigned int
 503 ilog10 (dev_t n)
 504 {
 505     unsigned int digits = 0;
 506
 507     do
 508     {
 509         digits++;
 510         n /= 10;
 511     }
 512     while (n != 0);
 513
 514     return digits;
 515 }
 516
 517 /* --------------------------------------------------------------------------------------------- */
 518
 519 static void
 520 format_device_number (char *buf, size_t bufsize, dev_t dev)
 521 {
 522     dev_t major_dev, minor_dev;
 523     unsigned int major_digits, minor_digits;
 524
 525     major_dev = major (dev);
 526     major_digits = ilog10 (major_dev);
 527
 528     minor_dev = minor (dev);
 529     minor_digits = ilog10 (minor_dev);
 530
 531     g_assert (bufsize >= 1);
 532
 533     if (major_digits + 1 + minor_digits + 1 <= bufsize)
 534         g_snprintf (buf, bufsize, "%lu,%lu", (unsigned long) major_dev, (unsigned long) minor_dev);
 535     else
 536         g_strlcpy (buf, _("[dev]"), bufsize);
 537 }
 538
 539 /* --------------------------------------------------------------------------------------------- */
 540 /** size */
 541
 542 static const char *
 543 string_file_size (file_entry_t * fe, int len)
 544 {
 545     static char buffer[BUF_TINY];
 546
 547     /* Don't ever show size of ".." since we don't calculate it */
 548     if (DIR_IS_DOTDOT (fe->fname->str))
 549         return _("UP--DIR");
 550
 551 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 552     if (S_ISBLK (fe->st.st_mode) || S_ISCHR (fe->st.st_mode))
 553         format_device_number (buffer, len + 1, fe->st.st_rdev);
 554     else
 555 #endif
 556         size_trunc_len (buffer, (unsigned int) len, fe->st.st_size, 0, panels_options.kilobyte_si);
 557
 558     return buffer;
 559 }
 560
 561 /* --------------------------------------------------------------------------------------------- */
 562 /** bsize */
 563
 564 static const char *
 565 string_file_size_brief (file_entry_t * fe, int len)
 566 {
 567     if (S_ISLNK (fe->st.st_mode) && !link_isdir (fe))
 568         return _("SYMLINK");
 569
 570     if ((S_ISDIR (fe->st.st_mode) || link_isdir (fe)) && !DIR_IS_DOTDOT (fe->fname->str))
 571         return _("SUB-DIR");
 572
 573     return string_file_size (fe, len);
 574 }
 575
 576 /* --------------------------------------------------------------------------------------------- */
 577 /** This functions return a string representation of a file entry type */
 578
 579 static const char *
 580 string_file_type (file_entry_t * fe, int len)
 581 {
 582     static char buffer[2];
 583
 584     (void) len;
 585
 586     if (S_ISDIR (fe->st.st_mode))
 587         buffer[0] = PATH_SEP;
 588     else if (S_ISLNK (fe->st.st_mode))
 589     {
 590         if (link_isdir (fe))
 591             buffer[0] = '~';
 592         else if (fe->f.stale_link != 0)
 593             buffer[0] = '!';
 594         else
 595             buffer[0] = '@';
 596     }
 597     else if (S_ISCHR (fe->st.st_mode))
 598         buffer[0] = '-';
 599     else if (S_ISSOCK (fe->st.st_mode))
 600         buffer[0] = '=';
 601     else if (S_ISDOOR (fe->st.st_mode))
 602         buffer[0] = '>';
 603     else if (S_ISBLK (fe->st.st_mode))
 604         buffer[0] = '+';
 605     else if (S_ISFIFO (fe->st.st_mode))
 606         buffer[0] = '|';
 607     else if (S_ISNAM (fe->st.st_mode))
 608         buffer[0] = '#';
 609     else if (!S_ISREG (fe->st.st_mode))
 610         buffer[0] = '?';        /* non-regular of unknown kind */
 611     else if (is_exe (fe->st.st_mode))
 612         buffer[0] = '*';
 613     else
 614         buffer[0] = ' ';
 615     buffer[1] = '\0';
 616     return buffer;
 617 }
 618
 619 /* --------------------------------------------------------------------------------------------- */
 620 /** mtime */
 621
 622 static const char *
 623 string_file_mtime (file_entry_t * fe, int len)
 624 {
 625     (void) len;
 626
 627     return file_date (fe->st.st_mtime);
 628 }
 629
 630 /* --------------------------------------------------------------------------------------------- */
 631 /** atime */
 632
 633 static const char *
 634 string_file_atime (file_entry_t * fe, int len)
 635 {
 636     (void) len;
 637
 638     return file_date (fe->st.st_atime);
 639 }
 640
 641 /* --------------------------------------------------------------------------------------------- */
 642 /** ctime */
 643
 644 static const char *
 645 string_file_ctime (file_entry_t * fe, int len)
 646 {
 647     (void) len;
 648
 649     return file_date (fe->st.st_ctime);
 650 }
 651
 652 /* --------------------------------------------------------------------------------------------- */
 653 /** perm */
 654
 655 static const char *
 656 string_file_permission (file_entry_t * fe, int len)
 657 {
 658     (void) len;
 659
 660     return string_perm (fe->st.st_mode);
 661 }
 662
 663 /* --------------------------------------------------------------------------------------------- */
 664 /** mode */
 665
 666 static const char *
 667 string_file_perm_octal (file_entry_t * fe, int len)
 668 {
 669     static char buffer[10];
 670
 671     (void) len;
 672
 673     g_snprintf (buffer, sizeof (buffer), "0%06lo", (unsigned long) fe->st.st_mode);
 674     return buffer;
 675 }
 676
 677 /* --------------------------------------------------------------------------------------------- */
 678 /** nlink */
 679
 680 static const char *
 681 string_file_nlinks (file_entry_t * fe, int len)
 682 {
 683     static char buffer[BUF_TINY];
 684
 685     (void) len;
 686
 687     g_snprintf (buffer, sizeof (buffer), "%16d", (int) fe->st.st_nlink);
 688     return buffer;
 689 }
 690
 691 /* --------------------------------------------------------------------------------------------- */
 692 /** inode */
 693
 694 static const char *
 695 string_inode (file_entry_t * fe, int len)
 696 {
 697     static char buffer[10];
 698
 699     (void) len;
 700
 701     g_snprintf (buffer, sizeof (buffer), "%lu", (unsigned long) fe->st.st_ino);
 702     return buffer;
 703 }
 704
 705 /* --------------------------------------------------------------------------------------------- */
 706 /** nuid */
 707
 708 static const char *
 709 string_file_nuid (file_entry_t * fe, int len)
 710 {
 711     static char buffer[10];
 712
 713     (void) len;
 714
 715     g_snprintf (buffer, sizeof (buffer), "%lu", (unsigned long) fe->st.st_uid);
 716     return buffer;
 717 }
 718
 719 /* --------------------------------------------------------------------------------------------- */
 720 /** ngid */
 721
 722 static const char *
 723 string_file_ngid (file_entry_t * fe, int len)
 724 {
 725     static char buffer[10];
 726
 727     (void) len;
 728
 729     g_snprintf (buffer, sizeof (buffer), "%lu", (unsigned long) fe->st.st_gid);
 730     return buffer;
 731 }
 732
 733 /* --------------------------------------------------------------------------------------------- */
 734 /** owner */
 735
 736 static const char *
 737 string_file_owner (file_entry_t * fe, int len)
 738 {
 739     (void) len;
 740
 741     return get_owner (fe->st.st_uid);
 742 }
 743
 744 /* --------------------------------------------------------------------------------------------- */
 745 /** group */
 746
 747 static const char *
 748 string_file_group (file_entry_t * fe, int len)
 749 {
 750     (void) len;
 751
 752     return get_group (fe->st.st_gid);
 753 }
 754
 755 /* --------------------------------------------------------------------------------------------- */
 756 /** mark */
 757
 758 static const char *
 759 string_marked (file_entry_t * fe, int len)
 760 {
 761     (void) len;
 762
 763     return fe->f.marked != 0 ? "*" : " ";
 764 }
 765
 766 /* --------------------------------------------------------------------------------------------- */
 767 /** space */
 768
 769 static const char *
 770 string_space (file_entry_t * fe, int len)
 771 {
 772     (void) fe;
 773     (void) len;
 774
 775     return " ";
 776 }
 777
 778 /* --------------------------------------------------------------------------------------------- */
 779 /** dot */
 780
 781 static const char *
 782 string_dot (file_entry_t * fe, int len)
 783 {
 784     (void) fe;
 785     (void) len;
 786
 787     return ".";
 788 }
 789
 790 /* --------------------------------------------------------------------------------------------- */
 791
 792 static int
 793 file_compute_color (file_attr_t attr, file_entry_t * fe)
 794 {
 795     switch (attr)
 796     {
 797     case FATTR_CURRENT:
 798         return (SELECTED_COLOR);
 799     case FATTR_MARKED:
 800         return (MARKED_COLOR);
 801     case FATTR_MARKED_CURRENT:
 802         return (MARKED_SELECTED_COLOR);
 803     case FATTR_STATUS:
 804         return (NORMAL_COLOR);
 805     case FATTR_NORMAL:
 806     default:
 807         if (!panels_options.filetype_mode)
 808             return (NORMAL_COLOR);
 809     }
 810
 811     return mc_fhl_get_color (mc_filehighlight, fe);
 812 }
 813
 814 /* --------------------------------------------------------------------------------------------- */
 815 /** Returns the number of items in the given panel */
 816
 817 static int
 818 panel_items (const WPanel * p)
 819 {
 820     return panel_lines (p) * p->list_cols;
 821 }
 822
 823 /* --------------------------------------------------------------------------------------------- */
 824 /** Formats the file number file_index of panel in the buffer dest */
 825
 826 static filename_scroll_flag_t
 827 format_file (WPanel * panel, int file_index, int width, file_attr_t attr, gboolean isstatus,
 828              int *field_length)
 829 {
 830     int color = NORMAL_COLOR;
 831     int length = 0;
 832     GSList *format, *home;
 833     file_entry_t *fe = NULL;
 834     filename_scroll_flag_t res = FILENAME_NOSCROLL;
 835
 836     *field_length = 0;
 837
 838     if (file_index < panel->dir.len)
 839     {
 840         fe = &panel->dir.list[file_index];
 841         color = file_compute_color (attr, fe);
 842     }
 843
 844     home = isstatus ? panel->status_format : panel->format;
 845
 846     for (format = home; format != NULL && length != width; format = g_slist_next (format))
 847     {
 848         format_item_t *fi = (format_item_t *) format->data;
 849
 850         if (fi->string_fn != NULL)
 851         {
 852             const char *txt = " ";
 853             int len, perm = 0;
 854             const char *prepared_text;
 855             int name_offset = 0;
 856
 857             if (fe != NULL)
 858                 txt = fi->string_fn (fe, fi->field_len);
 859
 860             len = fi->field_len;
 861             if (len + length > width)
 862                 len = width - length;
 863             if (len <= 0)
 864                 break;
 865
 866             if (!isstatus && panel->content_shift > -1 && strcmp (fi->id, "name") == 0)
 867             {
 868                 int str_len;
 869                 int i;
 870
 871                 *field_length = len + 1;
 872
 873                 str_len = str_length (txt);
 874                 i = MAX (0, str_len - len);
 875                 panel->max_shift = MAX (panel->max_shift, i);
 876                 i = MIN (panel->content_shift, i);
 877
 878                 if (i > -1)
 879                 {
 880                     name_offset = str_offset_to_pos (txt, i);
 881                     if (str_len > len)
 882                     {
 883                         res = FILENAME_SCROLL_LEFT;
 884                         if (str_length (txt + name_offset) > len)
 885                             res |= FILENAME_SCROLL_RIGHT;
 886                     }
 887                 }
 888             }
 889
 890             if (panels_options.permission_mode)
 891             {
 892                 if (strcmp (fi->id, "perm") == 0)
 893                     perm = 1;
 894                 else if (strcmp (fi->id, "mode") == 0)
 895                     perm = 2;
 896             }
 897
 898             if (color >= 0)
 899                 tty_setcolor (color);
 900             else
 901                 tty_lowlevel_setcolor (-color);
 902
 903             if (!isstatus && panel->content_shift > -1)
 904                 prepared_text = str_fit_to_term (txt + name_offset, len, HIDE_FIT (fi->just_mode));
 905             else
 906                 prepared_text = str_fit_to_term (txt, len, fi->just_mode);
 907
 908             if (perm != 0 && fe != NULL)
 909                 add_permission_string (prepared_text, fi->field_len, fe, attr, color, perm != 1);
 910             else
 911                 tty_print_string (prepared_text);
 912
 913             length += len;
 914         }
 915         else
 916         {
 917             if (attr == FATTR_CURRENT || attr == FATTR_MARKED_CURRENT)
 918                 tty_setcolor (SELECTED_COLOR);
 919             else
 920                 tty_setcolor (NORMAL_COLOR);
 921             tty_print_one_vline (TRUE);
 922             length++;
 923         }
 924     }
 925
 926     if (length < width)
 927     {
 928         int y, x;
 929
 930         tty_getyx (&y, &x);
 931         tty_draw_hline (y, x, ' ', width - length);
 932     }
 933
 934     return res;
 935 }
 936
 937 /* --------------------------------------------------------------------------------------------- */
 938
 939 static void
 940 repaint_file (WPanel * panel, int file_index, file_attr_t attr)
 941 {
 942     Widget *w = WIDGET (panel);
 943
 944     int nth_column = 0;
 945     int width;
 946     int offset = 0;
 947     filename_scroll_flag_t ret_frm;
 948     int ypos = 0;
 949     gboolean panel_is_split;
 950     int fln = 0;
 951
 952     panel_is_split = panel->list_cols > 1;
 953     width = w->rect.cols - 2;
 954
 955     if (panel_is_split)
 956     {
 957         nth_column = (file_index - panel->top) / panel_lines (panel);
 958         width /= panel->list_cols;
 959
 960         offset = width * nth_column;
 961
 962         if (nth_column + 1 >= panel->list_cols)
 963             width = w->rect.cols - offset - 2;
 964     }
 965
 966     /* Nothing to paint */
 967     if (width <= 0)
 968         return;
 969
 970     ypos = file_index - panel->top;
 971
 972     if (panel_is_split)
 973         ypos %= panel_lines (panel);
 974
 975     ypos += 2;                  /* top frame and header */
 976     widget_gotoyx (w, ypos, offset + 1);
 977
 978     ret_frm = format_file (panel, file_index, width, attr, FALSE, &fln);
 979
 980     if (panel_is_split && nth_column + 1 < panel->list_cols)
 981     {
 982         tty_setcolor (NORMAL_COLOR);
 983         tty_print_one_vline (TRUE);
 984     }
 985
 986     if (ret_frm != FILENAME_NOSCROLL)
 987     {
 988         if (!panel_is_split && fln > 0)
 989         {
 990             if (panel->list_format != list_long)
 991                 width = fln;
 992             else
 993             {
 994                 offset = width - fln + 1;
 995                 width = fln - 1;
 996             }
 997         }
 998
 999         widget_gotoyx (w, ypos, offset);
1000         tty_setcolor (NORMAL_COLOR);
1001         tty_print_string (panel_filename_scroll_left_char);
1002
1003         if ((ret_frm & FILENAME_SCROLL_RIGHT) != 0)
1004         {
1005             offset += width;
1006             if (nth_column + 1 >= panel->list_cols)
1007                 offset++;
1008
1009             widget_gotoyx (w, ypos, offset);
1010             tty_setcolor (NORMAL_COLOR);
1011             tty_print_string (panel_filename_scroll_right_char);
1012         }
1013     }
1014 }
1015
1016 /* --------------------------------------------------------------------------------------------- */
1017
1018 static void
1019 repaint_status (WPanel * panel)
1020 {
1021     int width;
1022
1023     width = WIDGET (panel)->rect.cols - 2;
1024     if (width > 0)
1025     {
1026         int fln = 0;
1027
1028         (void) format_file (panel, panel->current, width, FATTR_STATUS, TRUE, &fln);
1029     }
1030 }
1031
1032 /* --------------------------------------------------------------------------------------------- */
1033
1034 static void
1035 display_mini_info (WPanel * panel)
1036 {
1037     Widget *w = WIDGET (panel);
1038     const file_entry_t *fe;
1039
1040     if (!panels_options.show_mini_info || panel->current < 0)
1041         return;
1042
1043     widget_gotoyx (w, panel_lines (panel) + 3, 1);
1044
1045     if (panel->quick_search.active)
1046     {
1047         tty_setcolor (INPUT_COLOR);
1048         tty_print_char ('/');
1049         tty_print_string (str_fit_to_term
1050                           (panel->quick_search.buffer->str, w->rect.cols - 3, J_LEFT));
1051         return;
1052     }
1053
1054     /* Status resolves links and show them */
1055     set_colors (panel);
1056
1057     fe = panel_current_entry (panel);
1058
1059     if (S_ISLNK (fe->st.st_mode))
1060     {
1061         char link_target[MC_MAXPATHLEN];
1062         vfs_path_t *lc_link_vpath;
1063         int len;
1064
1065         lc_link_vpath = vfs_path_append_new (panel->cwd_vpath, fe->fname->str, (char *) NULL);
1066         len = mc_readlink (lc_link_vpath, link_target, MC_MAXPATHLEN - 1);
1067         vfs_path_free (lc_link_vpath, TRUE);
1068         if (len > 0)
1069         {
1070             link_target[len] = 0;
1071             tty_print_string ("-> ");
1072             tty_print_string (str_fit_to_term (link_target, w->rect.cols - 5, J_LEFT_FIT));
1073         }
1074         else
1075             tty_print_string (str_fit_to_term (_("<readlink failed>"), w->rect.cols - 2, J_LEFT));
1076     }
1077     else if (DIR_IS_DOTDOT (fe->fname->str))
1078     {
1079         /* FIXME:
1080          * while loading directory (dir_list_load() and dir_list_reload()),
1081          * the actual stat info about ".." directory isn't got;
1082          * so just don't display incorrect info about ".." directory */
1083         tty_print_string (str_fit_to_term (_("UP--DIR"), w->rect.cols - 2, J_LEFT));
1084     }
1085     else
1086         /* Default behavior */
1087         repaint_status (panel);
1088 }
1089
1090 /* --------------------------------------------------------------------------------------------- */
1091
1092 static void
1093 paint_dir (WPanel * panel)
1094 {
1095     int i;
1096     int items;                  /* Number of items */
1097
1098     items = panel_items (panel);
1099     /* reset max len of filename because we have the new max length for the new file list */
1100     panel->max_shift = -1;
1101
1102     for (i = 0; i < items; i++)
1103     {
1104         file_attr_t attr = FATTR_NORMAL;        /* Color value of the line */
1105         int n;
1106         gboolean marked;
1107
1108         n = i + panel->top;
1109         marked = (panel->dir.list[n].f.marked != 0);
1110
1111         if (n < panel->dir.len)
1112         {
1113             if (panel->current == n && panel->active)
1114                 attr = marked ? FATTR_MARKED_CURRENT : FATTR_CURRENT;
1115             else if (marked)
1116                 attr = FATTR_MARKED;
1117         }
1118
1119         repaint_file (panel, n, attr);
1120     }
1121
1122     tty_set_normal_attrs ();
1123 }
1124
1125 /* --------------------------------------------------------------------------------------------- */
1126
1127 static void
1128 display_total_marked_size (const WPanel * panel, int y, int x, gboolean size_only)
1129 {
1130     const Widget *w = CONST_WIDGET (panel);
1131
1132     char buffer[BUF_SMALL], b_bytes[BUF_SMALL];
1133     const char *buf;
1134     int cols;
1135
1136     if (panel->marked <= 0)
1137         return;
1138
1139     buf = size_only ? b_bytes : buffer;
1140     cols = w->rect.cols - 2;
1141
1142     g_strlcpy (b_bytes, size_trunc_sep (panel->total, panels_options.kilobyte_si),
1143                sizeof (b_bytes));
1144
1145     if (!size_only)
1146         g_snprintf (buffer, sizeof (buffer),
1147                     ngettext ("%s in %d file", "%s in %d files", panel->marked),
1148                     b_bytes, panel->marked);
1149
1150     /* don't forget spaces around buffer content */
1151     buf = str_trunc (buf, cols - 4);
1152
1153     if (x < 0)
1154         /* center in panel */
1155         x = (w->rect.cols - str_term_width1 (buf)) / 2 - 1;
1156
1157     /*
1158      * y == panel_lines (panel) + 2  for mini_info_separator
1159      * y == w->lines - 1             for panel bottom frame
1160      */
1161     widget_gotoyx (w, y, x);
1162     tty_setcolor (MARKED_COLOR);
1163     tty_printf (" %s ", buf);
1164 }
1165
1166 /* --------------------------------------------------------------------------------------------- */
1167
1168 static void
1169 mini_info_separator (const WPanel * panel)
1170 {
1171     if (panels_options.show_mini_info)
1172     {
1173         const Widget *w = CONST_WIDGET (panel);
1174         int y;
1175
1176         y = panel_lines (panel) + 2;
1177
1178         tty_setcolor (NORMAL_COLOR);
1179         tty_draw_hline (w->rect.y + y, w->rect.x + 1, ACS_HLINE, w->rect.cols - 2);
1180         /* Status displays total marked size.
1181          * Centered in panel, full format. */
1182         display_total_marked_size (panel, y, -1, FALSE);
1183     }
1184 }
1185
1186 /* --------------------------------------------------------------------------------------------- */
1187
1188 static void
1189 show_free_space (const WPanel * panel)
1190 {
1191     /* Used to figure out how many free space we have */
1192     static struct my_statfs myfs_stats;
1193     /* Old current working directory for displaying free space */
1194     static char *old_cwd = NULL;
1195
1196     /* Don't try to stat non-local fs */
1197     if (!vfs_file_is_local (panel->cwd_vpath) || !free_space)
1198         return;
1199
1200     if (old_cwd == NULL || strcmp (old_cwd, vfs_path_as_str (panel->cwd_vpath)) != 0)
1201     {
1202         char rpath[PATH_MAX];
1203
1204         init_my_statfs ();
1205         g_free (old_cwd);
1206         old_cwd = g_strdup (vfs_path_as_str (panel->cwd_vpath));
1207
1208         if (mc_realpath (old_cwd, rpath) == NULL)
1209             return;
1210
1211         my_statfs (&myfs_stats, rpath);
1212     }
1213
1214     if (myfs_stats.avail != 0 || myfs_stats.total != 0)
1215     {
1216         const Widget *w = CONST_WIDGET (panel);
1217         char buffer1[6], buffer2[6], tmp[BUF_SMALL];
1218
1219         size_trunc_len (buffer1, sizeof (buffer1) - 1, myfs_stats.avail, 1,
1220                         panels_options.kilobyte_si);
1221         size_trunc_len (buffer2, sizeof (buffer2) - 1, myfs_stats.total, 1,
1222                         panels_options.kilobyte_si);
1223         g_snprintf (tmp, sizeof (tmp), " %s / %s (%d%%) ", buffer1, buffer2,
1224                     myfs_stats.total == 0 ? 0 :
1225                     (int) (100 * (long double) myfs_stats.avail / myfs_stats.total));
1226         widget_gotoyx (w, w->rect.lines - 1, w->rect.cols - 2 - (int) strlen (tmp));
1227         tty_setcolor (NORMAL_COLOR);
1228         tty_print_string (tmp);
1229     }
1230 }
1231
1232 /* --------------------------------------------------------------------------------------------- */
1233 /**
1234  * Prepare path string for showing in panel's header.
1235  * Passwords will removed, also home dir will replaced by ~
1236  *
1237  * @param panel WPanel object
1238  *
1239  * @return newly allocated string.
1240  */
1241
1242 static char *
1243 panel_correct_path_to_show (const WPanel * panel)
1244 {
1245     vfs_path_t *last_vpath;
1246     const vfs_path_element_t *path_element;
1247     char *return_path;
1248     int elements_count;
1249
1250     elements_count = vfs_path_elements_count (panel->cwd_vpath);
1251
1252     /* get last path element */
1253     path_element = vfs_path_element_clone (vfs_path_get_by_index (panel->cwd_vpath, -1));
1254
1255     if (elements_count > 1 && (strcmp (path_element->class->name, "cpiofs") == 0 ||
1256                                strcmp (path_element->class->name, "extfs") == 0 ||
1257                                strcmp (path_element->class->name, "tarfs") == 0))
1258     {
1259         const char *archive_name;
1260         const vfs_path_element_t *prev_path_element;
1261
1262         /* get previous path element for catching archive name */
1263         prev_path_element = vfs_path_get_by_index (panel->cwd_vpath, -2);
1264         archive_name = strrchr (prev_path_element->path, PATH_SEP);
1265         if (archive_name != NULL)
1266             last_vpath = vfs_path_from_str_flags (archive_name + 1, VPF_NO_CANON);
1267         else
1268         {
1269             last_vpath = vfs_path_from_str_flags (prev_path_element->path, VPF_NO_CANON);
1270             last_vpath->relative = TRUE;
1271         }
1272     }
1273     else
1274         last_vpath = vfs_path_new (TRUE);
1275
1276     vfs_path_add_element (last_vpath, path_element);
1277     return_path =
1278         vfs_path_to_str_flags (last_vpath, 0,
1279                                VPF_STRIP_HOME | VPF_STRIP_PASSWORD | VPF_HIDE_CHARSET);
1280     vfs_path_free (last_vpath, TRUE);
1281
1282     return return_path;
1283 }
1284
1285 /* --------------------------------------------------------------------------------------------- */
1286 /**
1287  * Get Current path element encoding
1288  *
1289  * @param panel WPanel object
1290  *
1291  * @return newly allocated string or NULL if path charset is same as system charset
1292  */
1293
1294 #ifdef HAVE_CHARSET
1295 static char *
1296 panel_get_encoding_info_str (const WPanel * panel)
1297 {
1298     char *ret_str = NULL;
1299     const vfs_path_element_t *path_element;
1300
1301     path_element = vfs_path_get_by_index (panel->cwd_vpath, -1);
1302     if (path_element->encoding != NULL)
1303         ret_str = g_strdup_printf ("[%s]", path_element->encoding);
1304
1305     return ret_str;
1306 }
1307 #endif
1308
1309 /* --------------------------------------------------------------------------------------------- */
1310
1311 static void
1312 show_dir (const WPanel * panel)
1313 {
1314     const Widget *w = CONST_WIDGET (panel);
1315     gchar *tmp;
1316
1317     set_colors (panel);
1318     tty_draw_box (w->rect.y, w->rect.x, w->rect.lines, w->rect.cols, FALSE);
1319
1320     if (panels_options.show_mini_info)
1321     {
1322         int y;
1323
1324         y = panel_lines (panel) + 2;
1325
1326         widget_gotoyx (w, y, 0);
1327         tty_print_alt_char (ACS_LTEE, FALSE);
1328         widget_gotoyx (w, y, w->rect.cols - 1);
1329         tty_print_alt_char (ACS_RTEE, FALSE);
1330     }
1331
1332     widget_gotoyx (w, 0, 1);
1333     tty_print_string (panel_history_prev_item_char);
1334
1335     tmp = panels_options.show_dot_files ? panel_hiddenfiles_show_char : panel_hiddenfiles_hide_char;
1336     tmp = g_strdup_printf ("%s[%s]%s", tmp, panel_history_show_list_char,
1337                            panel_history_next_item_char);
1338
1339     widget_gotoyx (w, 0, w->rect.cols - 6);
1340     tty_print_string (tmp);
1341
1342     g_free (tmp);
1343
1344     widget_gotoyx (w, 0, 3);
1345
1346     if (panel->is_panelized)
1347         tty_printf (" %s ", _("Panelize"));
1348 #ifdef HAVE_CHARSET
1349     else
1350     {
1351         tmp = panel_get_encoding_info_str (panel);
1352         if (tmp != NULL)
1353         {
1354             tty_printf ("%s", tmp);
1355             widget_gotoyx (w, 0, 3 + strlen (tmp));
1356             g_free (tmp);
1357         }
1358     }
1359 #endif
1360
1361     if (panel->active)
1362         tty_setcolor (REVERSE_COLOR);
1363
1364     tmp = panel_correct_path_to_show (panel);
1365     tty_printf (" %s ", str_term_trim (tmp, MIN (MAX (w->rect.cols - 12, 0), w->rect.cols)));
1366     g_free (tmp);
1367
1368     if (!panels_options.show_mini_info)
1369     {
1370         if (panel->marked == 0)
1371         {
1372             const file_entry_t *fe;
1373
1374             fe = panel_current_entry (panel);
1375
1376             /* Show size of curret file in the bottom of panel */
1377             if (S_ISREG (fe->st.st_mode))
1378             {
1379                 char buffer[BUF_SMALL];
1380
1381                 g_snprintf (buffer, sizeof (buffer), " %s ",
1382                             size_trunc_sep (fe->st.st_size, panels_options.kilobyte_si));
1383                 tty_setcolor (NORMAL_COLOR);
1384                 widget_gotoyx (w, w->rect.lines - 1, 4);
1385                 tty_print_string (buffer);
1386             }
1387         }
1388         else
1389         {
1390             /* Show total size of marked files
1391              * In the bottom of panel, display size only. */
1392             display_total_marked_size (panel, w->rect.lines - 1, 2, TRUE);
1393         }
1394     }
1395
1396     show_free_space (panel);
1397
1398     if (panel->active)
1399         tty_set_normal_attrs ();
1400 }
1401
1402 /* --------------------------------------------------------------------------------------------- */
1403
1404 static void
1405 adjust_top_file (WPanel * panel)
1406 {
1407     int items;
1408
1409     /* Update panel->current to avoid out of range in panel->dir.list[panel->current]
1410      * when panel is redrawing when directory is reloading, for example in path:
1411      * dir_list_reload() -> mc_refresh() -> dialog_change_screen_size() ->
1412      * midnight_callback (MSG_RESIZE) -> setup_panels() -> panel_callback(MSG_DRAW) ->
1413      * display_mini_info()
1414      */
1415     panel->current = CLAMP (panel->current, 0, panel->dir.len - 1);
1416
1417     items = panel_items (panel);
1418
1419     if (panel->dir.len <= items)
1420     {
1421         /* If all files fit, show them all. */
1422         panel->top = 0;
1423     }
1424     else
1425     {
1426         int i;
1427
1428         /* top_file has to be in the range [current-items+1, current] so that
1429            the current file is visible.
1430            top_file should be in the range [0, count-items] so that there's
1431            no empty space wasted.
1432            Within these ranges, adjust it by as little as possible. */
1433
1434         if (panel->top < 0)
1435             panel->top = 0;
1436
1437         i = panel->current - items + 1;
1438         if (panel->top < i)
1439             panel->top = i;
1440
1441         i = panel->dir.len - items;
1442         if (panel->top > i)
1443             panel->top = i;
1444
1445         if (panel->top > panel->current)
1446             panel->top = panel->current;
1447     }
1448 }
1449
1450 /* --------------------------------------------------------------------------------------------- */
1451 /** add "#enc:encoding" to end of path */
1452 /* if path ends width a previous #enc:, only encoding is changed no additional
1453  * #enc: is appended
1454  * return new string
1455  */
1456
1457 static char *
1458 panel_save_name (WPanel * panel)
1459 {
1460     /* If the program is shutting down */
1461     if ((mc_global.midnight_shutdown && auto_save_setup) || saving_setup)
1462         return g_strdup (panel->name);
1463
1464     return g_strconcat ("Temporal:", panel->name, (char *) NULL);
1465 }
1466
1467 /* --------------------------------------------------------------------------------------------- */
1468
1469 static void
1470 directory_history_add (WPanel * panel, const vfs_path_t * vpath)
1471 {
1472     char *tmp;
1473
1474     tmp = vfs_path_to_str_flags (vpath, 0, VPF_STRIP_PASSWORD);
1475     panel->dir_history.list = list_append_unique (panel->dir_history.list, tmp);
1476     panel->dir_history.current = panel->dir_history.list;
1477 }
1478
1479 /* --------------------------------------------------------------------------------------------- */
1480
1481 /* "history_load" event handler */
1482 static gboolean
1483 panel_load_history (const gchar * event_group_name, const gchar * event_name,
1484                     gpointer init_data, gpointer data)
1485 {
1486     WPanel *p = PANEL (init_data);
1487     ev_history_load_save_t *ev = (ev_history_load_save_t *) data;
1488
1489     (void) event_group_name;
1490     (void) event_name;
1491
1492     if (ev->receiver == NULL || ev->receiver == WIDGET (p))
1493     {
1494         if (ev->cfg != NULL)
1495             p->dir_history.list = mc_config_history_load (ev->cfg, p->dir_history.name);
1496         else
1497             p->dir_history.list = mc_config_history_get (p->dir_history.name);
1498
1499         directory_history_add (p, p->cwd_vpath);
1500     }
1501
1502     return TRUE;
1503 }
1504
1505 /* --------------------------------------------------------------------------------------------- */
1506
1507 /* "history_save" event handler */
1508 static gboolean
1509 panel_save_history (const gchar * event_group_name, const gchar * event_name,
1510                     gpointer init_data, gpointer data)
1511 {
1512     WPanel *p = PANEL (init_data);
1513
1514     (void) event_group_name;
1515     (void) event_name;
1516
1517     if (p->dir_history.list != NULL)
1518     {
1519         ev_history_load_save_t *ev = (ev_history_load_save_t *) data;
1520
1521         mc_config_history_save (ev->cfg, p->dir_history.name, p->dir_history.list);
1522     }
1523
1524     return TRUE;
1525 }
1526
1527 /* --------------------------------------------------------------------------------------------- */
1528
1529 static void
1530 panel_destroy (WPanel * p)
1531 {
1532     size_t i;
1533
1534     if (panels_options.auto_save_setup)
1535     {
1536         char *name;
1537
1538         name = panel_save_name (p);
1539         panel_save_setup (p, name);
1540         g_free (name);
1541     }
1542
1543     panel_clean_dir (p);
1544
1545     /* clean history */
1546     if (p->dir_history.list != NULL)
1547     {
1548         /* directory history is already saved before this moment */
1549         p->dir_history.list = g_list_first (p->dir_history.list);
1550         g_list_free_full (p->dir_history.list, g_free);
1551     }
1552     g_free (p->dir_history.name);
1553
1554     file_filter_clear (&p->filter);
1555
1556     g_slist_free_full (p->format, (GDestroyNotify) format_item_free);
1557     g_slist_free_full (p->status_format, (GDestroyNotify) format_item_free);
1558
1559     g_free (p->user_format);
1560     for (i = 0; i < LIST_FORMATS; i++)
1561         g_free (p->user_status_format[i]);
1562
1563     g_free (p->name);
1564
1565     panelized_descr_free (p->panelized_descr);
1566
1567     g_string_free (p->quick_search.buffer, TRUE);
1568     g_string_free (p->quick_search.prev_buffer, TRUE);
1569
1570     vfs_path_free (p->lwd_vpath, TRUE);
1571     vfs_path_free (p->cwd_vpath, TRUE);
1572 }
1573
1574 /* --------------------------------------------------------------------------------------------- */
1575
1576 static void
1577 panel_paint_sort_info (const WPanel * panel)
1578 {
1579     if (*panel->sort_field->hotkey != '\0')
1580     {
1581         const char *sort_sign =
1582             panel->sort_info.reverse ? panel_sort_up_char : panel_sort_down_char;
1583         char *str;
1584
1585         str = g_strdup_printf ("%s%s", sort_sign, Q_ (panel->sort_field->hotkey));
1586         widget_gotoyx (panel, 1, 1);
1587         tty_print_string (str);
1588         g_free (str);
1589     }
1590 }
1591
1592 /* --------------------------------------------------------------------------------------------- */
1593
1594 static const char *
1595 panel_get_title_without_hotkey (const char *title)
1596 {
1597     static char translated_title[BUF_TINY];
1598
1599     if (title == NULL || title[0] == '\0')
1600         translated_title[0] = '\0';
1601     else
1602     {
1603         char *hkey;
1604
1605         g_snprintf (translated_title, sizeof (translated_title), "%s", _(title));
1606
1607         hkey = strchr (translated_title, '&');
1608         if (hkey != NULL && hkey[1] != '\0')
1609             memmove (hkey, hkey + 1, strlen (hkey));
1610     }
1611
1612     return translated_title;
1613 }
1614
1615 /* --------------------------------------------------------------------------------------------- */
1616
1617 static void
1618 panel_print_header (const WPanel * panel)
1619 {
1620     const Widget *w = CONST_WIDGET (panel);
1621
1622     int y, x;
1623     int i;
1624     GString *format_txt;
1625
1626     widget_gotoyx (w, 1, 1);
1627     tty_getyx (&y, &x);
1628     tty_setcolor (NORMAL_COLOR);
1629     tty_draw_hline (y, x, ' ', w->rect.cols - 2);
1630
1631     format_txt = g_string_new ("");
1632
1633     for (i = 0; i < panel->list_cols; i++)
1634     {
1635         GSList *format;
1636
1637         for (format = panel->format; format != NULL; format = g_slist_next (format))
1638         {
1639             format_item_t *fi = (format_item_t *) format->data;
1640
1641             if (fi->string_fn != NULL)
1642             {
1643                 g_string_set_size (format_txt, 0);
1644
1645                 if (panel->list_format == list_long && strcmp (fi->id, panel->sort_field->id) == 0)
1646                     g_string_append (format_txt,
1647                                      panel->sort_info.reverse
1648                                      ? panel_sort_up_char : panel_sort_down_char);
1649
1650                 g_string_append (format_txt, fi->title);
1651
1652                 if (panel->filter.handler != NULL && strcmp (fi->id, "name") == 0)
1653                 {
1654                     g_string_append (format_txt, " [");
1655                     g_string_append (format_txt, panel->filter.value);
1656                     g_string_append (format_txt, "]");
1657                 }
1658
1659                 tty_setcolor (HEADER_COLOR);
1660                 tty_print_string (str_fit_to_term (format_txt->str, fi->field_len, J_CENTER_LEFT));
1661             }
1662             else
1663             {
1664                 tty_setcolor (NORMAL_COLOR);
1665                 tty_print_one_vline (TRUE);
1666             }
1667         }
1668
1669         if (i < panel->list_cols - 1)
1670         {
1671             tty_setcolor (NORMAL_COLOR);
1672             tty_print_one_vline (TRUE);
1673         }
1674     }
1675
1676     g_string_free (format_txt, TRUE);
1677
1678     if (panel->list_format != list_long)
1679         panel_paint_sort_info (panel);
1680 }
1681
1682 /* --------------------------------------------------------------------------------------------- */
1683
1684 static const char *
1685 parse_panel_size (WPanel * panel, const char *format, gboolean isstatus)
1686 {
1687     panel_display_t frame = frame_half;
1688
1689     format = skip_separators (format);
1690
1691     if (strncmp (format, "full", 4) == 0)
1692     {
1693         frame = frame_full;
1694         format += 4;
1695     }
1696     else if (strncmp (format, "half", 4) == 0)
1697     {
1698         frame = frame_half;
1699         format += 4;
1700     }
1701
1702     if (!isstatus)
1703     {
1704         panel->frame_size = frame;
1705         panel->list_cols = 1;
1706     }
1707
1708     /* Now, the optional column specifier */
1709     format = skip_separators (format);
1710
1711     if (g_ascii_isdigit (*format))
1712     {
1713         if (!isstatus)
1714         {
1715             panel->list_cols = g_ascii_digit_value (*format);
1716             if (panel->list_cols < 1)
1717                 panel->list_cols = 1;
1718         }
1719
1720         format++;
1721     }
1722
1723     if (!isstatus)
1724         panel_update_cols (WIDGET (panel), panel->frame_size);
1725
1726     return skip_separators (format);
1727 }
1728
1729 /* --------------------------------------------------------------------------------------------- */
1730
1731 /* *INDENT-OFF* */
1732 /* Format is:
1733
1734    all              := panel_format? format
1735    panel_format     := [full|half] [1-9]
1736    format           := one_format_item_t
1737                      | format , one_format_item_t
1738
1739    one_format_item_t := just format.id [opt_size]
1740    just              := [<=>]
1741    opt_size          := : size [opt_expand]
1742    size              := [0-9]+
1743    opt_expand        := +
1744
1745  */
1746 /* *INDENT-ON* */
1747
1748 static GSList *
1749 parse_display_format (WPanel * panel, const char *format, char **error, gboolean isstatus,
1750                       int *res_total_cols)
1751 {
1752     GSList *home = NULL;        /* The formats we return */
1753     int total_cols = 0;         /* Used columns by the format */
1754     size_t i;
1755
1756     static size_t i18n_timelength = 0;  /* flag: check ?Time length at startup */
1757
1758     *error = NULL;
1759
1760     if (i18n_timelength == 0)
1761     {
1762         i18n_timelength = i18n_checktimelength ();      /* Mustn't be 0 */
1763
1764         for (i = 0; panel_fields[i].id != NULL; i++)
1765             if (strcmp ("time", panel_fields[i].id + 1) == 0)
1766                 panel_fields[i].min_size = i18n_timelength;
1767     }
1768
1769     /*
1770      * This makes sure that the panel and mini status full/half mode
1771      * setting is equal
1772      */
1773     format = parse_panel_size (panel, format, isstatus);
1774
1775     while (*format != '\0')
1776     {                           /* format can be an empty string */
1777         format_item_t *darr;
1778         align_crt_t justify;    /* Which mode. */
1779         gboolean set_justify = TRUE;    /* flag: set justification mode? */
1780         gboolean found = FALSE;
1781         size_t klen = 0;
1782
1783         darr = g_new0 (format_item_t, 1);
1784         home = g_slist_append (home, darr);
1785
1786         format = skip_separators (format);
1787
1788         switch (*format)
1789         {
1790         case '<':
1791             justify = J_LEFT;
1792             format = skip_separators (format + 1);
1793             break;
1794         case '=':
1795             justify = J_CENTER;
1796             format = skip_separators (format + 1);
1797             break;
1798         case '>':
1799             justify = J_RIGHT;
1800             format = skip_separators (format + 1);
1801             break;
1802         default:
1803             justify = J_LEFT;
1804             set_justify = FALSE;
1805             break;
1806         }
1807
1808         for (i = 0; !found && panel_fields[i].id != NULL; i++)
1809         {
1810             klen = strlen (panel_fields[i].id);
1811             found = strncmp (format, panel_fields[i].id, klen) == 0;
1812         }
1813
1814         if (found)
1815         {
1816             i--;
1817             format += klen;
1818
1819             darr->requested_field_len = panel_fields[i].min_size;
1820             darr->string_fn = panel_fields[i].string_fn;
1821             darr->title = g_strdup (panel_get_title_without_hotkey (panel_fields[i].title_hotkey));
1822             darr->id = panel_fields[i].id;
1823             darr->expand = panel_fields[i].expands;
1824             darr->just_mode = panel_fields[i].default_just;
1825
1826             if (set_justify)
1827             {
1828                 if (IS_FIT (darr->just_mode))
1829                     darr->just_mode = MAKE_FIT (justify);
1830                 else
1831                     darr->just_mode = justify;
1832             }
1833
1834             format = skip_separators (format);
1835
1836             /* If we have a size specifier */
1837             if (*format == ':')
1838             {
1839                 int req_length;
1840
1841                 /* If the size was specified, we don't want
1842                  * auto-expansion by default
1843                  */
1844                 darr->expand = FALSE;
1845                 format++;
1846                 req_length = atoi (format);
1847                 darr->requested_field_len = req_length;
1848
1849                 format = skip_numbers (format);
1850
1851                 /* Now, if they insist on expansion */
1852                 if (*format == '+')
1853                 {
1854                     darr->expand = TRUE;
1855                     format++;
1856                 }
1857             }
1858         }
1859         else
1860         {
1861             size_t pos;
1862             char *tmp_format;
1863
1864             pos = strlen (format);
1865             if (pos > 8)
1866                 pos = 8;
1867
1868             tmp_format = g_strndup (format, pos);
1869             g_slist_free_full (home, (GDestroyNotify) format_item_free);
1870             *error =
1871                 g_strconcat (_("Unknown tag on display format:"), " ", tmp_format, (char *) NULL);
1872             g_free (tmp_format);
1873
1874             return NULL;
1875         }
1876
1877         total_cols += darr->requested_field_len;
1878     }
1879
1880     *res_total_cols = total_cols;
1881     return home;
1882 }
1883
1884 /* --------------------------------------------------------------------------------------------- */
1885
1886 static GSList *
1887 use_display_format (WPanel * panel, const char *format, char **error, gboolean isstatus)
1888 {
1889 #define MAX_EXPAND 4
1890     int expand_top = 0;         /* Max used element in expand */
1891     int usable_columns;         /* Usable columns in the panel */
1892     int total_cols = 0;
1893     GSList *darr, *home;
1894
1895     if (format == NULL)
1896         format = DEFAULT_USER_FORMAT;
1897
1898     home = parse_display_format (panel, format, error, isstatus, &total_cols);
1899
1900     if (*error != NULL)
1901         return NULL;
1902
1903     panel->dirty = TRUE;
1904
1905     usable_columns = WIDGET (panel)->rect.cols - 2;
1906     /* Status needn't to be split */
1907     if (!isstatus)
1908     {
1909         usable_columns /= panel->list_cols;
1910         if (panel->list_cols > 1)
1911             usable_columns--;
1912     }
1913
1914     /* Look for the expandable fields and set field_len based on the requested field len */
1915     for (darr = home; darr != NULL && expand_top < MAX_EXPAND; darr = g_slist_next (darr))
1916     {
1917         format_item_t *fi = (format_item_t *) darr->data;
1918
1919         fi->field_len = fi->requested_field_len;
1920         if (fi->expand)
1921             expand_top++;
1922     }
1923
1924     /* If we used more columns than the available columns, adjust that */
1925     if (total_cols > usable_columns)
1926     {
1927         int dif;
1928         int pdif = 0;
1929
1930         dif = total_cols - usable_columns;
1931
1932         while (dif != 0 && pdif != dif)
1933         {
1934             pdif = dif;
1935
1936             for (darr = home; darr != NULL; darr = g_slist_next (darr))
1937             {
1938                 format_item_t *fi = (format_item_t *) darr->data;
1939
1940                 if (dif != 0 && fi->field_len != 1)
1941                 {
1942                     fi->field_len--;
1943                     dif--;
1944                 }
1945             }
1946         }
1947
1948         total_cols = usable_columns;    /* give up, the rest should be truncated */
1949     }
1950
1951     /* Expand the available space */
1952     if (usable_columns > total_cols && expand_top != 0)
1953     {
1954         int i;
1955         int spaces;
1956
1957         spaces = (usable_columns - total_cols) / expand_top;
1958
1959         for (i = 0, darr = home; darr != NULL && i < expand_top; darr = g_slist_next (darr))
1960         {
1961             format_item_t *fi = (format_item_t *) darr->data;
1962
1963             if (fi->expand)
1964             {
1965                 fi->field_len += spaces;
1966                 if (i == 0)
1967                     fi->field_len += (usable_columns - total_cols) % expand_top;
1968                 i++;
1969             }
1970         }
1971     }
1972
1973     return home;
1974 }
1975
1976 /* --------------------------------------------------------------------------------------------- */
1977 /** Given the panel->view_type returns the format string to be parsed */
1978
1979 static const char *
1980 panel_format (WPanel * panel)
1981 {
1982     switch (panel->list_format)
1983     {
1984     case list_long:
1985         return "full perm space nlink space owner space group space size space mtime space name";
1986
1987     case list_brief:
1988         {
1989             static char format[BUF_TINY];
1990             int brief_cols = panel->brief_cols;
1991
1992             if (brief_cols < 1)
1993                 brief_cols = 2;
1994
1995             if (brief_cols > 9)
1996                 brief_cols = 9;
1997
1998             g_snprintf (format, sizeof (format), "half %d type name", brief_cols);
1999             return format;
2000         }
2001
2002     case list_user:
2003         return panel->user_format;
2004
2005     default:
2006     case list_full:
2007         return "half type name | size | mtime";
2008     }
2009 }
2010
2011 /* --------------------------------------------------------------------------------------------- */
2012
2013 static const char *
2014 mini_status_format (WPanel * panel)
2015 {
2016     if (panel->user_mini_status)
2017         return panel->user_status_format[panel->list_format];
2018
2019     switch (panel->list_format)
2020     {
2021     case list_long:
2022         return "full perm space nlink space owner space group space size space mtime space name";
2023
2024     case list_brief:
2025         return "half type name space bsize space perm space";
2026
2027     case list_full:
2028         return "half type name";
2029
2030     default:
2031     case list_user:
2032         return panel->user_format;
2033     }
2034 }
2035
2036 /*                          */
2037 /* Panel operation commands */
2038 /*                          */
2039
2040 /* --------------------------------------------------------------------------------------------- */
2041
2042 static void
2043 cd_up_dir (WPanel * panel)
2044 {
2045     vfs_path_t *up_dir;
2046
2047     up_dir = vfs_path_from_str ("..");
2048     panel_cd (panel, up_dir, cd_exact);
2049     vfs_path_free (up_dir, TRUE);
2050 }
2051
2052 /* --------------------------------------------------------------------------------------------- */
2053 /** Used to emulate Lynx's entering leaving a directory with the arrow keys */
2054
2055 static cb_ret_t
2056 maybe_cd (WPanel * panel, gboolean move_up_dir)
2057 {
2058     if (panels_options.navigate_with_arrows && input_is_empty (cmdline))
2059     {
2060         const file_entry_t *fe;
2061
2062         if (move_up_dir)
2063         {
2064             cd_up_dir (panel);
2065             return MSG_HANDLED;
2066         }
2067
2068         fe = panel_current_entry (panel);
2069
2070         if (S_ISDIR (fe->st.st_mode) || link_isdir (fe))
2071         {
2072             vfs_path_t *vpath;
2073
2074             vpath = vfs_path_from_str (fe->fname->str);
2075             panel_cd (panel, vpath, cd_exact);
2076             vfs_path_free (vpath, TRUE);
2077             return MSG_HANDLED;
2078         }
2079     }
2080
2081     return MSG_NOT_HANDLED;
2082 }
2083
2084 /* --------------------------------------------------------------------------------------------- */
2085
2086 /* if command line is empty then do 'cd ..' */
2087 static cb_ret_t
2088 force_maybe_cd (WPanel * panel)
2089 {
2090     if (input_is_empty (cmdline))
2091     {
2092         cd_up_dir (panel);
2093         return MSG_HANDLED;
2094     }
2095
2096     return MSG_NOT_HANDLED;
2097 }
2098
2099 /* --------------------------------------------------------------------------------------------- */
2100
2101 static inline void
2102 unselect_item (WPanel * panel)
2103 {
2104     repaint_file (panel, panel->current,
2105                   panel_current_entry (panel)->f.marked != 0 ? FATTR_MARKED : FATTR_NORMAL);
2106 }
2107
2108 /* --------------------------------------------------------------------------------------------- */
2109 /** Select/unselect all the files like a current file by extension */
2110
2111 static void
2112 panel_select_ext_cmd (WPanel * panel)
2113 {
2114     const file_entry_t *fe;
2115     GString *filename;
2116     gboolean do_select;
2117     char *reg_exp, *cur_file_ext;
2118     mc_search_t *search;
2119     int i;
2120
2121     fe = panel_current_entry (panel);
2122
2123     filename = fe->fname;
2124     if (filename == NULL)
2125         return;
2126
2127     do_select = (fe->f.marked == 0);
2128
2129     cur_file_ext = str_regex_escape (extension (filename->str));
2130     if (cur_file_ext[0] != '\0')
2131         reg_exp = g_strconcat ("^.*\\.", cur_file_ext, "$", (char *) NULL);
2132     else
2133         reg_exp = g_strdup ("^[^\\.]+$");
2134
2135     g_free (cur_file_ext);
2136
2137     search = mc_search_new (reg_exp, NULL);
2138     search->search_type = MC_SEARCH_T_REGEX;
2139     search->is_case_sensitive = FALSE;
2140
2141     for (i = 0; i < panel->dir.len; i++)
2142     {
2143         fe = &panel->dir.list[i];
2144
2145         if (DIR_IS_DOTDOT (fe->fname->str) || S_ISDIR (fe->st.st_mode))
2146             continue;
2147
2148         if (!mc_search_run (search, fe->fname->str, 0, fe->fname->len, NULL))
2149             continue;
2150
2151         do_file_mark (panel, i, do_select ? 1 : 0);
2152     }
2153
2154     mc_search_free (search);
2155     g_free (reg_exp);
2156 }
2157
2158 /* --------------------------------------------------------------------------------------------- */
2159
2160 static int
2161 panel_current_at_half (const WPanel * panel)
2162 {
2163     int lines, top;
2164
2165     lines = panel_lines (panel);
2166
2167     /* define top file of column */
2168     top = panel->top;
2169     if (panel->list_cols > 1)
2170         top += lines * ((panel->current - top) / lines);
2171
2172     return (panel->current - top - lines / 2);
2173 }
2174
2175 /* --------------------------------------------------------------------------------------------- */
2176
2177 static void
2178 move_down (WPanel * panel)
2179 {
2180     int items;
2181
2182     if (panel->current + 1 == panel->dir.len)
2183         return;
2184
2185     unselect_item (panel);
2186     panel->current++;
2187
2188     items = panel_items (panel);
2189
2190     if (panels_options.scroll_pages && panel->current - panel->top == items)
2191     {
2192         /* Scroll window half screen */
2193         panel->top += items / 2;
2194         if (panel->top > panel->dir.len - items)
2195             panel->top = panel->dir.len - items;
2196         paint_dir (panel);
2197     }
2198     else if (panels_options.scroll_center && panel_current_at_half (panel) > 0)
2199     {
2200         /* Scroll window when cursor is halfway down */
2201         panel->top++;
2202         if (panel->top > panel->dir.len - items)
2203             panel->top = panel->dir.len - items;
2204     }
2205     select_item (panel);
2206 }
2207
2208 /* --------------------------------------------------------------------------------------------- */
2209
2210 static void
2211 move_up (WPanel * panel)
2212 {
2213     if (panel->current == 0)
2214         return;
2215
2216     unselect_item (panel);
2217     panel->current--;
2218
2219     if (panels_options.scroll_pages && panel->current < panel->top)
2220     {
2221         /* Scroll window half screen */
2222         panel->top -= panel_items (panel) / 2;
2223         if (panel->top < 0)
2224             panel->top = 0;
2225         paint_dir (panel);
2226     }
2227     else if (panels_options.scroll_center && panel_current_at_half (panel) < 0)
2228     {
2229         /* Scroll window when cursor is halfway up */
2230         panel->top--;
2231         if (panel->top < 0)
2232             panel->top = 0;
2233     }
2234     select_item (panel);
2235 }
2236
2237 /* --------------------------------------------------------------------------------------------- */
2238 /** Changes the current by lines (may be negative) */
2239
2240 static void
2241 panel_move_current (WPanel * panel, int lines)
2242 {
2243     int new_pos;
2244     gboolean adjust = FALSE;
2245
2246     new_pos = panel->current + lines;
2247     if (new_pos >= panel->dir.len)
2248         new_pos = panel->dir.len - 1;
2249
2250     if (new_pos < 0)
2251         new_pos = 0;
2252
2253     unselect_item (panel);
2254     panel->current = new_pos;
2255
2256     if (panel->current - panel->top >= panel_items (panel))
2257     {
2258         panel->top += lines;
2259         adjust = TRUE;
2260     }
2261
2262     if (panel->current - panel->top < 0)
2263     {
2264         panel->top += lines;
2265         adjust = TRUE;
2266     }
2267
2268     if (adjust)
2269     {
2270         if (panel->top > panel->current)
2271             panel->top = panel->current;
2272         if (panel->top < 0)
2273             panel->top = 0;
2274         paint_dir (panel);
2275     }
2276     select_item (panel);
2277 }
2278
2279 /* --------------------------------------------------------------------------------------------- */
2280
2281 static cb_ret_t
2282 move_left (WPanel * panel)
2283 {
2284     if (panel->list_cols > 1)
2285     {
2286         panel_move_current (panel, -panel_lines (panel));
2287         return MSG_HANDLED;
2288     }
2289
2290     return maybe_cd (panel, TRUE);      /* cd .. */
2291 }
2292
2293 /* --------------------------------------------------------------------------------------------- */
2294
2295 static cb_ret_t
2296 move_right (WPanel * panel)
2297 {
2298     if (panel->list_cols > 1)
2299     {
2300         panel_move_current (panel, panel_lines (panel));
2301         return MSG_HANDLED;
2302     }
2303
2304     return maybe_cd (panel, FALSE);     /* cd (current) */
2305 }
2306
2307 /* --------------------------------------------------------------------------------------------- */
2308
2309 static void
2310 prev_page (WPanel * panel)
2311 {
2312     int items;
2313
2314     if (panel->current == 0 && panel->top == 0)
2315         return;
2316
2317     unselect_item (panel);
2318     items = panel_items (panel);
2319     if (panel->top < items)
2320         items = panel->top;
2321     if (items == 0)
2322         panel->current = 0;
2323     else
2324         panel->current -= items;
2325     panel->top -= items;
2326
2327     select_item (panel);
2328     paint_dir (panel);
2329 }
2330
2331 /* --------------------------------------------------------------------------------------------- */
2332
2333 static void
2334 goto_parent_dir (WPanel * panel)
2335 {
2336     if (!panel->is_panelized)
2337         cd_up_dir (panel);
2338     else
2339     {
2340         GString *fname;
2341         const char *bname;
2342         vfs_path_t *dname_vpath;
2343
2344         fname = panel_current_entry (panel)->fname;
2345
2346         if (g_path_is_absolute (fname->str))
2347             fname = mc_g_string_dup (fname);
2348         else
2349         {
2350             char *fname2;
2351
2352             fname2 =
2353                 mc_build_filename (vfs_path_as_str (panel->panelized_descr->root_vpath), fname->str,
2354                                    (char *) NULL);
2355
2356             fname = g_string_new_take (fname2);
2357         }
2358
2359         bname = x_basename (fname->str);
2360
2361         if (bname == fname->str)
2362             dname_vpath = vfs_path_from_str (".");
2363         else
2364         {
2365             g_string_truncate (fname, bname - fname->str);
2366             dname_vpath = vfs_path_from_str (fname->str);
2367         }
2368
2369         panel_cd (panel, dname_vpath, cd_exact);
2370         panel_set_current_by_name (panel, bname);
2371
2372         vfs_path_free (dname_vpath, TRUE);
2373         g_string_free (fname, TRUE);
2374     }
2375 }
2376
2377 /* --------------------------------------------------------------------------------------------- */
2378
2379 static void
2380 next_page (WPanel * panel)
2381 {
2382     int items;
2383
2384     if (panel->current == panel->dir.len - 1)
2385         return;
2386
2387     unselect_item (panel);
2388     items = panel_items (panel);
2389     if (panel->top > panel->dir.len - 2 * items)
2390         items = panel->dir.len - items - panel->top;
2391     if (panel->top + items < 0)
2392         items = -panel->top;
2393     if (items == 0)
2394         panel->current = panel->dir.len - 1;
2395     else
2396         panel->current += items;
2397     panel->top += items;
2398
2399     select_item (panel);
2400     paint_dir (panel);
2401 }
2402
2403 /* --------------------------------------------------------------------------------------------- */
2404
2405 static void
2406 goto_child_dir (WPanel * panel)
2407 {
2408     const file_entry_t *fe;
2409
2410     fe = panel_current_entry (panel);
2411
2412     if (S_ISDIR (fe->st.st_mode) || link_isdir (fe))
2413     {
2414         vfs_path_t *vpath;
2415
2416         vpath = vfs_path_from_str (fe->fname->str);
2417         panel_cd (panel, vpath, cd_exact);
2418         vfs_path_free (vpath, TRUE);
2419     }
2420 }
2421
2422 /* --------------------------------------------------------------------------------------------- */
2423
2424 static void
2425 goto_top_file (WPanel * panel)
2426 {
2427     unselect_item (panel);
2428     panel->current = panel->top;
2429     select_item (panel);
2430 }
2431
2432 /* --------------------------------------------------------------------------------------------- */
2433
2434 static void
2435 goto_middle_file (WPanel * panel)
2436 {
2437     unselect_item (panel);
2438     panel->current = panel->top + panel_items (panel) / 2;
2439     select_item (panel);
2440 }
2441
2442 /* --------------------------------------------------------------------------------------------- */
2443
2444 static void
2445 goto_bottom_file (WPanel * panel)
2446 {
2447     unselect_item (panel);
2448     panel->current = panel->top + panel_items (panel) - 1;
2449     select_item (panel);
2450 }
2451
2452 /* --------------------------------------------------------------------------------------------- */
2453
2454 static void
2455 move_home (WPanel * panel)
2456 {
2457     if (panel->current == 0)
2458         return;
2459
2460     unselect_item (panel);
2461
2462     if (panels_options.torben_fj_mode)
2463     {
2464         int middle_pos;
2465
2466         middle_pos = panel->top + panel_items (panel) / 2;
2467
2468         if (panel->current > middle_pos)
2469         {
2470             goto_middle_file (panel);
2471             return;
2472         }
2473         if (panel->current != panel->top)
2474         {
2475             goto_top_file (panel);
2476             return;
2477         }
2478     }
2479
2480     panel->top = 0;
2481     panel->current = 0;
2482
2483     paint_dir (panel);
2484     select_item (panel);
2485 }
2486
2487 /* --------------------------------------------------------------------------------------------- */
2488
2489 static void
2490 move_end (WPanel * panel)
2491 {
2492     if (panel->current == panel->dir.len - 1)
2493         return;
2494
2495     unselect_item (panel);
2496
2497     if (panels_options.torben_fj_mode)
2498     {
2499         int items, middle_pos;
2500
2501         items = panel_items (panel);
2502         middle_pos = panel->top + items / 2;
2503
2504         if (panel->current < middle_pos)
2505         {
2506             goto_middle_file (panel);
2507             return;
2508         }
2509         if (panel->current != panel->top + items - 1)
2510         {
2511             goto_bottom_file (panel);
2512             return;
2513         }
2514     }
2515
2516     panel->current = panel->dir.len - 1;
2517     paint_dir (panel);
2518     select_item (panel);
2519 }
2520
2521 /* --------------------------------------------------------------------------------------------- */
2522
2523 static void
2524 do_mark_file (WPanel * panel, mark_act_t do_move)
2525 {
2526     do_file_mark (panel, panel->current, panel_current_entry (panel)->f.marked ? 0 : 1);
2527
2528     if ((panels_options.mark_moves_down && do_move == MARK_DOWN) || do_move == MARK_FORCE_DOWN)
2529         move_down (panel);
2530     else if (do_move == MARK_FORCE_UP)
2531         move_up (panel);
2532 }
2533
2534 /* --------------------------------------------------------------------------------------------- */
2535
2536 static inline void
2537 mark_file (WPanel * panel)
2538 {
2539     do_mark_file (panel, MARK_DOWN);
2540 }
2541
2542 /* --------------------------------------------------------------------------------------------- */
2543
2544 static inline void
2545 mark_file_up (WPanel * panel)
2546 {
2547     do_mark_file (panel, MARK_FORCE_UP);
2548 }
2549
2550 /* --------------------------------------------------------------------------------------------- */
2551
2552 static inline void
2553 mark_file_down (WPanel * panel)
2554 {
2555     do_mark_file (panel, MARK_FORCE_DOWN);
2556 }
2557
2558 /* --------------------------------------------------------------------------------------------- */
2559
2560 static void
2561 mark_file_right (WPanel * panel)
2562 {
2563     int lines;
2564
2565     if (state_mark < 0)
2566         state_mark = panel_current_entry (panel)->f.marked ? 0 : 1;
2567
2568     lines = panel_lines (panel);
2569     lines = MIN (lines, panel->dir.len - panel->current - 1);
2570     for (; lines != 0; lines--)
2571     {
2572         do_file_mark (panel, panel->current, state_mark);
2573         move_down (panel);
2574     }
2575     do_file_mark (panel, panel->current, state_mark);
2576 }
2577
2578 /* --------------------------------------------------------------------------------------------- */
2579
2580 static void
2581 mark_file_left (WPanel * panel)
2582 {
2583     int lines;
2584
2585     if (state_mark < 0)
2586         state_mark = panel_current_entry (panel)->f.marked ? 0 : 1;
2587
2588     lines = panel_lines (panel);
2589     lines = MIN (lines, panel->current + 1);
2590     for (; lines != 0; lines--)
2591     {
2592         do_file_mark (panel, panel->current, state_mark);
2593         move_up (panel);
2594     }
2595     do_file_mark (panel, panel->current, state_mark);
2596 }
2597
2598 /* --------------------------------------------------------------------------------------------- */
2599
2600 static mc_search_t *
2601 panel_select_unselect_files_dialog (select_flags_t * flags, const char *title,
2602                                     const char *history_name, const char *help_section, char **str)
2603 {
2604     gboolean files_only = (*flags & SELECT_FILES_ONLY) != 0;
2605     gboolean case_sens = (*flags & SELECT_MATCH_CASE) != 0;
2606     gboolean shell_patterns = (*flags & SELECT_SHELL_PATTERNS) != 0;
2607
2608     char *reg_exp;
2609     mc_search_t *search;
2610
2611     quick_widget_t quick_widgets[] = {
2612         /* *INDENT-OFF* */
2613         QUICK_INPUT (INPUT_LAST_TEXT, history_name, &reg_exp, NULL,
2614                      FALSE, FALSE, INPUT_COMPLETE_FILENAMES),
2615         QUICK_START_COLUMNS,
2616             QUICK_CHECKBOX (N_("&Files only"), &files_only, NULL),
2617             QUICK_CHECKBOX (N_("&Using shell patterns"), &shell_patterns, NULL),
2618         QUICK_NEXT_COLUMN,
2619             QUICK_CHECKBOX (N_("&Case sensitive"), &case_sens, NULL),
2620         QUICK_STOP_COLUMNS,
2621         QUICK_END
2622         /* *INDENT-ON* */
2623     };
2624
2625     WRect r = { -1, -1, 0, 50 };
2626
2627     quick_dialog_t qdlg = {
2628         r, title, help_section,
2629         quick_widgets, NULL, NULL
2630     };
2631
2632     if (quick_dialog (&qdlg) == B_CANCEL)
2633         return NULL;
2634
2635     if (*reg_exp == '\0')
2636     {
2637         g_free (reg_exp);
2638         if (str != NULL)
2639             *str = NULL;
2640         return SELECT_RESET;
2641     }
2642
2643     search = mc_search_new (reg_exp, NULL);
2644     search->search_type = shell_patterns ? MC_SEARCH_T_GLOB : MC_SEARCH_T_REGEX;
2645     search->is_entire_line = TRUE;
2646     search->is_case_sensitive = case_sens;
2647
2648     if (str != NULL)
2649         *str = reg_exp;
2650     else
2651         g_free (reg_exp);
2652
2653     if (!mc_search_prepare (search))
2654     {
2655         message (D_ERROR, MSG_ERROR, _("Malformed regular expression"));
2656         mc_search_free (search);
2657         return SELECT_ERROR;
2658     }
2659
2660     /* result flags */
2661     *flags = 0;
2662     if (case_sens)
2663         *flags |= SELECT_MATCH_CASE;
2664     if (files_only)
2665         *flags |= SELECT_FILES_ONLY;
2666     if (shell_patterns)
2667         *flags |= SELECT_SHELL_PATTERNS;
2668
2669     return search;
2670 }
2671
2672 /* --------------------------------------------------------------------------------------------- */
2673
2674 static void
2675 panel_select_unselect_files (WPanel * panel, const char *title, const char *history_name,
2676                              const char *help_section, gboolean do_select)
2677 {
2678     mc_search_t *search;
2679     gboolean files_only;
2680     int i;
2681
2682     search = panel_select_unselect_files_dialog (&panels_options.select_flags, title, history_name,
2683                                                  help_section, NULL);
2684     if (search == NULL || search == SELECT_RESET || search == SELECT_ERROR)
2685         return;
2686
2687     files_only = (panels_options.select_flags & SELECT_FILES_ONLY) != 0;
2688
2689     for (i = 0; i < panel->dir.len; i++)
2690     {
2691         if (DIR_IS_DOTDOT (panel->dir.list[i].fname->str))
2692             continue;
2693         if (S_ISDIR (panel->dir.list[i].st.st_mode) && files_only)
2694             continue;
2695
2696         if (mc_search_run
2697             (search, panel->dir.list[i].fname->str, 0, panel->dir.list[i].fname->len, NULL))
2698             do_file_mark (panel, i, do_select ? 1 : 0);
2699     }
2700
2701     mc_search_free (search);
2702 }
2703
2704 /* --------------------------------------------------------------------------------------------- */
2705
2706 static void
2707 panel_select_files (WPanel * panel)
2708 {
2709     panel_select_unselect_files (panel, _("Select"), MC_HISTORY_FM_PANEL_SELECT,
2710                                  "[Select/Unselect Files]", TRUE);
2711 }
2712
2713 /* --------------------------------------------------------------------------------------------- */
2714
2715 static void
2716 panel_unselect_files (WPanel * panel)
2717 {
2718     panel_select_unselect_files (panel, _("Unselect"), MC_HISTORY_FM_PANEL_UNSELECT,
2719                                  "[Select/Unselect Files]", FALSE);
2720 }
2721
2722 /* --------------------------------------------------------------------------------------------- */
2723
2724 static void
2725 panel_select_invert_files (WPanel * panel)
2726 {
2727     int i;
2728
2729     for (i = 0; i < panel->dir.len; i++)
2730     {
2731         file_entry_t *file = &panel->dir.list[i];
2732
2733         if (!panels_options.reverse_files_only || !S_ISDIR (file->st.st_mode))
2734             do_file_mark (panel, i, file->f.marked ? 0 : 1);
2735     }
2736 }
2737
2738 /* --------------------------------------------------------------------------------------------- */
2739
2740 static void
2741 panel_do_set_filter (WPanel * panel)
2742 {
2743     /* *INDENT-OFF* */
2744     file_filter_t ff = { .value = NULL, .handler = NULL, .flags = panel->filter.flags };
2745     /* *INDENT-ON* */
2746
2747     ff.handler =
2748         panel_select_unselect_files_dialog (&ff.flags, _("Filter"), MC_HISTORY_FM_PANEL_FILTER,
2749                                             "[Filter...]", &ff.value);
2750
2751     if (ff.handler == NULL || ff.handler == SELECT_ERROR)
2752         return;
2753
2754     if (ff.handler == SELECT_RESET)
2755         ff.handler = NULL;
2756
2757     panel_set_filter (panel, &ff);
2758 }
2759
2760 /* --------------------------------------------------------------------------------------------- */
2761 /** Incremental search of a file name in the panel.
2762   * @param panel instance of WPanel structure
2763   * @param c_code key code
2764   */
2765
2766 static void
2767 do_search (WPanel * panel, int c_code)
2768 {
2769     int curr;
2770     int i;
2771     gboolean wrapped = FALSE;
2772     char *act;
2773     mc_search_t *search;
2774     char *reg_exp, *esc_str;
2775     gboolean is_found = FALSE;
2776
2777     if (c_code == KEY_BACKSPACE)
2778     {
2779         if (panel->quick_search.buffer->len != 0)
2780         {
2781             act = panel->quick_search.buffer->str + panel->quick_search.buffer->len;
2782             str_prev_noncomb_char (&act, panel->quick_search.buffer->str);
2783             g_string_set_size (panel->quick_search.buffer, act - panel->quick_search.buffer->str);
2784         }
2785         panel->quick_search.chpoint = 0;
2786     }
2787     else
2788     {
2789         if (c_code != 0 && (gsize) panel->quick_search.chpoint < sizeof (panel->quick_search.ch))
2790         {
2791             panel->quick_search.ch[panel->quick_search.chpoint] = c_code;
2792             panel->quick_search.chpoint++;
2793         }
2794
2795         if (panel->quick_search.chpoint > 0)
2796         {
2797             switch (str_is_valid_char (panel->quick_search.ch, panel->quick_search.chpoint))
2798             {
2799             case -2:
2800                 return;
2801             case -1:
2802                 panel->quick_search.chpoint = 0;
2803                 return;
2804             default:
2805                 g_string_append_len (panel->quick_search.buffer, panel->quick_search.ch,
2806                                      panel->quick_search.chpoint);
2807                 panel->quick_search.chpoint = 0;
2808             }
2809         }
2810     }
2811
2812     reg_exp = g_strdup_printf ("%s*", panel->quick_search.buffer->str);
2813     esc_str = str_escape (reg_exp, -1, ",|\\{}[]", TRUE);
2814     search = mc_search_new (esc_str, NULL);
2815     search->search_type = MC_SEARCH_T_GLOB;
2816     search->is_entire_line = TRUE;
2817
2818     switch (panels_options.qsearch_mode)
2819     {
2820     case QSEARCH_CASE_SENSITIVE:
2821         search->is_case_sensitive = TRUE;
2822         break;
2823     case QSEARCH_CASE_INSENSITIVE:
2824         search->is_case_sensitive = FALSE;
2825         break;
2826     default:
2827         search->is_case_sensitive = panel->sort_info.case_sensitive;
2828         break;
2829     }
2830
2831     curr = panel->current;
2832
2833     for (i = panel->current; !wrapped || i != panel->current; i++)
2834     {
2835         if (i >= panel->dir.len)
2836         {
2837             i = 0;
2838             if (wrapped)
2839                 break;
2840             wrapped = TRUE;
2841         }
2842         if (mc_search_run
2843             (search, panel->dir.list[i].fname->str, 0, panel->dir.list[i].fname->len, NULL))
2844         {
2845             curr = i;
2846             is_found = TRUE;
2847             break;
2848         }
2849     }
2850     if (is_found)
2851     {
2852         unselect_item (panel);
2853         panel->current = curr;
2854         select_item (panel);
2855         widget_draw (WIDGET (panel));
2856     }
2857     else if (c_code != KEY_BACKSPACE)
2858     {
2859         act = panel->quick_search.buffer->str + panel->quick_search.buffer->len;
2860         str_prev_noncomb_char (&act, panel->quick_search.buffer->str);
2861         g_string_set_size (panel->quick_search.buffer, act - panel->quick_search.buffer->str);
2862     }
2863     mc_search_free (search);
2864     g_free (reg_exp);
2865     g_free (esc_str);
2866 }
2867
2868 /* --------------------------------------------------------------------------------------------- */
2869 /** Start new search.
2870   * @param panel instance of WPanel structure
2871   */
2872
2873 static void
2874 start_search (WPanel * panel)
2875 {
2876     if (panel->quick_search.active)
2877     {
2878         if (panel->current == panel->dir.len - 1)
2879             panel->current = 0;
2880         else
2881             move_down (panel);
2882
2883         /* in case if there was no search string we need to recall
2884            previous string, with which we ended previous searching */
2885         if (panel->quick_search.buffer->len == 0)
2886             mc_g_string_copy (panel->quick_search.buffer, panel->quick_search.prev_buffer);
2887
2888         do_search (panel, 0);
2889     }
2890     else
2891     {
2892         panel->quick_search.active = TRUE;
2893         g_string_set_size (panel->quick_search.buffer, 0);
2894         panel->quick_search.ch[0] = '\0';
2895         panel->quick_search.chpoint = 0;
2896         display_mini_info (panel);
2897     }
2898 }
2899
2900 /* --------------------------------------------------------------------------------------------- */
2901
2902 static void
2903 stop_search (WPanel * panel)
2904 {
2905     if (!panel->quick_search.active)
2906         return;
2907
2908     panel->quick_search.active = FALSE;
2909
2910     /* if user overrdied search string, we need to store it
2911        to the quick_search.prev_buffer */
2912     if (panel->quick_search.buffer->len != 0)
2913         mc_g_string_copy (panel->quick_search.prev_buffer, panel->quick_search.buffer);
2914
2915     display_mini_info (panel);
2916 }
2917
2918 /* --------------------------------------------------------------------------------------------- */
2919 /** Return TRUE if the Enter key has been processed, FALSE otherwise */
2920
2921 static gboolean
2922 do_enter_on_file_entry (WPanel * panel, file_entry_t * fe)
2923 {
2924     const char *fname = fe->fname->str;
2925     char *fname_quoted;
2926     vfs_path_t *full_name_vpath;
2927     gboolean ok;
2928
2929     /*
2930      * Directory or link to directory - change directory.
2931      * Try the same for the entries on which mc_lstat() has failed.
2932      */
2933     if (S_ISDIR (fe->st.st_mode) || link_isdir (fe) || (fe->st.st_mode == 0))
2934     {
2935         vfs_path_t *fname_vpath;
2936
2937         fname_vpath = vfs_path_from_str (fname);
2938         if (!panel_cd (panel, fname_vpath, cd_exact))
2939             cd_error_message (fname);
2940         vfs_path_free (fname_vpath, TRUE);
2941         return TRUE;
2942     }
2943
2944     full_name_vpath = vfs_path_append_new (panel->cwd_vpath, fname, (char *) NULL);
2945
2946     /* Try associated command */
2947     ok = regex_command (full_name_vpath, "Open") != 0;
2948     vfs_path_free (full_name_vpath, TRUE);
2949     if (ok)
2950         return TRUE;
2951
2952     /* Check if the file is executable */
2953     full_name_vpath = vfs_path_append_new (panel->cwd_vpath, fname, (char *) NULL);
2954     ok = (is_exe (fe->st.st_mode) && if_link_is_exe (full_name_vpath, fe));
2955     vfs_path_free (full_name_vpath, TRUE);
2956     if (!ok)
2957         return FALSE;
2958
2959     if (confirm_execute
2960         && query_dialog (_("The Midnight Commander"), _("Do you really want to execute?"), D_NORMAL,
2961                          2, _("&Yes"), _("&No")) != 0)
2962         return TRUE;
2963
2964     if (!vfs_current_is_local ())
2965     {
2966         int ret;
2967         vfs_path_t *tmp_vpath;
2968
2969         tmp_vpath = vfs_path_append_new (vfs_get_raw_current_dir (), fname, (char *) NULL);
2970         ret = mc_setctl (tmp_vpath, VFS_SETCTL_RUN, NULL);
2971         vfs_path_free (tmp_vpath, TRUE);
2972         /* We took action only if the dialog was shown or the execution was successful */
2973         return confirm_execute || (ret == 0);
2974     }
2975
2976     fname_quoted = name_quote (fname, FALSE);
2977     if (fname_quoted != NULL)
2978     {
2979         char *cmd;
2980
2981         cmd = g_strconcat ("." PATH_SEP_STR, fname_quoted, (char *) NULL);
2982         g_free (fname_quoted);
2983
2984         shell_execute (cmd, 0);
2985         g_free (cmd);
2986     }
2987
2988 #ifdef HAVE_CHARSET
2989     mc_global.source_codepage = default_source_codepage;
2990 #endif
2991
2992     return TRUE;
2993 }
2994
2995 /* --------------------------------------------------------------------------------------------- */
2996
2997 static inline gboolean
2998 do_enter (WPanel * panel)
2999 {
3000     return do_enter_on_file_entry (panel, panel_current_entry (panel));
3001 }
3002
3003 /* --------------------------------------------------------------------------------------------- */
3004
3005 static void
3006 panel_cycle_listing_format (WPanel * panel)
3007 {
3008     panel->list_format = (panel->list_format + 1) % LIST_FORMATS;
3009
3010     if (set_panel_formats (panel) == 0)
3011         do_refresh ();
3012 }
3013
3014 /* --------------------------------------------------------------------------------------------- */
3015
3016 static void
3017 chdir_other_panel (WPanel * panel)
3018 {
3019     const file_entry_t *entry;
3020     vfs_path_t *new_dir_vpath;
3021     char *curr_entry = NULL;
3022     WPanel *p;
3023
3024     entry = panel_current_entry (panel);
3025
3026     if (get_other_type () != view_listing)
3027         create_panel (get_other_index (), view_listing);
3028
3029     if (S_ISDIR (entry->st.st_mode) || link_isdir (entry))
3030         new_dir_vpath = vfs_path_append_new (panel->cwd_vpath, entry->fname->str, (char *) NULL);
3031     else
3032     {
3033         new_dir_vpath = vfs_path_append_new (panel->cwd_vpath, "..", (char *) NULL);
3034         curr_entry = strrchr (vfs_path_get_last_path_str (panel->cwd_vpath), PATH_SEP);
3035     }
3036
3037     p = change_panel ();
3038     panel_cd (p, new_dir_vpath, cd_exact);
3039     vfs_path_free (new_dir_vpath, TRUE);
3040
3041     if (curr_entry != NULL)
3042         panel_set_current_by_name (p, curr_entry);
3043     (void) change_panel ();
3044
3045     move_down (panel);
3046 }
3047
3048 /* --------------------------------------------------------------------------------------------- */
3049 /**
3050  * Make the current directory of the current panel also the current
3051  * directory of the other panel.  Put the other panel to the listing
3052  * mode if needed.  If the current panel is panelized, the other panel
3053  * doesn't become panelized.
3054  */
3055
3056 static void
3057 panel_sync_other (const WPanel * panel)
3058 {
3059     if (get_other_type () != view_listing)
3060         create_panel (get_other_index (), view_listing);
3061
3062     panel_do_cd (other_panel, panel->cwd_vpath, cd_exact);
3063
3064     /* try to set current filename on the other panel */
3065     if (!panel->is_panelized)
3066         panel_set_current_by_name (other_panel, panel_current_entry (panel)->fname->str);
3067 }
3068
3069 /* --------------------------------------------------------------------------------------------- */
3070
3071 static void
3072 chdir_to_readlink (WPanel * panel)
3073 {
3074     const file_entry_t *fe;
3075     vfs_path_t *new_dir_vpath;
3076     char buffer[MC_MAXPATHLEN];
3077     int i;
3078     struct stat st;
3079     vfs_path_t *panel_fname_vpath;
3080     gboolean ok;
3081     WPanel *cpanel;
3082
3083     if (get_other_type () != view_listing)
3084         return;
3085
3086     fe = panel_current_entry (panel);
3087
3088     if (!S_ISLNK (fe->st.st_mode))
3089         return;
3090
3091     i = readlink (fe->fname->str, buffer, MC_MAXPATHLEN - 1);
3092     if (i < 0)
3093         return;
3094
3095     panel_fname_vpath = vfs_path_from_str (fe->fname->str);
3096     ok = (mc_stat (panel_fname_vpath, &st) >= 0);
3097     vfs_path_free (panel_fname_vpath, TRUE);
3098     if (!ok)
3099         return;
3100
3101     buffer[i] = '\0';
3102     if (!S_ISDIR (st.st_mode))
3103     {
3104         char *p;
3105
3106         p = strrchr (buffer, PATH_SEP);
3107         if (p != NULL && p[1] == '\0')
3108         {
3109             *p = '\0';
3110             p = strrchr (buffer, PATH_SEP);
3111         }
3112         if (p == NULL)
3113             return;
3114
3115         p[1] = '\0';
3116     }
3117     if (IS_PATH_SEP (*buffer))
3118         new_dir_vpath = vfs_path_from_str (buffer);
3119     else
3120         new_dir_vpath = vfs_path_append_new (panel->cwd_vpath, buffer, (char *) NULL);
3121
3122     cpanel = change_panel ();
3123     panel_cd (cpanel, new_dir_vpath, cd_exact);
3124     vfs_path_free (new_dir_vpath, TRUE);
3125     (void) change_panel ();
3126
3127     move_down (panel);
3128 }
3129
3130 /* --------------------------------------------------------------------------------------------- */
3131 /**
3132    function return 0 if not found and REAL_INDEX+1 if found
3133  */
3134
3135 static gsize
3136 panel_get_format_field_index_by_name (const WPanel * panel, const char *name)
3137 {
3138     GSList *format;
3139     gsize lc_index;
3140
3141     for (lc_index = 1, format = panel->format;
3142          format != NULL && strcmp (((format_item_t *) format->data)->title, name) != 0;
3143          format = g_slist_next (format), lc_index++)
3144         ;
3145
3146     if (format == NULL)
3147         lc_index = 0;
3148
3149     return lc_index;
3150 }
3151
3152 /* --------------------------------------------------------------------------------------------- */
3153
3154 static const panel_field_t *
3155 panel_get_sortable_field_by_format (const WPanel * panel, gsize lc_index)
3156 {
3157     const panel_field_t *pfield;
3158     const format_item_t *format;
3159
3160     format = (const format_item_t *) g_slist_nth_data (panel->format, lc_index);
3161     if (format == NULL)
3162         return NULL;
3163
3164     pfield = panel_get_field_by_title (format->title);
3165     if (pfield == NULL)
3166         return NULL;
3167     if (pfield->sort_routine == NULL)
3168         return NULL;
3169     return pfield;
3170 }
3171
3172 /* --------------------------------------------------------------------------------------------- */
3173
3174 static void
3175 panel_toggle_sort_order_prev (WPanel * panel)
3176 {
3177     gsize lc_index, i;
3178     const char *title;
3179     const panel_field_t *pfield = NULL;
3180
3181     title = panel_get_title_without_hotkey (panel->sort_field->title_hotkey);
3182     lc_index = panel_get_format_field_index_by_name (panel, title);
3183
3184     if (lc_index > 1)
3185     {
3186         /* search for prev sortable column in panel format */
3187         for (i = lc_index - 1;
3188              i != 0 && (pfield = panel_get_sortable_field_by_format (panel, i - 1)) == NULL; i--)
3189             ;
3190     }
3191
3192     if (pfield == NULL)
3193     {
3194         /* Sortable field not found. Try to search in each array */
3195         for (i = g_slist_length (panel->format);
3196              i != 0 && (pfield = panel_get_sortable_field_by_format (panel, i - 1)) == NULL; i--)
3197             ;
3198     }
3199
3200     if (pfield != NULL)
3201     {
3202         panel->sort_field = pfield;
3203         panel_set_sort_order (panel, pfield);
3204     }
3205 }
3206
3207 /* --------------------------------------------------------------------------------------------- */
3208
3209 static void
3210 panel_toggle_sort_order_next (WPanel * panel)
3211 {
3212     gsize lc_index, i;
3213     const panel_field_t *pfield = NULL;
3214     gsize format_field_count;
3215     const char *title;
3216
3217     format_field_count = g_slist_length (panel->format);
3218     title = panel_get_title_without_hotkey (panel->sort_field->title_hotkey);
3219     lc_index = panel_get_format_field_index_by_name (panel, title);
3220
3221     if (lc_index != 0 && lc_index != format_field_count)
3222     {
3223         /* search for prev sortable column in panel format */
3224         for (i = lc_index;
3225              i != format_field_count
3226              && (pfield = panel_get_sortable_field_by_format (panel, i)) == NULL; i++)
3227             ;
3228     }
3229
3230     if (pfield == NULL)
3231     {
3232         /* Sortable field not found. Try to search in each array */
3233         for (i = 0;
3234              i != format_field_count
3235              && (pfield = panel_get_sortable_field_by_format (panel, i)) == NULL; i++)
3236             ;
3237     }
3238
3239     if (pfield != NULL)
3240     {
3241         panel->sort_field = pfield;
3242         panel_set_sort_order (panel, pfield);
3243     }
3244 }
3245
3246 /* --------------------------------------------------------------------------------------------- */
3247
3248 static void
3249 panel_select_sort_order (WPanel * panel)
3250 {
3251     const panel_field_t *sort_order;
3252
3253     sort_order = sort_box (&panel->sort_info, panel->sort_field);
3254     if (sort_order != NULL)
3255     {
3256         panel->sort_field = sort_order;
3257         panel_set_sort_order (panel, sort_order);
3258     }
3259 }
3260
3261 /* --------------------------------------------------------------------------------------------- */
3262
3263 /**
3264  * panel_content_scroll_left:
3265  * @param panel the pointer to the panel on which we operate
3266  *
3267  * scroll long filename to the left (decrement scroll pointer)
3268  *
3269  */
3270
3271 static void
3272 panel_content_scroll_left (WPanel * panel)
3273 {
3274     if (panel->content_shift > -1)
3275     {
3276         if (panel->content_shift > panel->max_shift)
3277             panel->content_shift = panel->max_shift;
3278
3279         panel->content_shift--;
3280         show_dir (panel);
3281         paint_dir (panel);
3282     }
3283 }
3284
3285 /* --------------------------------------------------------------------------------------------- */
3286 /**
3287  * panel_content_scroll_right:
3288  * @param panel the pointer to the panel on which we operate
3289  *
3290  * scroll long filename to the right (increment scroll pointer)
3291  *
3292  */
3293
3294 static void
3295 panel_content_scroll_right (WPanel * panel)
3296 {
3297     if (panel->content_shift < 0 || panel->content_shift < panel->max_shift)
3298     {
3299         panel->content_shift++;
3300         show_dir (panel);
3301         paint_dir (panel);
3302     }
3303 }
3304
3305 /* --------------------------------------------------------------------------------------------- */
3306
3307 static void
3308 panel_set_sort_type_by_id (WPanel * panel, const char *name)
3309 {
3310     if (strcmp (panel->sort_field->id, name) == 0)
3311         panel->sort_info.reverse = !panel->sort_info.reverse;
3312     else
3313     {
3314         const panel_field_t *sort_order;
3315
3316         sort_order = panel_get_field_by_id (name);
3317         if (sort_order == NULL)
3318             return;
3319
3320         panel->sort_field = sort_order;
3321     }
3322
3323     panel_set_sort_order (panel, panel->sort_field);
3324 }
3325
3326 /* --------------------------------------------------------------------------------------------- */
3327 /**
3328  *  If we moved to the parent directory move the 'current' pointer to
3329  *  the old directory name; If we leave VFS dir, remove FS specificator.
3330  *
3331  *  You do _NOT_ want to add any vfs aware code here. <pavel@ucw.cz>
3332  */
3333
3334 static const char *
3335 get_parent_dir_name (const vfs_path_t * cwd_vpath, const vfs_path_t * lwd_vpath)
3336 {
3337     size_t llen, clen;
3338     const char *p, *lwd;
3339
3340     llen = vfs_path_len (lwd_vpath);
3341     clen = vfs_path_len (cwd_vpath);
3342
3343     if (llen <= clen)
3344         return NULL;
3345
3346     lwd = vfs_path_as_str (lwd_vpath);
3347
3348     p = g_strrstr (lwd, VFS_PATH_URL_DELIMITER);
3349
3350     if (p == NULL)
3351     {
3352         const char *cwd;
3353
3354         cwd = vfs_path_as_str (cwd_vpath);
3355
3356         p = strrchr (lwd, PATH_SEP);
3357
3358         if (p != NULL && strncmp (cwd, lwd, (size_t) (p - lwd)) == 0
3359             && (clen == (size_t) (p - lwd) || (p == lwd && IS_PATH_SEP (cwd[0]) && cwd[1] == '\0')))
3360             return (p + 1);
3361
3362         return NULL;
3363     }
3364
3365     /* skip VFS prefix */
3366     while (--p > lwd && !IS_PATH_SEP (*p))
3367         ;
3368     /* get last component */
3369     while (--p > lwd && !IS_PATH_SEP (*p))
3370         ;
3371
3372     /* return last component */
3373     return (p != lwd || IS_PATH_SEP (*p)) ? p + 1 : p;
3374 }
3375
3376 /* --------------------------------------------------------------------------------------------- */
3377 /** Wrapper for do_subshell_chdir, check for availability of subshell */
3378
3379 static void
3380 subshell_chdir (const vfs_path_t * vpath)
3381 {
3382 #ifdef ENABLE_SUBSHELL
3383     if (mc_global.tty.use_subshell && vfs_current_is_local ())
3384         do_subshell_chdir (vpath, FALSE);
3385 #else /* ENABLE_SUBSHELL */
3386     (void) vpath;
3387 #endif /* ENABLE_SUBSHELL */
3388 }
3389
3390 /* --------------------------------------------------------------------------------------------- */
3391 /**
3392  * Changes the current directory of the panel.
3393  * Don't record change in the directory history.
3394  */
3395
3396 static gboolean
3397 panel_do_cd_int (WPanel * panel, const vfs_path_t * new_dir_vpath, enum cd_enum cd_type)
3398 {
3399     vfs_path_t *olddir_vpath;
3400
3401     /* Convert *new_path to a suitable pathname, handle ~user */
3402     if (cd_type == cd_parse_command)
3403     {
3404         const vfs_path_element_t *element;
3405
3406         element = vfs_path_get_by_index (new_dir_vpath, 0);
3407         if (strcmp (element->path, "-") == 0)
3408             new_dir_vpath = panel->lwd_vpath;
3409     }
3410
3411     if (mc_chdir (new_dir_vpath) == -1)
3412         return FALSE;
3413
3414     /* Success: save previous directory, shutdown status of previous dir */
3415     olddir_vpath = vfs_path_clone (panel->cwd_vpath);
3416     panel_set_lwd (panel, panel->cwd_vpath);
3417     input_complete_free (cmdline);
3418
3419     vfs_path_free (panel->cwd_vpath, TRUE);
3420     vfs_setup_cwd ();
3421     panel->cwd_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
3422
3423     vfs_release_path (olddir_vpath);
3424
3425     subshell_chdir (panel->cwd_vpath);
3426
3427     /* Reload current panel */
3428     panel_clean_dir (panel);
3429
3430     if (!dir_list_load (&panel->dir, panel->cwd_vpath, panel->sort_field->sort_routine,
3431                         &panel->sort_info, &panel->filter))
3432         message (D_ERROR, MSG_ERROR, _("Cannot read directory contents"));
3433
3434     panel_set_current_by_name (panel, get_parent_dir_name (panel->cwd_vpath, olddir_vpath));
3435
3436     load_hint (FALSE);
3437     panel->dirty = TRUE;
3438     update_xterm_title_path ();
3439     update_terminal_cwd ();
3440
3441     vfs_path_free (olddir_vpath, TRUE);
3442
3443     return TRUE;
3444 }
3445
3446 /* --------------------------------------------------------------------------------------------- */
3447
3448 static void
3449 directory_history_next (WPanel * panel)
3450 {
3451     gboolean ok;
3452
3453     do
3454     {
3455         GList *next;
3456
3457         ok = TRUE;
3458         next = g_list_next (panel->dir_history.current);
3459         if (next != NULL)
3460         {
3461             vfs_path_t *data_vpath;
3462
3463             data_vpath = vfs_path_from_str ((char *) next->data);
3464             ok = panel_do_cd_int (panel, data_vpath, cd_exact);
3465             vfs_path_free (data_vpath, TRUE);
3466             panel->dir_history.current = next;
3467         }
3468         /* skip directories that present in history but absent in file system */
3469     }
3470     while (!ok);
3471 }
3472
3473 /* --------------------------------------------------------------------------------------------- */
3474
3475 static void
3476 directory_history_prev (WPanel * panel)
3477 {
3478     gboolean ok;
3479
3480     do
3481     {
3482         GList *prev;
3483
3484         ok = TRUE;
3485         prev = g_list_previous (panel->dir_history.current);
3486         if (prev != NULL)
3487         {
3488             vfs_path_t *data_vpath;
3489
3490             data_vpath = vfs_path_from_str ((char *) prev->data);
3491             ok = panel_do_cd_int (panel, data_vpath, cd_exact);
3492             vfs_path_free (data_vpath, TRUE);
3493             panel->dir_history.current = prev;
3494         }
3495         /* skip directories that present in history but absent in file system */
3496     }
3497     while (!ok);
3498 }
3499
3500 /* --------------------------------------------------------------------------------------------- */
3501
3502 static void
3503 directory_history_list (WPanel * panel)
3504 {
3505     history_descriptor_t hd;
3506     gboolean ok = FALSE;
3507     size_t pos;
3508
3509     pos = g_list_position (panel->dir_history.current, panel->dir_history.list);
3510
3511     history_descriptor_init (&hd, WIDGET (panel)->rect.y, WIDGET (panel)->rect.x,
3512                              panel->dir_history.list, (int) pos);
3513     history_show (&hd);
3514
3515     panel->dir_history.list = hd.list;
3516     if (hd.text != NULL)
3517     {
3518         vfs_path_t *s_vpath;
3519
3520         s_vpath = vfs_path_from_str (hd.text);
3521         ok = panel_do_cd_int (panel, s_vpath, cd_exact);
3522         if (ok)
3523             directory_history_add (panel, panel->cwd_vpath);
3524         else
3525             cd_error_message (hd.text);
3526         vfs_path_free (s_vpath, TRUE);
3527         g_free (hd.text);
3528     }
3529
3530     if (!ok)
3531     {
3532         /* Since history is fully modified in history_show(), panel->dir_history actually
3533          * points to the invalid place. Try restore current position here. */
3534
3535         size_t i;
3536
3537         panel->dir_history.current = panel->dir_history.list;
3538
3539         for (i = 0; i <= pos; i++)
3540         {
3541             GList *prev;
3542
3543             prev = g_list_previous (panel->dir_history.current);
3544             if (prev == NULL)
3545                 break;
3546
3547             panel->dir_history.current = prev;
3548         }
3549     }
3550 }
3551
3552 /* --------------------------------------------------------------------------------------------- */
3553
3554 static cb_ret_t
3555 panel_execute_cmd (WPanel * panel, long command)
3556 {
3557     int res = MSG_HANDLED;
3558
3559     if (command != CK_Search)
3560         stop_search (panel);
3561
3562     switch (command)
3563     {
3564     case CK_Up:
3565     case CK_Down:
3566     case CK_Left:
3567     case CK_Right:
3568     case CK_Bottom:
3569     case CK_Top:
3570     case CK_PageDown:
3571     case CK_PageUp:
3572         /* reset state of marks flag */
3573         state_mark = -1;
3574         break;
3575     default:
3576         break;
3577     }
3578
3579     switch (command)
3580     {
3581     case CK_CycleListingFormat:
3582         panel_cycle_listing_format (panel);
3583         break;
3584     case CK_PanelOtherCd:
3585         chdir_other_panel (panel);
3586         break;
3587     case CK_PanelOtherCdLink:
3588         chdir_to_readlink (panel);
3589         break;
3590     case CK_CopySingle:
3591         copy_cmd_local (panel);
3592         break;
3593     case CK_DeleteSingle:
3594         delete_cmd_local (panel);
3595         break;
3596     case CK_Enter:
3597         do_enter (panel);
3598         break;
3599     case CK_ViewRaw:
3600         view_raw_cmd (panel);
3601         break;
3602     case CK_EditNew:
3603         edit_cmd_new ();
3604         break;
3605     case CK_MoveSingle:
3606         rename_cmd_local (panel);
3607         break;
3608     case CK_SelectInvert:
3609         panel_select_invert_files (panel);
3610         break;
3611     case CK_Select:
3612         panel_select_files (panel);
3613         break;
3614     case CK_SelectExt:
3615         panel_select_ext_cmd (panel);
3616         break;
3617     case CK_Unselect:
3618         panel_unselect_files (panel);
3619         break;
3620     case CK_Filter:
3621         panel_do_set_filter (panel);
3622         break;
3623     case CK_PageDown:
3624         next_page (panel);
3625         break;
3626     case CK_PageUp:
3627         prev_page (panel);
3628         break;
3629     case CK_CdChild:
3630         goto_child_dir (panel);
3631         break;
3632     case CK_CdParent:
3633         goto_parent_dir (panel);
3634         break;
3635     case CK_History:
3636         directory_history_list (panel);
3637         break;
3638     case CK_HistoryNext:
3639         directory_history_next (panel);
3640         break;
3641     case CK_HistoryPrev:
3642         directory_history_prev (panel);
3643         break;
3644     case CK_BottomOnScreen:
3645         goto_bottom_file (panel);
3646         break;
3647     case CK_MiddleOnScreen:
3648         goto_middle_file (panel);
3649         break;
3650     case CK_TopOnScreen:
3651         goto_top_file (panel);
3652         break;
3653     case CK_Mark:
3654         mark_file (panel);
3655         break;
3656     case CK_MarkUp:
3657         mark_file_up (panel);
3658         break;
3659     case CK_MarkDown:
3660         mark_file_down (panel);
3661         break;
3662     case CK_MarkLeft:
3663         mark_file_left (panel);
3664         break;
3665     case CK_MarkRight:
3666         mark_file_right (panel);
3667         break;
3668     case CK_CdParentSmart:
3669         res = force_maybe_cd (panel);
3670         break;
3671     case CK_Up:
3672         move_up (panel);
3673         break;
3674     case CK_Down:
3675         move_down (panel);
3676         break;
3677     case CK_Left:
3678         res = move_left (panel);
3679         break;
3680     case CK_Right:
3681         res = move_right (panel);
3682         break;
3683     case CK_Bottom:
3684         move_end (panel);
3685         break;
3686     case CK_Top:
3687         move_home (panel);
3688         break;
3689 #ifdef HAVE_CHARSET
3690     case CK_SelectCodepage:
3691         panel_change_encoding (panel);
3692         break;
3693 #endif
3694     case CK_ScrollLeft:
3695         panel_content_scroll_left (panel);
3696         break;
3697     case CK_ScrollRight:
3698         panel_content_scroll_right (panel);
3699         break;
3700     case CK_Search:
3701         start_search (panel);
3702         break;
3703     case CK_SearchStop:
3704         break;
3705     case CK_PanelOtherSync:
3706         panel_sync_other (panel);
3707         break;
3708     case CK_Sort:
3709         panel_select_sort_order (panel);
3710         break;
3711     case CK_SortPrev:
3712         panel_toggle_sort_order_prev (panel);
3713         break;
3714     case CK_SortNext:
3715         panel_toggle_sort_order_next (panel);
3716         break;
3717     case CK_SortReverse:
3718         panel->sort_info.reverse = !panel->sort_info.reverse;
3719         panel_set_sort_order (panel, panel->sort_field);
3720         break;
3721     case CK_SortByName:
3722         panel_set_sort_type_by_id (panel, "name");
3723         break;
3724     case CK_SortByExt:
3725         panel_set_sort_type_by_id (panel, "extension");
3726         break;
3727     case CK_SortBySize:
3728         panel_set_sort_type_by_id (panel, "size");
3729         break;
3730     case CK_SortByMTime:
3731         panel_set_sort_type_by_id (panel, "mtime");
3732         break;
3733     default:
3734         res = MSG_NOT_HANDLED;
3735         break;
3736     }
3737
3738     return res;
3739 }
3740
3741 /* --------------------------------------------------------------------------------------------- */
3742
3743 static cb_ret_t
3744 panel_key (WPanel * panel, int key)
3745 {
3746     long command;
3747
3748     if (is_abort_char (key))
3749     {
3750         stop_search (panel);
3751         return MSG_HANDLED;
3752     }
3753
3754     if (panel->quick_search.active && ((key >= ' ' && key <= 255) || key == KEY_BACKSPACE))
3755     {
3756         do_search (panel, key);
3757         return MSG_HANDLED;
3758     }
3759
3760     command = widget_lookup_key (WIDGET (panel), key);
3761     if (command != CK_IgnoreKey)
3762         return panel_execute_cmd (panel, command);
3763
3764     if (panels_options.torben_fj_mode && key == ALT ('h'))
3765     {
3766         goto_middle_file (panel);
3767         return MSG_HANDLED;
3768     }
3769
3770     if (!command_prompt && ((key >= ' ' && key <= 255) || key == KEY_BACKSPACE))
3771     {
3772         start_search (panel);
3773         do_search (panel, key);
3774         return MSG_HANDLED;
3775     }
3776
3777     return MSG_NOT_HANDLED;
3778 }
3779
3780 /* --------------------------------------------------------------------------------------------- */
3781
3782 static cb_ret_t
3783 panel_callback (Widget * w, Widget * sender, widget_msg_t msg, int parm, void *data)
3784 {
3785     WPanel *panel = PANEL (w);
3786     WDialog *h = DIALOG (w->owner);
3787     WButtonBar *bb;
3788
3789     switch (msg)
3790     {
3791     case MSG_INIT:
3792         /* subscribe to "history_load" event */
3793         mc_event_add (h->event_group, MCEVENT_HISTORY_LOAD, panel_load_history, w, NULL);
3794         /* subscribe to "history_save" event */
3795         mc_event_add (h->event_group, MCEVENT_HISTORY_SAVE, panel_save_history, w, NULL);
3796         return MSG_HANDLED;
3797
3798     case MSG_DRAW:
3799         /* Repaint everything, including frame and separator */
3800         widget_erase (w);
3801         show_dir (panel);
3802         panel_print_header (panel);
3803         adjust_top_file (panel);
3804         paint_dir (panel);
3805         mini_info_separator (panel);
3806         display_mini_info (panel);
3807         panel->dirty = FALSE;
3808         return MSG_HANDLED;
3809
3810     case MSG_FOCUS:
3811         state_mark = -1;
3812         current_panel = panel;
3813         panel->active = TRUE;
3814
3815         if (mc_chdir (panel->cwd_vpath) != 0)
3816         {
3817             char *cwd;
3818
3819             cwd = vfs_path_to_str_flags (panel->cwd_vpath, 0, VPF_STRIP_PASSWORD);
3820             cd_error_message (cwd);
3821             g_free (cwd);
3822         }
3823         else
3824             subshell_chdir (panel->cwd_vpath);
3825
3826         update_xterm_title_path ();
3827         update_terminal_cwd ();
3828         select_item (panel);
3829
3830         bb = buttonbar_find (h);
3831         midnight_set_buttonbar (bb);
3832         widget_draw (WIDGET (bb));
3833         return MSG_HANDLED;
3834
3835     case MSG_UNFOCUS:
3836         /* Janne: look at this for the multiple panel options */
3837         stop_search (panel);
3838         panel->active = FALSE;
3839         unselect_item (panel);
3840         return MSG_HANDLED;
3841
3842     case MSG_KEY:
3843         return panel_key (panel, parm);
3844
3845     case MSG_ACTION:
3846         return panel_execute_cmd (panel, parm);
3847
3848     case MSG_DESTROY:
3849         vfs_stamp_path (panel->cwd_vpath);
3850         /* unsubscribe from "history_load" event */
3851         mc_event_del (h->event_group, MCEVENT_HISTORY_LOAD, panel_load_history, w);
3852         /* unsubscribe from "history_save" event */
3853         mc_event_del (h->event_group, MCEVENT_HISTORY_SAVE, panel_save_history, w);
3854         panel_destroy (panel);
3855         free_my_statfs ();
3856         return MSG_HANDLED;
3857
3858     default:
3859         return widget_default_callback (w, sender, msg, parm, data);
3860     }
3861 }
3862
3863 /* --------------------------------------------------------------------------------------------- */
3864 /*                                     */
3865 /* Panel mouse events support routines */
3866 /*                                     */
3867
3868 static void
3869 mouse_toggle_mark (WPanel * panel)
3870 {
3871     do_mark_file (panel, MARK_DONT_MOVE);
3872     mouse_marking = (panel_current_entry (panel)->f.marked != 0);
3873     mouse_mark_panel = current_panel;
3874 }
3875
3876 /* --------------------------------------------------------------------------------------------- */
3877
3878 static void
3879 mouse_set_mark (WPanel * panel)
3880 {
3881     if (mouse_mark_panel == panel)
3882     {
3883         const file_entry_t *fe;
3884
3885         fe = panel_current_entry (panel);
3886
3887         if (mouse_marking && fe->f.marked == 0)
3888             do_mark_file (panel, MARK_DONT_MOVE);
3889         else if (!mouse_marking && fe->f.marked != 0)
3890             do_mark_file (panel, MARK_DONT_MOVE);
3891     }
3892 }
3893
3894 /* --------------------------------------------------------------------------------------------- */
3895
3896 static void
3897 mark_if_marking (WPanel * panel, const mouse_event_t * event, int previous_current)
3898 {
3899     if ((event->buttons & GPM_B_RIGHT) == 0)
3900         return;
3901
3902     if (event->msg == MSG_MOUSE_DOWN)
3903         mouse_toggle_mark (panel);
3904     else
3905     {
3906         int pcurr, curr1, curr2;
3907
3908         pcurr = panel->current;
3909         curr1 = MIN (previous_current, panel->current);
3910         curr2 = MAX (previous_current, panel->current);
3911
3912         for (; curr1 <= curr2; curr1++)
3913         {
3914             panel->current = curr1;
3915             mouse_set_mark (panel);
3916         }
3917
3918         panel->current = pcurr;
3919     }
3920 }
3921
3922 /* --------------------------------------------------------------------------------------------- */
3923 /** Determine which column was clicked, and sort the panel on
3924  * that column, or reverse sort on that column if already
3925  * sorted on that column.
3926  */
3927
3928 static void
3929 mouse_sort_col (WPanel * panel, int x)
3930 {
3931     int i = 0;
3932     GSList *format;
3933     const char *lc_sort_name = NULL;
3934     panel_field_t *col_sort_format = NULL;
3935
3936     for (format = panel->format; format != NULL; format = g_slist_next (format))
3937     {
3938         format_item_t *fi = (format_item_t *) format->data;
3939
3940         i += fi->field_len;
3941         if (x < i + 1)
3942         {
3943             /* found column */
3944             lc_sort_name = fi->title;
3945             break;
3946         }
3947     }
3948
3949     if (lc_sort_name == NULL)
3950         return;
3951
3952     for (i = 0; panel_fields[i].id != NULL; i++)
3953     {
3954         const char *title;
3955
3956         title = panel_get_title_without_hotkey (panel_fields[i].title_hotkey);
3957         if (panel_fields[i].sort_routine != NULL && strcmp (title, lc_sort_name) == 0)
3958         {
3959             col_sort_format = &panel_fields[i];
3960             break;
3961         }
3962     }
3963
3964     if (col_sort_format != NULL)
3965     {
3966         if (panel->sort_field == col_sort_format)
3967             /* reverse the sort if clicked column is already the sorted column */
3968             panel->sort_info.reverse = !panel->sort_info.reverse;
3969         else
3970             /* new sort is forced to be ascending */
3971             panel->sort_info.reverse = FALSE;
3972
3973         panel_set_sort_order (panel, col_sort_format);
3974     }
3975 }
3976
3977 /* --------------------------------------------------------------------------------------------- */
3978
3979 static int
3980 panel_mouse_is_on_item (const WPanel * panel, int y, int x)
3981 {
3982     int lines, col_width, col;
3983
3984     if (y < 0)
3985         return MOUSE_UPPER_FILE_LIST;
3986
3987     lines = panel_lines (panel);
3988     if (y >= lines)
3989         return MOUSE_BELOW_FILE_LIST;
3990
3991     col_width = (CONST_WIDGET (panel)->rect.cols - 2) / panel->list_cols;
3992     /* column where mouse is */
3993     col = x / col_width;
3994
3995     y += panel->top + lines * col;
3996
3997     /* are we below or in the next column of last file? */
3998     if (y > panel->dir.len)
3999         return MOUSE_AFTER_LAST_FILE;
4000
4001     /* we are on item of the file file; return an index to select a file */
4002     return y;
4003 }
4004
4005 /* --------------------------------------------------------------------------------------------- */
4006
4007 static void
4008 panel_mouse_callback (Widget * w, mouse_msg_t msg, mouse_event_t * event)
4009 {
4010     WPanel *panel = PANEL (w);
4011     gboolean is_active;
4012
4013     is_active = widget_is_active (w);
4014
4015     switch (msg)
4016     {
4017     case MSG_MOUSE_DOWN:
4018         if (event->y == 0)
4019         {
4020             /* top frame */
4021             if (event->x == 1)
4022                 /* "<" button */
4023                 directory_history_prev (panel);
4024             else if (event->x == w->rect.cols - 2)
4025                 /* ">" button */
4026                 directory_history_next (panel);
4027             else if (event->x >= w->rect.cols - 5 && event->x <= w->rect.cols - 3)
4028                 /* "^" button */
4029                 directory_history_list (panel);
4030             else if (event->x == w->rect.cols - 6)
4031                 /* "." button show/hide hidden files */
4032                 send_message (filemanager, NULL, MSG_ACTION, CK_ShowHidden, NULL);
4033             else
4034             {
4035                 /* no other events on 1st line, return MOU_UNHANDLED */
4036                 event->result.abort = TRUE;
4037                 /* avoid extra panel redraw */
4038                 panel->dirty = FALSE;
4039             }
4040             break;
4041         }
4042
4043         if (event->y == 1)
4044         {
4045             /* sort on clicked column */
4046             mouse_sort_col (panel, event->x + 1);
4047             break;
4048         }
4049
4050         if (!is_active)
4051             (void) change_panel ();
4052         MC_FALLTHROUGH;
4053
4054     case MSG_MOUSE_DRAG:
4055         {
4056             int my_index;
4057             int previous_current;
4058
4059             my_index = panel_mouse_is_on_item (panel, event->y - 2, event->x);
4060             previous_current = panel->current;
4061
4062             switch (my_index)
4063             {
4064             case MOUSE_UPPER_FILE_LIST:
4065                 move_up (panel);
4066                 mark_if_marking (panel, event, previous_current);
4067                 break;
4068
4069             case MOUSE_BELOW_FILE_LIST:
4070                 move_down (panel);
4071                 mark_if_marking (panel, event, previous_current);
4072                 break;
4073
4074             case MOUSE_AFTER_LAST_FILE:
4075                 break;          /* do nothing */
4076
4077             default:
4078                 if (my_index != panel->current)
4079                 {
4080                     unselect_item (panel);
4081                     panel->current = my_index;
4082                     select_item (panel);
4083                 }
4084
4085                 mark_if_marking (panel, event, previous_current);
4086                 break;
4087             }
4088         }
4089         break;
4090
4091     case MSG_MOUSE_UP:
4092         break;
4093
4094     case MSG_MOUSE_CLICK:
4095         if ((event->count & GPM_DOUBLE) != 0 && (event->buttons & GPM_B_LEFT) != 0 &&
4096             panel_mouse_is_on_item (panel, event->y - 2, event->x) >= 0)
4097             do_enter (panel);
4098         break;
4099
4100     case MSG_MOUSE_MOVE:
4101         break;
4102
4103     case MSG_MOUSE_SCROLL_UP:
4104         if (is_active)
4105         {
4106             if (panels_options.mouse_move_pages && panel->top > 0)
4107                 prev_page (panel);
4108             else                /* We are in first page */
4109                 move_up (panel);
4110         }
4111         break;
4112
4113     case MSG_MOUSE_SCROLL_DOWN:
4114         if (is_active)
4115         {
4116             if (panels_options.mouse_move_pages
4117                 && panel->top + panel_items (panel) < panel->dir.len)
4118                 next_page (panel);
4119             else                /* We are in last page */
4120                 move_down (panel);
4121         }
4122         break;
4123
4124     default:
4125         break;
4126     }
4127
4128     if (panel->dirty)
4129         widget_draw (w);
4130 }
4131
4132 /* --------------------------------------------------------------------------------------------- */
4133
4134 static void
4135 reload_panelized (WPanel * panel)
4136 {
4137     int i, j;
4138     dir_list *list = &panel->dir;
4139
4140     /* refresh current VFS directory required for vfs_path_from_str() */
4141     (void) mc_chdir (panel->cwd_vpath);
4142
4143     for (i = 0, j = 0; i < list->len; i++)
4144     {
4145         vfs_path_t *vpath;
4146
4147         vpath = vfs_path_from_str (list->list[i].fname->str);
4148         if (mc_lstat (vpath, &list->list[i].st) != 0)
4149             g_string_free (list->list[i].fname, TRUE);
4150         else
4151         {
4152             if (j != i)
4153                 list->list[j] = list->list[i];
4154             j++;
4155         }
4156         vfs_path_free (vpath, TRUE);
4157     }
4158     if (j == 0)
4159         dir_list_init (list);
4160     else
4161         list->len = j;
4162
4163     recalculate_panel_summary (panel);
4164
4165     if (panel != current_panel)
4166         (void) mc_chdir (current_panel->cwd_vpath);
4167 }
4168
4169 /* --------------------------------------------------------------------------------------------- */
4170
4171 static void
4172 update_one_panel_widget (WPanel * panel, panel_update_flags_t flags, const char *current_file)
4173 {
4174     gboolean free_pointer;
4175     char *my_current_file = NULL;
4176
4177     if ((flags & UP_RELOAD) != 0)
4178     {
4179         panel->is_panelized = FALSE;
4180         mc_setctl (panel->cwd_vpath, VFS_SETCTL_FLUSH, NULL);
4181         memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat));
4182     }
4183
4184     /* If current_file == -1 (an invalid pointer) then preserve current */
4185     free_pointer = current_file == UP_KEEPSEL;
4186
4187     if (free_pointer)
4188     {
4189         const GString *fname;
4190
4191         fname = panel_current_entry (panel)->fname;
4192         my_current_file = g_strndup (fname->str, fname->len);
4193         current_file = my_current_file;
4194     }
4195
4196     if (panel->is_panelized)
4197         reload_panelized (panel);
4198     else
4199         panel_reload (panel);
4200
4201     panel_set_current_by_name (panel, current_file);
4202     panel->dirty = TRUE;
4203
4204     if (free_pointer)
4205         g_free (my_current_file);
4206 }
4207
4208 /* --------------------------------------------------------------------------------------------- */
4209
4210 static void
4211 update_one_panel (int which, panel_update_flags_t flags, const char *current_file)
4212 {
4213     if (get_panel_type (which) == view_listing)
4214     {
4215         WPanel *panel;
4216
4217         panel = PANEL (get_panel_widget (which));
4218         if (panel->is_panelized)
4219             flags &= ~UP_RELOAD;
4220         update_one_panel_widget (panel, flags, current_file);
4221     }
4222 }
4223
4224 /* --------------------------------------------------------------------------------------------- */
4225
4226 static void
4227 panel_set_current (WPanel * panel, int i)
4228 {
4229     if (i != panel->current)
4230     {
4231         panel->dirty = TRUE;
4232         panel->current = i;
4233         panel->top = panel->current - (WIDGET (panel)->rect.lines - 2) / 2;
4234         if (panel->top < 0)
4235             panel->top = 0;
4236     }
4237 }
4238
4239 /* --------------------------------------------------------------------------------------------- */
4240
4241 /* event callback */
4242 static gboolean
4243 event_update_panels (const gchar * event_group_name, const gchar * event_name,
4244                      gpointer init_data, gpointer data)
4245 {
4246     (void) event_group_name;
4247     (void) event_name;
4248     (void) init_data;
4249     (void) data;
4250
4251     update_panels (UP_RELOAD, UP_KEEPSEL);
4252
4253     return TRUE;
4254 }
4255
4256 /* --------------------------------------------------------------------------------------------- */
4257
4258 /* event callback */
4259 static gboolean
4260 panel_save_current_file_to_clip_file (const gchar * event_group_name, const gchar * event_name,
4261                                       gpointer init_data, gpointer data)
4262 {
4263     (void) event_group_name;
4264     (void) event_name;
4265     (void) init_data;
4266     (void) data;
4267
4268     if (current_panel->marked == 0)
4269         mc_event_raise (MCEVENT_GROUP_CORE, "clipboard_text_to_file",
4270                         (gpointer) panel_current_entry (current_panel)->fname->str);
4271     else
4272     {
4273         int i;
4274         gboolean first = TRUE;
4275         char *flist = NULL;
4276
4277         for (i = 0; i < current_panel->dir.len; i++)
4278         {
4279             const file_entry_t *fe = &current_panel->dir.list[i];
4280
4281             if (fe->f.marked != 0)
4282             {                   /* Skip the unmarked ones */
4283                 if (first)
4284                 {
4285                     flist = g_strndup (fe->fname->str, fe->fname->len);
4286                     first = FALSE;
4287                 }
4288                 else
4289                 {
4290                     /* Add empty lines after the file */
4291                     char *tmp;
4292
4293                     tmp = g_strconcat (flist, "\n", fe->fname->str, (char *) NULL);
4294                     g_free (flist);
4295                     flist = tmp;
4296                 }
4297             }
4298         }
4299
4300         mc_event_raise (MCEVENT_GROUP_CORE, "clipboard_text_to_file", (gpointer) flist);
4301         g_free (flist);
4302     }
4303     return TRUE;
4304 }
4305
4306 /* --------------------------------------------------------------------------------------------- */
4307
4308 static vfs_path_t *
4309 panel_recursive_cd_to_parent (const vfs_path_t * vpath)
4310 {
4311     vfs_path_t *cwd_vpath;
4312
4313     cwd_vpath = vfs_path_clone (vpath);
4314
4315     while (mc_chdir (cwd_vpath) < 0)
4316     {
4317         const char *panel_cwd_path;
4318         vfs_path_t *tmp_vpath;
4319
4320         /* check if path contains only '/' */
4321         panel_cwd_path = vfs_path_as_str (cwd_vpath);
4322         if (panel_cwd_path != NULL && IS_PATH_SEP (panel_cwd_path[0]) && panel_cwd_path[1] == '\0')
4323         {
4324             vfs_path_free (cwd_vpath, TRUE);
4325             return NULL;
4326         }
4327
4328         tmp_vpath = vfs_path_vtokens_get (cwd_vpath, 0, -1);
4329         vfs_path_free (cwd_vpath, TRUE);
4330         cwd_vpath =
4331             vfs_path_build_filename (PATH_SEP_STR, vfs_path_as_str (tmp_vpath), (char *) NULL);
4332         vfs_path_free (tmp_vpath, TRUE);
4333     }
4334
4335     return cwd_vpath;
4336 }
4337
4338 /* --------------------------------------------------------------------------------------------- */
4339
4340 static void
4341 panel_dir_list_callback (dir_list_cb_state_t state, void *data)
4342 {
4343     static int count = 0;
4344
4345     (void) data;
4346
4347     switch (state)
4348     {
4349     case DIR_OPEN:
4350         count = 0;
4351         break;
4352
4353     case DIR_READ:
4354         count++;
4355         if ((count & 15) == 0)
4356             rotate_dash (TRUE);
4357         break;
4358
4359     case DIR_CLOSE:
4360         rotate_dash (FALSE);
4361         break;
4362
4363     default:
4364         g_assert_not_reached ();
4365     }
4366 }
4367
4368 /* --------------------------------------------------------------------------------------------- */
4369 /*** public functions ****************************************************************************/
4370 /* --------------------------------------------------------------------------------------------- */
4371
4372 void
4373 panel_set_current_by_name (WPanel * panel, const char *name)
4374 {
4375     int i;
4376     char *subdir;
4377
4378     if (name == NULL)
4379     {
4380         panel_set_current (panel, 0);
4381         return;
4382     }
4383
4384     /* We only want the last component of the directory,
4385      * and from this only the name without suffix.
4386      * Cut prefix if the panel is not panelized */
4387     if (panel->is_panelized)
4388         subdir = vfs_strip_suffix_from_filename (name);
4389     else
4390         subdir = vfs_strip_suffix_from_filename (x_basename (name));
4391
4392     /* Search that subdir or filename without prefix (if not panelized panel),
4393        make it current if found */
4394     for (i = 0; i < panel->dir.len; i++)
4395         if (strcmp (subdir, panel->dir.list[i].fname->str) == 0)
4396         {
4397             panel_set_current (panel, i);
4398             g_free (subdir);
4399             return;
4400         }
4401
4402     /* Make current near the filee that is missing */
4403     if (panel->current >= panel->dir.len)
4404         panel_set_current (panel, panel->dir.len - 1);
4405     g_free (subdir);
4406
4407     select_item (panel);
4408 }
4409
4410 /* --------------------------------------------------------------------------------------------- */
4411
4412 void
4413 panel_clean_dir (WPanel * panel)
4414 {
4415     panel->top = 0;
4416     panel->current = 0;
4417     panel->marked = 0;
4418     panel->dirs_marked = 0;
4419     panel->total = 0;
4420     panel->quick_search.active = FALSE;
4421     panel->is_panelized = FALSE;
4422     panel->dirty = TRUE;
4423     panel->content_shift = -1;
4424     panel->max_shift = -1;
4425
4426     dir_list_free_list (&panel->dir);
4427 }
4428
4429 /* --------------------------------------------------------------------------------------------- */
4430 /**
4431  * Set Up panel's current dir object
4432  *
4433  * @param panel panel object
4434  * @param path_str string contain path
4435  */
4436
4437 void
4438 panel_set_cwd (WPanel * panel, const vfs_path_t * vpath)
4439 {
4440     if (vpath != panel->cwd_vpath)      /* check if new vpath is not the panel->cwd_vpath object */
4441     {
4442         vfs_path_free (panel->cwd_vpath, TRUE);
4443         panel->cwd_vpath = vfs_path_clone (vpath);
4444     }
4445 }
4446
4447 /* --------------------------------------------------------------------------------------------- */
4448 /**
4449  * Set Up panel's last working dir object
4450  *
4451  * @param panel panel object
4452  * @param path_str string contain path
4453  */
4454
4455 void
4456 panel_set_lwd (WPanel * panel, const vfs_path_t * vpath)
4457 {
4458     if (vpath != panel->lwd_vpath)      /* check if new vpath is not the panel->lwd_vpath object */
4459     {
4460         vfs_path_free (panel->lwd_vpath, TRUE);
4461         panel->lwd_vpath = vfs_path_clone (vpath);
4462     }
4463 }
4464
4465 /* --------------------------------------------------------------------------------------------- */
4466 /**
4467  * Creatie an empty panel with specified size.
4468  *
4469  * @param panel_name name of panel for setup receiving
4470  * @param r panel areaa
4471  *
4472  * @return new instance of WPanel
4473  */
4474
4475 WPanel *
4476 panel_sized_empty_new (const char *panel_name, const WRect * r)
4477 {
4478     WPanel *panel;
4479     Widget *w;
4480     char *section;
4481     int i, err;
4482
4483     panel = g_new0 (WPanel, 1);
4484     w = WIDGET (panel);
4485     widget_init (w, r, panel_callback, panel_mouse_callback);
4486     w->options |= WOP_SELECTABLE | WOP_TOP_SELECT;
4487     w->keymap = panel_map;
4488
4489     panel->dir.size = DIR_LIST_MIN_SIZE;
4490     panel->dir.list = g_new (file_entry_t, panel->dir.size);
4491     panel->dir.len = 0;
4492     panel->dir.callback = panel_dir_list_callback;
4493
4494     panel->list_cols = 1;
4495     panel->brief_cols = 2;
4496     panel->dirty = TRUE;
4497     panel->content_shift = -1;
4498     panel->max_shift = -1;
4499
4500     panel->list_format = list_full;
4501     panel->user_format = g_strdup (DEFAULT_USER_FORMAT);
4502
4503     panel->filter.flags = FILE_FILTER_DEFAULT_FLAGS;
4504
4505     for (i = 0; i < LIST_FORMATS; i++)
4506         panel->user_status_format[i] = g_strdup (DEFAULT_USER_FORMAT);
4507
4508 #ifdef HAVE_CHARSET
4509     panel->codepage = SELECT_CHARSET_NO_TRANSLATE;
4510 #endif
4511
4512     panel->frame_size = frame_half;
4513
4514     panel->quick_search.buffer = g_string_sized_new (MC_MAXFILENAMELEN);
4515     panel->quick_search.prev_buffer = g_string_sized_new (MC_MAXFILENAMELEN);
4516
4517     panel->name = g_strdup (panel_name);
4518     panel->dir_history.name = g_strconcat ("Dir Hist ", panel->name, (char *) NULL);
4519     /* directories history will be get later */
4520
4521     section = g_strconcat ("Temporal:", panel->name, (char *) NULL);
4522     if (!mc_config_has_group (mc_global.main_config, section))
4523     {
4524         g_free (section);
4525         section = g_strdup (panel->name);
4526     }
4527     panel_load_setup (panel, section);
4528     g_free (section);
4529
4530     if (panel->filter.value != NULL)
4531     {
4532         gboolean case_sens = (panel->filter.flags & SELECT_MATCH_CASE) != 0;
4533         gboolean shell_patterns = (panel->filter.flags & SELECT_SHELL_PATTERNS) != 0;
4534
4535         panel->filter.handler = mc_search_new (panel->filter.value, NULL);
4536         panel->filter.handler->search_type = shell_patterns ? MC_SEARCH_T_GLOB : MC_SEARCH_T_REGEX;
4537         panel->filter.handler->is_entire_line = TRUE;
4538         panel->filter.handler->is_case_sensitive = case_sens;
4539
4540         /* FIXME: silent check -- do not display an error message */
4541         if (!mc_search_prepare (panel->filter.handler))
4542             file_filter_clear (&panel->filter);
4543     }
4544
4545     /* Load format strings */
4546     err = set_panel_formats (panel);
4547     if (err != 0)
4548         set_panel_formats (panel);
4549
4550     return panel;
4551 }
4552
4553 /* --------------------------------------------------------------------------------------------- */
4554 /**
4555  * Panel creation for specified size and directory.
4556  *
4557  * @param panel_name name of panel for setup retrieving
4558  * @param r panel areaa
4559  * @param vpath working panel directory. If NULL then current directory is used
4560  *
4561  * @return new instance of WPanel
4562  */
4563
4564 WPanel *
4565 panel_sized_with_dir_new (const char *panel_name, const WRect * r, const vfs_path_t * vpath)
4566 {
4567     WPanel *panel;
4568     char *curdir = NULL;
4569 #ifdef HAVE_CHARSET
4570     const vfs_path_element_t *path_element;
4571 #endif
4572
4573     panel = panel_sized_empty_new (panel_name, r);
4574
4575     if (vpath != NULL)
4576     {
4577         curdir = vfs_get_cwd ();
4578         panel_set_cwd (panel, vpath);
4579     }
4580     else
4581     {
4582         vfs_setup_cwd ();
4583         panel->cwd_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
4584     }
4585
4586     panel_set_lwd (panel, vfs_get_raw_current_dir ());
4587
4588 #ifdef HAVE_CHARSET
4589     path_element = vfs_path_get_by_index (panel->cwd_vpath, -1);
4590     if (path_element->encoding != NULL)
4591         panel->codepage = get_codepage_index (path_element->encoding);
4592 #endif
4593
4594     if (mc_chdir (panel->cwd_vpath) != 0)
4595     {
4596 #ifdef HAVE_CHARSET
4597         panel->codepage = SELECT_CHARSET_NO_TRANSLATE;
4598 #endif
4599         vfs_setup_cwd ();
4600         vfs_path_free (panel->cwd_vpath, TRUE);
4601         panel->cwd_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
4602     }
4603
4604     /* Load the default format */
4605     if (!dir_list_load (&panel->dir, panel->cwd_vpath, panel->sort_field->sort_routine,
4606                         &panel->sort_info, &panel->filter))
4607         message (D_ERROR, MSG_ERROR, _("Cannot read directory contents"));
4608
4609     /* Restore old right path */
4610     if (curdir != NULL)
4611     {
4612         vfs_path_t *tmp_vpath;
4613         int err;
4614
4615         tmp_vpath = vfs_path_from_str (curdir);
4616         mc_chdir (tmp_vpath);
4617         vfs_path_free (tmp_vpath, TRUE);
4618         (void) err;
4619     }
4620     g_free (curdir);
4621
4622     return panel;
4623 }
4624
4625 /* --------------------------------------------------------------------------------------------- */
4626
4627 void
4628 panel_reload (WPanel * panel)
4629 {
4630     struct stat current_stat;
4631     vfs_path_t *cwd_vpath;
4632
4633     if (panels_options.fast_reload && stat (vfs_path_as_str (panel->cwd_vpath), &current_stat) == 0
4634         && current_stat.st_ctime == panel->dir_stat.st_ctime
4635         && current_stat.st_mtime == panel->dir_stat.st_mtime)
4636         return;
4637
4638     cwd_vpath = panel_recursive_cd_to_parent (panel->cwd_vpath);
4639     vfs_path_free (panel->cwd_vpath, TRUE);
4640
4641     if (cwd_vpath == NULL)
4642     {
4643         panel->cwd_vpath = vfs_path_from_str (PATH_SEP_STR);
4644         panel_clean_dir (panel);
4645         dir_list_init (&panel->dir);
4646         return;
4647     }
4648
4649     panel->cwd_vpath = cwd_vpath;
4650     memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat));
4651     show_dir (panel);
4652
4653     if (!dir_list_reload (&panel->dir, panel->cwd_vpath, panel->sort_field->sort_routine,
4654                           &panel->sort_info, &panel->filter))
4655         message (D_ERROR, MSG_ERROR, _("Cannot read directory contents"));
4656
4657     panel->dirty = TRUE;
4658     if (panel->current >= panel->dir.len)
4659         panel_set_current (panel, panel->dir.len - 1);
4660
4661     recalculate_panel_summary (panel);
4662 }
4663
4664 /* --------------------------------------------------------------------------------------------- */
4665 /* Switches the panel to the mode specified in the format           */
4666 /* Setting up both format and status string. Return: 0 - on success; */
4667 /* 1 - format error; 2 - status error; 3 - errors in both formats.  */
4668
4669 int
4670 set_panel_formats (WPanel * p)
4671 {
4672     GSList *form;
4673     char *err = NULL;
4674     int retcode = 0;
4675
4676     form = use_display_format (p, panel_format (p), &err, FALSE);
4677
4678     if (err != NULL)
4679     {
4680         g_free (err);
4681         retcode = 1;
4682     }
4683     else
4684     {
4685         g_slist_free_full (p->format, (GDestroyNotify) format_item_free);
4686         p->format = form;
4687     }
4688
4689     if (panels_options.show_mini_info)
4690     {
4691         form = use_display_format (p, mini_status_format (p), &err, TRUE);
4692
4693         if (err != NULL)
4694         {
4695             g_free (err);
4696             retcode += 2;
4697         }
4698         else
4699         {
4700             g_slist_free_full (p->status_format, (GDestroyNotify) format_item_free);
4701             p->status_format = form;
4702         }
4703     }
4704
4705     panel_update_cols (WIDGET (p), p->frame_size);
4706
4707     if (retcode)
4708         message (D_ERROR, _("Warning"),
4709                  _("User supplied format looks invalid, reverting to default."));
4710     if (retcode & 0x01)
4711     {
4712         g_free (p->user_format);
4713         p->user_format = g_strdup (DEFAULT_USER_FORMAT);
4714     }
4715     if (retcode & 0x02)
4716     {
4717         g_free (p->user_status_format[p->list_format]);
4718         p->user_status_format[p->list_format] = g_strdup (DEFAULT_USER_FORMAT);
4719     }
4720
4721     return retcode;
4722 }
4723
4724 /* --------------------------------------------------------------------------------------------- */
4725
4726 void
4727 panel_set_filter (WPanel * panel, const file_filter_t * filter)
4728 {
4729     MC_PTR_FREE (panel->filter.value);
4730     mc_search_free (panel->filter.handler);
4731     panel->filter.handler = NULL;
4732
4733     /* NULL to clear filter */
4734     if (filter != NULL)
4735         panel->filter = *filter;
4736
4737     reread_cmd ();
4738 }
4739
4740 /* --------------------------------------------------------------------------------------------- */
4741
4742 /* Select current item and readjust the panel */
4743 void
4744 select_item (WPanel * panel)
4745 {
4746     adjust_top_file (panel);
4747
4748     panel->dirty = TRUE;
4749
4750     execute_hooks (select_file_hook);
4751 }
4752
4753 /* --------------------------------------------------------------------------------------------- */
4754 /** Clears all files in the panel, used only when one file was marked */
4755 void
4756 unmark_files (WPanel * panel)
4757 {
4758     if (panel->marked != 0)
4759     {
4760         int i;
4761
4762         for (i = 0; i < panel->dir.len; i++)
4763             file_mark (panel, i, 0);
4764
4765         panel->dirs_marked = 0;
4766         panel->marked = 0;
4767         panel->total = 0;
4768     }
4769 }
4770
4771 /* --------------------------------------------------------------------------------------------- */
4772 /** Recalculate the panels summary information, used e.g. when marked
4773    files might have been removed by an external command */
4774
4775 void
4776 recalculate_panel_summary (WPanel * panel)
4777 {
4778     int i;
4779
4780     panel->marked = 0;
4781     panel->dirs_marked = 0;
4782     panel->total = 0;
4783
4784     for (i = 0; i < panel->dir.len; i++)
4785         if (panel->dir.list[i].f.marked != 0)
4786         {
4787             /* do_file_mark will return immediately if newmark == oldmark.
4788                So we have to first unmark it to get panel's summary information
4789                updated. (Norbert) */
4790             panel->dir.list[i].f.marked = 0;
4791             do_file_mark (panel, i, 1);
4792         }
4793 }
4794
4795 /* --------------------------------------------------------------------------------------------- */
4796 /** This routine marks a file or a directory */
4797
4798 void
4799 do_file_mark (WPanel * panel, int idx, int mark)
4800 {
4801     if (panel->dir.list[idx].f.marked == mark)
4802         return;
4803
4804     /* Only '..' can't be marked, '.' isn't visible */
4805     if (DIR_IS_DOTDOT (panel->dir.list[idx].fname->str))
4806         return;
4807
4808     file_mark (panel, idx, mark);
4809     if (panel->dir.list[idx].f.marked != 0)
4810     {
4811         panel->marked++;
4812
4813         if (S_ISDIR (panel->dir.list[idx].st.st_mode))
4814         {
4815             if (panel->dir.list[idx].f.dir_size_computed != 0)
4816                 panel->total += (uintmax_t) panel->dir.list[idx].st.st_size;
4817             panel->dirs_marked++;
4818         }
4819         else
4820             panel->total += (uintmax_t) panel->dir.list[idx].st.st_size;
4821
4822         set_colors (panel);
4823     }
4824     else
4825     {
4826         if (S_ISDIR (panel->dir.list[idx].st.st_mode))
4827         {
4828             if (panel->dir.list[idx].f.dir_size_computed != 0)
4829                 panel->total -= (uintmax_t) panel->dir.list[idx].st.st_size;
4830             panel->dirs_marked--;
4831         }
4832         else
4833             panel->total -= (uintmax_t) panel->dir.list[idx].st.st_size;
4834
4835         panel->marked--;
4836     }
4837 }
4838
4839 /* --------------------------------------------------------------------------------------------- */
4840 /**
4841  * Changes the current directory of the panel.
4842  * Record change in the directory history.
4843  */
4844 gboolean
4845 panel_do_cd (WPanel * panel, const vfs_path_t * new_dir_vpath, enum cd_enum cd_type)
4846 {
4847     gboolean r;
4848
4849     r = panel_do_cd_int (panel, new_dir_vpath, cd_type);
4850     if (r)
4851         directory_history_add (panel, panel->cwd_vpath);
4852     return r;
4853 }
4854
4855 /* --------------------------------------------------------------------------------------------- */
4856
4857 void
4858 file_mark (WPanel * panel, int lc_index, int val)
4859 {
4860     if (panel->dir.list[lc_index].f.marked != val)
4861     {
4862         panel->dir.list[lc_index].f.marked = val;
4863         panel->dirty = TRUE;
4864     }
4865 }
4866
4867 /* --------------------------------------------------------------------------------------------- */
4868
4869 void
4870 panel_re_sort (WPanel * panel)
4871 {
4872     char *filename;
4873     const file_entry_t *fe;
4874     int i;
4875
4876     if (panel == NULL)
4877         return;
4878
4879     fe = panel_current_entry (panel);
4880     filename = g_strndup (fe->fname->str, fe->fname->len);
4881     unselect_item (panel);
4882     dir_list_sort (&panel->dir, panel->sort_field->sort_routine, &panel->sort_info);
4883     panel->current = -1;
4884
4885     for (i = panel->dir.len; i != 0; i--)
4886         if (strcmp (panel->dir.list[i - 1].fname->str, filename) == 0)
4887         {
4888             panel->current = i - 1;
4889             break;
4890         }
4891
4892     g_free (filename);
4893     panel->top = panel->current - panel_items (panel) / 2;
4894     select_item (panel);
4895     panel->dirty = TRUE;
4896 }
4897
4898 /* --------------------------------------------------------------------------------------------- */
4899
4900 void
4901 panel_set_sort_order (WPanel * panel, const panel_field_t * sort_order)
4902 {
4903     if (sort_order == NULL)
4904         return;
4905
4906     panel->sort_field = sort_order;
4907
4908     /* The directory is already sorted, we have to load the unsorted stuff */
4909     if (sort_order->sort_routine == (GCompareFunc) unsorted)
4910     {
4911         char *current_file;
4912         const GString *fname;
4913
4914         fname = panel_current_entry (panel)->fname;
4915         current_file = g_strndup (fname->str, fname->len);
4916         panel_reload (panel);
4917         panel_set_current_by_name (panel, current_file);
4918         g_free (current_file);
4919     }
4920     panel_re_sort (panel);
4921 }
4922
4923 /* --------------------------------------------------------------------------------------------- */
4924
4925 #ifdef HAVE_CHARSET
4926
4927 /**
4928  * Change panel encoding.
4929  * @param panel WPanel object
4930  */
4931
4932 void
4933 panel_change_encoding (WPanel * panel)
4934 {
4935     const char *encoding = NULL;
4936     char *errmsg;
4937     int r;
4938
4939     r = select_charset (-1, -1, panel->codepage, FALSE);
4940
4941     if (r == SELECT_CHARSET_CANCEL)
4942         return;                 /* Cancel */
4943
4944     panel->codepage = r;
4945
4946     if (panel->codepage == SELECT_CHARSET_NO_TRANSLATE)
4947     {
4948         /* No translation */
4949         vfs_path_t *cd_path_vpath;
4950
4951         g_free (init_translation_table (mc_global.display_codepage, mc_global.display_codepage));
4952         cd_path_vpath = remove_encoding_from_path (panel->cwd_vpath);
4953         panel_do_cd (panel, cd_path_vpath, cd_parse_command);
4954         show_dir (panel);
4955         vfs_path_free (cd_path_vpath, TRUE);
4956         return;
4957     }
4958
4959     errmsg = init_translation_table (panel->codepage, mc_global.display_codepage);
4960     if (errmsg != NULL)
4961     {
4962         message (D_ERROR, MSG_ERROR, "%s", errmsg);
4963         g_free (errmsg);
4964         return;
4965     }
4966
4967     encoding = get_codepage_id (panel->codepage);
4968     if (encoding != NULL)
4969     {
4970         vfs_path_change_encoding (panel->cwd_vpath, encoding);
4971
4972         if (!panel_do_cd (panel, panel->cwd_vpath, cd_parse_command))
4973             cd_error_message (vfs_path_as_str (panel->cwd_vpath));
4974     }
4975 }
4976
4977 /* --------------------------------------------------------------------------------------------- */
4978
4979 /**
4980  * Remove encode info from last path element.
4981  *
4982  */
4983 vfs_path_t *
4984 remove_encoding_from_path (const vfs_path_t * vpath)
4985 {
4986     vfs_path_t *ret_vpath;
4987     GString *tmp_conv;
4988     int indx;
4989
4990     ret_vpath = vfs_path_new (FALSE);
4991
4992     tmp_conv = g_string_new ("");
4993
4994     for (indx = 0; indx < vfs_path_elements_count (vpath); indx++)
4995     {
4996         GIConv converter;
4997         vfs_path_element_t *path_element;
4998
4999         path_element = vfs_path_element_clone (vfs_path_get_by_index (vpath, indx));
5000
5001         if (path_element->encoding == NULL)
5002         {
5003             vfs_path_add_element (ret_vpath, path_element);
5004             continue;
5005         }
5006
5007         converter = str_crt_conv_to (path_element->encoding);
5008         if (converter == INVALID_CONV)
5009         {
5010             vfs_path_add_element (ret_vpath, path_element);
5011             continue;
5012         }
5013
5014         MC_PTR_FREE (path_element->encoding);
5015
5016         str_vfs_convert_from (converter, path_element->path, tmp_conv);
5017
5018         g_free (path_element->path);
5019         path_element->path = g_strndup (tmp_conv->str, tmp_conv->len);
5020
5021         g_string_set_size (tmp_conv, 0);
5022
5023         str_close_conv (converter);
5024         str_close_conv (path_element->dir.converter);
5025         path_element->dir.converter = INVALID_CONV;
5026         vfs_path_add_element (ret_vpath, path_element);
5027     }
5028     g_string_free (tmp_conv, TRUE);
5029     return ret_vpath;
5030 }
5031 #endif /* HAVE_CHARSET */
5032
5033 /* --------------------------------------------------------------------------------------------- */
5034
5035 /**
5036  * This routine reloads the directory in both panels. It tries to
5037  * select current_file in current_panel and other_file in other_panel.
5038  * If current_file == -1 then it automatically sets current_file and
5039  * other_file to the current files in the panels.
5040  *
5041  * If flags has the UP_ONLY_CURRENT bit toggled on, then it
5042  * will not reload the other panel.
5043  *
5044  * @param flags for reload panel
5045  * @param current_file name of the current file
5046  */
5047
5048 void
5049 update_panels (panel_update_flags_t flags, const char *current_file)
5050 {
5051     WPanel *panel;
5052
5053     /* first, update other panel... */
5054     if ((flags & UP_ONLY_CURRENT) == 0)
5055         update_one_panel (get_other_index (), flags, UP_KEEPSEL);
5056     /* ...then current one */
5057     update_one_panel (get_current_index (), flags, current_file);
5058
5059     if (get_current_type () == view_listing)
5060         panel = PANEL (get_panel_widget (get_current_index ()));
5061     else
5062         panel = PANEL (get_panel_widget (get_other_index ()));
5063
5064     if (!panel->is_panelized)
5065         (void) mc_chdir (panel->cwd_vpath);
5066 }
5067
5068 /* --------------------------------------------------------------------------------------------- */
5069
5070 gsize
5071 panel_get_num_of_sortable_fields (void)
5072 {
5073     gsize ret = 0, lc_index;
5074
5075     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
5076         if (panel_fields[lc_index].is_user_choice)
5077             ret++;
5078     return ret;
5079 }
5080
5081 /* --------------------------------------------------------------------------------------------- */
5082
5083 char **
5084 panel_get_sortable_fields (gsize * array_size)
5085 {
5086     char **ret;
5087     gsize lc_index, i;
5088
5089     lc_index = panel_get_num_of_sortable_fields ();
5090
5091     ret = g_try_new0 (char *, lc_index + 1);
5092     if (ret == NULL)
5093         return NULL;
5094
5095     if (array_size != NULL)
5096         *array_size = lc_index;
5097
5098     lc_index = 0;
5099
5100     for (i = 0; panel_fields[i].id != NULL; i++)
5101         if (panel_fields[i].is_user_choice)
5102             ret[lc_index++] = g_strdup (_(panel_fields[i].title_hotkey));
5103
5104     return ret;
5105 }
5106
5107 /* --------------------------------------------------------------------------------------------- */
5108
5109 const panel_field_t *
5110 panel_get_field_by_id (const char *name)
5111 {
5112     gsize lc_index;
5113
5114     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
5115         if (panel_fields[lc_index].id != NULL && strcmp (name, panel_fields[lc_index].id) == 0)
5116             return &panel_fields[lc_index];
5117
5118     return NULL;
5119 }
5120
5121 /* --------------------------------------------------------------------------------------------- */
5122
5123 const panel_field_t *
5124 panel_get_field_by_title_hotkey (const char *name)
5125 {
5126     gsize lc_index;
5127
5128     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
5129         if (panel_fields[lc_index].title_hotkey != NULL &&
5130             strcmp (name, _(panel_fields[lc_index].title_hotkey)) == 0)
5131             return &panel_fields[lc_index];
5132
5133     return NULL;
5134 }
5135
5136 /* --------------------------------------------------------------------------------------------- */
5137
5138 const panel_field_t *
5139 panel_get_field_by_title (const char *name)
5140 {
5141     gsize lc_index;
5142
5143     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
5144     {
5145         const char *title;
5146
5147         title = panel_get_title_without_hotkey (panel_fields[lc_index].title_hotkey);
5148         if (strcmp (title, name) == 0)
5149             return &panel_fields[lc_index];
5150     }
5151
5152     return NULL;
5153 }
5154
5155 /* --------------------------------------------------------------------------------------------- */
5156
5157 gsize
5158 panel_get_num_of_user_possible_fields (void)
5159 {
5160     gsize ret = 0, lc_index;
5161
5162     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
5163         if (panel_fields[lc_index].use_in_user_format)
5164             ret++;
5165
5166     return ret;
5167 }
5168
5169 /* --------------------------------------------------------------------------------------------- */
5170
5171 char **
5172 panel_get_user_possible_fields (gsize * array_size)
5173 {
5174     char **ret;
5175     gsize lc_index, i;
5176
5177     lc_index = panel_get_num_of_user_possible_fields ();
5178
5179     ret = g_try_new0 (char *, lc_index + 1);
5180     if (ret == NULL)
5181         return NULL;
5182
5183     if (array_size != NULL)
5184         *array_size = lc_index;
5185
5186     lc_index = 0;
5187
5188     for (i = 0; panel_fields[i].id != NULL; i++)
5189         if (panel_fields[i].use_in_user_format)
5190             ret[lc_index++] = g_strdup (_(panel_fields[i].title_hotkey));
5191
5192     return ret;
5193 }
5194
5195 /* --------------------------------------------------------------------------------------------- */
5196
5197 void
5198 panel_panelize_cd (void)
5199 {
5200     WPanel *panel;
5201     int i;
5202     dir_list *list;
5203     panelized_descr_t *pdescr;
5204     dir_list *plist;
5205     gboolean panelized_same;
5206
5207     if (!SELECTED_IS_PANEL)
5208         create_panel (MENU_PANEL_IDX, view_listing);
5209
5210     panel = PANEL (get_panel_widget (MENU_PANEL_IDX));
5211
5212     dir_list_clean (&panel->dir);
5213
5214     if (panel->panelized_descr == NULL)
5215         panel->panelized_descr = panelized_descr_new ();
5216
5217     pdescr = panel->panelized_descr;
5218     plist = &pdescr->list;
5219
5220     if (pdescr->root_vpath == NULL)
5221         panel_panelize_change_root (panel, panel->cwd_vpath);
5222
5223     if (plist->len < 1)
5224         dir_list_init (plist);
5225     else if (plist->len > panel->dir.size)
5226         dir_list_grow (&panel->dir, plist->len - panel->dir.size);
5227
5228     list = &panel->dir;
5229     list->len = plist->len;
5230
5231     panelized_same = vfs_path_equal (pdescr->root_vpath, panel->cwd_vpath);
5232
5233     for (i = 0; i < plist->len; i++)
5234     {
5235         if (panelized_same || DIR_IS_DOTDOT (plist->list[i].fname->str))
5236             list->list[i].fname = mc_g_string_dup (plist->list[i].fname);
5237         else
5238         {
5239             vfs_path_t *tmp_vpath;
5240
5241             tmp_vpath =
5242                 vfs_path_append_new (pdescr->root_vpath, plist->list[i].fname->str, (char *) NULL);
5243             list->list[i].fname = g_string_new_take (vfs_path_free (tmp_vpath, FALSE));
5244         }
5245         list->list[i].f.link_to_dir = plist->list[i].f.link_to_dir;
5246         list->list[i].f.stale_link = plist->list[i].f.stale_link;
5247         list->list[i].f.dir_size_computed = plist->list[i].f.dir_size_computed;
5248         list->list[i].f.marked = plist->list[i].f.marked;
5249         list->list[i].st = plist->list[i].st;
5250         list->list[i].name_sort_key = plist->list[i].name_sort_key;
5251         list->list[i].extension_sort_key = plist->list[i].extension_sort_key;
5252     }
5253
5254     panel->is_panelized = TRUE;
5255     panel_panelize_absolutize_if_needed (panel);
5256
5257     panel_set_current_by_name (panel, NULL);
5258 }
5259
5260 /* --------------------------------------------------------------------------------------------- */
5261
5262 /**
5263  * Change root directory of panelized content.
5264  * @param panel file panel
5265  * @param new_root new path
5266  */
5267 void
5268 panel_panelize_change_root (WPanel * panel, const vfs_path_t * new_root)
5269 {
5270     if (panel->panelized_descr == NULL)
5271         panel->panelized_descr = panelized_descr_new ();
5272     else
5273         vfs_path_free (panel->panelized_descr->root_vpath, TRUE);
5274
5275     panel->panelized_descr->root_vpath = vfs_path_clone (new_root);
5276 }
5277
5278 /* --------------------------------------------------------------------------------------------- */
5279
5280 /**
5281  * Conditionally switches a panel's directory to "/" (root).
5282  *
5283  * If a panelized panel's listing contain absolute paths, this function
5284  * sets the panel's directory to "/". Otherwise it does nothing.
5285  *
5286  * Rationale:
5287  *
5288  * This makes tokenized strings like "%d/%p" work. This also makes other
5289  * places work where such naive concatenation is done in code (e.g., when
5290  * pressing ctrl+shift+enter, for CK_PutCurrentFullSelected).
5291  *
5292  * When to call:
5293  *
5294  * You should always call this function after you populate the listing
5295  * of a panelized panel.
5296  */
5297 void
5298 panel_panelize_absolutize_if_needed (WPanel * panel)
5299 {
5300     const dir_list *const list = &panel->dir;
5301
5302     /* Note: We don't support mixing of absolute and relative paths, which is
5303      * why it's ok for us to check only the 1st entry. */
5304     if (list->len > 1 && g_path_is_absolute (list->list[1].fname->str))
5305     {
5306         vfs_path_t *root;
5307
5308         root = vfs_path_from_str (PATH_SEP_STR);
5309         panel_set_cwd (panel, root);
5310         if (panel == current_panel)
5311             mc_chdir (root);
5312         vfs_path_free (root, TRUE);
5313     }
5314 }
5315
5316 /* --------------------------------------------------------------------------------------------- */
5317
5318 void
5319 panel_panelize_save (WPanel * panel)
5320 {
5321     int i;
5322     dir_list *list = &panel->dir;
5323     dir_list *plist;
5324
5325     panel_panelize_change_root (panel, panel->cwd_vpath);
5326
5327     plist = &panel->panelized_descr->list;
5328
5329     if (plist->len > 0)
5330         dir_list_clean (plist);
5331     if (panel->dir.len == 0)
5332         return;
5333
5334     if (panel->dir.len > plist->size)
5335         dir_list_grow (plist, panel->dir.len - plist->size);
5336     plist->len = panel->dir.len;
5337
5338     for (i = 0; i < panel->dir.len; i++)
5339     {
5340         plist->list[i].fname = mc_g_string_dup (list->list[i].fname);
5341         plist->list[i].f.link_to_dir = list->list[i].f.link_to_dir;
5342         plist->list[i].f.stale_link = list->list[i].f.stale_link;
5343         plist->list[i].f.dir_size_computed = list->list[i].f.dir_size_computed;
5344         plist->list[i].f.marked = list->list[i].f.marked;
5345         plist->list[i].st = list->list[i].st;
5346         plist->list[i].name_sort_key = list->list[i].name_sort_key;
5347         plist->list[i].extension_sort_key = list->list[i].extension_sort_key;
5348     }
5349 }
5350
5351 /* --------------------------------------------------------------------------------------------- */
5352
5353 void
5354 panel_init (void)
5355 {
5356     panel_sort_up_char = mc_skin_get ("widget-panel", "sort-up-char", "'");
5357     panel_sort_down_char = mc_skin_get ("widget-panel", "sort-down-char", ".");
5358     panel_hiddenfiles_show_char = mc_skin_get ("widget-panel", "hiddenfiles-show-char", ".");
5359     panel_hiddenfiles_hide_char = mc_skin_get ("widget-panel", "hiddenfiles-hide-char", ".");
5360     panel_history_prev_item_char = mc_skin_get ("widget-panel", "history-prev-item-char", "<");
5361     panel_history_next_item_char = mc_skin_get ("widget-panel", "history-next-item-char", ">");
5362     panel_history_show_list_char = mc_skin_get ("widget-panel", "history-show-list-char", "^");
5363     panel_filename_scroll_left_char =
5364         mc_skin_get ("widget-panel", "filename-scroll-left-char", "{");
5365     panel_filename_scroll_right_char =
5366         mc_skin_get ("widget-panel", "filename-scroll-right-char", "}");
5367
5368     string_file_name_buffer = g_string_sized_new (MC_MAXFILENAMELEN);
5369
5370     mc_event_add (MCEVENT_GROUP_FILEMANAGER, "update_panels", event_update_panels, NULL, NULL);
5371     mc_event_add (MCEVENT_GROUP_FILEMANAGER, "panel_save_current_file_to_clip_file",
5372                   panel_save_current_file_to_clip_file, NULL, NULL);
5373 }
5374
5375 /* --------------------------------------------------------------------------------------------- */
5376
5377 void
5378 panel_deinit (void)
5379 {
5380     g_free (panel_sort_up_char);
5381     g_free (panel_sort_down_char);
5382     g_free (panel_hiddenfiles_show_char);
5383     g_free (panel_hiddenfiles_hide_char);
5384     g_free (panel_history_prev_item_char);
5385     g_free (panel_history_next_item_char);
5386     g_free (panel_history_show_list_char);
5387     g_free (panel_filename_scroll_left_char);
5388     g_free (panel_filename_scroll_right_char);
5389     g_string_free (string_file_name_buffer, TRUE);
5390 }
5391
5392 /* --------------------------------------------------------------------------------------------- */
5393
5394 gboolean
5395 panel_cd (WPanel * panel, const vfs_path_t * new_dir_vpath, enum cd_enum exact)
5396 {
5397     gboolean res;
5398     const vfs_path_t *_new_dir_vpath = new_dir_vpath;
5399
5400     if (panel->is_panelized)
5401     {
5402         size_t new_vpath_len;
5403
5404         new_vpath_len = vfs_path_len (new_dir_vpath);
5405         if (vfs_path_equal_len (new_dir_vpath, panel->panelized_descr->root_vpath, new_vpath_len))
5406             _new_dir_vpath = panel->panelized_descr->root_vpath;
5407     }
5408
5409     res = panel_do_cd (panel, _new_dir_vpath, exact);
5410
5411 #ifdef HAVE_CHARSET
5412     if (res)
5413     {
5414         const vfs_path_element_t *path_element;
5415
5416         path_element = vfs_path_get_by_index (panel->cwd_vpath, -1);
5417         if (path_element->encoding != NULL)
5418             panel->codepage = get_codepage_index (path_element->encoding);
5419         else
5420             panel->codepage = SELECT_CHARSET_NO_TRANSLATE;
5421     }
5422 #endif /* HAVE_CHARSET */
5423
5424     return res;
5425 }
5426
5427 /* --------------------------------------------------------------------------------------------- */