src/filemanager/panel.c

   1 /*
   2    Panel managing.
   3
   4    Copyright (C) 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   5    2005, 2006, 2007, 2009, 2011
   6    The Free Software Foundation, Inc.
   7
   8    Written by:
   9    Miguel de Icaza, 1995
  10    Timur Bakeyev, 1997, 1999
  11
  12    This file is part of the Midnight Commander.
  13
  14    The Midnight Commander is free software: you can redistribute it
  15    and/or modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation, either version 3 of the License,
  17    or (at your option) any later version.
  18
  19    The Midnight Commander is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26  */
  27
  28 /** \file panel.c
  29  *  \brief Source: panel managin module
  30  */
  31
  32 #include <config.h>
  33
  34 #include <errno.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39
  40 #include "lib/global.h"
  41
  42 #include "lib/tty/tty.h"
  43 #include "lib/tty/mouse.h"      /* For Gpm_Event */
  44 #include "lib/tty/key.h"        /* XCTRL and ALT macros  */
  45 #include "lib/skin.h"
  46 #include "lib/strescape.h"
  47 #include "lib/filehighlight.h"
  48 #include "lib/mcconfig.h"
  49 #include "lib/vfs/vfs.h"
  50 #include "lib/unixcompat.h"
  51 #include "lib/timefmt.h"
  52 #include "lib/util.h"
  53 #include "lib/widget.h"
  54 #ifdef HAVE_CHARSET
  55 #include "lib/charsets.h"       /* get_codepage_id () */
  56 #endif
  57 #include "lib/event.h"
  58
  59 #include "src/setup.h"          /* For loading/saving panel options */
  60 #include "src/execute.h"
  61 #include "src/selcodepage.h"    /* select_charset (), SELECT_CHARSET_NO_TRANSLATE */
  62 #include "src/keybind-defaults.h"       /* global_keymap_t */
  63 #include "src/subshell.h"       /* do_subshell_chdir() */
  64
  65 #include "dir.h"
  66 #include "boxes.h"
  67 #include "tree.h"
  68 #include "ext.h"                /* regexp_command */
  69 #include "layout.h"             /* Most layout variables are here */
  70 #include "cmd.h"
  71 #include "command.h"            /* cmdline */
  72 #include "usermenu.h"
  73 #include "midnight.h"
  74 #include "mountlist.h"          /* my_statfs */
  75
  76 #include "panel.h"
  77
  78 /*** global variables ****************************************************************************/
  79
  80 /* The hook list for the select file function */
  81 hook_t *select_file_hook = NULL;
  82
  83 panelized_panel_t panelized_panel = { {NULL, 0}, -1, {'\0'} };
  84
  85 static const char *string_file_name (file_entry *, int);
  86 static const char *string_file_size (file_entry *, int);
  87 static const char *string_file_size_brief (file_entry *, int);
  88 static const char *string_file_type (file_entry *, int);
  89 static const char *string_file_mtime (file_entry *, int);
  90 static const char *string_file_atime (file_entry *, int);
  91 static const char *string_file_ctime (file_entry *, int);
  92 static const char *string_file_permission (file_entry *, int);
  93 static const char *string_file_perm_octal (file_entry *, int);
  94 static const char *string_file_nlinks (file_entry *, int);
  95 static const char *string_inode (file_entry *, int);
  96 static const char *string_file_nuid (file_entry *, int);
  97 static const char *string_file_ngid (file_entry *, int);
  98 static const char *string_file_owner (file_entry *, int);
  99 static const char *string_file_group (file_entry *, int);
 100 static const char *string_marked (file_entry *, int);
 101 static const char *string_space (file_entry *, int);
 102 static const char *string_dot (file_entry *, int);
 103
 104 /* *INDENT-OFF* */
 105 panel_field_t panel_fields[] = {
 106     {
 107      "unsorted", 12, 1, J_LEFT_FIT,
 108      /* TRANSLATORS: one single character to represent 'unsorted' sort mode  */
 109      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 110      N_("sort|u"),
 111      N_("&Unsorted"), TRUE, FALSE,
 112      string_file_name,
 113      (sortfn *) unsorted
 114     }
 115     ,
 116     {
 117      "name", 12, 1, J_LEFT_FIT,
 118      /* TRANSLATORS: one single character to represent 'name' sort mode  */
 119      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 120      N_("sort|n"),
 121      N_("&Name"), TRUE, TRUE,
 122      string_file_name,
 123      (sortfn *) sort_name
 124     }
 125     ,
 126     {
 127      "version", 12, 1, J_LEFT_FIT,
 128      /* TRANSLATORS: one single character to represent 'version' sort mode  */
 129      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 130      N_("sort|v"),
 131      N_("&Version"), TRUE, FALSE,
 132      string_file_name,
 133      (sortfn *) sort_vers
 134     }
 135     ,
 136     {
 137      "extension", 12, 1, J_LEFT_FIT,
 138      /* TRANSLATORS: one single character to represent 'extension' sort mode  */
 139      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 140      N_("sort|e"),
 141      N_("&Extension"), TRUE, FALSE,
 142      string_file_name,          /* TODO: string_file_ext */
 143      (sortfn *) sort_ext
 144     }
 145     ,
 146     {
 147      "size", 7, 0, J_RIGHT,
 148      /* TRANSLATORS: one single character to represent 'size' sort mode  */
 149      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 150      N_("sort|s"),
 151      N_("&Size"), TRUE, TRUE,
 152      string_file_size,
 153      (sortfn *) sort_size
 154     }
 155     ,
 156     {
 157      "bsize", 7, 0, J_RIGHT,
 158      "",
 159      N_("Block Size"), FALSE, FALSE,
 160      string_file_size_brief,
 161      (sortfn *) sort_size
 162     }
 163     ,
 164     {
 165      "type", 1, 0, J_LEFT,
 166      "",
 167      "", FALSE, TRUE,
 168      string_file_type,
 169      NULL
 170     }
 171     ,
 172     {
 173      "mtime", 12, 0, J_RIGHT,
 174      /* TRANSLATORS: one single character to represent 'Modify time' sort mode  */
 175      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 176      N_("sort|m"),
 177      N_("&Modify time"), TRUE, TRUE,
 178      string_file_mtime,
 179      (sortfn *) sort_time
 180     }
 181     ,
 182     {
 183      "atime", 12, 0, J_RIGHT,
 184      /* TRANSLATORS: one single character to represent 'Access time' sort mode  */
 185      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 186      N_("sort|a"),
 187      N_("&Access time"), TRUE, TRUE,
 188      string_file_atime,
 189      (sortfn *) sort_atime
 190     }
 191     ,
 192     {
 193      "ctime", 12, 0, J_RIGHT,
 194      /* TRANSLATORS: one single character to represent 'Change time' sort mode  */
 195      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 196      N_("sort|h"),
 197      N_("C&hange time"), TRUE, TRUE,
 198      string_file_ctime,
 199      (sortfn *) sort_ctime
 200     }
 201     ,
 202     {
 203      "perm", 10, 0, J_LEFT,
 204      "",
 205      N_("Permission"), FALSE, TRUE,
 206      string_file_permission,
 207      NULL
 208     }
 209     ,
 210     {
 211      "mode", 6, 0, J_RIGHT,
 212      "",
 213      N_("Perm"), FALSE, TRUE,
 214      string_file_perm_octal,
 215      NULL
 216     }
 217     ,
 218     {
 219      "nlink", 2, 0, J_RIGHT,
 220      "",
 221      N_("Nl"), FALSE, TRUE,
 222      string_file_nlinks, NULL
 223     }
 224     ,
 225     {
 226      "inode", 5, 0, J_RIGHT,
 227      /* TRANSLATORS: one single character to represent 'inode' sort mode  */
 228      /* TRANSLATORS: no need to translate 'sort', it's just a context prefix  */
 229      N_("sort|i"),
 230      N_("&Inode"), TRUE, TRUE,
 231      string_inode,
 232      (sortfn *) sort_inode
 233     }
 234     ,
 235     {
 236      "nuid", 5, 0, J_RIGHT,
 237      "",
 238      N_("UID"), FALSE, FALSE,
 239      string_file_nuid,
 240      NULL
 241     }
 242     ,
 243     {
 244      "ngid", 5, 0, J_RIGHT,
 245      "",
 246      N_("GID"), FALSE, FALSE,
 247      string_file_ngid,
 248      NULL
 249     }
 250     ,
 251     {
 252      "owner", 8, 0, J_LEFT_FIT,
 253      "",
 254      N_("Owner"), FALSE, TRUE,
 255      string_file_owner,
 256      NULL
 257     }
 258     ,
 259     {
 260      "group", 8, 0, J_LEFT_FIT,
 261      "",
 262      N_("Group"), FALSE, TRUE,
 263      string_file_group,
 264      NULL
 265     }
 266     ,
 267     {
 268      "mark", 1, 0, J_RIGHT,
 269      "",
 270      " ", FALSE, TRUE,
 271      string_marked,
 272      NULL
 273     }
 274     ,
 275     {
 276      "|", 1, 0, J_RIGHT,
 277      "",
 278      " ", FALSE, TRUE,
 279      NULL,
 280      NULL
 281     }
 282     ,
 283     {
 284      "space", 1, 0, J_RIGHT,
 285      "",
 286      " ", FALSE, TRUE,
 287      string_space,
 288      NULL
 289     }
 290     ,
 291     {
 292      "dot", 1, 0, J_RIGHT,
 293      "",
 294      " ", FALSE, FALSE,
 295      string_dot,
 296      NULL
 297     }
 298     ,
 299     {
 300      NULL, 0, 0, J_RIGHT, NULL, NULL, FALSE, FALSE, NULL, NULL
 301     }
 302 };
 303 /* *INDENT-ON* */
 304
 305 extern int saving_setup;
 306
 307 /*** file scope macro definitions ****************************************************************/
 308
 309 #define ELEMENTS(arr) ( sizeof(arr) / sizeof((arr)[0]) )
 310
 311 #define NORMAL          0
 312 #define SELECTED        1
 313 #define MARKED          2
 314 #define MARKED_SELECTED 3
 315 #define STATUS          5
 316
 317 /* This macro extracts the number of available lines in a panel */
 318 #define llines(p) (p->widget.lines - 3 - (panels_options.show_mini_info ? 2 : 0))
 319
 320 /*** file scope type declarations ****************************************************************/
 321
 322 typedef enum
 323 {
 324     MARK_DONT_MOVE = 0,
 325     MARK_DOWN = 1,
 326     MARK_FORCE_DOWN = 2,
 327     MARK_FORCE_UP = 3
 328 } mark_act_t;
 329
 330 /*
 331  * This describes a format item.  The parse_display_format routine parses
 332  * the user specified format and creates a linked list of format_e structures.
 333  */
 334 typedef struct format_e
 335 {
 336     struct format_e *next;
 337     int requested_field_len;
 338     int field_len;
 339     align_crt_t just_mode;
 340     int expand;
 341     const char *(*string_fn) (file_entry *, int len);
 342     char *title;
 343     const char *id;
 344 } format_e;
 345
 346 /*** file scope variables ************************************************************************/
 347
 348 static char *panel_sort_up_sign = NULL;
 349 static char *panel_sort_down_sign = NULL;
 350
 351 static char *panel_hiddenfiles_sign_show = NULL;
 352 static char *panel_hiddenfiles_sign_hide = NULL;
 353 static char *panel_history_prev_item_sign = NULL;
 354 static char *panel_history_next_item_sign = NULL;
 355 static char *panel_history_show_list_sign = NULL;
 356
 357 /* Panel that selection started */
 358 static WPanel *mouse_mark_panel = NULL;
 359
 360 static int mouse_marking = 0;
 361 static int state_mark = 0;
 362 /*** file scope functions ************************************************************************/
 363 /* --------------------------------------------------------------------------------------------- */
 364
 365 static void
 366 set_colors (WPanel * panel)
 367 {
 368     (void) panel;
 369     tty_set_normal_attrs ();
 370     tty_setcolor (NORMAL_COLOR);
 371 }
 372
 373 /* --------------------------------------------------------------------------------------------- */
 374 /** Delete format string, it is a linked list */
 375
 376 static void
 377 delete_format (format_e * format)
 378 {
 379     while (format != NULL)
 380     {
 381         format_e *next = format->next;
 382         g_free (format->title);
 383         g_free (format);
 384         format = next;
 385     }
 386 }
 387
 388 /* --------------------------------------------------------------------------------------------- */
 389 /** This code relies on the default justification!!! */
 390
 391 static void
 392 add_permission_string (char *dest, int width, file_entry * fe, int attr, int color, int is_octal)
 393 {
 394     int i, r, l;
 395
 396     l = get_user_permissions (&fe->st);
 397
 398     if (is_octal)
 399     {
 400         /* Place of the access bit in octal mode */
 401         l = width + l - 3;
 402         r = l + 1;
 403     }
 404     else
 405     {
 406         /* The same to the triplet in string mode */
 407         l = l * 3 + 1;
 408         r = l + 3;
 409     }
 410
 411     for (i = 0; i < width; i++)
 412     {
 413         if (i >= l && i < r)
 414         {
 415             if (attr == SELECTED || attr == MARKED_SELECTED)
 416                 tty_setcolor (MARKED_SELECTED_COLOR);
 417             else
 418                 tty_setcolor (MARKED_COLOR);
 419         }
 420         else if (color >= 0)
 421             tty_setcolor (color);
 422         else
 423             tty_lowlevel_setcolor (-color);
 424
 425         tty_print_char (dest[i]);
 426     }
 427 }
 428
 429 /* --------------------------------------------------------------------------------------------- */
 430 /** String representations of various file attributes name */
 431
 432 static const char *
 433 string_file_name (file_entry * fe, int len)
 434 {
 435     static char buffer[MC_MAXPATHLEN * MB_LEN_MAX + 1];
 436
 437     (void) len;
 438     g_strlcpy (buffer, fe->fname, sizeof (buffer));
 439     return buffer;
 440 }
 441
 442 /* --------------------------------------------------------------------------------------------- */
 443
 444 static unsigned int
 445 ilog10 (dev_t n)
 446 {
 447     unsigned int digits = 0;
 448     do
 449     {
 450         digits++, n /= 10;
 451     }
 452     while (n != 0);
 453     return digits;
 454 }
 455
 456 /* --------------------------------------------------------------------------------------------- */
 457
 458 static void
 459 format_device_number (char *buf, size_t bufsize, dev_t dev)
 460 {
 461     dev_t major_dev = major (dev);
 462     dev_t minor_dev = minor (dev);
 463     unsigned int major_digits = ilog10 (major_dev);
 464     unsigned int minor_digits = ilog10 (minor_dev);
 465
 466     g_assert (bufsize >= 1);
 467     if (major_digits + 1 + minor_digits + 1 <= bufsize)
 468     {
 469         g_snprintf (buf, bufsize, "%lu,%lu", (unsigned long) major_dev, (unsigned long) minor_dev);
 470     }
 471     else
 472     {
 473         g_strlcpy (buf, _("[dev]"), bufsize);
 474     }
 475 }
 476
 477 /* --------------------------------------------------------------------------------------------- */
 478 /** size */
 479
 480 static const char *
 481 string_file_size (file_entry * fe, int len)
 482 {
 483     static char buffer[BUF_TINY];
 484
 485     /* Don't ever show size of ".." since we don't calculate it */
 486     if (!strcmp (fe->fname, ".."))
 487     {
 488         return _("UP--DIR");
 489     }
 490
 491 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 492     if (S_ISBLK (fe->st.st_mode) || S_ISCHR (fe->st.st_mode))
 493         format_device_number (buffer, len + 1, fe->st.st_rdev);
 494     else
 495 #endif
 496     {
 497         size_trunc_len (buffer, (unsigned int) len, fe->st.st_size, 0, panels_options.kilobyte_si);
 498     }
 499     return buffer;
 500 }
 501
 502 /* --------------------------------------------------------------------------------------------- */
 503 /** bsize */
 504
 505 static const char *
 506 string_file_size_brief (file_entry * fe, int len)
 507 {
 508     if (S_ISLNK (fe->st.st_mode) && !fe->f.link_to_dir)
 509     {
 510         return _("SYMLINK");
 511     }
 512
 513     if ((S_ISDIR (fe->st.st_mode) || fe->f.link_to_dir) && strcmp (fe->fname, ".."))
 514     {
 515         return _("SUB-DIR");
 516     }
 517
 518     return string_file_size (fe, len);
 519 }
 520
 521 /* --------------------------------------------------------------------------------------------- */
 522 /** This functions return a string representation of a file entry type */
 523
 524 static const char *
 525 string_file_type (file_entry * fe, int len)
 526 {
 527     static char buffer[2];
 528
 529     (void) len;
 530     if (S_ISDIR (fe->st.st_mode))
 531         buffer[0] = PATH_SEP;
 532     else if (S_ISLNK (fe->st.st_mode))
 533     {
 534         if (fe->f.link_to_dir)
 535             buffer[0] = '~';
 536         else if (fe->f.stale_link)
 537             buffer[0] = '!';
 538         else
 539             buffer[0] = '@';
 540     }
 541     else if (S_ISCHR (fe->st.st_mode))
 542         buffer[0] = '-';
 543     else if (S_ISSOCK (fe->st.st_mode))
 544         buffer[0] = '=';
 545     else if (S_ISDOOR (fe->st.st_mode))
 546         buffer[0] = '>';
 547     else if (S_ISBLK (fe->st.st_mode))
 548         buffer[0] = '+';
 549     else if (S_ISFIFO (fe->st.st_mode))
 550         buffer[0] = '|';
 551     else if (S_ISNAM (fe->st.st_mode))
 552         buffer[0] = '#';
 553     else if (!S_ISREG (fe->st.st_mode))
 554         buffer[0] = '?';        /* non-regular of unknown kind */
 555     else if (is_exe (fe->st.st_mode))
 556         buffer[0] = '*';
 557     else
 558         buffer[0] = ' ';
 559     buffer[1] = '\0';
 560     return buffer;
 561 }
 562
 563 /* --------------------------------------------------------------------------------------------- */
 564 /** mtime */
 565
 566 static const char *
 567 string_file_mtime (file_entry * fe, int len)
 568 {
 569     (void) len;
 570     return file_date (fe->st.st_mtime);
 571 }
 572
 573 /* --------------------------------------------------------------------------------------------- */
 574 /** atime */
 575
 576 static const char *
 577 string_file_atime (file_entry * fe, int len)
 578 {
 579     (void) len;
 580     return file_date (fe->st.st_atime);
 581 }
 582
 583 /* --------------------------------------------------------------------------------------------- */
 584 /** ctime */
 585
 586 static const char *
 587 string_file_ctime (file_entry * fe, int len)
 588 {
 589     (void) len;
 590     return file_date (fe->st.st_ctime);
 591 }
 592
 593 /* --------------------------------------------------------------------------------------------- */
 594 /** perm */
 595
 596 static const char *
 597 string_file_permission (file_entry * fe, int len)
 598 {
 599     (void) len;
 600     return string_perm (fe->st.st_mode);
 601 }
 602
 603 /* --------------------------------------------------------------------------------------------- */
 604 /** mode */
 605
 606 static const char *
 607 string_file_perm_octal (file_entry * fe, int len)
 608 {
 609     static char buffer[10];
 610
 611     (void) len;
 612     g_snprintf (buffer, sizeof (buffer), "0%06lo", (unsigned long) fe->st.st_mode);
 613     return buffer;
 614 }
 615
 616 /* --------------------------------------------------------------------------------------------- */
 617 /** nlink */
 618
 619 static const char *
 620 string_file_nlinks (file_entry * fe, int len)
 621 {
 622     static char buffer[BUF_TINY];
 623
 624     (void) len;
 625     g_snprintf (buffer, sizeof (buffer), "%16d", (int) fe->st.st_nlink);
 626     return buffer;
 627 }
 628
 629 /* --------------------------------------------------------------------------------------------- */
 630 /** inode */
 631
 632 static const char *
 633 string_inode (file_entry * fe, int len)
 634 {
 635     static char buffer[10];
 636
 637     (void) len;
 638     g_snprintf (buffer, sizeof (buffer), "%lu", (unsigned long) fe->st.st_ino);
 639     return buffer;
 640 }
 641
 642 /* --------------------------------------------------------------------------------------------- */
 643 /** nuid */
 644
 645 static const char *
 646 string_file_nuid (file_entry * fe, int len)
 647 {
 648     static char buffer[10];
 649
 650     (void) len;
 651     g_snprintf (buffer, sizeof (buffer), "%lu", (unsigned long) fe->st.st_uid);
 652     return buffer;
 653 }
 654
 655 /* --------------------------------------------------------------------------------------------- */
 656 /** ngid */
 657
 658 static const char *
 659 string_file_ngid (file_entry * fe, int len)
 660 {
 661     static char buffer[10];
 662
 663     (void) len;
 664     g_snprintf (buffer, sizeof (buffer), "%lu", (unsigned long) fe->st.st_gid);
 665     return buffer;
 666 }
 667
 668 /* --------------------------------------------------------------------------------------------- */
 669 /** owner */
 670
 671 static const char *
 672 string_file_owner (file_entry * fe, int len)
 673 {
 674     (void) len;
 675     return get_owner (fe->st.st_uid);
 676 }
 677
 678 /* --------------------------------------------------------------------------------------------- */
 679 /** group */
 680
 681 static const char *
 682 string_file_group (file_entry * fe, int len)
 683 {
 684     (void) len;
 685     return get_group (fe->st.st_gid);
 686 }
 687
 688 /* --------------------------------------------------------------------------------------------- */
 689 /** mark */
 690
 691 static const char *
 692 string_marked (file_entry * fe, int len)
 693 {
 694     (void) len;
 695     return fe->f.marked ? "*" : " ";
 696 }
 697
 698 /* --------------------------------------------------------------------------------------------- */
 699 /** space */
 700
 701 static const char *
 702 string_space (file_entry * fe, int len)
 703 {
 704     (void) fe;
 705     (void) len;
 706     return " ";
 707 }
 708
 709 /* --------------------------------------------------------------------------------------------- */
 710 /** dot */
 711
 712 static const char *
 713 string_dot (file_entry * fe, int len)
 714 {
 715     (void) fe;
 716     (void) len;
 717     return ".";
 718 }
 719
 720 /* --------------------------------------------------------------------------------------------- */
 721
 722 static int
 723 file_compute_color (int attr, file_entry * fe)
 724 {
 725     switch (attr)
 726     {
 727     case SELECTED:
 728         return (SELECTED_COLOR);
 729     case MARKED:
 730         return (MARKED_COLOR);
 731     case MARKED_SELECTED:
 732         return (MARKED_SELECTED_COLOR);
 733     case STATUS:
 734         return (NORMAL_COLOR);
 735     case NORMAL:
 736     default:
 737         if (!panels_options.filetype_mode)
 738             return (NORMAL_COLOR);
 739     }
 740
 741     return mc_fhl_get_color (mc_filehighlight, fe);
 742 }
 743
 744 /* --------------------------------------------------------------------------------------------- */
 745 /** Formats the file number file_index of panel in the buffer dest */
 746
 747 static void
 748 format_file (char *dest, int limit, WPanel * panel, int file_index, int width, int attr,
 749              int isstatus)
 750 {
 751     int color, length, empty_line;
 752     const char *txt;
 753     format_e *format, *home;
 754     file_entry *fe;
 755
 756     (void) dest;
 757     (void) limit;
 758     length = 0;
 759     empty_line = (file_index >= panel->count);
 760     home = (isstatus) ? panel->status_format : panel->format;
 761     fe = &panel->dir.list[file_index];
 762
 763     if (!empty_line)
 764         color = file_compute_color (attr, fe);
 765     else
 766         color = NORMAL_COLOR;
 767
 768     for (format = home; format; format = format->next)
 769     {
 770         if (length == width)
 771             break;
 772
 773         if (format->string_fn)
 774         {
 775             int len, perm;
 776             char *preperad_text;
 777
 778             if (empty_line)
 779                 txt = " ";
 780             else
 781                 txt = (*format->string_fn) (fe, format->field_len);
 782
 783             len = format->field_len;
 784             if (len + length > width)
 785                 len = width - length;
 786             if (len <= 0)
 787                 break;
 788
 789             perm = 0;
 790             if (panels_options.permission_mode)
 791             {
 792                 if (!strcmp (format->id, "perm"))
 793                     perm = 1;
 794                 else if (!strcmp (format->id, "mode"))
 795                     perm = 2;
 796             }
 797
 798             if (color >= 0)
 799                 tty_setcolor (color);
 800             else
 801                 tty_lowlevel_setcolor (-color);
 802
 803             preperad_text = (char *) str_fit_to_term (txt, len, format->just_mode);
 804
 805             if (perm)
 806                 add_permission_string (preperad_text, format->field_len, fe, attr, color, perm - 1);
 807             else
 808                 tty_print_string (preperad_text);
 809
 810             length += len;
 811         }
 812         else
 813         {
 814             if (attr == SELECTED || attr == MARKED_SELECTED)
 815                 tty_setcolor (SELECTED_COLOR);
 816             else
 817                 tty_setcolor (NORMAL_COLOR);
 818             tty_print_one_vline (TRUE);
 819             length++;
 820         }
 821     }
 822
 823     if (length < width)
 824         tty_draw_hline (-1, -1, ' ', width - length);
 825 }
 826
 827 /* --------------------------------------------------------------------------------------------- */
 828
 829 static void
 830 repaint_file (WPanel * panel, int file_index, int mv, int attr, int isstatus)
 831 {
 832     int second_column = 0;
 833     int width;
 834     int offset = 0;
 835     char buffer[BUF_MEDIUM];
 836
 837     gboolean panel_is_split = !isstatus && panel->split;
 838
 839     width = panel->widget.cols - 2;
 840
 841     if (panel_is_split)
 842     {
 843         second_column = (file_index - panel->top_file) / llines (panel);
 844         width = width / 2 - 1;
 845
 846         if (second_column != 0)
 847         {
 848             offset = 1 + width;
 849             /*width = (panel->widget.cols-2) - (panel->widget.cols-2)/2 - 1; */
 850             width = panel->widget.cols - offset - 2;
 851         }
 852     }
 853
 854     /* Nothing to paint */
 855     if (width <= 0)
 856         return;
 857
 858     if (mv)
 859     {
 860         if (panel_is_split)
 861             widget_move (&panel->widget,
 862                          (file_index - panel->top_file) % llines (panel) + 2, offset + 1);
 863         else
 864             widget_move (&panel->widget, file_index - panel->top_file + 2, 1);
 865     }
 866
 867     format_file (buffer, sizeof (buffer), panel, file_index, width, attr, isstatus);
 868
 869     if (panel_is_split)
 870     {
 871         if (second_column)
 872             tty_print_char (' ');
 873         else
 874         {
 875             tty_setcolor (NORMAL_COLOR);
 876             tty_print_one_vline (TRUE);
 877         }
 878     }
 879 }
 880
 881 /* --------------------------------------------------------------------------------------------- */
 882
 883 static void
 884 display_mini_info (WPanel * panel)
 885 {
 886     if (!panels_options.show_mini_info)
 887         return;
 888
 889     widget_move (&panel->widget, llines (panel) + 3, 1);
 890
 891     if (panel->searching)
 892     {
 893         tty_setcolor (INPUT_COLOR);
 894         tty_print_char ('/');
 895         tty_print_string (str_fit_to_term (panel->search_buffer, panel->widget.cols - 3, J_LEFT));
 896         return;
 897     }
 898
 899     /* Status resolves links and show them */
 900     set_colors (panel);
 901
 902     if (S_ISLNK (panel->dir.list[panel->selected].st.st_mode))
 903     {
 904         char *lc_link, link_target[MC_MAXPATHLEN];
 905         int len;
 906
 907         lc_link = concat_dir_and_file (panel->cwd, panel->dir.list[panel->selected].fname);
 908         len = mc_readlink (lc_link, link_target, MC_MAXPATHLEN - 1);
 909         g_free (lc_link);
 910         if (len > 0)
 911         {
 912             link_target[len] = 0;
 913             tty_print_string ("-> ");
 914             tty_print_string (str_fit_to_term (link_target, panel->widget.cols - 5, J_LEFT_FIT));
 915         }
 916         else
 917             tty_print_string (str_fit_to_term (_("<readlink failed>"),
 918                                                panel->widget.cols - 2, J_LEFT));
 919     }
 920     else if (strcmp (panel->dir.list[panel->selected].fname, "..") == 0)
 921     {
 922         /* FIXME:
 923          * while loading directory (do_load_dir() and do_reload_dir()),
 924          * the actual stat info about ".." directory isn't got;
 925          * so just don't display incorrect info about ".." directory */
 926         tty_print_string (str_fit_to_term (_("UP--DIR"), panel->widget.cols - 2, J_LEFT));
 927     }
 928     else
 929         /* Default behavior */
 930         repaint_file (panel, panel->selected, 0, STATUS, 1);
 931 }
 932
 933 /* --------------------------------------------------------------------------------------------- */
 934
 935 static void
 936 paint_dir (WPanel * panel)
 937 {
 938     int i;
 939     int color;                  /* Color value of the line */
 940     int items;                  /* Number of items */
 941
 942     items = llines (panel) * (panel->split ? 2 : 1);
 943
 944     for (i = 0; i < items; i++)
 945     {
 946         if (i + panel->top_file >= panel->count)
 947             color = 0;
 948         else
 949         {
 950             color = 2 * (panel->dir.list[i + panel->top_file].f.marked);
 951             color += (panel->selected == i + panel->top_file && panel->active);
 952         }
 953         repaint_file (panel, i + panel->top_file, 1, color, 0);
 954     }
 955     tty_set_normal_attrs ();
 956 }
 957
 958 /* --------------------------------------------------------------------------------------------- */
 959
 960 static void
 961 display_total_marked_size (WPanel * panel, int y, int x, gboolean size_only)
 962 {
 963     char buffer[BUF_SMALL], b_bytes[BUF_SMALL], *buf;
 964     int cols;
 965
 966     if (panel->marked <= 0)
 967         return;
 968
 969     buf = size_only ? b_bytes : buffer;
 970     cols = panel->widget.cols - 2;
 971
 972     /*
 973      * This is a trick to use two ngettext() calls in one sentence.
 974      * First make "N bytes", then insert it into "X in M files".
 975      */
 976     g_snprintf (b_bytes, sizeof (b_bytes),
 977                 ngettext ("%s byte", "%s bytes", panel->total),
 978                 size_trunc_sep (panel->total, panels_options.kilobyte_si));
 979     if (!size_only)
 980         g_snprintf (buffer, sizeof (buffer),
 981                     ngettext ("%s in %d file", "%s in %d files", panel->marked),
 982                     b_bytes, panel->marked);
 983
 984     /* don't forget spaces around buffer content */
 985     buf = (char *) str_trunc (buf, cols - 4);
 986
 987     if (x < 0)
 988         /* center in panel */
 989         x = (panel->widget.cols - str_term_width1 (buf)) / 2 - 1;
 990
 991     /*
 992      * y == llines (panel) + 2      for mini_info_separator
 993      * y == panel->widget.lines - 1 for panel bottom frame
 994      */
 995     widget_move (&panel->widget, y, x);
 996     tty_setcolor (MARKED_COLOR);
 997     tty_printf (" %s ", buf);
 998 }
 999
