src/filegui.c

   1 /* File management GUI for the text mode edition
   2  *
   3  * Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
   4  * 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
   5  *
   6  * Written by: 1994, 1995       Janne Kukonlehto
   7  *             1994, 1995       Fred Leeflang
   8  *             1994, 1995, 1996 Miguel de Icaza
   9  *             1995, 1996       Jakub Jelinek
  10  *             1997             Norbert Warmuth
  11  *             1998             Pavel Machek
  12  *             2009             Slava Zanko
  13  *
  14  * The copy code was based in GNU's cp, and was written by:
  15  * Torbjorn Granlund, David MacKenzie, and Jim Meyering.
  16  *
  17  * The move code was based in GNU's mv, and was written by:
  18  * Mike Parker and David MacKenzie.
  19  *
  20  * Janne Kukonlehto added much error recovery to them for being used
  21  * in an interactive program.
  22  *
  23  * This program is free software; you can redistribute it and/or modify
  24  * it under the terms of the GNU General Public License as published by
  25  * the Free Software Foundation; either version 2 of the License, or
  26  * (at your option) any later version.
  27  *
  28  * This program is distributed in the hope that it will be useful,
  29  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  30  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31  * GNU General Public License for more details.
  32  *
  33  * You should have received a copy of the GNU General Public License
  34  * along with this program; if not, write to the Free Software
  35  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  36  */
  37
  38 /*
  39  * Please note that all dialogs used here must be safe for background
  40  * operations.
  41  */
  42
  43 /** \file  filegui.c
  44  *  \brief Source: file management GUI for the text mode edition
  45  */
  46
  47 /* {{{ Include files */
  48
  49 #include <config.h>
  50
  51 #include <errno.h>
  52 #include <ctype.h>
  53 #include <stdio.h>
  54 #include <string.h>
  55 #include <sys/types.h>
  56 #include <sys/stat.h>
  57
  58 #if defined(STAT_STATVFS) \
  59      && (defined(HAVE_STRUCT_STATVFS_F_BASETYPE) \
  60          || defined(HAVE_STRUCT_STATVFS_F_FSTYPENAME))
  61 #   include <sys/statvfs.h>
  62 #   define STRUCT_STATFS struct statvfs
  63 #   define STATFS statvfs
  64 #elif defined(HAVE_STATFS) && !defined(STAT_STATFS4)
  65 #   ifdef HAVE_SYS_VFS_H
  66 #      include <sys/vfs.h>
  67 #   elif defined(HAVE_SYS_MOUNT_H) && defined(HAVE_SYS_PARAM_H)
  68 #      include <sys/param.h>
  69 #      include <sys/mount.h>
  70 #   elif defined(HAVE_SYS_STATFS_H)
  71 #      include <sys/statfs.h>
  72 #   endif
  73 #   define STRUCT_STATFS struct statfs
  74 #   define STATFS statfs
  75 #endif
  76
  77 #include <unistd.h>
  78
  79 #include "lib/global.h"
  80
  81 #include "lib/tty/key.h"        /* tty_get_event */
  82 #include "lib/mcconfig.h"
  83 #include "lib/search.h"
  84 #include "lib/vfs/mc-vfs/vfs.h"
  85 #include "lib/strescape.h"
  86 #include "lib/strutil.h"
  87
  88 #include "setup.h"              /* verbose */
  89 #include "dialog.h"             /* do_refresh() */
  90 #include "widget.h"             /* WLabel */
  91 #include "main-widgets.h"
  92 #include "main.h"               /* the_hint */
  93 #include "wtools.h"             /* QuickDialog */
  94 #include "panel.h"              /* current_panel */
  95 #include "fileopctx.h"          /* FILE_CONT */
  96 #include "filegui.h"
  97
  98 /* }}} */
  99 /* *INDENT-OFF* */
 100 typedef enum {
 101     MSDOS_SUPER_MAGIC     = 0x4d44,
 102     NTFS_SB_MAGIC         = 0x5346544e,
 103     NTFS_3G_MAGIC         = 0x65735546,
 104     PROC_SUPER_MAGIC      = 0x9fa0,
 105     SMB_SUPER_MAGIC       = 0x517B,
 106     NCP_SUPER_MAGIC       = 0x564c,
 107     USBDEVICE_SUPER_MAGIC = 0x9fa2
 108 } filegui_nonattrs_fs_t;
 109 /* *INDENT-ON* */
 110
 111 /* Hack: the vfs code should not rely on this */
 112 #define WITH_FULL_PATHS 1
 113
 114 /* Used for button result values */
 115 typedef enum
 116 {
 117     REPLACE_YES = B_USER,
 118     REPLACE_NO,
 119     REPLACE_APPEND,
 120     REPLACE_ALWAYS,
 121     REPLACE_UPDATE,
 122     REPLACE_NEVER,
 123     REPLACE_ABORT,
 124     REPLACE_SIZE,
 125     REPLACE_REGET
 126 } replace_action_t;
 127
 128 /* This structure describes the UI and internal data required by a file
 129  * operation context.
 130  */
 131 typedef struct
 132 {
 133     /* ETA and bps */
 134     gboolean showing_eta;
 135     gboolean showing_bps;
 136
 137     /* Dialog and widgets for the operation progress window */
 138     Dlg_head *op_dlg;
 139     WLabel *file_string[2];
 140     WLabel *file_label[2];
 141     WGauge *progress_file_gauge;
 142     WLabel *progress_file_label;
 143
 144     WGauge *progress_total_gauge;
 145
 146     WLabel *total_files_processed_label;
 147     WLabel *time_label;
 148     WLabel *total_bytes_label;
 149
 150     /* Query replace dialog */
 151     Dlg_head *replace_dlg;
 152     const char *replace_filename;
 153     replace_action_t replace_result;
 154
 155     struct stat *s_stat, *d_stat;
 156 } FileOpContextUI;
 157
 158
 159 /* Used to save the hint line */
 160 static int last_hint_line;
 161
 162 /* File operate window sizes */
 163 #define WX 58
 164 #define WY 11
 165 #define FCOPY_LABEL_X 3
 166
 167 static gboolean
 168 filegui__check_attrs_on_fs (const char *fs_path)
 169 {
 170 #ifdef STATFS
 171     STRUCT_STATFS stfs;
 172
 173     if (!setup_copymove_persistent_attr)
 174         return FALSE;
 175
 176     if (STATFS (fs_path, &stfs) != 0)
 177         return TRUE;
 178
 179 # ifdef __linux__
 180     switch ((filegui_nonattrs_fs_t) stfs.f_type)
 181     {
 182     case MSDOS_SUPER_MAGIC:
 183     case NTFS_SB_MAGIC:
 184     case NTFS_3G_MAGIC:
 185     case PROC_SUPER_MAGIC:
 186     case SMB_SUPER_MAGIC:
 187     case NCP_SUPER_MAGIC:
 188     case USBDEVICE_SUPER_MAGIC:
 189         return FALSE;
 190     }
 191 # elif defined(HAVE_STRUCT_STATFS_F_FSTYPENAME) \
 192       || defined(HAVE_STRUCT_STATVFS_F_FSTYPENAME)
 193     if (!strcmp (stfs.f_fstypename, "msdos")
 194         || !strcmp (stfs.f_fstypename, "msdosfs")
 195         || !strcmp (stfs.f_fstypename, "ntfs")
 196         || !strcmp (stfs.f_fstypename, "procfs")
 197         || !strcmp (stfs.f_fstypename, "smbfs") || strstr (stfs.f_fstypename, "fusefs"))
 198         return FALSE;
 199 # elif defined(HAVE_STRUCT_STATVFS_F_BASETYPE)
 200     if (!strcmp (stfs.f_basetype, "pcfs")
 201         || !strcmp (stfs.f_basetype, "ntfs")
 202         || !strcmp (stfs.f_basetype, "proc")
 203         || !strcmp (stfs.f_basetype, "smbfs") || !strcmp (stfs.f_basetype, "fuse"))
 204         return FALSE;
 205 # endif
 206 #endif /* STATFS */
 207
 208     return TRUE;
 209 }
 210
 211 FileProgressStatus
 212 check_progress_buttons (FileOpContext * ctx)
 213 {
 214     int c;
 215     Gpm_Event event;
 216     FileOpContextUI *ui;
 217
 218     if (ctx->ui == NULL)
 219         return FILE_CONT;
 220
 221     ui = ctx->ui;
 222
 223     event.x = -1;               /* Don't show the GPM cursor */
 224     c = tty_get_event (&event, FALSE, FALSE);
 225     if (c == EV_NONE)
 226         return FILE_CONT;
 227
 228     /* Reinitialize to avoid old values after events other than
 229        selecting a button */
 230     ui->op_dlg->ret_value = FILE_CONT;
 231
 232     dlg_process_event (ui->op_dlg, c, &event);
 233     switch (ui->op_dlg->ret_value)
 234     {
 235     case FILE_SKIP:
 236         return FILE_SKIP;
 237     case B_CANCEL:
 238     case FILE_ABORT:
 239         return FILE_ABORT;
 240     default:
 241         return FILE_CONT;
 242     }
 243 }
 244
 245 /* {{{ File progress display routines */
 246
 247 void
 248 file_op_context_create_ui_without_init (FileOpContext * ctx, gboolean with_eta,
 249                                         filegui_dialog_type_t dialog_type)
 250 {
 251     FileOpContextUI *ui;
 252     int minus = 0, total_reserve = 0;
 253     const char *abort_button_label = N_("&Abort");
 254     const char *skip_button_label = N_("&Skip");
 255     int abort_button_width, skip_button_width, buttons_width;
 256     int dlg_width;
 257
 258     g_return_if_fail (ctx != NULL);
 259     g_return_if_fail (ctx->ui == NULL);
 260
 261 #ifdef ENABLE_NLS
 262     abort_button_label = _(abort_button_label);
 263     skip_button_label = _(skip_button_label);
 264 #endif
 265
 266     abort_button_width = str_term_width1 (abort_button_label) + 3;
 267     skip_button_width = str_term_width1 (skip_button_label) + 3;
 268     buttons_width = abort_button_width + skip_button_width + 2;
 269
 270     dlg_width = max (WX, buttons_width + 6);
 271
 272     ui = g_new0 (FileOpContextUI, 1);
 273     ctx->ui = ui;
 274
 275     ctx->dialog_type = dialog_type;
 276
 277     switch (dialog_type)
 278     {
 279     case FILEGUI_DIALOG_ONE_ITEM:
 280         total_reserve = 0;
 281         minus = verbose ? 0 : 2;
 282         break;
 283     case FILEGUI_DIALOG_MULTI_ITEM:
 284         total_reserve = 5;
 285         minus = verbose ? 0 : 7;
 286         break;
 287     case FILEGUI_DIALOG_DELETE_ITEM:
 288         total_reserve = -5;
 289         minus = 0;
 290         break;
 291     }
 292
 293     ctx->recursive_result = RECURSIVE_YES;
 294
 295     ui->replace_result = REPLACE_YES;
 296     ui->showing_eta = with_eta;
 297     ui->showing_bps = with_eta;
 298
 299     ui->op_dlg =
 300         create_dlg (0, 0, WY - minus + 1 + total_reserve, dlg_width,
 301                     dialog_colors, NULL, NULL, op_names[ctx->operation], DLG_CENTER | DLG_REVERSE);
 302
 303     last_hint_line = the_hint->widget.y;
 304     if ((ui->op_dlg->y + ui->op_dlg->lines) > last_hint_line)
 305         the_hint->widget.y = ui->op_dlg->y + ui->op_dlg->lines + 1;
 306
 307     add_widget (ui->op_dlg,
 308                 button_new (WY - minus - 2 + total_reserve,
 309                             dlg_width / 2 + 1, FILE_ABORT,
 310                             NORMAL_BUTTON, abort_button_label, NULL));
 311     add_widget (ui->op_dlg,
 312                 button_new (WY - minus - 2 + total_reserve,
 313                             dlg_width / 2 - 1 - skip_button_width, FILE_SKIP,
 314                             NORMAL_BUTTON, skip_button_label, NULL));
 315
 316
 317     if (verbose && dialog_type == FILEGUI_DIALOG_MULTI_ITEM)
 318     {
 319         add_widget (ui->op_dlg, hline_new (8, 1, dlg_width - 2));
 320
 321         add_widget (ui->op_dlg, ui->total_bytes_label = label_new (8, FCOPY_LABEL_X + 15, ""));
 322
 323         add_widget (ui->op_dlg, ui->progress_total_gauge =
 324                     gauge_new (9, FCOPY_LABEL_X + 3, 0, 100, 0));
 325
 326         add_widget (ui->op_dlg, ui->total_files_processed_label =
 327                     label_new (11, FCOPY_LABEL_X, ""));
 328
 329         add_widget (ui->op_dlg, ui->time_label = label_new (12, FCOPY_LABEL_X, ""));
 330     }
 331
 332     add_widget (ui->op_dlg, ui->progress_file_label = label_new (7, FCOPY_LABEL_X, ""));
 333
 334     add_widget (ui->op_dlg, ui->progress_file_gauge = gauge_new (6, FCOPY_LABEL_X + 3, 0, 100, 0));
 335
 336     add_widget (ui->op_dlg, ui->file_string[1] = label_new (5, FCOPY_LABEL_X, ""));
 337
 338     add_widget (ui->op_dlg, ui->file_label[1] = label_new (4, FCOPY_LABEL_X, ""));
 339     add_widget (ui->op_dlg, ui->file_string[0] = label_new (3, FCOPY_LABEL_X, ""));
 340     add_widget (ui->op_dlg, ui->file_label[0] = label_new (2, FCOPY_LABEL_X, ""));
 341
 342     if ((right_panel == current_panel)
 343         && !mc_config_get_bool (mc_main_config, "Layout", "classic_progressbar", TRUE))
 344     {
 345         ui->progress_file_gauge->from_left_to_right = FALSE;
 346         if (dialog_type == FILEGUI_DIALOG_MULTI_ITEM)
 347             ui->progress_total_gauge->from_left_to_right = FALSE;
 348     }
 349 }
 350
 351 void
 352 file_op_context_create_ui (FileOpContext * ctx, gboolean with_eta,
 353                            filegui_dialog_type_t dialog_type)
 354 {
 355     FileOpContextUI *ui;
 356
 357     g_return_if_fail (ctx != NULL);
 358     g_return_if_fail (ctx->ui == NULL);
 359
 360     file_op_context_create_ui_without_init (ctx, with_eta, dialog_type);
 361     ui = ctx->ui;
 362
 363     /* We will manage the dialog without any help, that's why
 364        we have to call init_dlg */
 365     init_dlg (ui->op_dlg);
 366     ui->op_dlg->running = 1;
 367 }
 368
 369 void
 370 file_op_context_destroy_ui (FileOpContext * ctx)
 371 {
 372     FileOpContextUI *ui;
 373
 374     g_return_if_fail (ctx != NULL);
 375
 376     if (ctx->ui)
 377     {
 378         ui = ctx->ui;
 379
 380         dlg_run_done (ui->op_dlg);
 381         destroy_dlg (ui->op_dlg);
 382         g_free (ui);
 383     }
 384
 385     the_hint->widget.y = last_hint_line;
 386
 387     ctx->ui = NULL;
 388 }
 389
 390 static void
 391 file_frmt_time (char *buffer, double eta_secs)
 392 {
 393     int eta_hours, eta_mins, eta_s;
 394     eta_hours = eta_secs / (60 * 60);
 395     eta_mins = (eta_secs - (eta_hours * 60 * 60)) / 60;
 396     eta_s = eta_secs - (eta_hours * 60 * 60 + eta_mins * 60);
 397     g_snprintf (buffer, BUF_TINY, _("%d:%02d.%02d"), eta_hours, eta_mins, eta_s);
 398 }
 399
 400 static void
 401 file_eta_prepare_for_show (char *buffer, double eta_secs, gboolean always_show)
 402 {
 403     char _fmt_buff[BUF_TINY];
 404     if (eta_secs <= 0.5 && !always_show)
 405     {
 406         *buffer = '\0';
 407         return;
 408     }
 409     if (eta_secs <= 0.5)
 410         eta_secs = 1;
 411     file_frmt_time (_fmt_buff, eta_secs);
 412     g_snprintf (buffer, BUF_TINY, _("ETA %s"), _fmt_buff);
 413 }
 414
 415 static void
 416 file_bps_prepare_for_show (char *buffer, long bps)
 417 {
 418     if (bps > 1024 * 1024)
 419     {
 420         g_snprintf (buffer, BUF_TINY, _("%.2f MB/s"), bps / (1024 * 1024.0));
 421     }
 422     else if (bps > 1024)
 423     {
 424         g_snprintf (buffer, BUF_TINY, _("%.2f KB/s"), bps / 1024.0);
 425     }
 426     else if (bps > 1)
 427     {
 428         g_snprintf (buffer, BUF_TINY, _("%ld B/s"), bps);
 429     }
 430     else
 431         *buffer = 0;
 432 }
 433
 434 /*
 435    show progressbar for file
 436  */
 437 void
 438 file_progress_show (FileOpContext * ctx, off_t done, off_t total,
 439                     const char *stalled_msg, gboolean force_update)
 440 {
 441     FileOpContextUI *ui;
 442     char buffer[BUF_TINY];
 443     char buffer2[BUF_TINY];
 444     char buffer3[BUF_TINY];
 445
 446     g_return_if_fail (ctx != NULL);
 447
 448     if (ctx->ui == NULL)
 449         return;
 450
 451     ui = ctx->ui;
 452
 453     if (!verbose)
 454         return;
 455
 456     if (total == 0)
 457     {
 458         gauge_show (ui->progress_file_gauge, 0);
 459         return;
 460     }
 461
 462     gauge_set_value (ui->progress_file_gauge, 1024, (int) (1024 * done / total));
 463     gauge_show (ui->progress_file_gauge, 1);
 464
 465     if (!force_update)
 466         return;
 467
 468     if (ui->showing_eta && ctx->eta_secs > 0.5)
 469     {
 470         file_eta_prepare_for_show (buffer2, ctx->eta_secs, FALSE);
 471         file_bps_prepare_for_show (buffer3, ctx->bps);
 472         g_snprintf (buffer, BUF_TINY, "%s (%s) %s", buffer2, buffer3, stalled_msg);
 473     }
 474     else
 475     {
 476         g_snprintf (buffer, BUF_TINY, "%s", stalled_msg);
 477     }
 478
 479     label_set_text (ui->progress_file_label, buffer);
 480 }
 481
 482 void
 483 file_progress_show_count (FileOpContext * ctx, off_t done, off_t total)
 484 {
 485     char buffer[BUF_TINY];
 486     FileOpContextUI *ui;
 487
 488     g_return_if_fail (ctx != NULL);
 489
 490     if (ctx->dialog_type != FILEGUI_DIALOG_MULTI_ITEM || ctx->ui == NULL)
 491         return;
 492
 493     ui = ctx->ui;
 494
 495     if (!verbose)
 496         return;
 497
 498     g_snprintf (buffer, BUF_TINY, _("Files processed: %llu of %llu"),
 499                 (unsigned long long) done, (unsigned long long) total);
 500
 501     label_set_text (ui->total_files_processed_label, buffer);
 502 }
 503
 504 void
 505 file_progress_show_total (FileOpTotalContext * tctx, FileOpContext * ctx, double copyed_bytes,
 506                           gboolean need_show_total_summary)
 507 {
 508     char buffer[BUF_TINY];
 509     char buffer2[BUF_TINY];
 510     char buffer3[BUF_TINY];
 511     char buffer4[BUF_TINY];
 512     struct timeval tv_current;
 513     FileOpContextUI *ui;
 514
 515     if (!verbose)
 516         return;
 517
 518     if (ctx->dialog_type != FILEGUI_DIALOG_MULTI_ITEM || ctx->ui == NULL)
 519         return;
 520
 521     ui = ctx->ui;
 522
 523     if (ctx->progress_bytes > 0)
 524     {
 525         gauge_set_value (ui->progress_total_gauge, 1024,
 526                          (int) (1024 * copyed_bytes / ctx->progress_bytes));
 527         gauge_show (ui->progress_total_gauge, 1);
 528     }
 529     else
 530         gauge_show (ui->progress_total_gauge, 0);
 531
 532
 533     if (!need_show_total_summary && tctx->bps == 0)
 534         return;
 535
 536     gettimeofday (&tv_current, NULL);
 537     file_frmt_time (buffer2, tv_current.tv_sec - tctx->transfer_start.tv_sec);
 538     file_eta_prepare_for_show (buffer3, tctx->eta_secs, TRUE);
 539     file_bps_prepare_for_show (buffer4, (long) tctx->bps);
 540
 541
 542
 543     g_snprintf (buffer, BUF_TINY, _("Time: %s  %s (%s)"), buffer2, buffer3, buffer4);
 544     label_set_text (ui->time_label, buffer);
 545
 546     size_trunc_len (buffer2, 5, tctx->copyed_bytes, 0);
 547     size_trunc_len (buffer3, 5, ctx->progress_bytes, 0);
 548
 549     g_snprintf (buffer, BUF_TINY, _(" Total: %s of %s "), buffer2, buffer3);
 550
 551     label_set_text (ui->total_bytes_label, buffer);
 552
 553 }
 554
 555 /* }}} */
 556
 557 #define truncFileString(ui, s)       str_trunc (s, 52)
 558 #define truncFileStringSecure(ui, s) path_trunc (s, 52)
 559
 560 void
 561 file_progress_show_source (FileOpContext * ctx, const char *s)
 562 {
 563     FileOpContextUI *ui;
 564
 565     g_return_if_fail (ctx != NULL);
 566
 567     if (ctx->ui == NULL)
 568         return;
 569
 570     ui = ctx->ui;
 571
 572     if (s != NULL)
 573     {
 574 #ifdef WITH_FULL_PATHS
 575         int i = strlen (current_panel->cwd);
 576
 577         /* We remove the full path we have added before */
 578         if (!strncmp (s, current_panel->cwd, i))
 579         {
 580             if (s[i] == PATH_SEP)
 581                 s += i + 1;
 582         }
 583 #endif /* WITH_FULL_PATHS */
 584
 585         label_set_text (ui->file_label[0], _("Source"));
 586         label_set_text (ui->file_string[0], truncFileString (ui, s));
 587     }
 588     else
 589     {
 590         label_set_text (ui->file_label[0], "");
 591         label_set_text (ui->file_string[0], "");
 592     }
 593 }
 594
 595 void
 596 file_progress_show_target (FileOpContext * ctx, const char *s)
 597 {
 598     FileOpContextUI *ui;
 599
 600     g_return_if_fail (ctx != NULL);
 601
 602     if (ctx->ui == NULL)
 603         return;
 604
 605     ui = ctx->ui;
 606
 607     if (s != NULL)
 608     {
 609         label_set_text (ui->file_label[1], _("Target"));
 610         label_set_text (ui->file_string[1], truncFileStringSecure (ui, s));
 611     }
 612     else
 613     {
 614         label_set_text (ui->file_label[1], "");
 615         label_set_text (ui->file_string[1], "");
 616     }
 617 }
 618
 619 void
 620 file_progress_show_deleting (FileOpContext * ctx, const char *s)
 621 {
 622     FileOpContextUI *ui;
 623
 624     g_return_if_fail (ctx != NULL);
 625
 626     if (ctx->ui == NULL)
 627         return;
 628
 629     ui = ctx->ui;
 630     label_set_text (ui->file_label[0], _("Deleting"));
 631     label_set_text (ui->file_label[0], truncFileStringSecure (ui, s));
 632 }
 633
 634 /*
 635  * FIXME: probably it is better to replace this with quick dialog machinery,
 636  * but actually I'm not familiar with it and have not much time :(
 637  *   alex
 638  */
 639 static replace_action_t
 640 overwrite_query_dialog (FileOpContext * ctx, enum OperationMode mode)
 641 {
 642 #define ADD_RD_BUTTON(i)\
 643         add_widget (ui->replace_dlg,\
 644                 button_new (rd_widgets [i].ypos, rd_widgets [i].xpos, rd_widgets [i].value,\
 645                 NORMAL_BUTTON, rd_widgets [i].text, 0))
 646
 647 #define ADD_RD_LABEL(i, p1, p2)\
 648         g_snprintf (buffer, sizeof (buffer), rd_widgets [i].text, p1, p2);\
 649         add_widget (ui->replace_dlg,\
 650                 label_new (rd_widgets [i].ypos, rd_widgets [i].xpos, buffer))
 651
 652     /* dialog sizes */
 653     const int rd_ylen = 17;
 654     int rd_xlen = 60;
 655
 656     struct
 657     {
 658         const char *text;
 659         int ypos, xpos;
 660         int value;              /* 0 for labels */
 661     } rd_widgets[] =
 662     {
 663         /*  0 */
 664         {
 665         N_("Target file already exists!"), 3, 4, 0},
 666             /*  1 */
 667         {
 668         "%s", 4, 4, 0},
 669 #if (defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64) || (defined _LARGE_FILES && _LARGE_FILES)
 670             /*  2 */
 671         {
 672         N_("Source date: %s, size %llu"), 6, 4, 0},
 673             /*  3 */
 674         {
 675         N_("Target date: %s, size %llu"), 7, 4, 0},
 676 #else
 677             /*  2 */
 678         {
 679         N_("Source date: %s, size %u"), 6, 4, 0},
 680             /*  3 */
 681         {
 682         N_("Target date: %s, size %u"), 7, 4, 0},
 683 #endif
 684             /*  4 */
 685         {
 686         N_("&Abort"), 14, 25, REPLACE_ABORT},
 687             /*  5 */
 688         {
 689         N_("If &size differs"), 12, 28, REPLACE_SIZE},
 690             /*  6 */
 691         {
 692         N_("Non&e"), 11, 47, REPLACE_NEVER},
 693             /*  7 */
 694         {
 695         N_("&Update"), 11, 36, REPLACE_UPDATE},
 696             /*  8 */
 697         {
 698         N_("A&ll"), 11, 28, REPLACE_ALWAYS},
 699             /*  9 */
 700         {
 701         N_("Overwrite all targets?"), 11, 4, 0},
 702             /* 10 */
 703         {
 704         N_("&Reget"), 10, 28, REPLACE_REGET},
 705             /* 11 */
 706         {
 707         N_("A&ppend"), 9, 45, REPLACE_APPEND},
 708             /* 12 */
 709         {
 710         N_("&No"), 9, 37, REPLACE_NO},
 711             /* 13 */
 712         {
 713         N_("&Yes"), 9, 28, REPLACE_YES},
 714             /* 14 */
 715         {
 716         N_("Overwrite this target?"), 9, 4, 0}
 717     };
 718
 719     const int num = sizeof (rd_widgets) / sizeof (rd_widgets[0]);
 720     int *widgets_len;
 721
 722     FileOpContextUI *ui = ctx->ui;
 723
 724     char buffer[BUF_SMALL];
 725     const char *title;
 726     const char *stripped_name = strip_home_and_password (ui->replace_filename);
 727     int stripped_name_len;
 728
 729     int result;
 730
 731     widgets_len = g_new0 (int, num);
 732
 733     if (mode == Foreground)
 734         title = _(" File exists ");
 735     else
 736         title = _(" Background process: File exists ");
 737
 738     stripped_name_len = str_term_width1 (stripped_name);
 739
 740     {
 741         int i, l1, l2, l, row;
 742
 743         for (i = 0; i < num; i++)
 744         {
 745 #ifdef ENABLE_NLS
 746             if (i != 1)         /* skip filename */
 747                 rd_widgets[i].text = _(rd_widgets[i].text);
 748 #endif /* ENABLE_NLS */
 749             widgets_len[i] = str_term_width1 (rd_widgets[i].text);
 750         }
 751
 752         /*
 753          * longest of "Overwrite..." labels
 754          * (assume "Target date..." are short enough)
 755          */
 756         l1 = max (widgets_len[9], widgets_len[14]);
 757
 758         /* longest of button rows */
 759         i = num;
 760         for (row = l = l2 = 0; i--;)
 761             if (rd_widgets[i].value != 0)
 762             {
 763                 if (row != rd_widgets[i].ypos)
 764                 {
 765                     row = rd_widgets[i].ypos;
 766                     l2 = max (l2, l);
 767                     l = 0;
 768                 }
 769                 l += widgets_len[i] + 4;
 770             }
 771
 772         l2 = max (l2, l);       /* last row */
 773         rd_xlen = max (rd_xlen, l1 + l2 + 8);
 774         rd_xlen = max (rd_xlen, str_term_width1 (title) + 2);
 775         rd_xlen = max (rd_xlen, min (COLS, stripped_name_len + 8));
 776
 777         /* Now place widgets */
 778         l1 += 5;                /* start of first button in the row */
 779         i = num;
 780         for (l = l1, row = 0; --i > 1;)
 781             if (rd_widgets[i].value != 0)
 782             {
 783                 if (row != rd_widgets[i].ypos)
 784                 {
 785                     row = rd_widgets[i].ypos;
 786                     l = l1;
 787                 }
 788                 rd_widgets[i].xpos = l;
 789                 l += widgets_len[i] + 4;
 790             }
 791
 792         /* Abort button is centered */
 793         rd_widgets[4].xpos = (rd_xlen - widgets_len[4] - 3) / 2;
 794     }
 795
 796     /* FIXME - missing help node */
 797     ui->replace_dlg =
 798         create_dlg (0, 0, rd_ylen, rd_xlen, alarm_colors, NULL, "[Replace]",
 799                     title, DLG_CENTER | DLG_REVERSE);
 800
 801     /* prompt -- centered */
 802     add_widget (ui->replace_dlg,
 803                 label_new (rd_widgets[0].ypos, (rd_xlen - widgets_len[0]) / 2, rd_widgets[0].text));
 804     /* file name -- centered */
 805     stripped_name = str_trunc (stripped_name, rd_xlen - 8);
 806     stripped_name_len = str_term_width1 (stripped_name);
 807     add_widget (ui->replace_dlg,
 808                 label_new (rd_widgets[1].ypos, (rd_xlen - stripped_name_len) / 2, stripped_name));
 809
 810     /* source date */
 811     ADD_RD_LABEL (2, file_date (ui->s_stat->st_mtime), (off_t) ui->s_stat->st_size);
 812     /* destination date */
 813     ADD_RD_LABEL (3, file_date (ui->d_stat->st_mtime), (off_t) ui->d_stat->st_size);
 814
 815     ADD_RD_BUTTON (4);          /* Abort */
 816     ADD_RD_BUTTON (5);          /* If size differs */
 817     ADD_RD_BUTTON (6);          /* None */
 818     ADD_RD_BUTTON (7);          /* Update */
 819     ADD_RD_BUTTON (8);          /* All" */
 820     ADD_RD_LABEL (9, 0, 0);     /* Overwrite all targets? */
 821
 822     /* "this target..." widgets */
 823     if (!S_ISDIR (ui->d_stat->st_mode))
 824     {
 825         if ((ctx->operation == OP_COPY) && (ui->d_stat->st_size != 0)
 826             && (ui->s_stat->st_size > ui->d_stat->st_size))
 827             ADD_RD_BUTTON (10); /* Reget */
 828
 829         ADD_RD_BUTTON (11);     /* Append */
 830     }
 831     ADD_RD_BUTTON (12);         /* No */
 832     ADD_RD_BUTTON (13);         /* Yes */
 833     ADD_RD_LABEL (14, 0, 0);    /* Overwrite this target? */
 834
 835     result = run_dlg (ui->replace_dlg);
 836     destroy_dlg (ui->replace_dlg);
 837
 838     g_free (widgets_len);
 839
 840     return (result == B_CANCEL) ? REPLACE_ABORT : (replace_action_t) result;
 841 #undef ADD_RD_LABEL
 842 #undef ADD_RD_BUTTON
 843 }
 844
 845 FileProgressStatus
 846 file_progress_real_query_replace (FileOpContext * ctx,
 847                                   enum OperationMode mode, const char *destname,
 848                                   struct stat * _s_stat, struct stat * _d_stat)
 849 {
 850     FileOpContextUI *ui;
 851
 852     g_return_val_if_fail (ctx != NULL, FILE_CONT);
 853     g_return_val_if_fail (ctx->ui != NULL, FILE_CONT);
 854
 855     ui = ctx->ui;
 856
 857     if (ui->replace_result < REPLACE_ALWAYS)
 858     {
 859         ui->replace_filename = destname;
 860         ui->s_stat = _s_stat;
 861         ui->d_stat = _d_stat;
 862         ui->replace_result = overwrite_query_dialog (ctx, mode);
 863     }
 864
 865     switch (ui->replace_result)
 866     {
 867     case REPLACE_UPDATE:
 868         do_refresh ();
 869         if (_s_stat->st_mtime > _d_stat->st_mtime)
 870             return FILE_CONT;
 871         else
 872             return FILE_SKIP;
 873
 874     case REPLACE_SIZE:
 875         do_refresh ();
 876         if (_s_stat->st_size == _d_stat->st_size)
 877             return FILE_SKIP;
 878         else
 879             return FILE_CONT;
 880
 881     case REPLACE_REGET:
 882         /* Careful: we fall through and set do_append */
 883         ctx->do_reget = _d_stat->st_size;
 884
 885     case REPLACE_APPEND:
 886         ctx->do_append = TRUE;
 887
 888     case REPLACE_YES:
 889     case REPLACE_ALWAYS:
 890         do_refresh ();
 891         return FILE_CONT;
 892     case REPLACE_NO:
 893     case REPLACE_NEVER:
 894         do_refresh ();
 895         return FILE_SKIP;
 896     case REPLACE_ABORT:
 897     default:
 898         return FILE_ABORT;
 899     }
 900 }
 901
 902 static gboolean
 903 is_wildcarded (char *p)
 904 {
 905     for (; *p; p++)
 906     {
 907         if (*p == '*')
 908             return TRUE;
 909         if (*p == '\\' && p[1] >= '1' && p[1] <= '9')
 910             return TRUE;
 911     }
 912     return FALSE;
 913 }
 914
 915 char *
 916 file_mask_dialog (FileOpContext * ctx, FileOperation operation,
 917                   gboolean only_one,
 918                   const char *format, const void *text,
 919                   const char *def_text, gboolean * do_background)
 920 {
 921     const size_t FMDY = 13;
 922     const size_t FMDX = 68;
 923     size_t fmd_xlen;
 924
 925     /* buttons */
 926     const size_t gap = 1;
 927     size_t b0_len, b2_len;
 928     size_t b1_len = 0;
 929
 930     int source_easy_patterns = easy_patterns;
 931     size_t i, len;
 932     char fmd_buf[BUF_MEDIUM];
 933     char *source_mask, *orig_mask, *dest_dir, *tmp;
 934     char *def_text_secure;
 935     int val;
 936
 937     QuickWidget fmd_widgets[] = {
 938         /* 0 */ QUICK_BUTTON (42, 64, 10, FMDY, N_("&Cancel"), B_CANCEL, NULL),
 939 #ifdef WITH_BACKGROUND
 940         /* 1 */ QUICK_BUTTON (25, 64, 10, FMDY, N_("&Background"), B_USER, NULL),
 941 #define OFFSET 0
 942 #else
 943 #define OFFSET 1
 944 #endif /* WITH_BACKGROUND */
 945         /*  2 - OFFSET */
 946         QUICK_BUTTON (14, FMDX, 10, FMDY, N_("&OK"), B_ENTER, NULL),
 947         /*  3 - OFFSET */
 948         QUICK_CHECKBOX (42, FMDX, 8, FMDY, N_("&Stable Symlinks"), &ctx->stable_symlinks),
 949         /*  4 - OFFSET */
 950         QUICK_CHECKBOX (31, FMDX, 7, FMDY, N_("di&Ve into subdir if exists"),
 951                         &ctx->dive_into_subdirs),
 952         /*  5 - OFFSET */
 953         QUICK_CHECKBOX (3, FMDX, 8, FMDY, N_("preserve &Attributes"), &ctx->op_preserve),
 954         /*  6 - OFFSET */
 955         QUICK_CHECKBOX (3, FMDX, 7, FMDY, N_("follow &Links"), &ctx->follow_links),
 956         /*  7 - OFFSET */
 957         QUICK_INPUT (3, FMDX, 6, FMDY, "", 58, 0, "input2", &dest_dir),
 958         /*  8 - OFFSET */
 959         QUICK_LABEL (3, FMDX, 5, FMDY, N_("to:")),
 960         /*  9 - OFFSET */
 961         QUICK_CHECKBOX (37, FMDX, 4, FMDY, N_("&Using shell patterns"), &source_easy_patterns),
 962         /* 10 - OFFSET */
 963         QUICK_INPUT (3, FMDX, 3, FMDY, easy_patterns ? "*" : "^(.*)$", 58, 0, "input-def",
 964                      &source_mask),
 965         /* 11 - OFFSET */
 966         QUICK_LABEL (3, FMDX, 2, FMDY, fmd_buf),
 967         QUICK_END
 968     };
 969
 970     g_return_val_if_fail (ctx != NULL, NULL);
 971
 972 #ifdef ENABLE_NLS
 973     /* buttons */
 974     for (i = 0; i <= 2 - OFFSET; i++)
 975         fmd_widgets[i].u.button.text = _(fmd_widgets[i].u.button.text);
 976
 977     /* checkboxes */
 978     for (i = 3 - OFFSET; i <= 9 - OFFSET; i++)
 979         if (i != 7 - OFFSET)
 980             fmd_widgets[i].u.checkbox.text = _(fmd_widgets[i].u.checkbox.text);
 981 #endif /* !ENABLE_NLS */
 982
 983     fmd_xlen = max (FMDX, (size_t) COLS * 2 / 3);
 984
 985     len = str_term_width1 (fmd_widgets[6 - OFFSET].u.checkbox.text)
 986         + str_term_width1 (fmd_widgets[4 - OFFSET].u.checkbox.text) + 15;
 987     fmd_xlen = max (fmd_xlen, len);
 988
 989     len = str_term_width1 (fmd_widgets[5 - OFFSET].u.checkbox.text)
 990         + str_term_width1 (fmd_widgets[3 - OFFSET].u.checkbox.text) + 15;
 991     fmd_xlen = max (fmd_xlen, len);
 992
 993     /* buttons */
 994     b2_len = str_term_width1 (fmd_widgets[2 - OFFSET].u.button.text) + 6 + gap; /* OK */
 995 #ifdef WITH_BACKGROUND
 996     b1_len = str_term_width1 (fmd_widgets[1].u.button.text) + 4 + gap;  /* Background */
 997 #endif
 998     b0_len = str_term_width1 (fmd_widgets[0].u.button.text) + 4;        /* Cancel */
 999     len = b0_len + b1_len + b2_len;
1000     fmd_xlen = min (max (fmd_xlen, len + 6), (size_t) COLS);
1001
1002     if (only_one)
1003     {
1004         int flen;
1005
1006         flen = str_term_width1 (format);
1007         i = fmd_xlen - flen - 4;        /* FIXME */
1008         g_snprintf (fmd_buf, sizeof (fmd_buf), format, str_trunc ((const char *) text, i));
1009     }
1010     else
1011     {
1012         g_snprintf (fmd_buf, sizeof (fmd_buf), format, *(const int *) text);
1013         fmd_xlen = max (fmd_xlen, (size_t) str_term_width1 (fmd_buf) + 6);
1014     }
1015
1016     for (i = sizeof (fmd_widgets) / sizeof (fmd_widgets[0]); i > 0;)
1017         fmd_widgets[--i].x_divisions = fmd_xlen;
1018
1019     i = (fmd_xlen - len) / 2;
1020     /* OK button */
1021     fmd_widgets[2 - OFFSET].relative_x = i;
1022     i += b2_len;
1023 #ifdef WITH_BACKGROUND
1024     /* Background button */
1025     fmd_widgets[1].relative_x = i;
1026     i += b1_len;
1027 #endif
1028     /* Cancel button */
1029     fmd_widgets[0].relative_x = i;
1030
1031 #define chkbox_xpos(i) \
1032     fmd_widgets [i].relative_x = fmd_xlen - str_term_width1 (fmd_widgets [i].u.checkbox.text) - 6
1033     chkbox_xpos (3 - OFFSET);
1034     chkbox_xpos (4 - OFFSET);
1035     chkbox_xpos (9 - OFFSET);
1036 #undef chkbox_xpos
1037
1038     /* inputs */
1039     fmd_widgets[7 - OFFSET].u.input.len = fmd_widgets[10 - OFFSET].u.input.len = fmd_xlen - 6;
1040
1041     /* unselect checkbox if target filesystem don't support attributes */
1042     ctx->op_preserve = filegui__check_attrs_on_fs (def_text);
1043
1044     /* filter out a possible password from def_text */
1045     tmp = strip_password (g_strdup (def_text), 1);
1046     if (source_easy_patterns)
1047         def_text_secure = strutils_glob_escape (tmp);
1048     else
1049         def_text_secure = strutils_regex_escape (tmp);
1050     g_free (tmp);
1051
1052     /* destination */
1053     fmd_widgets[7 - OFFSET].u.input.text = def_text_secure;
1054
1055     ctx->stable_symlinks = FALSE;
1056     *do_background = FALSE;
1057
1058     {
1059         struct stat buf;
1060
1061         QuickDialog Quick_input = {
1062             fmd_xlen, FMDY, -1, -1, op_names[operation],
1063             "[Mask Copy/Rename]", fmd_widgets, TRUE
1064         };
1065
1066       ask_file_mask:
1067         val = quick_dialog_skip (&Quick_input, 4);
1068
1069         if (val == B_CANCEL)
1070         {
1071             g_free (def_text_secure);
1072             return NULL;
1073         }
1074
1075         if (ctx->follow_links)
1076             ctx->stat_func = mc_stat;
1077         else
1078             ctx->stat_func = mc_lstat;
1079
1080         if (ctx->op_preserve)
1081         {
1082             ctx->preserve = TRUE;
1083             ctx->umask_kill = 0777777;
1084             ctx->preserve_uidgid = (geteuid () == 0);
1085         }
1086         else
1087         {
1088             int i2;
1089             ctx->preserve = ctx->preserve_uidgid = FALSE;
1090             i2 = umask (0);
1091             umask (i2);
1092             ctx->umask_kill = i2 ^ 0777777;
1093         }
1094
1095         if ((dest_dir == NULL) || (*dest_dir == '\0'))
1096         {
1097             g_free (def_text_secure);
1098             g_free (source_mask);
1099             return dest_dir;
1100         }
1101
1102         ctx->search_handle = mc_search_new (source_mask, -1);
1103
1104         if (ctx->search_handle == NULL)
1105         {
1106             message (D_ERROR, MSG_ERROR, _("Invalid source pattern `%s'"), source_mask);
1107             g_free (dest_dir);
1108             g_free (source_mask);
1109             goto ask_file_mask;
1110         }
1111
1112         g_free (def_text_secure);
1113         g_free (source_mask);
1114
1115         ctx->search_handle->is_case_sentitive = TRUE;
1116         if (source_easy_patterns)
1117             ctx->search_handle->search_type = MC_SEARCH_T_GLOB;
1118         else
1119             ctx->search_handle->search_type = MC_SEARCH_T_REGEX;
1120
1121         tmp = dest_dir;
1122         dest_dir = tilde_expand (tmp);
1123         g_free (tmp);
1124
1125         ctx->dest_mask = strrchr (dest_dir, PATH_SEP);
1126         if (ctx->dest_mask == NULL)
1127             ctx->dest_mask = dest_dir;
1128         else
1129             ctx->dest_mask++;
1130         orig_mask = ctx->dest_mask;
1131         if (!*ctx->dest_mask
1132             || (!ctx->dive_into_subdirs && !is_wildcarded (ctx->dest_mask)
1133                 && (!only_one
1134                     || (!mc_stat (dest_dir, &buf) && S_ISDIR (buf.st_mode))))
1135             || (ctx->dive_into_subdirs
1136                 && ((!only_one && !is_wildcarded (ctx->dest_mask))
1137                     || (only_one && !mc_stat (dest_dir, &buf) && S_ISDIR (buf.st_mode)))))
1138             ctx->dest_mask = g_strdup ("\\0");
1139         else
1140         {
1141             ctx->dest_mask = g_strdup (ctx->dest_mask);
1142             *orig_mask = '\0';
1143         }
1144         if (!*dest_dir)
1145         {
1146             g_free (dest_dir);
1147             dest_dir = g_strdup ("./");
1148         }
1149         if (val == B_USER)
1150             *do_background = TRUE;
1151     }
1152
1153     return dest_dir;
1154 }