src/boxes.c

   1 /* Some misc dialog boxes for the program.
   2
   3    Copyright (C) 1994, 1995, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   4    2005, 2006 Free Software Foundation, Inc.
   5
   6    Authors: 1994, 1995 Miguel de Icaza
   7             1995 Jakub Jelinek
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23 #include <config.h>
  24
  25 #include <ctype.h>
  26 #include <signal.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32
  33 #include <mhl/memory.h>
  34 #include <mhl/string.h>
  35
  36 #include "global.h"
  37 #include "tty.h"
  38 #include "win.h"                /* Our window tools */
  39 #include "color.h"              /* Color definitions */
  40 #include "dialog.h"             /* The nice dialog manager */
  41 #include "widget.h"             /* The widgets for the nice dialog manager */
  42 #include "wtools.h"
  43 #include "setup.h"              /* For profile_name */
  44 #include "profile.h"            /* Load/save user formats */
  45 #include "key.h"                /* XCTRL and ALT macros  */
  46 #include "command.h"            /* For cmdline */
  47 #include "dir.h"
  48 #include "panel.h"
  49 #include "boxes.h"
  50 #include "main.h"               /* For the confirm_* variables */
  51 #include "tree.h"
  52 #include "layout.h"             /* for get_nth_panel_name proto */
  53 #include "background.h"         /* task_list */
  54
  55 #ifdef HAVE_CHARSET
  56 #include "charsets.h"
  57 #include "selcodepage.h"
  58 #endif
  59
  60 #ifdef USE_NETCODE
  61 #   include "../vfs/ftpfs.h"
  62 #endif
  63
  64 #ifdef USE_VFS
  65 #include "../vfs/gc.h"
  66 #endif
  67
  68 static int DISPLAY_X = 45, DISPLAY_Y = 14;
  69
  70 static Dlg_head *dd;
  71 static WRadio *my_radio;
  72 static WInput *user;
  73 static WInput *status;
  74 static WCheck *check_status;
  75 static int current_mode;
  76
  77 static char **displays_status;
  78
  79 /* Controls whether the array strings have been translated */
  80 static const char *displays [LIST_TYPES] = {
  81     N_("&Full file list"),
  82     N_("&Brief file list"),
  83     N_("&Long file list"),
  84     N_("&User defined:")
  85 };
  86
  87 /* Index in displays[] for "user defined" */
  88 #define USER_TYPE 3
  89
  90 static int user_hotkey = 'u';
  91
  92 static cb_ret_t
  93 display_callback (struct Dlg_head *h, dlg_msg_t msg, int parm)
  94 {
  95     switch (msg) {
  96     case DLG_UNFOCUS:
  97         if (dlg_widget_active (my_radio)) {
  98             assign_text (status, displays_status[my_radio->sel]);
  99             input_set_point (status, 0);
 100         }
 101         return MSG_HANDLED;
 102
 103     case DLG_KEY:
 104         if (parm == '\n') {
 105             if (dlg_widget_active (my_radio)) {
 106                 assign_text (status, displays_status[my_radio->sel]);
 107                 dlg_stop (h);
 108                 return MSG_HANDLED;
 109             }
 110
 111             if (dlg_widget_active (user)) {
 112                 h->ret_value = B_USER + 6;
 113                 dlg_stop (h);
 114                 return MSG_HANDLED;
 115             }
 116
 117             if (dlg_widget_active (status)) {
 118                 h->ret_value = B_USER + 7;
 119                 dlg_stop (h);
 120                 return MSG_HANDLED;
 121             }
 122         }
 123
 124         if (tolower (parm) == user_hotkey && dlg_widget_active (user)
 125             && dlg_widget_active (status)) {
 126             my_radio->sel = 3;
 127             dlg_select_widget (my_radio);       /* force redraw */
 128             dlg_select_widget (user);
 129             return MSG_HANDLED;
 130         }
 131         return MSG_NOT_HANDLED;
 132
 133     default:
 134         return default_dlg_callback (h, msg, parm);
 135     }
 136 }
 137
 138 static void
 139 display_init (int radio_sel, char *init_text, int _check_status,
 140               char **_status)
 141 {
 142     static const char *display_title = N_("Listing mode");
 143     static int i18n_displays_flag;
 144     const char *user_mini_status = _("user &Mini status");
 145     const char *ok_button = _("&OK");
 146     const char *cancel_button = _("&Cancel");
 147
 148     static int button_start = 30;
 149
 150     displays_status = _status;
 151
 152     if (!i18n_displays_flag) {
 153         int i, l, maxlen = 0;
 154         const char *cp;
 155
 156         display_title = _(display_title);
 157         for (i = 0; i < LIST_TYPES; i++) {
 158             displays[i] = _(displays[i]);
 159             if ((l = strlen (displays[i])) > maxlen)
 160                 maxlen = l;
 161         }
 162
 163         i = strlen (ok_button) + 5;
 164         l = strlen (cancel_button) + 3;
 165         l = max (i, l);
 166
 167         i = maxlen + l + 16;
 168         if (i > DISPLAY_X)
 169             DISPLAY_X = i;
 170
 171         i = strlen (user_mini_status) + 13;
 172         if (i > DISPLAY_X)
 173             DISPLAY_X = i;
 174
 175         i = strlen (display_title) + 10;
 176         if (i > DISPLAY_X)
 177             DISPLAY_X = i;
 178
 179         button_start = DISPLAY_X - l - 5;
 180
 181         /* get hotkey of user-defined format string */
 182         cp = strchr (displays[USER_TYPE], '&');
 183         if (cp != NULL && *++cp != '\0')
 184             user_hotkey = tolower ((unsigned char) *cp);
 185
 186         i18n_displays_flag = 1;
 187     }
 188     dd = create_dlg (0, 0, DISPLAY_Y, DISPLAY_X, dialog_colors,
 189                      display_callback, "[Listing Mode...]", display_title,
 190                      DLG_CENTER | DLG_REVERSE);
 191
 192     add_widget (dd,
 193                 button_new (4, button_start, B_CANCEL, NORMAL_BUTTON,
 194                             cancel_button, 0));
 195
 196     add_widget (dd,
 197                 button_new (3, button_start, B_ENTER, DEFPUSH_BUTTON,
 198                             ok_button, 0));
 199
 200     status =
 201         input_new (10, 9, INPUT_COLOR, DISPLAY_X - 14, _status[radio_sel],
 202                    "mini-input", INPUT_COMPLETE_DEFAULT);
 203     add_widget (dd, status);
 204     input_set_point (status, 0);
 205
 206     check_status =
 207         check_new (9, 5, _check_status, user_mini_status);
 208     add_widget (dd, check_status);
 209
 210     user =
 211         input_new (7, 9, INPUT_COLOR, DISPLAY_X - 14, init_text,
 212                    "user-fmt-input", INPUT_COMPLETE_DEFAULT);
 213     add_widget (dd, user);
 214     input_set_point (user, 0);
 215
 216     my_radio = radio_new (3, 5, LIST_TYPES, displays);
 217     my_radio->sel = my_radio->pos = current_mode;
 218     add_widget (dd, my_radio);
 219 }
 220
 221 int
 222 display_box (WPanel *panel, char **userp, char **minip, int *use_msformat, int num)
 223 {
 224     int result, i;
 225     char *section = NULL;
 226     const char *p;
 227
 228     if (!panel) {
 229         p = get_nth_panel_name (num);
 230         panel = g_new (WPanel, 1);
 231         panel->list_type = list_full;
 232         panel->user_format = g_strdup (DEFAULT_USER_FORMAT);
 233         panel->user_mini_status = 0;
 234         for (i = 0; i < LIST_TYPES; i++)
 235             panel->user_status_format[i] = g_strdup (DEFAULT_USER_FORMAT);
 236         section = g_strconcat ("Temporal:", p, (char *) NULL);
 237         if (!profile_has_section (section, profile_name)) {
 238             g_free (section);
 239             section = g_strdup (p);
 240         }
 241         panel_load_setup (panel, section);
 242         g_free (section);
 243     }
 244
 245     current_mode = panel->list_type;
 246     display_init (current_mode, panel->user_format,
 247         panel->user_mini_status, panel->user_status_format);
 248
 249     run_dlg (dd);
 250
 251     result = -1;
 252
 253     if (section) {
 254         g_free (panel->user_format);
 255         for (i = 0; i < LIST_TYPES; i++)
 256            g_free (panel->user_status_format [i]);
 257         g_free (panel);
 258     }
 259
 260     if (dd->ret_value != B_CANCEL){
 261         result = my_radio->sel;
 262         *userp = g_strdup (user->buffer);
 263         *minip = g_strdup (status->buffer);
 264         *use_msformat = check_status->state & C_BOOL;
 265     }
 266     destroy_dlg (dd);
 267
 268     return result;
 269 }
 270
 271 static int SORT_X = 60, SORT_Y = 14;
 272
 273 static const char *sort_orders_names [SORT_TYPES];
 274
 275 sortfn *
 276 sort_box (sortfn *sort_fn, int *reverse, int *case_sensitive, int *exec_first)
 277 {
 278     int i, r, l;
 279     sortfn *result;
 280     WCheck *c, *case_sense, *exec_ff;
 281
 282     const char *ok_button = _("&OK");
 283     const char *cancel_button = _("&Cancel");
 284     const char *reverse_label = _("&Reverse");
 285     const char *case_label = _("case sensi&tive");
 286     const char *sort_title = _("Sort order");
 287     const char *exec_label = _("Executable first");
 288
 289     static int i18n_sort_flag = 0, check_pos = 0, button_pos = 0;
 290
 291     if (!i18n_sort_flag) {
 292         int maxlen = 0;
 293         for (i = SORT_TYPES - 1; i >= 0; i--) {
 294             sort_orders_names[i] = _(sort_orders[i].sort_name);
 295             r = strlen (sort_orders_names[i]);
 296             if (r > maxlen)
 297                 maxlen = r;
 298         }
 299
 300         check_pos = maxlen + 9;
 301
 302         r = strlen (reverse_label) + 4;
 303         i = strlen (case_label) + 4;
 304         if (i > r)
 305             r = i;
 306
 307         l = strlen (ok_button) + 6;
 308         i = strlen (cancel_button) + 4;
 309         if (i > l)
 310             l = i;
 311
 312         i = check_pos + max (r, l) + 2;
 313
 314         if (i > SORT_X)
 315             SORT_X = i;
 316
 317         i = strlen (sort_title) + 6;
 318         if (i > SORT_X)
 319             SORT_X = i;
 320
 321         button_pos = SORT_X - l - 2;
 322
 323         i18n_sort_flag = 1;
 324     }
 325
 326     result = 0;
 327
 328     for (i = 0; i < SORT_TYPES; i++)
 329         if ((sortfn *) (sort_orders[i].sort_fn) == sort_fn) {
 330             current_mode = i;
 331             break;
 332         }
 333
 334     dd = create_dlg (0, 0, SORT_Y, SORT_X, dialog_colors, NULL,
 335                      "[Sort Order...]", sort_title, DLG_CENTER | DLG_REVERSE);
 336
 337     add_widget (dd,
 338                 button_new (10, button_pos, B_CANCEL, NORMAL_BUTTON,
 339                             cancel_button, 0));
 340
 341     add_widget (dd,
 342                 button_new (9, button_pos, B_ENTER, DEFPUSH_BUTTON,
 343                             ok_button, 0));
 344
 345     exec_ff = check_new (5, check_pos, *exec_first, exec_label);
 346     add_widget (dd, exec_ff);
 347     case_sense = check_new (4, check_pos, *case_sensitive, case_label);
 348     add_widget (dd, case_sense);
 349     c = check_new (3, check_pos, *reverse, reverse_label);
 350     add_widget (dd, c);
 351
 352     my_radio = radio_new (3, 3, SORT_TYPES, sort_orders_names);
 353     my_radio->sel = my_radio->pos = current_mode;
 354
 355     add_widget (dd, my_radio);
 356     run_dlg (dd);
 357
 358     r = dd->ret_value;
 359     if (r != B_CANCEL) {
 360         result = (sortfn *) sort_orders[my_radio->sel].sort_fn;
 361         *reverse = c->state & C_BOOL;
 362         *case_sensitive = case_sense->state & C_BOOL;
 363         *exec_first = exec_ff->state & C_BOOL;
 364     } else
 365         result = sort_fn;
 366     destroy_dlg (dd);
 367
 368     return result;
 369 }
 370
 371 #define CONFY 11
 372 #define CONFX 46
 373
 374 static int my_delete;
 375 static int my_directory_hotlist_delete;
 376 static int my_overwrite;
 377 static int my_execute;
 378 static int my_exit;
 379
 380 static QuickWidget conf_widgets [] = {
 381 { quick_button,   4, 6, 4, CONFY, N_("&Cancel"),
 382       0, B_CANCEL, 0, 0, NULL },
 383 { quick_button,   4, 6, 3, CONFY, N_("&OK"),
 384       0, B_ENTER, 0, 0, NULL },
 385
 386 { quick_checkbox, 1, 13, 7, CONFY, N_(" confirm di&Rectory hotlist delete "),
 387       11, 0, &my_directory_hotlist_delete, NULL, NULL },
 388 { quick_checkbox, 1, 13, 6, CONFY, N_(" confirm &Exit "),
 389       9, 0, &my_exit, 0, NULL },
 390 { quick_checkbox, 1, 13, 5, CONFY, N_(" confirm e&Xecute "),
 391       10, 0, &my_execute, 0, NULL },
 392 { quick_checkbox, 1, 13, 4, CONFY, N_(" confirm o&Verwrite "),
 393       10, 0, &my_overwrite, 0, NULL },
 394 { quick_checkbox, 1, 13, 3, CONFY, N_(" confirm &Delete "),
 395       9, 0, &my_delete, 0, NULL },
 396 NULL_QuickWidget
 397 };
 398
 399 static QuickDialog confirmation =
 400     { CONFX, CONFY, -1, -1, N_(" Confirmation "), "[Confirmation]",
 401     conf_widgets, 0
 402 };
 403
 404 void
 405 confirm_box (void)
 406 {
 407
 408 #ifdef ENABLE_NLS
 409         static int i18n_flag = 0;
 410
 411         if (!i18n_flag)
 412         {
 413                 register int i = sizeof(conf_widgets)/sizeof(QuickWidget) - 1;
 414                 int l1, maxlen = 0;
 415                 while (i--)
 416                 {
 417                         conf_widgets [i].text = _(conf_widgets [i].text);
 418                         l1 = strlen (conf_widgets [i].text) + 3;
 419                         if (l1 > maxlen)
 420                                 maxlen = l1;
 421                 }
 422
 423                 /*
 424                  * If buttons start on 4/6, checkboxes (with some add'l space)
 425                  * must take not more than it.
 426                  */
 427                 confirmation.xlen = (maxlen + 5) * 6 / 4;
 428
 429                 /*
 430                  * And this for the case when buttons with some space to the right
 431                  * do not fit within 2/6
 432                  */
 433                 l1 = strlen (conf_widgets [0].text) + 3;
 434                 i = strlen (conf_widgets [1].text) + 5;
 435                 if (i > l1)
 436                         l1 = i;
 437
 438                 i = (l1 + 3) * 6 / 2;
 439                 if (i > confirmation.xlen)
 440                         confirmation.xlen = i;
 441
 442                 confirmation.title = _(confirmation.title);
 443
 444                 i18n_flag = confirmation.i18n = 1;
 445         }
 446
 447 #endif /* ENABLE_NLS */
 448
 449     my_delete    = confirm_delete;
 450     my_overwrite = confirm_overwrite;
 451     my_execute   = confirm_execute;
 452     my_exit      = confirm_exit;
 453     my_directory_hotlist_delete = confirm_directory_hotlist_delete;
 454
 455     if (quick_dialog (&confirmation) != B_CANCEL){
 456         confirm_delete    = my_delete;
 457         confirm_overwrite = my_overwrite;
 458         confirm_execute   = my_execute;
 459         confirm_exit      = my_exit;
 460         confirm_directory_hotlist_delete = my_directory_hotlist_delete;
 461     }
 462 }
 463
 464 #define DISPY 11
 465 #define DISPX 46
 466
 467
 468 #ifndef HAVE_CHARSET
 469
 470 static int new_mode;
 471 static int new_meta;
 472
 473 static const char *display_bits_str [] =
 474 { N_("Full 8 bits output"), N_("ISO 8859-1"), N_("7 bits") };
 475
 476 static QuickWidget display_widgets [] = {
 477 { quick_button,   4,  6,    4, DISPY, N_("&Cancel"),
 478       0, B_CANCEL, 0, 0, NULL },
 479 { quick_button,   4,  6,    3, DISPY, N_("&OK"),
 480       0, B_ENTER, 0, 0, NULL },
 481 { quick_checkbox, 4, DISPX, 7, DISPY, N_("F&ull 8 bits input"),
 482       0, 0, &new_meta, 0, NULL },
 483 { quick_radio,    4, DISPX, 3, DISPY, "", 3, 0,
 484       &new_mode, const_cast(char **, display_bits_str), NULL },
 485 NULL_QuickWidget
 486 };
 487
 488 static QuickDialog display_bits =
 489 { DISPX, DISPY, -1, -1, N_(" Display bits "), "[Display bits]",
 490   display_widgets, 0 };
 491
 492 void
 493 display_bits_box (void)
 494 {
 495     int current_mode;
 496
 497 #ifdef ENABLE_NLS
 498         static int i18n_flag = 0;
 499         if (!i18n_flag)
 500         {
 501                 register int i;
 502                 int l1, maxlen = 0;
 503                 for (i = 0; i < 3; i++)
 504                 {
 505                         display_widgets [i].text = _(display_widgets[i].text);
 506                         display_bits_str [i] = _(display_bits_str [i]);
 507                         l1 = strlen (display_bits_str [i]);
 508                         if (l1 > maxlen)
 509                                 maxlen = l1;
 510                 }
 511                 l1 = strlen (display_widgets [2].text);
 512                 if (l1 > maxlen)
 513                         maxlen = l1;
 514
 515
 516                 display_bits.xlen = (maxlen + 5) * 6 / 4;
 517
 518                 /* See above confirm_box */
 519                 l1 = strlen (display_widgets [0].text) + 3;
 520                 i = strlen (display_widgets [1].text) + 5;
 521                 if (i > l1)
 522                         l1 = i;
 523
 524                 i = (l1 + 3) * 6 / 2;
 525                 if (i > display_bits.xlen)
 526                         display_bits.xlen = i;
 527
 528                 display_bits.title = _(display_bits.title);
 529                 i18n_flag = display_bits.i18n = 1;
 530         }
 531
 532 #endif /* ENABLE_NLS */
 533
 534     if (full_eight_bits)
 535         current_mode = 0;
 536     else if (eight_bit_clean)
 537         current_mode = 1;
 538     else
 539         current_mode = 2;
 540
 541     display_widgets [3].value = current_mode;
 542     new_meta = !use_8th_bit_as_meta;
 543     if (quick_dialog (&display_bits) != B_ENTER)
 544             return;
 545
 546     eight_bit_clean = new_mode < 2;
 547     full_eight_bits = new_mode == 0;
 548 #ifndef HAVE_SLANG
 549     meta (stdscr, eight_bit_clean);
 550 #else
 551     SLsmg_Display_Eight_Bit = full_eight_bits ? 128 : 160;
 552 #endif
 553     use_8th_bit_as_meta = !new_meta;
 554 }
 555
 556
 557 #else /* HAVE_CHARSET */
 558
 559
 560 static int new_display_codepage;
 561
 562 static WLabel *cplabel;
 563 static WCheck *inpcheck;
 564
 565 static int
 566 sel_charset_button (int action)
 567 {
 568     const char *cpname;
 569     char buf[64];
 570     new_display_codepage = select_charset (new_display_codepage, 1);
 571     cpname = (new_display_codepage < 0)
 572         ? _("Other 8 bit")
 573         : codepages[new_display_codepage].name;
 574
 575     /* avoid strange bug with label repainting */
 576     g_snprintf (buf, sizeof (buf), "%-27s", cpname);
 577     label_set_text (cplabel, buf);
 578     return 0;
 579 }
 580
 581 static Dlg_head *
 582 init_disp_bits_box (void)
 583 {
 584     const char *cpname;
 585     Dlg_head *dbits_dlg;
 586
 587     do_refresh ();
 588
 589     dbits_dlg =
 590         create_dlg (0, 0, DISPY, DISPX, dialog_colors, NULL,
 591                     "[Display bits]", _(" Display bits "), DLG_CENTER | DLG_REVERSE);
 592
 593     add_widget (dbits_dlg,
 594                 label_new (3, 4, _("Input / display codepage:")));
 595
 596     cpname = (new_display_codepage < 0)
 597         ? _("Other 8 bit")
 598         : codepages[new_display_codepage].name;
 599     cplabel = label_new (4, 4, cpname);
 600     add_widget (dbits_dlg, cplabel);
 601
 602     add_widget (dbits_dlg,
 603                 button_new (DISPY - 3, DISPX / 2 + 3, B_CANCEL,
 604                             NORMAL_BUTTON, _("&Cancel"), 0));
 605     add_widget (dbits_dlg,
 606                 button_new (DISPY - 3, 7, B_ENTER, NORMAL_BUTTON, _("&OK"),
 607                             0));
 608
 609     inpcheck =
 610         check_new (6, 4, !use_8th_bit_as_meta, _("F&ull 8 bits input"));
 611     add_widget (dbits_dlg, inpcheck);
 612
 613     cpname = _("&Select");
 614     add_widget (dbits_dlg,
 615                 button_new (4, DISPX - 8 - strlen (cpname), B_USER,
 616                             NORMAL_BUTTON, cpname, sel_charset_button));
 617
 618     return dbits_dlg;
 619 }
 620
 621 void
 622 display_bits_box (void)
 623 {
 624     Dlg_head *dbits_dlg;
 625     new_display_codepage = display_codepage;
 626
 627     application_keypad_mode ();
 628     dbits_dlg = init_disp_bits_box ();
 629
 630     run_dlg (dbits_dlg);
 631
 632     if (dbits_dlg->ret_value == B_ENTER) {
 633         const char *errmsg;
 634         display_codepage = new_display_codepage;
 635         errmsg =
 636             init_translation_table (source_codepage, display_codepage);
 637         if (errmsg)
 638             message (D_ERROR, MSG_ERROR, "%s", errmsg);
 639 #ifndef HAVE_SLANG
 640         meta (stdscr, display_codepage != 0);
 641 #else
 642         SLsmg_Display_Eight_Bit = (display_codepage != 0
 643                                    && display_codepage != 1) ? 128 : 160;
 644 #endif
 645         use_8th_bit_as_meta = !(inpcheck->state & C_BOOL);
 646     }
 647     destroy_dlg (dbits_dlg);
 648     repaint_screen ();
 649 }
 650
 651 #endif /* HAVE_CHARSET */
 652
 653
 654 #define TREE_Y 20
 655 #define TREE_X 60
 656
 657 static cb_ret_t
 658 tree_callback (struct Dlg_head *h, dlg_msg_t msg, int parm)
 659 {
 660     switch (msg) {
 661
 662     case DLG_POST_KEY:
 663         /* The enter key will be processed by the tree widget */
 664         if (parm == '\n') {
 665             h->ret_value = B_ENTER;
 666             dlg_stop (h);
 667         }
 668         return MSG_HANDLED;
 669
 670     default:
 671         return default_dlg_callback (h, msg, parm);
 672     }
 673 }
 674
 675 /* Show tree in a box, not on a panel */
 676 char *
 677 tree_box (const char *current_dir)
 678 {
 679     WTree    *mytree;
 680     Dlg_head *dlg;
 681     char     *val;
 682     WButtonBar *bar;
 683
 684     /* Create the components */
 685     dlg = create_dlg (0, 0, TREE_Y, TREE_X, dialog_colors,
 686                       tree_callback, "[Directory Tree]", NULL, DLG_CENTER | DLG_REVERSE);
 687     mytree = tree_new (0, 2, 2, TREE_Y - 6, TREE_X - 5);
 688     add_widget (dlg, mytree);
 689     bar = buttonbar_new(1);
 690     add_widget (dlg, bar);
 691     ((Widget *) bar)->x = 0;
 692     ((Widget *) bar)->y = LINES - 1;
 693
 694     run_dlg (dlg);
 695     if (dlg->ret_value == B_ENTER)
 696         val = g_strdup (tree_selected_name (mytree));
 697     else
 698         val = 0;
 699
 700     destroy_dlg (dlg);
 701     return val;
 702 }
 703
 704 #ifdef USE_VFS
 705
 706 #if defined(USE_NETCODE)
 707 #define VFSY 17
 708 #define VFS_WIDGETBASE 10
 709 #else
 710 #define VFSY 8
 711 #define VFS_WIDGETBASE 0
 712 #endif
 713
 714 #define VFSX 56
 715
 716 static char *ret_timeout;
 717
 718 #if defined(USE_NETCODE)
 719 static char *ret_passwd;
 720 static char *ret_directory_timeout;
 721 static char *ret_ftp_proxy;
 722 static int ret_use_netrc;
 723 static int ret_ftpfs_use_passive_connections;
 724 static int ret_ftpfs_use_passive_connections_over_proxy;
 725 #endif
 726
 727 static QuickWidget confvfs_widgets [] = {
 728 { quick_button,   30,  VFSX,    VFSY - 3, VFSY, N_("&Cancel"),
 729       0, B_CANCEL, 0, 0, NULL },
 730 { quick_button,   12, VFSX,    VFSY - 3, VFSY, N_("&OK"),
 731       0, B_ENTER, 0, 0, NULL },
 732 #if defined(USE_NETCODE)
 733 { quick_checkbox,  4, VFSX, 12, VFSY, N_("Use passive mode over pro&xy"), 0, 0,
 734       &ret_ftpfs_use_passive_connections_over_proxy, 0, NULL },
 735 { quick_checkbox,  4, VFSX, 11, VFSY, N_("Use &passive mode"), 0, 0,
 736       &ret_ftpfs_use_passive_connections, 0, NULL },
 737 { quick_checkbox,  4, VFSX, 10, VFSY, N_("&Use ~/.netrc"), 0, 0,
 738       &ret_use_netrc, 0, NULL },
 739 { quick_input,     4, VFSX, 9, VFSY, "", 48, 0, 0, &ret_ftp_proxy,
 740       "input-ftp-proxy" },
 741 { quick_checkbox,  4, VFSX, 8, VFSY, N_("&Always use ftp proxy"), 0, 0,
 742       &ftpfs_always_use_proxy, 0, NULL },
 743 { quick_label,    49, VFSX, 7, VFSY, N_("sec"),
 744       0, 0, 0, 0, NULL },
 745 { quick_input,    38, VFSX, 7, VFSY, "", 10, 0, 0, &ret_directory_timeout,
 746       "input-timeout" },
 747 { quick_label,     4, VFSX, 7, VFSY, N_("ftpfs directory cache timeout:"),
 748       0, 0, 0, 0, NULL },
 749 { quick_input,     4, VFSX, 6, VFSY, "", 48, 0, 0, &ret_passwd,
 750       "input-passwd" },
 751 { quick_label,     4, VFSX, 5, VFSY, N_("ftp anonymous password:"),
 752       0, 0, 0, 0, NULL },
 753 #endif
 754 { quick_label,    49, VFSX, 3, VFSY, "sec",
 755       0, 0, 0, 0, NULL },
 756 { quick_input,    38, VFSX, 3, VFSY, "", 10, 0, 0, &ret_timeout,
 757       "input-timo-vfs" },
 758 { quick_label,    4,  VFSX, 3, VFSY, N_("Timeout for freeing VFSs:"),
 759       0, 0, 0, 0, NULL },
 760 NULL_QuickWidget
 761 };
 762
 763 static QuickDialog confvfs_dlg =
 764     { VFSX, VFSY, -1, -1, N_(" Virtual File System Setting "),
 765 "[Virtual FS]", confvfs_widgets, 0 };
 766
 767 void
 768 configure_vfs (void)
 769 {
 770     char buffer2[BUF_TINY];
 771 #if defined(USE_NETCODE)
 772     char buffer3[BUF_TINY];
 773
 774     ret_use_netrc = use_netrc;
 775     ret_ftpfs_use_passive_connections = ftpfs_use_passive_connections;
 776     ret_ftpfs_use_passive_connections_over_proxy = ftpfs_use_passive_connections_over_proxy;
 777     g_snprintf(buffer3, sizeof (buffer3), "%i", ftpfs_directory_timeout);
 778     confvfs_widgets[8].text = buffer3;
 779     confvfs_widgets[10].text = ftpfs_anonymous_passwd;
 780     confvfs_widgets[5].text = ftpfs_proxy_host;
 781 #endif
 782     g_snprintf (buffer2, sizeof (buffer2), "%i", vfs_timeout);
 783     confvfs_widgets [3 + VFS_WIDGETBASE].text = buffer2;
 784
 785     if (quick_dialog (&confvfs_dlg) != B_CANCEL) {
 786         vfs_timeout = atoi (ret_timeout);
 787         g_free (ret_timeout);
 788         if (vfs_timeout < 0 || vfs_timeout > 10000)
 789             vfs_timeout = 10;
 790 #if defined(USE_NETCODE)
 791         g_free (ftpfs_anonymous_passwd);
 792         ftpfs_anonymous_passwd = ret_passwd;
 793         g_free (ftpfs_proxy_host);
 794         ftpfs_proxy_host = ret_ftp_proxy;
 795         ftpfs_directory_timeout = atoi(ret_directory_timeout);
 796         use_netrc = ret_use_netrc;
 797         ftpfs_use_passive_connections = ret_ftpfs_use_passive_connections;
 798         ftpfs_use_passive_connections_over_proxy = ret_ftpfs_use_passive_connections_over_proxy;
 799         g_free (ret_directory_timeout);
 800 #endif
 801     }
 802 }
 803
 804 #endif  /* USE_VFS */
 805
 806 char *
 807 cd_dialog (void)
 808 {
 809     QuickDialog Quick_input;
 810     QuickWidget quick_widgets [] = {
 811         { quick_input,  6, 57, 2, 0, "", 50, 0, 0, 0, "input" },
 812         { quick_label,  3, 57, 2, 0, "",  0, 0, 0, 0, NULL },
 813         NULL_QuickWidget
 814     };
 815     char *my_str;
 816     int len;
 817
 818     Quick_input.xlen  = 57;
 819     Quick_input.title = _("Quick cd");
 820     Quick_input.help  = "[Quick cd]";
 821     quick_widgets [0].value = 2; /* want cd like completion */
 822     quick_widgets [1].text = _("cd");
 823     quick_widgets [1].y_divisions =
 824         quick_widgets [0].y_divisions = Quick_input.ylen = 5;
 825
 826     len = strlen (quick_widgets [1].text);
 827
 828     quick_widgets [0].relative_x =
 829         quick_widgets [1].relative_x + len + 1;
 830
 831     Quick_input.xlen = len + quick_widgets [0].hotkey_pos + 7;
 832         quick_widgets [0].x_divisions =
 833                 quick_widgets [1].x_divisions = Quick_input.xlen;
 834
 835     Quick_input.i18n = 1;
 836     Quick_input.xpos = 2;
 837     Quick_input.ypos = LINES - 2 - Quick_input.ylen;
 838     quick_widgets [0].str_result = &my_str;
 839
 840     Quick_input.widgets = quick_widgets;
 841     if (quick_dialog (&Quick_input) != B_CANCEL){
 842         return my_str;
 843     } else
 844         return 0;
 845 }
 846
 847 void
 848 symlink_dialog (const char *existing, const char *new, char **ret_existing,
 849                 char **ret_new)
 850 {
 851     QuickDialog Quick_input;
 852     QuickWidget quick_widgets[] = {
 853         {quick_button, 50, 80, 6, 8, N_("&Cancel"), 0, B_CANCEL, 0, 0,
 854          NULL},
 855         {quick_button, 16, 80, 6, 8, N_("&OK"), 0, B_ENTER, 0, 0, NULL},
 856         {quick_input, 4, 80, 5, 8, "", 58, 0, 0, 0, "input-1"},
 857         {quick_label, 4, 80, 4, 8, N_("Symbolic link filename:"), 0, 0, 0,
 858          0, NULL},
 859         {quick_input, 4, 80, 3, 8, "", 58, 0, 0, 0, "input-2"},
 860         {quick_label, 4, 80, 2, 8,
 861          N_("Existing filename (filename symlink will point to):"), 0, 0,
 862          0, 0, NULL},
 863         NULL_QuickWidget
 864     };
 865
 866     Quick_input.xlen = 64;
 867     Quick_input.ylen = 12;
 868     Quick_input.title = N_("Symbolic link");
 869     Quick_input.help = "[File Menu]";
 870     Quick_input.i18n = 0;
 871     quick_widgets[2].text = new;
 872     quick_widgets[4].text = existing;
 873     Quick_input.xpos = -1;
 874     quick_widgets[2].str_result = ret_new;
 875     quick_widgets[4].str_result = ret_existing;
 876
 877     Quick_input.widgets = quick_widgets;
 878     if (quick_dialog (&Quick_input) == B_CANCEL) {
 879         *ret_new = NULL;
 880         *ret_existing = NULL;
 881     }
 882 }
 883
 884 #ifdef WITH_BACKGROUND
 885 #define B_STOP   (B_USER+1)
 886 #define B_RESUME (B_USER+2)
 887 #define B_KILL   (B_USER+3)
 888
 889 static int JOBS_X = 60;
 890 #define JOBS_Y 15
 891 static WListbox *bg_list;
 892 static Dlg_head *jobs_dlg;
 893
 894 static void
 895 jobs_fill_listbox (void)
 896 {
 897     static const char *state_str [2];
 898     TaskList *tl = task_list;
 899
 900     if (!state_str [0]){
 901        state_str [0] = _("Running ");
 902        state_str [1] = _("Stopped");
 903     }
 904
 905     while (tl){
 906         char *s;
 907
 908         s = g_strconcat (state_str [tl->state], " ", tl->info, (char *) NULL);
 909         listbox_add_item (bg_list, LISTBOX_APPEND_AT_END, 0, s, (void *) tl);
 910         g_free (s);
 911         tl = tl->next;
 912     }
 913 }
 914
 915 static int
 916 task_cb (int action)
 917 {
 918     TaskList *tl;
 919     int sig = 0;
 920
 921     if (!bg_list->list)
 922         return 0;
 923
 924     /* Get this instance information */
 925     tl = (TaskList *) bg_list->current->data;
 926
 927 #  ifdef SIGTSTP
 928     if (action == B_STOP){
 929         sig   = SIGSTOP;
 930         tl->state = Task_Stopped;
 931     } else if (action == B_RESUME){
 932         sig   = SIGCONT;
 933         tl->state = Task_Running;
 934     } else
 935 #  endif
 936     if (action == B_KILL){
 937         sig = SIGKILL;
 938     }
 939
 940     if (sig == SIGINT)
 941         unregister_task_running (tl->pid, tl->fd);
 942
 943     kill (tl->pid, sig);
 944     listbox_remove_list (bg_list);
 945     jobs_fill_listbox ();
 946
 947     /* This can be optimized to just redraw this widget :-) */
 948     dlg_redraw (jobs_dlg);
 949
 950     return 0;
 951 }
 952
 953 static struct
 954 {
 955         const char* name;
 956         int xpos;
 957         int value;
 958         int (*callback)(int);
 959 }
 960 job_buttons [] =
 961 {
 962         {N_("&Stop"),   3,  B_STOP,   task_cb},
 963         {N_("&Resume"), 12, B_RESUME, task_cb},
 964         {N_("&Kill"),   23, B_KILL,   task_cb},
 965         {N_("&OK"),     35, B_CANCEL, NULL   }
 966 };
 967
 968 void
 969 jobs_cmd (void)
 970 {
 971         register int i;
 972         int n_buttons = sizeof (job_buttons) / sizeof (job_buttons[0]);
 973
 974 #ifdef ENABLE_NLS
 975         static int i18n_flag = 0;
 976         if (!i18n_flag)
 977         {
 978                 int startx = job_buttons [0].xpos;
 979                 int len;
 980
 981                 for (i = 0; i < n_buttons; i++)
 982                 {
 983                         job_buttons [i].name = _(job_buttons [i].name);
 984
 985                         len = strlen (job_buttons [i].name) + 4;
 986                         JOBS_X = max (JOBS_X, startx + len + 3);
 987
 988                         job_buttons [i].xpos = startx;
 989                         startx += len;
 990                 }
 991
 992                 /* Last button - Ok a.k.a. Cancel :) */
 993                 job_buttons [n_buttons - 1].xpos =
 994                         JOBS_X - strlen (job_buttons [n_buttons - 1].name) - 7;
 995
 996                 i18n_flag = 1;
 997         }
 998 #endif /* ENABLE_NLS */
 999
1000     jobs_dlg = create_dlg (0, 0, JOBS_Y, JOBS_X, dialog_colors, NULL,
1001                            "[Background jobs]", _("Background Jobs"),
1002                            DLG_CENTER | DLG_REVERSE);
1003
1004     bg_list = listbox_new (2, 3, JOBS_X-7, JOBS_Y-9, 0);
1005     add_widget (jobs_dlg, bg_list);
1006
1007         i = n_buttons;
1008         while (i--)
1009         {
1010                 add_widget (jobs_dlg, button_new (JOBS_Y-4,
1011                         job_buttons [i].xpos, job_buttons [i].value,
1012                         NORMAL_BUTTON, job_buttons [i].name,
1013                         job_buttons [i].callback));
1014         }
1015
1016     /* Insert all of task information in the list */
1017     jobs_fill_listbox ();
1018     run_dlg (jobs_dlg);
1019
1020     destroy_dlg (jobs_dlg);
1021 }
1022 #endif /* WITH_BACKGROUND */
1023
1024 #ifdef WITH_SMBFS
1025 struct smb_authinfo *
1026 vfs_smb_get_authinfo (const char *host, const char *share, const char *domain,
1027                       const char *user)
1028 {
1029     static int dialog_x = 44;
1030     enum { b0 = 3, dialog_y = 12};
1031     struct smb_authinfo *return_value;
1032     static const char* labs[] = {N_("Domain:"), N_("Username:"), N_("Password:")};
1033     static const char* buts[] = {N_("&OK"), N_("&Cancel")};
1034     static int ilen = 30, istart = 14;
1035     static int b2 = 30;
1036     char *title;
1037     WInput *in_password;
1038     WInput *in_user;
1039     WInput *in_domain;
1040     Dlg_head *auth_dlg;
1041
1042 #ifdef ENABLE_NLS
1043     static int i18n_flag = 0;
1044
1045     if (!i18n_flag)
1046     {
1047         register int i = sizeof(labs)/sizeof(labs[0]);
1048         int l1, maxlen = 0;
1049
1050         while (i--)
1051         {
1052             l1 = strlen (labs [i] = _(labs [i]));
1053             if (l1 > maxlen)
1054                 maxlen = l1;
1055         }
1056         i = maxlen + ilen + 7;
1057         if (i > dialog_x)
1058             dialog_x = i;
1059
1060         for (i = sizeof(buts)/sizeof(buts[0]), l1 = 0; i--; )
1061         {
1062             l1 += strlen (buts [i] = _(buts [i]));
1063         }
1064         l1 += 15;
1065         if (l1 > dialog_x)
1066             dialog_x = l1;
1067
1068         ilen = dialog_x - 7 - maxlen; /* for the case of very long buttons :) */
1069         istart = dialog_x - 3 - ilen;
1070
1071         b2 = dialog_x - (strlen(buts[1]) + 6);
1072
1073         i18n_flag = 1;
1074     }
1075
1076 #endif /* ENABLE_NLS */
1077
1078     if (!domain)
1079     domain = "";
1080     if (!user)
1081     user = "";
1082
1083     title = g_strdup_printf (_("Password for \\\\%s\\%s"), host, share);
1084
1085     auth_dlg = create_dlg (0, 0, dialog_y, dialog_x, dialog_colors, NULL,
1086                            "[Smb Authinfo]", title, DLG_CENTER | DLG_REVERSE);
1087
1088     g_free (title);
1089
1090     in_user  = input_new (5, istart, INPUT_COLOR, ilen, user, "auth_name", INPUT_COMPLETE_DEFAULT);
1091     add_widget (auth_dlg, in_user);
1092
1093     in_domain = input_new (3, istart, INPUT_COLOR, ilen, domain, "auth_domain", INPUT_COMPLETE_DEFAULT);
1094     add_widget (auth_dlg, in_domain);
1095     add_widget (auth_dlg, button_new (9, b2, B_CANCEL, NORMAL_BUTTON,
1096                  buts[1], 0));
1097     add_widget (auth_dlg, button_new (9, b0, B_ENTER, DEFPUSH_BUTTON,
1098                  buts[0], 0));
1099
1100     in_password  = input_new (7, istart, INPUT_COLOR, ilen, "", "auth_password", INPUT_COMPLETE_DEFAULT);
1101     in_password->completion_flags = 0;
1102     in_password->is_password = 1;
1103     add_widget (auth_dlg, in_password);
1104
1105     add_widget (auth_dlg, label_new (7, 3, labs[2]));
1106     add_widget (auth_dlg, label_new (5, 3, labs[1]));
1107     add_widget (auth_dlg, label_new (3, 3, labs[0]));
1108
1109     run_dlg (auth_dlg);
1110
1111     switch (auth_dlg->ret_value) {
1112     case B_CANCEL:
1113         return_value = 0;
1114         break;
1115     default:
1116         return_value = g_new (struct smb_authinfo, 1);
1117         if (return_value) {
1118             return_value->host = g_strdup (host);
1119             return_value->share = g_strdup (share);
1120             return_value->domain = g_strdup (in_domain->buffer);
1121             return_value->user = g_strdup (in_user->buffer);
1122             return_value->password = g_strdup (in_password->buffer);
1123         }
1124     }
1125
1126     destroy_dlg (auth_dlg);
1127
1128     return return_value;
1129 }
1130 #endif /* WITH_SMBFS */