src/utilops.c

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