src/utilops.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 John Ellis
   4  * Copyright (C) 2008 The Geeqie Team
   5  *
   6  * Author: John Ellis
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13
  14 #include "main.h"
  15 #include "utilops.h"
  16
  17
  18 #include "cache.h"
  19 #include "cache_maint.h"
  20 #include "collect.h"
  21 #include "dupe.h"
  22 #include "filedata.h"
  23 #include "filefilter.h"
  24 #include "image.h"
  25 #include "img-view.h"
  26 #include "layout.h"
  27 #include "search.h"
  28 #include "thumb_standard.h"
  29 #include "trash.h"
  30 #include "ui_bookmark.h"
  31 #include "ui_fileops.h"
  32 #include "ui_misc.h"
  33 #include "ui_tabcomp.h"
  34 #include "editors.h"
  35
  36 /*
  37  *--------------------------------------------------------------------------
  38  * Adds 1 or 2 images (if 2, side by side) to a GenericDialog
  39  *--------------------------------------------------------------------------
  40  */
  41
  42 #define DIALOG_DEF_IMAGE_DIM_X 200
  43 #define DIALOG_DEF_IMAGE_DIM_Y 150
  44
  45 static void generic_dialog_add_image(GenericDialog *gd, GtkWidget *box,
  46                                      FileData *fd1, const gchar *header1,
  47                                      FileData *fd2, const gchar *header2,
  48                                      gint show_filename)
  49 {
  50         ImageWindow *imd;
  51         GtkWidget *hbox = NULL;
  52         GtkWidget *vbox;
  53         GtkWidget *label = NULL;
  54
  55         if (!box) box = gd->vbox;
  56
  57         if (fd2)
  58                 {
  59                 hbox = pref_box_new(box, TRUE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
  60                 }
  61
  62         /* image 1 */
  63
  64         vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
  65         if (hbox)
  66                 {
  67                 GtkWidget *sep;
  68
  69                 gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
  70
  71                 sep = gtk_vseparator_new();
  72                 gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 0);
  73                 gtk_widget_show(sep);
  74                 }
  75         else
  76                 {
  77                 gtk_box_pack_start(GTK_BOX(box), vbox, TRUE, TRUE, PREF_PAD_GAP);
  78                 }
  79         gtk_widget_show(vbox);
  80
  81         if (header1)
  82                 {
  83                 GtkWidget *head;
  84
  85                 head = pref_label_new(vbox, header1);
  86                 pref_label_bold(head, TRUE, FALSE);
  87                 gtk_misc_set_alignment(GTK_MISC(head), 0.0, 0.5);
  88                 }
  89
  90         imd = image_new(FALSE);
  91         g_object_set(G_OBJECT(imd->pr), "zoom_expand", FALSE, NULL);
  92         gtk_widget_set_size_request(imd->widget, DIALOG_DEF_IMAGE_DIM_X, DIALOG_DEF_IMAGE_DIM_Y);
  93         gtk_box_pack_start(GTK_BOX(vbox), imd->widget, TRUE, TRUE, 0);
  94         image_change_fd(imd, fd1, 0.0);
  95         gtk_widget_show(imd->widget);
  96
  97         if (show_filename)
  98                 {
  99                 label = pref_label_new(vbox, (fd1 == NULL) ? "" : fd1->name);
 100                 }
 101
 102         /* only the first image is stored (for use in gd_image_set) */
 103         g_object_set_data(G_OBJECT(gd->dialog), "img_image", imd);
 104         g_object_set_data(G_OBJECT(gd->dialog), "img_label", label);
 105
 106
 107         /* image 2 */
 108
 109         if (hbox && fd2)
 110                 {
 111                 vbox = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
 112
 113                 if (header2)
 114                         {
 115                         GtkWidget *head;
 116
 117                         head = pref_label_new(vbox, header2);
 118                         pref_label_bold(head, TRUE, FALSE);
 119                         gtk_misc_set_alignment(GTK_MISC(head), 0.0, 0.5);
 120                         }
 121
 122                 imd = image_new(FALSE);
 123                 g_object_set(G_OBJECT(imd->pr), "zoom_expand", FALSE, NULL);
 124                 gtk_widget_set_size_request(imd->widget, DIALOG_DEF_IMAGE_DIM_X, DIALOG_DEF_IMAGE_DIM_Y);
 125                 gtk_box_pack_start(GTK_BOX(vbox), imd->widget, TRUE, TRUE, 0);
 126                 image_change_fd(imd, fd2, 0.0);
 127                 gtk_widget_show(imd->widget);
 128
 129                 pref_label_new(vbox, fd2->name);
 130                 }
 131 }
 132
 133 static void generic_dialog_image_set(GenericDialog *gd, FileData *fd)
 134 {
 135         ImageWindow *imd;
 136         GtkWidget *label;
 137
 138         imd = g_object_get_data(G_OBJECT(gd->dialog), "img_image");
 139         label = g_object_get_data(G_OBJECT(gd->dialog), "img_label");
 140
 141         if (!imd) return;
 142
 143         image_change_fd(imd, fd, 0.0);
 144         if (label) gtk_label_set_text(GTK_LABEL(label), fd->name);
 145 }
 146
 147 /*
 148  *--------------------------------------------------------------------------
 149  * Wrappers to aid in setting additional dialog properties (unde mouse, etc.)
 150  *--------------------------------------------------------------------------
 151  */
 152
 153 GenericDialog *file_util_gen_dlg(const gchar *title,
 154                                  const gchar *wmclass, const gchar *wmsubclass,
 155                                  GtkWidget *parent, gint auto_close,
 156                                  void (*cancel_cb)(GenericDialog *, gpointer), gpointer data)
 157 {
 158         GenericDialog *gd;
 159
 160         gd = generic_dialog_new(title, wmclass, wmsubclass, parent, auto_close, cancel_cb, data);
 161         if (options->place_dialogs_under_mouse)
 162                 {
 163                 gtk_window_set_position(GTK_WINDOW(gd->dialog), GTK_WIN_POS_MOUSE);
 164                 }
 165
 166         return gd;
 167 }
 168
 169 FileDialog *file_util_file_dlg(const gchar *title,
 170                                const gchar *wmclass, const gchar *wmsubclass,
 171                                GtkWidget *parent,
 172                                void (*cancel_cb)(FileDialog *, gpointer), gpointer data)
 173 {
 174         FileDialog *fdlg;
 175
 176         fdlg = file_dialog_new(title, wmclass, wmsubclass, parent, cancel_cb, data);
 177         if (options->place_dialogs_under_mouse)
 178                 {
 179                 gtk_window_set_position(GTK_WINDOW(GENERIC_DIALOG(fdlg)->dialog), GTK_WIN_POS_MOUSE);
 180                 }
 181
 182         return fdlg;
 183 }
 184
 185 /* this warning dialog is copied from SLIK's ui_utildg.c,
 186  * because it does not have a mouse center option,
 187  * and we must center it before show, implement it here.
 188  */
 189 static void file_util_warning_dialog_ok_cb(GenericDialog *gd, gpointer data)
 190 {
 191         /* no op */
 192 }
 193
 194 GenericDialog *file_util_warning_dialog(const gchar *heading, const gchar *message,
 195                                         const gchar *icon_stock_id, GtkWidget *parent)
 196 {
 197         GenericDialog *gd;
 198
 199         gd = file_util_gen_dlg(heading, GQ_WMCLASS, "warning", parent, TRUE, NULL, NULL);
 200         generic_dialog_add_message(gd, icon_stock_id, heading, message);
 201         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, file_util_warning_dialog_ok_cb, TRUE);
 202         if (options->place_dialogs_under_mouse)
 203                 {
 204                 gtk_window_set_position(GTK_WINDOW(gd->dialog), GTK_WIN_POS_MOUSE);
 205                 }
 206         gtk_widget_show(gd->dialog);
 207
 208         return gd;
 209 }
 210
 211 static gint filename_base_length(const gchar *name)
 212 {
 213         gint n;
 214
 215         if (!name) return 0;
 216
 217         n = strlen(name);
 218
 219         if (filter_name_exists(name))
 220                 {
 221                 const gchar *ext;
 222
 223                 ext = extension_from_path(name);
 224                 if (ext) n -= strlen(ext);
 225                 }
 226
 227         return n;
 228 }
 229
 230
 231
 232 /*
 233  *--------------------------------------------------------------------------
 234  * call these when names change, files move, deleted, etc.
 235  * so that any open windows are also updated
 236  *--------------------------------------------------------------------------
 237  */
 238
 239 /* FIXME this is a temporary solution */
 240 void file_data_notify_ci(FileData *fd)
 241 {
 242         FileDataChangeType type = fd->change->type;
 243         switch (type)
 244                 {
 245                 case FILEDATA_CHANGE_MOVE:
 246                         collection_maint_renamed(fd);
 247
 248                         break;
 249                 case FILEDATA_CHANGE_COPY:
 250                         break;
 251                 case FILEDATA_CHANGE_RENAME:
 252                         collection_maint_renamed(fd);
 253
 254                         break;
 255                 case FILEDATA_CHANGE_DELETE:
 256
 257                         collection_maint_removed(fd);
 258                         break;
 259                 case FILEDATA_CHANGE_UNSPECIFIED:
 260                         /* FIXME */
 261                         break;
 262                 }
 263
 264
 265         /* this is the new way: */
 266         file_data_send_notification(fd, NOTIFY_TYPE_CHANGE);
 267 }
 268
 269 void file_data_sc_notify_ci(FileData *fd)
 270 {
 271         GList *work;
 272         if (fd->parent) fd = fd->parent;
 273
 274         file_data_notify_ci(fd);
 275
 276         work = fd->sidecar_files;
 277         while (work)
 278                 {
 279                 FileData *sfd = work->data;
 280                 file_data_notify_ci(sfd);
 281                 work = work->next;
 282                 }
 283 }
 284
 285
 286 typedef enum {
 287         UTILITY_TYPE_COPY,
 288         UTILITY_TYPE_MOVE,
 289         UTILITY_TYPE_RENAME,
 290         UTILITY_TYPE_EDITOR,
 291         UTILITY_TYPE_FILTER,
 292         UTILITY_TYPE_DELETE,
 293         UTILITY_TYPE_DELETE_LINK,
 294         UTILITY_TYPE_DELETE_FOLDER
 295 } UtilityType;
 296
 297 typedef enum {
 298         UTILITY_PHASE_START = 0,
 299         UTILITY_PHASE_ENTERING,
 300         UTILITY_PHASE_CHECKED,
 301         UTILITY_PHASE_DONE,
 302         UTILITY_PHASE_CANCEL
 303 } UtilityPhase;
 304
 305 enum {
 306         UTILITY_RENAME = 0,
 307         UTILITY_RENAME_AUTO,
 308         UTILITY_RENAME_FORMATTED
 309 };
 310
 311 typedef struct _UtilityDataMessages UtilityDataMessages;
 312 struct _UtilityDataMessages {
 313         gchar *title;
 314         gchar *question;
 315         gchar *desc_flist;
 316         gchar *desc_dlist;
 317         gchar *desc_source_fd;
 318         gchar *fail;
 319 };
 320
 321 typedef struct _UtilityData UtilityData;
 322
 323 struct _UtilityData {
 324         UtilityType type;
 325         UtilityPhase phase;
 326
 327         FileData *source_fd;
 328         GList *dlist;
 329         GList *flist;
 330
 331         GtkWidget *parent;
 332         GenericDialog *gd;
 333         FileDialog *fdlg;
 334
 335         gint update_idle_id;
 336
 337         /* alternative dialog parts */
 338         GtkWidget *notebook;
 339
 340         UtilityDataMessages messages;
 341
 342         /* helper entries for various modes */
 343         GtkWidget *rename_entry;
 344         GtkWidget *rename_label;
 345         GtkWidget *auto_entry_front;
 346         GtkWidget *auto_entry_end;
 347         GtkWidget *auto_spin_start;
 348         GtkWidget *auto_spin_pad;
 349         GtkWidget *format_entry;
 350         GtkWidget *format_spin;
 351
 352         GtkWidget *listview;
 353
 354
 355         gchar *dest_path;
 356
 357         /* data for the operation itself, internal or external */
 358         gboolean external; /* TRUE for external command, FALSE for internal */
 359
 360         gint external_command;
 361         gpointer resume_data;
 362 };
 363
 364 enum {
 365         UTILITY_COLUMN_FD = 0,
 366         UTILITY_COLUMN_PATH,
 367         UTILITY_COLUMN_NAME,
 368         UTILITY_COLUMN_SIDECARS,
 369         UTILITY_COLUMN_DEST_PATH,
 370         UTILITY_COLUMN_DEST_NAME,
 371         UTILITY_COLUMN_COUNT
 372 };
 373
 374 #define UTILITY_LIST_MIN_WIDTH  250
 375 #define UTILITY_LIST_MIN_HEIGHT 150
 376
 377 /* thumbnail spec has a max depth of 4 (.thumb??/fail/appname/??.png) */
 378 #define UTILITY_DELETE_MAX_DEPTH 5
 379
 380 static UtilityData *file_util_data_new(UtilityType type)
 381 {
 382         UtilityData *ud;
 383
 384         ud = g_new0(UtilityData, 1);
 385         ud->type = type;
 386         ud->phase = UTILITY_PHASE_START;
 387         ud->update_idle_id = -1;
 388         ud->external_command = -1;
 389         return ud;
 390 }
 391
 392 static void file_util_data_free(UtilityData *ud)
 393 {
 394         if (!ud) return;
 395
 396         if (ud->update_idle_id != -1) g_source_remove(ud->update_idle_id);
 397
 398         file_data_unref(ud->source_fd);
 399         filelist_free(ud->dlist);
 400         filelist_free(ud->flist);
 401
 402         if (ud->gd) generic_dialog_close(ud->gd);
 403
 404         g_free(ud->dest_path);
 405
 406         g_free(ud);
 407 }
 408
 409 static GtkTreeViewColumn *file_util_dialog_add_list_column(GtkWidget *view, const gchar *text, gint n)
 410 {
 411         GtkTreeViewColumn *column;
 412         GtkCellRenderer *renderer;
 413
 414         column = gtk_tree_view_column_new();
 415         gtk_tree_view_column_set_title(column, text);
 416         gtk_tree_view_column_set_min_width(column, 4);
 417         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
 418         renderer = gtk_cell_renderer_text_new();
 419         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 420         gtk_tree_view_column_add_attribute(column, renderer, "text", n);
 421         gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
 422
 423         return column;
 424 }
 425
 426 static void file_util_dialog_list_select(GtkWidget *view, gint n)
 427 {
 428         GtkTreeModel *store;
 429         GtkTreeIter iter;
 430         GtkTreeSelection *selection;
 431
 432         store = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 433         if (gtk_tree_model_iter_nth_child(store, &iter, NULL, n))
 434                 {
 435                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
 436                 gtk_tree_selection_select_iter(selection, &iter);
 437                 }
 438 }
 439
 440 static GtkWidget *file_util_dialog_add_list(GtkWidget *box, GList *list, gint full_paths)
 441 {
 442         GtkWidget *scrolled;
 443         GtkWidget *view;
 444         GtkListStore *store;
 445
 446         scrolled = gtk_scrolled_window_new(NULL, NULL);
 447         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
 448         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
 449                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
 450         gtk_box_pack_start(GTK_BOX(box), scrolled, TRUE, TRUE, 0);
 451         gtk_widget_show(scrolled);
 452
 453         store = gtk_list_store_new(UTILITY_COLUMN_COUNT, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 454         view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 455         g_object_unref(store);
 456
 457         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), TRUE);
 458         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(view), FALSE);
 459
 460         if (full_paths)
 461                 {
 462                 file_util_dialog_add_list_column(view, _("Location"), UTILITY_COLUMN_PATH);
 463                 }
 464         else
 465                 {
 466                 file_util_dialog_add_list_column(view, _("Name"), UTILITY_COLUMN_NAME);
 467                 }
 468
 469         gtk_widget_set_size_request(view, UTILITY_LIST_MIN_WIDTH, UTILITY_LIST_MIN_HEIGHT);
 470         gtk_container_add(GTK_CONTAINER(scrolled), view);
 471         gtk_widget_show(view);
 472
 473         while (list)
 474                 {
 475                 FileData *fd = list->data;
 476                 GtkTreeIter iter;
 477                 gchar *sidecars;
 478
 479                 sidecars = file_data_sc_list_to_string(fd);
 480
 481                 gtk_list_store_append(store, &iter);
 482                 gtk_list_store_set(store, &iter,
 483                                    UTILITY_COLUMN_FD, fd,
 484                                    UTILITY_COLUMN_PATH, fd->path,
 485                                    UTILITY_COLUMN_NAME, fd->name,
 486                                    UTILITY_COLUMN_SIDECARS, sidecars,
 487                                    UTILITY_COLUMN_DEST_PATH, fd->change ? fd->change->dest : "error",
 488                                    UTILITY_COLUMN_DEST_NAME, fd->change ? filename_from_path(fd->change->dest) : "error",
 489                                    -1);
 490                 g_free(sidecars);
 491
 492                 list = list->next;
 493                 }
 494
 495         return view;
 496 }
 497
 498 // FIXME
 499 static void file_util_delete_dir_ok_cb(GenericDialog *gd, gpointer data);
 500
 501 void file_util_perform_ci_internal(UtilityData *ud);
 502 void file_util_dialog_run(UtilityData *ud);
 503 static gint file_util_perform_ci_cb(gpointer resume_data, gint flags, GList *list, gpointer data);
 504
 505 /* call file_util_perform_ci_internal or start_editor_from_filelist_full */
 506
 507
 508 static void file_util_resume_cb(GenericDialog *gd, gpointer data)
 509 {
 510         UtilityData *ud = data;
 511         if (ud->external)
 512                 editor_resume(ud->resume_data);
 513         else
 514                 file_util_perform_ci_internal(ud);
 515 }
 516
 517 static void file_util_abort_cb(GenericDialog *gd, gpointer data)
 518 {
 519         UtilityData *ud = data;
 520         if (ud->external)
 521                 editor_skip(ud->resume_data);
 522         else
 523                 file_util_perform_ci_cb(NULL, EDITOR_ERROR_SKIPPED, ud->flist, ud);
 524
 525 }
 526
 527
 528 static gint file_util_perform_ci_cb(gpointer resume_data, gint flags, GList *list, gpointer data)
 529 {
 530         UtilityData *ud = data;
 531         ud->resume_data = resume_data;
 532
 533         gint ret = EDITOR_CB_CONTINUE;
 534         if ((flags & EDITOR_ERROR_MASK) && !(flags & EDITOR_ERROR_SKIPPED))
 535                 {
 536                 GString *msg = g_string_new(editor_get_error_str(flags));
 537                 GenericDialog *d;
 538                 g_string_append(msg, "\n");
 539                 g_string_append(msg, ud->messages.fail);
 540                 g_string_append(msg, "\n");
 541                 while (list)
 542                         {
 543                         FileData *fd = list->data;
 544
 545                         g_string_append(msg, fd->path);
 546                         g_string_append(msg, "\n");
 547                         list = list->next;
 548                         }
 549                 if (resume_data)
 550                         {
 551                         g_string_append(msg, _("\n Continue multiple file operation?"));
 552                         d = file_util_gen_dlg(ud->messages.fail, GQ_WMCLASS, "dlg_confirm",
 553                                               NULL, TRUE,
 554                                               file_util_abort_cb, ud);
 555
 556                         generic_dialog_add_message(d, GTK_STOCK_DIALOG_WARNING, NULL, msg->str);
 557
 558                         generic_dialog_add_button(d, GTK_STOCK_GO_FORWARD, _("Co_ntinue"),
 559                                                   file_util_resume_cb, TRUE);
 560                         gtk_widget_show(d->dialog);
 561                         ret = EDITOR_CB_SUSPEND;
 562                         }
 563                 else
 564                         {
 565                         file_util_warning_dialog(ud->messages.fail, msg->str, GTK_STOCK_DIALOG_ERROR, NULL);
 566                         }
 567                 g_string_free(msg, TRUE);
 568                 }
 569
 570
 571         while (list)  /* be careful, file_util_perform_ci_internal can pass ud->flist as list */
 572                 {
 573                 FileData *fd = list->data;
 574                 list = list->next;
 575
 576                 if (!(flags & EDITOR_ERROR_MASK)) /* files were successfully deleted, call the maint functions */
 577                         {
 578                         file_data_sc_apply_ci(fd);
 579                         file_data_sc_notify_ci(fd);
 580                         }
 581
 582                 ud->flist = g_list_remove(ud->flist, fd);
 583                 file_data_sc_free_ci(fd);
 584                 file_data_unref(fd);
 585                 }
 586
 587         if (!resume_data) /* end of the list */
 588                 {
 589                 ud->phase = UTILITY_PHASE_DONE;
 590                 file_util_dialog_run(ud);
 591                 }
 592
 593         return ret;
 594 }
 595
 596
 597 /*
 598  * Perform the operation described by FileDataChangeInfo on all files in the list
 599  * it is an alternative to start_editor_from_filelist_full, it should use similar interface
 600  */
 601
 602
 603 void file_util_perform_ci_internal(UtilityData *ud)
 604 {
 605
 606         while (ud->flist)
 607                 {
 608                 gint ret;
 609
 610                 /* take a single entry each time, this allows better control over the operation */
 611                 GList *single_entry = g_list_append(NULL, ud->flist->data);
 612                 gboolean last = !ud->flist->next;
 613                 gint status = EDITOR_ERROR_STATUS;
 614
 615                 if (file_data_sc_perform_ci(single_entry->data))
 616                         status = 0; /* OK */
 617
 618                 ret = file_util_perform_ci_cb(GINT_TO_POINTER(!last), status, single_entry, ud);
 619                 g_list_free(single_entry);
 620
 621                 if (ret == EDITOR_CB_SUSPEND || last) return;
 622
 623                 if (ret == EDITOR_CB_SKIP)
 624                         {
 625                         file_util_perform_ci_cb(NULL, EDITOR_ERROR_SKIPPED, ud->flist, ud);
 626                         }
 627
 628                 /* FIXME: convert the loop to idle call */
 629
 630                 }
 631 }
 632
 633
 634 void file_util_perform_ci(UtilityData *ud)
 635 {
 636         switch (ud->type)
 637                 {
 638                 case UTILITY_TYPE_COPY:
 639                         ud->external_command = CMD_COPY;
 640                         break;
 641                 case UTILITY_TYPE_MOVE:
 642                         ud->external_command = CMD_MOVE;
 643                         break;
 644                 case UTILITY_TYPE_RENAME:
 645                         ud->external_command = CMD_RENAME;
 646                         break;
 647                 case UTILITY_TYPE_DELETE:
 648                 case UTILITY_TYPE_DELETE_LINK:
 649                 case UTILITY_TYPE_DELETE_FOLDER:
 650                         ud->external_command = CMD_DELETE;
 651                         break;
 652                 case UTILITY_TYPE_FILTER:
 653                 case UTILITY_TYPE_EDITOR:
 654                         g_assert(ud->external_command != -1); /* it should be already set */
 655                         break;
 656                 }
 657
 658         if (is_valid_editor_command(ud->external_command))
 659                 {
 660                 gint flags;
 661
 662                 ud->external = TRUE;
 663                 flags = start_editor_from_filelist_full(ud->external_command, ud->flist, file_util_perform_ci_cb, ud);
 664
 665                 if (flags)
 666                         {
 667                         gchar *text = g_strdup_printf(_("%s\nUnable to start external command.\n"), editor_get_error_str(flags));
 668                         file_util_warning_dialog(ud->messages.fail, text, GTK_STOCK_DIALOG_ERROR, NULL);
 669                         g_free(text);
 670                         }
 671                 }
 672         else
 673                 {
 674                 ud->external = FALSE;
 675                 file_util_perform_ci_internal(ud);
 676                 }
 677 }
 678
 679 static void file_util_cancel_cb(GenericDialog *gd, gpointer data)
 680 {
 681         UtilityData *ud = data;
 682
 683         generic_dialog_close(gd);
 684
 685         ud->gd = NULL;
 686
 687         ud->phase = UTILITY_PHASE_CANCEL;
 688         file_util_dialog_run(ud);
 689 }
 690
 691 static void file_util_ok_cb(GenericDialog *gd, gpointer data)
 692 {
 693         UtilityData *ud = data;
 694
 695         generic_dialog_close(gd);
 696
 697         ud->gd = NULL;
 698
 699         file_util_dialog_run(ud);
 700 }
 701
 702 static void file_util_fdlg_cancel_cb(FileDialog *fdlg, gpointer data)
 703 {
 704         UtilityData *ud = data;
 705
 706         file_dialog_close(fdlg);
 707
 708         ud->fdlg = NULL;
 709
 710         ud->phase = UTILITY_PHASE_CANCEL;
 711         file_util_dialog_run(ud);
 712 }
 713
 714 static void file_util_fdlg_ok_cb(FileDialog *fdlg, gpointer data)
 715 {
 716         UtilityData *ud = data;
 717
 718         file_dialog_close(fdlg);
 719
 720         ud->fdlg = NULL;
 721
 722         file_util_dialog_run(ud);
 723 }
 724
 725
 726 static void file_util_dest_folder_entry_cb(GtkWidget *entry, gpointer data)
 727 {
 728         UtilityData *ud = data;
 729
 730         g_free(ud->dest_path);
 731         ud->dest_path = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
 732
 733         switch (ud->type)
 734                 {
 735                 case UTILITY_TYPE_COPY:
 736                         file_data_sc_update_ci_copy_list(ud->flist, ud->dest_path);
 737                         break;
 738                 case UTILITY_TYPE_MOVE:
 739                         file_data_sc_update_ci_move_list(ud->flist, ud->dest_path);
 740                         break;
 741                 case UTILITY_TYPE_FILTER:
 742                 case UTILITY_TYPE_EDITOR:
 743                         file_data_sc_update_ci_unspecified_list(ud->flist, ud->dest_path);
 744                         break;
 745                 case UTILITY_TYPE_DELETE:
 746                 case UTILITY_TYPE_DELETE_LINK:
 747                 case UTILITY_TYPE_DELETE_FOLDER:
 748                 case UTILITY_TYPE_RENAME:
 749                         g_warning("unhandled operation");
 750                 }
 751 }
 752
 753
 754 /* format: * = filename without extension, ## = number position, extension is kept */
 755 static gchar *file_util_rename_multiple_auto_format_name(const gchar *format, const gchar *name, gint n)
 756 {
 757         gchar *new_name;
 758         gchar *parsed;
 759         const gchar *ext;
 760         gchar *middle;
 761         gchar *tmp;
 762         gchar *pad_start;
 763         gchar *pad_end;
 764         gint padding;
 765
 766         if (!format || !name) return NULL;
 767
 768         tmp = g_strdup(format);
 769         pad_start = strchr(tmp, '#');
 770         if (pad_start)
 771                 {
 772                 pad_end = pad_start;
 773                 padding = 0;
 774                 while (*pad_end == '#')
 775                         {
 776                         pad_end++;
 777                         padding++;
 778                         }
 779                 *pad_start = '\0';
 780
 781                 parsed = g_strdup_printf("%s%0*d%s", tmp, padding, n, pad_end);
 782                 g_free(tmp);
 783                 }
 784         else
 785                 {
 786                 parsed = tmp;
 787                 }
 788
 789         ext = extension_from_path(name);
 790
 791         middle = strchr(parsed, '*');
 792         if (middle)
 793                 {
 794                 gchar *base;
 795
 796                 *middle = '\0';
 797                 middle++;
 798
 799                 base = remove_extension_from_path(name);
 800                 new_name = g_strconcat(parsed, base, middle, ext, NULL);
 801                 g_free(base);
 802                 }
 803         else
 804                 {
 805                 new_name = g_strconcat(parsed, ext, NULL);
 806                 }
 807
 808         g_free(parsed);
 809
 810         return new_name;
 811 }
 812
 813
 814 static void file_util_rename_preview_update(UtilityData *ud)
 815 {
 816         GtkTreeModel *store;
 817         GtkTreeSelection *selection;
 818         GtkTreeIter iter;
 819         const gchar *front;
 820         const gchar *end;
 821         const gchar *format;
 822         gint valid;
 823         gint start_n;
 824         gint padding;
 825         gint n;
 826         gint mode;
 827
 828         mode = gtk_notebook_get_current_page(GTK_NOTEBOOK(ud->notebook));
 829
 830         if (mode == UTILITY_RENAME)
 831                 {
 832                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ud->listview));
 833                 if (gtk_tree_selection_get_selected(selection, &store, &iter))
 834                         {
 835                         FileData *fd;
 836                         const gchar *dest = gtk_entry_get_text(GTK_ENTRY(ud->rename_entry));
 837
 838                         gtk_tree_model_get(store, &iter, UTILITY_COLUMN_FD, &fd, -1);
 839                         file_data_sc_update_ci_rename(fd, dest);
 840                         gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 841                                            UTILITY_COLUMN_DEST_PATH, fd->change->dest,
 842                                            UTILITY_COLUMN_DEST_NAME, filename_from_path(fd->change->dest),
 843                                            -1);
 844                         }
 845                 return;
 846                 }
 847
 848
 849         front = gtk_entry_get_text(GTK_ENTRY(ud->auto_entry_front));
 850         end = gtk_entry_get_text(GTK_ENTRY(ud->auto_entry_end));
 851         padding = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ud->auto_spin_pad));
 852
 853         format = gtk_entry_get_text(GTK_ENTRY(ud->format_entry));
 854
 855         if (mode == UTILITY_RENAME_FORMATTED)
 856                 {
 857                 start_n = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ud->format_spin));
 858                 }
 859         else
 860                 {
 861                 start_n = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ud->auto_spin_start));
 862                 }
 863
 864         store = gtk_tree_view_get_model(GTK_TREE_VIEW(ud->listview));
 865         n = start_n;
 866         valid = gtk_tree_model_get_iter_first(store, &iter);
 867         while (valid)
 868                 {
 869                 gchar *dest;
 870                 FileData *fd;
 871                 gtk_tree_model_get(store, &iter, UTILITY_COLUMN_FD, &fd, -1);
 872
 873                 if (mode == UTILITY_RENAME_FORMATTED)
 874                         {
 875                         dest = file_util_rename_multiple_auto_format_name(format, fd->name, n);
 876                         }
 877                 else
 878                         {
 879                         dest = g_strdup_printf("%s%0*d%s", front, padding, n, end);
 880                         }
 881
 882                 file_data_sc_update_ci_rename(fd, dest);
 883                 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 884                                    UTILITY_COLUMN_DEST_PATH, fd->change->dest,
 885                                    UTILITY_COLUMN_DEST_NAME, filename_from_path(fd->change->dest),
 886                                    -1);
 887                 g_free(dest);
 888
 889                 n++;
 890                 valid = gtk_tree_model_iter_next(store, &iter);
 891                 }
 892
 893 }
 894
 895 static void file_util_rename_preview_entry_cb(GtkWidget *entry, gpointer data)
 896 {
 897         UtilityData *ud = data;
 898         file_util_rename_preview_update(ud);
 899 }
 900
 901 static void file_util_rename_preview_adj_cb(GtkWidget *spin, gpointer data)
 902 {
 903         UtilityData *ud = data;
 904         file_util_rename_preview_update(ud);
 905 }
 906
 907 static gboolean file_util_rename_idle_cb(gpointer data)
 908 {
 909         UtilityData *ud = data;
 910
 911         file_util_rename_preview_update(ud);
 912
 913         ud->update_idle_id = -1;
 914         return FALSE;
 915 }
 916
 917 static void file_util_rename_preview_order_cb(GtkTreeModel *treemodel, GtkTreePath *tpath,
 918                                                        GtkTreeIter *iter, gpointer data)
 919 {
 920         UtilityData *ud = data;
 921
 922         if (ud->update_idle_id != -1) return;
 923
 924         ud->update_idle_id = g_idle_add(file_util_rename_idle_cb, ud);
 925 }
 926
 927
 928 static gboolean file_util_preview_cb(GtkTreeSelection *selection, GtkTreeModel *store,
 929                                                 GtkTreePath *tpath, gboolean path_currently_selected,
 930                                                 gpointer data)
 931 {
 932         UtilityData *ud = data;
 933         GtkTreeIter iter;
 934         FileData *fd = NULL;
 935
 936         if (path_currently_selected ||
 937             !gtk_tree_model_get_iter(store, &iter, tpath)) return TRUE;
 938
 939         gtk_tree_model_get(store, &iter, UTILITY_COLUMN_FD, &fd, -1);
 940         generic_dialog_image_set(ud->gd, fd);
 941
 942         if (ud->type == UTILITY_TYPE_RENAME)
 943                 {
 944                 const gchar *name = filename_from_path(fd->change->dest);
 945
 946                 gtk_widget_grab_focus(ud->rename_entry);
 947                 gtk_label_set_text(GTK_LABEL(ud->rename_label), fd->name);
 948                 g_signal_handlers_block_by_func(ud->rename_entry, G_CALLBACK(file_util_rename_preview_entry_cb), ud);
 949                 gtk_entry_set_text(GTK_ENTRY(ud->rename_entry), name);
 950                 gtk_editable_select_region(GTK_EDITABLE(ud->rename_entry), 0, filename_base_length(name));
 951                 g_signal_handlers_unblock_by_func(ud->rename_entry, G_CALLBACK(file_util_rename_preview_entry_cb), ud);
 952                 }
 953
 954         return TRUE;
 955 }
 956
 957
 958
 959 static void box_append_safe_delete_status(GenericDialog *gd)
 960 {
 961         GtkWidget *label;
 962         gchar *buf;
 963
 964         buf = file_util_safe_delete_status();
 965         label = pref_label_new(gd->vbox, buf);
 966         g_free(buf);
 967
 968         gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
 969         gtk_widget_set_sensitive(label, FALSE);
 970 }
 971
 972
 973 static void file_util_dialog_init_simple_list(UtilityData *ud)
 974 {
 975         GtkWidget *box;
 976         GtkTreeSelection *selection;
 977
 978         ud->gd = file_util_gen_dlg(ud->messages.title, GQ_WMCLASS, "dlg_confirm",
 979                                    ud->parent, FALSE,  file_util_cancel_cb, ud);
 980         generic_dialog_add_button(ud->gd, GTK_STOCK_DELETE, NULL, file_util_ok_cb, TRUE);
 981
 982         box = generic_dialog_add_message(ud->gd, GTK_STOCK_DIALOG_QUESTION,
 983                                          ud->messages.question,
 984                                          ud->messages.desc_flist);
 985
 986         box = pref_group_new(box, TRUE, ud->messages.desc_flist, GTK_ORIENTATION_HORIZONTAL);
 987
 988         ud->listview = file_util_dialog_add_list(box, ud->flist, FALSE);
 989         file_util_dialog_add_list_column(ud->listview, _("Sidecars"), UTILITY_COLUMN_SIDECARS);
 990
 991         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ud->listview));
 992         gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
 993         gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, NULL);
 994
 995         generic_dialog_add_image(ud->gd, box, NULL, NULL, NULL, NULL, FALSE);
 996
 997         box_append_safe_delete_status(ud->gd);
 998
 999         gtk_widget_show(ud->gd->dialog);
