src/main.c

   1 /* Main program for the Midnight Commander
   2    Copyright (C) 1994, 1995, 1996, 1997 The Free Software Foundation
   3
   4    Written by: 1994, 1995, 1996, 1997 Miguel de Icaza
   5                1994, 1995 Janne Kukonlehto
   6                1997 Norbert Warmuth
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include <config.h>
  23 #include <locale.h>
  24
  25 #ifdef NATIVE_WIN32
  26 #    include <windows.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <sys/types.h>
  33
  34 #include <sys/stat.h>
  35
  36 #ifdef HAVE_UNISTD_H
  37 #   include <unistd.h>
  38 #endif
  39
  40 #include <errno.h>
  41 #include <ctype.h>
  42 #include <signal.h>
  43
  44 /* Program include files */
  45 #include "global.h"
  46 #include "tty.h"
  47 #include "dir.h"
  48 #include "color.h"
  49 #include "dialog.h"
  50 #include "menu.h"
  51 #include "file.h"
  52 #include "panel.h"
  53 #include "main.h"
  54 #include "win.h"
  55 #include "user.h"
  56 #include "mouse.h"
  57 #include "option.h"
  58 #include "tree.h"
  59 #include "cons.saver.h"
  60 #include "subshell.h"
  61 #include "key.h"        /* For init_key() and mi_getch() */
  62 #include "setup.h"      /* save_setup() */
  63 #include "profile.h"    /* free_profiles() */
  64 #include "boxes.h"
  65 #include "layout.h"
  66 #include "cmd.h"                /* Normal commands */
  67 #include "hotlist.h"
  68 #include "panelize.h"
  69 #include "learn.h"
  70 #include "listmode.h"
  71 #include "background.h"
  72 #include "ext.h"        /* For flush_extension_file() */
  73
  74 /* Listbox for the command history feature */
  75 #include "widget.h"
  76 #include "command.h"
  77 #include "wtools.h"
  78 #include "complete.h"           /* For the free_completion */
  79
  80 #include "chmod.h"
  81 #include "chown.h"
  82
  83 #ifdef NATIVE_WIN32
  84 #    include "drive.h"
  85 #endif
  86
  87 #include "../vfs/vfs.h"
  88
  89 #ifdef WITH_SMBFS
  90 #include "../vfs/smbfs.h"       /* smbfs_set_debug() */
  91 #endif
  92
  93 #ifdef  HAVE_CHARSET
  94 #include "charsets.h"
  95 #endif  /* HAVE_CHARSET */
  96
  97 #include "popt.h"
  98
  99 /* "$Id$" */
 100
 101 /* When the modes are active, left_panel, right_panel and tree_panel */
 102 /* Point to a proper data structure.  You should check with the functions */
 103 /* get_current_type and get_other_type the types of the panels before using */
 104 /* This pointer variables */
 105
 106 /* The structures for the panels */
 107 WPanel *left_panel;
 108 WPanel *right_panel;
 109
 110 /* The pointer to the tree */
 111 WTree *the_tree;
 112
 113 /* The Menubar */
 114 WMenu *the_menubar;
 115
 116 /* Pointers to the selected and unselected panel */
 117 WPanel *current_panel = NULL;
 118
 119 /* Set when main loop should be terminated */
 120 volatile int quit = 0;
 121
 122 /* Set if you want the possible completions dialog for the first time */
 123 int show_all_if_ambiguous = 0;
 124
 125 /* Set when cd symlink following is desirable (bash mode) */
 126 int cd_symlinks = 1;
 127
 128 /* If set then dialogs just clean the screen when refreshing, else */
 129 /* they do a complete refresh, refreshing all the parts of the program */
 130 int fast_refresh = 0;
 131
 132 /* If true, marking a files moves the cursor down */
 133 int   mark_moves_down = 1;
 134
 135 /* If true, at startup the user-menu is invoked */
 136 int   auto_menu = 0;
 137
 138 /* If true, use + and \ keys normally and select/unselect do if M-+ / M-\
 139    and M-- and keypad + / - */
 140 int   alternate_plus_minus = 0;
 141
 142 /* If true, then the +, - and \ keys have their special meaning only if the
 143  * command line is emtpy, otherwise they behave like regular letters
 144  */
 145 int   only_leading_plus_minus = 1;
 146
 147 /* If true, after executing a command, wait for a keystroke */
 148 enum { pause_never, pause_on_dumb_terminals, pause_always };
 149
 150 int   pause_after_run = pause_on_dumb_terminals;
 151
 152 /* It true saves the setup when quitting */
 153 int auto_save_setup = 1;
 154
 155 #ifndef HAVE_CHARSET
 156 /* If true, be eight bit clean */
 157 int eight_bit_clean = 1;
 158
 159 /* If true, then display chars 0-255, else iso-8859-1,
 160    requires eight_bit_clean */
 161 int full_eight_bits = 1;
 162 #endif /* !HAVE_CHARSET */
 163
 164 /* If true use the internal viewer */
 165 int use_internal_view = 1;
 166
 167 /* Have we shown the fast-reload warning in the past? */
 168 int fast_reload_w = 0;
 169
 170 /* Move page/item? When clicking on the top or bottom of a panel */
 171 int mouse_move_pages = 1;
 172
 173 /* If true: l&r arrows are used to chdir if the input line is empty */
 174 int navigate_with_arrows = 0;
 175
 176 /* If true use +, -, | for line drawing */
 177 int force_ugly_line_drawing = 0;
 178
 179 /* If true message "The shell is already running a command" never */
 180 int force_subshell_execution = 0;
 181
 182 /* If true program softkeys (HP terminals only) on startup and after every
 183    command ran in the subshell to the description found in the termcap/terminfo
 184    database */
 185 int reset_hp_softkeys = 0;
 186
 187 /* The prompt */
 188 char *prompt = 0;
 189
 190 /* The widget where we draw the prompt */
 191 WLabel *the_prompt;
 192
 193 /* The hint bar */
 194 WLabel *the_hint;
 195
 196 /* The button bar */
 197 WButtonBar *the_bar;
 198
 199 /* For slow terminals */
 200 int slow_terminal = 0;
 201
 202 /* Mouse type: GPM, xterm or none */
 203 Mouse_Type use_mouse_p = MOUSE_NONE;
 204
 205 /* If true, assume we are running on an xterm terminal */
 206 static int force_xterm = 0;
 207
 208 /* Controls screen clearing before an exec */
 209 int clear_before_exec = 1;
 210
 211 /* Asks for confirmation before deleting a file */
 212 int confirm_delete = 1;
 213
 214 /* Asks for confirmation before overwriting a file */
 215 int confirm_overwrite = 1;
 216
 217 /* Asks for confirmation before executing a program by pressing enter */
 218 int confirm_execute = 0;
 219
 220 /* Asks for confirmation before leaving the program */
 221 int confirm_exit = 1;
 222
 223 /* Asks for confirmation when using F3 to view a directory and there
 224    are tagged files */
 225 int confirm_view_dir = 0;
 226
 227 /* This flag indicates if the pull down menus by default drop down */
 228 int drop_menus = 0;
 229
 230 /* The dialog handle for the main program */
 231 Dlg_head *midnight_dlg;
 232
 233 /* Subshell: if set, then the prompt was not saved on CONSOLE_SAVE */
 234 /* We need to paint it after CONSOLE_RESTORE, see: load_prompt */
 235 int update_prompt = 0;
 236
 237 #if 0
 238 /* The name which was used to invoke mc */
 239 char *program_name;
 240 #endif
 241
 242 /* The home directory */
 243 char *home_dir;
 244
 245 /* The value of the other directory, only used when loading the setup */
 246 char *other_dir = 0;
 247
 248 /* Only used at program boot */
 249 int boot_current_is_left = 1;
 250
 251 char *this_dir = 0;
 252
 253 /* If this is true, then when browsing the tree the other window will
 254  * automatically reload it's directory with the contents of the currently
 255  * selected directory.
 256  */
 257 int xtree_mode = 0;
 258
 259 /* If true, then print on stdout the last directory we were at */
 260 static int print_last_wd = 0;
 261 static char *last_wd_string;
 262 static int print_last_revert = 0;
 263
 264 /* Force colors, only used by Slang */
 265 int force_colors = 0;
 266
 267 /* colors specified on the command line: they override any other setting */
 268 char *command_line_colors;
 269
 270 /* File name to view if argument was supplied */
 271 char *view_one_file = 0;
 272
 273 /* File name to edit if argument was supplied */
 274 char *edit_one_file = 0;
 275 static int edit_one_file_start_line = 1;
 276
 277 /* Used so that widgets know if they are being destroyed or
 278    shut down */
 279 int midnight_shutdown = 0;
 280
 281 /* to show nice prompts */
 282 static int last_paused = 0;
 283
 284 /* Used for keeping track of the original stdout */
 285 int stdout_fd = 0;
 286
 287 /* The user's shell */
 288 char *shell;
 289
 290 /* mc_home: The home of MC */
 291 char *mc_home;
 292
 293 /* if on, it displays the information that files have been moved to ~/.mc */
 294 int show_change_notice = 0;
 295
 296 char cmd_buf [512];
 297
 298 /* Used during argument processing */
 299 int finish_program = 0;
 300
 301 WPanel *
 302 get_current_panel (void)
 303 {
 304         return current_panel;
 305 }
 306
 307 WPanel *
 308 get_other_panel (void)
 309 {
 310         return (WPanel *) get_panel_widget (get_other_index ());
 311 }
 312
 313 static void
 314 reload_panelized (WPanel *panel)
 315 {
 316     int i, j;
 317     dir_list *list = &panel->dir;
 318
 319     if (panel != cpanel)
 320         mc_chdir (panel->cwd);
 321
 322     for (i = 0, j = 0; i < panel->count; i++){
 323         if (list->list [i].f.marked) {
 324             /* Unmark the file in advance. In case the following mc_lstat
 325              * fails we are done, else we have to mark the file again
 326              * (Note: do_file_mark depends on a valid "list->list [i].buf").
 327              * IMO that's the best way to update the panel's summary status
 328              * -- Norbert
 329              */
 330             do_file_mark (panel, i, 0);
 331         }
 332         if (mc_lstat (list->list [i].fname, &list->list [i].buf)){
 333             g_free (list->list [i].fname);
 334             continue;
 335         }
 336         if (list->list [i].f.marked)
 337             do_file_mark (panel, i, 1);
 338         if (j != i)
 339             list->list [j] = list->list [i];
 340         j++;
 341     }
 342     if (j == 0)
 343         panel->count = set_zero_dir (list);
 344     else
 345         panel->count = j;
 346
 347     if (panel != cpanel)
 348         mc_chdir (cpanel->cwd);
 349 }
 350
 351 static void
 352 update_one_panel_widget (WPanel *panel, int force_update, char *current_file)
 353 {
 354     int free_pointer;
 355
 356     if (force_update & UP_RELOAD){
 357         panel->is_panelized = 0;
 358
 359 #if 1
 360         ftpfs_flushdir ();
 361 #endif
 362 /* FIXME: Should supply flushdir method */
 363         memset (&(panel->dir_stat), 0, sizeof (panel->dir_stat));
 364     }
 365
 366     /* If current_file == -1 (an invalid pointer) then preserve selection */
 367     if (current_file == UP_KEEPSEL){
 368         free_pointer = 1;
 369         current_file = g_strdup (panel->dir.list [panel->selected].fname);
 370     } else
 371         free_pointer = 0;
 372
 373     if (panel->is_panelized)
 374         reload_panelized (panel);
 375     else
 376         panel_reload (panel);
 377
 378     try_to_select (panel, current_file);
 379     panel->dirty = 1;
 380
 381     if (free_pointer)
 382         g_free (current_file);
 383 }
 384
 385 void
 386 panel_clean_dir (WPanel *panel)
 387 {
 388     int count = panel->count;
 389
 390     panel->count = 0;
 391     panel->top_file = 0;
 392     panel->selected = 0;
 393     panel->marked = 0;
 394     panel->dirs_marked = 0;
 395     panel->total = 0;
 396     panel->searching = 0;
 397     panel->is_panelized = 0;
 398
 399     clean_dir (&panel->dir, count);
 400 }
 401
 402 static void
 403 update_one_panel (int which, int force_update, char *current_file)
 404 {
 405     WPanel *panel;
 406
 407     if (get_display_type (which) != view_listing)
 408         return;
 409
 410     panel = (WPanel *) get_panel_widget (which);
 411     update_one_panel_widget (panel, force_update, current_file);
 412 }
 413
 414 /* This routine reloads the directory in both panels. It tries to
 415  * select current_file in current_panel and other_file in other_panel.
 416  * If current_file == -1 then it automatically sets current_file and
 417  * other_file to the currently selected files in the panels.
 418  *
 419  * if force_update has the UP_ONLY_CURRENT bit toggled on, then it
 420  * will not reload the other panel.
 421 */
 422 void
 423 update_panels (int force_update, char *current_file)
 424 {
 425     int reload_other = !(force_update & UP_ONLY_CURRENT);
 426     WPanel *panel;
 427
 428     update_one_panel (get_current_index (), force_update, current_file);
 429     if (reload_other)
 430         update_one_panel (get_other_index (), force_update, UP_KEEPSEL);
 431
 432     if (get_current_type () == view_listing)
 433         panel = (WPanel *) get_panel_widget (get_current_index ());
 434     else
 435         panel = (WPanel *) get_panel_widget (get_other_index ());
 436
 437     mc_chdir (panel->cwd);
 438 }
 439
 440 /* Sets up the terminal before executing a program */
 441 static void
 442 pre_exec (void)
 443 {
 444     use_dash (0);
 445     edition_pre_exec ();
 446 }
 447
 448 /* Save current stat of directories to avoid reloading the panels */
 449 /* when no modifications have taken place */
 450 void
 451 save_cwds_stat (void)
 452 {
 453     if (fast_reload){
 454         mc_stat (cpanel->cwd, &(cpanel->dir_stat));
 455         if (get_other_type () == view_listing)
 456             mc_stat (opanel->cwd, &(opanel->dir_stat));
 457     }
 458 }
 459
 460 #ifdef HAVE_SUBSHELL_SUPPORT
 461 void
 462 do_possible_cd (char *new_dir)
 463 {
 464     if (!do_cd (new_dir, cd_exact))
 465         message (1, _(" Warning "),
 466                  _(" The Commander can't change to the directory that \n"
 467                    " the subshell claims you are in.  Perhaps you have \n"
 468                    " deleted your working directory, or given yourself \n"
 469                    " extra access permissions with the \"su\" command? "));
 470 }
 471
 472 void
 473 do_update_prompt (void)
 474 {
 475     if (update_prompt){
 476         printf ("%s", subshell_prompt);
 477         fflush (stdout);
 478         update_prompt = 0;
 479     }
 480 }
 481 #endif /* HAVE_SUBSHELL_SUPPORT */
 482
 483 void
 484 restore_console (void)
 485 {
 486     handle_console (CONSOLE_RESTORE);
 487 }
 488
 489 void
 490 exec_shell (void)
 491 {
 492     do_execute (shell, 0, 0);
 493 }
 494
 495 void
 496 do_execute (const char *shell, const char *command, int flags)
 497 {
 498 #ifdef HAVE_SUBSHELL_SUPPORT
 499     char *new_dir = NULL;
 500 #endif /* HAVE_SUBSHELL_SUPPORT */
 501
 502 #ifdef USE_VFS
 503     char *old_vfs_dir = 0;
 504
 505     if (!vfs_current_is_local ())
 506         old_vfs_dir = g_strdup (vfs_get_current_dir ());
 507 #endif /* USE_VFS */
 508
 509     save_cwds_stat ();
 510     pre_exec ();
 511     if (console_flag)
 512         restore_console ();
 513
 514     if (!use_subshell && !(flags & EXECUTE_INTERNAL && command)) {
 515         printf ("%s%s%s\n", last_paused ? "\r\n":"", prompt, command);
 516         last_paused = 0;
 517     }
 518
 519 #ifdef HAVE_SUBSHELL_SUPPORT
 520     if (use_subshell && !(flags & EXECUTE_INTERNAL)){
 521         do_update_prompt ();
 522
 523         /* We don't care if it died, higher level takes care of this */
 524 #ifdef USE_VFS
 525         invoke_subshell (command, VISIBLY, old_vfs_dir ? 0 : &new_dir);
 526 #else
 527         invoke_subshell (command, VISIBLY, &new_dir);
 528 #endif /* !USE_VFS */
 529     } else
 530 #endif /* HAVE_SUBSHELL_SUPPORT */
 531         my_system (flags, shell, command);
 532
 533     if (!(flags & EXECUTE_INTERNAL)) {
 534         if ((pause_after_run == pause_always ||
 535             (pause_after_run == pause_on_dumb_terminals &&
 536              !xterm_flag && !console_flag)) && !quit
 537 #ifdef HAVE_SUBSHELL_SUPPORT
 538              && subshell_state != RUNNING_COMMAND
 539 #endif /* HAVE_SUBSHELL_SUPPORT */
 540            ) {
 541             printf ("%s\r\n", _("Press any key to continue..."));
 542             last_paused = 1;
 543             fflush (stdout);
 544             mc_raw_mode ();
 545             getch ();
 546         }
 547         if (console_flag) {
 548             if (output_lines && keybar_visible) {
 549                 putchar('\n');
 550                 fflush(stdout);
 551             }
 552         }
 553     }
 554
 555     if (console_flag)
 556         handle_console (CONSOLE_SAVE);
 557     edition_post_exec ();
 558
 559 #ifdef HAVE_SUBSHELL_SUPPORT
 560         if (new_dir)
 561             do_possible_cd (new_dir);
 562
 563 #endif /* HAVE_SUBSHELL_SUPPORT */
 564
 565 #ifdef USE_VFS
 566         if (old_vfs_dir){
 567             mc_chdir (old_vfs_dir);
 568             g_free (old_vfs_dir);
 569         }
 570 #endif /* USE_VFS */
 571
 572     update_panels (UP_OPTIMIZE, UP_KEEPSEL);
 573
 574     do_refresh ();
 575     use_dash (TRUE);
 576 }
 577
 578 /* Executes a command */
 579 void
 580 shell_execute (char *command, int flags)
 581 {
 582 #ifdef HAVE_SUBSHELL_SUPPORT
 583     if (use_subshell)
 584         if (subshell_state == INACTIVE || force_subshell_execution)
 585             do_execute (shell, command, flags | EXECUTE_AS_SHELL);
 586         else
 587             message (1, MSG_ERROR, _(" The shell is already running a command "));
 588     else
 589 #endif /* HAVE_SUBSHELL_SUPPORT */
 590         do_execute (shell, command, flags | EXECUTE_AS_SHELL);
 591 }
 592
 593 void
 594 execute (char *command)
 595 {
 596     shell_execute (command, 0);
 597 }
 598
 599 void
 600 change_panel (void)
 601 {
 602     free_completions (cmdline);
 603     dlg_one_down (midnight_dlg);
 604 }
 605
 606 /* Stop MC main dialog and the current dialog if it exists.
 607  * Needed to provide fast exit from MC viewer or editor on shell exit */
 608 static void stop_dialogs (void)
 609 {
 610     midnight_dlg->running = 0;
 611     if (current_dlg) {
 612         current_dlg->running = 0;
 613     }
 614 }
 615
 616 static int
 617 quit_cmd_internal (int quiet)
 618 {
 619     int q = quit;
 620
 621     if (quiet || !confirm_exit){
 622         q = 1;
 623     } else  {
 624         if (query_dialog (_(" The Midnight Commander "),
 625                      _(" Do you really want to quit the Midnight Commander? "),
 626                           0, 2, _("&Yes"), _("&No")) == 0)
 627             q = 1;
 628     }
 629     if (q){
 630 #ifdef HAVE_SUBSHELL_SUPPORT
 631         if (!use_subshell)
 632             stop_dialogs ();
 633         else
 634             if ((q = exit_subshell ()))
 635 #endif
 636                 stop_dialogs ();
 637     }
 638     if (q)
 639         quit |= 1;
 640     return quit;
 641 }
 642
 643 int quit_cmd (void)
 644 {
 645     quit_cmd_internal (0);
 646     return quit;
 647 }
 648
 649 int quiet_quit_cmd (void)
 650 {
 651     print_last_revert = 1;
 652     quit_cmd_internal (1);
 653     return quit;
 654 }
 655
 656 /*
 657  * Touch window and refresh window functions
 658  */
 659
 660 /* This routine untouches the first line on both panels in order */
 661 /* to avoid the refreshing the menu bar */
 662
 663 void
 664 untouch_bar (void)
 665 {
 666     do_refresh ();
 667 }
 668
 669 void
 670 repaint_screen (void)
 671 {
 672     do_refresh ();
 673     mc_refresh ();
 674 }
 675
 676 /* Wrapper for do_subshell_chdir, check for availability of subshell */
 677 void
 678 subshell_chdir (char *directory)
 679 {
 680 #ifdef HAVE_SUBSHELL_SUPPORT
 681     if (use_subshell){
 682         if (vfs_current_is_local ())
 683             do_subshell_chdir (directory, 0, 1);
 684     }
 685 #endif /* HAVE_SUBSHELL_SUPPORT */
 686 }
 687
 688 void
 689 directory_history_add (WPanel * panel, char *s)
 690 {
 691     if (!panel->dir_history) {
 692         panel->dir_history = g_new0 (Hist, 1);
 693         panel->dir_history->text = g_strdup (s);
 694         strip_password (panel->dir_history->text, 1);
 695         return;
 696     }
 697     if (!strcmp (panel->dir_history->text, s))
 698         return;
 699     if (panel->dir_history->next) {
 700         if (panel->dir_history->next->text) {
 701            g_free (panel->dir_history->next->text);
 702             panel->dir_history->next->text = 0;
 703         }
 704     } else {
 705         panel->dir_history->next = g_new0 (Hist, 1);
 706         panel->dir_history->next->prev = panel->dir_history;
 707     }
 708     panel->dir_history = panel->dir_history->next;
 709     panel->dir_history->text = g_strdup (s);
 710     strip_password (panel->dir_history->text, 1);
 711 }
 712
 713 /*
 714  *  If we moved to the parent directory move the selection pointer to
 715  *  the old directory name; If we leave VFS dir, remove FS specificator.
 716  *  Warn: This code spoils lwd string.
 717  *
 718  *  You do _NOT_ want to add any vfs aware code here. <pavel@ucw.cz>
 719  */
 720 static char*
 721 get_parent_dir_name (char *cwd, char *lwd)
 722 {
 723     char *p;
 724     if (strlen (lwd) > strlen (cwd))
 725         if((p=strrchr(lwd, PATH_SEP)) && !strncmp(cwd, lwd, p-lwd)){
 726             return (p+1);
 727         }
 728     return NULL;
 729 }
 730
 731 /* Changes the current panel directory */
 732 static int
 733 _do_panel_cd (WPanel *panel, char *new_dir, enum cd_enum cd_type)
 734 {
 735     char *directory, *olddir;
 736     char temp [MC_MAXPATHLEN];
 737     char *translated_url;
 738 #ifdef USE_VFS
 739     vfs *oldvfs;
 740     vfsid oldvfsid;
 741     struct vfs_stamping *parent;
 742 #endif
 743     olddir = g_strdup (panel->cwd);
 744     translated_url = new_dir = vfs_translate_url (new_dir);
 745
 746     /* Convert *new_path to a suitable pathname, handle ~user */
 747
 748     if (cd_type == cd_parse_command){
 749         while (*new_dir == ' ')
 750             new_dir++;
 751
 752         if (!strcmp (new_dir, "-")){
 753             strcpy (temp, panel->lwd);
 754             new_dir = temp;
 755         }
 756     }
 757     directory = *new_dir ? new_dir : home_dir;
 758
 759     if (mc_chdir (directory) == -1){
 760         strcpy (panel->cwd, olddir);
 761         g_free (olddir);
 762         g_free (translated_url);
 763         return 0;
 764     }
 765     g_free (translated_url);
 766
 767     /* Success: save previous directory, shutdown status of previous dir */
 768     strcpy (panel->lwd, olddir);
 769     free_completions (cmdline);
 770
 771     mc_get_current_wd (panel->cwd, sizeof (panel->cwd) - 2);
 772
 773 #ifdef USE_VFS
 774     oldvfs = vfs_type (olddir);
 775     oldvfsid = vfs_ncs_getid (oldvfs, olddir, &parent);
 776     vfs_add_noncurrent_stamps (oldvfs, oldvfsid, parent);
 777     vfs_rm_parents (parent);
 778 #endif
 779
 780     subshell_chdir (panel->cwd);
 781
 782     /* Reload current panel */
 783     panel_clean_dir (panel);
 784     panel->count = do_load_dir (&panel->dir, panel->sort_type,
 785                                  panel->reverse, panel->case_sensitive, panel->filter);
 786     try_to_select (panel, get_parent_dir_name (panel->cwd, olddir));
 787     load_hint ();
 788     panel_update_contents (panel);
 789
 790     g_free (olddir);
 791
 792     return 1;
 793 }
 794
 795 int
 796 do_panel_cd (WPanel *panel, char *new_dir, enum cd_enum cd_type)
 797 {
 798     int r;
 799
 800     r = _do_panel_cd (panel, new_dir, cd_type);
 801     if (r)
 802         directory_history_add (cpanel, cpanel->cwd);
 803     return r;
 804 }
 805
 806 int
 807 do_cd (char *new_dir, enum cd_enum exact)
 808 {
 809     return (do_panel_cd (cpanel, new_dir, exact));
 810 }
 811
 812 void
 813 directory_history_next (WPanel * panel)
 814 {
 815     if (!panel->dir_history->next)
 816         return;
 817     if (_do_panel_cd (panel, panel->dir_history->next->text, cd_exact))
 818         panel->dir_history = panel->dir_history->next;
 819 }
 820
 821 void
 822 directory_history_prev (WPanel * panel)
 823 {
 824     if (!panel->dir_history->prev)
 825         return;
 826     if (_do_panel_cd (panel, panel->dir_history->prev->text, cd_exact))
 827         panel->dir_history = panel->dir_history->prev;
 828 }
 829
 830 void
 831 directory_history_list (WPanel * panel)
 832 {
 833     char *s;
 834 /* must be at least two to show a history */
 835     if (panel->dir_history) {
 836         if (panel->dir_history->prev || panel->dir_history->next) {
 837             s = show_hist (panel->dir_history, panel->widget.x, panel->widget.y);
 838             if (s) {
 839                 int r;
 840                 r = _do_panel_cd (panel, s, cd_exact);
 841                 if (r)
 842                     directory_history_add (panel, panel->cwd);
 843                 else
 844                     message (1, MSG_ERROR, _("Could not change directory") );
 845                 g_free (s);
 846             }
 847         }
 848     }
 849 }
 850
 851 #ifdef HAVE_SUBSHELL_SUPPORT
 852 int
 853 load_prompt (int fd, void *unused)
 854 {
 855     if (!read_subshell_prompt ())
 856         return 0;
 857
 858     /* Don't actually change the prompt if it's invisible */
 859     if (current_dlg == midnight_dlg && command_prompt){
 860         int  prompt_len;
 861
 862         prompt = strip_ctrl_codes (subshell_prompt);
 863         prompt_len = strlen (prompt);
 864
 865         /* Check for prompts too big */
 866         if (COLS > 8 && prompt_len > COLS - 8) {
 867             prompt [COLS - 8 ] = 0;
 868             prompt_len = COLS - 8;
 869         }
 870         label_set_text (the_prompt, prompt);
 871         winput_set_origin ((WInput *)cmdline, prompt_len, COLS-prompt_len);
 872
 873         /* since the prompt has changed, and we are called from one of the
 874          * get_event channels, the prompt updating does not take place
 875          * automatically: force a cursor update and a screen refresh
 876          */
 877         update_cursor (midnight_dlg);
 878         mc_refresh ();
 879     }
 880     update_prompt = 1;
 881     return 0;
 882 }
 883 #endif /* HAVE_SUBSHELL_SUPPORT */
 884
 885 /* Used to emulate Lynx's entering leaving a directory with the arrow keys */
 886 int
 887 maybe_cd (int char_code, int move_up_dir)
 888 {
 889     if (navigate_with_arrows){
 890         if (!cmdline->buffer [0]){
 891             if (!move_up_dir){
 892                 do_cd ("..", cd_exact);
 893                 return 1;
 894             }
 895             if (S_ISDIR (selection (cpanel)->buf.st_mode)
 896                 || link_isdir (selection (cpanel))){
 897                 do_cd (selection (cpanel)->fname, cd_exact);
 898                 return 1;
 899             }
 900         }
 901     }
 902     return 0;
 903 }
 904
 905 void
 906 sort_cmd (void)
 907 {
 908     WPanel  *p;
 909     sortfn *sort_order;
 910
 911     if (!SELECTED_IS_PANEL)
 912         return;
 913
 914     p = MENU_PANEL;
 915     sort_order = sort_box (p->sort_type, &p->reverse, &p->case_sensitive);
 916
 917     panel_set_sort_order (p, sort_order);
 918
 919 }
 920
 921 static void
 922 treebox_cmd (void)
 923 {
 924     char *sel_dir;
 925
 926     sel_dir = tree_box (selection (cpanel)->fname);
 927     if (sel_dir){
 928         do_cd(sel_dir, cd_exact);
 929         g_free (sel_dir);
 930     }
 931 }
 932
 933 #ifdef LISTMODE_EDITOR
 934 static void
 935 listmode_cmd (void)
 936 {
 937     char *newmode;
 938     newmode = listmode_edit ("half <type,>name,|,size:8,|,perm:4+");
 939     message (0, _(" Listing format edit "), _(" New mode is \"%s\" "), newmode);
 940     g_free (newmode);
 941 }
 942 #endif /* LISTMODE_EDITOR */
 943
 944 /* NOTICE: hotkeys specified here are overriden in menubar_paint_idx (alex) */
 945 static menu_entry PanelMenu [] = {
 946     { ' ', N_("&Listing mode..."),          'L', listing_cmd },
 947     { ' ', N_("&Quick view     C-x q"),     'Q', quick_view_cmd },
 948     { ' ', N_("&Info           C-x i"),     'I', info_cmd },
 949     { ' ', N_("&Tree"),                     'T', tree_cmd },
 950     { ' ', "", ' ', 0 },
 951     { ' ', N_("&Sort order..."),            'S', sort_cmd },
 952     { ' ', "", ' ', 0 },
 953     { ' ', N_("&Filter..."),                'F', filter_cmd },
 954 #ifdef USE_NETCODE
 955     { ' ', "", ' ', 0 },
 956 #ifdef WITH_MCFS
 957     { ' ', N_("&Network link..."),          'N', netlink_cmd },
 958 #endif
 959     { ' ', N_("FT&P link..."),              'P', ftplink_cmd },
 960     { ' ', N_("S&hell link..."),            'H', fishlink_cmd },
 961 #ifdef WITH_SMBFS
 962     { ' ', N_("SM&B link..."),              'B', smblink_cmd },
 963 #endif
 964 #endif
 965     { ' ', "", ' ', 0 },
 966 #ifdef NATIVE_WIN32
 967     { ' ', N_("&Drive...       M-d"),       'D', drive_cmd_a },
 968 #endif
 969     { ' ', N_("&Rescan         C-r"),       'R', reread_cmd }
 970 };
 971
 972 static menu_entry RightMenu [] = {
 973     { ' ', N_("&Listing mode..."),       'L', listing_cmd },
 974     { ' ', N_("&Quick view     C-x q"),  'Q', quick_view_cmd },
 975     { ' ', N_("&Info           C-x i"),  'I', info_cmd },
 976     { ' ', N_("&Tree"),                  'T', tree_cmd },
 977     { ' ', "", ' ', 0 },
 978     { ' ', N_("&Sort order..."),         'S', sort_cmd },
 979     { ' ', "", ' ', 0 },
 980     { ' ', N_("&Filter..."),             'F', filter_cmd },
 981 #ifdef USE_NETCODE
 982     { ' ', "", ' ', 0 },
 983 #ifdef WITH_MCFS
 984     { ' ', N_("&Network link..."),       'N', netlink_cmd },
 985 #endif
 986     { ' ', N_("FT&P link..."),           'P', ftplink_cmd },
 987     { ' ', N_("S&hell link..."),         'H', fishlink_cmd },
 988 #ifdef WITH_SMBFS
 989     { ' ', N_("SM&B link..."),           'B', smblink_cmd },
 990 #endif
 991 #endif
 992     { ' ', "", ' ', 0 },
 993 #ifdef NATIVE_WIN32
 994     { ' ', N_("&Drive...       M-d"),    'D', drive_cmd_b },
 995 #endif
 996     { ' ', N_("&Rescan         C-r"),    'R', reread_cmd }
 997 };
 998
 999 static menu_entry FileMenu [] = {
1000     { ' ', N_("&User menu          F2"), 'U', user_file_menu_cmd },
1001     { ' ', N_("&View               F3"), 'V', view_cmd },
1002     { ' ', N_("Vie&w file...         "), 'W', view_file_cmd },
1003     { ' ', N_("&Filtered view     M-!"), 'F', filtered_view_cmd },
1004     { ' ', N_("&Edit               F4"), 'E', edit_cmd },
1005     { ' ', N_("&Copy               F5"), 'C', copy_cmd },
1006     { ' ', N_("c&Hmod           C-x c"), 'H', chmod_cmd },
1007 #ifndef NATIVE_WIN32
1008     { ' ', N_("&Link            C-x l"), 'L', link_cmd },
1009     { ' ', N_("&SymLink         C-x s"), 'S', symlink_cmd },
1010     { ' ', N_("edit s&Ymlink  C-x C-s"), 'Y', edit_symlink_cmd },
1011     { ' ', N_("ch&Own           C-x o"), 'O', chown_cmd },
1012     { ' ', N_("&Advanced chown       "), 'A', chown_advanced_cmd },
1013 #endif
1014     { ' ', N_("&Rename/Move        F6"), 'R', ren_cmd },
1015     { ' ', N_("&Mkdir              F7"), 'M', mkdir_cmd },
1016     { ' ', N_("&Delete             F8"), 'D', delete_cmd },
1017     { ' ', N_("&Quick cd          M-c"), 'Q', quick_cd_cmd },
1018     { ' ', "", ' ', 0 },
1019     { ' ', N_("select &Group      M-+"), 'G', select_cmd },
1020     { ' ', N_("u&Nselect group    M-\\"),'N', unselect_cmd },
1021     { ' ', N_("reverse selec&Tion M-*"), 'T', reverse_selection_cmd },
1022     { ' ', "", ' ', 0 },
1023     { ' ', N_("e&Xit              F10"), 'X', (callfn) quit_cmd }
1024 };
1025
1026 static menu_entry CmdMenu [] = {
1027     /* I know, I'm lazy, but the tree widget when it's not running
1028      * as a panel still has some problems, I have not yet finished
1029      * the WTree widget port, sorry.
1030      */
1031     { ' ', N_("&Directory tree"),               'D', treebox_cmd },
1032     { ' ', N_("&Find file            M-?"),     'F', find_cmd },
1033     { ' ', N_("s&Wap panels          C-u"),     'W', swap_cmd },
1034     { ' ', N_("switch &Panels on/off C-o"),     'P', view_other_cmd },
1035     { ' ', N_("&Compare directories  C-x d"),   'C', compare_dirs_cmd },
1036     { ' ', N_("e&Xternal panelize    C-x !"),   'X', external_panelize },
1037     { ' ', N_("show directory s&Izes"),         'I', dirsizes_cmd },
1038     { ' ', "", ' ', 0 },
1039     { ' ', N_("command &History"),              'H', history_cmd },
1040     { ' ', N_("di&Rectory hotlist    C-\\"),    'R', quick_chdir_cmd },
1041 #ifdef USE_VFS
1042     { ' ', N_("&Active VFS list      C-x a"),   'A', reselect_vfs },
1043     { ' ', N_("Fr&ee VFSs now"),                'E', free_vfs_now },
1044 #endif
1045 #ifdef WITH_BACKGROUND
1046     { ' ', N_("&Background jobs      C-x j"),   'B', jobs_cmd },
1047 #endif
1048     { ' ', "", ' ', 0 },
1049 #ifdef USE_EXT2FSLIB
1050     { ' ', N_("&Undelete files (ext2fs only)"), 'U', undelete_cmd },
1051 #endif
1052 #ifdef LISTMODE_EDITOR
1053     { ' ', N_("&Listing format edit"),          'L', listmode_cmd},
1054 #endif
1055 #if defined (USE_EXT2FSLIB) || defined (LISTMODE_EDITOR)
1056     { ' ', "", ' ', 0 },
1057 #endif
1058     { ' ', N_("&Extension file edit"),          'E', ext_cmd },
1059     { ' ', N_("&Menu file edit"),               'M', menu_edit_cmd },
1060 #ifdef USE_INTERNAL_EDIT
1061     {' ',  N_("Menu edi&Tor edit"),             'T', edit_user_menu_cmd},
1062     {' ',  N_("&Syntax file edit"),             'S', edit_syntax_cmd}
1063 #endif /* USE_INTERNAL_EDIT */
1064 };
1065
1066 /* Must keep in sync with the constants in menu_cmd */
1067 static menu_entry OptMenu [] = {
1068     { ' ', N_("&Configuration..."),    'C', configure_box },
1069     { ' ', N_("&Layout..."),           'L', layout_cmd },
1070     { ' ', N_("c&Onfirmation..."),     'O', confirm_box },
1071     { ' ', N_("&Display bits..."),     'D', display_bits_box },
1072 #ifndef NATIVE_WIN32
1073     { ' ', N_("learn &Keys..."),       'K', learn_keys },
1074 #endif /* !NATIVE_WIN32 */
1075 #ifdef USE_VFS
1076     { ' ', N_("&Virtual FS..."),       'V', configure_vfs },
1077 #endif /* !USE_VFS */
1078     { ' ', "", ' ', 0 },
1079     { ' ', N_("&Save setup"),          'S', save_setup_cmd }
1080 };
1081
1082 #define menu_entries(x) sizeof(x)/sizeof(menu_entry)
1083
1084 static Menu MenuBar [5];
1085
1086 void
1087 init_menu (void)
1088 {
1089     MenuBar [0] = create_menu ( horizontal_split ? _(" &Above ") : _(" &Left "),
1090                                 PanelMenu, menu_entries (PanelMenu),
1091                                 "[Left and Right Menus]");
1092     MenuBar [1] = create_menu (_(" &File "), FileMenu, menu_entries (FileMenu),
1093                                 "[File Menu]");
1094     MenuBar [2] = create_menu (_(" &Command "), CmdMenu, menu_entries (CmdMenu),
1095                                 "[Command Menu]");
1096     MenuBar [3] = create_menu (_(" &Options "), OptMenu, menu_entries (OptMenu),
1097                                 "[Options Menu]");
1098     MenuBar [4] = create_menu (horizontal_split ? _(" &Below ") : _(" &Right "),
1099                                RightMenu, menu_entries (PanelMenu),
1100                                "[Left and Right Menus]");
1101 }
1102
1103 void
1104 done_menu (void)
1105 {
1106     int i;
1107
1108     for (i = 0; i < 5; i++){
1109         destroy_menu (MenuBar [i]);
1110     }
1111 }
1112
1113 static void
1114 menu_last_selected_cmd (void)
1115 {
1116     the_menubar->active = 1;
1117     the_menubar->dropped = drop_menus;
1118     the_menubar->previous_selection = dlg_item_number (midnight_dlg);
1119     dlg_select_widget (midnight_dlg, the_menubar);
1120 }
1121
1122 static void
1123 menu_cmd (void)
1124 {
1125     if (the_menubar->active)
1126         return;
1127
1128     if (get_current_index () == 0)
1129         the_menubar->selected = 0;
1130     else
1131         the_menubar->selected = 4;
1132     menu_last_selected_cmd ();
1133 }
1134
1135 /* Flag toggling functions */
1136 void
1137 toggle_fast_reload (void)
1138 {
1139     fast_reload = !fast_reload;
1140     if (fast_reload_w == 0 && fast_reload){
1141         message (0, _(" Information "),
1142                  _(" Using the fast reload option may not reflect the exact \n"
1143                    " directory contents. In this cases you'll need to do a  \n"
1144                    " manual reload of the directory. See the man page for   \n"
1145                    " the details.                                           "));
1146         fast_reload_w = 1;
1147     }
1148 }
1149
1150 void
1151 toggle_mix_all_files (void)
1152 {
1153     mix_all_files = !mix_all_files;
1154     update_panels (UP_RELOAD, UP_KEEPSEL);
1155 }
1156
1157 void
1158 toggle_show_backup (void)
1159 {
1160     show_backups = !show_backups;
1161     update_panels (UP_RELOAD, UP_KEEPSEL);
1162 }
1163
1164 void
1165 toggle_show_hidden (void)
1166 {
1167     show_dot_files = !show_dot_files;
1168     update_panels (UP_RELOAD, UP_KEEPSEL);
1169 }
1170
1171 /*
1172  * Just a hack for allowing url-like pathnames to be accepted from the
1173  * command line.
1174  */
1175 static void
1176 translated_mc_chdir (char *dir)
1177 {
1178         char *newdir;
1179
1180         newdir = vfs_translate_url (dir);
1181         mc_chdir (newdir);
1182         g_free (newdir);
1183 }
1184
1185 void
1186 create_panels (void)
1187 {
1188     int current_index;
1189     int other_index;
1190     int current_mode;
1191     int other_mode;
1192     char original_dir [1024];
1193
1194     original_dir [0] = 0;
1195
1196     if (boot_current_is_left){
1197         current_index = 0;
1198         other_index = 1;
1199         current_mode = startup_left_mode;
1200         other_mode = startup_right_mode;
1201     } else {
1202         current_index = 1;
1203         other_index = 0;
1204         current_mode = startup_right_mode;
1205         other_mode = startup_left_mode;
1206     }
1207     /* Creates the left panel */
1208     if (this_dir){
1209         if (other_dir){
1210             /* Ok, user has specified two dirs, save the original one,
1211              * since we may not be able to chdir to the proper
1212              * second directory later
1213              */
1214             mc_get_current_wd (original_dir, sizeof (original_dir)-2);
1215         }
1216         translated_mc_chdir (this_dir);
1217     }
1218     set_display_type (current_index, current_mode);
1219
1220     /* The other panel */
1221     if (other_dir){
1222         if (original_dir [0])
1223             translated_mc_chdir (original_dir);
1224         translated_mc_chdir (other_dir);
1225     }
1226     set_display_type (other_index, other_mode);
1227
1228     if (startup_left_mode == view_listing){
1229         current_panel = left_panel;
1230     } else {
1231         if (right_panel)
1232             current_panel = right_panel;
1233         else
1234             current_panel = left_panel;
1235     }
1236
1237     /* Create the nice widgets */
1238     cmdline     = command_new (0, 0, 0);
1239     the_prompt  = label_new (0, 0, prompt, NULL);
1240     the_prompt->transparent = 1;
1241     the_bar     = buttonbar_new (keybar_visible);
1242
1243     the_hint    = label_new (0, 0, 0, NULL);
1244     the_hint->transparent = 1;
1245     the_hint->auto_adjust_cols = 0;
1246     the_hint->widget.cols = COLS;
1247
1248     the_menubar = menubar_new (0, 0, COLS, MenuBar, 5);
1249 }
1250
1251 static void copy_current_pathname (void)
1252 {
1253     if (!command_prompt)
1254         return;
1255
1256     command_insert (cmdline, cpanel->cwd, 0);
1257     if (cpanel->cwd [strlen (cpanel->cwd) - 1] != PATH_SEP)
1258         command_insert (cmdline, PATH_SEP_STR, 0);
1259 }
1260
1261 static void copy_other_pathname (void)
1262 {
1263     if (get_other_type () != view_listing)
1264         return;
1265
1266     if (!command_prompt)
1267         return;
1268
1269     command_insert (cmdline, opanel->cwd, 0);
1270     if (cpanel->cwd [strlen (opanel->cwd) - 1] != PATH_SEP)
1271         command_insert (cmdline, PATH_SEP_STR, 0);
1272 }
1273
1274 static void copy_readlink (WPanel *panel)
1275 {
1276     if (!command_prompt)
1277         return;
1278     if (S_ISLNK (selection (panel)->buf.st_mode)) {
1279         char buffer [MC_MAXPATHLEN];
1280         char *p = concat_dir_and_file (panel->cwd, selection (panel)->fname);
1281         int i;
1282
1283         i = mc_readlink (p, buffer, MC_MAXPATHLEN);
1284         g_free (p);
1285         if (i > 0) {
1286             buffer [i] = 0;
1287             command_insert (cmdline, buffer, 1);
1288         }
1289     }
1290 }
1291
1292 static void copy_current_readlink (void)
1293 {
1294     copy_readlink (cpanel);
1295 }
1296
1297 static void copy_other_readlink (void)
1298 {
1299     if (get_other_type () != view_listing)
1300         return;
1301     copy_readlink (opanel);
1302 }
1303
1304 /* Inserts the selected file name into the input line */
1305 /* Exported so that the command modules uses it */
1306 void copy_prog_name (void)
1307 {
1308     char *tmp;
1309     if (!command_prompt)
1310         return;
1311
1312     if (get_current_type () == view_tree){
1313         WTree *tree = (WTree *) get_panel_widget (get_current_index ());
1314         tmp = tree->selected_ptr->name;
1315     } else
1316         tmp = selection (cpanel)->fname;
1317
1318     command_insert (cmdline, tmp, 1);
1319 }
1320
1321 static void
1322 copy_tagged (WPanel * panel)
1323 {
1324     int i;
1325
1326     if (!command_prompt)
1327         return;
1328     input_disable_update (cmdline);
1329     if (panel->marked) {
1330         for (i = 0; i < panel->count; i++) {
1331             if (panel->dir.list[i].f.marked)
1332                 command_insert (cmdline, panel->dir.list[i].fname, 1);
1333         }
1334     } else {
1335         command_insert (cmdline, panel->dir.list[panel->selected].fname,
1336                         1);
1337     }
1338     input_enable_update (cmdline);
1339 }
1340
1341 static void copy_current_tagged (void)
1342 {
1343     copy_tagged (cpanel);
1344 }
1345
1346 static void copy_other_tagged (void)
1347 {
1348     if (get_other_type () != view_listing)
1349         return;
1350     copy_tagged (opanel);
1351 }
1352
1353 static void do_suspend_cmd (void)
1354 {
1355     pre_exec ();
1356
1357     if (console_flag && !use_subshell)
1358         restore_console ();
1359
1360 #ifdef SIGTSTP
1361     {
1362         struct sigaction sigtstp_action;
1363
1364         /* Make sure that the SIGTSTP below will suspend us directly,
1365            without calling ncurses' SIGTSTP handler; we *don't* want
1366            ncurses to redraw the screen immediately after the SIGCONT */
1367         sigaction (SIGTSTP, &startup_handler, &sigtstp_action);
1368
1369         kill (getpid (), SIGTSTP);
1370
1371         /* Restore previous SIGTSTP action */
1372         sigaction (SIGTSTP, &sigtstp_action, NULL);
1373     }
1374 #endif /* SIGTSTP */
1375
1376     if (console_flag && !use_subshell)
1377         handle_console (CONSOLE_SAVE);
1378
1379     edition_post_exec ();
1380 }
1381
1382 void
1383 suspend_cmd (void)
1384 {
1385     save_cwds_stat ();
1386     do_suspend_cmd ();
1387     update_panels (UP_OPTIMIZE, UP_KEEPSEL);
1388     do_refresh ();
1389 }
1390
1391 static void
1392 init_labels (Widget *paneletc)
1393 {
1394     define_label (midnight_dlg, paneletc, 1, _("Help"), help_cmd);
1395     define_label (midnight_dlg, paneletc, 2, _("Menu"), user_file_menu_cmd);
1396     define_label (midnight_dlg, paneletc, 9, _("PullDn"), menu_cmd);
1397     define_label (midnight_dlg, paneletc, 10, _("Quit"), (voidfn) quit_cmd);
1398 }
1399
1400 static const key_map ctl_x_map [] = {
1401     { XCTRL('c'),   (callfn) quit_cmd },
1402     { 'd',          compare_dirs_cmd },
1403 #ifdef USE_VFS
1404     { 'a',          reselect_vfs },
1405 #endif /* USE_VFS */
1406     { 'p',          copy_current_pathname },
1407     { XCTRL('p'),   copy_other_pathname },
1408     { 't',          copy_current_tagged },
1409     { XCTRL('t'),   copy_other_tagged },
1410     { 'c',          chmod_cmd },
1411 #ifndef NATIVE_WIN32
1412     { 'o',          chown_cmd },
1413     { 'r',          copy_current_readlink },
1414     { XCTRL('r'),   copy_other_readlink },
1415     { 'l',          link_cmd },
1416     { 's',          symlink_cmd },
1417     { XCTRL('s'),   edit_symlink_cmd },
1418 #endif /* !NATIVE_WIN32 */
1419     { 'i',          info_cmd_no_menu },
1420     { 'q',          quick_cmd_no_menu },
1421     { 'h',          add2hotlist_cmd },
1422     { '!',          external_panelize },
1423 #ifdef WITH_BACKGROUND
1424     { 'j',          jobs_cmd },
1425 #endif /* WITH_BACKGROUND */
1426 #ifdef HAVE_SETSOCKOPT
1427     { '%',          source_routing },
1428 #endif /* HAVE_SETSOCKOPT */
1429     { 0,  0 }
1430 };
1431
1432 static int ctl_x_map_enabled = 0;
1433
1434 static void ctl_x_cmd (int ignore)
1435 {
1436         ctl_x_map_enabled = 1;
1437 }
1438
1439 static void nothing (void)
1440 {
1441 }
1442
1443 static const key_map default_map [] = {
1444     { KEY_F(19),  menu_last_selected_cmd },
1445     { KEY_F(20),  (key_callback) quiet_quit_cmd },
1446
1447     /* Copy useful information to the command line */
1448     { ALT('\n'),  copy_prog_name },
1449     { ALT('\r'),  copy_prog_name },
1450     { ALT('a'),   copy_current_pathname },
1451     { ALT('A'),   copy_other_pathname },
1452
1453     { ALT('c'),   quick_cd_cmd },
1454
1455     /* To access the directory hotlist */
1456     { XCTRL('\\'), quick_chdir_cmd },
1457
1458     /* Suspend */
1459     { XCTRL('z'), suspend_cmd },
1460     /* The filtered view command */
1461     { ALT('!'),   filtered_view_cmd_cpanel },
1462
1463     /* Find file */
1464     { ALT('?'),   find_cmd },
1465
1466     /* Panel refresh */
1467     { XCTRL('r'), reread_cmd },
1468
1469     /* Toggle listing between long, user defined and full formats */
1470     { ALT('t'),   toggle_listing_cmd },
1471
1472     /* Swap panels */
1473     { XCTRL('u'), swap_cmd },
1474
1475     /* View output */
1476     { XCTRL('o'), view_other_cmd },
1477
1478     /* Control-X keybindings */
1479     { XCTRL('x'), ctl_x_cmd },
1480
1481     /* Trap dlg's exit commands */
1482     { ESC_CHAR,   nothing },
1483     { XCTRL('c'), nothing },
1484     { XCTRL('g'), nothing },
1485     { 0, 0 },
1486 };
1487
1488 static void setup_sigwinch (void)
1489 {
1490 #if (defined(HAVE_SLANG) || (NCURSES_VERSION_MAJOR >= 4)) && \
1491    !defined(NATIVE_WIN32) && defined(SIGWINCH)
1492     struct sigaction act, oact;
1493     act.sa_handler = flag_winch;
1494     sigemptyset (&act.sa_mask);
1495     act.sa_flags = 0;
1496 #   ifdef SA_RESTART
1497         act.sa_flags |= SA_RESTART;
1498 #   endif
1499     sigaction (SIGWINCH, &act, &oact);
1500 #endif
1501 }
1502
1503 static void
1504 setup_pre (void)
1505 {
1506     /* Call all the inits */
1507 #ifdef HAVE_CHARSET
1508 /*
1509  * Don't restrict the output on the screen manager level,
1510  * the translation tables take care of it.
1511  */
1512 #define full_eight_bits (1)
1513 #define eight_bit_clean (1)
1514 #endif /* !HAVE_CHARSET */
1515
1516 #ifndef HAVE_SLANG
1517     meta (stdscr, eight_bit_clean);
1518 #else
1519     SLsmg_Display_Eight_Bit = full_eight_bits ? 128 : 160;
1520 #endif
1521 }
1522
1523 static void
1524 init_xterm_support (void)
1525 {
1526     char   *termvalue;
1527 #ifdef HAVE_SLANG
1528     char   *term_entry;
1529 #endif
1530
1531     termvalue = getenv ("TERM");
1532     if (!termvalue || !(*termvalue)){
1533         fprintf (stderr, _("The TERM environment variable is unset!\n"));
1534         exit (1);
1535     }
1536
1537     /* Check mouse capabilities */
1538 #ifdef HAVE_SLANG
1539     term_entry = SLtt_tigetent (termvalue);
1540     xmouse_seq = SLtt_tigetstr ("Km", &term_entry);
1541 #else
1542     xmouse_seq = tigetstr ("kmous");
1543 #endif
1544
1545      /* -1 means invalid capability, shouldn't happen, but let's make it 0 */
1546     if ((long) xmouse_seq == -1) {
1547         xmouse_seq = NULL;
1548     }
1549
1550     if (strcmp (termvalue, "cygwin") == 0) {
1551         force_xterm = 1;
1552         use_mouse_p = MOUSE_DISABLED;
1553     }
1554
1555     if (force_xterm
1556             || strncmp (termvalue, "xterm", 5) == 0
1557             || strncmp (termvalue, "rxvt", 4) == 0
1558             || strcmp (termvalue, "dtterm") == 0) {
1559         xterm_flag = 1;
1560
1561         /* Default to the standard xterm sequence */
1562         if (!xmouse_seq) {
1563             xmouse_seq = ESC_STR "[M";
1564         }
1565
1566         /* Enable mouse unless explicitly disabled by --nomouse */
1567         if (use_mouse_p != MOUSE_DISABLED) {
1568             use_mouse_p = MOUSE_XTERM;
1569         }
1570
1571 #if 0 /* It works on xterm, but not on rxvt */
1572         printf (ESC_STR "]0;GNU Midnight Commander\7");
1573 #endif
1574     }
1575 }
1576
1577 static void setup_mc (void)
1578 {
1579     setup_pre ();
1580     init_menu ();
1581     create_panels ();
1582     setup_panels ();
1583
1584 #ifdef HAVE_SUBSHELL_SUPPORT
1585     if (use_subshell)
1586         add_select_channel (subshell_pty, load_prompt, 0);
1587 #endif /* !HAVE_SUBSHELL_SUPPORT */
1588
1589     setup_sigwinch ();
1590
1591     if (baudrate () < 9600 || slow_terminal){
1592         verbose = 0;
1593     }
1594     init_mouse ();
1595 }
1596
1597 static void setup_dummy_mc (const char *file)
1598 {
1599     char d[MC_MAXPATHLEN];
1600
1601     mc_get_current_wd (d, MC_MAXPATHLEN);
1602     setup_mc ();
1603     mc_chdir (d);
1604
1605     /* Create a fake current_panel, this is needed because the
1606      * expand_format routine will use current panel.
1607      */
1608     strcpy (cpanel->cwd, d);
1609     cpanel->selected = 0;
1610     cpanel->count = 1;
1611     cpanel->dir.list[0].fname = (char *) file;
1612 }
1613
1614 static void done_mc (void)
1615 {
1616     disable_mouse ();
1617
1618     done_menu ();
1619
1620     /* Setup shutdown
1621      *
1622      * We sync the profiles since the hotlist may have changed, while
1623      * we only change the setup data if we have the auto save feature set
1624      */
1625     if (auto_save_setup)
1626         save_setup ();   /* does also call save_hotlist */
1627     else
1628         save_hotlist();
1629     done_screen ();
1630     vfs_add_current_stamps ();
1631     if (xterm_flag && xterm_hintbar)
1632         set_hintbar(_("Thank you for using GNU Midnight Commander"));
1633 }
1634
1635 /* This should be called after destroy_dlg since panel widgets
1636  *  save their state on the profiles
1637  */
1638 static void done_mc_profile (void)
1639 {
1640     if (!auto_save_setup)
1641         profile_forget_profile (profile_name);
1642     sync_profiles ();
1643     done_setup ();
1644     free_profiles ();
1645 }
1646
1647 /* This routine only handles cpanel, and opanel, it is easy to
1648  * change to use npanels, just loop over the number of panels
1649  * and use get_panel_widget (i) and make the test done below
1650  */
1651 static void
1652 make_panels_dirty (void)
1653 {
1654     if (cpanel->dirty)
1655         panel_update_contents (cpanel);
1656
1657     if ((get_other_type () == view_listing) && opanel->dirty)
1658         panel_update_contents (opanel);
1659 }
1660
1661 /* In Windows people want to actually type the '\' key frequently */
1662 #ifdef NATIVE_WIN32
1663 #   define check_key_backslash(x) 0
1664 #else
1665 #   define check_key_backslash(x) ((x) == '\\')
1666 #endif
1667
1668 int
1669 midnight_callback (struct Dlg_head *h, int id, int msg)
1670 {
1671     int i;
1672     static int first_pre_event = 1;
1673
1674     switch (msg){
1675
1676     case DLG_PRE_EVENT:
1677         make_panels_dirty ();
1678         if (auto_menu && first_pre_event) {
1679             user_file_menu_cmd ();
1680         }
1681         first_pre_event = 0;
1682         return MSG_HANDLED;
1683
1684     case DLG_KEY:
1685         if (ctl_x_map_enabled){
1686                 ctl_x_map_enabled = 0;
1687                 for (i = 0; ctl_x_map [i].key_code; i++)
1688                         if (id == ctl_x_map [i].key_code){
1689                                 (*ctl_x_map [i].fn)(id);
1690                                 return MSG_HANDLED;
1691                         }
1692         }
1693
1694         /* FIXME: should handle all menu shortcuts before this point */
1695         if (the_menubar->active)
1696             break;
1697
1698         if (id == KEY_F(10)){
1699             quit_cmd ();
1700             return MSG_HANDLED;
1701         }
1702
1703         if (id == '\t')
1704             free_completions (cmdline);
1705
1706         /* On Linux, we can tell the difference */
1707         if (id == '\n' && ctrl_pressed ()){
1708             copy_prog_name ();
1709             return MSG_HANDLED;
1710         }
1711
1712         if (id == '\n' && cmdline->buffer [0]){
1713             send_message_to (h, (Widget *) cmdline, WIDGET_KEY, id);
1714             return MSG_HANDLED;
1715         }
1716
1717         if ((!alternate_plus_minus || !(console_flag || xterm_flag)) &&
1718              !quote && !cpanel->searching) {
1719             if(!only_leading_plus_minus) {
1720                 /* Special treatement, since the input line will eat them */
1721                 if (id == '+' ) {
1722                     select_cmd ();
1723                     return MSG_HANDLED;
1724                 }
1725
1726                 if (check_key_backslash (id) || id == '-'){
1727                     unselect_cmd ();
1728                     return MSG_HANDLED;
1729                 }
1730
1731                 if (id == '*') {
1732                     reverse_selection_cmd ();
1733                     return MSG_HANDLED;
1734                 }
1735             } else if (command_prompt && !strlen (cmdline->buffer)) {
1736                 /* Special treatement '+', '-', '\', '*' only when this is
1737                  * first char on input line
1738                  */
1739
1740                 if (id == '+') {
1741                     select_cmd ();
1742                     return MSG_HANDLED;
1743                 }
1744
1745                 if (check_key_backslash (id) || id == '-') {
1746                     unselect_cmd ();
1747                     return MSG_HANDLED;
1748                 }
1749
1750                 if (id == '*') {
1751                     reverse_selection_cmd ();
1752                     return MSG_HANDLED;
1753                 }
1754             }
1755         }
1756         break;
1757
1758     case DLG_HOTKEY_HANDLED:
1759         if (get_current_type () == view_listing)
1760             cpanel->searching = 0;
1761         break;
1762
1763     case DLG_UNHANDLED_KEY:
1764         if (command_prompt){
1765             int v;
1766
1767             v = send_message_to (h, (Widget *) cmdline, WIDGET_KEY, id);
1768             if (v)
1769                 return v;
1770         }
1771         if (ctl_x_map_enabled) {
1772                 ctl_x_map_enabled = 0;
1773                 for (i = 0; ctl_x_map [i].key_code; i++)
1774                         if (id == ctl_x_map [i].key_code){
1775                                 (*ctl_x_map [i].fn)(id);
1776                                 return MSG_HANDLED;
1777                         }
1778         } else
1779         {
1780                 for (i = 0; default_map [i].key_code; i++){
1781                         if (id == default_map [i].key_code){
1782                                 (*default_map [i].fn)(id);
1783                                 return MSG_HANDLED;
1784                         }
1785                 }
1786         }
1787         return MSG_NOT_HANDLED;
1788
1789         /* We handle the special case of the output lines */
1790     case DLG_DRAW:
1791         attrset (SELECTED_COLOR);
1792         if (console_flag && output_lines)
1793             show_console_contents (output_start_y,
1794                                    LINES-output_lines-keybar_visible-1,
1795                                    LINES-keybar_visible-1);
1796         return MSG_HANDLED;
1797
1798     }
1799     return default_dlg_callback (h, id, msg);
1800 }
1801
1802 #define xtoolkit_panel_setup()
1803
1804 void
1805 load_hint (void)
1806 {
1807     char *hint;
1808
1809     if (!the_hint->widget.parent)
1810         return;
1811
1812     if (!message_visible && (!xterm_flag || !xterm_hintbar)) {
1813         label_set_text (the_hint, 0);
1814         return;
1815     }
1816
1817     if ((hint = get_random_hint ())) {
1818         if (*hint)
1819             set_hintbar (hint);
1820         g_free (hint);
1821     } else {
1822         char text[BUF_SMALL];
1823
1824         g_snprintf (text, sizeof (text), _("GNU Midnight Commander %s\n"),
1825                     VERSION);
1826         set_hintbar (text);
1827     }
1828 }
1829
1830 static void
1831 setup_panels_and_run_mc (void)
1832 {
1833     int first, second;
1834
1835     xtoolkit_panel_setup ();
1836     add_widget (midnight_dlg, the_hint);
1837     load_hint ();
1838     add_widget (midnight_dlg, cmdline);
1839     add_widget (midnight_dlg, the_prompt);
1840     add_widget (midnight_dlg, the_bar);
1841
1842     if (boot_current_is_left){
1843         first = 1;
1844         second = 0;
1845     } else {
1846         first = 0;
1847         second = 1;
1848     }
1849     add_widget (midnight_dlg, get_panel_widget (first));
1850     add_widget (midnight_dlg, get_panel_widget (second));
1851     add_widget (midnight_dlg, the_menubar);
1852
1853     init_labels (get_panel_widget (0));
1854     init_labels (get_panel_widget (1));
1855
1856     /* Run the Midnight Commander if no file was specified in the command line */
1857     run_dlg (midnight_dlg);
1858 }
1859
1860 /* result must be free'd (I think this should go in util.c) */
1861 static char *
1862 prepend_cwd_on_local (char *filename)
1863 {
1864     char *d;
1865     int l;
1866
1867     if (vfs_file_is_local (filename)){
1868         if (*filename == PATH_SEP)      /* an absolute pathname */
1869             return g_strdup (filename);
1870         d = g_malloc (MC_MAXPATHLEN + strlen (filename) + 2);
1871         mc_get_current_wd (d, MC_MAXPATHLEN);
1872         l = strlen(d);
1873         d[l++] = PATH_SEP;
1874         strcpy (d + l, filename);
1875         return canonicalize_pathname (d);
1876     } else
1877         return g_strdup (filename);
1878 }
1879
1880 static int
1881 mc_maybe_editor_or_viewer (void)
1882 {
1883     char *path = NULL;
1884
1885     if (!(view_one_file || edit_one_file))
1886             return 0;
1887
1888     /* Invoke the internal view/edit routine with:
1889      * the default processing and forcing the internal viewer/editor
1890      */
1891     if (view_one_file) {
1892             path = prepend_cwd_on_local (view_one_file);
1893             setup_dummy_mc (path);
1894             view_file (path, 0, 1);
1895     }
1896 #ifdef USE_INTERNAL_EDIT
1897     else {
1898             path = prepend_cwd_on_local ("");
1899             setup_dummy_mc (path);
1900             edit (edit_one_file, edit_one_file_start_line);
1901     }
1902 #endif /* USE_INTERNAL_EDIT */
1903     g_free (path);
1904     midnight_shutdown = 1;
1905     done_mc ();
1906     return 1;
1907 }
1908
1909 /* Run the main dialog that occupies the whole screen */
1910 static void
1911 do_nc (void)
1912 {
1913     int midnight_colors [4];
1914
1915     midnight_colors [0] = NORMAL_COLOR;      /* NORMALC */
1916     midnight_colors [1] = REVERSE_COLOR;     /* FOCUSC */
1917     midnight_colors [2] = INPUT_COLOR;       /* HOT_NORMALC */
1918     midnight_colors [3] = NORMAL_COLOR;      /* HOT_FOCUSC */
1919
1920     midnight_dlg = create_dlg (0, 0, LINES, COLS, midnight_colors,
1921                                midnight_callback, "[main]", NULL,
1922                                DLG_HAS_MENUBAR);
1923
1924     /* Check if we were invoked as an editor or file viewer */
1925     if (mc_maybe_editor_or_viewer ())
1926             return;
1927
1928     setup_mc ();
1929
1930     setup_panels_and_run_mc ();
1931
1932     /* Program end */
1933     midnight_shutdown = 1;
1934
1935     /* destroy_dlg destroys even cpanel->cwd, so we have to save a copy :) */
1936     if (print_last_wd) {
1937         if (!vfs_current_is_local ())
1938             last_wd_string = g_strdup (".");
1939         else
1940             last_wd_string = g_strdup (cpanel->cwd);
1941     }
1942     done_mc ();
1943
1944     destroy_dlg (midnight_dlg);
1945     current_panel = 0;
1946     done_mc_profile ();
1947 }
1948
1949 #if defined (NATIVE_WIN32)
1950 /* Windows NT code */
1951
1952 void
1953 OS_Setup (void)
1954 {
1955     SetConsoleTitle ("GNU Midnight Commander");
1956
1957     shell = getenv ("COMSPEC");
1958     if (!shell || !*shell)
1959         shell = get_default_shell ();
1960
1961     /* Default opening mode for files is binary, not text (CR/LF translation) */
1962 #ifndef __EMX__
1963     _fmode = O_BINARY;
1964 #endif
1965
1966     mc_home = get_mc_lib_dir ();
1967 }
1968
1969 /* Nothing to be done on Windows */
1970 static void
1971 sigchld_handler_no_subshell (int sig)
1972 {
1973 }
1974
1975 void
1976 init_sigchld (void)
1977 {
1978 }
1979
1980 void
1981 init_sigfatals (void)
1982 {
1983 }
1984
1985
1986 #else
1987
1988 /* Unix version */
1989 static void
1990 OS_Setup (void)
1991 {
1992     char   *mc_libdir;
1993     shell = getenv ("SHELL");
1994     if (!shell || !*shell)
1995         shell = g_strdup (getpwuid (geteuid ())->pw_shell);
1996     if (!shell || !*shell)
1997         shell = "/bin/sh";
1998
1999     /* This is the directory, where MC was installed, on Unix this is DATADIR */
2000     /* and can be overriden by the MC_DATADIR environment variable */
2001     if ((mc_libdir = getenv ("MC_DATADIR")) != NULL) {
2002         mc_home = g_strdup (mc_libdir);
2003     } else {
2004         mc_home = g_strdup (DATADIR);
2005     }
2006 }
2007
2008 static void
2009 sigchld_handler_no_subshell (int sig)
2010 {
2011 #if defined(linux) || defined(__linux__)
2012     int pid, status;
2013
2014     if (!console_flag)
2015         return;
2016
2017     /* COMMENT: if it were true that after the call to handle_console(..INIT)
2018        the value of console_flag never changed, we could simply not install
2019        this handler at all if (!console_flag && !use_subshell). */
2020
2021     /* That comment is no longer true.  We need to wait() on a sigchld
2022        handler (that's at least what the tarfs code expects currently). */
2023
2024     pid = waitpid (cons_saver_pid, &status, WUNTRACED | WNOHANG);
2025
2026     if (pid == cons_saver_pid){
2027
2028         if (WIFSTOPPED (status)) {
2029             /* Someone has stopped cons.saver - restart it */
2030             kill (pid, SIGCONT);
2031         } else {
2032             /* cons.saver has died - disable console saving */
2033             handle_console (CONSOLE_DONE);
2034             console_flag = 0;
2035         }
2036     }
2037 #endif /* linux || __linux__ */
2038
2039     /* If we get here, some other child exited; ignore it */
2040 }
2041
2042 void
2043 init_sigchld (void)
2044 {
2045     struct sigaction sigchld_action;
2046
2047     sigchld_action.sa_handler =
2048 #ifdef HAVE_SUBSHELL_SUPPORT
2049         use_subshell ? sigchld_handler :
2050 #endif /* HAVE_SUBSHELL_SUPPORT */
2051         sigchld_handler_no_subshell;
2052
2053     sigemptyset (&sigchld_action.sa_mask);
2054
2055 #ifdef SA_RESTART
2056     sigchld_action.sa_flags = SA_RESTART;
2057 #else
2058     sigchld_action.sa_flags = 0;
2059 #endif /* !SA_RESTART */
2060
2061     if (sigaction (SIGCHLD, &sigchld_action, NULL) == -1) {
2062 #ifdef HAVE_SUBSHELL_SUPPORT
2063         /*
2064          * This may happen on QNX Neutrino 6, where SA_RESTART
2065          * is defined but not implemented.  Fallback to no subshell.
2066          */
2067         use_subshell = 0;
2068 #endif /* HAVE_SUBSHELL_SUPPORT */
2069     }
2070 }
2071
2072 #endif /* NATIVE_WIN32, UNIX */
2073
2074 static void
2075 print_mc_usage (poptContext ctx, FILE * stream)
2076 {
2077     fprintf (stream,
2078              _("Usage is:\n\n"
2079                "mc [flags] [this_dir] [other_panel_dir]\n\n"));
2080
2081     /* print help for options */
2082     poptPrintHelp (ctx, stream, 0);
2083
2084     fprintf (stream, "  %-19s %s\n", _("+number"),
2085              _("Set initial line number for the internal editor"));
2086     fprintf (stream,
2087              _("\n"
2088                "Please send any bug reports (including the output of `mc -V')\n"
2089                "to mc-devel@gnome.org\n"));
2090     version (0);
2091 }
2092
2093 static void
2094 print_color_usage (void)
2095 {
2096     fputs (_("--colors KEYWORD={FORE},{BACK}\n\n"
2097              "{FORE} and {BACK} can be omitted, and the default will be used\n"
2098              "\n"
2099              "Keywords:\n"
2100              "   Global:       errors, reverse, gauge, input\n"
2101              "   File display: normal, selected, marked, markselect\n"
2102              "   Dialog boxes: dnormal, dfocus, dhotnormal, dhotfocus\n"
2103              "   Menus:        menu, menuhot, menusel, menuhotsel\n"
2104              "   Help:         helpnormal, helpitalic, helplink, helpslink\n"
2105              "   File types:   directory, execute, link, device, special, core\n"
2106              "\n"
2107              "Colors:\n"
2108              "   black, gray, red, brightred, green, brightgreen, brown,\n"
2109              "   yellow, blue, brightblue, magenta, brightmagenta, cyan,\n"
2110              "   brightcyan, lightgray and white\n\n"), stdout);
2111 }
2112
2113 static void
2114 probably_finish_program (void)
2115 {
2116     if (finish_program){
2117         if (print_last_wd)
2118             printf (".");
2119         exit (1);
2120     }
2121 }
2122
2123 enum {
2124         GEOMETRY_KEY = -1,
2125         NOWIN_KEY    = -2
2126 };
2127
2128 static void
2129 process_args (poptContext ctx, int c, const char *option_arg)
2130 {
2131     switch (c) {
2132     case 'V':
2133         version (1);
2134         finish_program = 1;
2135         break;
2136
2137     case 'c':
2138         disable_colors = 0;
2139 #ifdef HAVE_SLANG
2140         force_colors = 1;
2141 #endif /* HAVE_SLANG */
2142         break;
2143
2144     case 'f':
2145         printf ("%s\n", mc_home);
2146         finish_program = 1;
2147         break;
2148
2149 #ifdef USE_NETCODE
2150     case 'l':
2151         ftpfs_set_debug (option_arg);
2152 #ifdef WITH_SMBFS
2153         smbfs_set_debugf (option_arg);
2154 #endif /* WITH_SMBFS */
2155         break;
2156
2157 #ifdef WITH_SMBFS
2158     case 'D':
2159         smbfs_set_debug (atoi (option_arg));
2160         break;
2161 #endif /* WITH_SMBFS */
2162 #endif /* USE_NETCODE */
2163
2164     case 'd':
2165         use_mouse_p = MOUSE_DISABLED;
2166         break;
2167
2168 #ifdef HAVE_SUBSHELL_SUPPORT
2169     case 'u':
2170         use_subshell = 0;
2171         break;
2172 #endif  /* HAVE_SUBSHELL_SUPPORT */
2173
2174     case 'H':
2175         print_color_usage ();
2176         finish_program = 1;
2177         break;
2178
2179     case 'h':
2180         print_mc_usage (ctx, stdout);
2181         finish_program = 1;
2182     }
2183 }
2184
2185 static const struct poptOption argument_table[] = {
2186 #ifdef WITH_BACKGROUND
2187     {"background", 'B', POPT_ARG_NONE, &background_wait, 0,
2188      N_("Use to debug the background code")},
2189 #endif
2190     {"color", 'c', POPT_ARG_NONE, NULL, 'c',
2191      N_("Request to run in color mode")},
2192     {"colors", 'C', POPT_ARG_STRING, &command_line_colors, 0,
2193      N_("Specifies a color configuration")},
2194
2195 #ifdef USE_INTERNAL_EDIT
2196     {"edit", 'e', POPT_ARG_STRING, &edit_one_file, 0,
2197      N_("Edits one file")},
2198 #endif
2199
2200     {"help", 'h', POPT_ARG_NONE, NULL, 'h',
2201      N_("Displays this help message")},
2202     {"help-colors", 'H', POPT_ARG_NONE, NULL, 'H',
2203      N_("Displays a help screen on how to change the color scheme")},
2204 #ifdef USE_NETCODE
2205     {"ftplog", 'l', POPT_ARG_STRING, NULL, 'l',
2206      N_("Log ftp dialog to specified file")},
2207 #ifdef WITH_SMBFS
2208     {"debuglevel", 'D', POPT_ARG_STRING, NULL, 'D',
2209      N_("Set debug level")},
2210 #endif
2211 #endif
2212     {"datadir", 'f', POPT_ARG_NONE, NULL, 'f',
2213      N_("Print data directory")},
2214     {"nocolor", 'b', POPT_ARG_NONE, &disable_colors, 0,
2215      N_("Requests to run in black and white")},
2216     {"nomouse", 'd', POPT_ARG_NONE, NULL, 'd',
2217      N_("Disable mouse support in text version")},
2218 #ifdef HAVE_SUBSHELL_SUPPORT
2219     {"nosubshell", 'u', POPT_ARG_NONE, NULL, 'u',
2220      N_("Disables subshell support")},
2221     {"forceexec", 'r', POPT_ARG_NONE, &force_subshell_execution, 0,
2222      N_("Force subshell execution")},
2223 #endif
2224     {"printwd", 'P', POPT_ARG_NONE, &print_last_wd, 0,
2225      N_("Prints working directory at program exit")},
2226     {"resetsoft", 'k', POPT_ARG_NONE, &reset_hp_softkeys, 0,
2227      N_("Resets soft keys on HP terminals")},
2228     {"slow", 's', POPT_ARG_NONE, &slow_terminal, 0,
2229      N_("To run on slow terminals")},
2230 #ifndef NATIVE_WIN32
2231     {"stickchars", 'a', 0, &force_ugly_line_drawing, 0,
2232      N_("Use stickchars to draw")},
2233 #endif                          /* !NATIVE_WIN32 */
2234 #ifdef HAVE_SUBSHELL_SUPPORT
2235     {"subshell", 'U', POPT_ARG_NONE, &use_subshell, 0,
2236      N_("Enables subshell support (default)")},
2237 #endif
2238 #if defined(HAVE_SLANG) && !defined(NATIVE_WIN32)
2239     {"termcap", 't', 0, &SLtt_Try_Termcap, 0,
2240      N_("Tries to use termcap instead of terminfo")},
2241 #endif
2242     {"version", 'V', POPT_ARG_NONE, NULL, 'V',
2243      N_("Displays the current version")},
2244     {"view", 'v', POPT_ARG_STRING, &view_one_file, 0,
2245      N_("Launches the file viewer on a file")},
2246     {"xterm", 'x', POPT_ARG_NONE, &force_xterm, 0,
2247      N_("Forces xterm features")},
2248
2249     {NULL, 0, 0, NULL, 0}
2250 };
2251
2252 static void
2253 handle_args (int argc, char *argv [])
2254 {
2255     char   *tmp;
2256     poptContext   ctx;
2257     char   *base;
2258     int    c;
2259
2260     ctx = poptGetContext ("mc", argc, argv, argument_table,
2261                           POPT_CONTEXT_NO_EXEC);
2262
2263 #ifdef USE_TERMCAP
2264     SLtt_Try_Termcap = 1;
2265 #endif
2266
2267     while ((c = poptGetNextOpt (ctx)) > 0){
2268         process_args (ctx, c, poptGetOptArg (ctx));
2269     }
2270
2271     if (c < -1){
2272         print_mc_usage (ctx, stderr);
2273         fprintf(stderr, "%s: %s\n",
2274                 poptBadOption (ctx, POPT_BADOPTION_NOALIAS),
2275                 poptStrerror (c));
2276         finish_program = 1;
2277     }
2278     probably_finish_program ();
2279
2280     tmp = poptGetArg (ctx);
2281
2282     /*
2283      * Check for special invocation names mcedit and mcview,
2284      * if none apply then set the current directory and the other
2285      * directory from the command line arguments
2286      */
2287     base = x_basename (argv[0]);
2288     if (!STRNCOMP (base, "mce", 3) || !STRCOMP(base, "vi")) {
2289         edit_one_file = "";
2290         edit_one_file_start_line = 1;
2291         if (tmp) {
2292             if (*tmp == '+' && isdigit ((unsigned char) tmp[1])){
2293                 int start_line = atoi (tmp);
2294                 if (start_line > 0) {
2295                     char *file = poptGetArg (ctx);
2296                     if (file) {
2297                         tmp = file;
2298                         edit_one_file_start_line = start_line;
2299                     }
2300                 }
2301             }
2302             edit_one_file = g_strdup (tmp);
2303         }
2304     } else
2305     if (!STRNCOMP (base, "mcv", 3) || !STRCOMP(base, "view")) {
2306         if (tmp)
2307             view_one_file = g_strdup (tmp);
2308         else {
2309             fprintf (stderr, "No arguments given to the viewer\n");
2310             finish_program = 1;
2311             probably_finish_program ();
2312         }
2313     } else {
2314         /* sets the current dir and the other dir */
2315         if (tmp) {
2316             this_dir = g_strdup (tmp);
2317             if ((tmp = poptGetArg (ctx)))
2318                 other_dir = g_strdup (tmp);
2319         }
2320     }
2321
2322     poptFreeContext (ctx);
2323 }
2324
2325 /*
2326  * The compatibility_move_mc_files routine is intended to
2327  * move all of the hidden .mc files into a private ~/.mc
2328  * directory in the home directory, to avoid cluttering the users.
2329  *
2330  * Previous versions of the program had all of their files in
2331  * the $HOME, we are now putting them in $HOME/.mc
2332  */
2333 #ifdef NATIVE_WIN32
2334 #    define compatibility_move_mc_files()
2335 #else
2336
2337 static int
2338 do_mc_filename_rename (char *mc_dir, char *o_name, char *n_name)
2339 {
2340         char *full_o_name = concat_dir_and_file (home_dir, o_name);
2341         char *full_n_name = g_strconcat (home_dir, MC_BASE, n_name, NULL);
2342         int move;
2343
2344         move = 0 == rename (full_o_name, full_n_name);
2345         g_free (full_o_name);
2346         g_free (full_n_name);
2347         return move;
2348 }
2349
2350 static void
2351 do_compatibility_move (char *mc_dir)
2352 {
2353         struct stat s;
2354         int move;
2355
2356         if (stat (mc_dir, &s) == 0)
2357                 return;
2358         if (errno != ENOENT)
2359                 return;
2360
2361         if (mkdir (mc_dir, 0777) == -1)
2362                 return;
2363
2364         move = do_mc_filename_rename (mc_dir, ".mc.ini", "ini");
2365         move += do_mc_filename_rename (mc_dir, ".mc.hot", "hotlist");
2366         move += do_mc_filename_rename (mc_dir, ".mc.ext", "ext");
2367         move += do_mc_filename_rename (mc_dir, ".mc.menu", "menu");
2368         move += do_mc_filename_rename (mc_dir, ".mc.bashrc", "bashrc");
2369         move += do_mc_filename_rename (mc_dir, ".mc.inputrc", "inputrc");
2370         move += do_mc_filename_rename (mc_dir, ".mc.tcshrc", "tcshrc");
2371         move += do_mc_filename_rename (mc_dir, ".mc.tree", "tree");
2372
2373         if (!move)
2374                 return;
2375
2376         show_change_notice = 1;
2377 }
2378
2379 static void
2380 compatibility_move_mc_files (void)
2381 {
2382         char *mc_dir = concat_dir_and_file (home_dir, ".mc");
2383
2384         do_compatibility_move (mc_dir);
2385         g_free (mc_dir);
2386 }
2387 #endif  /* NATIVE_WIN32 */
2388
2389 int
2390 main (int argc, char *argv [])
2391 {
2392     /* We had LC_CTYPE before, LC_ALL includs LC_TYPE as well */
2393     setlocale (LC_ALL, "");
2394     bindtextdomain ("mc", LOCALEDIR);
2395     textdomain ("mc");
2396
2397     /* Initialize list of all user group for timur_clr_mode */
2398     init_groups ();
2399
2400     /* Set up temporary directory */
2401     mc_tmpdir ();
2402
2403     OS_Setup ();
2404
2405     /* This variable is used by the subshell */
2406     home_dir = getenv ("HOME");
2407     if (!home_dir) {
2408             /* mc_home was computed by OS_Setup */
2409             home_dir = mc_home;
2410     }
2411
2412     vfs_init ();
2413
2414 #ifdef HAVE_SLANG
2415     SLtt_Ignore_Beep = 1;
2416 #endif
2417
2418     /* NOTE: This has to be called before slang_init or whatever routine
2419        calls any define_sequence */
2420     init_key ();
2421
2422     handle_args (argc, argv);
2423
2424     /* Used to report the last working directory at program end */
2425     if (print_last_wd){
2426 #ifndef NATIVE_WIN32
2427         stdout_fd = dup (1);
2428         close (1);
2429         if (open (ttyname (0), O_RDWR) < 0)
2430             if (open ("/dev/tty", O_RDWR) < 0) {
2431             /* Try if stderr is not redirected as the last chance */
2432                 char *p = g_strdup (ttyname (0));
2433
2434                 if (!strcmp (p, ttyname (2)))
2435                     dup2 (2, 1);
2436                 else {
2437                     fprintf (stderr,
2438                              _("Couldn't open tty line. You have to run mc without the -P flag.\n"
2439                                "On some systems you may want to run # `which mc`\n"));
2440                     exit (1);
2441                 }
2442                 g_free (p);
2443             }
2444 #endif
2445     }
2446
2447     /* Must be done before installing the SIGCHLD handler [[FIXME]] */
2448     handle_console (CONSOLE_INIT);
2449
2450 #   ifdef HAVE_SUBSHELL_SUPPORT
2451     subshell_get_console_attributes ();
2452 #   endif
2453
2454     /* Install the SIGCHLD handler; must be done before init_subshell() */
2455     init_sigchld ();
2456
2457     compatibility_move_mc_files ();
2458
2459     /* We need this, since ncurses endwin () doesn't restore the signals */
2460     save_stop_handler ();
2461
2462     /* Must be done before init_subshell, to set up the terminal size: */
2463     /* FIXME: Should be removed and LINES and COLS computed on subshell */
2464 #ifdef HAVE_SLANG
2465     slang_init ();
2466 #endif
2467     /* NOTE: This call has to be after slang_init. It's the small part from
2468     the previous init_key which had to be moved after the call of slang_init */
2469     init_key_input_fd ();
2470
2471     load_setup ();
2472
2473     init_curses ();
2474
2475     init_xterm_support ();
2476
2477 #ifdef HAVE_SUBSHELL_SUPPORT
2478
2479     /* Don't use subshell when invoked as a viewer or editor */
2480     if (edit_one_file || view_one_file)
2481         use_subshell = 0;
2482
2483     /* Done here to ensure that the subshell doesn't  */
2484     /* inherit the file descriptors opened below, etc */
2485     if (use_subshell)
2486         init_subshell ();
2487
2488 #endif /* HAVE_SUBSHELL_SUPPORT */
2489
2490     /* Removing this from the X code let's us type C-c */
2491     load_key_defs ();
2492
2493     /* Also done after init_subshell, to save any shell init file messages */
2494     if (console_flag)
2495         handle_console (CONSOLE_SAVE);
2496
2497     if (alternate_plus_minus)
2498         application_keypad_mode ();
2499
2500     if (show_change_notice){
2501         message (1, _(" Notice "),
2502                  _(" The Midnight Commander configuration files \n"
2503                    " are now stored in the ~/.mc directory, the \n"
2504                    " files have been moved now\n"));
2505     }
2506
2507 #ifdef HAVE_SUBSHELL_SUPPORT
2508         if (use_subshell){
2509             prompt = strip_ctrl_codes (subshell_prompt);
2510             if (!prompt)
2511                 prompt = "";
2512         } else
2513 #endif /* HAVE_SUBSHELL_SUPPORT */
2514             prompt = (geteuid () == 0) ? "# " : "$ ";
2515
2516     /* Program main loop */
2517     do_nc ();
2518
2519     /* Save the tree store */
2520     tree_store_save ();
2521
2522     /* Virtual File System shutdown */
2523     vfs_shut ();
2524
2525     /* Delete list of all user groups */
2526     destroy_groups ();
2527
2528     flush_extension_file (); /* does only free memory */
2529
2530     endwin ();
2531 #ifdef HAVE_SLANG
2532     slang_shutdown ();
2533 #endif
2534
2535     if (console_flag && !(quit & SUBSHELL_EXIT))
2536         restore_console ();
2537     if (alternate_plus_minus)
2538         numeric_keypad_mode ();
2539
2540 #ifndef NATIVE_WIN32
2541     signal (SIGCHLD, SIG_DFL);  /* Disable the SIGCHLD handler */
2542 #endif
2543
2544     if (console_flag)
2545         handle_console (CONSOLE_DONE);
2546     putchar ('\n');  /* Hack to make shell's prompt start at left of screen */
2547
2548 #ifdef NATIVE_WIN32
2549     /* On NT, home_dir is malloced */
2550     g_free (home_dir);
2551 #endif
2552     if (print_last_wd) {
2553         if (print_last_revert || edit_one_file || view_one_file)
2554             write (stdout_fd, ".", 1);
2555         else
2556             write (stdout_fd, last_wd_string, strlen (last_wd_string));
2557         g_free (last_wd_string);
2558     }
2559
2560 #ifndef NATIVE_WIN32
2561     g_free (mc_home);
2562 #endif /* (NATIVE_WIN32) */
2563     done_key ();
2564 #ifdef HAVE_CHARSET
2565     free_codepages_list ();
2566 #endif
2567     if (this_dir)
2568         g_free (this_dir);
2569     if (other_dir)
2570         g_free (other_dir);
2571
2572     return 0;
2573 }