src/utilops.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 John Ellis
   4  * Copyright (C) 2008 The Geeqie Team
   5  *
   6  * Author: John Ellis
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13
  14 #include "main.h"
  15 #include "utilops.h"
  16
  17
  18 #include "cache.h"
  19 #include "cache_maint.h"
  20 #include "collect.h"
  21 #include "dupe.h"
  22 #include "filelist.h"
  23 #include "image.h"
  24 #include "img-view.h"
  25 #include "layout.h"
  26 #include "search.h"
  27 #include "thumb_standard.h"
  28 #include "ui_bookmark.h"
  29 #include "ui_fileops.h"
  30 #include "ui_misc.h"
  31 #include "ui_tabcomp.h"
  32 #include "editors.h"
  33
  34 /*
  35  *--------------------------------------------------------------------------
  36  * call these when names change, files move, deleted, etc.
  37  * so that any open windows are also updated
  38  *--------------------------------------------------------------------------
  39  */
  40
  41
  42 void file_maint_renamed(FileData *fd)
  43 {
  44         cache_maint_moved(fd);
  45         collection_maint_renamed(fd);
  46
  47         layout_maint_renamed(fd);
  48         view_window_maint_moved(fd);
  49         dupe_maint_renamed(fd);
  50         search_maint_renamed(fd);
  51 }
  52
  53 /* under most cases ignore_list should be NULL */
  54 void file_maint_removed(FileData *fd, GList *ignore_list)
  55 {
  56         layout_maint_removed(fd, ignore_list);
  57         view_window_maint_removed(fd, ignore_list);
  58         dupe_maint_removed(fd);
  59         search_maint_removed(fd);
  60
  61         collection_maint_removed(fd);
  62         cache_maint_removed(fd);
  63 }
  64
  65 /* special case for correct main window behavior */
  66 void file_maint_moved(FileData *fd, GList *ignore_list)
  67 {
  68         cache_maint_moved(fd);
  69         collection_maint_renamed(fd);
  70
  71         layout_maint_moved(fd, ignore_list);
  72         view_window_maint_moved(fd);
  73         dupe_maint_renamed(fd);
  74         search_maint_renamed(fd);
  75 }
  76
  77 void file_maint_copied(FileData *fd)
  78 {
  79         cache_maint_copied(fd);
  80 }
  81
  82 /*
  83  *--------------------------------------------------------------------------
  84  * The file manipulation dialogs
  85  *--------------------------------------------------------------------------
  86  */
  87
  88
  89 enum {
  90         DIALOG_NEW_DIR,
  91         DIALOG_COPY,
  92         DIALOG_MOVE,
  93         DIALOG_DELETE,
  94         DIALOG_RENAME
  95 };
  96
  97 typedef struct _FileDataMult FileDataMult;
  98 struct _FileDataMult
  99 {
 100         gint confirm_all;
 101         gint confirmed;
 102         gint skip;
 103         GList *source_list;
 104         GList *source_next;
 105         gchar *dest_base;
 106         FileData *source_fd;
 107         gchar *dest;
 108         gint copy;
 109
 110         gint rename;
 111         gint rename_auto;
 112         gint rename_all;
 113
 114         GtkWidget *rename_box;
 115         GtkWidget *rename_entry;
 116         GtkWidget *rename_auto_box;
 117
 118         GtkWidget *yes_all_button;
 119 };
 120
 121 typedef struct _FileDataSingle FileDataSingle;
 122 struct _FileDataSingle
 123 {
 124         gint confirmed;
 125         FileData *source_fd;
 126         gchar *dest;
 127         gint copy;
 128
 129         gint rename;
 130         gint rename_auto;
 131
 132         GtkWidget *rename_box;
 133         GtkWidget *rename_entry;
 134         GtkWidget *rename_auto_box;
 135 };
 136
 137 /*
 138  *--------------------------------------------------------------------------
 139  * Adds 1 or 2 images (if 2, side by side) to a GenericDialog
 140  *--------------------------------------------------------------------------
 141  */
 142
 143 #define DIALOG_DEF_IMAGE_DIM_X 200
 144 #define DIALOG_DEF_IMAGE_DIM_Y 150
 145
 146 static void generic_dialog_add_image(GenericDialog *gd, GtkWidget *box,
 147                                      FileData *fd1, const gchar *header1,
 148                                      FileData *fd2, const gchar *header2,
 149                                      gint show_filename)
 150 {
 151         ImageWindow *imd;
 152         GtkWidget *hbox = NULL;
 153         GtkWidget *vbox;
 154         GtkWidget *label = NULL;
 155
 156         if (!box) box = gd->vbox;
 157
 158         if (fd2)
 159                 {
 160                 hbox = pref_box_new(box, TRUE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
 161                 }
 162
 163         /* image 1 */
 164
 165         vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
 166         if (hbox)
 167                 {
 168                 GtkWidget *sep;
 169
 170                 gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
 171
 172                 sep = gtk_vseparator_new();
 173                 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0);
 174                 gtk_widget_show(sep);
 175                 }
 176         else
 177                 {
 178                 gtk_box_pack_start(GTK_BOX(box), vbox, TRUE, TRUE, PREF_PAD_GAP);
 179                 }
 180         gtk_widget_show(vbox);
 181
 182         if (header1)
 183                 {
 184                 GtkWidget *head;
 185
 186                 head = pref_label_new(vbox, header1);
 187                 pref_label_bold(head, TRUE, FALSE);
 188                 gtk_misc_set_alignment(GTK_MISC(head), 0.0, 0.5);
 189                 }
 190
 191         imd = image_new(FALSE);
 192         g_object_set(G_OBJECT(imd->pr), "zoom_expand", FALSE, NULL);
 193         gtk_widget_set_size_request(imd->widget, DIALOG_DEF_IMAGE_DIM_X, DIALOG_DEF_IMAGE_DIM_Y);
 194         gtk_box_pack_start(GTK_BOX(vbox), imd->widget, TRUE, TRUE, 0);
 195         image_change_fd(imd, fd1, 0.0);
 196         gtk_widget_show(imd->widget);
 197
 198         if (show_filename)
 199                 {
 200                 label = pref_label_new(vbox, (fd1 == NULL) ? "" : fd1->name);
 201                 }
 202
 203         /* only the first image is stored (for use in gd_image_set) */
 204         g_object_set_data(G_OBJECT(gd->dialog), "img_image", imd);
 205         g_object_set_data(G_OBJECT(gd->dialog), "img_label", label);
 206
 207
 208         /* image 2 */
 209
 210         if (hbox && fd2)
 211                 {
 212                 vbox = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
 213
 214                 if (header2)
 215                         {
 216                         GtkWidget *head;
 217
 218                         head = pref_label_new(vbox, header2);
 219                         pref_label_bold(head, TRUE, FALSE);
 220                         gtk_misc_set_alignment(GTK_MISC(head), 0.0, 0.5);
 221                         }
 222
 223                 imd = image_new(FALSE);
 224                 g_object_set(G_OBJECT(imd->pr), "zoom_expand", FALSE, NULL);
 225                 gtk_widget_set_size_request(imd->widget, DIALOG_DEF_IMAGE_DIM_X, DIALOG_DEF_IMAGE_DIM_Y);
 226                 gtk_box_pack_start(GTK_BOX(vbox), imd->widget, TRUE, TRUE, 0);
 227                 image_change_fd(imd, fd2, 0.0);
 228                 gtk_widget_show(imd->widget);
 229
 230                 pref_label_new(vbox, fd2->name);
 231                 }
 232 }
 233
 234 static void generic_dialog_image_set(GenericDialog *gd, FileData *fd)
 235 {
 236         ImageWindow *imd;
 237         GtkWidget *label;
 238
 239         imd = g_object_get_data(G_OBJECT(gd->dialog), "img_image");
 240         label = g_object_get_data(G_OBJECT(gd->dialog), "img_label");
 241
 242         if (!imd) return;
 243
 244         image_change_fd(imd, fd, 0.0);
 245         if (label) gtk_label_set_text(GTK_LABEL(label), fd->name);
 246 }
 247
 248 /*
 249  *--------------------------------------------------------------------------
 250  * Wrappers to aid in setting additional dialog properties (unde mouse, etc.)
 251  *--------------------------------------------------------------------------
 252  */
 253
 254 GenericDialog *file_util_gen_dlg(const gchar *title,
 255                                  const gchar *wmclass, const gchar *wmsubclass,
 256                                  GtkWidget *parent, gint auto_close,
 257                                  void (*cancel_cb)(GenericDialog *, gpointer), gpointer data)
 258 {
 259         GenericDialog *gd;
 260
 261         gd = generic_dialog_new(title, wmclass, wmsubclass, parent, auto_close, cancel_cb, data);
 262         if (options->place_dialogs_under_mouse)
 263                 {
 264                 gtk_window_set_position(GTK_WINDOW(gd->dialog), GTK_WIN_POS_MOUSE);
 265                 }
 266
 267         return gd;
 268 }
 269
 270 FileDialog *file_util_file_dlg(const gchar *title,
 271                                const gchar *wmclass, const gchar *wmsubclass,
 272                                GtkWidget *parent,
 273                                void (*cancel_cb)(FileDialog *, gpointer), gpointer data)
 274 {
 275         FileDialog *fdlg;
 276
 277         fdlg = file_dialog_new(title, wmclass, wmsubclass, parent, cancel_cb, data);
 278         if (options->place_dialogs_under_mouse)
 279                 {
 280                 gtk_window_set_position(GTK_WINDOW(GENERIC_DIALOG(fdlg)->dialog), GTK_WIN_POS_MOUSE);
 281                 }
 282
 283         return fdlg;
 284 }
 285
 286 /* this warning dialog is copied from SLIK's ui_utildg.c,
 287  * because it does not have a mouse center option,
 288  * and we must center it before show, implement it here.
 289  */
 290 static void file_util_warning_dialog_ok_cb(GenericDialog *gd, gpointer data)
 291 {
 292         /* no op */
 293 }
 294
 295 GenericDialog *file_util_warning_dialog(const gchar *heading, const gchar *message,
 296                                         const gchar *icon_stock_id, GtkWidget *parent)
 297 {
 298         GenericDialog *gd;
 299
 300         gd = file_util_gen_dlg(heading, GQ_WMCLASS, "warning", parent, TRUE, NULL, NULL);
 301         generic_dialog_add_message(gd, icon_stock_id, heading, message);
 302         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, file_util_warning_dialog_ok_cb, TRUE);
 303         if (options->place_dialogs_under_mouse)
 304                 {
 305                 gtk_window_set_position(GTK_WINDOW(gd->dialog), GTK_WIN_POS_MOUSE);
 306                 }
 307         gtk_widget_show(gd->dialog);
 308
 309         return gd;
 310 }
 311
 312 static gint filename_base_length(const gchar *name)
 313 {
 314         gint n;
 315
 316         if (!name) return 0;
 317
 318         n = strlen(name);
 319
 320         if (filter_name_exists(name))
 321                 {
 322                 const gchar *ext;
 323
 324                 ext = extension_from_path(name);
 325                 if (ext) n -= strlen(ext);
 326                 }
 327
 328         return n;
 329 }
 330
 331
 332 /*
 333  *--------------------------------------------------------------------------
 334  * Move and Copy routines
 335  *--------------------------------------------------------------------------
 336  */
 337
 338 static gint copy_file_ext_cb(gpointer ed, gint flags, GList *list, gpointer data)
 339 {
 340         if ((flags & EDITOR_ERROR_MASK) && !(flags & EDITOR_ERROR_SKIPPED))
 341                 {
 342                 FileData *fd = list->data;
 343                 gchar *title = _("Error copying file");
 344                 gchar *text = g_strdup_printf(_("%s\nUnable to copy file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
 345                 file_util_warning_dialog(title, text, GTK_STOCK_DIALOG_ERROR, NULL);
 346                 g_free(text);
 347                 }
 348         while (list)
 349                 {
 350                 FileData *fd = list->data;
 351                 if (!(flags & EDITOR_ERROR_MASK))
 352                         file_maint_copied(fd);
 353                 file_data_change_info_free(NULL, fd);
 354                 list = list->next;
 355                 }
 356         return EDITOR_CB_CONTINUE;
 357 }
 358
 359
 360 gint copy_file_ext(FileData *fd)
 361 {
 362         gint ok;
 363         g_assert(fd->change);
 364         if (options->editor_command[CMD_COPY])
 365                 {
 366                 ok = !start_editor_from_file_full(CMD_COPY, fd, copy_file_ext_cb, NULL);
 367                 if (ok) return ok; /* that's all for now, let's continue in callback */
 368                 }
 369         else
 370                 ok = copy_file(fd->change->source, fd->change->dest);
 371
 372         if (ok)
 373                 {
 374                 file_maint_copied(fd);
 375                 }
 376
 377         file_data_change_info_free(NULL, fd);
 378
 379         return ok;
 380 }
 381
 382 static gint move_file_ext_cb(gpointer ed, gint flags, GList *list, gpointer data)
 383 {
 384         if ((flags & EDITOR_ERROR_MASK) && !(flags & EDITOR_ERROR_SKIPPED))
 385                 {
 386                 FileData *fd = list->data;
 387                 gchar *title = _("Error moving file");
 388                 gchar *text = g_strdup_printf(_("%s\nUnable to move file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
 389                 file_util_warning_dialog(title, text, GTK_STOCK_DIALOG_ERROR, NULL);
 390                 g_free(text);
 391                 }
 392         while (list)
 393                 {
 394                 FileData *fd = list->data;
 395                 if (!(flags & EDITOR_ERROR_MASK))
 396                         {
 397                         file_data_do_change(fd);
 398                         file_maint_moved(fd, NULL);
 399                         }
 400                 file_data_change_info_free(NULL, fd);
 401                 list = list->next;
 402                 }
 403         return EDITOR_CB_CONTINUE;
 404
 405 }
 406
 407
 408 gint move_file_ext(FileData *fd)
 409 {
 410         gint ok;
 411         g_assert(fd->change);
 412         if (options->editor_command[CMD_MOVE])
 413                 {
 414                 ok = !start_editor_from_file_full(CMD_MOVE, fd, move_file_ext_cb, NULL);
 415                 if (ok) return ok; /* that's all for now, let's continue in callback */
 416                 }
 417         else
 418                 ok = move_file(fd->change->source, fd->change->dest);
 419
 420         if (ok)
 421                 {
 422                 file_data_do_change(fd);
 423                 file_maint_moved(fd, NULL);
 424                 }
 425
 426         file_data_change_info_free(NULL, fd);
 427
 428         return ok;
 429 }
 430
 431 static gint rename_file_ext_cb(gpointer ed, gint flags, GList *list, gpointer data)
 432 {
 433         if ((flags & EDITOR_ERROR_MASK) && !(flags & EDITOR_ERROR_SKIPPED))
 434                 {
 435                 FileData *fd = list->data;
 436                 gchar *title = _("Error renaming file");
 437                 gchar *text = g_strdup_printf(_("%s\nUnable to rename file:\n%s\nto:\n%s"), editor_get_error_str(flags), fd->name, fd->change->dest);
 438                 file_util_warning_dialog(title, text, GTK_STOCK_DIALOG_ERROR, NULL);
 439                 g_free(text);
 440                 }
 441         while (list)
 442                 {
 443                 FileData *fd = list->data;
 444                 if (!(flags & EDITOR_ERROR_MASK))
 445                         {
 446                         file_data_do_change(fd);
 447                         file_maint_renamed(fd);
 448                         }
 449                 file_data_change_info_free(NULL, fd);
 450                 list = list->next;
 451                 }
 452         return EDITOR_CB_CONTINUE;
 453 }
 454
 455 gint rename_file_ext(FileData *fd)
 456 {
 457         gint ok;
 458         g_assert(fd->change);
 459         if (options->editor_command[CMD_RENAME])
 460                 {
 461                 ok = !start_editor_from_file_full(CMD_RENAME, fd, rename_file_ext_cb, NULL);
 462                 if (ok) return ok; /* that's all for now, let's continue in callback */
 463                 }
 464         else
 465                 ok = rename_file(fd->change->source, fd->change->dest);
 466
 467         if (ok)
 468                 {
 469                 file_data_do_change(fd);
 470                 file_maint_renamed(fd);
 471                 }
 472
 473         file_data_change_info_free(NULL, fd);
 474
 475         return ok;
 476 }
 477
 478
 479 /*
 480  * Multi file move
 481  */
 482
 483 static FileDataMult *file_data_multiple_new(GList *source_list, const gchar *dest, gint copy)
 484 {
 485         FileDataMult *fdm = g_new0(FileDataMult, 1);
 486         fdm->confirm_all = FALSE;
 487         fdm->confirmed = FALSE;
 488         fdm->skip = FALSE;
 489         fdm->source_list = source_list;
 490         fdm->source_next = fdm->source_list;
 491         fdm->dest_base = g_strdup(dest);
 492         fdm->source_fd = NULL;
 493         fdm->dest = NULL;
 494         fdm->copy = copy;
 495         return fdm;
 496 }
 497
 498 static void file_data_multiple_free(FileDataMult *fdm)
 499 {
 500         filelist_free(fdm->source_list);
 501         g_free(fdm->dest_base);
 502         g_free(fdm->dest);
 503         g_free(fdm);
 504 }
 505
 506 static void file_util_move_multiple(FileDataMult *fdm);
 507
 508 static void file_util_move_multiple_ok_cb(GenericDialog *gd, gpointer data)
 509 {
 510         FileDataMult *fdm = data;
 511
 512         fdm->confirmed = TRUE;
 513
 514         if (fdm->rename_auto)
 515                 {
 516                 gchar *buf;
 517
 518                 buf = unique_filename_simple(fdm->dest);
 519                 if (buf)
 520                         {
 521                         g_free(fdm->dest);
 522                         fdm->dest = buf;
 523                         }
 524                 else
 525                         {
 526                         /* unique failed? well, return to the overwrite prompt :( */
 527                         fdm->confirmed = FALSE;
 528                         }
 529                 }
 530         else if (fdm->rename)
 531                 {
 532                 const gchar *name;
 533
 534                 name = gtk_entry_get_text(GTK_ENTRY(fdm->rename_entry));
 535                 if (strlen(name) == 0 ||
 536                     strcmp(name, fdm->source_fd->name) == 0)
 537                         {
 538                         fdm->confirmed = FALSE;
 539                         }
 540                 else
 541                         {
 542                         g_free(fdm->dest);
 543                         fdm->dest = concat_dir_and_file(fdm->dest_base, name);
 544                         fdm->confirmed = !isname(fdm->dest);
 545                         }
 546                 }
 547
 548         file_util_move_multiple(fdm);
 549 }
 550
 551 static void file_util_move_multiple_all_cb(GenericDialog *gd, gpointer data)
 552 {
 553         FileDataMult *fdm = data;
 554
 555         fdm->confirm_all = TRUE;
 556
 557         if (fdm->rename_auto) fdm->rename_all = TRUE;
 558
 559         file_util_move_multiple(fdm);
 560 }
 561
 562 static void file_util_move_multiple_skip_cb(GenericDialog *gd, gpointer data)
 563 {
 564         FileDataMult *fdm = data;
 565
 566         fdm->skip = TRUE;
 567         fdm->confirmed = TRUE;
 568
 569         file_util_move_multiple(fdm);
 570 }
 571
 572 static void file_util_move_multiple_skip_all_cb(GenericDialog *gd, gpointer data)
 573 {
 574         FileDataMult *fdm = data;
 575
 576         fdm->skip = TRUE;
 577         fdm->confirm_all = TRUE;
 578         file_util_move_multiple(fdm);
 579 }
 580
 581 static void file_util_move_multiple_continue_cb(GenericDialog *gd, gpointer data)
 582 {
 583         FileDataMult *fdm = data;
 584
 585         fdm->confirmed = TRUE;
 586         file_util_move_multiple(fdm);
 587 }
 588
 589 static void file_util_move_multiple_cancel_cb(GenericDialog *gd, gpointer data)
 590 {
 591         FileDataMult *fdm = data;
 592
 593         file_data_multiple_free(fdm);
 594 }
 595
 596 /* rename option */
 597
 598 static void file_util_move_multiple_rename_auto_cb(GtkWidget *widget, gpointer data)
 599 {
 600         GenericDialog *gd = data;
 601         FileDataMult *fdm;
 602
 603         fdm = gd->data;
 604
 605         fdm->rename_auto = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 606         gtk_widget_set_sensitive(fdm->rename_box, !fdm->rename_auto);
 607         gtk_widget_set_sensitive(fdm->rename_entry, (!fdm->rename_auto && fdm->rename));
 608
 609         if (fdm->rename_auto)
 610                 {
 611                 gchar *preview;
 612
 613                 preview = unique_filename_simple(fdm->dest);
 614                 if (preview) gtk_entry_set_text(GTK_ENTRY(fdm->rename_entry), filename_from_path(preview));
 615                 g_free(preview);
 616                 }
 617
 618         gtk_widget_set_sensitive(fdm->yes_all_button, (fdm->rename_auto || !fdm->rename));
 619 }
 620
 621 static void file_util_move_multiple_rename_cb(GtkWidget *widget, gpointer data)
 622 {
 623         GenericDialog *gd = data;
 624         FileDataMult *fdm;
 625
 626         fdm = gd->data;
 627
 628         fdm->rename = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 629         gtk_widget_set_sensitive(fdm->rename_entry, fdm->rename);
 630         gtk_widget_set_sensitive(fdm->yes_all_button, !fdm->rename);
 631
 632         if (fdm->rename)
 633                 {
 634                 const gchar *name;
 635
 636                 gtk_widget_grab_focus(fdm->rename_entry);
 637
 638                 name = gtk_entry_get_text(GTK_ENTRY(fdm->rename_entry));
 639                 gtk_editable_select_region(GTK_EDITABLE(fdm->rename_entry), 0, filename_base_length(name));
 640                 }
 641 }
 642
 643 static GenericDialog *file_util_move_multiple_confirm_dialog(FileDataMult *fdm)
 644 {
 645         GenericDialog *gd;
 646         GtkWidget *hbox;
 647
 648         gd = file_util_gen_dlg(_("Overwrite file"), GQ_WMCLASS, "dlg_confirm",
 649                                 NULL, TRUE,
 650                                 file_util_move_multiple_cancel_cb, fdm);
 651
 652         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION,
 653                                    _("Overwrite file?"),
 654                                    _("Replace existing file with new file."));
 655         pref_spacer(gd->vbox, 0);
 656
 657         generic_dialog_add_button(gd, GTK_STOCK_YES, _("_Overwrite"), file_util_move_multiple_ok_cb, TRUE);
 658         fdm->yes_all_button = generic_dialog_add_button(gd, NULL, _("Overwrite _all"),
 659                                                         file_util_move_multiple_all_cb, FALSE);
 660         generic_dialog_add_button(gd, GTK_STOCK_GOTO_LAST, _("S_kip all"), file_util_move_multiple_skip_all_cb, FALSE);
 661         generic_dialog_add_button(gd, GTK_STOCK_GO_FORWARD, _("_Skip"), file_util_move_multiple_skip_cb, FALSE);
 662         generic_dialog_add_image(gd, NULL, file_data_new_simple(fdm->dest), _("Existing file"), fdm->source_fd, _("New file"), TRUE);
 663
 664         /* rename option */
 665
 666         fdm->rename = FALSE;
 667         fdm->rename_all = FALSE;
 668         fdm->rename_auto = FALSE;
 669
 670         hbox = pref_box_new(gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
 671
 672         fdm->rename_auto_box = gtk_check_button_new_with_label(_("Auto rename"));
 673         g_signal_connect(G_OBJECT(fdm->rename_auto_box), "clicked",
 674                          G_CALLBACK(file_util_move_multiple_rename_auto_cb), gd);
 675         gtk_box_pack_start(GTK_BOX(hbox), fdm->rename_auto_box, FALSE, FALSE, 0);
 676         gtk_widget_show(fdm->rename_auto_box);
 677
 678         hbox = pref_box_new(gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
 679
 680         fdm->rename_box = gtk_check_button_new_with_label(_("Rename"));
 681         g_signal_connect(G_OBJECT(fdm->rename_box), "clicked",
 682                          G_CALLBACK(file_util_move_multiple_rename_cb), gd);
 683         gtk_box_pack_start(GTK_BOX(hbox), fdm->rename_box, FALSE, FALSE, 0);
 684         gtk_widget_show(fdm->rename_box);
 685
 686         fdm->rename_entry = gtk_entry_new();
 687         gtk_entry_set_text(GTK_ENTRY(fdm->rename_entry), filename_from_path(fdm->dest));
 688         gtk_widget_set_sensitive(fdm->rename_entry, FALSE);
 689         gtk_box_pack_start(GTK_BOX(hbox), fdm->rename_entry, TRUE, TRUE, 0);
 690         gtk_widget_show(fdm->rename_entry);
 691
 692         return gd;
 693 }
 694
 695 static void file_util_move_multiple(FileDataMult *fdm)
 696 {
 697         while (fdm->dest || fdm->source_next)
 698                 {
 699                 gint success = FALSE;
 700                 gint skip_file = FALSE;
 701
 702                 if (!fdm->dest)
 703                         {
 704                         GList *work = fdm->source_next;
 705                         fdm->source_fd = work->data;
 706                         fdm->dest = concat_dir_and_file(fdm->dest_base, fdm->source_fd->name);
 707                         fdm->source_next = work->next;
 708                         fdm->confirmed = FALSE;
 709                         }
 710
 711                 if (fdm->dest && fdm->source_fd && strcmp(fdm->dest, fdm->source_fd->name) == 0)
 712                         {
 713                         if (!fdm->confirmed)
 714                                 {
 715                                 GenericDialog *gd;
 716                                 const gchar *title;
 717                                 gchar *text;
 718
 719                                 if (fdm->copy)
 720                                         {
 721                                         title = _("Source to copy matches destination");
 722                                         text = g_strdup_printf(_("Unable to copy file:\n%s\nto itself."), fdm->dest);
 723                                         }
 724                                 else
 725                                         {
 726                                         title = _("Source to move matches destination");
 727                                         text = g_strdup_printf(_("Unable to move file:\n%s\nto itself."), fdm->dest);
 728                                         }
 729
 730                                 gd = file_util_gen_dlg(title, GQ_WMCLASS, "dlg_confirm",
 731                                                         NULL, TRUE,
 732                                                         file_util_move_multiple_cancel_cb, fdm);
 733                                 generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING, title, text);
 734                                 g_free(text);
 735                                 generic_dialog_add_button(gd, GTK_STOCK_GO_FORWARD, _("Co_ntinue"),
 736                                                          file_util_move_multiple_continue_cb, TRUE);
 737
 738                                 gtk_widget_show(gd->dialog);
 739                                 return;
 740                                 }
 741                         skip_file = TRUE;
 742                         }
 743                 else if (isfile(fdm->dest))
 744                         {
 745                         if (!fdm->confirmed && !fdm->confirm_all)
 746                                 {
 747                                 GenericDialog *gd;
 748
 749                                 gd = file_util_move_multiple_confirm_dialog(fdm);
 750                                 gtk_widget_show(gd->dialog);
 751                                 return;
 752                                 }
 753                         if (fdm->skip) skip_file = TRUE;
 754                         }
 755
 756                 if (skip_file)
 757                         {
 758                         success = TRUE;
 759                         if (!fdm->confirm_all) fdm->skip = FALSE;
 760                         }
 761                 else
 762                         {
 763                         gint try = TRUE;
 764
 765                         if (fdm->confirm_all && fdm->rename_all && isfile(fdm->dest))
 766                                 {
 767                                 gchar *buf;
 768                                 buf = unique_filename_simple(fdm->dest);
 769                                 if (buf)
 770                                         {
 771                                         g_free(fdm->dest);
 772                                         fdm->dest = buf;
 773                                         }
 774                                 else
 775                                         {
 776                                         try = FALSE;
 777                                         }
 778                                 }
 779                         if (try)
 780                                 {
 781                                 if (fdm->copy)
 782                                         {
 783                                         if (file_data_add_change_info(fdm->source_fd, FILEDATA_CHANGE_COPY, fdm->source_fd->path, fdm->dest) &&
 784                                             copy_file_ext(fdm->source_fd))
 785                                                 {
 786                                                 success = TRUE;
 787                                                 }
 788                                         }
 789                                 else
 790                                         {
 791                                         if (file_data_add_change_info(fdm->source_fd, FILEDATA_CHANGE_MOVE, fdm->source_fd->path, fdm->dest) &&
 792                                             move_file_ext(fdm->source_fd))
 793                                                 {
 794                                                 success = TRUE;
 795                                                 }
 796                                         }
 797
 798                                 }
 799                         }
 800                 if (!success)
 801                         {
 802                         GenericDialog *gd;
 803                         const gchar *title;
 804                         gchar *text;
 805
 806                         if (fdm->copy)
 807                                 {
 808                                 title = _("Error copying file");
 809                                 text = g_strdup_printf(_("Unable to copy file:\n%s\nto:\n%s\nduring multiple file copy."), fdm->source_fd->path, fdm->dest);
 810                                 }
 811                         else
 812                                 {
 813                                 title = _("Error moving file");
 814                                 text = g_strdup_printf(_("Unable to move file:\n%s\nto:\n%s\nduring multiple file move."), fdm->source_fd->path, fdm->dest);
 815                                 }
 816                         gd = file_util_gen_dlg(title, GQ_WMCLASS, "dlg_confirm",
 817                                                 NULL, TRUE,
 818                                                 file_util_move_multiple_cancel_cb, fdm);
 819                         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING, title, text);
 820                         g_free(text);
 821
 822                         generic_dialog_add_button(gd, GTK_STOCK_GO_FORWARD, _("Co_ntinue"),
 823                                                   file_util_move_multiple_continue_cb, TRUE);
 824                         gtk_widget_show(gd->dialog);
 825                         }
 826
 827                 g_free(fdm->dest);
 828                 fdm->dest = NULL;
 829
 830                 if (!success) return;
 831                 }
 832 /*
 833         if (fdm->source_list)
 834                 file_util_do_move_list(fdm->source_list, fdm->copy);
 835         else
 836                 {
 837                 GList *list = g_list_append(NULL, file_data_ref(fdm->source_fd));
 838                 file_util_do_move_list(list, fdm->copy);
 839                 filelist_free(list);
 840                 }
 841 */
 842         file_data_multiple_free(fdm);
 843 }
 844
 845 /*
 846  * Single file move
 847  */
 848
 849 static FileDataSingle *file_data_single_new(FileData *source_fd, const gchar *dest, gint copy)
 850 {
 851         FileDataSingle *fds = g_new0(FileDataSingle, 1);
 852         fds->confirmed = FALSE;
 853         fds->source_fd = file_data_ref(source_fd);
 854         fds->dest = g_strdup(dest);
 855         fds->copy = copy;
 856         return fds;
 857 }
 858
 859 static void file_data_single_free(FileDataSingle *fds)
 860 {
 861         file_data_unref(fds->source_fd);
 862         g_free(fds->dest);
 863         g_free(fds);
 864 }
 865
 866 static void file_util_move_single(FileDataSingle *fds);
 867
 868 static void file_util_move_single_ok_cb(GenericDialog *gd, gpointer data)
 869 {
 870         FileDataSingle *fds = data;
 871
 872         fds->confirmed = TRUE;
 873
 874         if (fds->rename_auto)
 875                 {
 876                 gchar *buf;
 877
 878                 buf = unique_filename_simple(fds->dest);
 879                 if (buf)
 880                         {
 881                         g_free(fds->dest);
 882                         fds->dest = buf;
 883                         }
 884                 else
 885                         {
 886                         /* unique failed? well, return to the overwrite prompt :( */
 887                         fds->confirmed = FALSE;
 888                         }
 889                 }
 890         else if (fds->rename)
 891                 {
 892                 const gchar *name;
 893
 894                 name = gtk_entry_get_text(GTK_ENTRY(fds->rename_entry));
 895                 if (strlen(name) == 0 ||
 896                     strcmp(name, fds->source_fd->name) == 0)
 897                         {
 898                         fds->confirmed = FALSE;
 899                         }
 900                 else
 901                         {
 902                         gchar *base;
 903
 904                         base = remove_level_from_path(fds->dest);
 905                         g_free(fds->dest);
 906                         fds->dest = concat_dir_and_file(base, name);
 907                         fds->confirmed = !isname(fds->dest);
 908
 909                         g_free(base);
 910                         }
 911                 }
 912
 913         file_util_move_single(fds);
 914 }
 915
 916 static void file_util_move_single_cancel_cb(GenericDialog *gd, gpointer data)
 917 {
 918         FileDataSingle *fds = data;
 919
 920         file_data_single_free(fds);
 921 }
 922
 923 static void file_util_move_single_rename_auto_cb(GtkWidget *widget, gpointer data)
 924 {
 925         GenericDialog *gd = data;
 926         FileDataSingle *fds;
 927
 928         fds = gd->data;
 929
 930         fds->rename_auto = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 931         gtk_widget_set_sensitive(fds->rename_box, !fds->rename_auto);
 932         gtk_widget_set_sensitive(fds->rename_entry, (!fds->rename_auto && fds->rename));
 933
 934         if (fds->rename_auto)
 935                 {
 936                 gchar *preview;
 937
 938                 preview = unique_filename_simple(fds->dest);
 939                 if (preview) gtk_entry_set_text(GTK_ENTRY(fds->rename_entry), filename_from_path(preview));
 940                 g_free(preview);
 941                 }
 942 }
 943
 944 static void file_util_move_single_rename_cb(GtkWidget *widget, gpointer data)
 945 {
 946         GenericDialog *gd = data;
 947         FileDataSingle *fds;
 948
 949         fds = gd->data;
 950
 951         fds->rename = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 952         gtk_widget_set_sensitive(fds->rename_entry, fds->rename);
 953
 954         if (fds->rename)
 955                 {
 956                 const gchar *name;
 957
 958                 gtk_widget_grab_focus(fds->rename_entry);
 959
 960                 name = gtk_entry_get_text(GTK_ENTRY(fds->rename_entry));
 961                 gtk_editable_select_region(GTK_EDITABLE(fds->rename_entry), 0, filename_base_length(name));
 962                 }
 963 }
 964
 965 static void file_util_move_single(FileDataSingle *fds)
 966 {
 967         if (fds->dest && fds->source_fd && strcmp(fds->dest, fds->source_fd->name) == 0)
 968                 {
 969                 file_util_warning_dialog(_("Source matches destination"),
 970                                          _("Source and destination are the same, operation cancelled."),
 971                                          GTK_STOCK_DIALOG_INFO, NULL);
 972                 }
 973         else if (isfile(fds->dest) && !fds->confirmed)
 974                 {
 975                 GenericDialog *gd;
 976                 GtkWidget *hbox;
 977
 978                 gd = file_util_gen_dlg(_("Overwrite file"), GQ_WMCLASS, "dlg_confirm",
 979                                         NULL, TRUE,
 980                                         file_util_move_single_cancel_cb, fds);
 981
 982                 generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION,
 983                                            _("Overwrite file?"),
 984                                            _("Replace existing file with new file."));
 985                 pref_spacer(gd->vbox, 0);
 986
 987                 generic_dialog_add_button(gd, GTK_STOCK_OK, _("_Overwrite"), file_util_move_single_ok_cb, TRUE);
 988                 generic_dialog_add_image(gd, NULL, file_data_new_simple(fds->dest), _("Existing file"), fds->source_fd, _("New file"), TRUE);
 989
 990                 /* rename option */
 991
 992                 fds->rename = FALSE;
 993                 fds->rename_auto = FALSE;
 994
 995                 hbox = pref_box_new(gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
 996
 997                 fds->rename_auto_box = gtk_check_button_new_with_label(_("Auto rename"));
 998                 g_signal_connect(G_OBJECT(fds->rename_auto_box), "clicked",
 999                                  G_CALLBACK(file_util_move_single_rename_auto_cb), gd);
1000                 gtk_box_pack_start(GTK_BOX(hbox), fds->rename_auto_box, FALSE, FALSE, 0);
1001                 gtk_widget_show(fds->rename_auto_box);
1002
1003                 hbox = pref_box_new(gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
1004
1005                 fds->rename_box = gtk_check_button_new_with_label(_("Rename"));
1006                 g_signal_connect(G_OBJECT(fds->rename_box), "clicked",
1007                                  G_CALLBACK(file_util_move_single_rename_cb), gd);
1008                 gtk_box_pack_start(GTK_BOX(hbox), fds->rename_box, FALSE, FALSE, 0);
1009                 gtk_widget_show(fds->rename_box);
1010
1011                 fds->rename_entry = gtk_entry_new();
1012                 gtk_entry_set_text(GTK_ENTRY(fds->rename_entry), filename_from_path(fds->dest));
1013                 gtk_widget_set_sensitive(fds->rename_entry, FALSE);
1014                 gtk_box_pack_start(GTK_BOX(hbox), fds->rename_entry, TRUE, TRUE, 0);
1015                 gtk_widget_show(fds->rename_entry);
1016
1017                 gtk_widget_show(gd->dialog);
1018                 return;
1019                 }
1020         else
1021                 {
1022                 gint success = FALSE;
1023                 if (fds->copy)
1024                         {
1025                         if (file_data_add_change_info(fds->source_fd, FILEDATA_CHANGE_COPY, fds->source_fd->path, fds->dest) &&
1026                             copy_file_ext(fds->source_fd))
1027                                 {
1028                                 success = TRUE;
1029                                 }
1030                         }
1031                 else
1032                         {
1033                         if (file_data_add_change_info(fds->source_fd, FILEDATA_CHANGE_MOVE, fds->source_fd->path, fds->dest) &&
1034                             move_file_ext(fds->source_fd))
1035                                 {
1036                                 success = TRUE;
1037                                 }
1038                         }
1039                 if (!success)
1040                         {
1041                         gchar *title;
1042                         gchar *text;
1043                         if (fds->copy)
1044                                 {
1045                                 title = _("Error copying file");
1046                                 text = g_strdup_printf(_("Unable to copy file:\n%s\nto:\n%s"), fds->source_fd->name, fds->dest);
1047                                 }
1048                         else
1049                                 {
1050                                 title = _("Error moving file");
1051                                 text = g_strdup_printf(_("Unable to move file:\n%s\nto:\n%s"), fds->source_fd->name, fds->dest);
1052                                 }
1053                         file_util_warning_dialog(title, text, GTK_STOCK_DIALOG_ERROR, NULL);
1054                         g_free(text);
1055                         }
1056                 }
1057
1058         file_data_single_free(fds);
1059 }
1060
1061 /*
1062  * file move dialog
1063  */
1064
1065 static void file_util_move_do(FileDialog *fdlg)
1066 {
1067         file_dialog_sync_history(fdlg, TRUE);
1068
1069         if (fdlg->multiple_files)
1070                 {
1071                 file_util_move_multiple(file_data_multiple_new(fdlg->source_list, fdlg->dest_path, fdlg->type));
1072                 fdlg->source_list = NULL;
1073                 }
1074         else
1075                 {
1076                 if (isdir(fdlg->dest_path))
1077                         {
1078                         gchar *buf = concat_dir_and_file(fdlg->dest_path, fdlg->source_fd->name);
1079                         gtk_entry_set_text(GTK_ENTRY(fdlg->entry), buf);
1080                         g_free(buf);
1081                         }
1082                 file_util_move_single(file_data_single_new(fdlg->source_fd, fdlg->dest_path, fdlg->type));
1083                 }
1084
1085         file_dialog_close(fdlg);
1086 }
1087
1088 static void file_util_move_check(FileDialog *fdlg)
1089 {
1090         if (fdlg->dest_path && strcmp(fdlg->dest_path, "~") == 0)
1091                 {
1092                 gtk_entry_set_text(GTK_ENTRY(fdlg->entry), homedir());
1093                 }
1094
1095         if (fdlg->multiple_files && !isdir(fdlg->dest_path))
1096                 {
1097                 if (isfile(fdlg->dest_path))
1098                         {
1099                         file_util_warning_dialog(_("Invalid destination"),
1100                                                  _("When operating with multiple files, please select\na folder, not a file."),
1101                                                  GTK_STOCK_DIALOG_INFO, NULL);
1102                         }
1103                 else
1104                         file_util_warning_dialog(_("Invalid folder"),
1105                                                  _("Please select an existing folder."),
1106                                                  GTK_STOCK_DIALOG_INFO, NULL);
1107                 return;
1108                 }
1109
1110         if (!fdlg->dest_path || fdlg->dest_path[0] != '/')
1111                 {
1112                 if (fdlg->source_fd)
1113                         {
1114                         gchar *base;
1115                         gchar *path;
1116
1117                         base = remove_level_from_path(fdlg->source_fd->path);
1118                         path = concat_dir_and_file(base, fdlg->dest_path);
1119
1120                         gtk_entry_set_text(GTK_ENTRY(fdlg->entry), path);
1121
1122                         g_free(path);
1123                         g_free(base);
1124                         }
1125                 return;
1126                 }
1127
1128         file_util_move_do(fdlg);
1129 }
1130
1131 static void file_util_move_cb(FileDialog *fdlg, gpointer data)
1132 {
1133         file_util_move_check(fdlg);
1134 }
1135
1136 static void file_util_move_cancel_cb(FileDialog *fdlg, gpointer data)
1137 {
1138         file_dialog_close(fdlg);
1139 }
1140
1141 static void real_file_util_move(FileData *source_fd, GList *source_list,
1142                                 const gchar *dest_path, gint copy, GtkWidget *parent)
1143 {
1144         FileDialog *fdlg;
1145         GtkWidget *label;
1146         FileData *fd = NULL;
1147         gint multiple;
1148         const gchar *text;
1149         gchar *title;
1150         const gchar *op_text;
1151         const gchar *stock_id;
1152
1153         if (!source_fd && !source_list) return;
1154
1155         if (source_fd)
1156                 {
1157                 fd = file_data_ref(source_fd);
1158                 multiple = FALSE;
1159                 }
1160         else if (source_list->next)
1161                 {
1162                 multiple = TRUE;
1163                 }
1164         else
1165                 {
1166                 fd = file_data_ref(source_list->data);
1167                 filelist_free(source_list);
1168                 source_list = NULL;
1169                 multiple = FALSE;
1170                 }
1171
1172         if (copy)
1173                 {
1174                 title = g_strdup_printf("%s -%s", _("Copy"), GQ_APPNAME);
1175                 op_text = _("_Copy");
1176                 if (fd)
1177                         {
1178                         text = _("Copy file");
1179                         }
1180                 else
1181                         {
1182                         text = _("Copy multiple files");
1183                         }
1184                 stock_id = GTK_STOCK_COPY;
1185                 }
1186         else
1187                 {
1188                 title = g_strdup_printf("%s -%s", _("Move"), GQ_APPNAME);
1189                 op_text = _("_Move");
1190                 if (fd)
1191                         {
1192                         text = _("Move file");
1193                         }
1194                 else
1195                         {
1196                         text = _("Move multiple files");
1197                         }
1198                 stock_id = GTK_STOCK_OK;
1199                 }
1200
1201         fdlg = file_util_file_dlg(title, GQ_WMCLASS, "dlg_copymove", parent,
1202                                 file_util_move_cancel_cb, NULL);
1203         g_free(title);
1204         generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, text, NULL);
1205
1206         if (fd)
1207                 {
1208                 GtkWidget *box;
1209
1210                 box = pref_box_new(GENERIC_DIALOG(fdlg)->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
1211                 pref_label_new(box, _("File name:"));
1212                 pref_label_new(box, fd->name);
1213                 }
1214
1215         label = pref_label_new(GENERIC_DIALOG(fdlg)->vbox, _("Choose the destination folder."));
1216         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
1217         pref_spacer(GENERIC_DIALOG(fdlg)->vbox, 0);
1218
1219         file_dialog_add_button(fdlg, stock_id, op_text, file_util_move_cb, TRUE);
1220
1221         file_dialog_add_path_widgets(fdlg, NULL, dest_path, "move_copy", NULL, NULL);
1222
1223         fdlg->type = copy;
1224         fdlg->source_fd = fd;
1225         fdlg->source_list = source_list;
1226         fdlg->multiple_files = multiple;
1227
1228         gtk_widget_show(GENERIC_DIALOG(fdlg)->dialog);
1229 }
1230
1231 void file_util_move(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent)
1232 {
1233         real_file_util_move(source_fd, source_list, dest_path, FALSE, parent);
1234 }
1235
1236 void file_util_copy(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent)
1237 {
1238         real_file_util_move(source_fd, source_list, dest_path, TRUE, parent);
1239 }
1240
1241 void file_util_move_simple(GList *list, const gchar *dest_path)
1242 {
1243         if (!list) return;
1244         if (!dest_path)
1245                 {
1246                 filelist_free(list);
1247                 return;
1248                 }
1249
1250         if (!list->next)
1251                 {
1252                 FileData *source_fd;
1253                 gchar *dest;
1254
1255                 source_fd = list->data;
1256                 dest = concat_dir_and_file(dest_path, source_fd->name);
1257
1258                 file_util_move_single(file_data_single_new(source_fd, dest, FALSE));
1259                 g_free(dest);
1260                 filelist_free(list);
1261                 return;
1262                 }
1263
1264         file_util_move_multiple(file_data_multiple_new(list, dest_path, FALSE));
1265 }
1266
1267 void file_util_copy_simple(GList *list, const gchar *dest_path)
1268 {
1269         if (!list) return;
1270         if (!dest_path)
1271                 {
1272                 filelist_free(list);
1273                 return;
1274                 }
1275
1276         if (!list->next)
1277                 {
1278                 FileData *source_fd;
1279                 gchar *dest;
1280
1281                 source_fd = list->data;
1282                 dest = concat_dir_and_file(dest_path, source_fd->name);
1283
1284                 file_util_move_single(file_data_single_new(source_fd, dest, TRUE));
1285                 g_free(dest);
1286                 filelist_free(list);
1287                 return;
1288                 }
1289
1290         file_util_move_multiple(file_data_multiple_new(list, dest_path, TRUE));
1291 }
1292
1293 /*
1294  *--------------------------------------------------------------------------
1295  * Safe Delete
1296  *--------------------------------------------------------------------------
1297  */
1298
1299 static gint file_util_safe_number(gint64 free_space)
1300 {
1301         gint n = 0;
1302         gint64 total = 0;
1303         GList *list;
1304         GList *work;
1305         gint sorted = FALSE;
1306         gint warned = FALSE;
1307
1308         if (!filelist_read(options->file_ops.safe_delete_path, &list, NULL)) return 0;
1309
1310         work = list;
1311         while (work)
1312                 {
1313                 FileData *fd;
1314                 gint v;
1315
1316                 fd = work->data;
1317                 work = work->next;
1318
1319                 v = (gint)strtol(fd->name, NULL, 10);
1320                 if (v >= n) n = v + 1;
1321
1322                 total += fd->size;
1323                 }
1324
1325         while (options->file_ops.safe_delete_folder_maxsize > 0 && list &&
1326                (free_space < 0 || total + free_space > (gint64)options->file_ops.safe_delete_folder_maxsize * 1048576) )
1327                 {
1328                 FileData *fd;
1329
1330                 if (!sorted)
1331                         {
1332                         list = filelist_sort(list, SORT_NAME, TRUE);
1333                         sorted = TRUE;
1334                         }
1335
1336                 fd = list->data;
1337                 list = g_list_remove(list, fd);
1338
1339                 if (debug) printf("expunging from trash for space: %s\n", fd->name);
1340                 if (!unlink_file(fd->path) && !warned)
1341                         {
1342                         file_util_warning_dialog(_("Delete failed"),
1343                                                  _("Unable to remove old file from trash folder"),
1344                                                  GTK_STOCK_DIALOG_WARNING, NULL);
1345                         warned = TRUE;
1346                         }
1347                 total -= fd->size;
1348                 file_data_unref(fd);
1349                 }
1350
1351         filelist_free(list);
1352
1353         return n;
1354 }
1355
1356 void file_util_trash_clear(void)
1357 {
1358         file_util_safe_number(-1);
1359 }
1360
1361 static gchar *file_util_safe_dest(const gchar *path)
1362 {
1363         gint n;
1364
1365         n = file_util_safe_number(filesize(path));
1366         return g_strdup_printf("%s/%06d_%s", options->file_ops.safe_delete_path, n, filename_from_path(path));
1367 }
1368
1369 static void file_util_safe_del_toggle_cb(GtkWidget *button, gpointer data)
1370 {
1371         options->file_ops.safe_delete_enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
1372 }
1373
1374 static void file_util_safe_del_close_cb(GtkWidget *dialog, gpointer data)
1375 {
1376         GenericDialog **gd = data;
1377
1378         *gd = NULL;
1379 }
1380
1381 static gint file_util_unlink(FileData *fd)
1382 {
1383         static GenericDialog *gd = NULL;
1384         gchar *result = NULL;
1385         gint success = TRUE;
1386
1387         if (!isfile(fd->path)) return FALSE;
1388
1389
1390         if (!options->file_ops.safe_delete_enable)
1391                 {
1392                 return unlink_file(fd->path);
1393                 }
1394
1395         if (!isdir(options->file_ops.safe_delete_path))
1396                 {
1397                 if (debug) printf("creating trash: %s\n", options->file_ops.safe_delete_path);
1398                 if (!options->file_ops.safe_delete_path || !mkdir_utf8(options->file_ops.safe_delete_path, 0755))
1399                         {
1400                         result = _("Could not create folder");
1401                         success = FALSE;
1402                         }
1403                 }
1404
1405         if (success)
1406                 {
1407                 gchar *dest;
1408
1409                 dest = file_util_safe_dest(fd->path);
1410                 if (dest)
1411                         {
1412                         if (debug) printf("safe deleting %s to %s\n", fd->path, dest);
1413                         success = move_file(fd->path, dest);
1414                         }
1415                 else
1416                         {
1417                         success = FALSE;
1418                         }
1419
1420                 if (!success && !access_file(fd->path, W_OK))
1421                         {
1422                         result = _("Permission denied");
1423                         }
1424                 g_free(dest);
1425                 }
1426
1427         if (result && !gd)
1428                 {
1429                 GtkWidget *button;
1430                 gchar *buf;
1431
1432                 buf = g_strdup_printf(_("Unable to access or create the trash folder.\n\"%s\""), options->file_ops.safe_delete_path);
1433                 gd = file_util_warning_dialog(result, buf, GTK_STOCK_DIALOG_WARNING, NULL);
1434                 g_free(buf);
1435
1436                 button = gtk_check_button_new_with_label(_("Turn off safe delete"));
1437                 g_signal_connect(G_OBJECT(button), "toggled",
1438                                  G_CALLBACK(file_util_safe_del_toggle_cb), NULL);
1439                 gtk_box_pack_start(GTK_BOX(gd->vbox), button, FALSE, FALSE, 0);
1440                 gtk_widget_show(button);
1441
1442                 g_signal_connect(G_OBJECT(gd->dialog), "destroy",
1443                                  G_CALLBACK(file_util_safe_del_close_cb), &gd);
1444                 }
1445
1446         return success;
1447 }
1448
1449 static void box_append_safe_delete_status(GenericDialog *gd)
1450 {
1451         GtkWidget *label;
1452         gchar *buf;
1453
1454         if (options->editor_command[CMD_DELETE])
1455                 {
1456                 buf = g_strdup(_("Deletion by external command"));
1457                 }
1458         else
1459                 {
1460                 if (options->file_ops.safe_delete_enable)
1461                         {
1462                         gchar *buf2;
1463                         if (options->file_ops.safe_delete_folder_maxsize > 0)
1464                                 buf2 = g_strdup_printf(_(" (max. %d MB)"), options->file_ops.safe_delete_folder_maxsize);
1465                         else
1466                                 buf2 = g_strdup("");
1467
1468                         buf = g_strdup_printf(_("Safe delete: %s%s\nTrash: %s"), _("on"), buf2, options->file_ops.safe_delete_path);
1469                         g_free(buf2);
1470                         }
1471                 else
1472                         {
1473                         buf = g_strdup_printf(_("Safe delete: %s"), _("off"));
1474                         }
1475                 }
1476
1477         label = pref_label_new(gd->vbox, buf);
1478         g_free(buf);
1479
1480         gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
1481         gtk_widget_set_sensitive(label, FALSE);
1482 }
1483
1484 /*
1485  *--------------------------------------------------------------------------
1486  * Delete routines
1487  *--------------------------------------------------------------------------
1488  */
1489
1490 /*
1491  * delete multiple files
1492  */
1493
1494 static void file_util_delete_multiple_ok_cb(GenericDialog *gd, gpointer data);
1495 static void file_util_delete_multiple_cancel_cb(GenericDialog *gd, gpointer data);
1496
1497 static void file_util_delete_ext_ok_cb(GenericDialog *gd, gpointer data)
1498 {
1499         editor_resume(data);
1500 }
1501
1502 static void file_util_delete_ext_cancel_cb(GenericDialog *gd, gpointer data)
1503 {
1504         editor_skip(data);
1505 }
1506
1507
1508 static gint file_util_delete_ext_cb(gpointer resume_data, gint flags, GList *list, gpointer data)
1509 {
1510         gint ret = EDITOR_CB_CONTINUE;
1511         if ((flags & EDITOR_ERROR_MASK) && !(flags & EDITOR_ERROR_SKIPPED))
1512                 {
1513                         GString *msg = g_string_new(editor_get_error_str(flags));
1514                         g_string_append(msg,_("\nUnable to delete file by external command:\n"));
1515                         GenericDialog *d;
1516                         while (list)
1517                                 {
1518                                 FileData *fd = list->data;
1519
1520                                 g_string_append(msg, fd->path);
1521                                 g_string_append(msg, "\n");
1522                                 list = list->next;
1523                                 }
1524                         if (resume_data)
1525                                 {
1526                                 g_string_append(msg, _("\n Continue multiple delete operation?"));
1527                                 d = file_util_gen_dlg(_("Delete failed"), GQ_WMCLASS, "dlg_confirm",
1528                                                       NULL, TRUE,
1529                                                       file_util_delete_ext_cancel_cb, resume_data);
1530
1531                                 generic_dialog_add_message(d, GTK_STOCK_DIALOG_WARNING, NULL, msg->str);
1532
1533                                 generic_dialog_add_button(d, GTK_STOCK_GO_FORWARD, _("Co_ntinue"),
1534                                                           file_util_delete_ext_ok_cb, TRUE);
1535                                 gtk_widget_show(d->dialog);
1536                                 ret = EDITOR_CB_SUSPEND;
1537                                 }
1538                         else
1539                                 {
1540                                 file_util_warning_dialog(_("Delete failed"), msg->str, GTK_STOCK_DIALOG_ERROR, NULL);
1541                                 }
1542                         g_string_free(msg, TRUE);
1543                 }
1544
1545
1546                 {
1547                 while (list)
1548                         {
1549                         FileData *fd = list->data;
1550                         if (flags & EDITOR_ERROR_MASK)
1551                                 /* an error occured -> no change -> delete change info */
1552                                 file_data_change_info_free(NULL, fd);
1553                         else
1554                                 /* files were successfully deleted, call the maint functions and keep the change info forever */
1555                                 file_maint_removed(fd, list);
1556                         list = list->next;
1557                         }
1558                 }
1559         return ret;
1560 }
1561
1562 static void file_util_delete_multiple_ok_cb(GenericDialog *gd, gpointer data)
1563 {
1564         GList *source_list = data;
1565         GList *work = source_list;
1566         gboolean ok = TRUE;
1567
1568         while (work)
1569                 {
1570                 FileData *fd = work->data;
1571                 if (fd->change) ok = FALSE; /* another operation in progress */
1572                 work = work->next;
1573                 }
1574
1575         if (!ok)
1576                 {
1577                 file_util_warning_dialog(_("File deletion failed"), _("Another operation in progress.\n"), GTK_STOCK_DIALOG_ERROR, NULL);
1578                 filelist_free(source_list);
1579                 return;
1580                 }
1581
1582
1583         if (options->editor_command[CMD_DELETE])
1584                 {
1585                 gint flags;
1586                 work = source_list;
1587                 while (work)
1588                         {
1589                         FileData *fd = work->data;
1590                         file_data_add_change_info(fd, FILEDATA_CHANGE_DELETE, NULL, NULL);
1591                         work = work->next;
1592                         }
1593
1594                 if ((flags = start_editor_from_filelist_full(CMD_DELETE, source_list, file_util_delete_ext_cb, NULL)))
1595                         {
1596                         gchar *text = g_strdup_printf(_("%s\nUnable to delete files by external command.\n"), editor_get_error_str(flags));
1597                         file_util_warning_dialog(_("File deletion failed"), text, GTK_STOCK_DIALOG_ERROR, NULL);
1598                         g_free(text);
1599                         }
1600
1601                 filelist_free(source_list);
1602                 return;
1603                 }
1604
1605
1606         while (source_list)
1607                 {
1608                 FileData *fd = source_list->data;
1609
1610                 source_list = g_list_remove(source_list, fd);
1611
1612                 if (!file_util_unlink(fd))
1613                         {
1614                         if (source_list)
1615                                 {
1616                                 GenericDialog *d;
1617                                 gchar *text;
1618
1619                                 d = file_util_gen_dlg(_("Delete failed"), GQ_WMCLASS, "dlg_confirm",
1620                                                       NULL, TRUE,
1621                                                       file_util_delete_multiple_cancel_cb, source_list);
1622
1623                                 text = g_strdup_printf(_("Unable to delete file:\n %s\n Continue multiple delete operation?"), fd->path);
1624                                 generic_dialog_add_message(d, GTK_STOCK_DIALOG_WARNING, NULL, text);
1625                                 g_free(text);
1626
1627                                 generic_dialog_add_button(d, GTK_STOCK_GO_FORWARD, _("Co_ntinue"),
1628                                                           file_util_delete_multiple_ok_cb, TRUE);
1629                                 gtk_widget_show(d->dialog);
1630                                 }
1631                         else
1632                                 {
1633                                 gchar *text;
1634
1635                                 text = g_strdup_printf(_("Unable to delete file:\n%s"), fd->path);
1636                                 file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, NULL);
1637                                 g_free(text);
1638                                 }
1639                         file_data_unref(fd);
1640                         return;
1641                         }
1642                 else
1643                         {
1644                         file_maint_removed(fd, source_list);
1645                         }
1646                 file_data_unref(fd);
1647                 }
1648 }
1649
1650 static void file_util_delete_multiple_cancel_cb(GenericDialog *gd, gpointer data)
1651 {
1652         GList *source_list = data;
1653
1654         filelist_free(source_list);
1655 }
1656
1657 static void file_util_delete_multiple_review_skip(GenericDialog *gd, gint next)
1658 {
1659         GtkWidget *button_back;
1660         GtkWidget *button_next;
1661         GtkWidget *button_label;
1662         GList *list;
1663         GList *list_point;
1664         FileData *fd;
1665         gchar *buf;
1666
1667         list = gd->data;
1668         button_back = g_object_get_data(G_OBJECT(gd->dialog), "button_back");
1669         button_next = g_object_get_data(G_OBJECT(gd->dialog), "button_next");
1670         button_label = g_object_get_data(G_OBJECT(gd->dialog), "button_label");
1671         list_point = g_object_get_data(G_OBJECT(gd->dialog), "list_point");
1672
1673         if (!list || !button_label) return;
1674
1675         if (list_point)
1676                 {
1677                 if (next)
1678                         {
1679                         if (list_point->next) list_point = list_point->next;
1680                         }
1681                 else
1682                         {
1683                         if (list_point->prev) list_point = list_point->prev;
1684                         }
1685                 }
1686         else
1687                 {
1688                 list_point = list;
1689                 }
1690
1691         if (!list_point) return;
1692
1693         fd = list_point->data;
1694         buf = g_strdup_printf(_("File %d of %d"),
1695                               g_list_index(list, (gpointer)fd) + 1,
1696                               g_list_length(list));
1697         gtk_label_set_text(GTK_LABEL(button_label), buf);
1698         g_free(buf);
1699
1700         gtk_widget_set_sensitive(button_back, (list_point->prev != NULL) );
1701         gtk_widget_set_sensitive(button_next, (list_point->next != NULL) );
1702
1703         generic_dialog_image_set(gd, fd);
1704
1705         g_object_set_data(G_OBJECT(gd->dialog), "list_point", list_point);
1706 }
1707
1708 static void file_util_delete_multiple_review_back(GtkWidget *button, gpointer data)
1709 {
1710         GenericDialog *gd = data;
1711
1712         file_util_delete_multiple_review_skip(gd, FALSE);
1713 }
1714
1715 static void file_util_delete_multiple_review_next(GtkWidget *button, gpointer data)
1716 {
1717         GenericDialog *gd = data;
1718
1719         file_util_delete_multiple_review_skip(gd, TRUE);
1720 }
1721
1722 static void file_util_delete_multiple_review_button_cb(ImageWindow *imd, gint button, guint32 time,
1723                                                        gdouble x, gdouble y, guint state, gpointer data)
1724 {
1725         if (button == MOUSE_BUTTON_LEFT)
1726                 {
1727                 file_util_delete_multiple_review_next(NULL, data);
1728                 }
1729         else if (button == MOUSE_BUTTON_MIDDLE || button == MOUSE_BUTTON_RIGHT)
1730                 {
1731                 file_util_delete_multiple_review_back(NULL, data);
1732                 }
1733 }
1734
1735 static void file_util_delete_multiple_review_scroll_cb(ImageWindow *imd, GdkScrollDirection direction, guint32 time,
1736                                                        gdouble x, gdouble y, guint state, gpointer data)
1737 {
1738         if (direction == GDK_SCROLL_UP)
1739                 {
1740                 file_util_delete_multiple_review_back(NULL, data);
1741                 }
1742         else if (direction == GDK_SCROLL_DOWN)
1743                 {
1744                 file_util_delete_multiple_review_next(NULL, data);
1745                 }
1746 }
1747
1748 static void file_util_delete_multiple(GList *source_list, GtkWidget *parent)
1749 {
1750         if (!options->file_ops.confirm_delete)
1751                 {
1752                 file_util_delete_multiple_ok_cb(NULL, source_list);
1753                 }
1754         else
1755                 {
1756                 GenericDialog *gd;
1757                 GtkWidget *hbox;
1758                 GtkWidget *button;
1759                 GtkWidget *label;
1760                 ImageWindow *imd;
1761                 gchar *buf;
1762                 gchar *title = g_strdup_printf("%s -%s", _("Delete files"), GQ_APPNAME);
1763
1764                 gd = file_util_gen_dlg(title, GQ_WMCLASS, "dlg_confirm", parent, TRUE,
1765                                        file_util_delete_multiple_cancel_cb, source_list);
1766                 g_free(title);
1767
1768                 generic_dialog_add_message(gd, NULL, _("Delete multiple files"), NULL);
1769
1770                 generic_dialog_add_image(gd, NULL, NULL, NULL, NULL, NULL, TRUE);
1771                 imd = g_object_get_data(G_OBJECT(gd->dialog), "img_image");
1772                 image_set_button_func(imd, file_util_delete_multiple_review_button_cb, gd);
1773                 image_set_scroll_func(imd, file_util_delete_multiple_review_scroll_cb, gd);
1774
1775                 hbox = pref_box_new(gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
1776
1777                 button = pref_button_new(hbox, GTK_STOCK_GO_BACK, NULL, TRUE,
1778                                          G_CALLBACK(file_util_delete_multiple_review_back), gd);
1779                 gtk_widget_set_sensitive(button, FALSE);
1780                 g_object_set_data(G_OBJECT(gd->dialog), "button_back", button);
1781
1782                 button = pref_button_new(hbox, GTK_STOCK_GO_FORWARD, NULL, TRUE,
1783                                          G_CALLBACK(file_util_delete_multiple_review_next), gd);
1784                 g_object_set_data(G_OBJECT(gd->dialog), "button_next", button);
1785
1786                 buf = g_strdup_printf(_("Review %d files"), g_list_length(source_list) );
1787                 label = pref_label_new(hbox, buf);
1788                 g_free(buf);
1789                 g_object_set_data(G_OBJECT(gd->dialog), "button_label", label);
1790
1791                 box_append_safe_delete_status(gd);
1792
1793                 generic_dialog_add_button(gd, GTK_STOCK_DELETE, NULL, file_util_delete_multiple_ok_cb, TRUE);
1794
1795                 gtk_widget_show(gd->dialog);
1796                 }
1797 }
1798
1799 /*
1800  * delete single file
1801  */
1802
1803 static void file_util_delete_ok_cb(GenericDialog *gd, gpointer data)
1804 {
1805         FileData *fd = data;
1806
1807         if (!file_data_add_change_info(fd, FILEDATA_CHANGE_DELETE, NULL, NULL))
1808                 {
1809                 file_util_warning_dialog(_("File deletion failed"), _("Another operation in progress.\n"), GTK_STOCK_DIALOG_ERROR, NULL);
1810                 file_data_unref(fd);
1811                 return;
1812                 }
1813
1814
1815         if (options->editor_command[CMD_DELETE])
1816                 {
1817                 gint flags;
1818                 if ((flags = start_editor_from_file_full(CMD_DELETE, fd, file_util_delete_ext_cb, NULL)))
1819                         {
1820                         gchar *text = g_strdup_printf(_("%s\nUnable to delete file by external command:\n%s"), editor_get_error_str(flags), fd->path);
1821                         file_util_warning_dialog(_("File deletion failed"), text, GTK_STOCK_DIALOG_ERROR, NULL);
1822                         g_free(text);
1823                         file_data_change_info_free(NULL, fd);
1824                         }
1825                 }
1826         else if (!file_util_unlink(fd))
1827                 {
1828                 gchar *text = g_strdup_printf(_("Unable to delete file:\n%s"), fd->path);
1829                 file_util_warning_dialog(_("File deletion failed"), text, GTK_STOCK_DIALOG_ERROR, NULL);
1830                 g_free(text);
1831                 file_data_change_info_free(NULL, fd);
1832                 }
1833         else
1834                 {
1835                 file_maint_removed(fd, NULL);
1836                 }
1837
1838         file_data_unref(fd);
1839 }
1840
1841 static void file_util_delete_cancel_cb(GenericDialog *gd, gpointer data)
1842 {
1843         FileData *fd = data;
1844
1845         file_data_unref(fd);
1846 }
1847
1848 static void file_util_delete_single(FileData *fd, GtkWidget *parent)
1849 {
1850         if (!options->file_ops.confirm_delete)
1851                 {
1852                 file_util_delete_ok_cb(NULL, file_data_ref(fd));
1853                 }
1854         else
1855                 {
1856                 GenericDialog *gd;
1857                 GtkWidget *table;
1858                 gchar *base;
1859                 gchar *title = g_strdup_printf("%s -%s", _("Delete file"), GQ_APPNAME);
1860
1861                 gd = file_util_gen_dlg(title, GQ_WMCLASS, "dlg_confirm", parent, TRUE,
1862                                        file_util_delete_cancel_cb, file_data_ref(fd));
1863                 g_free(title);
1864
1865                 generic_dialog_add_message(gd, NULL, _("Delete file?"), NULL);
1866
1867                 table = pref_table_new(gd->vbox, 2, 2, FALSE, FALSE);
1868
1869                 pref_table_label(table, 0, 0, _("File name:"), 1.0);
1870                 pref_table_label(table, 1, 0, fd->name, 0.0);
1871
1872                 pref_table_label(table, 0, 1, _("Location:"), 1.0);
1873
1874                 base = remove_level_from_path(fd->path);
1875                 pref_table_label(table, 1, 1, base, 0.0);
1876                 g_free(base);
1877
1878                 generic_dialog_add_image(gd, NULL, fd, NULL, NULL, NULL, FALSE);
1879
1880                 box_append_safe_delete_status(gd);
1881
1882                 generic_dialog_add_button(gd, GTK_STOCK_DELETE, NULL, file_util_delete_ok_cb, TRUE);
1883
1884                 gtk_widget_show(gd->dialog);
1885                 }
1886 }
1887
1888 void file_util_delete(FileData *source_fd, GList *source_list, GtkWidget *parent)
1889 {
1890         if (!source_fd && !source_list) return;
1891
1892         if (source_fd)
1893                 {
1894                 file_util_delete_single(source_fd, parent);
1895                 }
1896         else if (!source_list->next)
1897                 {
1898                 file_util_delete_single(source_list->data, parent);
1899                 filelist_free(source_list);
1900                 }
1901         else
1902                 {
1903                 file_util_delete_multiple(source_list, parent);
1904                 }
1905 }
1906
1907 /*
1908  *--------------------------------------------------------------------------
1909  * Rename routines
1910  *--------------------------------------------------------------------------
1911  */
1912
1913 /*
1914  * rename multiple files
1915  */
1916
1917 enum {
1918         RENAME_COLUMN_FD = 0,
1919         RENAME_COLUMN_PATH,
1920         RENAME_COLUMN_NAME,
1921         RENAME_COLUMN_PREVIEW,
1922         RENAME_COLUMN_COUNT
1923 };
1924
1925 typedef enum {
1926         RENAME_TYPE_MANUAL = 0,
1927         RENAME_TYPE_FORMATTED,
1928         RENAME_TYPE_AUTO
1929 } RenameType;
1930
1931 typedef struct _RenameDataMult RenameDataMult;
1932 struct _RenameDataMult
1933 {
1934         FileDialog *fdlg;
1935
1936         RenameType rename_type;
1937
1938         GtkWidget *listview;
1939         GtkWidget *combo_type;
1940
1941         GtkWidget *rename_box;
1942         GtkWidget *rename_label;
1943         GtkWidget *rename_entry;
1944
1945         GtkWidget *auto_box;
1946         GtkWidget *auto_entry_front;
1947         GtkWidget *auto_spin_start;
1948         GtkWidget *auto_spin_pad;
1949         GtkWidget *auto_entry_end;
1950
1951         GtkWidget *format_box;
1952         GtkWidget *format_entry;
1953         GtkWidget *format_spin;
1954
1955         ImageWindow *imd;
1956
1957         gint update_idle_id;
1958 };
1959
1960 static void file_util_rename_multiple(RenameDataMult *rd);
1961
1962 static void file_util_rename_multiple_ok_cb(GenericDialog *gd, gpointer data)
1963 {
1964         RenameDataMult *rd = data;
1965         GtkWidget *dialog;
1966
1967         dialog = GENERIC_DIALOG(rd->fdlg)->dialog;
1968         if (!GTK_WIDGET_VISIBLE(dialog)) gtk_widget_show(dialog);
1969
1970         rd->fdlg->type = TRUE;
1971         file_util_rename_multiple(rd);
1972 }
1973
1974 static void file_util_rename_multiple_cancel_cb(GenericDialog *gd, gpointer data)
1975 {
1976         RenameDataMult *rd = data;
1977         GtkWidget *dialog;
1978
1979         dialog = GENERIC_DIALOG(rd->fdlg)->dialog;
1980         if (!GTK_WIDGET_VISIBLE(dialog)) gtk_widget_show(dialog);
1981 }
1982
1983 static gint file_util_rename_multiple_find_row(RenameDataMult *rd, FileData *fd, GtkTreeIter *iter)
1984 {
1985         GtkTreeModel *store;
1986         gint valid;
1987         gint row = 0;
1988
1989         store = gtk_tree_view_get_model(GTK_TREE_VIEW(rd->listview));
1990         valid = gtk_tree_model_get_iter_first(store, iter);
1991         while (valid)
1992                 {
1993                 FileData *fd_n;
1994                 gint ret;
1995
1996                 gtk_tree_model_get(GTK_TREE_MODEL(store), iter, RENAME_COLUMN_FD, &fd_n, -1);
1997                 ret = (fd_n == fd);
1998 //              file_data_unref(fd_n);
1999                 if (ret) return row;
2000
2001                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), iter);
2002                 row++;
2003                 }
2004
2005         return -1;
2006 }
2007
2008 static void file_util_rename_multiple(RenameDataMult *rd)
2009 {
2010         FileDialog *fdlg;
2011
2012         fdlg = rd->fdlg;
2013
2014         if (isfile(fdlg->dest_path) && !fdlg->type)
2015                 {
2016                 GenericDialog *gd;
2017
2018                 gd = file_util_gen_dlg(_("Overwrite file"), GQ_WMCLASS, "dlg_confirm",
2019                                         NULL, TRUE,
2020                                         file_util_rename_multiple_cancel_cb, rd);
2021
2022                 generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION,
2023                                            _("Overwrite file?"),
2024                                            _("Replace existing file by renaming new file."));
2025                 pref_spacer(gd->vbox, 0);
2026
2027                 generic_dialog_add_button(gd, GTK_STOCK_OK, _("_Overwrite"), file_util_rename_multiple_ok_cb, TRUE);
2028                 generic_dialog_add_image(gd, NULL,
2029                                          file_data_new_simple(fdlg->dest_path), _("Existing file"),
2030                                          fdlg->source_fd, _("New file"), TRUE);
2031
2032                 gtk_widget_hide(GENERIC_DIALOG(fdlg)->dialog);
2033
2034                 gtk_widget_show(gd->dialog);
2035                 return;
2036                 }
2037         else
2038                 {
2039                 if (!file_data_add_change_info(fdlg->source_fd, FILEDATA_CHANGE_RENAME, fdlg->source_fd->path, fdlg->dest_path) ||
2040                     !rename_file_ext(fdlg->source_fd))
2041                         {
2042                         gchar *text = g_strdup_printf(_("Unable to rename file:\n%s\n to:\n%s"),
2043                                                       fdlg->source_fd->name,
2044                                                       filename_from_path(fdlg->dest_path));
2045                         file_util_warning_dialog(_("Error renaming file"), text, GTK_STOCK_DIALOG_ERROR, NULL);
2046                         g_free(text);
2047                         }
2048                 else
2049                         {
2050                         GtkTreeModel *store;
2051                         GtkTreeIter iter;
2052                         GtkTreeIter next;
2053                         gint row;
2054
2055                         store = gtk_tree_view_get_model(GTK_TREE_VIEW(rd->listview));
2056                         row = file_util_rename_multiple_find_row(rd, rd->fdlg->source_fd, &iter);
2057
2058                         if (row >= 0 &&
2059                             (gtk_tree_model_iter_nth_child(store, &next, NULL, row + 1) ||
2060                             (row > 0 && gtk_tree_model_iter_nth_child(store, &next, NULL, row - 1)) ) )
2061                                 {
2062                                 GtkTreeSelection *selection;
2063
2064                                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(rd->listview));
2065                                 gtk_tree_selection_select_iter(selection, &next);
2066                                 gtk_list_store_remove(GTK_LIST_STORE(store), &iter);
2067                                 }
2068                         else
2069                                 {
2070                                 if (debug) printf("closed by #%d\n", row);
2071
2072                                 file_dialog_close(rd->fdlg);
2073                                 }
2074                         }
2075                 }
2076 }
2077
2078 /* format: * = filename without extension, ## = number position, extension is kept */
2079 static gchar *file_util_rename_multiple_auto_format_name(const gchar *format, const gchar *name, gint n)
2080 {
2081         gchar *new_name;
2082         gchar *parsed;
2083         const gchar *ext;
2084         gchar *middle;
2085         gchar *tmp;
2086         gchar *pad_start;
2087         gchar *pad_end;
2088         gint padding;
2089
2090         if (!format || !name) return NULL;
2091
2092         tmp = g_strdup(format);
2093         pad_start = strchr(tmp, '#');
2094         if (pad_start)
2095                 {
2096                 pad_end = pad_start;
2097                 padding = 0;
2098                 while (*pad_end == '#')
2099                         {
2100                         pad_end++;
2101                         padding++;
2102                         }
2103                 *pad_start = '\0';
2104
2105                 parsed = g_strdup_printf("%s%0*d%s", tmp, padding, n, pad_end);
2106                 g_free(tmp);
2107                 }
2108         else
2109                 {
2110                 parsed = tmp;
2111                 }
2112
2113         ext = extension_from_path(name);
2114
2115         middle = strchr(parsed, '*');
2116         if (middle)
2117                 {
2118                 gchar *base;
2119
2120                 *middle = '\0';
2121                 middle++;
2122
2123                 base = remove_extension_from_path(name);
2124                 new_name = g_strconcat(parsed, base, middle, ext, NULL);
2125                 g_free(base);
2126                 }
2127         else
2128                 {
2129                 new_name = g_strconcat(parsed, ext, NULL);
2130                 }
2131
2132         g_free(parsed);
2133
2134         return new_name;
2135 }
2136
2137 static void file_util_rename_multiple_auto(RenameDataMult *rd)
2138 {
2139         const gchar *front;
2140         const gchar *end;
2141         const gchar *format;
2142         gint start_n;
2143         gint padding;
2144         gint n;
2145         GtkTreeModel *store;
2146         GtkTreeIter iter;
2147         gint valid;
2148         gint success;
2149
2150         front = gtk_entry_get_text(GTK_ENTRY(rd->auto_entry_front));
2151         end = gtk_entry_get_text(GTK_ENTRY(rd->auto_entry_end));
2152         padding = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(rd->auto_spin_pad));
2153
2154         format = gtk_entry_get_text(GTK_ENTRY(rd->format_entry));
2155
2156         if (rd->rename_type == RENAME_TYPE_FORMATTED)
2157                 {
2158                 start_n = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(rd->format_spin));
2159
2160                 if (!format ||
2161                     (strchr(format, '*') == NULL && strchr(format, '#') == NULL))
2162                         {
2163                         file_util_warning_dialog(_("Auto rename"),
2164                                _("Format must include at least one of the symbol characters '*' or '#'.\n"),
2165                                GTK_STOCK_DIALOG_WARNING, NULL);
2166                         return;
2167                         }
2168
2169                 history_combo_append_history(rd->format_entry, NULL);
2170                 }
2171         else
2172                 {
2173                 start_n = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(rd->auto_spin_start));
2174
2175                 history_combo_append_history(rd->auto_entry_front, NULL);
2176                 history_combo_append_history(rd->auto_entry_end, NULL);
2177                 }
2178
2179         store = gtk_tree_view_get_model(GTK_TREE_VIEW(rd->listview));
2180
2181         /* first check for name conflicts */
2182         success = TRUE;
2183         n = start_n;
2184         valid = gtk_tree_model_get_iter_first(store, &iter);
2185         while (valid && success)
2186                 {
2187                 gchar *dest;
2188                 gchar *base;
2189                 FileData *fd;
2190
2191                 gtk_tree_model_get(store, &iter, RENAME_COLUMN_FD, &fd, -1);
2192                 base = remove_level_from_path(fd->path);
2193
2194                 if (rd->rename_type == RENAME_TYPE_FORMATTED)
2195                         {
2196                         gchar *new_name;
2197
2198                         new_name = file_util_rename_multiple_auto_format_name(format, fd->name, n);
2199                         dest = g_strconcat(base, "/", new_name, NULL);
2200                         g_free(new_name);
2201                         }
2202                 else
2203                         {
2204                         dest = g_strdup_printf("%s/%s%0*d%s", base, front, padding, n, end);
2205                         }
2206
2207                 if (isname(dest)) success = FALSE;
2208
2209                 g_free(dest);
2210                 g_free(base);
2211 //              file_data_unref(fd);
2212
2213                 n++;
2214                 valid = gtk_tree_model_iter_next(store, &iter);
2215                 }
2216
2217         if (!success)
2218                 {
2219                 file_util_warning_dialog(_("Auto rename"),
2220                                _("Can not auto rename with the selected\nnumber set, one or more files exist that\nmatch the resulting name list.\n"),
2221                                GTK_STOCK_DIALOG_WARNING, NULL);
2222                 return;
2223                 }
2224
2225         /* select the first iter, so that on fail the correct info is given to user */
2226         if (gtk_tree_model_get_iter_first(store, &iter))
2227                 {
2228                 GtkTreeSelection *selection;
2229
2230                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(rd->listview));
2231                 gtk_tree_selection_select_iter(selection, &iter);
2232                 }
2233
2234         /* now do it for real */
2235         success = TRUE;
2236         n = start_n;
2237         while (success && gtk_tree_model_get_iter_first(store, &iter))
2238                 {
2239                 gchar *dest;
2240                 gchar *base;
2241                 FileData *fd;
2242
2243                 gtk_tree_model_get(store, &iter, RENAME_COLUMN_FD, &fd, -1);
2244                 base = remove_level_from_path(fd->path);
2245
2246                 if (rd->rename_type == RENAME_TYPE_FORMATTED)
2247                         {
2248                         gchar *new_name;
2249
2250                         new_name = file_util_rename_multiple_auto_format_name(format, fd->name, n);
2251                         dest = g_strconcat(base, "/", new_name, NULL);
2252                         g_free(new_name);
2253                         }
2254                 else
2255                         {
2256                         dest = g_strdup_printf("%s/%s%0*d%s", base, front, padding, n, end);
2257                         }
2258
2259                 if (!file_data_add_change_info(fd, FILEDATA_CHANGE_RENAME, fd->path, dest) ||
2260                     !rename_file_ext(fd))
2261                         {
2262                         success = FALSE;
2263                         }
2264
2265                 g_free(dest);
2266                 g_free(base);
2267 //              file_data_unref(fd);
2268
2269                 if (success)
2270                         {
2271                         gtk_list_store_remove(GTK_LIST_STORE(store), &iter);
2272                         if (gtk_tree_model_get_iter_first(store, &iter))
2273                                 {
2274                                 GtkTreeSelection *selection;
2275
2276                                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(rd->listview));
2277                                 gtk_tree_selection_select_iter(selection, &iter);
2278                                 }
2279                         }
2280
2281                 n++;
2282                 }
2283
2284         if (!success)
2285                 {
2286                 gchar *buf;
2287
2288                 n--;
2289                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(rd->auto_spin_start), (gdouble)n);
2290
2291                 buf = g_strdup_printf(_("Failed to rename\n%s\nThe number was %d."), rd->fdlg->source_fd->name, n);
2292                 file_util_warning_dialog(_("Auto rename"), buf, GTK_STOCK_DIALOG_ERROR, NULL);
2293                 g_free(buf);
2294
2295                 return;
2296                 }
2297
2298         file_dialog_close(rd->fdlg);
2299 }
2300
2301 static void file_util_rename_multiple_cb(FileDialog *fdlg, gpointer data)
2302 {
2303         RenameDataMult *rd = data;
2304         gchar *base;
2305         const gchar *name;
2306
2307         if (rd->rename_type != RENAME_TYPE_MANUAL)
2308                 {
2309                 file_util_rename_multiple_auto(rd);
2310                 return;
2311                 }
2312
2313         name = gtk_entry_get_text(GTK_ENTRY(rd->rename_entry));
2314         base = remove_level_from_path(fdlg->source_fd->path);
2315
2316         g_free(fdlg->dest_path);
2317         fdlg->dest_path = concat_dir_and_file(base, name);
2318         g_free(base);
2319
2320         if (strlen(name) == 0 || strcmp(fdlg->source_fd->path, fdlg->dest_path) == 0)
2321                 {
2322                 return;
2323                 }
2324
2325         fdlg->type = FALSE;
2326         file_util_rename_multiple(rd);
2327 }
2328
2329 static void file_util_rename_multiple_close_cb(FileDialog *fdlg, gpointer data)
2330 {
2331         RenameDataMult *rd = data;
2332
2333         file_dialog_close(rd->fdlg);
2334 }
2335
2336 static gboolean file_util_rename_multiple_select_cb(GtkTreeSelection *selection, GtkTreeModel *store, GtkTreePath *tpath,
2337                                                     gboolean path_currently_selected, gpointer data)
2338 {
2339         RenameDataMult *rd = data;
2340         GtkTreeIter iter;
2341         const gchar *name;
2342         FileData *fd = NULL;
2343
2344         if (path_currently_selected ||
2345             !gtk_tree_model_get_iter(store, &iter, tpath)) return TRUE;
2346         gtk_tree_model_get(store, &iter, RENAME_COLUMN_FD, &fd, -1);
2347
2348         file_data_unref(rd->fdlg->source_fd);
2349         rd->fdlg->source_fd = file_data_ref(fd);
2350
2351         name = rd->fdlg->source_fd->name;
2352         gtk_label_set_text(GTK_LABEL(rd->rename_label), name);
2353         gtk_entry_set_text(GTK_ENTRY(rd->rename_entry), name);
2354
2355         image_change_fd(rd->imd, rd->fdlg->source_fd, 0.0);
2356
2357         if (GTK_WIDGET_VISIBLE(rd->rename_box))
2358                 {
2359                 gtk_widget_grab_focus(rd->rename_entry);
2360                 gtk_editable_select_region(GTK_EDITABLE(rd->rename_entry), 0, filename_base_length(name));
2361                 }
2362
2363         return TRUE;
2364 }
2365
2366 static void file_util_rename_multiple_preview_update(RenameDataMult *rd)
2367 {
2368         GtkTreeModel *store;
2369         GtkTreeIter iter;
2370         const gchar *front;
2371         const gchar *end;
2372         const gchar *format;
2373         gint valid;
2374         gint start_n;
2375         gint padding;
2376         gint n;
2377
2378         front = gtk_entry_get_text(GTK_ENTRY(rd->auto_entry_front));
2379         end = gtk_entry_get_text(GTK_ENTRY(rd->auto_entry_end));
2380         padding = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(rd->auto_spin_pad));
2381
2382         format = gtk_entry_get_text(GTK_ENTRY(rd->format_entry));
2383
2384         if (rd->rename_type == RENAME_TYPE_FORMATTED)
2385                 {
2386                 start_n = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(rd->format_spin));
2387                 }
2388         else
2389                 {
2390                 start_n = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(rd->auto_spin_start));
2391                 }
2392
2393         store = gtk_tree_view_get_model(GTK_TREE_VIEW(rd->listview));
2394         n = start_n;
2395         valid = gtk_tree_model_get_iter_first(store, &iter);
2396         while (valid)
2397                 {
2398                 gchar *dest;
2399
2400                 if (rd->rename_type == RENAME_TYPE_FORMATTED)
2401                         {
2402                         FileData *fd;
2403
2404                         gtk_tree_model_get(store, &iter, RENAME_COLUMN_FD, &fd, -1);
2405                         dest = file_util_rename_multiple_auto_format_name(format, fd->name, n);
2406 //                      file_data_unref(fd);
2407                         }
2408                 else
2409                         {
2410                         dest = g_strdup_printf("%s%0*d%s", front, padding, n, end);
2411                         }
2412                 gtk_list_store_set(GTK_LIST_STORE(store), &iter, RENAME_COLUMN_PREVIEW, dest, -1);
2413                 g_free(dest);
2414
2415                 n++;
2416                 valid = gtk_tree_model_iter_next(store, &iter);
2417                 }
2418
2419 }
2420
2421 static gboolean file_util_rename_multiple_idle_cb(gpointer data)
2422 {
2423         RenameDataMult *rd = data;
2424
2425         file_util_rename_multiple_preview_update(rd);
2426
2427         rd->update_idle_id = -1;
2428         return FALSE;
2429 }
2430
2431 static void file_util_rename_multiple_preview_order_cb(GtkTreeModel *treemodel, GtkTreePath *tpath,
2432                                                        GtkTreeIter *iter, gpointer data)
2433 {
2434         RenameDataMult *rd = data;
2435
2436         if (rd->rename_type != RENAME_TYPE_MANUAL && rd->update_idle_id == -1)
2437                 {
2438                 rd->update_idle_id = g_idle_add(file_util_rename_multiple_idle_cb, rd);
2439                 }
2440 }
2441
2442 static void file_util_rename_multiple_preview_entry_cb(GtkWidget *entry, gpointer data)
2443 {
2444         RenameDataMult *rd = data;
2445         file_util_rename_multiple_preview_update(rd);
2446 }
2447
2448 static void file_util_rename_multiple_preview_adj_cb(GtkWidget *spin, gpointer data)
2449 {
2450         RenameDataMult *rd = data;
2451         file_util_rename_multiple_preview_update(rd);
2452 }
2453
2454 static void file_util_rename_multiple_auto_change(GtkWidget *widget, gpointer data)
2455 {
2456         RenameDataMult *rd = data;
2457         GtkTreeViewColumn *column;
2458
2459         rd->rename_type = gtk_combo_box_get_active(GTK_COMBO_BOX(rd->combo_type));
2460
2461         switch (rd->rename_type)
2462                 {
2463                 case RENAME_TYPE_FORMATTED:
2464                         if (GTK_WIDGET_VISIBLE(rd->rename_box)) gtk_widget_hide(rd->rename_box);
2465                         if (GTK_WIDGET_VISIBLE(rd->auto_box)) gtk_widget_hide(rd->auto_box);
2466                         if (!GTK_WIDGET_VISIBLE(rd->format_box)) gtk_widget_show(rd->format_box);
2467                         file_util_rename_multiple_preview_update(rd);
2468                         break;
2469                 case RENAME_TYPE_AUTO:
2470                         if (GTK_WIDGET_VISIBLE(rd->format_box)) gtk_widget_hide(rd->format_box);
2471                         if (GTK_WIDGET_VISIBLE(rd->rename_box)) gtk_widget_hide(rd->rename_box);
2472                         if (!GTK_WIDGET_VISIBLE(rd->auto_box)) gtk_widget_show(rd->auto_box);
2473                         file_util_rename_multiple_preview_update(rd);
2474                         break;
2475                 case RENAME_TYPE_MANUAL:
2476                 default:
2477                         if (GTK_WIDGET_VISIBLE(rd->format_box)) gtk_widget_hide(rd->format_box);
2478                         if (GTK_WIDGET_VISIBLE(rd->auto_box)) gtk_widget_hide(rd->auto_box);
2479                         if (!GTK_WIDGET_VISIBLE(rd->rename_box)) gtk_widget_show(rd->rename_box);
2480                         break;
2481                 }
2482
2483         column = gtk_tree_view_get_column(GTK_TREE_VIEW(rd->listview), RENAME_COLUMN_PREVIEW - 1);
2484         gtk_tree_view_column_set_visible(column, (rd->rename_type != RENAME_TYPE_MANUAL));
2485 }
2486
2487 static GtkWidget *furm_simple_vlabel(GtkWidget *box, const gchar *text, gint expand)
2488 {
2489         GtkWidget *vbox;
2490         GtkWidget *label;
2491
2492         vbox = gtk_vbox_new(FALSE, 0);
2493         gtk_box_pack_start(GTK_BOX(box), vbox, expand, expand, 0);
2494         gtk_widget_show(vbox);
2495
2496         label = gtk_label_new(text);
2497         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
2498         gtk_widget_show(label);
2499
2500         return vbox;
2501 }
2502
2503 static GtkTreeViewColumn *file_util_rename_multiple_add_column(RenameDataMult *rd, const gchar *text, gint n)
2504 {
2505         GtkTreeViewColumn *column;
2506         GtkCellRenderer *renderer;
2507
2508         column = gtk_tree_view_column_new();
2509         gtk_tree_view_column_set_title(column, text);
2510         gtk_tree_view_column_set_min_width(column, 4);
2511         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
2512         renderer = gtk_cell_renderer_text_new();
2513         gtk_tree_view_column_pack_start(column, renderer, TRUE);
2514         gtk_tree_view_column_add_attribute(column, renderer, "text", n);
2515         gtk_tree_view_append_column(GTK_TREE_VIEW(rd->listview), column);
2516
2517         return column;
2518 }
2519
2520 static void file_util_rename_multiple_destroy_cb(GtkWidget *widget, gpointer data)
2521 {
2522         RenameDataMult *rd = data;
2523
2524         if (rd->update_idle_id != -1) g_source_remove(rd->update_idle_id);
2525
2526         g_free(rd);
2527 }
2528
2529 static void file_util_rename_multiple_do(GList *source_list, GtkWidget *parent)
2530 {
2531         RenameDataMult *rd;
2532         GtkWidget *pane;
2533         GtkWidget *scrolled;
2534         GtkListStore *store;
2535         GtkTreeSelection *selection;
2536         GtkTreeViewColumn *column;
2537         GtkWidget *hbox;
2538         GtkWidget *vbox;
2539         GtkWidget *box2;
2540         GtkWidget *table;
2541         GtkWidget *combo;
2542         GList *work;
2543         const gchar *name;
2544         gchar *title;
2545
2546         rd = g_new0(RenameDataMult, 1);
2547
2548         title = g_strdup_printf("%s -%s", _("Rename"), GQ_APPNAME);
2549         rd->fdlg = file_util_file_dlg(title, GQ_WMCLASS, "dlg_rename", parent,
2550                                       file_util_rename_multiple_close_cb, rd);
2551         g_free(title);
2552         generic_dialog_add_message(GENERIC_DIALOG(rd->fdlg), NULL, _("Rename multiple files"), NULL);
2553         file_dialog_add_button(rd->fdlg, GTK_STOCK_OK, _("_Rename"), file_util_rename_multiple_cb, TRUE);
2554
2555         rd->fdlg->source_fd = file_data_ref(source_list->data);
2556         rd->fdlg->dest_path = NULL;
2557
2558         rd->rename_type = RENAME_TYPE_MANUAL;
2559
2560         rd->update_idle_id = -1;
2561
2562         vbox = GENERIC_DIALOG(rd->fdlg)->vbox;
2563
2564         pane = gtk_hpaned_new();
2565         gtk_box_pack_start(GTK_BOX(vbox), pane, TRUE, TRUE, 0);
2566         gtk_widget_show(pane);
2567
2568         scrolled = gtk_scrolled_window_new(NULL, NULL);
2569         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
2570         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled),
2571                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
2572         gtk_paned_pack1(GTK_PANED(pane), scrolled, TRUE, TRUE);
2573         gtk_widget_show(scrolled);
2574
2575         store = gtk_list_store_new(4, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
2576         rd->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
2577         g_object_unref(store);
2578
2579         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(rd->listview), TRUE);
2580         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(rd->listview), FALSE);
2581
2582         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(rd->listview));
2583         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
2584         gtk_tree_selection_set_select_function(selection, file_util_rename_multiple_select_cb, rd, NULL);
2585
2586         file_util_rename_multiple_add_column(rd, _("Original Name"), RENAME_COLUMN_NAME);
2587         column = file_util_rename_multiple_add_column(rd, _("Preview"), RENAME_COLUMN_PREVIEW);
2588         gtk_tree_view_column_set_visible(column, FALSE);
2589
2590         gtk_tree_view_set_reorderable(GTK_TREE_VIEW(rd->listview), TRUE);
2591         g_signal_connect(G_OBJECT(store), "row_changed",
2592                          G_CALLBACK(file_util_rename_multiple_preview_order_cb), rd);
2593         gtk_widget_set_size_request(rd->listview, 250, 150);
2594
2595         gtk_container_add(GTK_CONTAINER(scrolled), rd->listview);
2596         gtk_widget_show(rd->listview);
2597
2598         work = source_list;
2599         while (work)
2600                 {
2601                 FileData *fd = work->data;
2602                 GtkTreeIter iter;
2603
2604                 gtk_list_store_append(store, &iter);
2605                 gtk_list_store_set(store, &iter, RENAME_COLUMN_FD, fd, RENAME_COLUMN_PATH, fd->path, RENAME_COLUMN_NAME, fd->name, -1);
2606
2607                 work = work->next;
2608                 }
2609
2610         filelist_free(source_list);
2611
2612         rd->imd = image_new(TRUE);
2613         g_object_set(G_OBJECT(rd->imd->pr), "zoom_expand", FALSE, NULL);
2614         gtk_widget_set_size_request(rd->imd->widget, DIALOG_DEF_IMAGE_DIM_X, DIALOG_DEF_IMAGE_DIM_Y);
2615         gtk_paned_pack2(GTK_PANED(pane), rd->imd->widget, FALSE, TRUE);
2616         gtk_widget_show(rd->imd->widget);
2617
2618         hbox = gtk_hbox_new(FALSE, 0);
2619         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
2620         gtk_widget_show(hbox);
2621
2622         rd->combo_type = gtk_combo_box_new_text();
2623
2624         gtk_combo_box_append_text(GTK_COMBO_BOX(rd->combo_type), _("Manual rename"));
2625         gtk_combo_box_append_text(GTK_COMBO_BOX(rd->combo_type), _("Formatted rename"));
2626         gtk_combo_box_append_text(GTK_COMBO_BOX(rd->combo_type), _("Auto rename"));
2627
2628         gtk_combo_box_set_active(GTK_COMBO_BOX(rd->combo_type), rd->rename_type);
2629
2630         g_signal_connect(G_OBJECT(rd->combo_type), "changed",
2631                          G_CALLBACK(file_util_rename_multiple_auto_change), rd);
2632         gtk_box_pack_end(GTK_BOX(hbox), rd->combo_type, FALSE, FALSE, 0);
2633         gtk_widget_show(rd->combo_type);
2634
2635         rd->rename_box = pref_box_new(vbox, FALSE, GTK_ORIENTATION_VERTICAL, 0);
2636         table = pref_table_new(rd->rename_box, 2, 2, FALSE, FALSE);
2637
2638         pref_table_label(table, 0, 0, _("Original name:"), 1.0);
2639         rd->rename_label = pref_table_label(table, 1, 0, rd->fdlg->source_fd->name, 0.0);
2640
2641         pref_table_label(table, 0, 1, _("New name:"), 1.0);
2642
2643         rd->rename_entry = gtk_entry_new();
2644         gtk_table_attach(GTK_TABLE(table), rd->rename_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
2645         generic_dialog_attach_default(GENERIC_DIALOG(rd->fdlg), rd->rename_entry);
2646         gtk_widget_grab_focus(rd->rename_entry);
2647
2648         name = rd->fdlg->source_fd->name;
2649         gtk_entry_set_text(GTK_ENTRY(rd->rename_entry), name);
2650         gtk_editable_select_region(GTK_EDITABLE(rd->rename_entry), 0, filename_base_length(name));
2651         gtk_widget_show(rd->rename_entry);
2652
2653         rd->auto_box = gtk_vbox_new(FALSE, PREF_PAD_GAP);
2654         gtk_box_pack_start(GTK_BOX(vbox), rd->auto_box, FALSE, FALSE, 0);
2655         /* do not show it here */
2656
2657         hbox = pref_box_new(rd->auto_box, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
2658
2659         box2 = furm_simple_vlabel(hbox, _("Begin text"), TRUE);
2660
2661         combo = history_combo_new(&rd->auto_entry_front, "", "numerical_rename_prefix", -1);
2662         g_signal_connect(G_OBJECT(rd->auto_entry_front), "changed",
2663                          G_CALLBACK(file_util_rename_multiple_preview_entry_cb), rd);
2664         gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
2665         gtk_widget_show(combo);
2666
2667         box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE);
2668
2669         rd->auto_spin_start = pref_spin_new(box2, NULL, NULL,
2670                                             0.0, 1000000.0, 1.0, 0, 1.0,
2671                                             G_CALLBACK(file_util_rename_multiple_preview_adj_cb), rd);
2672
2673         box2 = furm_simple_vlabel(hbox, _("End text"), TRUE);
2674
2675         combo = history_combo_new(&rd->auto_entry_end, "", "numerical_rename_suffix", -1);
2676         g_signal_connect(G_OBJECT(rd->auto_entry_end), "changed",
2677                          G_CALLBACK(file_util_rename_multiple_preview_entry_cb), rd);
2678         gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
2679         gtk_widget_show(combo);
2680
2681         rd->auto_spin_pad = pref_spin_new(rd->auto_box, _("Padding:"), NULL,
2682                                           1.0, 8.0, 1.0, 0, 1.0,
2683                                           G_CALLBACK(file_util_rename_multiple_preview_adj_cb), rd);
2684
2685         rd->format_box = gtk_vbox_new(FALSE, PREF_PAD_GAP);
2686         gtk_box_pack_start(GTK_BOX(vbox), rd->format_box, FALSE, FALSE, 0);
2687         /* do not show it here */
2688
2689         hbox = pref_box_new(rd->format_box, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
2690
2691         box2 = furm_simple_vlabel(hbox, _("Format (* = original name, ## = numbers)"), TRUE);
2692
2693         combo = history_combo_new(&rd->format_entry, "", "auto_rename_format", -1);
2694         g_signal_connect(G_OBJECT(rd->format_entry), "changed",
2695                          G_CALLBACK(file_util_rename_multiple_preview_entry_cb), rd);
2696         gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
2697         gtk_widget_show(combo);
2698
2699         box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE);
2700
2701         rd->format_spin = pref_spin_new(box2, NULL, NULL,
2702                                         0.0, 1000000.0, 1.0, 0, 1.0,
2703                                         G_CALLBACK(file_util_rename_multiple_preview_adj_cb), rd);
2704
2705         image_change_fd(rd->imd, rd->fdlg->source_fd, 0.0);
2706
2707         g_signal_connect(G_OBJECT(GENERIC_DIALOG(rd->fdlg)->dialog), "destroy",
2708                          G_CALLBACK(file_util_rename_multiple_destroy_cb), rd);
2709
2710         gtk_widget_show(GENERIC_DIALOG(rd->fdlg)->dialog);
2711 }
2712
2713 /*
2714  * rename single file
2715  */
2716
2717 static void file_util_rename_single(FileDataSingle *fds);
2718
2719 static void file_util_rename_single_ok_cb(GenericDialog *gd, gpointer data)
2720 {
2721         FileDataSingle *fds = data;
2722         fds->confirmed = TRUE;
2723         file_util_rename_single(fds);
2724 }
2725
2726 static void file_util_rename_single_cancel_cb(GenericDialog *gd, gpointer data)
2727 {
2728         FileDataSingle *fds = data;
2729         file_data_single_free(fds);
2730 }
2731
2732 static void file_util_rename_single(FileDataSingle *fds)
2733 {
2734         if (isfile(fds->dest) && !fds->confirmed)
2735                 {
2736                 GenericDialog *gd;
2737
2738                 gd = file_util_gen_dlg(_("Overwrite file"), GQ_WMCLASS, "dlg_confirm",
2739                                         NULL, TRUE,
2740                                         file_util_rename_single_cancel_cb, fds);
2741
2742                 generic_dialog_add_message(gd, GTK_STOCK_DIALOG_QUESTION,
2743                                            _("Overwrite file?"),
2744                                            _("Replace existing file by renaming new file."));
2745                 pref_spacer(gd->vbox, 0);
2746
2747                 generic_dialog_add_button(gd, GTK_STOCK_OK, _("_Overwrite"), file_util_rename_single_ok_cb, TRUE);
2748                 generic_dialog_add_image(gd, NULL,
2749                                          file_data_new_simple(fds->dest), _("Existing file"),
2750                                          fds->source_fd, _("New file"), TRUE);
2751
2752                 gtk_widget_show(gd->dialog);
2753
2754                 return;
2755                 }
2756         else
2757                 {
2758 /*
2759                 GList *list = g_list_append(NULL, file_data_ref(fds->source_fd));
2760                 file_util_do_move_list(list, FALSE, TRUE);
2761                 filelist_free(list);
2762 */
2763                 if (!file_data_add_change_info(fds->source_fd, FILEDATA_CHANGE_RENAME, fds->source_fd->path, fds->dest) ||
2764                     !rename_file_ext(fds->source_fd))
2765                         {
2766                         gchar *text = g_strdup_printf(_("Unable to rename file:\n%s\nto:\n%s"), fds->source_fd->name, filename_from_path(fds->dest));
2767                         file_util_warning_dialog(_("Error renaming file"), text, GTK_STOCK_DIALOG_ERROR, NULL);
2768                         g_free(text);
2769                         }
2770
2771                 }
2772         file_data_single_free(fds);
2773 }
2774
2775 static void file_util_rename_single_cb(FileDialog *fdlg, gpointer data)
2776 {
2777         const gchar *name;
2778         gchar *path;
2779
2780         name = gtk_entry_get_text(GTK_ENTRY(fdlg->entry));
2781         path = concat_dir_and_file(fdlg->dest_path, name);
2782
2783         if (strlen(name) == 0 || strcmp(fdlg->source_fd->path, path) == 0)
2784                 {
2785                 g_free(path);
2786                 return;
2787                 }
2788
2789         file_util_rename_single(file_data_single_new(fdlg->source_fd, path, fdlg->type));
2790
2791         g_free(path);
2792         file_dialog_close(fdlg);
2793 }
2794
2795 static void file_util_rename_single_close_cb(FileDialog *fdlg, gpointer data)
2796 {
2797         file_dialog_close(fdlg);
2798 }
2799
2800 static void file_util_rename_single_do(FileData *source_fd, GtkWidget *parent)
2801 {
2802         FileDialog *fdlg;
2803         GtkWidget *table;
2804         const gchar *name;
2805         gchar *title;
2806
2807         title = g_strdup_printf("%s -%s", _("Rename"), GQ_APPNAME);
2808         fdlg = file_util_file_dlg(title, GQ_WMCLASS, "dlg_rename", parent,
2809                                   file_util_rename_single_close_cb, NULL);
2810         g_free(title);
2811
2812         generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, _("Rename file"), NULL);
2813         generic_dialog_add_image(GENERIC_DIALOG(fdlg), NULL, source_fd, NULL, NULL, NULL, FALSE);
2814
2815         file_dialog_add_button(fdlg, GTK_STOCK_OK, _("_Rename"), file_util_rename_single_cb, TRUE);
2816
2817         fdlg->source_fd = file_data_ref(source_fd);
2818         fdlg->dest_path = remove_level_from_path(source_fd->path);
2819
2820         table = pref_table_new(GENERIC_DIALOG(fdlg)->vbox, 2, 2, FALSE, FALSE);
2821
2822         pref_table_label(table, 0, 0, _("Original name:"), 1.0);
2823         pref_table_label(table, 1, 0, fdlg->source_fd->name, 0.0);
2824
2825         pref_table_label(table, 0, 1, _("New name:"), 1.0);
2826
2827         fdlg->entry = gtk_entry_new();
2828         gtk_table_attach(GTK_TABLE(table), fdlg->entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
2829         generic_dialog_attach_default(GENERIC_DIALOG(fdlg), fdlg->entry);
2830         gtk_widget_grab_focus(fdlg->entry);
2831
2832         name = fdlg->source_fd->name;
2833         gtk_entry_set_text(GTK_ENTRY(fdlg->entry), name);
2834         gtk_editable_select_region(GTK_EDITABLE(fdlg->entry), 0, filename_base_length(name));
2835         gtk_widget_show(fdlg->entry);
2836
2837         gtk_widget_show(GENERIC_DIALOG(fdlg)->dialog);
2838 }
2839
2840 void file_util_rename(FileData *source_fd, GList *source_list, GtkWidget *parent)
2841 {
2842         if (!source_fd && !source_list) return;
2843
2844         if (source_fd)
2845                 {
2846                 file_util_rename_single_do(source_fd, parent);
2847                 }
2848         else if (!source_list->next)
2849                 {
2850                 file_util_rename_single_do(source_list->data, parent);
2851                 filelist_free(source_list);
2852                 }
2853         else
2854                 {
2855                 file_util_rename_multiple_do(source_list, parent);
2856                 }
2857 }
2858
2859 /*
2860  *--------------------------------------------------------------------------
2861  * Create directory routines
2862  *--------------------------------------------------------------------------
2863  */
2864
2865 static void file_util_create_dir_do(const gchar *base, const gchar *name)
2866 {
2867         gchar *path;
2868
2869         path = concat_dir_and_file(base, name);
2870
2871         if (isdir(path))
2872                 {
2873                 gchar *text = g_strdup_printf(_("The folder:\n%s\nalready exists."), name);
2874                 file_util_warning_dialog(_("Folder exists"), text, GTK_STOCK_DIALOG_INFO, NULL);
2875                 g_free(text);
2876                 }
2877         else if (isname(path))
2878                 {
2879                 gchar *text = g_strdup_printf(_("The path:\n%s\nalready exists as a file."), name);
2880                 file_util_warning_dialog(_("Could not create folder"), text, GTK_STOCK_DIALOG_INFO, NULL);
2881                 g_free(text);
2882                 }
2883         else
2884                 {
2885                 if (!mkdir_utf8(path, 0755))
2886                         {
2887                         gchar *text = g_strdup_printf(_("Unable to create folder:\n%s"), name);
2888                         file_util_warning_dialog(_("Error creating folder"), text, GTK_STOCK_DIALOG_ERROR, NULL);
2889                         g_free(text);
2890                         }
2891                 }
2892
2893         g_free(path);
2894 }
2895
2896 static void file_util_create_dir_cb(FileDialog *fdlg, gpointer data)
2897 {
2898         const gchar *name;
2899
2900         name = gtk_entry_get_text(GTK_ENTRY(fdlg->entry));
2901
2902         if (strlen(name) == 0) return;
2903
2904         if (name[0] == '/')
2905                 {
2906                 gchar *buf;
2907                 buf  = remove_level_from_path(name);
2908                 file_util_create_dir_do(buf, filename_from_path(name));
2909                 g_free(buf);
2910                 }
2911         else
2912                 {
2913                 file_util_create_dir_do(fdlg->dest_path, name);
2914                 }
2915
2916         file_dialog_close(fdlg);
2917 }
2918
2919 static void file_util_create_dir_close_cb(FileDialog *fdlg, gpointer data)
2920 {
2921         file_dialog_close(fdlg);
2922 }
2923
2924 void file_util_create_dir(const gchar *path, GtkWidget *parent)
2925 {
2926         FileDialog *fdlg;
2927         gchar *text;
2928         gchar *title;
2929
2930         if (!isdir(path)) return;
2931
2932         title = g_strdup_printf("%s -%s", _("New folder"), GQ_APPNAME);
2933         fdlg = file_util_file_dlg(title, GQ_WMCLASS, "dlg_newdir", parent,
2934                                   file_util_create_dir_close_cb, NULL);
2935         g_free(title);
2936
2937         text = g_strdup_printf(_("Create folder in:\n%s\nnamed:"), path);
2938         generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, NULL, text);
2939         g_free(text);
2940
2941         file_dialog_add_button(fdlg, GTK_STOCK_OK, NULL, file_util_create_dir_cb, TRUE);
2942
2943         fdlg->dest_path = g_strdup(path);
2944
2945         fdlg->entry = gtk_entry_new();
2946         gtk_box_pack_start(GTK_BOX(GENERIC_DIALOG(fdlg)->vbox), fdlg->entry, FALSE, FALSE, 0);
2947         generic_dialog_attach_default(GENERIC_DIALOG(fdlg), fdlg->entry);
2948         gtk_widget_grab_focus(fdlg->entry);
2949         gtk_widget_show(fdlg->entry);
2950
2951         gtk_widget_show(GENERIC_DIALOG(fdlg)->dialog);
2952 }
2953
2954 gint file_util_rename_dir(FileData *old_fd, const gchar *new_path, GtkWidget *parent)
2955 {
2956         const gchar *old_name;
2957         const gchar *new_name;
2958
2959         if (!old_fd || !new_path || !isdir(old_fd->path)) return FALSE;
2960
2961         old_name = old_fd->name;
2962         new_name = filename_from_path(new_path);
2963
2964         if (isdir(new_path))
2965                 {
2966                 gchar *text = g_strdup_printf(_("The folder:\n%s\nalready exists."), new_name);
2967                 file_util_warning_dialog(_("Folder exists"), text, GTK_STOCK_DIALOG_INFO, parent);
2968                 g_free(text);
2969
2970                 return FALSE;
2971                 }
2972
2973         if (isname(new_path))
2974                 {
2975                 gchar *text = g_strdup_printf(_("The path:\n%s\nalready exists as a file."), new_name);
2976                 file_util_warning_dialog(_("Rename failed"), text, GTK_STOCK_DIALOG_INFO,parent);
2977                 g_free(text);
2978
2979                 return FALSE;
2980                 }
2981         if (!file_data_add_change_info(old_fd, FILEDATA_CHANGE_RENAME, old_fd->path, new_path) ||
2982             !rename_file_ext(old_fd))
2983                 {
2984                 gchar *text = g_strdup_printf(_("Failed to rename %s to %s."), old_name, new_name);
2985                 file_util_warning_dialog(_("Rename failed"), text, GTK_STOCK_DIALOG_ERROR, parent);
2986                 g_free(text);
2987
2988                 return FALSE;
2989                 }
2990
2991         return TRUE;
2992 }
2993
2994 /*
2995  *--------------------------------------------------------------------------
2996  * Delete directory routines
2997  *--------------------------------------------------------------------------
2998  */
2999
3000 /* The plan is to eventually make all of utilops.c
3001  * use UtilityData and UtilityType.
3002  * And clean up the above mess someday.
3003  */
3004
3005 typedef enum {
3006         UTILITY_TYPE_NONE = 0,
3007         UTILITY_TYPE_COPY,
3008         UTILITY_TYPE_MOVE,
3009         UTILITY_TYPE_RENAME,
3010         UTILITY_TYPE_DELETE,
3011         UTILITY_TYPE_DELETE_LINK,
3012         UTILITY_TYPE_DELETE_FOLDER
3013 } UtilityType;
3014
3015 typedef struct _UtilityData UtilityData;
3016 struct _UtilityData {
3017         UtilityType type;
3018         FileData *source_fd;
3019         GList *dlist;
3020         GList *flist;
3021
3022         GenericDialog *gd;
3023 };
3024
3025 enum {
3026         UTILITY_COLUMN_FD = 0,
3027         UTILITY_COLUMN_PATH,
3028         UTILITY_COLUMN_NAME,
3029         UTILITY_COLUMN_COUNT
3030 };
3031
3032
3033 #define UTILITY_LIST_MIN_WIDTH  250
3034 #define UTILITY_LIST_MIN_HEIGHT 150
3035
3036 /* thumbnail spec has a max depth of 4 (.thumb??/fail/appname/??.png) */
3037 #define UTILITY_DELETE_MAX_DEPTH 5
3038
3039
3040 static void file_util_data_free(UtilityData *ud)
3041 {
3042         if (!ud) return;
3043
3044         file_data_unref(ud->source_fd);
3045         filelist_free(ud->dlist);
3046         filelist_free(ud->flist);
3047
3048         if (ud->gd) generic_dialog_close(ud->gd);
3049
3050         g_free(ud);
3051 }
3052
3053 static GtkTreeViewColumn *file_util_dialog_add_list_column(GtkWidget *view, const gchar *text, gint n)
3054 {
3055         GtkTreeViewColumn *column;
3056         GtkCellRenderer *renderer;
3057
3058         column = gtk_tree_view_column_new();
3059         gtk_tree_view_column_set_title(column, text);
3060         gtk_tree_view_column_set_min_width(column, 4);
3061         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
3062         renderer = gtk_cell_renderer_text_new();
3063         gtk_tree_view_column_pack_start(column, renderer, TRUE);
3064         gtk_tree_view_column_add_attribute(column, renderer, "text", n);
3065         gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
3066
3067         return column;
3068 }
3069
3070 static GtkWidget *file_util_dialog_add_list(GtkWidget *box, GList *list, gint full_paths)
3071 {
3072         GtkWidget *scrolled;
3073         GtkWidget *view;
3074         GtkListStore *store;
3075
3076         scrolled = gtk_scrolled_window_new(NULL, NULL);
3077         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
3078         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled),
3079                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
3080         gtk_box_pack_start(GTK_BOX(box), scrolled, TRUE, TRUE, 0);
3081         gtk_widget_show(scrolled);
3082
3083         store = gtk_list_store_new(UTILITY_COLUMN_COUNT, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING);
3084         view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
3085         g_object_unref(store);
3086
3087         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), TRUE);
3088         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(view), FALSE);
3089
3090         if (full_paths)
3091                 {
3092                 file_util_dialog_add_list_column(view, _("Location"), UTILITY_COLUMN_PATH);
3093                 }
3094         else
3095                 {
3096                 file_util_dialog_add_list_column(view, _("Name"), UTILITY_COLUMN_NAME);
3097                 }
3098
3099         gtk_widget_set_size_request(view, UTILITY_LIST_MIN_WIDTH, UTILITY_LIST_MIN_HEIGHT);
3100         gtk_container_add(GTK_CONTAINER(scrolled), view);
3101         gtk_widget_show(view);
3102
3103         while (list)
3104                 {
3105                 FileData *fd = list->data;
3106                 GtkTreeIter iter;
3107
3108                 gtk_list_store_append(store, &iter);
3109                 gtk_list_store_set(store, &iter, UTILITY_COLUMN_FD, fd,
3110                                                  UTILITY_COLUMN_PATH, fd->path,
3111                                                  UTILITY_COLUMN_NAME, fd->name, -1);
3112
3113                 list = list->next;
3114                 }
3115
3116         return view;
3117 }
3118
3119 static gboolean file_util_delete_dir_preview_cb(GtkTreeSelection *selection, GtkTreeModel *store,
3120                                                 GtkTreePath *tpath, gboolean path_currently_selected,
3121                                                 gpointer data)
3122 {
3123         UtilityData *ud = data;
3124         GtkTreeIter iter;
3125         FileData *fd = NULL;
3126
3127         if (path_currently_selected ||
3128             !gtk_tree_model_get_iter(store, &iter, tpath)) return TRUE;
3129
3130         gtk_tree_model_get(store, &iter, UTILITY_COLUMN_FD, &fd, -1);
3131         generic_dialog_image_set(ud->gd, fd);
3132 //      file_data_unref(fd);
3133
3134         return TRUE;
3135 }
3136
3137 static void file_util_delete_dir_cancel_cb(GenericDialog *gd, gpointer data)
3138 {
3139         UtilityData *ud = data;
3140
3141         ud->gd = NULL;
3142         file_util_data_free(ud);
3143 }
3144
3145 FileData *file_util_delete_dir_empty_path(FileData *fd, gint real_content, gint level)
3146 {
3147         GList *dlist = NULL;
3148         GList *flist = NULL;
3149         GList *work;
3150         FileData *fail = NULL;
3151
3152         if (debug) printf("deltree into: %s\n", fd->path);
3153
3154         level++;
3155         if (level > UTILITY_DELETE_MAX_DEPTH)
3156                 {
3157                 printf("folder recursion depth past %d, giving up\n", UTILITY_DELETE_MAX_DEPTH);
3158                 return file_data_ref(fd);
3159                 }
3160
3161         if (!filelist_read_lstat(fd->path, &flist, &dlist)) file_data_ref(fd);
3162
3163         work = dlist;
3164         while (work && !fail)
3165                 {
3166                 FileData *lfd;
3167
3168                 lfd = work->data;
3169                 work = work->next;
3170
3171                 fail = file_util_delete_dir_empty_path(lfd, real_content, level);
3172                 }
3173
3174         work = flist;
3175         while (work && !fail)
3176                 {
3177                 FileData *lfd;
3178
3179                 lfd = work->data;
3180                 work = work->next;
3181
3182                 if (debug) printf("deltree child: %s\n", lfd->path);
3183
3184                 if (real_content && !islink(lfd->path))
3185                         {
3186                         if (!file_util_unlink(lfd)) fail = file_data_ref(lfd);
3187                         }
3188                 else
3189                         {
3190                         if (!unlink_file(lfd->path)) fail = file_data_ref(lfd);
3191                         }
3192                 }
3193
3194         filelist_free(dlist);
3195         filelist_free(flist);
3196
3197         if (!fail && !rmdir_utf8(fd->path))
3198                 {
3199                 fail = file_data_ref(fd);
3200                 }
3201
3202         if (debug) printf("deltree done: %s\n", fd->path);
3203
3204         return fail;
3205 }
3206
3207 static void file_util_delete_dir_ok_cb(GenericDialog *gd, gpointer data)
3208 {
3209         UtilityData *ud = data;
3210
3211         ud->gd = NULL;
3212
3213         if (ud->type == UTILITY_TYPE_DELETE_LINK)
3214                 {
3215                 if (!unlink_file(ud->source_fd->path))
3216                         {
3217                         gchar *text;
3218
3219                         text = g_strdup_printf("Unable to remove symbolic link:\n %s", ud->source_fd->path);
3220                         file_util_warning_dialog(_("Delete failed"), text,
3221                                                  GTK_STOCK_DIALOG_ERROR, NULL);
3222                         g_free(text);
3223                         }
3224                 }
3225         else
3226                 {
3227                 FileData *fail = NULL;
3228                 GList *work;
3229
3230                 work = ud->dlist;
3231                 while (work && !fail)
3232                         {
3233                         FileData *fd;
3234
3235                         fd = work->data;
3236                         work = work->next;
3237
3238                         fail = file_util_delete_dir_empty_path(fd, FALSE, 0);
3239                         }
3240
3241                 work = ud->flist;
3242                 while (work && !fail)
3243                         {
3244                         FileData *fd;
3245
3246                         fd = work->data;
3247                         work = work->next;
3248
3249                         if (debug) printf("deltree unlink: %s\n", fd->path);
3250
3251                         if (islink(fd->path))
3252                                 {
3253                                 if (!unlink_file(fd->path)) fail = file_data_ref(fd);
3254                                 }
3255                         else
3256                                 {
3257                                 if (!file_util_unlink(fd)) fail = file_data_ref(fd);
3258                                 }
3259                         }
3260
3261                 if (!fail)
3262                         {
3263                         if (!rmdir_utf8(ud->source_fd->path)) fail = file_data_ref(ud->source_fd);
3264                         }
3265
3266                 if (fail)
3267                         {
3268                         gchar *text;
3269
3270                         text = g_strdup_printf(_("Unable to delete folder:\n\n%s"), ud->source_fd->path);
3271                         gd = file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, NULL);
3272                         g_free(text);
3273
3274                         if (fail != ud->source_fd)
3275                                 {
3276                                 pref_spacer(gd->vbox, PREF_PAD_GROUP);
3277                                 text = g_strdup_printf(_("Removal of folder contents failed at this file:\n\n%s"),
3278                                                         fail->path);
3279                                 pref_label_new(gd->vbox, text);
3280                                 g_free(text);
3281                                 }
3282
3283                         file_data_unref(fail);
3284                         }
3285                 }
3286
3287         file_util_data_free(ud);
3288 }
3289
3290 static GList *file_util_delete_dir_remaining_folders(GList *dlist)
3291 {
3292         GList *rlist = NULL;
3293
3294         while (dlist)
3295                 {
3296                 FileData *fd;
3297
3298                 fd = dlist->data;
3299                 dlist = dlist->next;
3300
3301                 if (!fd->name ||
3302                     (strcmp(fd->name, THUMB_FOLDER_GLOBAL) != 0 &&
3303                      strcmp(fd->name, THUMB_FOLDER_LOCAL) != 0 &&
3304                      strcmp(fd->name, GQ_CACHE_LOCAL_METADATA) != 0) )
3305                         {
3306                         rlist = g_list_prepend(rlist, fd);
3307                         }
3308                 }
3309
3310         return g_list_reverse(rlist);
3311 }
3312
3313 void file_util_delete_dir(FileData *fd, GtkWidget *parent)
3314 {
3315         GList *dlist = NULL;
3316         GList *flist = NULL;
3317         GList *rlist;
3318
3319         if (!isdir(fd->path)) return;
3320
3321         if (islink(fd->path))
3322                 {
3323                 UtilityData *ud;
3324                 gchar *text;
3325
3326                 ud = g_new0(UtilityData, 1);
3327                 ud->type = UTILITY_TYPE_DELETE_LINK;
3328                 ud->source_fd = file_data_ref(fd);
3329                 ud->dlist = NULL;
3330                 ud->flist = NULL;
3331
3332                 ud->gd = file_util_gen_dlg(_("Delete folder"), GQ_WMCLASS, "dlg_confirm",
3333                                            parent, TRUE,
3334                                            file_util_delete_dir_cancel_cb, ud);
3335
3336                 text = g_strdup_printf(_("This will delete the symbolic link:\n\n%s\n\n"
3337                                          "The folder this link points to will not be deleted."),
3338                                         fd->path);
3339                 generic_dialog_add_message(ud->gd, GTK_STOCK_DIALOG_QUESTION,
3340                                            _("Delete symbolic link to folder?"),
3341                                            text);
3342                 g_free(text);
3343
3344                 generic_dialog_add_button(ud->gd, GTK_STOCK_DELETE, NULL, file_util_delete_dir_ok_cb, TRUE);
3345
3346                 gtk_widget_show(ud->gd->dialog);
3347
3348                 return;
3349                 }
3350
3351         if (!access_file(fd->path, W_OK | X_OK))
3352                 {
3353                 gchar *text;
3354
3355                 text = g_strdup_printf(_("Unable to remove folder %s\n"
3356                                          "Permissions do not allow writing to the folder."), fd->path);
3357                 file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, parent);
3358                 g_free(text);
3359
3360                 return;
3361                 }
3362
3363         if (!filelist_read_lstat(fd->path, &flist, &dlist))
3364                 {
3365                 gchar *text;
3366
3367                 text = g_strdup_printf(_("Unable to list contents of folder %s"), fd->path);
3368                 file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, parent);
3369                 g_free(text);
3370
3371                 return;
3372                 }
3373
3374         rlist = file_util_delete_dir_remaining_folders(dlist);
3375         if (rlist)
3376                 {
3377                 GenericDialog *gd;
3378                 GtkWidget *box;
3379                 gchar *text;
3380
3381                 gd = file_util_gen_dlg(_("Folder contains subfolders"), GQ_WMCLASS, "dlg_warning",
3382                                         parent, TRUE, NULL, NULL);
3383                 generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE);
3384
3385                 text = g_strdup_printf(_("Unable to delete the folder:\n\n%s\n\n"
3386                                          "This folder contains subfolders which must be moved before it can be deleted."),
3387                                         fd->path);
3388                 box = generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING,
3389                                                  _("Folder contains subfolders"),
3390                                                  text);
3391                 g_free(text);
3392
3393                 box = pref_group_new(box, TRUE, _("Subfolders:"), GTK_ORIENTATION_VERTICAL);
3394
3395                 rlist = filelist_sort_path(rlist);
3396                 file_util_dialog_add_list(box, rlist, FALSE);
3397
3398                 gtk_widget_show(gd->dialog);
3399                 }
3400         else
3401                 {
3402                 UtilityData *ud;
3403                 GtkWidget *box;
3404                 GtkWidget *view;
3405                 GtkTreeSelection *selection;
3406                 gchar *text;
3407
3408                 ud = g_new0(UtilityData, 1);
3409                 ud->type = UTILITY_TYPE_DELETE_FOLDER;
3410                 ud->source_fd = file_data_ref(fd);
3411                 ud->dlist = dlist;
3412                 dlist = NULL;
3413                 ud->flist = filelist_sort_path(flist);
3414                 flist = NULL;
3415
3416                 ud->gd = file_util_gen_dlg(_("Delete folder"), GQ_WMCLASS, "dlg_confirm",
3417                                            parent, TRUE, file_util_delete_dir_cancel_cb, ud);
3418                 generic_dialog_add_button(ud->gd, GTK_STOCK_DELETE, NULL, file_util_delete_dir_ok_cb, TRUE);
3419
3420                 text = g_strdup_printf(_("This will delete the folder:\n\n%s\n\n"
3421                                          "The contents of this folder will also be deleted."),
3422                                         fd->path);
3423                 box = generic_dialog_add_message(ud->gd, GTK_STOCK_DIALOG_QUESTION,
3424                                                  _("Delete folder?"),
3425                                                  text);
3426                 g_free(text);
3427
3428                 box = pref_group_new(box, TRUE, _("Contents:"), GTK_ORIENTATION_HORIZONTAL);
3429
3430                 view = file_util_dialog_add_list(box, ud->flist, FALSE);
3431                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
3432                 gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
3433                 gtk_tree_selection_set_select_function(selection, file_util_delete_dir_preview_cb, ud, NULL);
3434
3435                 generic_dialog_add_image(ud->gd, box, NULL, NULL, NULL, NULL, FALSE);
3436
3437                 box_append_safe_delete_status(ud->gd);
3438
3439                 gtk_widget_show(ud->gd->dialog);
3440                 }
3441
3442         g_list_free(rlist);
3443         filelist_free(dlist);
3444         filelist_free(flist);
3445 }