1000
1001         file_util_dialog_list_select(ud->listview, 0);
1002 }
1003
1004 static void file_util_dialog_init_dest_folder(UtilityData *ud)
1005 {
1006         FileDialog *fdlg;
1007         GtkWidget *label;
1008         const gchar *stock_id;
1009
1010         if (ud->type == UTILITY_TYPE_COPY)
1011                 {
1012                 stock_id = GTK_STOCK_COPY;
1013                 }
1014         else
1015                 {
1016                 stock_id = GTK_STOCK_OK;
1017                 }
1018
1019         fdlg = file_util_file_dlg(ud->messages.title, GQ_WMCLASS, "dlg_dest_folder", ud->parent,
1020                                   file_util_fdlg_cancel_cb, ud);
1021
1022         ud->fdlg = fdlg;
1023
1024         generic_dialog_add_message(GENERIC_DIALOG(fdlg), NULL, ud->messages.question, NULL);
1025
1026         label = pref_label_new(GENERIC_DIALOG(fdlg)->vbox, _("Choose the destination folder."));
1027         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
1028         pref_spacer(GENERIC_DIALOG(fdlg)->vbox, 0);
1029
1030         file_dialog_add_button(fdlg, stock_id, ud->messages.title, file_util_fdlg_ok_cb, TRUE);
1031
1032         file_dialog_add_path_widgets(fdlg, NULL, ud->dest_path, "move_copy", NULL, NULL);
1033
1034         g_signal_connect(G_OBJECT(fdlg->entry), "changed",
1035                          G_CALLBACK(file_util_dest_folder_entry_cb), ud);
1036
1037         gtk_widget_show(GENERIC_DIALOG(fdlg)->dialog);
1038 }
1039
1040
1041 static GtkWidget *furm_simple_vlabel(GtkWidget *box, const gchar *text, gint expand)
1042 {
1043         GtkWidget *vbox;
1044         GtkWidget *label;
1045
1046         vbox = gtk_vbox_new(FALSE, 0);
1047         gtk_box_pack_start(GTK_BOX(box), vbox, expand, expand, 0);
1048         gtk_widget_show(vbox);
1049
1050         label = gtk_label_new(text);
1051         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
1052         gtk_widget_show(label);
1053
1054         return vbox;
1055 }
1056
1057
1058 static void file_util_dialog_init_source_dest(UtilityData *ud)
1059 {
1060         GtkTreeModel *store;
1061         GtkTreeSelection *selection;
1062         GtkWidget *box;
1063         GtkWidget *hbox;
1064         GtkWidget *box2;
1065         GtkWidget *table;
1066         GtkWidget *combo;
1067         GtkWidget *page;
1068
1069         ud->gd = file_util_gen_dlg(ud->messages.title, GQ_WMCLASS, "dlg_confirm",
1070                                    ud->parent, FALSE,  file_util_cancel_cb, ud);
1071
1072         box = generic_dialog_add_message(ud->gd, NULL, ud->messages.question, NULL);
1073         generic_dialog_add_button(ud->gd, GTK_STOCK_OK, ud->messages.title, file_util_ok_cb, TRUE);
1074
1075         box = pref_group_new(box, TRUE, ud->messages.desc_flist, GTK_ORIENTATION_HORIZONTAL);
1076
1077         ud->listview = file_util_dialog_add_list(box, ud->flist, FALSE);
1078         file_util_dialog_add_list_column(ud->listview, _("Sidecars"), UTILITY_COLUMN_SIDECARS);
1079
1080         file_util_dialog_add_list_column(ud->listview, _("New name"), UTILITY_COLUMN_DEST_NAME);
1081
1082         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ud->listview));
1083         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
1084         gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, NULL);
1085
1086
1087 //      column = file_util_rename_multiple_add_column(rd, _("Preview"), RENAME_COLUMN_PREVIEW);
1088 //      gtk_tree_view_column_set_visible(column, FALSE);
1089
1090         gtk_tree_view_set_reorderable(GTK_TREE_VIEW(ud->listview), TRUE);
1091
1092         store = gtk_tree_view_get_model(GTK_TREE_VIEW(ud->listview));
1093         g_signal_connect(G_OBJECT(store), "row_changed",
1094                          G_CALLBACK(file_util_rename_preview_order_cb), ud);
1095         gtk_widget_set_size_request(ud->listview, 300, 150);
1096
1097         generic_dialog_add_image(ud->gd, box, NULL, NULL, NULL, NULL, FALSE);
1098
1099 //      gtk_container_add(GTK_CONTAINER(scrolled), view);
1100         gtk_widget_show(ud->gd->dialog);
1101
1102
1103         ud->notebook = gtk_notebook_new();
1104
1105         gtk_box_pack_start(GTK_BOX(ud->gd->vbox), ud->notebook, FALSE, FALSE, 0);
1106         gtk_widget_show(ud->notebook);
1107
1108
1109         page = gtk_vbox_new(FALSE, PREF_PAD_GAP);
1110         gtk_notebook_append_page(GTK_NOTEBOOK(ud->notebook), page, gtk_label_new(_("Manual rename")));
1111         gtk_widget_show(page);
1112
1113         table = pref_table_new(page, 2, 2, FALSE, FALSE);
1114
1115         pref_table_label(table, 0, 0, _("Original name:"), 1.0);
1116         ud->rename_label = pref_table_label(table, 1, 0, "", 0.0);
1117
1118         pref_table_label(table, 0, 1, _("New name:"), 1.0);
1119
1120         ud->rename_entry = gtk_entry_new();
1121         gtk_table_attach(GTK_TABLE(table), ud->rename_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
1122         generic_dialog_attach_default(GENERIC_DIALOG(ud->gd), ud->rename_entry);
1123         gtk_widget_grab_focus(ud->rename_entry);
1124
1125         g_signal_connect(G_OBJECT(ud->rename_entry), "changed",
1126                          G_CALLBACK(file_util_rename_preview_entry_cb), ud);
1127
1128         gtk_widget_show(ud->rename_entry);
1129
1130         page = gtk_vbox_new(FALSE, PREF_PAD_GAP);
1131         gtk_notebook_append_page(GTK_NOTEBOOK(ud->notebook), page, gtk_label_new(_("Auto rename")));
1132         gtk_widget_show(page);
1133
1134
1135         hbox = pref_box_new(page, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
1136
1137         box2 = furm_simple_vlabel(hbox, _("Begin text"), TRUE);
1138
1139         combo = history_combo_new(&ud->auto_entry_front, "", "numerical_rename_prefix", -1);
1140         g_signal_connect(G_OBJECT(ud->auto_entry_front), "changed",
1141                          G_CALLBACK(file_util_rename_preview_entry_cb), ud);
1142         gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
1143         gtk_widget_show(combo);
1144
1145         box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE);
1146
1147         ud->auto_spin_start = pref_spin_new(box2, NULL, NULL,
1148                                             0.0, 1000000.0, 1.0, 0, 1.0,
1149                                             G_CALLBACK(file_util_rename_preview_adj_cb), ud);
1150
1151         box2 = furm_simple_vlabel(hbox, _("End text"), TRUE);
1152
1153         combo = history_combo_new(&ud->auto_entry_end, "", "numerical_rename_suffix", -1);
1154         g_signal_connect(G_OBJECT(ud->auto_entry_end), "changed",
1155                          G_CALLBACK(file_util_rename_preview_entry_cb), ud);
1156         gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
1157         gtk_widget_show(combo);
1158
1159         ud->auto_spin_pad = pref_spin_new(page, _("Padding:"), NULL,
1160                                           1.0, 8.0, 1.0, 0, 1.0,
1161                                           G_CALLBACK(file_util_rename_preview_adj_cb), ud);
1162
1163         page = gtk_vbox_new(FALSE, PREF_PAD_GAP);
1164         gtk_notebook_append_page(GTK_NOTEBOOK(ud->notebook), page, gtk_label_new(_("Formatted rename")));
1165         gtk_widget_show(page);
1166
1167         hbox = pref_box_new(page, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
1168
1169         box2 = furm_simple_vlabel(hbox, _("Format (* = original name, ## = numbers)"), TRUE);
1170
1171         combo = history_combo_new(&ud->format_entry, "", "auto_rename_format", -1);
1172         g_signal_connect(G_OBJECT(ud->format_entry), "changed",
1173                          G_CALLBACK(file_util_rename_preview_entry_cb), ud);
1174         gtk_box_pack_start(GTK_BOX(box2), combo, TRUE, TRUE, 0);
1175         gtk_widget_show(combo);
1176
1177         box2 = furm_simple_vlabel(hbox, _("Start #"), FALSE);
1178
1179         ud->format_spin = pref_spin_new(box2, NULL, NULL,
1180                                         0.0, 1000000.0, 1.0, 0, 1.0,
1181                                         G_CALLBACK(file_util_rename_preview_adj_cb), ud);
1182
1183 //      gtk_combo_box_set_active(GTK_COMBO_BOX(ud->combo_type), 0); /* callback will take care of the rest */
1184
1185         file_util_dialog_list_select(ud->listview, 0);
1186 }
1187
1188
1189 void file_util_dialog_run(UtilityData *ud)
1190 {
1191         switch (ud->phase)
1192                 {
1193                 case UTILITY_PHASE_START:
1194                         /* create the dialogs */
1195                         switch (ud->type)
1196                                 {
1197                                 case UTILITY_TYPE_DELETE:
1198                                 case UTILITY_TYPE_DELETE_LINK:
1199                                 case UTILITY_TYPE_DELETE_FOLDER:
1200                                 case UTILITY_TYPE_EDITOR:
1201                                         file_util_dialog_init_simple_list(ud);
1202                                         break;
1203                                 case UTILITY_TYPE_RENAME:
1204                                         file_util_dialog_init_source_dest(ud);
1205                                         break;
1206                                 case UTILITY_TYPE_COPY:
1207                                 case UTILITY_TYPE_MOVE:
1208                                 case UTILITY_TYPE_FILTER:
1209                                         file_util_dialog_init_dest_folder(ud);
1210                                         break;
1211                                 }
1212                         ud->phase = UTILITY_PHASE_ENTERING;
1213                         break;
1214                 case UTILITY_PHASE_ENTERING:
1215                         /* FIXME use file_data_sc_check_ci_dest to detect problems and eventually go back to PHASE_START
1216                         or to PHASE_CANCEL */
1217
1218                         ud->phase = UTILITY_PHASE_CHECKED;
1219                 case UTILITY_PHASE_CHECKED:
1220                         file_util_perform_ci(ud);
1221                         break;
1222                 case UTILITY_PHASE_CANCEL:
1223                 case UTILITY_PHASE_DONE:
1224                         file_data_sc_free_ci_list(ud->flist);
1225                         file_data_sc_free_ci_list(ud->dlist);
1226                         if (ud->source_fd) file_data_sc_free_ci(ud->source_fd);
1227                         file_util_data_free(ud);
1228                         break;
1229                 }
1230 }
1231
1232
1233
1234
1235 static gint file_util_unlink(FileData *fd)
1236 {
1237 }
1238
1239 static void file_util_warn_op_in_progress(const gchar *title)
1240 {
1241         file_util_warning_dialog(title, _("Another operation in progress.\n"), GTK_STOCK_DIALOG_ERROR, NULL);
1242 }
1243
1244 static void file_util_delete_full(FileData *source_fd, GList *source_list, GtkWidget *parent, UtilityPhase phase)
1245 {
1246         UtilityData *ud;
1247         GList *flist = filelist_copy(source_list);
1248
1249         if (source_fd)
1250                 flist = g_list_append(flist, file_data_ref(source_fd));
1251
1252         if (!file_data_sc_add_ci_delete_list(flist))
1253                 {
1254                 file_util_warn_op_in_progress(_("File deletion failed"));
1255                 filelist_free(flist);
1256                 return;
1257                 }
1258
1259         ud = file_util_data_new(UTILITY_TYPE_DELETE);
1260
1261         ud->phase = phase;
1262
1263         ud->source_fd = NULL;
1264         ud->flist = flist;
1265         ud->dlist = NULL;
1266         ud->parent = parent;
1267
1268         ud->messages.title = _("Delete");
1269         ud->messages.question = _("Delete files?");
1270         ud->messages.desc_flist = _("This will delete the following files");
1271         ud->messages.desc_dlist = "";
1272         ud->messages.desc_source_fd = "";
1273         ud->messages.fail = _("File deletion failed");
1274
1275         file_util_dialog_run(ud);
1276 }
1277
1278 static void file_util_move_full(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase)
1279 {
1280         UtilityData *ud;
1281         GList *flist = filelist_copy(source_list);
1282
1283         if (source_fd)
1284                 flist = g_list_append(flist, file_data_ref(source_fd));
1285
1286         if (!file_data_sc_add_ci_move_list(flist, dest_path))
1287                 {
1288                 file_util_warn_op_in_progress(_("Move failed"));
1289                 filelist_free(flist);
1290                 return;
1291                 }
1292
1293         ud = file_util_data_new(UTILITY_TYPE_MOVE);
1294
1295         ud->phase = phase;
1296
1297         ud->source_fd = NULL;
1298         ud->flist = flist;
1299         ud->dlist = NULL;
1300         ud->parent = parent;
1301
1302         ud->dest_path = g_strdup(dest_path ? dest_path : "");
1303
1304         ud->messages.title = _("Move");
1305         ud->messages.question = _("Move files?");
1306         ud->messages.desc_flist = _("This will move the following files");
1307         ud->messages.desc_dlist = "";
1308         ud->messages.desc_source_fd = "";
1309         ud->messages.fail = _("Move failed");
1310
1311         file_util_dialog_run(ud);
1312 }
1313 static void file_util_copy_full(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase)
1314 {
1315         UtilityData *ud;
1316         GList *flist = filelist_copy(source_list);
1317
1318         if (source_fd)
1319                 flist = g_list_append(flist, file_data_ref(source_fd));
1320
1321         if (!file_data_sc_add_ci_copy_list(flist, dest_path))
1322                 {
1323                 file_util_warn_op_in_progress(_("Copy failed"));
1324                 filelist_free(flist);
1325                 return;
1326                 }
1327
1328         ud = file_util_data_new(UTILITY_TYPE_COPY);
1329
1330         ud->phase = phase;
1331
1332         ud->source_fd = NULL;
1333         ud->flist = flist;
1334         ud->dlist = NULL;
1335         ud->parent = parent;
1336
1337         ud->dest_path = g_strdup(dest_path ? dest_path : "");
1338
1339         ud->messages.title = _("Copy");
1340         ud->messages.question = _("Copy files?");
1341         ud->messages.desc_flist = _("This will copy the following files");
1342         ud->messages.desc_dlist = "";
1343         ud->messages.desc_source_fd = "";
1344         ud->messages.fail = _("Copy failed");
1345
1346         file_util_dialog_run(ud);
1347 }
1348
1349 static void file_util_rename_full(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase)
1350 {
1351         UtilityData *ud;
1352         GList *flist = filelist_copy(source_list);
1353
1354         if (source_fd)
1355                 flist = g_list_append(flist, file_data_ref(source_fd));
1356
1357         if (!file_data_sc_add_ci_rename_list(flist, dest_path))
1358                 {
1359                 file_util_warn_op_in_progress(_("Rename failed"));
1360                 filelist_free(flist);
1361                 return;
1362                 }
1363
1364         ud = file_util_data_new(UTILITY_TYPE_RENAME);
1365
1366         ud->phase = phase;
1367
1368         ud->source_fd = NULL;
1369         ud->flist = flist;
1370         ud->dlist = NULL;
1371         ud->parent = parent;
1372
1373         ud->messages.title = _("Rename");
1374         ud->messages.question = _("Rename files?");
1375         ud->messages.desc_flist = _("This will rename the following files");
1376         ud->messages.desc_dlist = "";
1377         ud->messages.desc_source_fd = "";
1378         ud->messages.fail = _("Rename failed");
1379
1380         file_util_dialog_run(ud);
1381 }
1382
1383 static void file_util_start_editor_full(gint n, FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent, UtilityPhase phase)
1384 {
1385         UtilityData *ud;
1386         GList *flist = filelist_copy(source_list);
1387
1388         if (source_fd)
1389                 flist = g_list_append(flist, file_data_ref(source_fd));
1390
1391         if (!file_data_sc_add_ci_unspecified_list(flist, dest_path))
1392                 {
1393                 file_util_warn_op_in_progress(_("Can't run external editor"));
1394                 filelist_free(flist);
1395                 return;
1396                 }
1397
1398         if (editor_is_filter(n))
1399                 ud = file_util_data_new(UTILITY_TYPE_FILTER);
1400         else
1401                 ud = file_util_data_new(UTILITY_TYPE_EDITOR);
1402
1403
1404         /* ask for destination if we don't have it */
1405         if (ud->type == UTILITY_TYPE_FILTER && dest_path == NULL) phase = UTILITY_PHASE_START;
1406
1407         ud->phase = phase;
1408
1409         ud->external_command = n;
1410
1411         ud->source_fd = NULL;
1412         ud->flist = flist;
1413         ud->dlist = NULL;
1414         ud->parent = parent;
1415
1416         ud->dest_path = g_strdup(dest_path ? dest_path : "");
1417
1418         ud->messages.title = _("Editor");
1419         ud->messages.question = _("Run editor?");
1420         ud->messages.desc_flist = _("This will copy the following files");
1421         ud->messages.desc_dlist = "";
1422         ud->messages.desc_source_fd = "";
1423         ud->messages.fail = _("External command failed");
1424
1425         file_util_dialog_run(ud);
1426 }
1427
1428
1429 /* FIXME: */
1430 void file_util_create_dir(FileData *dir_fd, GtkWidget *parent)
1431 {
1432 }
1433
1434 gint file_util_rename_dir(FileData *source_fd, const gchar *new_path, GtkWidget *parent)
1435 {
1436 }
1437
1438 /* full-featured entry points
1439 */
1440
1441 void file_util_delete(FileData *source_fd, GList *source_list, GtkWidget *parent)
1442 {
1443         file_util_delete_full(source_fd, source_list, parent, UTILITY_PHASE_START);
1444 }
1445
1446 void file_util_copy(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent)
1447 {
1448         file_util_copy_full(source_fd, source_list, dest_path, parent, UTILITY_PHASE_START);
1449 }
1450
1451 void file_util_move(FileData *source_fd, GList *source_list, const gchar *dest_path, GtkWidget *parent)
1452 {
1453         file_util_move_full(source_fd, source_list, dest_path, parent, UTILITY_PHASE_START);
1454 }
1455
1456 void file_util_rename(FileData *source_fd, GList *source_list, GtkWidget *parent)
1457 {
1458         file_util_rename_full(source_fd, source_list, NULL, parent, UTILITY_PHASE_START);
1459 }
1460
1461 /* these avoid the location entry dialog unless there is an error, list must be files only and
1462  * dest_path must be a valid directory path
1463  */
1464 void file_util_move_simple(GList *list, const gchar *dest_path, GtkWidget *parent)
1465 {
1466         file_util_move_full(NULL, list, dest_path, parent, UTILITY_PHASE_ENTERING);
1467 }
1468
1469 void file_util_copy_simple(GList *list, const gchar *dest_path, GtkWidget *parent)
1470 {
1471         file_util_copy_full(NULL, list, dest_path, parent, UTILITY_PHASE_ENTERING);
1472 }
1473
1474 void file_util_rename_simple(FileData *fd, const gchar *dest_path, GtkWidget *parent)
1475 {
1476         file_util_rename_full(fd, NULL, dest_path, parent, UTILITY_PHASE_ENTERING);
1477 }
1478
1479
1480 void file_util_start_editor_from_file(gint n, FileData *fd, GtkWidget *parent)
1481 {
1482         file_util_start_editor_full(n, fd, NULL, NULL, parent, UTILITY_PHASE_ENTERING);
1483 }
1484
1485 void file_util_start_editor_from_filelist(gint n, GList *list, GtkWidget *parent)
1486 {
1487         file_util_start_editor_full(n, NULL, list, NULL, parent, UTILITY_PHASE_ENTERING);
1488 }
1489
1490 void file_util_start_filter_from_file(gint n, FileData *fd, const gchar *dest_path, GtkWidget *parent)
1491 {
1492         file_util_start_editor_full(n, fd, NULL, dest_path, parent, UTILITY_PHASE_ENTERING);
1493 }
1494
1495 void file_util_start_filter_from_filelist(gint n, GList *list, const gchar *dest_path, GtkWidget *parent)
1496 {
1497         file_util_start_editor_full(n, NULL, list, dest_path, parent, UTILITY_PHASE_ENTERING);
1498 }
1499
1500
1501 /*
1502  *--------------------------------------------------------------------------
1503  * Delete directory routines
1504  *--------------------------------------------------------------------------
1505  */
1506
1507 // FIXME
1508
1509
1510
1511 FileData *file_util_delete_dir_empty_path(FileData *fd, gint real_content, gint level)
1512 {
1513         GList *dlist;
1514         GList *flist;
1515         GList *work;
1516         FileData *fail = NULL;
1517
1518         DEBUG_1("deltree into: %s", fd->path);
1519
1520         level++;
1521         if (level > UTILITY_DELETE_MAX_DEPTH)
1522                 {
1523                 log_printf("folder recursion depth past %d, giving up\n", UTILITY_DELETE_MAX_DEPTH);
1524                 return file_data_ref(fd);
1525                 }
1526
1527         if (!filelist_read_lstat(fd, &flist, &dlist)) file_data_ref(fd);
1528
1529         work = dlist;
1530         while (work && !fail)
1531                 {
1532                 FileData *lfd;
1533
1534                 lfd = work->data;
1535                 work = work->next;
1536
1537                 fail = file_util_delete_dir_empty_path(lfd, real_content, level);
1538                 }
1539
1540         work = flist;
1541         while (work && !fail)
1542                 {
1543                 FileData *lfd;
1544
1545                 lfd = work->data;
1546                 work = work->next;
1547
1548                 DEBUG_1("deltree child: %s", lfd->path);
1549
1550                 if (real_content && !islink(lfd->path))
1551                         {
1552                         if (!file_util_unlink(lfd)) fail = file_data_ref(lfd);
1553                         }
1554                 else
1555                         {
1556                         if (!unlink_file(lfd->path)) fail = file_data_ref(lfd);
1557                         }
1558                 }
1559
1560         filelist_free(dlist);
1561         filelist_free(flist);
1562
1563         if (!fail && !rmdir_utf8(fd->path))
1564                 {
1565                 fail = file_data_ref(fd);
1566                 }
1567
1568         DEBUG_1("deltree done: %s", fd->path);
1569
1570         return fail;
1571 }
1572
1573 static void file_util_delete_dir_ok_cb(GenericDialog *gd, gpointer data)
1574 {
1575         UtilityData *ud = data;
1576
1577         ud->gd = NULL;
1578
1579         if (ud->type == UTILITY_TYPE_DELETE_LINK)
1580                 {
1581                 if (!unlink_file(ud->source_fd->path))
1582                         {
1583                         gchar *text;
1584
1585                         text = g_strdup_printf("Unable to remove symbolic link:\n %s", ud->source_fd->path);
1586                         file_util_warning_dialog(_("Delete failed"), text,
1587                                                  GTK_STOCK_DIALOG_ERROR, NULL);
1588                         g_free(text);
1589                         }
1590                 }
1591         else
1592                 {
1593                 FileData *fail = NULL;
1594                 GList *work;
1595
1596                 work = ud->dlist;
1597                 while (work && !fail)
1598                         {
1599                         FileData *fd;
1600
1601                         fd = work->data;
1602                         work = work->next;
1603
1604                         fail = file_util_delete_dir_empty_path(fd, FALSE, 0);
1605                         }
1606
1607                 work = ud->flist;
1608                 while (work && !fail)
1609                         {
1610                         FileData *fd;
1611
1612                         fd = work->data;
1613                         work = work->next;
1614
1615                         DEBUG_1("deltree unlink: %s", fd->path);
1616
1617                         if (islink(fd->path))
1618                                 {
1619                                 if (!unlink_file(fd->path)) fail = file_data_ref(fd);
1620                                 }
1621                         else
1622                                 {
1623                                 if (!file_util_unlink(fd)) fail = file_data_ref(fd);
1624                                 }
1625                         }
1626
1627                 if (!fail)
1628                         {
1629                         if (!rmdir_utf8(ud->source_fd->path)) fail = file_data_ref(ud->source_fd);
1630                         }
1631
1632                 if (fail)
1633                         {
1634                         gchar *text;
1635
1636                         text = g_strdup_printf(_("Unable to delete folder:\n\n%s"), ud->source_fd->path);
1637                         gd = file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, NULL);
1638                         g_free(text);
1639
1640                         if (fail != ud->source_fd)
1641                                 {
1642                                 pref_spacer(gd->vbox, PREF_PAD_GROUP);
1643                                 text = g_strdup_printf(_("Removal of folder contents failed at this file:\n\n%s"),
1644                                                         fail->path);
1645                                 pref_label_new(gd->vbox, text);
1646                                 g_free(text);
1647                                 }
1648
1649                         file_data_unref(fail);
1650                         }
1651                 }
1652
1653         file_util_data_free(ud);
1654 }
1655
1656 static GList *file_util_delete_dir_remaining_folders(GList *dlist)
1657 {
1658         GList *rlist = NULL;
1659
1660         while (dlist)
1661                 {
1662                 FileData *fd;
1663
1664                 fd = dlist->data;
1665                 dlist = dlist->next;
1666
1667                 if (!fd->name ||
1668                     (strcmp(fd->name, THUMB_FOLDER_GLOBAL) != 0 &&
1669                      strcmp(fd->name, THUMB_FOLDER_LOCAL) != 0 &&
1670                      strcmp(fd->name, GQ_CACHE_LOCAL_METADATA) != 0) )
1671                         {
1672                         rlist = g_list_prepend(rlist, fd);
1673                         }
1674                 }
1675
1676         return g_list_reverse(rlist);
1677 }
1678
1679 void file_util_delete_dir(FileData *fd, GtkWidget *parent)
1680 {
1681         GList *dlist;
1682         GList *flist;
1683         GList *rlist;
1684
1685         if (!isdir(fd->path)) return;
1686
1687         if (islink(fd->path))
1688                 {
1689                 UtilityData *ud;
1690                 gchar *text;
1691
1692                 ud = g_new0(UtilityData, 1);
1693                 ud->type = UTILITY_TYPE_DELETE_LINK;
1694                 ud->source_fd = file_data_ref(fd);
1695                 ud->dlist = NULL;
1696                 ud->flist = NULL;
1697
1698                 ud->gd = file_util_gen_dlg(_("Delete folder"), GQ_WMCLASS, "dlg_confirm",
1699                                            parent, TRUE,
1700                                            file_util_cancel_cb, ud);
1701
1702                 text = g_strdup_printf(_("This will delete the symbolic link:\n\n%s\n\n"
1703                                          "The folder this link points to will not be deleted."),
1704                                        fd->path);
1705                 generic_dialog_add_message(ud->gd, GTK_STOCK_DIALOG_QUESTION,
1706                                            _("Delete symbolic link to folder?"),
1707                                            text);
1708                 g_free(text);
1709
1710                 generic_dialog_add_button(ud->gd, GTK_STOCK_DELETE, NULL, file_util_delete_dir_ok_cb, TRUE);
1711
1712                 gtk_widget_show(ud->gd->dialog);
1713
1714                 return;
1715                 }
1716
1717         if (!access_file(fd->path, W_OK | X_OK))
1718                 {
1719                 gchar *text;
1720
1721                 text = g_strdup_printf(_("Unable to remove folder %s\n"
1722                                          "Permissions do not allow writing to the folder."), fd->path);
1723                 file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, parent);
1724                 g_free(text);
1725
1726                 return;
1727                 }
1728
1729         if (!filelist_read_lstat(fd, &flist, &dlist))
1730                 {
1731                 gchar *text;
1732
1733                 text = g_strdup_printf(_("Unable to list contents of folder %s"), fd->path);
1734                 file_util_warning_dialog(_("Delete failed"), text, GTK_STOCK_DIALOG_ERROR, parent);
1735                 g_free(text);
1736
1737                 return;
1738                 }
1739
1740         rlist = file_util_delete_dir_remaining_folders(dlist);
1741         if (rlist)
1742                 {
1743                 GenericDialog *gd;
1744                 GtkWidget *box;
1745                 gchar *text;
1746
1747                 gd = file_util_gen_dlg(_("Folder contains subfolders"), GQ_WMCLASS, "dlg_warning",
1748                                         parent, TRUE, NULL, NULL);
1749                 generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE);
1750
1751                 text = g_strdup_printf(_("Unable to delete the folder:\n\n%s\n\n"
1752                                          "This folder contains subfolders which must be moved before it can be deleted."),
1753                                         fd->path);
1754                 box = generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING,
1755                                                  _("Folder contains subfolders"),
1756                                                  text);
1757                 g_free(text);
1758
1759                 box = pref_group_new(box, TRUE, _("Subfolders:"), GTK_ORIENTATION_VERTICAL);
1760
1761                 rlist = filelist_sort_path(rlist);
1762                 file_util_dialog_add_list(box, rlist, FALSE);
1763
1764                 gtk_widget_show(gd->dialog);
1765                 }
1766         else
1767                 {
1768                 UtilityData *ud;
1769                 GtkWidget *box;
1770                 GtkWidget *view;
1771                 GtkTreeSelection *selection;
1772                 gchar *text;
1773
1774                 ud = g_new0(UtilityData, 1);
1775                 ud->type = UTILITY_TYPE_DELETE_FOLDER;
1776                 ud->source_fd = file_data_ref(fd);
1777                 ud->dlist = dlist;
1778                 dlist = NULL;
1779                 ud->flist = filelist_sort_path(flist);
1780                 flist = NULL;
1781
1782                 ud->gd = file_util_gen_dlg(_("Delete folder"), GQ_WMCLASS, "dlg_confirm",
1783                                            parent, TRUE,  file_util_cancel_cb, ud);
1784                 generic_dialog_add_button(ud->gd, GTK_STOCK_DELETE, NULL, file_util_delete_dir_ok_cb, TRUE);
1785
1786                 text = g_strdup_printf(_("This will delete the folder:\n\n%s\n\n"
1787                                          "The contents of this folder will also be deleted."),
1788                                         fd->path);
1789                 box = generic_dialog_add_message(ud->gd, GTK_STOCK_DIALOG_QUESTION,
1790                                                  _("Delete folder?"),
1791                                                  text);
1792                 g_free(text);
1793
1794                 box = pref_group_new(box, TRUE, _("Contents:"), GTK_ORIENTATION_HORIZONTAL);
1795
1796                 view = file_util_dialog_add_list(box, ud->flist, FALSE);
1797                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
1798                 gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
1799                 gtk_tree_selection_set_select_function(selection, file_util_preview_cb, ud, NULL);
1800
1801                 generic_dialog_add_image(ud->gd, box, NULL, NULL, NULL, NULL, FALSE);
1802
1803                 box_append_safe_delete_status(ud->gd);
1804
1805                 gtk_widget_show(ud->gd->dialog);
1806                 }
1807
1808         g_list_free(rlist);
1809         filelist_free(dlist);
1810         filelist_free(flist);
1811 }
1812
1813
1814 void file_util_copy_path_to_clipboard(FileData *fd)
1815 {
1816         GtkClipboard *clipboard;
1817
1818         if (!fd || !*fd->path) return;
1819
1820         clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
1821         gtk_clipboard_set_text(clipboard, g_shell_quote(fd->path), -1);
1822 }
1823
1824 void file_util_copy_path_list_to_clipboard(GList *list)
1825 {
1826         GtkClipboard *clipboard;
1827         GList *work;
1828         GString *new;
1829
1830         clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
1831
1832         new = g_string_new("");
1833         work = list;
1834         while (work) {
1835                 FileData *fd = work->data;
1836                 work = work->next;
1837
1838                 if (!fd || !*fd->path) continue;
1839
1840                 g_string_append(new, g_shell_quote(fd->path));
1841                 if (work) g_string_append_c(new, ' ');
1842                 }
1843
1844         gtk_clipboard_set_text(clipboard, new->str, new->len);
1845         g_string_free(new, TRUE);
1846 }