1000 /* --------------------------------------------------------------------------------------------- */
1001
1002 static void
1003 mini_info_separator (WPanel * panel)
1004 {
1005     if (panels_options.show_mini_info)
1006     {
1007         const int y = llines (panel) + 2;
1008
1009         tty_setcolor (NORMAL_COLOR);
1010         tty_draw_hline (panel->widget.y + y, panel->widget.x + 1,
1011                         ACS_HLINE, panel->widget.cols - 2);
1012         /* Status displays total marked size.
1013          * Centered in panel, full format. */
1014         display_total_marked_size (panel, y, -1, FALSE);
1015     }
1016 }
1017
1018 /* --------------------------------------------------------------------------------------------- */
1019
1020 static void
1021 show_free_space (WPanel * panel)
1022 {
1023     /* Used to figure out how many free space we have */
1024     static struct my_statfs myfs_stats;
1025     /* Old current working directory for displaying free space */
1026     static char *old_cwd = NULL;
1027     vfs_path_t *vpath = vfs_path_from_str (panel->cwd);
1028
1029     /* Don't try to stat non-local fs */
1030     if (!vfs_file_is_local (vpath) || !free_space)
1031     {
1032         vfs_path_free (vpath);
1033         return;
1034     }
1035     vfs_path_free (vpath);
1036
1037     if (old_cwd == NULL || strcmp (old_cwd, panel->cwd) != 0)
1038     {
1039         char rpath[PATH_MAX];
1040
1041         init_my_statfs ();
1042         g_free (old_cwd);
1043         old_cwd = g_strdup (panel->cwd);
1044
1045         if (mc_realpath (panel->cwd, rpath) == NULL)
1046             return;
1047
1048         my_statfs (&myfs_stats, rpath);
1049     }
1050
1051     if (myfs_stats.avail != 0 || myfs_stats.total != 0)
1052     {
1053         char buffer1[6], buffer2[6], tmp[BUF_SMALL];
1054         size_trunc_len (buffer1, sizeof (buffer1) - 1, myfs_stats.avail, 1,
1055                         panels_options.kilobyte_si);
1056         size_trunc_len (buffer2, sizeof (buffer2) - 1, myfs_stats.total, 1,
1057                         panels_options.kilobyte_si);
1058         g_snprintf (tmp, sizeof (tmp), " %s/%s (%d%%) ", buffer1, buffer2,
1059                     myfs_stats.total == 0 ? 0 :
1060                     (int) (100 * (long double) myfs_stats.avail / myfs_stats.total));
1061         widget_move (&panel->widget, panel->widget.lines - 1,
1062                      panel->widget.cols - 2 - (int) strlen (tmp));
1063         tty_setcolor (NORMAL_COLOR);
1064         tty_print_string (tmp);
1065     }
1066 }
1067
1068 /* --------------------------------------------------------------------------------------------- */
1069
1070 static void
1071 show_dir (WPanel * panel)
1072 {
1073     gchar *tmp;
1074     set_colors (panel);
1075     draw_box (panel->widget.owner,
1076               panel->widget.y, panel->widget.x, panel->widget.lines, panel->widget.cols, FALSE);
1077
1078     if (panels_options.show_mini_info)
1079     {
1080         widget_move (&panel->widget, llines (panel) + 2, 0);
1081         tty_print_alt_char (ACS_LTEE, FALSE);
1082         widget_move (&panel->widget, llines (panel) + 2, panel->widget.cols - 1);
1083         tty_print_alt_char (ACS_RTEE, FALSE);
1084     }
1085
1086     widget_move (&panel->widget, 0, 1);
1087     tty_print_string (panel_history_prev_item_sign);
1088
1089     tmp = panels_options.show_dot_files ? panel_hiddenfiles_sign_show : panel_hiddenfiles_sign_hide;
1090     tmp = g_strdup_printf ("%s[%s]%s", tmp, panel_history_show_list_sign,
1091                            panel_history_next_item_sign);
1092
1093     widget_move (&panel->widget, 0, panel->widget.cols - 6);
1094     tty_print_string (tmp);
1095
1096     g_free (tmp);
1097
1098     if (panel->active)
1099         tty_setcolor (REVERSE_COLOR);
1100
1101     widget_move (&panel->widget, 0, 3);
1102
1103     if (panel->is_panelized)
1104         tty_printf (" %s ", _("Panelize"));
1105     else
1106         tty_printf (" %s ",
1107                 str_term_trim (strip_home_and_password (panel->cwd),
1108                                min (max (panel->widget.cols - 12, 0), panel->widget.cols)));
1109
1110     if (!panels_options.show_mini_info)
1111     {
1112         if (panel->marked == 0)
1113         {
1114             /* Show size of curret file in the bottom of panel */
1115             if (S_ISREG (panel->dir.list[panel->selected].st.st_mode))
1116             {
1117                 char buffer[BUF_SMALL];
1118
1119                 g_snprintf (buffer, sizeof (buffer), " %s ",
1120                             size_trunc_sep (panel->dir.list[panel->selected].st.st_size,
1121                                             panels_options.kilobyte_si));
1122                 tty_setcolor (NORMAL_COLOR);
1123                 widget_move (&panel->widget, panel->widget.lines - 1, 4);
1124                 tty_print_string (buffer);
1125             }
1126         }
1127         else
1128         {
1129             /* Show total size of marked files
1130              * In the bottom of panel, display size only. */
1131             display_total_marked_size (panel, panel->widget.lines - 1, 2, TRUE);
1132         }
1133     }
1134
1135     show_free_space (panel);
1136
1137     if (panel->active)
1138         tty_set_normal_attrs ();
1139 }
1140
1141 /* --------------------------------------------------------------------------------------------- */
1142 /** To be used only by long_frame and full_frame to adjust top_file */
1143
1144 static void
1145 adjust_top_file (WPanel * panel)
1146 {
1147     int old_top = panel->top_file;
1148
1149     if (panel->selected - old_top > llines (panel))
1150         panel->top_file = panel->selected;
1151     if (old_top - panel->count > llines (panel))
1152         panel->top_file = panel->count - llines (panel);
1153 }
1154
1155 /* --------------------------------------------------------------------------------------------- */
1156 /** add "#enc:encodning" to end of path */
1157 /* if path end width a previous #enc:, only encoding is changed no additional
1158  * #enc: is appended
1159  * retun new string
1160  */
1161
1162 static char *
1163 panel_save_name (WPanel * panel)
1164 {
1165     /* If the program is shuting down */
1166     if ((mc_global.widget.midnight_shutdown && auto_save_setup) || saving_setup)
1167         return g_strdup (panel->panel_name);
1168     else
1169         return g_strconcat ("Temporal:", panel->panel_name, (char *) NULL);
1170 }
1171
1172 /* --------------------------------------------------------------------------------------------- */
1173
1174 /* "history_load" event handler */
1175 static gboolean
1176 panel_load_history (const gchar * event_group_name, const gchar * event_name,
1177                     gpointer init_data, gpointer data)
1178 {
1179     WPanel *p = (WPanel *) init_data;
1180     ev_history_load_save_t *ev = (ev_history_load_save_t *) data;
1181
1182     (void) event_group_name;
1183     (void) event_name;
1184
1185     if (ev->receiver == NULL || ev->receiver == (Widget *) p)
1186     {
1187         if (ev->cfg != NULL)
1188             p->dir_history = history_load (ev->cfg, p->hist_name);
1189         else
1190             p->dir_history = history_get (p->hist_name);
1191
1192         directory_history_add (p, p->cwd);
1193     }
1194
1195     return TRUE;
1196 }
1197
1198 /* --------------------------------------------------------------------------------------------- */
1199
1200 /* "history_save" event handler */
1201 static gboolean
1202 panel_save_history (const gchar * event_group_name, const gchar * event_name,
1203                     gpointer init_data, gpointer data)
1204 {
1205     WPanel *p = (WPanel *) init_data;
1206
1207     (void) event_group_name;
1208     (void) event_name;
1209
1210     if (p->dir_history != NULL)
1211     {
1212         ev_history_load_save_t *ev = (ev_history_load_save_t *) data;
1213
1214         history_save (ev->cfg, p->hist_name, p->dir_history);
1215     }
1216
1217     return TRUE;
1218 }
1219
1220 /* --------------------------------------------------------------------------------------------- */
1221
1222 static void
1223 panel_destroy (WPanel * p)
1224 {
1225     size_t i;
1226
1227     if (panels_options.auto_save_setup)
1228     {
1229         char *name;
1230
1231         name = panel_save_name (p);
1232         panel_save_setup (p, name);
1233         g_free (name);
1234     }
1235
1236     panel_clean_dir (p);
1237
1238     /* clean history */
1239     if (p->dir_history != NULL)
1240     {
1241         /* directory history is already saved before this moment */
1242         p->dir_history = g_list_first (p->dir_history);
1243         g_list_foreach (p->dir_history, (GFunc) g_free, NULL);
1244         g_list_free (p->dir_history);
1245     }
1246     g_free (p->hist_name);
1247
1248     delete_format (p->format);
1249     delete_format (p->status_format);
1250
1251     g_free (p->user_format);
1252     for (i = 0; i < LIST_TYPES; i++)
1253         g_free (p->user_status_format[i]);
1254     g_free (p->dir.list);
1255     g_free (p->panel_name);
1256 }
1257
1258 /* --------------------------------------------------------------------------------------------- */
1259
1260 static void
1261 panel_format_modified (WPanel * panel)
1262 {
1263     panel->format_modified = 1;
1264 }
1265
1266 /* --------------------------------------------------------------------------------------------- */
1267
1268 static void
1269 panel_paint_sort_info (WPanel * panel)
1270 {
1271     if (*panel->sort_info.sort_field->hotkey != '\0')
1272     {
1273         const char *sort_sign =
1274             panel->sort_info.reverse ? panel_sort_down_sign : panel_sort_up_sign;
1275         char *str;
1276
1277         str = g_strdup_printf ("%s%s", sort_sign, Q_ (panel->sort_info.sort_field->hotkey));
1278         widget_move (&panel->widget, 1, 1);
1279         tty_print_string (str);
1280         g_free (str);
1281     }
1282 }
1283
1284 /* --------------------------------------------------------------------------------------------- */
1285
1286 static gchar *
1287 panel_get_title_without_hotkey (const char *title)
1288 {
1289     char *translated_title;
1290     char *hkey;
1291
1292     if (title == NULL)
1293         return NULL;
1294     if (title[0] == '\0')
1295         return g_strdup ("");
1296
1297     translated_title = g_strdup (_(title));
1298
1299     hkey = strchr (translated_title, '&');
1300     if ((hkey != NULL) && (hkey[1] != '\0'))
1301         memmove ((void *) hkey, (void *) hkey + 1, strlen (hkey));
1302
1303     return translated_title;
1304 }
1305
1306 /* --------------------------------------------------------------------------------------------- */
1307
1308 static void
1309 paint_frame (WPanel * panel)
1310 {
1311     int side, width;
1312     GString *format_txt;
1313
1314     if (!panel->split)
1315         adjust_top_file (panel);
1316
1317     widget_erase (&panel->widget);
1318     show_dir (panel);
1319
1320     widget_move (&panel->widget, 1, 1);
1321
1322     for (side = 0; side <= panel->split; side++)
1323     {
1324         format_e *format;
1325
1326         if (side)
1327         {
1328             tty_setcolor (NORMAL_COLOR);
1329             tty_print_one_vline (TRUE);
1330             width = panel->widget.cols - panel->widget.cols / 2 - 1;
1331         }
1332         else if (panel->split)
1333             width = panel->widget.cols / 2 - 3;
1334         else
1335             width = panel->widget.cols - 2;
1336
1337         format_txt = g_string_new ("");
1338         for (format = panel->format; format; format = format->next)
1339         {
1340             if (format->string_fn)
1341             {
1342                 g_string_set_size (format_txt, 0);
1343
1344                 if (panel->list_type == list_long
1345                     && strcmp (format->id, panel->sort_info.sort_field->id) == 0)
1346                     g_string_append (format_txt,
1347                                      panel->sort_info.reverse
1348                                      ? panel_sort_down_sign : panel_sort_up_sign);
1349
1350                 g_string_append (format_txt, format->title);
1351                 if (strcmp (format->id, "name") == 0 && panel->filter && *panel->filter)
1352                 {
1353                     g_string_append (format_txt, " [");
1354                     g_string_append (format_txt, panel->filter);
1355                     g_string_append (format_txt, "]");
1356                 }
1357
1358                 tty_setcolor (HEADER_COLOR);
1359                 tty_print_string (str_fit_to_term (format_txt->str, format->field_len,
1360                                                    J_CENTER_LEFT));
1361                 width -= format->field_len;
1362             }
1363             else
1364             {
1365                 tty_setcolor (NORMAL_COLOR);
1366                 tty_print_one_vline (TRUE);
1367                 width--;
1368             }
1369         }
1370         g_string_free (format_txt, TRUE);
1371
1372         if (width > 0)
1373             tty_draw_hline (-1, -1, ' ', width);
1374     }
1375
1376     if (panel->list_type != list_long)
1377         panel_paint_sort_info (panel);
1378 }
1379
1380 /* --------------------------------------------------------------------------------------------- */
1381
1382 static const char *
1383 parse_panel_size (WPanel * panel, const char *format, int isstatus)
1384 {
1385     panel_display_t frame = frame_half;
1386     format = skip_separators (format);
1387
1388     if (!strncmp (format, "full", 4))
1389     {
1390         frame = frame_full;
1391         format += 4;
1392     }
1393     else if (!strncmp (format, "half", 4))
1394     {
1395         frame = frame_half;
1396         format += 4;
1397     }
1398
1399     if (!isstatus)
1400     {
1401         panel->frame_size = frame;
1402         panel->split = 0;
1403     }
1404
1405     /* Now, the optional column specifier */
1406     format = skip_separators (format);
1407
1408     if (*format == '1' || *format == '2')
1409     {
1410         if (!isstatus)
1411             panel->split = *format == '2';
1412         format++;
1413     }
1414
1415     if (!isstatus)
1416         panel_update_cols (&(panel->widget), panel->frame_size);
1417
1418     return skip_separators (format);
1419 }
1420
1421 /* Format is:
1422
1423    all              := panel_format? format
1424    panel_format     := [full|half] [1|2]
1425    format           := one_format_e
1426    | format , one_format_e
1427
1428    one_format_e     := just format.id [opt_size]
1429    just             := [<=>]
1430    opt_size         := : size [opt_expand]
1431    size             := [0-9]+
1432    opt_expand       := +
1433
1434  */
1435
1436 /* --------------------------------------------------------------------------------------------- */
1437
1438 static format_e *
1439 parse_display_format (WPanel * panel, const char *format, char **error, int isstatus,
1440                       int *res_total_cols)
1441 {
1442     format_e *darr, *old = 0, *home = 0;        /* The formats we return */
1443     int total_cols = 0;         /* Used columns by the format */
1444     int set_justify;            /* flag: set justification mode? */
1445     align_crt_t justify = J_LEFT;       /* Which mode. */
1446     size_t i;
1447
1448     static size_t i18n_timelength = 0;  /* flag: check ?Time length at startup */
1449
1450     *error = 0;
1451
1452     if (i18n_timelength == 0)
1453     {
1454         i18n_timelength = i18n_checktimelength ();      /* Musn't be 0 */
1455
1456         for (i = 0; panel_fields[i].id != NULL; i++)
1457             if (strcmp ("time", panel_fields[i].id + 1) == 0)
1458                 panel_fields[i].min_size = i18n_timelength;
1459     }
1460
1461     /*
1462      * This makes sure that the panel and mini status full/half mode
1463      * setting is equal
1464      */
1465     format = parse_panel_size (panel, format, isstatus);
1466
1467     while (*format)
1468     {                           /* format can be an empty string */
1469         int found = 0;
1470
1471         darr = g_new0 (format_e, 1);
1472
1473         /* I'm so ugly, don't look at me :-) */
1474         if (!home)
1475             home = old = darr;
1476
1477         old->next = darr;
1478         darr->next = 0;
1479         old = darr;
1480
1481         format = skip_separators (format);
1482
1483         if (strchr ("<=>", *format))
1484         {
1485             set_justify = 1;
1486             switch (*format)
1487             {
1488             case '<':
1489                 justify = J_LEFT;
1490                 break;
1491             case '=':
1492                 justify = J_CENTER;
1493                 break;
1494             case '>':
1495             default:
1496                 justify = J_RIGHT;
1497                 break;
1498             }
1499             format = skip_separators (format + 1);
1500         }
1501         else
1502             set_justify = 0;
1503
1504         for (i = 0; panel_fields[i].id != NULL; i++)
1505         {
1506             size_t klen = strlen (panel_fields[i].id);
1507
1508             if (strncmp (format, panel_fields[i].id, klen) != 0)
1509                 continue;
1510
1511             format += klen;
1512
1513             darr->requested_field_len = panel_fields[i].min_size;
1514             darr->string_fn = panel_fields[i].string_fn;
1515             darr->title = panel_get_title_without_hotkey (panel_fields[i].title_hotkey);
1516
1517             darr->id = panel_fields[i].id;
1518             darr->expand = panel_fields[i].expands;
1519             darr->just_mode = panel_fields[i].default_just;
1520
1521             if (set_justify)
1522             {
1523                 if (IS_FIT (darr->just_mode))
1524                     darr->just_mode = MAKE_FIT (justify);
1525                 else
1526                     darr->just_mode = justify;
1527             }
1528             found = 1;
1529
1530             format = skip_separators (format);
1531
1532             /* If we have a size specifier */
1533             if (*format == ':')
1534             {
1535                 int req_length;
1536
1537                 /* If the size was specified, we don't want
1538                  * auto-expansion by default
1539                  */
1540                 darr->expand = 0;
1541                 format++;
1542                 req_length = atoi (format);
1543                 darr->requested_field_len = req_length;
1544
1545                 format = skip_numbers (format);
1546
1547                 /* Now, if they insist on expansion */
1548                 if (*format == '+')
1549                 {
1550                     darr->expand = 1;
1551                     format++;
1552                 }
1553
1554             }
1555
1556             break;
1557         }
1558         if (!found)
1559         {
1560             char *tmp_format = g_strdup (format);
1561
1562             int pos = min (8, strlen (format));
1563             delete_format (home);
1564             tmp_format[pos] = 0;
1565             *error =
1566                 g_strconcat (_("Unknown tag on display format:"), " ", tmp_format, (char *) NULL);
1567             g_free (tmp_format);
1568             return 0;
1569         }
1570         total_cols += darr->requested_field_len;
1571     }
1572
1573     *res_total_cols = total_cols;
1574     return home;
1575 }
1576
1577 /* --------------------------------------------------------------------------------------------- */
1578
1579 static format_e *
1580 use_display_format (WPanel * panel, const char *format, char **error, int isstatus)
1581 {
1582 #define MAX_EXPAND 4
1583     int expand_top = 0;         /* Max used element in expand */
1584     int usable_columns;         /* Usable columns in the panel */
1585     int total_cols = 0;
1586     int i;
1587     format_e *darr, *home;
1588
1589     if (!format)
1590         format = DEFAULT_USER_FORMAT;
1591
1592     home = parse_display_format (panel, format, error, isstatus, &total_cols);
1593
1594     if (*error)
1595         return 0;
1596
1597     panel->dirty = 1;
1598
1599     /* Status needn't to be split */
1600     usable_columns = ((panel->widget.cols - 2) / ((isstatus)
1601                                                   ? 1
1602                                                   : (panel->split + 1))) - (!isstatus
1603                                                                             && panel->split);
1604
1605     /* Look for the expandable fields and set field_len based on the requested field len */
1606     for (darr = home; darr && expand_top < MAX_EXPAND; darr = darr->next)
1607     {
1608         darr->field_len = darr->requested_field_len;
1609         if (darr->expand)
1610             expand_top++;
1611     }
1612
1613     /* If we used more columns than the available columns, adjust that */
1614     if (total_cols > usable_columns)
1615     {
1616         int pdif, dif = total_cols - usable_columns;
1617
1618         while (dif)
1619         {
1620             pdif = dif;
1621             for (darr = home; darr; darr = darr->next)
1622             {
1623                 if (dif && darr->field_len - 1)
1624                 {
1625                     darr->field_len--;
1626                     dif--;
1627                 }
1628             }
1629
1630             /* avoid endless loop if num fields > 40 */
1631             if (pdif == dif)
1632                 break;
1633         }
1634         total_cols = usable_columns;    /* give up, the rest should be truncated */
1635     }
1636
1637     /* Expand the available space */
1638     if ((usable_columns > total_cols) && expand_top)
1639     {
1640         int spaces = (usable_columns - total_cols) / expand_top;
1641         int extra = (usable_columns - total_cols) % expand_top;
1642
1643         for (i = 0, darr = home; darr && (i < expand_top); darr = darr->next)
1644             if (darr->expand)
1645             {
1646                 darr->field_len += (spaces + ((i == 0) ? extra : 0));
1647                 i++;
1648             }
1649     }
1650     return home;
1651 }
1652
1653 /* --------------------------------------------------------------------------------------------- */
1654 /** Given the panel->view_type returns the format string to be parsed */
1655
1656 static const char *
1657 panel_format (WPanel * panel)
1658 {
1659     switch (panel->list_type)
1660     {
1661     case list_long:
1662         return "full perm space nlink space owner space group space size space mtime space name";
1663
1664     case list_brief:
1665         return "half 2 type name";
1666
1667     case list_user:
1668         return panel->user_format;
1669
1670     default:
1671     case list_full:
1672         return "half type name | size | mtime";
1673     }
1674 }
1675
1676 /* --------------------------------------------------------------------------------------------- */
1677
1678 static const char *
1679 mini_status_format (WPanel * panel)
1680 {
1681     if (panel->user_mini_status)
1682         return panel->user_status_format[panel->list_type];
1683
1684     switch (panel->list_type)
1685     {
1686
1687     case list_long:
1688         return "full perm space nlink space owner space group space size space mtime space name";
1689
1690     case list_brief:
1691         return "half type name space bsize space perm space";
1692
1693     case list_full:
1694         return "half type name";
1695
1696     default:
1697     case list_user:
1698         return panel->user_format;
1699     }
1700 }
1701
1702 /*                          */
1703 /* Panel operation commands */
1704 /*                          */
1705
1706 /* --------------------------------------------------------------------------------------------- */
1707 /** Used to emulate Lynx's entering leaving a directory with the arrow keys */
1708
1709 static cb_ret_t
1710 maybe_cd (int move_up_dir)
1711 {
1712     if (panels_options.navigate_with_arrows && (cmdline->buffer[0] == '\0'))
1713     {
1714         if (move_up_dir)
1715         {
1716             do_cd ("..", cd_exact);
1717             return MSG_HANDLED;
1718         }
1719
1720         if (S_ISDIR (selection (current_panel)->st.st_mode)
1721             || link_isdir (selection (current_panel)))
1722         {
1723             do_cd (selection (current_panel)->fname, cd_exact);
1724             return MSG_HANDLED;
1725         }
1726     }
1727     return MSG_NOT_HANDLED;
1728 }
1729
1730 /* --------------------------------------------------------------------------------------------- */
1731
1732 /* if command line is empty then do 'cd ..' */
1733 static cb_ret_t
1734 force_maybe_cd (void)
1735 {
1736     if (cmdline->buffer[0] == '\0')
1737     {
1738         do_cd ("..", cd_exact);
1739         return MSG_HANDLED;
1740     }
1741     return MSG_NOT_HANDLED;
1742 }
1743
1744 /* --------------------------------------------------------------------------------------------- */
1745
1746 /* Returns the number of items in the given panel */
1747 static int
1748 ITEMS (WPanel * p)
1749 {
1750     if (p->split)
1751         return llines (p) * 2;
1752     else
1753         return llines (p);
1754 }
1755
1756 /* --------------------------------------------------------------------------------------------- */
1757
1758 static void
1759 unselect_item (WPanel * panel)
1760 {
1761     repaint_file (panel, panel->selected, 1, 2 * selection (panel)->f.marked, 0);
1762 }
1763
1764 /* --------------------------------------------------------------------------------------------- */
1765
1766 static void
1767 move_down (WPanel * panel)
1768 {
1769     if (panel->selected + 1 == panel->count)
1770         return;
1771
1772     unselect_item (panel);
1773     panel->selected++;
1774     if (panels_options.scroll_pages && panel->selected - panel->top_file == ITEMS (panel))
1775     {
1776         /* Scroll window half screen */
1777         panel->top_file += ITEMS (panel) / 2;
1778         if (panel->top_file > panel->count - ITEMS (panel))
1779             panel->top_file = panel->count - ITEMS (panel);
1780         paint_dir (panel);
1781     }
1782     select_item (panel);
1783 }
1784
1785 /* --------------------------------------------------------------------------------------------- */
1786
1787 static void
1788 move_up (WPanel * panel)
1789 {
1790     if (panel->selected == 0)
1791         return;
1792
1793     unselect_item (panel);
1794     panel->selected--;
1795     if (panels_options.scroll_pages && panel->selected < panel->top_file)
1796     {
1797         /* Scroll window half screen */
1798         panel->top_file -= ITEMS (panel) / 2;
1799         if (panel->top_file < 0)
1800             panel->top_file = 0;
1801         paint_dir (panel);
1802     }
1803     select_item (panel);
1804 }
1805
1806 /* --------------------------------------------------------------------------------------------- */
1807 /** Changes the selection by lines (may be negative) */
1808
1809 static void
1810 move_selection (WPanel * panel, int lines)
1811 {
1812     int new_pos;
1813     int adjust = 0;
1814
1815     new_pos = panel->selected + lines;
1816     if (new_pos >= panel->count)
1817         new_pos = panel->count - 1;
1818
1819     if (new_pos < 0)
1820         new_pos = 0;
1821
1822     unselect_item (panel);
1823     panel->selected = new_pos;
1824
1825     if (panel->selected - panel->top_file >= ITEMS (panel))
1826     {
1827         panel->top_file += lines;
1828         adjust = 1;
1829     }
1830
1831     if (panel->selected - panel->top_file < 0)
1832     {
1833         panel->top_file += lines;
1834         adjust = 1;
1835     }
1836
1837     if (adjust)
1838     {
1839         if (panel->top_file > panel->selected)
1840             panel->top_file = panel->selected;
1841         if (panel->top_file < 0)
1842             panel->top_file = 0;
1843         paint_dir (panel);
1844     }
1845     select_item (panel);
1846 }
1847
1848 /* --------------------------------------------------------------------------------------------- */
1849
1850 static cb_ret_t
1851 move_left (WPanel * panel)
1852 {
1853     if (panel->split)
1854     {
1855         move_selection (panel, -llines (panel));
1856         return MSG_HANDLED;
1857     }
1858     else
1859         return maybe_cd (1);    /* cd .. */
1860 }
1861
1862 /* --------------------------------------------------------------------------------------------- */
1863
1864 static cb_ret_t
1865 move_right (WPanel * panel)
1866 {
1867     if (panel->split)
1868     {
1869         move_selection (panel, llines (panel));
1870         return MSG_HANDLED;
1871     }
1872     else
1873         return maybe_cd (0);    /* cd (selection) */
1874 }
1875
1876 /* --------------------------------------------------------------------------------------------- */
1877
1878 static void
1879 prev_page (WPanel * panel)
1880 {
1881     int items;
1882
1883     if (!panel->selected && !panel->top_file)
1884         return;
1885     unselect_item (panel);
1886     items = ITEMS (panel);
1887     if (panel->top_file < items)
1888         items = panel->top_file;
1889     if (!items)
1890         panel->selected = 0;
1891     else
1892         panel->selected -= items;
1893     panel->top_file -= items;
1894
1895     select_item (panel);
1896     paint_dir (panel);
1897 }
1898
1899 /* --------------------------------------------------------------------------------------------- */
1900
1901 static void
1902 goto_parent_dir (WPanel * panel)
1903 {
1904     if (!panel->is_panelized)
1905         do_cd ("..", cd_exact);
1906     else
1907     {
1908         char *fname = panel->dir.list[panel->selected].fname;
1909         const char *bname;
1910         char *dname;
1911
1912         if (g_path_is_absolute (fname))
1913             fname = g_strdup (fname);
1914         else
1915             fname = mc_build_filename (panelized_panel.root, fname, (char *) NULL);
1916
1917         bname = x_basename (fname);
1918
1919         if (bname == fname)
1920             dname = g_strdup (".");
1921         else
1922             dname = g_strndup (fname, bname - fname);
1923
1924         do_cd (dname, cd_exact);
1925         try_to_select (panel, bname);
1926
1927         g_free (dname);
1928         g_free (fname);
1929     }
1930 }
1931
1932 /* --------------------------------------------------------------------------------------------- */
1933
1934 static void
1935 next_page (WPanel * panel)
1936 {
1937     int items;
1938
1939     if (panel->selected == panel->count - 1)
1940         return;
1941     unselect_item (panel);
1942     items = ITEMS (panel);
1943     if (panel->top_file > panel->count - 2 * items)
1944         items = panel->count - items - panel->top_file;
1945     if (panel->top_file + items < 0)
1946         items = -panel->top_file;
1947     if (!items)
1948         panel->selected = panel->count - 1;
1949     else
1950         panel->selected += items;
1951     panel->top_file += items;
1952
1953     select_item (panel);
1954     paint_dir (panel);
1955 }
1956
1957 /* --------------------------------------------------------------------------------------------- */
1958
1959 static void
1960 goto_child_dir (WPanel * panel)
1961 {
1962     if ((S_ISDIR (selection (panel)->st.st_mode) || link_isdir (selection (panel))))
1963     {
1964         do_cd (selection (panel)->fname, cd_exact);
1965     }
1966 }
1967
1968 /* --------------------------------------------------------------------------------------------- */
1969
1970 static void
1971 goto_top_file (WPanel * panel)
1972 {
1973     unselect_item (panel);
1974     panel->selected = panel->top_file;
1975     select_item (panel);
1976 }
1977
1978 /* --------------------------------------------------------------------------------------------- */
1979
1980 static void
1981 goto_middle_file (WPanel * panel)
1982 {
1983     unselect_item (panel);
1984     panel->selected = panel->top_file + (ITEMS (panel) / 2);
1985     select_item (panel);
1986 }
1987
1988 /* --------------------------------------------------------------------------------------------- */
1989
1990 static void
1991 goto_bottom_file (WPanel * panel)
1992 {
1993     unselect_item (panel);
1994     panel->selected = panel->top_file + ITEMS (panel) - 1;
1995     select_item (panel);
1996 }
1997
1998 /* --------------------------------------------------------------------------------------------- */
1999
2000 static void
2001 move_home (WPanel * panel)
2002 {
2003     if (panel->selected == 0)
2004         return;
2005
2006     unselect_item (panel);
2007
2008     if (panels_options.torben_fj_mode)
2009     {
2010         int middle_pos = panel->top_file + (ITEMS (panel) / 2);
2011
2012         if (panel->selected > middle_pos)
2013         {
2014             goto_middle_file (panel);
2015             return;
2016         }
2017         if (panel->selected != panel->top_file)
2018         {
2019             goto_top_file (panel);
2020             return;
2021         }
2022     }
2023
2024     panel->top_file = 0;
2025     panel->selected = 0;
2026
2027     paint_dir (panel);
2028     select_item (panel);
2029 }
2030
2031 /* --------------------------------------------------------------------------------------------- */
2032
2033 static void
2034 move_end (WPanel * panel)
2035 {
2036     if (panel->selected == panel->count - 1)
2037         return;
2038
2039     unselect_item (panel);
2040
2041     if (panels_options.torben_fj_mode)
2042     {
2043         int middle_pos = panel->top_file + (ITEMS (panel) / 2);
2044
2045         if (panel->selected < middle_pos)
2046         {
2047             goto_middle_file (panel);
2048             return;
2049         }
2050         if (panel->selected != (panel->top_file + ITEMS (panel) - 1))
2051         {
2052             goto_bottom_file (panel);
2053             return;
2054         }
2055     }
2056
2057     panel->selected = panel->count - 1;
2058     paint_dir (panel);
2059     select_item (panel);
2060 }
2061
2062 /* --------------------------------------------------------------------------------------------- */
2063
2064 static void
2065 do_mark_file (WPanel * panel, mark_act_t do_move)
2066 {
2067     do_file_mark (panel, panel->selected, selection (panel)->f.marked ? 0 : 1);
2068     if ((panels_options.mark_moves_down && do_move == MARK_DOWN) || do_move == MARK_FORCE_DOWN)
2069         move_down (panel);
2070     else if (do_move == MARK_FORCE_UP)
2071         move_up (panel);
2072 }
2073
2074 /* --------------------------------------------------------------------------------------------- */
2075
2076 static void
2077 mark_file (WPanel * panel)
2078 {
2079     do_mark_file (panel, MARK_DOWN);
2080 }
2081
2082 /* --------------------------------------------------------------------------------------------- */
2083
2084 static void
2085 mark_file_up (WPanel * panel)
2086 {
2087     do_mark_file (panel, MARK_FORCE_UP);
2088 }
2089
2090 /* --------------------------------------------------------------------------------------------- */
2091
2092 static void
2093 mark_file_down (WPanel * panel)
2094 {
2095     do_mark_file (panel, MARK_FORCE_DOWN);
2096 }
2097
2098 /* --------------------------------------------------------------------------------------------- */
2099
2100 static void
2101 mark_file_right (WPanel * panel)
2102 {
2103     int lines = llines (panel);
2104
2105     if (state_mark < 0)
2106         state_mark = selection (panel)->f.marked ? 0 : 1;
2107
2108     lines = min (lines, panel->count - panel->selected - 1);
2109     for (; lines != 0; lines--)
2110     {
2111         do_file_mark (panel, panel->selected, state_mark);
2112         move_down (panel);
2113     }
2114     do_file_mark (panel, panel->selected, state_mark);
2115 }
2116
2117 /* --------------------------------------------------------------------------------------------- */
2118
2119 static void
2120 mark_file_left (WPanel * panel)
2121 {
2122     int lines = llines (panel);
2123
2124     if (state_mark < 0)
2125         state_mark = selection (panel)->f.marked ? 0 : 1;
2126
2127     lines = min (lines, panel->selected + 1);
2128     for (; lines != 0; lines--)
2129     {
2130         do_file_mark (panel, panel->selected, state_mark);
2131         move_up (panel);
2132     }
2133     do_file_mark (panel, panel->selected, state_mark);
2134 }
2135
2136 /* --------------------------------------------------------------------------------------------- */
2137 /** Incremental search of a file name in the panel.
2138   * @param panel instance of WPanel structure
2139   * @param c_code key code
2140   */
2141
2142 static void
2143 do_search (WPanel * panel, int c_code)
2144 {
2145     size_t l;
2146     int i, sel;
2147     gboolean wrapped = FALSE;
2148     char *act;
2149     mc_search_t *search;
2150     char *reg_exp, *esc_str;
2151     gboolean is_found = FALSE;
2152
2153     l = strlen (panel->search_buffer);
2154     if (c_code == KEY_BACKSPACE)
2155     {
2156         if (l != 0)
2157         {
2158             act = panel->search_buffer + l;
2159             str_prev_noncomb_char (&act, panel->search_buffer);
2160             act[0] = '\0';
2161         }
2162         panel->search_chpoint = 0;
2163     }
2164     else
2165     {
2166         if (c_code != 0 && (gsize) panel->search_chpoint < sizeof (panel->search_char))
2167         {
2168             panel->search_char[panel->search_chpoint] = c_code;
2169             panel->search_chpoint++;
2170         }
2171
2172         if (panel->search_chpoint > 0)
2173         {
2174             switch (str_is_valid_char (panel->search_char, panel->search_chpoint))
2175             {
2176             case -2:
2177                 return;
2178             case -1:
2179                 panel->search_chpoint = 0;
2180                 return;
2181             default:
2182                 if (l + panel->search_chpoint < sizeof (panel->search_buffer))
2183                 {
2184                     memcpy (panel->search_buffer + l, panel->search_char, panel->search_chpoint);
2185                     l += panel->search_chpoint;
2186                     *(panel->search_buffer + l) = '\0';
2187                     panel->search_chpoint = 0;
2188                 }
2189             }
2190         }
2191     }
2192
2193     reg_exp = g_strdup_printf ("%s*", panel->search_buffer);
2194     esc_str = strutils_escape (reg_exp, -1, ",|\\{}[]", TRUE);
2195     search = mc_search_new (esc_str, -1);
2196     search->search_type = MC_SEARCH_T_GLOB;
2197     search->is_entire_line = TRUE;
2198     switch (panels_options.qsearch_mode)
2199     {
2200     case QSEARCH_CASE_SENSITIVE:
2201         search->is_case_sensitive = TRUE;
2202         break;
2203     case QSEARCH_CASE_INSENSITIVE:
2204         search->is_case_sensitive = FALSE;
2205         break;
2206     default:
2207         search->is_case_sensitive = panel->sort_info.case_sensitive;
2208         break;
2209     }
2210     sel = panel->selected;
2211     for (i = panel->selected; !wrapped || i != panel->selected; i++)
2212     {
2213         if (i >= panel->count)
2214         {
2215             i = 0;
2216             if (wrapped)
2217                 break;
2218             wrapped = TRUE;
2219         }
2220         if (mc_search_run (search, panel->dir.list[i].fname, 0, panel->dir.list[i].fnamelen, NULL))
2221         {
2222             sel = i;
2223             is_found = TRUE;
2224             break;
2225         }
2226     }
2227     if (is_found)
2228     {
2229         unselect_item (panel);
2230         panel->selected = sel;
2231         select_item (panel);
2232         send_message ((Widget *) panel, WIDGET_DRAW, 0);
2233     }
2234     else if (c_code != KEY_BACKSPACE)
2235     {
2236         act = panel->search_buffer + l;
2237         str_prev_noncomb_char (&act, panel->search_buffer);
2238         act[0] = '\0';
2239     }
2240     mc_search_free (search);
2241     g_free (reg_exp);
2242     g_free (esc_str);
2243 }
2244
2245 /* --------------------------------------------------------------------------------------------- */
2246 /** Start new search.
2247   * @param panel instance of WPanel structure
2248   */
2249
2250 static void
2251 start_search (WPanel * panel)
2252 {
2253     if (panel->searching)
2254     {
2255         if (panel->selected + 1 == panel->count)
2256             panel->selected = 0;
2257         else
2258             move_down (panel);
2259
2260         /* in case if there was no search string we need to recall
2261            previous string, with which we ended previous searching */
2262         if (panel->search_buffer[0] == '\0')
2263             g_strlcpy (panel->search_buffer, panel->prev_search_buffer,
2264                        sizeof (panel->search_buffer));
2265
2266         do_search (panel, 0);
2267     }
2268     else
2269     {
2270         panel->searching = TRUE;
2271         panel->search_buffer[0] = '\0';
2272         panel->search_char[0] = '\0';
2273         panel->search_chpoint = 0;
2274         display_mini_info (panel);
2275         mc_refresh ();
2276     }
2277 }
2278
2279 /* --------------------------------------------------------------------------------------------- */
2280
2281 static void
2282 stop_search (WPanel * panel)
2283 {
2284     panel->searching = FALSE;
2285
2286     /* if user had overrdied search string, we need to store it
2287        to the previous_search_buffer */
2288     if (panel->search_buffer[0] != '\0')
2289         g_strlcpy (panel->prev_search_buffer, panel->search_buffer,
2290                    sizeof (panel->prev_search_buffer));
2291
2292     display_mini_info (panel);
2293 }
2294
2295 /* --------------------------------------------------------------------------------------------- */
2296 /** Return 1 if the Enter key has been processed, 0 otherwise */
2297
2298 static int
2299 do_enter_on_file_entry (file_entry * fe)
2300 {
2301     char *full_name;
2302
2303     /*
2304      * Directory or link to directory - change directory.
2305      * Try the same for the entries on which mc_lstat() has failed.
2306      */
2307     if (S_ISDIR (fe->st.st_mode) || link_isdir (fe) || (fe->st.st_mode == 0))
2308     {
2309         if (!do_cd (fe->fname, cd_exact))
2310             message (D_ERROR, MSG_ERROR, _("Cannot change directory"));
2311         return 1;
2312     }
2313
2314     /* Try associated command */
2315     if (regex_command (fe->fname, "Open", NULL) != 0)
2316         return 1;
2317
2318     /* Check if the file is executable */
2319     full_name = concat_dir_and_file (current_panel->cwd, fe->fname);
2320     if (!is_exe (fe->st.st_mode) || !if_link_is_exe (full_name, fe))
2321     {
2322         g_free (full_name);
2323         return 0;
2324     }
2325     g_free (full_name);
2326
2327     if (confirm_execute)
2328     {
2329         if (query_dialog
2330             (_("The Midnight Commander"),
2331              _("Do you really want to execute?"), D_NORMAL, 2, _("&Yes"), _("&No")) != 0)
2332             return 1;
2333     }
2334
2335     if (!vfs_current_is_local ())
2336     {
2337         char *tmp, *tmp_curr_dir;
2338         int ret;
2339
2340         tmp_curr_dir = vfs_get_current_dir ();
2341         tmp = concat_dir_and_file (tmp_curr_dir, fe->fname);
2342         g_free (tmp_curr_dir);
2343         ret = mc_setctl (tmp, VFS_SETCTL_RUN, NULL);
2344         g_free (tmp);
2345         /* We took action only if the dialog was shown or the execution
2346          * was successful */
2347         return confirm_execute || (ret == 0);
2348     }
2349
2350     {
2351         char *tmp = name_quote (fe->fname, 0);
2352         char *cmd = g_strconcat (".", PATH_SEP_STR, tmp, (char *) NULL);
2353         g_free (tmp);
2354         shell_execute (cmd, 0);
2355         g_free (cmd);
2356     }
2357
2358 #if HAVE_CHARSET
2359     mc_global.source_codepage = default_source_codepage;
2360 #endif
2361
2362     return 1;
2363 }
2364
2365 /* --------------------------------------------------------------------------------------------- */
2366
2367 static int
2368 do_enter (WPanel * panel)
2369 {
2370     return do_enter_on_file_entry (selection (panel));
2371 }
2372
2373 /* --------------------------------------------------------------------------------------------- */
2374
2375 static void
2376 chdir_other_panel (WPanel * panel)
2377 {
2378     const file_entry *entry = &panel->dir.list[panel->selected];
2379
2380     char *new_dir;
2381     char *sel_entry = NULL;
2382
2383     if (get_other_type () != view_listing)
2384     {
2385         set_display_type (get_other_index (), view_listing);
2386     }
2387
2388     if (S_ISDIR (entry->st.st_mode) || entry->f.link_to_dir)
2389         new_dir = mc_build_filename (panel->cwd, entry->fname, (char *) NULL);
2390     else
2391     {
2392         new_dir = mc_build_filename (panel->cwd, "..", (char *) NULL);
2393         sel_entry = strrchr (panel->cwd, PATH_SEP);
2394     }
2395
2396     change_panel ();
2397     do_cd (new_dir, cd_exact);
2398     if (sel_entry)
2399         try_to_select (current_panel, sel_entry);
2400     change_panel ();
2401
2402     move_down (panel);
2403
2404     g_free (new_dir);
2405 }
2406
2407 /* --------------------------------------------------------------------------------------------- */
2408 /**
2409  * Make the current directory of the current panel also the current
2410  * directory of the other panel.  Put the other panel to the listing
2411  * mode if needed.  If the current panel is panelized, the other panel
2412  * doesn't become panelized.
2413  */
2414
2415 static void
2416 panel_sync_other (const WPanel * panel)
2417 {
2418     if (get_other_type () != view_listing)
2419     {
2420         set_display_type (get_other_index (), view_listing);
2421     }
2422
2423     do_panel_cd (other_panel, current_panel->cwd, cd_exact);
2424
2425     /* try to select current filename on the other panel */
2426     if (!panel->is_panelized)
2427     {
2428         try_to_select (other_panel, selection (panel)->fname);
2429     }
2430 }
2431
2432 /* --------------------------------------------------------------------------------------------- */
2433
2434 static void
2435 chdir_to_readlink (WPanel * panel)
2436 {
2437     char *new_dir;
2438
2439     if (get_other_type () != view_listing)
2440         return;
2441
2442     if (S_ISLNK (panel->dir.list[panel->selected].st.st_mode))
2443     {
2444         char buffer[MC_MAXPATHLEN], *p;
2445         int i;
2446         struct stat st;
2447
2448         i = readlink (selection (panel)->fname, buffer, MC_MAXPATHLEN - 1);
2449         if (i < 0)
2450             return;
2451         if (mc_stat (selection (panel)->fname, &st) < 0)
2452             return;
2453         buffer[i] = 0;
2454         if (!S_ISDIR (st.st_mode))
2455         {
2456             p = strrchr (buffer, PATH_SEP);
2457             if (p && !p[1])
2458             {
2459                 *p = 0;
2460                 p = strrchr (buffer, PATH_SEP);
2461             }
2462             if (!p)
2463                 return;
2464             p[1] = 0;
2465         }
2466         if (*buffer == PATH_SEP)
2467             new_dir = g_strdup (buffer);
2468         else
2469             new_dir = concat_dir_and_file (panel->cwd, buffer);
2470
2471         change_panel ();
2472         do_cd (new_dir, cd_exact);
2473         change_panel ();
2474
2475         move_down (panel);
2476
2477         g_free (new_dir);
2478     }
2479 }
2480
2481 /* --------------------------------------------------------------------------------------------- */
2482
2483 static gsize
2484 panel_get_format_field_count (WPanel * panel)
2485 {
2486     format_e *format;
2487     gsize lc_index;
2488     for (lc_index = 0, format = panel->format; format != NULL; format = format->next, lc_index++);
2489     return lc_index;
2490 }
2491
2492 /* --------------------------------------------------------------------------------------------- */
2493 /**
2494    function return 0 if not found and REAL_INDEX+1 if found
2495  */
2496
2497 static gsize
2498 panel_get_format_field_index_by_name (WPanel * panel, const char *name)
2499 {
2500     format_e *format;
2501     gsize lc_index;
2502
2503     for (lc_index = 1, format = panel->format;
2504          !(format == NULL || strcmp (format->title, name) == 0); format = format->next, lc_index++);
2505     if (format == NULL)
2506         lc_index = 0;
2507
2508     return lc_index;
2509 }
2510
2511 /* --------------------------------------------------------------------------------------------- */
2512
2513 static format_e *
2514 panel_get_format_field_by_index (WPanel * panel, gsize lc_index)
2515 {
2516     format_e *format;
2517     for (format = panel->format;
2518          !(format == NULL || lc_index == 0); format = format->next, lc_index--);
2519     return format;
2520 }
2521
2522 /* --------------------------------------------------------------------------------------------- */
2523
2524 static const panel_field_t *
2525 panel_get_sortable_field_by_format (WPanel * panel, gsize lc_index)
2526 {
2527     const panel_field_t *pfield;
2528     format_e *format;
2529
2530     format = panel_get_format_field_by_index (panel, lc_index);
2531     if (format == NULL)
2532         return NULL;
2533     pfield = panel_get_field_by_title (format->title);
2534     if (pfield == NULL)
2535         return NULL;
2536     if (pfield->sort_routine == NULL)
2537         return NULL;
2538     return pfield;
2539 }
2540
2541 /* --------------------------------------------------------------------------------------------- */
2542
2543 static void
2544 panel_toggle_sort_order_prev (WPanel * panel)
2545 {
2546     gsize lc_index, i;
2547     gchar *title;
2548
2549     const panel_field_t *pfield = NULL;
2550
2551     title = panel_get_title_without_hotkey (panel->sort_info.sort_field->title_hotkey);
2552     lc_index = panel_get_format_field_index_by_name (panel, title);
2553     g_free (title);
2554
2555     if (lc_index > 1)
2556     {
2557         /* search for prev sortable column in panel format */
2558         for (i = lc_index - 1;
2559              i != 0 && (pfield = panel_get_sortable_field_by_format (panel, i - 1)) == NULL; i--);
2560     }
2561
2562     if (pfield == NULL)
2563     {
2564         /* Sortable field not found. Try to search in each array */
2565         for (i = panel_get_format_field_count (panel);
2566              i != 0 && (pfield = panel_get_sortable_field_by_format (panel, i - 1)) == NULL; i--);
2567     }
2568
2569     if (pfield != NULL)
2570     {
2571         panel->sort_info.sort_field = pfield;
2572         panel_set_sort_order (panel, pfield);
2573     }
2574 }
2575
2576 /* --------------------------------------------------------------------------------------------- */
2577
2578 static void
2579 panel_toggle_sort_order_next (WPanel * panel)
2580 {
2581     gsize lc_index, i;
2582     const panel_field_t *pfield = NULL;
2583     gsize format_field_count;
2584     gchar *title;
2585
2586     format_field_count = panel_get_format_field_count (panel);
2587     title = panel_get_title_without_hotkey (panel->sort_info.sort_field->title_hotkey);
2588     lc_index = panel_get_format_field_index_by_name (panel, title);
2589     g_free (title);
2590
2591     if (lc_index != 0 && lc_index != format_field_count)
2592     {
2593         /* search for prev sortable column in panel format */
2594         for (i = lc_index;
2595              i != format_field_count
2596              && (pfield = panel_get_sortable_field_by_format (panel, i)) == NULL; i++);
2597     }
2598
2599     if (pfield == NULL)
2600     {
2601         /* Sortable field not found. Try to search in each array */
2602         for (i = 0;
2603              i != format_field_count
2604              && (pfield = panel_get_sortable_field_by_format (panel, i)) == NULL; i++);
2605     }
2606
2607     if (pfield != NULL)
2608     {
2609         panel->sort_info.sort_field = pfield;
2610         panel_set_sort_order (panel, pfield);
2611     }
2612 }
2613
2614 /* --------------------------------------------------------------------------------------------- */
2615
2616 static void
2617 panel_select_sort_order (WPanel * panel)
2618 {
2619     const panel_field_t *sort_order;
2620
2621     sort_order = sort_box (&panel->sort_info);
2622     if (sort_order != NULL)
2623     {
2624         panel->sort_info.sort_field = sort_order;
2625         panel_set_sort_order (panel, sort_order);
2626     }
2627 }
2628
2629 /* --------------------------------------------------------------------------------------------- */
2630
2631 static void
2632 panel_set_sort_type_by_id (WPanel * panel, const char *name)
2633 {
2634     if (strcmp (panel->sort_info.sort_field->id, name) != 0)
2635     {
2636         const panel_field_t *sort_order;
2637
2638         sort_order = panel_get_field_by_id (name);
2639         if (sort_order == NULL)
2640             return;
2641         panel->sort_info.sort_field = sort_order;
2642     }
2643     else
2644         panel->sort_info.reverse = !panel->sort_info.reverse;
2645
2646     panel_set_sort_order (panel, panel->sort_info.sort_field);
2647 }
2648
2649 /* --------------------------------------------------------------------------------------------- */
2650 /**
2651  *  If we moved to the parent directory move the selection pointer to
2652  *  the old directory name; If we leave VFS dir, remove FS specificator.
2653  *
2654  *  You do _NOT_ want to add any vfs aware code here. <pavel@ucw.cz>
2655  */
2656
2657 static const char *
2658 get_parent_dir_name (const char *cwd, const char *lwd)
2659 {
2660     size_t llen, clen;
2661     const char *p;
2662
2663     llen = strlen (lwd);
2664     clen = strlen (cwd);
2665
2666     if (llen <= clen)
2667         return NULL;
2668
2669     p = g_strrstr (lwd, VFS_PATH_URL_DELIMITER);
2670
2671     if (p == NULL)
2672     {
2673         p = strrchr (lwd, PATH_SEP);
2674
2675         if ((p != NULL)
2676             && (strncmp (cwd, lwd, (size_t) (p - lwd)) == 0)
2677             && (clen == (size_t) (p - lwd)
2678                 || ((p == lwd) && (cwd[0] == PATH_SEP) && (cwd[1] == '\0'))))
2679             return (p + 1);
2680
2681         return NULL;
2682     }
2683
2684     while (--p > lwd && *p != PATH_SEP);
2685     while (--p > lwd && *p != PATH_SEP);
2686
2687     return (p != lwd) ? p + 1 : NULL;
2688 }
2689
2690 /* --------------------------------------------------------------------------------------------- */
2691 /** Wrapper for do_subshell_chdir, check for availability of subshell */
2692
2693 static void
2694 subshell_chdir (const char *directory)
2695 {
2696 #ifdef HAVE_SUBSHELL_SUPPORT
2697     if (mc_global.tty.use_subshell && vfs_current_is_local ())
2698         do_subshell_chdir (directory, FALSE, TRUE);
2699 #endif /* HAVE_SUBSHELL_SUPPORT */
2700 }
2701
2702 /* --------------------------------------------------------------------------------------------- */
2703 /**
2704  * Changes the current directory of the panel.
2705  * Don't record change in the directory history.
2706  */
2707
2708 static gboolean
2709 _do_panel_cd (WPanel * panel, const char *new_dir, enum cd_enum cd_type)
2710 {
2711     const char *directory;
2712     char *olddir;
2713     char temp[MC_MAXPATHLEN];
2714
2715     if (cd_type == cd_parse_command)
2716     {
2717         while (*new_dir == ' ')
2718             new_dir++;
2719     }
2720
2721     olddir = g_strdup (panel->cwd);
2722
2723     /* Convert *new_path to a suitable pathname, handle ~user */
2724
2725     if (cd_type == cd_parse_command)
2726     {
2727         if (!strcmp (new_dir, "-"))
2728         {
2729             strcpy (temp, panel->lwd);
2730             new_dir = temp;
2731         }
2732     }
2733     directory = *new_dir ? new_dir : mc_config_get_home_dir ();
2734
2735     if (mc_chdir (directory) == -1)
2736     {
2737         strcpy (panel->cwd, olddir);
2738         g_free (olddir);
2739         return FALSE;
2740     }
2741
2742     /* Success: save previous directory, shutdown status of previous dir */
2743     strcpy (panel->lwd, olddir);
2744     input_free_completions (cmdline);
2745
2746     mc_get_current_wd (panel->cwd, sizeof (panel->cwd) - 2);
2747
2748     vfs_release_path (olddir);
2749
2750     subshell_chdir (panel->cwd);
2751
2752     /* Reload current panel */
2753     panel_clean_dir (panel);
2754     panel->count =
2755         do_load_dir (panel->cwd, &panel->dir, panel->sort_info.sort_field->sort_routine,
2756                      panel->sort_info.reverse, panel->sort_info.case_sensitive,
2757                      panel->sort_info.exec_first, panel->filter);
2758     try_to_select (panel, get_parent_dir_name (panel->cwd, olddir));
2759     load_hint (0);
2760     panel->dirty = 1;
2761     update_xterm_title_path ();
2762
2763     g_free (olddir);
2764
2765     return TRUE;
2766 }
2767
2768 /* --------------------------------------------------------------------------------------------- */
2769
2770 static void
2771 directory_history_next (WPanel * panel)
2772 {
2773     GList *nextdir;
2774
2775     nextdir = g_list_next (panel->dir_history);
2776
2777     if ((nextdir != NULL) && (_do_panel_cd (panel, (char *) nextdir->data, cd_exact)))
2778         panel->dir_history = nextdir;
2779 }
2780
2781 /* --------------------------------------------------------------------------------------------- */
2782
2783 static void
2784 directory_history_prev (WPanel * panel)
2785 {
2786     GList *prevdir;
2787
2788     prevdir = g_list_previous (panel->dir_history);
2789
2790     if ((prevdir != NULL) && (_do_panel_cd (panel, (char *) prevdir->data, cd_exact)))
2791         panel->dir_history = prevdir;
2792 }
2793
2794 /* --------------------------------------------------------------------------------------------- */
2795
2796 static void
2797 directory_history_list (WPanel * panel)
2798 {
2799     char *s;
2800
2801     s = history_show (&panel->dir_history, &panel->widget);
2802
2803     if (s != NULL)
2804     {
2805         if (_do_panel_cd (panel, s, cd_exact))
2806             directory_history_add (panel, panel->cwd);
2807         else
2808             message (D_ERROR, MSG_ERROR, _("Cannot change directory"));
2809         g_free (s);
2810     }
2811 }
2812
2813 /* --------------------------------------------------------------------------------------------- */
2814
2815 static cb_ret_t
2816 panel_execute_cmd (WPanel * panel, unsigned long command)
2817 {
2818     int res = MSG_HANDLED;
2819
2820     if (command != CK_Search)
2821         stop_search (panel);
2822
2823
2824     switch (command)
2825     {
2826     case CK_Up:
2827     case CK_Down:
2828     case CK_Left:
2829     case CK_Right:
2830     case CK_Bottom:
2831     case CK_Top:
2832     case CK_PageDown:
2833     case CK_PageUp:
2834         /* reset state of marks flag */
2835         state_mark = -1;
2836         break;
2837     }
2838     switch (command)
2839     {
2840     case CK_PanelOtherCd:
2841         chdir_other_panel (panel);
2842         break;
2843     case CK_PanelOtherCdLink:
2844         chdir_to_readlink (panel);
2845         break;
2846     case CK_CopySingle:
2847         copy_cmd_local ();
2848         break;
2849     case CK_DeleteSingle:
2850         delete_cmd_local ();
2851         break;
2852     case CK_Enter:
2853         do_enter (panel);
2854         break;
2855     case CK_ViewRaw:
2856         view_raw_cmd ();
2857         break;
2858     case CK_EditNew:
2859         edit_cmd_new ();
2860         break;
2861     case CK_MoveSingle:
2862         rename_cmd_local ();
2863         break;
2864     case CK_SelectInvert:
2865         select_invert_cmd ();
2866         break;
2867     case CK_Select:
2868         select_cmd ();
2869         break;
2870     case CK_Unselect:
2871         unselect_cmd ();
2872         break;
2873     case CK_PageDown:
2874         next_page (panel);
2875         break;
2876     case CK_PageUp:
2877         prev_page (panel);
2878         break;
2879     case CK_CdChild:
2880         goto_child_dir (panel);
2881         break;
2882     case CK_CdParent:
2883         goto_parent_dir (panel);
2884         break;
2885     case CK_History:
2886         directory_history_list (panel);
2887         break;
2888     case CK_HistoryNext:
2889         directory_history_next (panel);
2890         break;
2891     case CK_HistoryPrev:
2892         directory_history_prev (panel);
2893         break;
2894     case CK_BottomOnScreen:
2895         goto_bottom_file (panel);
2896         break;
2897     case CK_MiddleOnScreen:
2898         goto_middle_file (panel);
2899         break;
2900     case CK_TopOnScreen:
2901         goto_top_file (panel);
2902         break;
2903     case CK_Mark:
2904         mark_file (panel);
2905         break;
2906     case CK_MarkUp:
2907         mark_file_up (panel);
2908         break;
2909     case CK_MarkDown:
2910         mark_file_down (panel);
2911         break;
2912     case CK_MarkLeft:
2913         mark_file_left (panel);
2914         break;
2915     case CK_MarkRight:
2916         mark_file_right (panel);
2917         break;
2918     case CK_CdParentSmart:
2919         res = force_maybe_cd ();
2920         break;
2921     case CK_Up:
2922         move_up (panel);
2923         break;
2924     case CK_Down:
2925         move_down (panel);
2926         break;
2927     case CK_Left:
2928         res = move_left (panel);
2929         break;
2930     case CK_Right:
2931         res = move_right (panel);
2932         break;
2933     case CK_Bottom:
2934         move_end (panel);
2935         break;
2936     case CK_Top:
2937         move_home (panel);
2938         break;
2939 #ifdef HAVE_CHARSET
2940     case CK_SelectCodepage:
2941         panel_change_encoding (panel);
2942         break;
2943 #endif
2944     case CK_Search:
2945         start_search (panel);
2946         break;
2947     case CK_SearchStop:
2948         break;
2949     case CK_PanelOtherSync:
2950         panel_sync_other (panel);
2951         break;
2952     case CK_Sort:
2953         panel_select_sort_order (panel);
2954         break;
2955     case CK_SortPrev:
2956         panel_toggle_sort_order_prev (panel);
2957         break;
2958     case CK_SortNext:
2959         panel_toggle_sort_order_next (panel);
2960         break;
2961     case CK_SortReverse:
2962         panel->sort_info.reverse = !panel->sort_info.reverse;
2963         panel_set_sort_order (panel, panel->sort_info.sort_field);
2964         break;
2965     case CK_SortByName:
2966         panel_set_sort_type_by_id (panel, "name");
2967         break;
2968     case CK_SortByExt:
2969         panel_set_sort_type_by_id (panel, "extension");
2970         break;
2971     case CK_SortBySize:
2972         panel_set_sort_type_by_id (panel, "size");
2973         break;
2974     case CK_SortByMTime:
2975         panel_set_sort_type_by_id (panel, "mtime");
2976         break;
2977     }
2978     return res;
2979 }
2980
2981 /* --------------------------------------------------------------------------------------------- */
2982
2983 static cb_ret_t
2984 panel_key (WPanel * panel, int key)
2985 {
2986     size_t i;
2987
2988     if (is_abort_char (key))
2989     {
2990         stop_search (panel);
2991         return MSG_HANDLED;
2992     }
2993
2994     if (panel->searching && ((key >= ' ' && key <= 255) || key == KEY_BACKSPACE))
2995     {
2996         do_search (panel, key);
2997         return MSG_HANDLED;
2998     }
2999
3000     for (i = 0; panel_map[i].key != 0; i++)
3001         if (key == panel_map[i].key)
3002             return panel_execute_cmd (panel, panel_map[i].command);
3003
3004     if (panels_options.torben_fj_mode && key == ALT ('h'))
3005     {
3006         goto_middle_file (panel);
3007         return MSG_HANDLED;
3008     }
3009
3010     if (!command_prompt && ((key >= ' ' && key <= 255) || key == KEY_BACKSPACE))
3011     {
3012         start_search (panel);
3013         do_search (panel, key);
3014         return MSG_HANDLED;
3015     }
3016
3017     return MSG_NOT_HANDLED;
3018 }
3019
3020 /* --------------------------------------------------------------------------------------------- */
3021
3022 static cb_ret_t
3023 panel_callback (Widget * w, widget_msg_t msg, int parm)
3024 {
3025     WPanel *panel = (WPanel *) w;
3026     WButtonBar *bb;
3027
3028     switch (msg)
3029     {
3030     case WIDGET_INIT:
3031         /* subscribe to "history_load" event */
3032         mc_event_add (w->owner->event_group, MCEVENT_HISTORY_LOAD, panel_load_history, w, NULL);
3033         /* subscribe to "history_save" event */
3034         mc_event_add (w->owner->event_group, MCEVENT_HISTORY_SAVE, panel_save_history, w, NULL);
3035         return MSG_HANDLED;
3036
3037     case WIDGET_DRAW:
3038         /* Repaint everything, including frame and separator */
3039         paint_frame (panel);    /* including show_dir */
3040         paint_dir (panel);
3041         mini_info_separator (panel);
3042         display_mini_info (panel);
3043         panel->dirty = 0;
3044         return MSG_HANDLED;
3045
3046     case WIDGET_FOCUS:
3047         state_mark = -1;
3048         current_panel = panel;
3049         panel->active = 1;
3050         if (mc_chdir (panel->cwd) != 0)
3051         {
3052             char *cwd = strip_password (g_strdup (panel->cwd), 1);
3053             message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\"\n%s"),
3054                      cwd, unix_error_string (errno));
3055             g_free (cwd);
3056         }
3057         else
3058             subshell_chdir (panel->cwd);
3059
3060         update_xterm_title_path ();
3061         select_item (panel);
3062         show_dir (panel);
3063         paint_dir (panel);
3064         panel->dirty = 0;
3065
3066         bb = find_buttonbar (panel->widget.owner);
3067         midnight_set_buttonbar (bb);
3068         buttonbar_redraw (bb);
3069         return MSG_HANDLED;
3070
3071     case WIDGET_UNFOCUS:
3072         /* Janne: look at this for the multiple panel options */
3073         stop_search (panel);
3074         panel->active = 0;
3075         show_dir (panel);
3076         unselect_item (panel);
3077         return MSG_HANDLED;
3078
3079     case WIDGET_KEY:
3080         return panel_key (panel, parm);
3081
3082     case WIDGET_COMMAND:
3083         return panel_execute_cmd (panel, parm);
3084
3085     case WIDGET_DESTROY:
3086         /* unsubscribe from "history_load" event */
3087         mc_event_del (w->owner->event_group, MCEVENT_HISTORY_LOAD, panel_load_history, w);
3088         /* unsubscribe from "history_save" event */
3089         mc_event_del (w->owner->event_group, MCEVENT_HISTORY_SAVE, panel_save_history, w);
3090         panel_destroy (panel);
3091         free_my_statfs ();
3092         return MSG_HANDLED;
3093
3094     default:
3095         return default_proc (msg, parm);
3096     }
3097 }
3098
3099 /* --------------------------------------------------------------------------------------------- */
3100 /*                                     */
3101 /* Panel mouse events support routines */
3102 /*                                     */
3103
3104 static void
3105 mouse_toggle_mark (WPanel * panel)
3106 {
3107     do_mark_file (panel, MARK_DONT_MOVE);
3108     mouse_marking = selection (panel)->f.marked;
3109     mouse_mark_panel = current_panel;
3110 }
3111
3112 /* --------------------------------------------------------------------------------------------- */
3113
3114 static void
3115 mouse_set_mark (WPanel * panel)
3116 {
3117
3118     if (mouse_mark_panel == panel)
3119     {
3120         if (mouse_marking && !(selection (panel)->f.marked))
3121             do_mark_file (panel, MARK_DONT_MOVE);
3122         else if (!mouse_marking && (selection (panel)->f.marked))
3123             do_mark_file (panel, MARK_DONT_MOVE);
3124     }
3125 }
3126
3127 /* --------------------------------------------------------------------------------------------- */
3128
3129 static int
3130 mark_if_marking (WPanel * panel, Gpm_Event * event)
3131 {
3132     if (event->buttons & GPM_B_RIGHT)
3133     {
3134         if (event->type & GPM_DOWN)
3135             mouse_toggle_mark (panel);
3136         else
3137             mouse_set_mark (panel);
3138         return 1;
3139     }
3140     return 0;
3141 }
3142
3143 /* --------------------------------------------------------------------------------------------- */
3144 /** Determine which column was clicked, and sort the panel on
3145  * that column, or reverse sort on that column if already
3146  * sorted on that column.
3147  */
3148
3149 static void
3150 mouse_sort_col (Gpm_Event * event, WPanel * panel)
3151 {
3152     int i;
3153     const char *lc_sort_name = NULL;
3154     panel_field_t *col_sort_format = NULL;
3155     format_e *format;
3156     gchar *title;
3157
3158     for (i = 0, format = panel->format; format != NULL; format = format->next)
3159     {
3160         i += format->field_len;
3161         if (event->x < i + 1)
3162         {
3163             /* found column */
3164             lc_sort_name = format->title;
3165             break;
3166         }
3167     }
3168
3169     if (lc_sort_name == NULL)
3170         return;
3171
3172     for (i = 0; panel_fields[i].id != NULL; i++)
3173     {
3174         title = panel_get_title_without_hotkey (panel_fields[i].title_hotkey);
3175         if (!strcmp (lc_sort_name, title) && panel_fields[i].sort_routine)
3176         {
3177             col_sort_format = &panel_fields[i];
3178             g_free (title);
3179             break;
3180         }
3181         g_free (title);
3182     }
3183
3184     if (col_sort_format == NULL)
3185         return;
3186
3187     if (panel->sort_info.sort_field == col_sort_format)
3188     {
3189         /* reverse the sort if clicked column is already the sorted column */
3190         panel->sort_info.reverse = !panel->sort_info.reverse;
3191     }
3192     else
3193     {
3194         /* new sort is forced to be ascending */
3195         panel->sort_info.reverse = FALSE;
3196     }
3197     panel_set_sort_order (panel, col_sort_format);
3198 }
3199
3200
3201 /* --------------------------------------------------------------------------------------------- */
3202 /**
3203  * Mouse callback of the panel minus repainting.
3204  * If the event is redirected to the menu, *redir is set to TRUE.
3205  */
3206 static int
3207 do_panel_event (Gpm_Event * event, WPanel * panel, gboolean * redir)
3208 {
3209     const int lines = llines (panel);
3210     const gboolean is_active = dlg_widget_active (panel);
3211     const gboolean mouse_down = (event->type & GPM_DOWN) != 0;
3212
3213     *redir = FALSE;
3214
3215     /* 1st line */
3216     if (mouse_down && event->y == 1)
3217     {
3218         /* "<" button */
3219         if (event->x == 2)
3220         {
3221             directory_history_prev (panel);
3222             return MOU_NORMAL;
3223         }
3224
3225         /* "." button show/hide hidden files */
3226         if (event->x == panel->widget.cols - 5)
3227         {
3228             panel->widget.owner->callback (panel->widget.owner, NULL,
3229                                            DLG_ACTION, CK_ShowHidden, NULL);
3230             repaint_screen ();
3231             return MOU_NORMAL;
3232         }
3233
3234         /* ">" button */
3235         if (event->x == panel->widget.cols - 1)
3236         {
3237             directory_history_next (panel);
3238             return MOU_NORMAL;
3239         }
3240
3241         /* "^" button */
3242         if (event->x >= panel->widget.cols - 4 && event->x <= panel->widget.cols - 2)
3243         {
3244             directory_history_list (panel);
3245             return MOU_NORMAL;
3246         }
3247
3248         /* rest of the upper frame, the menu is invisible - call menu */
3249         if (!menubar_visible)
3250         {
3251             *redir = TRUE;
3252             event->x += panel->widget.x;
3253             return the_menubar->widget.mouse (event, the_menubar);
3254         }
3255
3256         /* no other events on 1st line */
3257         return MOU_NORMAL;
3258     }
3259
3260     /* sort on clicked column; don't handle wheel events */
3261     if (mouse_down && (event->buttons & (GPM_B_UP | GPM_B_DOWN)) == 0 && event->y == 2)
3262     {
3263         mouse_sort_col (event, panel);
3264         return MOU_NORMAL;
3265     }
3266
3267     /* Mouse wheel events */
3268     if (mouse_down && (event->buttons & GPM_B_UP))
3269     {
3270         if (is_active)
3271         {
3272             if (panels_options.mouse_move_pages && (panel->top_file > 0))
3273                 prev_page (panel);
3274             else                /* We are in first page */
3275                 move_up (panel);
3276         }
3277         return MOU_NORMAL;
3278     }
3279
3280     if (mouse_down && (event->buttons & GPM_B_DOWN))
3281     {
3282         if (is_active)
3283         {
3284             if (panels_options.mouse_move_pages && (panel->top_file + ITEMS (panel) < panel->count))
3285                 next_page (panel);
3286             else                /* We are in last page */
3287                 move_down (panel);
3288         }
3289         return MOU_NORMAL;
3290     }
3291
3292     event->y -= 2;
3293     if ((event->type & (GPM_DOWN | GPM_DRAG)))
3294     {
3295         int my_index;
3296
3297         if (!is_active)
3298             change_panel ();
3299
3300         if (panel->top_file + event->y > panel->count)
3301             my_index = panel->count - 1;
3302         else
3303         {
3304             my_index = panel->top_file + event->y - 1;
3305             if (panel->split && (event->x > ((panel->widget.cols - 2) / 2)))
3306                 my_index += llines (panel);
3307
3308             if (my_index >= panel->count)
3309                 my_index = panel->count - 1;
3310         }
3311
3312         if (my_index != panel->selected)
3313         {
3314             unselect_item (panel);
3315             panel->selected = my_index;
3316             select_item (panel);
3317         }
3318
3319         /* This one is new */
3320         mark_if_marking (panel, event);
3321     }
3322     else if ((event->type & (GPM_UP | GPM_DOUBLE)) == (GPM_UP | GPM_DOUBLE))
3323     {
3324         if (event->y > 0 && event->y <= lines)
3325             do_enter (panel);
3326     }
3327     return MOU_NORMAL;
3328 }
3329
3330 /* --------------------------------------------------------------------------------------------- */
3331 /** Mouse callback of the panel */
3332
3333 static int
3334 panel_event (Gpm_Event * event, void *data)
3335 {
3336     WPanel *panel = data;
3337     int ret;
3338     gboolean redir;
3339
3340     ret = do_panel_event (event, panel, &redir);
3341     if (!redir)
3342         send_message ((Widget *) panel, WIDGET_DRAW, 0);
3343
3344     return ret;
3345 }
3346
3347 /* --------------------------------------------------------------------------------------------- */
3348
3349 static void
3350 reload_panelized (WPanel * panel)
3351 {
3352     int i, j;
3353     dir_list *list = &panel->dir;
3354
3355     if (panel != current_panel)
3356     {
3357         int ret;
3358         ret = mc_chdir (panel->cwd);
3359     }
3360
3361     for (i = 0, j = 0; i < panel->count; i++)
3362     {
3363         if (list->list[i].f.marked)
3364         {
3365             /* Unmark the file in advance. In case the following mc_lstat
3366              * fails we are done, else we have to mark the file again
3367              * (Note: do_file_mark depends on a valid "list->list [i].buf").
3368              * IMO that's the best way to update the panel's summary status
3369              * -- Norbert
3370              */
3371             do_file_mark (panel, i, 0);
3372         }
3373         if (mc_lstat (list->list[i].fname, &list->list[i].st))
3374         {
3375             g_free (list->list[i].fname);
3376             continue;
3377         }
3378         if (list->list[i].f.marked)
3379             do_file_mark (panel, i, 1);
3380         if (j != i)
3381             list->list[j] = list->list[i];
3382         j++;
3383     }
3384     if (j == 0)
3385         panel->count = set_zero_dir (list) ? 1 : 0;
3386     else
3387         panel->count = j;
3388
3389     if (panel != current_panel)
3390     {
3391         int ret;
3392         ret = mc_chdir (current_panel->cwd);
3393     }
3394 }
3395
3396 /* --------------------------------------------------------------------------------------------- */
3397
3398 static void
3399 update_one_panel_widget (WPanel * panel, panel_update_flags_t flags, const char *current_file)
3400 {
3401     gboolean free_pointer;
3402     char *my_current_file = NULL;
3403
3404     if ((flags & UP_RELOAD) != 0)
3405     {
3406         panel->is_panelized = FALSE;
3407         mc_setctl (panel->cwd, VFS_SETCTL_FLUSH, 0);
3408         memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat));
3409     }
3410
3411     /* If current_file == -1 (an invalid pointer) then preserve selection */
3412     free_pointer = current_file == UP_KEEPSEL;
3413
3414     if (free_pointer)
3415     {
3416         my_current_file = g_strdup (panel->dir.list[panel->selected].fname);
3417         current_file = my_current_file;
3418     }
3419
3420     if (panel->is_panelized)
3421         reload_panelized (panel);
3422     else
3423         panel_reload (panel);
3424
3425     try_to_select (panel, current_file);
3426     panel->dirty = 1;
3427
3428     if (free_pointer)
3429         g_free (my_current_file);
3430 }
3431
3432 /* --------------------------------------------------------------------------------------------- */
3433
3434 static void
3435 update_one_panel (int which, panel_update_flags_t flags, const char *current_file)
3436 {
3437     if (get_display_type (which) == view_listing)
3438     {
3439         WPanel *panel;
3440
3441         panel = (WPanel *) get_panel_widget (which);
3442         if (panel->is_panelized)
3443             flags &= ~UP_RELOAD;
3444         update_one_panel_widget (panel, flags, current_file);
3445     }
3446 }
3447
3448 /* --------------------------------------------------------------------------------------------- */
3449 /*** public functions ****************************************************************************/
3450 /* --------------------------------------------------------------------------------------------- */
3451
3452 char *
3453 remove_encoding_from_path (const char *path)
3454 {
3455     GString *ret;
3456     GString *tmp_path, *tmp_conv;
3457     char *tmp;
3458
3459     ret = g_string_new ("");
3460     tmp_conv = g_string_new ("");
3461     tmp_path = g_string_new (path);
3462
3463     while ((tmp = g_strrstr (tmp_path->str, PATH_SEP_STR VFS_ENCODING_PREFIX)) != NULL)
3464     {
3465         GIConv converter;
3466         char *tmp2;
3467
3468         vfs_path_t *vpath = vfs_path_from_str (tmp);
3469         vfs_path_element_t *path_element = vfs_path_get_by_index (vpath, -1);
3470
3471         converter =
3472             path_element->encoding !=
3473             NULL ? str_crt_conv_to (path_element->encoding) : str_cnv_to_term;
3474         vfs_path_free (vpath);
3475
3476         if (converter == INVALID_CONV)
3477             converter = str_cnv_to_term;
3478
3479         tmp2 = tmp + 1;
3480         while (*tmp2 != '\0' && *tmp2 != PATH_SEP)
3481             tmp2++;
3482
3483         if (*tmp2 != '\0')
3484         {
3485             str_vfs_convert_from (converter, tmp2, tmp_conv);
3486             g_string_prepend (ret, tmp_conv->str);
3487             g_string_set_size (tmp_conv, 0);
3488         }
3489
3490         g_string_set_size (tmp_path, tmp - tmp_path->str);
3491         str_close_conv (converter);
3492     }
3493
3494     g_string_prepend (ret, tmp_path->str);
3495     g_string_free (tmp_path, TRUE);
3496     g_string_free (tmp_conv, TRUE);
3497
3498     return g_string_free (ret, FALSE);
3499 }
3500
3501 /* --------------------------------------------------------------------------------------------- */
3502
3503 static void
3504 do_select (WPanel * panel, int i)
3505 {
3506     if (i != panel->selected)
3507     {
3508         panel->dirty = 1;
3509         panel->selected = i;
3510         panel->top_file = panel->selected - (panel->widget.lines - 2) / 2;
3511         if (panel->top_file < 0)
3512             panel->top_file = 0;
3513     }
3514 }
3515
3516 /* --------------------------------------------------------------------------------------------- */
3517
3518 static void
3519 do_try_to_select (WPanel * panel, const char *name)
3520 {
3521     int i;
3522     char *subdir;
3523
3524     if (!name)
3525     {
3526         do_select (panel, 0);
3527         return;
3528     }
3529
3530     /* We only want the last component of the directory,
3531      * and from this only the name without suffix. */
3532     subdir = vfs_strip_suffix_from_filename (x_basename (name));
3533
3534     /* Search that subdirectory, if found select it */
3535     for (i = 0; i < panel->count; i++)
3536     {
3537         if (strcmp (subdir, panel->dir.list[i].fname) == 0)
3538         {
3539             do_select (panel, i);
3540             g_free (subdir);
3541             return;
3542         }
3543     }
3544
3545     /* Try to select a file near the file that is missing */
3546     if (panel->selected >= panel->count)
3547         do_select (panel, panel->count - 1);
3548     g_free (subdir);
3549 }
3550
3551 /* --------------------------------------------------------------------------------------------- */
3552
3553 /* event callback */
3554 static gboolean
3555 event_update_panels (const gchar * event_group_name, const gchar * event_name,
3556                      gpointer init_data, gpointer data)
3557 {
3558     (void) event_group_name;
3559     (void) event_name;
3560     (void) init_data;
3561     (void) data;
3562
3563     update_panels (UP_RELOAD, UP_KEEPSEL);
3564
3565     return TRUE;
3566 }
3567
3568 /* --------------------------------------------------------------------------------------------- */
3569
3570 /* event callback */
3571 static gboolean
3572 panel_save_curent_file_to_clip_file (const gchar * event_group_name, const gchar * event_name,
3573                                      gpointer init_data, gpointer data)
3574 {
3575     (void) event_group_name;
3576     (void) event_name;
3577     (void) init_data;
3578     (void) data;
3579
3580     if (current_panel->marked == 0)
3581         mc_event_raise (MCEVENT_GROUP_CORE, "clipboard_text_to_file",
3582                         (gpointer) selection (current_panel)->fname);
3583     else
3584     {
3585         int i;
3586         gboolean first = TRUE;
3587         char *flist = NULL;
3588
3589         for (i = 0; i < current_panel->count; i++)
3590             if (current_panel->dir.list[i].f.marked != 0)
3591             {                   /* Skip the unmarked ones */
3592                 if (first)
3593                 {
3594                     flist = g_strdup (current_panel->dir.list[i].fname);
3595                     first = FALSE;
3596                 }
3597                 else
3598                 {
3599                     /* Add empty lines after the file */
3600                     char *tmp;
3601
3602                     tmp =
3603                         g_strconcat (flist, "\n", current_panel->dir.list[i].fname, (char *) NULL);
3604                     g_free (flist);
3605                     flist = tmp;
3606                 }
3607             }
3608
3609         mc_event_raise (MCEVENT_GROUP_CORE, "clipboard_text_to_file", (gpointer) flist);
3610         g_free (flist);
3611     }
3612     return TRUE;
3613 }
3614
3615 /* --------------------------------------------------------------------------------------------- */
3616 /*** public functions ****************************************************************************/
3617 /* --------------------------------------------------------------------------------------------- */
3618
3619 void
3620 try_to_select (WPanel * panel, const char *name)
3621 {
3622     do_try_to_select (panel, name);
3623     select_item (panel);
3624 }
3625
3626 /* --------------------------------------------------------------------------------------------- */
3627
3628 void
3629 panel_clean_dir (WPanel * panel)
3630 {
3631     int count = panel->count;
3632
3633     panel->count = 0;
3634     panel->top_file = 0;
3635     panel->selected = 0;
3636     panel->marked = 0;
3637     panel->dirs_marked = 0;
3638     panel->total = 0;
3639     panel->searching = FALSE;
3640     panel->is_panelized = FALSE;
3641     panel->dirty = 1;
3642
3643     clean_dir (&panel->dir, count);
3644 }
3645
3646 /* --------------------------------------------------------------------------------------------- */
3647 /** Panel creation.
3648  * @param panel_name the name of the panel for setup retieving
3649  * @returns new instance of WPanel
3650  */
3651
3652 WPanel *
3653 panel_new (const char *panel_name)
3654 {
3655     return panel_new_with_dir (panel_name, NULL);
3656 }
3657
3658 /* --------------------------------------------------------------------------------------------- */
3659 /** Panel creation for specified directory.
3660  * @param panel_name specifies the name of the panel for setup retieving
3661  * @param the path of working panel directory. If path is NULL then panel will be created for current directory
3662  * @returns new instance of WPanel
3663  */
3664
3665 WPanel *
3666 panel_new_with_dir (const char *panel_name, const char *wpath)
3667 {
3668     WPanel *panel;
3669     char *section;
3670     int i, err;
3671     char curdir[MC_MAXPATHLEN] = "\0";
3672
3673     panel = g_new0 (WPanel, 1);
3674
3675     /* No know sizes of the panel at startup */
3676     init_widget (&panel->widget, 0, 0, 0, 0, panel_callback, panel_event);
3677
3678     /* We do not want the cursor */
3679     widget_want_cursor (panel->widget, 0);
3680
3681     if (wpath != NULL)
3682     {
3683         g_strlcpy (panel->cwd, wpath, sizeof (panel->cwd));
3684         mc_get_current_wd (curdir, sizeof (curdir) - 2);
3685     }
3686     else
3687         mc_get_current_wd (panel->cwd, sizeof (panel->cwd) - 2);
3688
3689     strcpy (panel->lwd, ".");
3690
3691     panel->hist_name = g_strconcat ("Dir Hist ", panel_name, (char *) NULL);
3692     /* directories history will be get later */
3693
3694     panel->dir.list = g_new (file_entry, MIN_FILES);
3695     panel->dir.size = MIN_FILES;
3696     panel->active = 0;
3697     panel->filter = 0;
3698     panel->split = 0;
3699     panel->top_file = 0;
3700     panel->selected = 0;
3701     panel->marked = 0;
3702     panel->total = 0;
3703     panel->dirty = 1;
3704     panel->searching = FALSE;
3705     panel->dirs_marked = 0;
3706     panel->is_panelized = FALSE;
3707     panel->format = 0;
3708     panel->status_format = 0;
3709     panel->format_modified = 1;
3710
3711     panel->panel_name = g_strdup (panel_name);
3712     panel->user_format = g_strdup (DEFAULT_USER_FORMAT);
3713
3714     panel->codepage = SELECT_CHARSET_NO_TRANSLATE;
3715
3716     for (i = 0; i < LIST_TYPES; i++)
3717         panel->user_status_format[i] = g_strdup (DEFAULT_USER_FORMAT);
3718
3719     panel->search_buffer[0] = '\0';
3720     panel->prev_search_buffer[0] = '\0';
3721     panel->frame_size = frame_half;
3722
3723     section = g_strconcat ("Temporal:", panel->panel_name, (char *) NULL);
3724     if (!mc_config_has_group (mc_main_config, section))
3725     {
3726         g_free (section);
3727         section = g_strdup (panel->panel_name);
3728     }
3729     panel_load_setup (panel, section);
3730     g_free (section);
3731
3732     /* Load format strings */
3733     err = set_panel_formats (panel);
3734     if (err != 0)
3735         set_panel_formats (panel);
3736
3737 #ifdef HAVE_CHARSET
3738     {
3739         vfs_path_t *vpath = vfs_path_from_str (panel->cwd);
3740         vfs_path_element_t *path_element = vfs_path_get_by_index (vpath, -1);
3741
3742         if (path_element->encoding != NULL)
3743             panel->codepage = get_codepage_index (path_element->encoding);
3744
3745         vfs_path_free (vpath);
3746     }
3747 #endif
3748
3749     if (mc_chdir (panel->cwd) != 0)
3750     {
3751         panel->codepage = SELECT_CHARSET_NO_TRANSLATE;
3752         mc_get_current_wd (panel->cwd, sizeof (panel->cwd) - 2);
3753     }
3754
3755     /* Load the default format */
3756     panel->count =
3757         do_load_dir (panel->cwd, &panel->dir, panel->sort_info.sort_field->sort_routine,
3758                      panel->sort_info.reverse, panel->sort_info.case_sensitive,
3759                      panel->sort_info.exec_first, panel->filter);
3760
3761     /* Restore old right path */
3762     if (curdir[0] != '\0')
3763         err = mc_chdir (curdir);
3764
3765     return panel;
3766 }
3767
3768 /* --------------------------------------------------------------------------------------------- */
3769
3770 void
3771 panel_reload (WPanel * panel)
3772 {
3773     struct stat current_stat;
3774
3775     if (panels_options.fast_reload && !stat (panel->cwd, &current_stat)
3776         && current_stat.st_ctime == panel->dir_stat.st_ctime
3777         && current_stat.st_mtime == panel->dir_stat.st_mtime)
3778         return;
3779
3780     while (mc_chdir (panel->cwd) == -1)
3781     {
3782         char *last_slash;
3783
3784         if (panel->cwd[0] == PATH_SEP && panel->cwd[1] == 0)
3785         {
3786             panel_clean_dir (panel);
3787             panel->count = set_zero_dir (&panel->dir) ? 1 : 0;
3788             return;
3789         }
3790         last_slash = strrchr (panel->cwd, PATH_SEP);
3791         if (!last_slash || last_slash == panel->cwd)
3792             strcpy (panel->cwd, PATH_SEP_STR);
3793         else
3794             *last_slash = 0;
3795         memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat));
3796         show_dir (panel);
3797     }
3798
3799     panel->count =
3800         do_reload_dir (panel->cwd, &panel->dir, panel->sort_info.sort_field->sort_routine,
3801                        panel->count, panel->sort_info.reverse, panel->sort_info.case_sensitive,
3802                        panel->sort_info.exec_first, panel->filter);
3803
3804     panel->dirty = 1;
3805     if (panel->selected >= panel->count)
3806         do_select (panel, panel->count - 1);
3807
3808     recalculate_panel_summary (panel);
3809 }
3810
3811 /* --------------------------------------------------------------------------------------------- */
3812 /* Switches the panel to the mode specified in the format           */
3813 /* Seting up both format and status string. Return: 0 - on success; */
3814 /* 1 - format error; 2 - status error; 3 - errors in both formats.  */
3815
3816 int
3817 set_panel_formats (WPanel * p)
3818 {
3819     format_e *form;
3820     char *err = NULL;
3821     int retcode = 0;
3822
3823     form = use_display_format (p, panel_format (p), &err, 0);
3824
3825     if (err != NULL)
3826     {
3827         g_free (err);
3828         retcode = 1;
3829     }
3830     else
3831     {
3832         delete_format (p->format);
3833         p->format = form;
3834     }
3835
3836     if (panels_options.show_mini_info)
3837     {
3838         form = use_display_format (p, mini_status_format (p), &err, 1);
3839
3840         if (err != NULL)
3841         {
3842             g_free (err);
3843             retcode += 2;
3844         }
3845         else
3846         {
3847             delete_format (p->status_format);
3848             p->status_format = form;
3849         }
3850     }
3851
3852     panel_format_modified (p);
3853     panel_update_cols (&(p->widget), p->frame_size);
3854
3855     if (retcode)
3856         message (D_ERROR, _("Warning"),
3857                  _("User supplied format looks invalid, reverting to default."));
3858     if (retcode & 0x01)
3859     {
3860         g_free (p->user_format);
3861         p->user_format = g_strdup (DEFAULT_USER_FORMAT);
3862     }
3863     if (retcode & 0x02)
3864     {
3865         g_free (p->user_status_format[p->list_type]);
3866         p->user_status_format[p->list_type] = g_strdup (DEFAULT_USER_FORMAT);
3867     }
3868
3869     return retcode;
3870 }
3871
3872 /* --------------------------------------------------------------------------------------------- */
3873
3874 /* Select current item and readjust the panel */
3875 void
3876 select_item (WPanel * panel)
3877 {
3878     int items = ITEMS (panel);
3879
3880     /* Although currently all over the code we set the selection and
3881        top file to decent values before calling select_item, I could
3882        forget it someday, so it's better to do the actual fitting here */
3883
3884     if (panel->top_file < 0)
3885         panel->top_file = 0;
3886
3887     if (panel->selected < 0)
3888         panel->selected = 0;
3889
3890     if (panel->selected > panel->count - 1)
3891         panel->selected = panel->count - 1;
3892
3893     if (panel->top_file > panel->count - 1)
3894         panel->top_file = panel->count - 1;
3895
3896     if ((panel->count - panel->top_file) < items)
3897     {
3898         panel->top_file = panel->count - items;
3899         if (panel->top_file < 0)
3900             panel->top_file = 0;
3901     }
3902
3903     if (panel->selected < panel->top_file)
3904         panel->top_file = panel->selected;
3905
3906     if ((panel->selected - panel->top_file) >= items)
3907         panel->top_file = panel->selected - items + 1;
3908
3909     panel->dirty = 1;
3910
3911     execute_hooks (select_file_hook);
3912 }
3913
3914 /* --------------------------------------------------------------------------------------------- */
3915 /** Clears all files in the panel, used only when one file was marked */
3916 void
3917 unmark_files (WPanel * panel)
3918 {
3919     int i;
3920
3921     if (!panel->marked)
3922         return;
3923     for (i = 0; i < panel->count; i++)
3924         file_mark (panel, i, 0);
3925
3926     panel->dirs_marked = 0;
3927     panel->marked = 0;
3928     panel->total = 0;
3929 }
3930
3931 /* --------------------------------------------------------------------------------------------- */
3932 /** Recalculate the panels summary information, used e.g. when marked
3933    files might have been removed by an external command */
3934
3935 void
3936 recalculate_panel_summary (WPanel * panel)
3937 {
3938     int i;
3939
3940     panel->marked = 0;
3941     panel->dirs_marked = 0;
3942     panel->total = 0;
3943
3944     for (i = 0; i < panel->count; i++)
3945         if (panel->dir.list[i].f.marked)
3946         {
3947             /* do_file_mark will return immediately if newmark == oldmark.
3948                So we have to first unmark it to get panel's summary information
3949                updated. (Norbert) */
3950             panel->dir.list[i].f.marked = 0;
3951             do_file_mark (panel, i, 1);
3952         }
3953 }
3954
3955 /* --------------------------------------------------------------------------------------------- */
3956 /** This routine marks a file or a directory */
3957
3958 void
3959 do_file_mark (WPanel * panel, int idx, int mark)
3960 {
3961     if (panel->dir.list[idx].f.marked == mark)
3962         return;
3963
3964     /* Only '..' can't be marked, '.' isn't visible */
3965     if (strcmp (panel->dir.list[idx].fname, "..") == 0)
3966         return;
3967
3968     file_mark (panel, idx, mark);
3969     if (panel->dir.list[idx].f.marked)
3970     {
3971         panel->marked++;
3972         if (S_ISDIR (panel->dir.list[idx].st.st_mode))
3973         {
3974             if (panel->dir.list[idx].f.dir_size_computed)
3975                 panel->total += (uintmax_t) panel->dir.list[idx].st.st_size;
3976             panel->dirs_marked++;
3977         }
3978         else
3979             panel->total += (uintmax_t) panel->dir.list[idx].st.st_size;
3980         set_colors (panel);
3981     }
3982     else
3983     {
3984         if (S_ISDIR (panel->dir.list[idx].st.st_mode))
3985         {
3986             if (panel->dir.list[idx].f.dir_size_computed)
3987                 panel->total -= (uintmax_t) panel->dir.list[idx].st.st_size;
3988             panel->dirs_marked--;
3989         }
3990         else
3991             panel->total -= (uintmax_t) panel->dir.list[idx].st.st_size;
3992         panel->marked--;
3993     }
3994 }
3995
3996 /* --------------------------------------------------------------------------------------------- */
3997 /**
3998  * Changes the current directory of the panel.
3999  * Record change in the directory history.
4000  */
4001 gboolean
4002 do_panel_cd (struct WPanel *panel, const char *new_dir, enum cd_enum cd_type)
4003 {
4004     gboolean r;
4005
4006     r = _do_panel_cd (panel, new_dir, cd_type);
4007     if (r)
4008         directory_history_add (panel, panel->cwd);
4009     return r;
4010 }
4011
4012 /* --------------------------------------------------------------------------------------------- */
4013
4014 void
4015 file_mark (WPanel * panel, int lc_index, int val)
4016 {
4017     if (panel->dir.list[lc_index].f.marked != val)
4018     {
4019         panel->dir.list[lc_index].f.marked = val;
4020         panel->dirty = 1;
4021     }
4022 }
4023
4024 /* --------------------------------------------------------------------------------------------- */
4025
4026 void
4027 panel_re_sort (WPanel * panel)
4028 {
4029     char *filename;
4030     int i;
4031
4032     if (panel == NULL)
4033         return;
4034
4035     filename = g_strdup (selection (panel)->fname);
4036     unselect_item (panel);
4037     do_sort (&panel->dir, panel->sort_info.sort_field->sort_routine, panel->count - 1,
4038              panel->sort_info.reverse, panel->sort_info.case_sensitive,
4039              panel->sort_info.exec_first);
4040     panel->selected = -1;
4041     for (i = panel->count; i; i--)
4042     {
4043         if (!strcmp (panel->dir.list[i - 1].fname, filename))
4044         {
4045             panel->selected = i - 1;
4046             break;
4047         }
4048     }
4049     g_free (filename);
4050     panel->top_file = panel->selected - ITEMS (panel) / 2;
4051     select_item (panel);
4052     panel->dirty = 1;
4053 }
4054
4055 /* --------------------------------------------------------------------------------------------- */
4056
4057 void
4058 panel_set_sort_order (WPanel * panel, const panel_field_t * sort_order)
4059 {
4060     if (sort_order == NULL)
4061         return;
4062
4063     panel->sort_info.sort_field = sort_order;
4064
4065     /* The directory is already sorted, we have to load the unsorted stuff */
4066     if (sort_order->sort_routine == (sortfn *) unsorted)
4067     {
4068         char *current_file;
4069
4070         current_file = g_strdup (panel->dir.list[panel->selected].fname);
4071         panel_reload (panel);
4072         try_to_select (panel, current_file);
4073         g_free (current_file);
4074     }
4075     panel_re_sort (panel);
4076 }
4077
4078 /* --------------------------------------------------------------------------------------------- */
4079 /**
4080  * Change panel encoding.
4081  * @param panel WPanel object
4082  */
4083
4084 void
4085 panel_change_encoding (WPanel * panel)
4086 {
4087     const char *encoding = NULL;
4088     char *cd_path;
4089 #ifdef HAVE_CHARSET
4090     char *errmsg;
4091     int r;
4092
4093     r = select_charset (-1, -1, panel->codepage, FALSE);
4094
4095     if (r == SELECT_CHARSET_CANCEL)
4096         return;                 /* Cancel */
4097
4098     panel->codepage = r;
4099
4100     if (panel->codepage == SELECT_CHARSET_NO_TRANSLATE)
4101     {
4102         /* No translation */
4103         g_free (init_translation_table (mc_global.display_codepage, mc_global.display_codepage));
4104         cd_path = remove_encoding_from_path (panel->cwd);
4105         do_panel_cd (panel, cd_path, cd_parse_command);
4106         g_free (cd_path);
4107         return;
4108     }
4109
4110     errmsg = init_translation_table (panel->codepage, mc_global.display_codepage);
4111     if (errmsg != NULL)
4112     {
4113         message (D_ERROR, MSG_ERROR, "%s", errmsg);
4114         g_free (errmsg);
4115         return;
4116     }
4117
4118     encoding = get_codepage_id (panel->codepage);
4119 #endif
4120     if (encoding != NULL)
4121     {
4122         vfs_path_t *vpath = vfs_path_from_str (panel->cwd);
4123
4124         vfs_change_encoding (vpath, encoding);
4125
4126         cd_path = vfs_path_to_str (vpath);
4127         if (!do_panel_cd (panel, cd_path, cd_parse_command))
4128             message (D_ERROR, MSG_ERROR, _("Cannot chdir to \"%s\""), cd_path);
4129         g_free (cd_path);
4130
4131         vfs_path_free (vpath);
4132     }
4133 }
4134
4135 /* --------------------------------------------------------------------------------------------- */
4136 /**
4137  * This routine reloads the directory in both panels. It tries to
4138  * select current_file in current_panel and other_file in other_panel.
4139  * If current_file == -1 then it automatically sets current_file and
4140  * other_file to the currently selected files in the panels.
4141  *
4142  * if force_update has the UP_ONLY_CURRENT bit toggled on, then it
4143  * will not reload the other panel.
4144  */
4145
4146 void
4147 update_panels (panel_update_flags_t flags, const char *current_file)
4148 {
4149     gboolean reload_other = (flags & UP_ONLY_CURRENT) == 0;
4150     WPanel *panel;
4151     int ret;
4152
4153     update_one_panel (get_current_index (), flags, current_file);
4154     if (reload_other)
4155         update_one_panel (get_other_index (), flags, UP_KEEPSEL);
4156
4157     if (get_current_type () == view_listing)
4158         panel = (WPanel *) get_panel_widget (get_current_index ());
4159     else
4160         panel = (WPanel *) get_panel_widget (get_other_index ());
4161
4162     if (!panel->is_panelized)
4163         ret = mc_chdir (panel->cwd);
4164 }
4165
4166 /* --------------------------------------------------------------------------------------------- */
4167
4168 void
4169 directory_history_add (struct WPanel *panel, const char *dir)
4170 {
4171     char *tmp;
4172
4173     tmp = g_strdup (dir);
4174     strip_password (tmp, 1);
4175
4176     panel->dir_history = list_append_unique (panel->dir_history, tmp);
4177 }
4178
4179 /* --------------------------------------------------------------------------------------------- */
4180
4181 gsize
4182 panel_get_num_of_sortable_fields (void)
4183 {
4184     gsize ret = 0, lc_index;
4185
4186     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
4187         if (panel_fields[lc_index].is_user_choice)
4188             ret++;
4189     return ret;
4190 }
4191
4192 /* --------------------------------------------------------------------------------------------- */
4193
4194 const char **
4195 panel_get_sortable_fields (gsize * array_size)
4196 {
4197     char **ret;
4198     gsize lc_index, i;
4199
4200     lc_index = panel_get_num_of_sortable_fields ();
4201
4202     ret = g_try_new0 (char *, lc_index + 1);
4203     if (ret == NULL)
4204         return NULL;
4205
4206     if (array_size != NULL)
4207         *array_size = lc_index;
4208
4209     lc_index = 0;
4210
4211     for (i = 0; panel_fields[i].id != NULL; i++)
4212         if (panel_fields[i].is_user_choice)
4213             ret[lc_index++] = g_strdup (_(panel_fields[i].title_hotkey));
4214     return (const char **) ret;
4215 }
4216
4217 /* --------------------------------------------------------------------------------------------- */
4218
4219 const panel_field_t *
4220 panel_get_field_by_id (const char *name)
4221 {
4222     gsize lc_index;
4223     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
4224         if (panel_fields[lc_index].id != NULL && strcmp (name, panel_fields[lc_index].id) == 0)
4225             return &panel_fields[lc_index];
4226     return NULL;
4227 }
4228
4229 /* --------------------------------------------------------------------------------------------- */
4230
4231 const panel_field_t *
4232 panel_get_field_by_title_hotkey (const char *name)
4233 {
4234     gsize lc_index;
4235     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
4236         if (panel_fields[lc_index].title_hotkey != NULL &&
4237             strcmp (name, _(panel_fields[lc_index].title_hotkey)) == 0)
4238             return &panel_fields[lc_index];
4239     return NULL;
4240 }
4241
4242 /* --------------------------------------------------------------------------------------------- */
4243
4244 const panel_field_t *
4245 panel_get_field_by_title (const char *name)
4246 {
4247     gsize lc_index;
4248     gchar *title = NULL;
4249
4250     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
4251     {
4252         title = panel_get_title_without_hotkey (panel_fields[lc_index].title_hotkey);
4253         if (panel_fields[lc_index].title_hotkey != NULL && strcmp (name, title) == 0)
4254         {
4255             g_free (title);
4256             return &panel_fields[lc_index];
4257         }
4258     }
4259     g_free (title);
4260     return NULL;
4261 }
4262
4263 /* --------------------------------------------------------------------------------------------- */
4264
4265 gsize
4266 panel_get_num_of_user_possible_fields (void)
4267 {
4268     gsize ret = 0, lc_index;
4269
4270     for (lc_index = 0; panel_fields[lc_index].id != NULL; lc_index++)
4271         if (panel_fields[lc_index].use_in_user_format)
4272             ret++;
4273     return ret;
4274 }
4275
4276 /* --------------------------------------------------------------------------------------------- */
4277
4278 const char **
4279 panel_get_user_possible_fields (gsize * array_size)
4280 {
4281     char **ret;
4282     gsize lc_index, i;
4283
4284     lc_index = panel_get_num_of_user_possible_fields ();
4285
4286     ret = g_try_new0 (char *, lc_index + 1);
4287     if (ret == NULL)
4288         return NULL;
4289
4290     if (array_size != NULL)
4291         *array_size = lc_index;
4292
4293     lc_index = 0;
4294
4295     for (i = 0; panel_fields[i].id != NULL; i++)
4296         if (panel_fields[i].use_in_user_format)
4297             ret[lc_index++] = g_strdup (_(panel_fields[i].title_hotkey));
4298     return (const char **) ret;
4299 }
4300
4301 /* --------------------------------------------------------------------------------------------- */
4302
4303 void
4304 panel_init (void)
4305 {
4306     panel_sort_up_sign = mc_skin_get ("widget-common", "sort-sign-up", "'");
4307     panel_sort_down_sign = mc_skin_get ("widget-common", "sort-sign-down", ",");
4308
4309     panel_hiddenfiles_sign_show = mc_skin_get ("widget-panel", "hiddenfiles-sign-show", ".");
4310     panel_hiddenfiles_sign_hide = mc_skin_get ("widget-panel", "hiddenfiles-sign-hide", ".");
4311     panel_history_prev_item_sign = mc_skin_get ("widget-panel", "history-prev-item-sign", "<");
4312     panel_history_next_item_sign = mc_skin_get ("widget-panel", "history-next-item-sign", ">");
4313     panel_history_show_list_sign = mc_skin_get ("widget-panel", "history-show-list-sign", "^");
4314
4315     mc_event_add (MCEVENT_GROUP_FILEMANAGER, "update_panels", event_update_panels, NULL, NULL);
4316     mc_event_add (MCEVENT_GROUP_FILEMANAGER, "panel_save_curent_file_to_clip_file",
4317                   panel_save_curent_file_to_clip_file, NULL, NULL);
4318
4319 }
4320
4321 /* --------------------------------------------------------------------------------------------- */
4322
4323 void
4324 panel_deinit (void)
4325 {
4326     g_free (panel_sort_up_sign);
4327     g_free (panel_sort_down_sign);
4328
4329     g_free (panel_hiddenfiles_sign_show);
4330     g_free (panel_hiddenfiles_sign_hide);
4331     g_free (panel_history_prev_item_sign);
4332     g_free (panel_history_next_item_sign);
4333     g_free (panel_history_show_list_sign);
4334
4335 }
4336
4337 /* --------------------------------------------------------------------------------------------- */