src/dupe.c

   1 /*
   2  * Geeqie
   3  * (C) 2005 John Ellis
   4  * Copyright (C) 2008 - 2012 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 "dupe.h"
  16
  17 #include "cache.h"
  18 #include "collect.h"
  19 #include "collect-table.h"
  20 #include "dnd.h"
  21 #include "editors.h"
  22 #include "filedata.h"
  23 #include "image-load.h"
  24 #include "img-view.h"
  25 #include "layout.h"
  26 #include "layout_image.h"
  27 #include "md5-util.h"
  28 #include "menu.h"
  29 #include "misc.h"
  30 #include "print.h"
  31 #include "thumb.h"
  32 #include "ui_fileops.h"
  33 #include "ui_menu.h"
  34 #include "ui_misc.h"
  35 #include "ui_tree_edit.h"
  36 #include "uri_utils.h"
  37 #include "utilops.h"
  38 #include "window.h"
  39
  40 #include <gdk/gdkkeysyms.h> /* for keyboard values */
  41
  42
  43 #include <math.h>
  44
  45
  46 #define DUPE_DEF_WIDTH 800
  47 #define DUPE_DEF_HEIGHT 400
  48
  49 /* column assignment order (simply change them here) */
  50 enum {
  51         DUPE_COLUMN_POINTER = 0,
  52         DUPE_COLUMN_RANK,
  53         DUPE_COLUMN_THUMB,
  54         DUPE_COLUMN_NAME,
  55         DUPE_COLUMN_SIZE,
  56         DUPE_COLUMN_DATE,
  57         DUPE_COLUMN_DIMENSIONS,
  58         DUPE_COLUMN_PATH,
  59         DUPE_COLUMN_COLOR,
  60         DUPE_COLUMN_COUNT       /* total columns */
  61 };
  62
  63
  64 static GList *dupe_window_list = NULL;  /* list of open DupeWindow *s */
  65
  66 /*
  67  * Well, after adding the 'compare two sets' option things got a little sloppy in here
  68  * because we have to account for two 'modes' everywhere. (be careful).
  69  */
  70
  71 static void dupe_match_unlink(DupeItem *a, DupeItem *b);
  72 static DupeItem *dupe_match_find_parent(DupeWindow *dw, DupeItem *child);
  73
  74 static gint dupe_match(DupeItem *a, DupeItem *b, DupeMatchType mask, gdouble *rank, gint fast);
  75
  76 static void dupe_thumb_step(DupeWindow *dw);
  77 static gint dupe_check_cb(gpointer data);
  78
  79 static void dupe_second_add(DupeWindow *dw, DupeItem *di);
  80 static void dupe_second_remove(DupeWindow *dw, DupeItem *di);
  81 static GtkWidget *dupe_menu_popup_second(DupeWindow *dw, DupeItem *di);
  82
  83 static void dupe_dnd_init(DupeWindow *dw);
  84
  85 static void dupe_notify_cb(FileData *fd, NotifyType type, gpointer data);
  86
  87 /*
  88  * ------------------------------------------------------------------
  89  * Window updates
  90  * ------------------------------------------------------------------
  91  */
  92
  93
  94 static void dupe_window_update_count(DupeWindow *dw, gboolean count_only)
  95 {
  96         gchar *text;
  97
  98         if (!dw->list)
  99                 {
 100                 text = g_strdup(_("Drop files to compare them."));
 101                 }
 102         else if (count_only)
 103                 {
 104                 text = g_strdup_printf(_("%d files"), g_list_length(dw->list));
 105                 }
 106         else
 107                 {
 108                 text = g_strdup_printf(_("%d matches found in %d files"), g_list_length(dw->dupes), g_list_length(dw->list));
 109                 }
 110
 111         if (dw->second_set)
 112                 {
 113                 gchar *buf = g_strconcat(text, " ", _("[set 1]"), NULL);
 114                 g_free(text);
 115                 text = buf;
 116                 }
 117         gtk_label_set_text(GTK_LABEL(dw->status_label), text);
 118
 119         g_free(text);
 120 }
 121
 122 static guint64 msec_time(void)
 123 {
 124         struct timeval tv;
 125
 126         if (gettimeofday(&tv, NULL) == -1) return 0;
 127
 128         return (guint64)tv.tv_sec * 1000000 + (guint64)tv.tv_usec;
 129 }
 130
 131 static gint dupe_iterations(gint n)
 132 {
 133         return (n * ((n + 1) / 2));
 134 }
 135
 136 static void dupe_window_update_progress(DupeWindow *dw, const gchar *status, gdouble value, gboolean force)
 137 {
 138         const gchar *status_text;
 139
 140         if (status)
 141                 {
 142                 guint64 new_time = 0;
 143
 144                 if (dw->setup_n % 10 == 0)
 145                         {
 146                         new_time = msec_time() - dw->setup_time;
 147                         }
 148
 149                 if (!force &&
 150                     value != 0.0 &&
 151                     dw->setup_count > 0 &&
 152                     new_time > 2000000)
 153                         {
 154                         gchar *buf;
 155                         gint t;
 156                         gint d;
 157                         guint32 rem;
 158
 159                         if (new_time - dw->setup_time_count < 250000) return;
 160                         dw->setup_time_count = new_time;
 161
 162                         if (dw->setup_done)
 163                                 {
 164                                 if (dw->second_set)
 165                                         {
 166                                         t = dw->setup_count;
 167                                         d = dw->setup_count - dw->setup_n;
 168                                         }
 169                                 else
 170                                         {
 171                                         t = dupe_iterations(dw->setup_count);
 172                                         d = dupe_iterations(dw->setup_count - dw->setup_n);
 173                                         }
 174                                 }
 175                         else
 176                                 {
 177                                 t = dw->setup_count;
 178                                 d = dw->setup_count - dw->setup_n;
 179                                 }
 180
 181                         rem = (t - d) ? ((gdouble)(dw->setup_time_count / 1000000) / (t - d)) * d : 0;
 182
 183                         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), value);
 184
 185                         buf = g_strdup_printf("%s %d:%02d ", status, rem / 60, rem % 60);
 186                         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(dw->extra_label), buf);
 187                         g_free(buf);
 188
 189                         return;
 190                         }
 191                 else if (force ||
 192                          value == 0.0 ||
 193                          dw->setup_count == 0 ||
 194                          dw->setup_time_count == 0 ||
 195                          (new_time > 0 && new_time - dw->setup_time_count >= 250000))
 196                         {
 197                         if (dw->setup_time_count == 0) dw->setup_time_count = 1;
 198                         if (new_time > 0) dw->setup_time_count = new_time;
 199                         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), value);
 200                         status_text = status;
 201                         }
 202                 else
 203                         {
 204                         status_text = NULL;
 205                         }
 206                 }
 207         else
 208                 {
 209                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), 0.0);
 210                 status_text = " ";
 211                 }
 212
 213         if (status_text) gtk_progress_bar_set_text(GTK_PROGRESS_BAR(dw->extra_label), status_text);
 214 }
 215
 216 static void widget_set_cursor(GtkWidget *widget, gint icon)
 217 {
 218         GdkCursor *cursor;
 219
 220         if (!gtk_widget_get_window(widget)) return;
 221
 222         if (icon == -1)
 223                 {
 224                 cursor = NULL;
 225                 }
 226         else
 227                 {
 228                 cursor = gdk_cursor_new(icon);
 229                 }
 230
 231         gdk_window_set_cursor(gtk_widget_get_window(widget), cursor);
 232
 233         if (cursor) gdk_cursor_unref(cursor);
 234 }
 235
 236 /*
 237  * ------------------------------------------------------------------
 238  * row color utils
 239  * ------------------------------------------------------------------
 240  */
 241
 242 static void dupe_listview_realign_colors(DupeWindow *dw)
 243 {
 244         GtkTreeModel *store;
 245         GtkTreeIter iter;
 246         gboolean color_set = TRUE;
 247         DupeItem *parent = NULL;
 248         gboolean valid;
 249
 250         store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
 251         valid = gtk_tree_model_get_iter_first(store, &iter);
 252         while (valid)
 253                 {
 254                 DupeItem *child;
 255                 DupeItem *child_parent;
 256
 257                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &child, -1);
 258                 child_parent = dupe_match_find_parent(dw, child);
 259                 if (!parent || parent != child_parent)
 260                         {
 261                         if (!parent)
 262                                 {
 263                                 /* keep the first row as it is */
 264                                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_COLOR, &color_set, -1);
 265                                 }
 266                         else
 267                                 {
 268                                 color_set = !color_set;
 269                                 }
 270                         parent = dupe_match_find_parent(dw, child);
 271                         }
 272                 gtk_list_store_set(GTK_LIST_STORE(store), &iter, DUPE_COLUMN_COLOR, color_set, -1);
 273
 274                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
 275                 }
 276 }
 277
 278 /*
 279  * ------------------------------------------------------------------
 280  * Dupe item utils
 281  * ------------------------------------------------------------------
 282  */
 283
 284 static DupeItem *dupe_item_new(FileData *fd)
 285 {
 286         DupeItem *di;
 287
 288         di = g_new0(DupeItem, 1);
 289
 290         di->fd = file_data_ref(fd);
 291         di->group_rank = 0.0;
 292
 293         return di;
 294 }
 295
 296 static void dupe_item_free(DupeItem *di)
 297 {
 298         file_data_unref(di->fd);
 299         image_sim_free(di->simd);
 300         g_free(di->md5sum);
 301         if (di->pixbuf) g_object_unref(di->pixbuf);
 302
 303         g_free(di);
 304 }
 305
 306 static void dupe_list_free(GList *list)
 307 {
 308         GList *work = list;
 309         while (work)
 310                 {
 311                 DupeItem *di = work->data;
 312                 work = work->next;
 313                 dupe_item_free(di);
 314                 }
 315         g_list_free(list);
 316 }
 317
 318 /*
 319 static DupeItem *dupe_item_find_fd_by_list(FileData *fd, GList *work)
 320 {
 321         while (work)
 322                 {
 323                 DupeItem *di = work->data;
 324
 325                 if (di->fd == fd) return di;
 326
 327                 work = work->next;
 328                 }
 329
 330         return NULL;
 331 }
 332 */
 333
 334 /*
 335 static DupeItem *dupe_item_find_fd(DupeWindow *dw, FileData *fd)
 336 {
 337         DupeItem *di;
 338
 339         di = dupe_item_find_fd_by_list(fd, dw->list);
 340         if (!di && dw->second_set) di = dupe_item_find_fd_by_list(fd, dw->second_list);
 341
 342         return di;
 343 }
 344 */
 345
 346 static DupeItem *dupe_item_find_path_by_list(const gchar *path, GList *work)
 347 {
 348         while (work)
 349                 {
 350                 DupeItem *di = work->data;
 351
 352                 if (strcmp(di->fd->path, path) == 0) return di;
 353
 354                 work = work->next;
 355                 }
 356
 357         return NULL;
 358 }
 359
 360 static DupeItem *dupe_item_find_path(DupeWindow *dw, const gchar *path)
 361 {
 362         DupeItem *di;
 363
 364         di = dupe_item_find_path_by_list(path, dw->list);
 365         if (!di && dw->second_set) di = dupe_item_find_path_by_list(path, dw->second_list);
 366
 367         return di;
 368 }
 369
 370 /*
 371  * ------------------------------------------------------------------
 372  * Image property cache
 373  * ------------------------------------------------------------------
 374  */
 375
 376 static void dupe_item_read_cache(DupeItem *di)
 377 {
 378         gchar *path;
 379         CacheData *cd;
 380
 381         if (!di) return;
 382
 383         path = cache_find_location(CACHE_TYPE_SIM, di->fd->path);
 384         if (!path) return;
 385
 386         if (filetime(di->fd->path) != filetime(path))
 387                 {
 388                 g_free(path);
 389                 return;
 390                 }
 391
 392         cd = cache_sim_data_load(path);
 393         g_free(path);
 394
 395         if (cd)
 396                 {
 397                 if (!di->simd && cd->sim)
 398                         {
 399                         di->simd = cd->sim;
 400                         cd->sim = NULL;
 401                         }
 402                 if (di->width == 0 && di->height == 0 && cd->dimensions)
 403                         {
 404                         di->width = cd->width;
 405                         di->height = cd->height;
 406                         }
 407                 if (!di->md5sum && cd->have_md5sum)
 408                         {
 409                         di->md5sum = md5_digest_to_text(cd->md5sum);
 410                         }
 411                 cache_sim_data_free(cd);
 412                 }
 413 }
 414
 415 static void dupe_item_write_cache(DupeItem *di)
 416 {
 417         gchar *base;
 418         mode_t mode = 0755;
 419
 420         if (!di) return;
 421
 422         base = cache_get_location(CACHE_TYPE_SIM, di->fd->path, FALSE, &mode);
 423         if (recursive_mkdir_if_not_exists(base, mode))
 424                 {
 425                 CacheData *cd;
 426
 427                 cd = cache_sim_data_new();
 428                 cd->path = cache_get_location(CACHE_TYPE_SIM, di->fd->path, TRUE, NULL);
 429
 430                 if (di->width != 0) cache_sim_data_set_dimensions(cd, di->width, di->height);
 431                 if (di->md5sum)
 432                         {
 433                         guchar digest[16];
 434                         if (md5_digest_from_text(di->md5sum, digest)) cache_sim_data_set_md5sum(cd, digest);
 435                         }
 436                 if (di->simd) cache_sim_data_set_similarity(cd, di->simd);
 437
 438                 if (cache_sim_data_save(cd))
 439                         {
 440                         filetime_set(cd->path, filetime(di->fd->path));
 441                         }
 442                 cache_sim_data_free(cd);
 443                 }
 444         g_free(base);
 445 }
 446
 447 /*
 448  * ------------------------------------------------------------------
 449  * Window list utils
 450  * ------------------------------------------------------------------
 451  */
 452
 453 static gint dupe_listview_find_item(GtkListStore *store, DupeItem *item, GtkTreeIter *iter)
 454 {
 455         gboolean valid;
 456         gint row = 0;
 457
 458         valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), iter);
 459         while (valid)
 460                 {
 461                 DupeItem *item_n;
 462                 gtk_tree_model_get(GTK_TREE_MODEL(store), iter, DUPE_COLUMN_POINTER, &item_n, -1);
 463                 if (item_n == item) return row;
 464
 465                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), iter);
 466                 row++;
 467                 }
 468
 469         return -1;
 470 }
 471
 472 static void dupe_listview_add(DupeWindow *dw, DupeItem *parent, DupeItem *child)
 473 {
 474         DupeItem *di;
 475         gint row;
 476         gchar *text[DUPE_COLUMN_COUNT];
 477         GtkListStore *store;
 478         GtkTreeIter iter;
 479         gboolean color_set = FALSE;
 480         gint rank;
 481
 482         if (!parent) return;
 483
 484         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
 485
 486         if (child)
 487                 {
 488                 DupeMatch *dm;
 489
 490                 row = dupe_listview_find_item(store, parent, &iter);
 491                 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_COLOR, &color_set, -1);
 492
 493                 row++;
 494
 495                 if (child->group)
 496                         {
 497                         dm = child->group->data;
 498                         rank = (gint)floor(dm->rank);
 499                         }
 500                 else
 501                         {
 502                         rank = 1;
 503                         log_printf("NULL group in item!\n");
 504                         }
 505                 }
 506         else
 507                 {
 508                 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter))
 509                         {
 510                         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, DUPE_COLUMN_COLOR, &color_set, -1);
 511                         color_set = !color_set;
 512                         }
 513                 else
 514                         {
 515                         color_set = FALSE;
 516                         }
 517                 row = 0;
 518                 rank = 0;
 519                 }
 520
 521         di = (child) ? child : parent;
 522
 523         if (!child && dw->second_set)
 524                 {
 525                 text[DUPE_COLUMN_RANK] = g_strdup("[1]");
 526                 }
 527         else if (rank == 0)
 528                 {
 529                 text[DUPE_COLUMN_RANK] = g_strdup((di->second) ? "(2)" : "");
 530                 }
 531         else
 532                 {
 533                 text[DUPE_COLUMN_RANK] = g_strdup_printf("%d%s", rank, (di->second) ? " (2)" : "");
 534                 }
 535
 536         text[DUPE_COLUMN_THUMB] = "";
 537         text[DUPE_COLUMN_NAME] = (gchar *)di->fd->name;
 538         text[DUPE_COLUMN_SIZE] = text_from_size(di->fd->size);
 539         text[DUPE_COLUMN_DATE] = (gchar *)text_from_time(di->fd->date);
 540         if (di->width > 0 && di->height > 0)
 541                 {
 542                 text[DUPE_COLUMN_DIMENSIONS] = g_strdup_printf("%d x %d", di->width, di->height);
 543                 }
 544         else
 545                 {
 546                 text[DUPE_COLUMN_DIMENSIONS] = g_strdup("");
 547                 }
 548         text[DUPE_COLUMN_PATH] = di->fd->path;
 549         text[DUPE_COLUMN_COLOR] = NULL;
 550
 551         gtk_list_store_insert(store, &iter, row);
 552         gtk_list_store_set(store, &iter,
 553                                 DUPE_COLUMN_POINTER, di,
 554                                 DUPE_COLUMN_RANK, text[DUPE_COLUMN_RANK],
 555                                 DUPE_COLUMN_THUMB, NULL,
 556                                 DUPE_COLUMN_NAME, text[DUPE_COLUMN_NAME],
 557                                 DUPE_COLUMN_SIZE, text[DUPE_COLUMN_SIZE],
 558                                 DUPE_COLUMN_DATE, text[DUPE_COLUMN_DATE],
 559                                 DUPE_COLUMN_DIMENSIONS, text[DUPE_COLUMN_DIMENSIONS],
 560                                 DUPE_COLUMN_PATH, text[DUPE_COLUMN_PATH],
 561                                 DUPE_COLUMN_COLOR, color_set,
 562                                 -1);
 563
 564         g_free(text[DUPE_COLUMN_RANK]);
 565         g_free(text[DUPE_COLUMN_SIZE]);
 566         g_free(text[DUPE_COLUMN_DIMENSIONS]);
 567 }
 568
 569 static void dupe_listview_populate(DupeWindow *dw)
 570 {
 571         GtkListStore *store;
 572         GList *work;
 573
 574         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
 575         gtk_list_store_clear(store);
 576
 577         work = g_list_last(dw->dupes);
 578         while (work)
 579                 {
 580                 DupeItem *parent = work->data;
 581                 GList *temp;
 582
 583                 dupe_listview_add(dw, parent, NULL);
 584
 585                 temp = g_list_last(parent->group);
 586                 while (temp)
 587                         {
 588                         DupeMatch *dm = temp->data;
 589                         DupeItem *child;
 590
 591                         child = dm->di;
 592
 593                         dupe_listview_add(dw, parent, child);
 594
 595                         temp = temp->prev;
 596                         }
 597
 598                 work = work->prev;
 599                 }
 600
 601         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dw->listview));
 602 }
 603
 604 static void dupe_listview_remove(DupeWindow *dw, DupeItem *di)
 605 {
 606         GtkListStore *store;
 607         GtkTreeIter iter;
 608         gint row;
 609
 610         if (!di) return;
 611
 612         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
 613         row = dupe_listview_find_item(store, di, &iter);
 614         if (row < 0) return;
 615
 616         tree_view_move_cursor_away(GTK_TREE_VIEW(dw->listview), &iter, TRUE);
 617         gtk_list_store_remove(store, &iter);
 618
 619         if (g_list_find(dw->dupes, di) != NULL)
 620                 {
 621                 if (!dw->color_frozen) dupe_listview_realign_colors(dw);
 622                 }
 623 }
 624
 625
 626 static GList *dupe_listview_get_filelist(DupeWindow *dw, GtkWidget *listview)
 627 {
 628         GtkTreeModel *store;
 629         GtkTreeIter iter;
 630         gboolean valid;
 631         GList *list = NULL;
 632
 633         store = gtk_tree_view_get_model(GTK_TREE_VIEW(listview));
 634         valid = gtk_tree_model_get_iter_first(store, &iter);
 635         while (valid)
 636                 {
 637                 DupeItem *di;
 638                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
 639                 list = g_list_prepend(list, file_data_ref(di->fd));
 640
 641                 valid = gtk_tree_model_iter_next(store, &iter);
 642                 }
 643
 644         return g_list_reverse(list);
 645 }
 646
 647
 648 static GList *dupe_listview_get_selection(DupeWindow *dw, GtkWidget *listview)
 649 {
 650         GtkTreeModel *store;
 651         GtkTreeSelection *selection;
 652         GList *slist;
 653         GList *list = NULL;
 654         GList *work;
 655
 656         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
 657         slist = gtk_tree_selection_get_selected_rows(selection, &store);
 658         work = slist;
 659         while (work)
 660                 {
 661                 GtkTreePath *tpath = work->data;
 662                 DupeItem *di = NULL;
 663                 GtkTreeIter iter;
 664
 665                 gtk_tree_model_get_iter(store, &iter, tpath);
 666                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
 667                 if (di)
 668                         {
 669                         list = g_list_prepend(list, file_data_ref(di->fd));
 670                         }
 671                 work = work->next;
 672                 }
 673         g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
 674         g_list_free(slist);
 675
 676         return g_list_reverse(list);
 677 }
 678
 679 static gboolean dupe_listview_item_is_selected(DupeWindow *dw, DupeItem *di, GtkWidget *listview)
 680 {
 681         GtkTreeModel *store;
 682         GtkTreeSelection *selection;
 683         GList *slist;
 684         GList *work;
 685         gboolean found = FALSE;
 686
 687         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
 688         slist = gtk_tree_selection_get_selected_rows(selection, &store);
 689         work = slist;
 690         while (!found && work)
 691                 {
 692                 GtkTreePath *tpath = work->data;
 693                 DupeItem *di_n;
 694                 GtkTreeIter iter;
 695
 696                 gtk_tree_model_get_iter(store, &iter, tpath);
 697                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di_n, -1);
 698                 if (di_n == di) found = TRUE;
 699                 work = work->next;
 700                 }
 701         g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
 702         g_list_free(slist);
 703
 704         return found;
 705 }
 706
 707 static void dupe_listview_select_dupes(DupeWindow *dw, gint parents)
 708 {
 709         GtkTreeModel *store;
 710         GtkTreeSelection *selection;
 711         GtkTreeIter iter;
 712         gboolean valid;
 713
 714         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
 715         gtk_tree_selection_unselect_all(selection);
 716
 717         store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
 718         valid = gtk_tree_model_get_iter_first(store, &iter);
 719         while (valid)
 720                 {
 721                 DupeItem *di;
 722
 723                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
 724                 if ( (dupe_match_find_parent(dw, di) == di) == (parents) )
 725                         {
 726                         gtk_tree_selection_select_iter(selection, &iter);
 727                         }
 728                 valid = gtk_tree_model_iter_next(store, &iter);
 729                 }
 730 }
 731
 732 /*
 733  * ------------------------------------------------------------------
 734  * Match group manipulation
 735  * ------------------------------------------------------------------
 736  */
 737
 738 static DupeMatch *dupe_match_find_match(DupeItem *child, DupeItem *parent)
 739 {
 740         GList *work;
 741
 742         work = parent->group;
 743         while (work)
 744                 {
 745                 DupeMatch *dm = work->data;
 746                 if (dm->di == child) return dm;
 747                 work = work->next;
 748                 }
 749         return NULL;
 750 }
 751
 752 static void dupe_match_link_child(DupeItem *child, DupeItem *parent, gdouble rank)
 753 {
 754         DupeMatch *dm;
 755
 756         dm = g_new0(DupeMatch, 1);
 757         dm->di = child;
 758         dm->rank = rank;
 759         parent->group = g_list_append(parent->group, dm);
 760 }
 761
 762 static void dupe_match_link(DupeItem *a, DupeItem *b, gdouble rank)
 763 {
 764         dupe_match_link_child(a, b, rank);
 765         dupe_match_link_child(b, a, rank);
 766 }
 767
 768 static void dupe_match_unlink_child(DupeItem *child, DupeItem *parent)
 769 {
 770         DupeMatch *dm;
 771
 772         dm = dupe_match_find_match(child, parent);
 773         if (dm)
 774                 {
 775                 parent->group = g_list_remove(parent->group, dm);
 776                 g_free(dm);
 777                 }
 778 }
 779
 780 static void dupe_match_unlink(DupeItem *a, DupeItem *b)
 781 {
 782         dupe_match_unlink_child(a, b);
 783         dupe_match_unlink_child(b, a);
 784 }
 785
 786 static void dupe_match_link_clear(DupeItem *parent, gboolean unlink_children)
 787 {
 788         GList *work;
 789
 790         work = parent->group;
 791         while (work)
 792                 {
 793                 DupeMatch *dm = work->data;
 794                 work = work->next;
 795
 796                 if (unlink_children) dupe_match_unlink_child(parent, dm->di);
 797
 798                 g_free(dm);
 799                 }
 800
 801         g_list_free(parent->group);
 802         parent->group = NULL;
 803         parent->group_rank = 0.0;
 804 }
 805
 806 static gint dupe_match_link_exists(DupeItem *child, DupeItem *parent)
 807 {
 808         return (dupe_match_find_match(child, parent) != NULL);
 809 }
 810
 811 static gdouble dupe_match_link_rank(DupeItem *child, DupeItem *parent)
 812 {
 813         DupeMatch *dm;
 814
 815         dm = dupe_match_find_match(child, parent);
 816         if (dm) return dm->rank;
 817
 818         return 0.0;
 819 }
 820
 821 static DupeItem *dupe_match_highest_rank(DupeItem *child)
 822 {
 823         DupeMatch *dr;
 824         GList *work;
 825
 826         dr = NULL;
 827         work = child->group;
 828         while (work)
 829                 {
 830                 DupeMatch *dm = work->data;
 831                 if (!dr || dm->rank > dr->rank) dr = dm;
 832                 work = work->next;
 833                 }
 834
 835         return (dr) ? dr->di : NULL;
 836 }
 837
 838 static void dupe_match_rank_update(DupeItem *parent)
 839 {
 840         GList *work;
 841         gdouble rank = 0.0;
 842         gint c = 0;
 843
 844         work = parent->group;
 845         while (work)
 846                 {
 847                 DupeMatch *dm = work->data;
 848                 work = work->next;
 849                 rank += dm->rank;
 850                 c++;
 851                 }
 852
 853         if (c > 0)
 854                 {
 855                 parent->group_rank = rank / c;
 856                 }
 857         else
 858                 {
 859                 parent->group_rank = 0.0;
 860                 }
 861 }
 862
 863 static DupeItem *dupe_match_find_parent(DupeWindow *dw, DupeItem *child)
 864 {
 865         GList *work;
 866
 867         if (g_list_find(dw->dupes, child)) return child;
 868
 869         work = child->group;
 870         while (work)
 871                 {
 872                 DupeMatch *dm = work->data;
 873                 if (g_list_find(dw->dupes, dm->di)) return dm->di;
 874                 work = work->next;
 875                 }
 876
 877         return NULL;
 878 }
 879
 880 static void dupe_match_reset_list(GList *work)
 881 {
 882         while (work)
 883                 {
 884                 DupeItem *di = work->data;
 885                 work = work->next;
 886
 887                 dupe_match_link_clear(di, FALSE);
 888                 }
 889 }
 890
 891 static void dupe_match_reparent(DupeWindow *dw, DupeItem *old, DupeItem *new)
 892 {
 893         GList *work;
 894
 895         if (!old || !new || !dupe_match_link_exists(old, new)) return;
 896
 897         dupe_match_link_clear(new, TRUE);
 898         work = old->group;
 899         while (work)
 900                 {
 901                 DupeMatch *dm = work->data;
 902                 dupe_match_unlink_child(old, dm->di);
 903                 dupe_match_link_child(new, dm->di, dm->rank);
 904                 work = work->next;
 905                 }
 906
 907         new->group = old->group;
 908         old->group = NULL;
 909
 910         work = g_list_find(dw->dupes, old);
 911         if (work) work->data = new;
 912 }
 913
 914 static void dupe_match_print_group(DupeItem *di)
 915 {
 916         GList *work;
 917
 918         log_printf("+ %f %s\n", di->group_rank, di->fd->name);
 919
 920         work = di->group;
 921         while (work)
 922                 {
 923                 DupeMatch *dm = work->data;
 924                 work = work->next;
 925
 926                 log_printf("  %f %s\n", dm->rank, dm->di->fd->name);
 927                 }
 928
 929         log_printf("\n");
 930 }
 931
 932 static void dupe_match_print_list(GList *list)
 933 {
 934         GList *work;
 935
 936         work = list;
 937         while (work)
 938                 {
 939                 DupeItem *di = work->data;
 940                 dupe_match_print_group(di);
 941                 work = work->next;
 942                 }
 943 }
 944
 945 /* level 3, unlinking and orphan handling */
 946 static GList *dupe_match_unlink_by_rank(DupeItem *child, DupeItem *parent, GList *list, DupeWindow *dw)
 947 {
 948         DupeItem *best;
 949
 950         best = dupe_match_highest_rank(parent);
 951         if (best == child || dupe_match_highest_rank(child) == parent)
 952                 {
 953                 GList *work;
 954                 gdouble rank;
 955
 956                 DEBUG_2("link found %s to %s [%d]", child->fd->name, parent->fd->name, g_list_length(parent->group));
 957
 958                 work = parent->group;
 959                 while (work)
 960                         {
 961                         DupeMatch *dm = work->data;
 962                         DupeItem *orphan;
 963
 964                         work = work->next;
 965                         orphan = dm->di;
 966                         if (orphan != child && g_list_length(orphan->group) < 2)
 967                                 {
 968                                 dupe_match_link_clear(orphan, TRUE);
 969                                 if (!dw->second_set || orphan->second)
 970                                         {
 971                                         dupe_match(orphan, child, dw->match_mask, &rank, FALSE);
 972                                         dupe_match_link(orphan, child, rank);
 973                                         }
 974                                 list = g_list_remove(list, orphan);
 975                                 }
 976                         }
 977
 978                 rank = dupe_match_link_rank(child, parent);
 979                 dupe_match_link_clear(parent, TRUE);
 980                 dupe_match_link(child, parent, rank);
 981                 list = g_list_remove(list, parent);
 982                 }
 983         else
 984                 {
 985                 DEBUG_2("unlinking %s and %s", child->fd->name, parent->fd->name);
 986
 987                 dupe_match_unlink(child, parent);
 988                 }
 989
 990         return list;
 991 }
 992
 993 /* level 2 */
 994 static GList *dupe_match_group_filter(GList *list, DupeItem *di, DupeWindow *dw)
 995 {
 996         GList *work;
 997
 998         work = g_list_last(di->group);
 999         while (work)
1000                 {
1001                 DupeMatch *dm = work->data;
1002                 work = work->prev;
1003                 list = dupe_match_unlink_by_rank(di, dm->di, list, dw);
1004                 }
1005
1006         return list;
1007 }
1008
1009 /* level 1 (top) */
1010 static GList *dupe_match_group_trim(GList *list, DupeWindow *dw)
1011 {
1012         GList *work;
1013
1014         work = list;
1015         while (work)
1016                 {
1017                 DupeItem *di = work->data;
1018                 if (!di->second) list = dupe_match_group_filter(list, di, dw);
1019                 work = work->next;
1020                 if (di->second) list = g_list_remove(list, di);
1021                 }
1022
1023         return list;
1024 }
1025
1026 static gint dupe_match_sort_groups_cb(gconstpointer a, gconstpointer b)
1027 {
1028         DupeMatch *da = (DupeMatch *)a;
1029         DupeMatch *db = (DupeMatch *)b;
1030
1031         if (da->rank > db->rank) return -1;
1032         if (da->rank < db->rank) return 1;
1033         return 0;
1034 }
1035
1036 static void dupe_match_sort_groups(GList *list)
1037 {
1038         GList *work;
1039
1040         work = list;
1041         while (work)
1042                 {
1043                 DupeItem *di = work->data;
1044                 di->group = g_list_sort(di->group, dupe_match_sort_groups_cb);
1045                 work = work->next;
1046                 }
1047 }
1048
1049 static gint dupe_match_rank_sort_cb(gconstpointer a, gconstpointer b)
1050 {
1051         DupeItem *da = (DupeItem *)a;
1052         DupeItem *db = (DupeItem *)b;
1053
1054         if (da->group_rank > db->group_rank) return -1;
1055         if (da->group_rank < db->group_rank) return 1;
1056         return 0;
1057 }
1058
1059 /* returns allocated GList of dupes sorted by rank */
1060 static GList *dupe_match_rank_sort(GList *source_list)
1061 {
1062         GList *list = NULL;
1063         GList *work;
1064
1065         work = source_list;
1066         while (work)
1067                 {
1068                 DupeItem *di = work->data;
1069
1070                 if (di->group)
1071                         {
1072                         dupe_match_rank_update(di);
1073                         list = g_list_prepend(list, di);
1074                         }
1075
1076                 work = work->next;
1077                 }
1078
1079         return g_list_sort(list, dupe_match_rank_sort_cb);
1080 }
1081
1082 static void dupe_match_rank(DupeWindow *dw)
1083 {
1084         GList *list;
1085
1086         list = dupe_match_rank_sort(dw->list);
1087
1088         if (required_debug_level(2)) dupe_match_print_list(list);
1089
1090         DEBUG_1("Similar items: %d", g_list_length(list));
1091         list = dupe_match_group_trim(list, dw);
1092         DEBUG_1("Unique groups: %d", g_list_length(list));
1093
1094         dupe_match_sort_groups(list);
1095
1096         if (required_debug_level(2)) dupe_match_print_list(list);
1097
1098         list = dupe_match_rank_sort(list);
1099
1100         g_list_free(dw->dupes);
1101         dw->dupes = list;
1102 }
1103
1104 /*
1105  * ------------------------------------------------------------------
1106  * Match group tests
1107  * ------------------------------------------------------------------
1108  */
1109
1110 static gboolean dupe_match(DupeItem *a, DupeItem *b, DupeMatchType mask, gdouble *rank, gint fast)
1111 {
1112         *rank = 0.0;
1113
1114         if (a->fd->path == b->fd->path) return FALSE;
1115
1116         if (mask & DUPE_MATCH_PATH)
1117                 {
1118                 if (utf8_compare(a->fd->path, b->fd->path, TRUE) != 0) return FALSE;
1119                 }
1120         if (mask & DUPE_MATCH_NAME)
1121                 {
1122                 if (strcmp(a->fd->collate_key_name, b->fd->collate_key_name) != 0) return FALSE;
1123                 }
1124         if (mask & DUPE_MATCH_NAME_CI)
1125                 {
1126                 if (strcmp(a->fd->collate_key_name_nocase, b->fd->collate_key_name_nocase) != 0) return FALSE;
1127                 }
1128         if (mask & DUPE_MATCH_SIZE)
1129                 {
1130                 if (a->fd->size != b->fd->size) return FALSE;
1131                 }
1132         if (mask & DUPE_MATCH_DATE)
1133                 {
1134                 if (a->fd->date != b->fd->date) return FALSE;
1135                 }
1136         if (mask & DUPE_MATCH_SUM)
1137                 {
1138                 if (!a->md5sum) a->md5sum = md5_text_from_file_utf8(a->fd->path, "");
1139                 if (!b->md5sum) b->md5sum = md5_text_from_file_utf8(b->fd->path, "");
1140                 if (a->md5sum[0] == '\0' ||
1141                     b->md5sum[0] == '\0' ||
1142                     strcmp(a->md5sum, b->md5sum) != 0) return FALSE;
1143                 }
1144         if (mask & DUPE_MATCH_DIM)
1145                 {
1146                 if (a->width == 0) image_load_dimensions(a->fd, &a->width, &a->height);
1147                 if (b->width == 0) image_load_dimensions(b->fd, &b->width, &b->height);
1148                 if (a->width != b->width || a->height != b->height) return FALSE;
1149                 }
1150         if (mask & DUPE_MATCH_SIM_HIGH ||
1151             mask & DUPE_MATCH_SIM_MED ||
1152             mask & DUPE_MATCH_SIM_LOW ||
1153             mask & DUPE_MATCH_SIM_CUSTOM)
1154                 {
1155                 gdouble f;
1156                 gdouble m;
1157
1158                 if (mask & DUPE_MATCH_SIM_HIGH) m = 0.95;
1159                 else if (mask & DUPE_MATCH_SIM_MED) m = 0.90;
1160                 else if (mask & DUPE_MATCH_SIM_CUSTOM) m = (gdouble)options->duplicates_similarity_threshold / 100.0;
1161                 else m = 0.85;
1162
1163                 if (fast)
1164                         {
1165                         f = image_sim_compare_fast(a->simd, b->simd, m);
1166                         }
1167                 else
1168                         {
1169                         f = image_sim_compare(a->simd, b->simd);
1170                         }
1171
1172                 *rank = f * 100.0;
1173
1174                 if (f < m) return FALSE;
1175
1176                 DEBUG_3("similar: %32s %32s = %f", a->fd->name, b->fd->name, f);
1177                 }
1178
1179         return TRUE;
1180 }
1181
1182 static void dupe_list_check_match(DupeWindow *dw, DupeItem *needle, GList *start)
1183 {
1184         GList *work;
1185
1186         if (dw->second_set)
1187                 {
1188                 work = dw->second_list;
1189                 }
1190         else if (start)
1191                 {
1192                 work = start;
1193                 }
1194         else
1195                 {
1196                 work = g_list_last(dw->list);
1197                 }
1198
1199         while (work)
1200                 {
1201                 DupeItem *di = work->data;
1202
1203                 /* speed opt: forward for second set, back for simple compare */
1204                 if (dw->second_set)
1205                         work = work->next;
1206                 else
1207                         work = work->prev;
1208
1209                 if (!dupe_match_link_exists(needle, di))
1210                         {
1211                         gdouble rank;
1212
1213                         if (dupe_match(di, needle, dw->match_mask, &rank, TRUE))
1214                                 {
1215                                 dupe_match_link(di, needle, rank);
1216                                 }
1217                         }
1218                 }
1219 }
1220
1221 /*
1222  * ------------------------------------------------------------------
1223  * Thumbnail handling
1224  * ------------------------------------------------------------------
1225  */
1226
1227 static void dupe_listview_set_thumb(DupeWindow *dw, DupeItem *di, GtkTreeIter *iter)
1228 {
1229         GtkListStore *store;
1230         GtkTreeIter iter_n;
1231
1232         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
1233         if (!iter)
1234                 {
1235                 if (dupe_listview_find_item(store, di, &iter_n) >= 0)
1236                         {
1237                         iter = &iter_n;
1238                         }
1239                 }
1240
1241         if (iter) gtk_list_store_set(store, iter, DUPE_COLUMN_THUMB, di->pixbuf, -1);
1242 }
1243
1244 static void dupe_thumb_do(DupeWindow *dw)
1245 {
1246         DupeItem *di;
1247
1248         if (!dw->thumb_loader || !dw->thumb_item) return;
1249         di = dw->thumb_item;
1250
1251         if (di->pixbuf) g_object_unref(di->pixbuf);
1252         di->pixbuf = thumb_loader_get_pixbuf(dw->thumb_loader);
1253
1254         dupe_listview_set_thumb(dw, di, NULL);
1255 }
1256
1257 static void dupe_thumb_error_cb(ThumbLoader *tl, gpointer data)
1258 {
1259         DupeWindow *dw = data;
1260
1261         dupe_thumb_do(dw);
1262         dupe_thumb_step(dw);
1263 }
1264
1265 static void dupe_thumb_done_cb(ThumbLoader *tl, gpointer data)
1266 {
1267         DupeWindow *dw = data;
1268
1269         dupe_thumb_do(dw);
1270         dupe_thumb_step(dw);
1271 }
1272
1273 static void dupe_thumb_step(DupeWindow *dw)
1274 {
1275         GtkTreeModel *store;
1276         GtkTreeIter iter;
1277         DupeItem *di = NULL;
1278         gboolean valid;
1279         gint row = 0;
1280         gint length = 0;
1281
1282         store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
1283         valid = gtk_tree_model_get_iter_first(store, &iter);
1284
1285         while (!di && valid)
1286                 {
1287                 GdkPixbuf *pixbuf;
1288
1289                 length++;
1290                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, DUPE_COLUMN_THUMB, &pixbuf, -1);
1291                 if (pixbuf || di->pixbuf)
1292                         {
1293                         if (!pixbuf) gtk_list_store_set(GTK_LIST_STORE(store), &iter, DUPE_COLUMN_THUMB, di->pixbuf, -1);
1294                         row++;
1295                         di = NULL;
1296                         }
1297                 valid = gtk_tree_model_iter_next(store, &iter);
1298                 }
1299         if (valid)
1300                 {
1301                 while (gtk_tree_model_iter_next(store, &iter)) length++;
1302                 }
1303
1304         if (!di)
1305                 {
1306                 dw->thumb_item = NULL;
1307                 thumb_loader_free(dw->thumb_loader);
1308                 dw->thumb_loader = NULL;
1309
1310                 dupe_window_update_progress(dw, NULL, 0.0, FALSE);
1311                 return;
1312                 }
1313
1314         dupe_window_update_progress(dw, _("Loading thumbs..."),
1315                                     length == 0 ? 0.0 : (gdouble)(row) / length, FALSE);
1316
1317         dw->thumb_item = di;
1318         thumb_loader_free(dw->thumb_loader);
1319         dw->thumb_loader = thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
1320
1321         thumb_loader_set_callbacks(dw->thumb_loader,
1322                                    dupe_thumb_done_cb,
1323                                    dupe_thumb_error_cb,
1324                                    NULL,
1325                                    dw);
1326
1327         /* start it */
1328         if (!thumb_loader_start(dw->thumb_loader, di->fd))
1329                 {
1330                 /* error, handle it, do next */
1331                 DEBUG_1("error loading thumb for %s", di->fd->path);
1332                 dupe_thumb_do(dw);
1333                 dupe_thumb_step(dw);
1334                 }
1335 }
1336
1337 /*
1338  * ------------------------------------------------------------------
1339  * Dupe checking loop
1340  * ------------------------------------------------------------------
1341  */
1342
1343 static void dupe_check_stop(DupeWindow *dw)
1344 {
1345         if (dw->idle_id || dw->img_loader || dw->thumb_loader)
1346                 {
1347                 g_source_remove(dw->idle_id);
1348                 dw->idle_id = 0;
1349                 dupe_window_update_progress(dw, NULL, 0.0, FALSE);
1350                 widget_set_cursor(dw->listview, -1);
1351                 }
1352
1353         thumb_loader_free(dw->thumb_loader);
1354         dw->thumb_loader = NULL;
1355
1356         image_loader_free(dw->img_loader);
1357         dw->img_loader = NULL;
1358 }
1359
1360 static void dupe_loader_done_cb(ImageLoader *il, gpointer data)
1361 {
1362         DupeWindow *dw = data;
1363         GdkPixbuf *pixbuf;
1364
1365         pixbuf = image_loader_get_pixbuf(il);
1366
1367         if (dw->setup_point)
1368                 {
1369                 DupeItem *di = dw->setup_point->data;
1370
1371                 if (!di->simd)
1372                         {
1373                         di->simd = image_sim_new_from_pixbuf(pixbuf);
1374                         }
1375                 else
1376                         {
1377                         image_sim_fill_data(di->simd, pixbuf);
1378                         }
1379
1380                 if (di->width == 0 && di->height == 0)
1381                         {
1382                         di->width = gdk_pixbuf_get_width(pixbuf);
1383                         di->height = gdk_pixbuf_get_height(pixbuf);
1384                         }
1385                 if (options->thumbnails.enable_caching)
1386                         {
1387                         dupe_item_write_cache(di);
1388                         }
1389
1390                 image_sim_alternate_processing(di->simd);
1391                 }
1392
1393         image_loader_free(dw->img_loader);
1394         dw->img_loader = NULL;
1395
1396         dw->idle_id = g_idle_add(dupe_check_cb, dw);
1397 }
1398
1399 static void dupe_setup_reset(DupeWindow *dw)
1400 {
1401         dw->setup_point = NULL;
1402         dw->setup_n = 0;
1403         dw->setup_time = msec_time();
1404         dw->setup_time_count = 0;
1405 }
1406
1407 static GList *dupe_setup_point_step(DupeWindow *dw, GList *p)
1408 {
1409         if (!p) return NULL;
1410
1411         if (p->next) return p->next;
1412
1413         if (dw->second_set && g_list_first(p) == dw->list) return dw->second_list;
1414
1415         return NULL;
1416 }
1417
1418 static gboolean dupe_check_cb(gpointer data)
1419 {
1420         DupeWindow *dw = data;
1421
1422         if (!dw->idle_id) return FALSE;
1423
1424         if (!dw->setup_done)
1425                 {
1426                 if ((dw->match_mask & DUPE_MATCH_SUM) &&
1427                     !(dw->setup_mask & DUPE_MATCH_SUM) )
1428                         {
1429                         if (!dw->setup_point) dw->setup_point = dw->list;
1430
1431                         while (dw->setup_point)
1432                                 {
1433                                 DupeItem *di = dw->setup_point->data;
1434
1435                                 dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
1436                                 dw->setup_n++;
1437
1438                                 if (!di->md5sum)
1439                                         {
1440                                         dupe_window_update_progress(dw, _("Reading checksums..."),
1441                                                 dw->setup_count == 0 ? 0.0 : (gdouble)(dw->setup_n - 1) / dw->setup_count, FALSE);
1442
1443                                         if (options->thumbnails.enable_caching)
1444                                                 {
1445                                                 dupe_item_read_cache(di);
1446                                                 if (di->md5sum) return TRUE;
1447                                                 }
1448
1449                                         di->md5sum = md5_text_from_file_utf8(di->fd->path, "");
1450                                         if (options->thumbnails.enable_caching)
1451                                                 {
1452                                                 dupe_item_write_cache(di);
1453                                                 }
1454                                         return TRUE;
1455                                         }
1456                                 }
1457                         dw->setup_mask |= DUPE_MATCH_SUM;
1458                         dupe_setup_reset(dw);
1459                         }
1460                 if ((dw->match_mask & DUPE_MATCH_DIM) &&
1461                     !(dw->setup_mask & DUPE_MATCH_DIM) )
1462                         {
1463                         if (!dw->setup_point) dw->setup_point = dw->list;
1464
1465                         while (dw->setup_point)
1466                                 {
1467                                 DupeItem *di = dw->setup_point->data;
1468
1469                                 dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
1470                                 dw->setup_n++;
1471                                 if (di->width == 0 && di->height == 0)
1472                                         {
1473                                         dupe_window_update_progress(dw, _("Reading dimensions..."),
1474                                                 dw->setup_count == 0 ? 0.0 : (gdouble)(dw->setup_n - 1) / dw->setup_count, FALSE);
1475
1476                                         if (options->thumbnails.enable_caching)
1477                                                 {
1478                                                 dupe_item_read_cache(di);
1479                                                 if (di->width != 0 || di->height != 0) return TRUE;
1480                                                 }
1481
1482                                         image_load_dimensions(di->fd, &di->width, &di->height);
1483                                         if (options->thumbnails.enable_caching)
1484                                                 {
1485                                                 dupe_item_write_cache(di);
1486                                                 }
1487                                         return TRUE;
1488                                         }
1489                                 }
1490                         dw->setup_mask |= DUPE_MATCH_DIM;
1491                         dupe_setup_reset(dw);
1492                         }
1493                 if ((dw->match_mask & DUPE_MATCH_SIM_HIGH ||
1494                      dw->match_mask & DUPE_MATCH_SIM_MED ||
1495                      dw->match_mask & DUPE_MATCH_SIM_LOW ||
1496                      dw->match_mask & DUPE_MATCH_SIM_CUSTOM) &&
1497                     !(dw->setup_mask & DUPE_MATCH_SIM_MED) )
1498                         {
1499                         if (!dw->setup_point) dw->setup_point = dw->list;
1500
1501                         while (dw->setup_point)
1502                                 {
1503                                 DupeItem *di = dw->setup_point->data;
1504
1505                                 if (!di->simd)
1506                                         {
1507                                         dupe_window_update_progress(dw, _("Reading similarity data..."),
1508                                                 dw->setup_count == 0 ? 0.0 : (gdouble)dw->setup_n / dw->setup_count, FALSE);
1509
1510                                         if (options->thumbnails.enable_caching)
1511                                                 {
1512                                                 dupe_item_read_cache(di);
1513                                                 if (cache_sim_data_filled(di->simd))
1514                                                         {
1515                                                         image_sim_alternate_processing(di->simd);
1516                                                         return TRUE;
1517                                                         }
1518                                                 }
1519
1520                                         dw->img_loader = image_loader_new(di->fd);
1521                                         image_loader_set_buffer_size(dw->img_loader, 8);
1522                                         g_signal_connect(G_OBJECT(dw->img_loader), "error", (GCallback)dupe_loader_done_cb, dw);
1523                                         g_signal_connect(G_OBJECT(dw->img_loader), "done", (GCallback)dupe_loader_done_cb, dw);
1524
1525                                         if (!image_loader_start(dw->img_loader))
1526                                                 {
1527                                                 image_sim_free(di->simd);
1528                                                 di->simd = image_sim_new();
1529                                                 image_loader_free(dw->img_loader);
1530                                                 dw->img_loader = NULL;
1531                                                 return TRUE;
1532                                                 }
1533                                         dw->idle_id = 0;
1534                                         return FALSE;
1535                                         }
1536
1537                                 dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
1538                                 dw->setup_n++;
1539                                 }
1540                         dw->setup_mask |= DUPE_MATCH_SIM_MED;
1541                         dupe_setup_reset(dw);
1542                         }
1543                 dupe_window_update_progress(dw, _("Comparing..."), 0.0, FALSE);
1544                 dw->setup_done = TRUE;
1545                 dupe_setup_reset(dw);
1546                 dw->setup_count = g_list_length(dw->list);
1547                 }
1548
1549         if (!dw->working)
1550                 {
1551                 if (dw->setup_count > 0)
1552                         {
1553                         dw->setup_count = 0;
1554                         dupe_window_update_progress(dw, _("Sorting..."), 1.0, TRUE);
1555                         return TRUE;
1556                         }
1557                 dw->idle_id = 0;
1558                 dupe_window_update_progress(dw, NULL, 0.0, FALSE);
1559
1560                 dupe_match_rank(dw);
1561                 dupe_window_update_count(dw, FALSE);
1562
1563                 dupe_listview_populate(dw);
1564
1565                 /* check thumbs */
1566                 if (dw->show_thumbs) dupe_thumb_step(dw);
1567
1568                 widget_set_cursor(dw->listview, -1);
1569
1570                 return FALSE;
1571                 }
1572
1573         dupe_list_check_match(dw, (DupeItem *)dw->working->data, dw->working);
1574         dupe_window_update_progress(dw, _("Comparing..."), dw->setup_count == 0 ? 0.0 : (gdouble) dw->setup_n / dw->setup_count, FALSE);
1575         dw->setup_n++;
1576
1577         dw->working = dw->working->prev;
1578
1579         return TRUE;
1580 }
1581
1582 static void dupe_check_start(DupeWindow *dw)
1583 {
1584         dw->setup_done = FALSE;
1585
1586         dw->setup_count = g_list_length(dw->list);
1587         if (dw->second_set) dw->setup_count += g_list_length(dw->second_list);
1588
1589         dw->setup_mask = 0;
1590         dupe_setup_reset(dw);
1591
1592         dw->working = g_list_last(dw->list);
1593
1594         dupe_window_update_count(dw, TRUE);
1595         widget_set_cursor(dw->listview, GDK_WATCH);
1596
1597         if (dw->idle_id) return;
1598
1599         dw->idle_id = g_idle_add(dupe_check_cb, dw);
1600 }
1601
1602 /*
1603  * ------------------------------------------------------------------
1604  * Item addition, removal
1605  * ------------------------------------------------------------------
1606  */
1607
1608 static void dupe_item_remove(DupeWindow *dw, DupeItem *di)
1609 {
1610         if (!di) return;
1611
1612         /* handle things that may be in progress... */
1613         if (dw->working && dw->working->data == di)
1614                 {
1615                 dw->working = dw->working->prev;
1616                 }
1617         if (dw->thumb_loader && dw->thumb_item == di)
1618                 {
1619                 dupe_thumb_step(dw);
1620                 }
1621         if (dw->setup_point && dw->setup_point->data == di)
1622                 {
1623                 dw->setup_point = dupe_setup_point_step(dw, dw->setup_point);
1624                 if (dw->img_loader)
1625                         {
1626                         image_loader_free(dw->img_loader);
1627                         dw->img_loader = NULL;
1628                         dw->idle_id = g_idle_add(dupe_check_cb, dw);
1629                         }
1630                 }
1631
1632         if (di->group && dw->dupes)
1633                 {
1634                 /* is a dupe, must remove from group/reset children if a parent */
1635                 DupeItem *parent;
1636
1637                 parent = dupe_match_find_parent(dw, di);
1638                 if (di == parent)
1639                         {
1640                         if (g_list_length(parent->group) < 2)
1641                                 {
1642                                 DupeItem *child;
1643
1644                                 child = dupe_match_highest_rank(parent);
1645                                 dupe_match_link_clear(child, TRUE);
1646                                 dupe_listview_remove(dw, child);
1647
1648                                 dupe_match_link_clear(parent, TRUE);
1649                                 dupe_listview_remove(dw, parent);
1650                                 dw->dupes = g_list_remove(dw->dupes, parent);
1651                                 }
1652                         else
1653                                 {
1654                                 DupeItem *new_parent;
1655                                 DupeMatch *dm;
1656
1657                                 dm = parent->group->data;
1658                                 new_parent = dm->di;
1659                                 dupe_match_reparent(dw, parent, new_parent);
1660                                 dupe_listview_remove(dw, parent);
1661                                 }
1662                         }
1663                 else
1664                         {
1665                         if (g_list_length(parent->group) < 2)
1666                                 {
1667                                 dupe_match_link_clear(parent, TRUE);
1668                                 dupe_listview_remove(dw, parent);
1669                                 dw->dupes = g_list_remove(dw->dupes, parent);
1670                                 }
1671                         dupe_match_link_clear(di, TRUE);
1672                         dupe_listview_remove(dw, di);
1673                         }
1674                 }
1675         else
1676                 {
1677                 /* not a dupe, or not sorted yet, simply reset */
1678                 dupe_match_link_clear(di, TRUE);
1679                 }
1680
1681         if (dw->second_list && g_list_find(dw->second_list, di))
1682                 {
1683                 dupe_second_remove(dw, di);
1684                 }
1685         else
1686                 {
1687                 dw->list = g_list_remove(dw->list, di);
1688                 }
1689         dupe_item_free(di);
1690
1691         dupe_window_update_count(dw, FALSE);
1692 }
1693
1694 static gboolean dupe_item_remove_by_path(DupeWindow *dw, const gchar *path)
1695 {
1696         DupeItem *di;
1697
1698         di = dupe_item_find_path(dw, path);
1699         if (!di) return FALSE;
1700
1701         dupe_item_remove(dw, di);
1702
1703         return TRUE;
1704 }
1705
1706 static void dupe_files_add(DupeWindow *dw, CollectionData *collection, CollectInfo *info,
1707                            FileData *fd, gboolean recurse)
1708 {
1709         DupeItem *di = NULL;
1710
1711         if (info)
1712                 {
1713                 di = dupe_item_new(info->fd);
1714                 }
1715         else if (fd)
1716                 {
1717                 if (isfile(fd->path))
1718                         {
1719                         di = dupe_item_new(fd);
1720                         }
1721                 else if (isdir(fd->path) && recurse)
1722                         {
1723                         GList *f, *d;
1724                         if (filelist_read(fd, &f, &d))
1725                                 {
1726                                 GList *work;
1727
1728                                 f = filelist_filter(f, FALSE);
1729                                 d = filelist_filter(d, TRUE);
1730
1731                                 work = f;
1732                                 while (work)
1733                                         {
1734                                         dupe_files_add(dw, NULL, NULL, (FileData *)work->data, TRUE);
1735                                         work = work->next;
1736                                         }
1737                                 filelist_free(f);
1738                                 work = d;
1739                                 while (work)
1740                                         {
1741                                         dupe_files_add(dw, NULL, NULL, (FileData *)work->data, TRUE);
1742                                         work = work->next;
1743                                         }
1744                                 filelist_free(d);
1745                                 }
1746                         }
1747                 }
1748
1749         if (!di) return;
1750
1751         if (dw->second_drop)
1752                 {
1753                 dupe_second_add(dw, di);
1754                 }
1755         else
1756                 {
1757                 dw->list = g_list_prepend(dw->list, di);
1758                 }
1759 }
1760
1761 void dupe_window_add_collection(DupeWindow *dw, CollectionData *collection)
1762 {
1763         CollectInfo *info;
1764
1765         info = collection_get_first(collection);
1766         while (info)
1767                 {
1768                 dupe_files_add(dw, collection, info, NULL, FALSE);
1769                 info = collection_next_by_info(collection, info);
1770                 }
1771
1772         dupe_check_start(dw);
1773 }
1774
1775 void dupe_window_add_files(DupeWindow *dw, GList *list, gboolean recurse)
1776 {
1777         GList *work;
1778
1779         work = list;
1780         while (work)
1781                 {
1782                 FileData *fd = work->data;
1783                 work = work->next;
1784
1785                 dupe_files_add(dw, NULL, NULL, fd, recurse);
1786                 }
1787
1788         dupe_check_start(dw);
1789 }
1790
1791 static void dupe_item_update(DupeWindow *dw, DupeItem *di)
1792 {
1793         if ( (dw->match_mask & DUPE_MATCH_NAME) || (dw->match_mask & DUPE_MATCH_PATH || (dw->match_mask & DUPE_MATCH_NAME_CI)) )
1794                 {
1795                 /* only effects matches on name or path */
1796 /*
1797                 FileData *fd = file_data_ref(di->fd);
1798                 gint second;
1799
1800                 second = di->second;
1801                 dupe_item_remove(dw, di);
1802
1803                 dw->second_drop = second;
1804                 dupe_files_add(dw, NULL, NULL, fd, FALSE);
1805                 dw->second_drop = FALSE;
1806
1807                 file_data_unref(fd);
1808 */
1809                 dupe_check_start(dw);
1810                 }
1811         else
1812                 {
1813                 GtkListStore *store;
1814                 GtkTreeIter iter;
1815                 gint row;
1816                 /* update the listview(s) */
1817
1818                 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
1819                 row = dupe_listview_find_item(store, di, &iter);
1820                 if (row >= 0)
1821                         {
1822                         gtk_list_store_set(store, &iter,
1823                                            DUPE_COLUMN_NAME, di->fd->name,
1824                                            DUPE_COLUMN_PATH, di->fd->path, -1);
1825                         }
1826
1827                 if (dw->second_listview)
1828                         {
1829                         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
1830                         row = dupe_listview_find_item(store, di, &iter);
1831                         if (row >= 0)
1832                                 {
1833                                 gtk_list_store_set(store, &iter, 1, di->fd->path, -1);
1834                                 }
1835                         }
1836                 }
1837
1838 }
1839
1840 static void dupe_item_update_fd_in_list(DupeWindow *dw, FileData *fd, GList *work)
1841 {
1842         while (work)
1843                 {
1844                 DupeItem *di = work->data;
1845
1846                 if (di->fd == fd)
1847                         dupe_item_update(dw, di);
1848
1849                 work = work->next;
1850                 }
1851 }
1852
1853 static void dupe_item_update_fd(DupeWindow *dw, FileData *fd)
1854 {
1855         dupe_item_update_fd_in_list(dw, fd, dw->list);
1856         if (dw->second_set) dupe_item_update_fd_in_list(dw, fd, dw->second_list);
1857 }
1858
1859
1860 /*
1861  * ------------------------------------------------------------------
1862  * Misc.
1863  * ------------------------------------------------------------------
1864  */
1865
1866 static GtkWidget *dupe_display_label(GtkWidget *vbox, const gchar *description, const gchar *text)
1867 {
1868         GtkWidget *hbox;
1869         GtkWidget *label;
1870
1871         hbox = gtk_hbox_new(FALSE, 10);
1872
1873         label = gtk_label_new(description);
1874         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
1875         gtk_widget_show(label);
1876
1877         label = gtk_label_new(text);
1878         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
1879         gtk_widget_show(label);
1880
1881         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1882         gtk_widget_show(hbox);
1883
1884         return label;
1885 }
1886
1887 static void dupe_display_stats(DupeWindow *dw, DupeItem *di)
1888 {
1889         GenericDialog *gd;
1890         gchar *buf;
1891
1892         if (!di) return;
1893
1894         gd = file_util_gen_dlg("Image thumbprint debug info", "thumbprint",
1895                                dw->window, TRUE,
1896                                NULL, NULL);
1897         generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE);
1898
1899         dupe_display_label(gd->vbox, "name:", di->fd->name);
1900         buf = text_from_size(di->fd->size);
1901         dupe_display_label(gd->vbox, "size:", buf);
1902         g_free(buf);
1903         dupe_display_label(gd->vbox, "date:", text_from_time(di->fd->date));
1904         buf = g_strdup_printf("%d x %d", di->width, di->height);
1905         dupe_display_label(gd->vbox, "dimensions:", buf);
1906         g_free(buf);
1907         dupe_display_label(gd->vbox, "md5sum:", (di->md5sum) ? di->md5sum : "not generated");
1908
1909         dupe_display_label(gd->vbox, "thumbprint:", (di->simd) ? "" : "not generated");
1910         if (di->simd)
1911                 {
1912                 GtkWidget *image;
1913                 GdkPixbuf *pixbuf;
1914                 gint x, y;
1915                 guchar *d_pix;
1916                 guchar *dp;
1917                 gint rs;
1918                 gint sp;
1919
1920                 pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, 32, 32);
1921                 rs = gdk_pixbuf_get_rowstride(pixbuf);
1922                 d_pix = gdk_pixbuf_get_pixels(pixbuf);
1923
1924                 for (y = 0; y < 32; y++)
1925                         {
1926                         dp = d_pix + (y * rs);
1927                         sp = y * 32;
1928                         for (x = 0; x < 32; x++)
1929                                 {
1930                                 *(dp++) = di->simd->avg_r[sp + x];
1931                                 *(dp++) = di->simd->avg_g[sp + x];
1932                                 *(dp++) = di->simd->avg_b[sp + x];
1933                                 }
1934                         }
1935
1936                 image = gtk_image_new_from_pixbuf(pixbuf);
1937                 gtk_box_pack_start(GTK_BOX(gd->vbox), image, FALSE, FALSE, 0);
1938                 gtk_widget_show(image);
1939
1940                 g_object_unref(pixbuf);
1941                 }
1942
1943         gtk_widget_show(gd->dialog);
1944 }
1945
1946 static void dupe_window_recompare(DupeWindow *dw)
1947 {
1948         GtkListStore *store;
1949
1950         dupe_check_stop(dw);
1951
1952         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
1953         gtk_list_store_clear(store);
1954
1955         g_list_free(dw->dupes);
1956         dw->dupes = NULL;
1957
1958         dupe_match_reset_list(dw->list);
1959         dupe_match_reset_list(dw->second_list);
1960
1961         dupe_check_start(dw);
1962 }
1963
1964 static void dupe_menu_view(DupeWindow *dw, DupeItem *di, GtkWidget *listview, gint new_window)
1965 {
1966         if (!di) return;
1967
1968         if (di->collection && collection_info_valid(di->collection, di->info))
1969                 {
1970                 if (new_window)
1971                         {
1972                         view_window_new_from_collection(di->collection, di->info);
1973                         }
1974                 else
1975                         {
1976                         layout_image_set_collection(NULL, di->collection, di->info);
1977                         }
1978                 }
1979         else
1980                 {
1981                 if (new_window)
1982                         {
1983                         GList *list;
1984
1985                         list = dupe_listview_get_selection(dw, listview);
1986                         view_window_new_from_list(list);
1987                         filelist_free(list);
1988                         }
1989                 else
1990                         {
1991                         layout_set_fd(NULL, di->fd);
1992                         }
1993                 }
1994 }
1995
1996 static void dupe_window_remove_selection(DupeWindow *dw, GtkWidget *listview)
1997 {
1998         GtkTreeSelection *selection;
1999         GtkTreeModel *store;
2000         GtkTreeIter iter;
2001         GList *slist;
2002         GList *list = NULL;
2003         GList *work;
2004
2005         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
2006         slist = gtk_tree_selection_get_selected_rows(selection, &store);
2007         work = slist;
2008         while (work)
2009                 {
2010                 GtkTreePath *tpath = work->data;
2011                 DupeItem *di = NULL;
2012
2013                 gtk_tree_model_get_iter(store, &iter, tpath);
2014                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
2015                 if (di) list = g_list_prepend(list, di);
2016                 work = work->next;
2017                 }
2018         g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
2019         g_list_free(slist);
2020
2021         dw->color_frozen = TRUE;
2022         work = list;
2023         while (work)
2024                 {
2025                 DupeItem *di;
2026
2027                 di = work->data;
2028                 work = work->next;
2029                 dupe_item_remove(dw, di);
2030                 }
2031         dw->color_frozen = FALSE;
2032
2033         g_list_free(list);
2034
2035         dupe_listview_realign_colors(dw);
2036 }
2037
2038 static void dupe_window_edit_selected(DupeWindow *dw, const gchar *key)
2039 {
2040         file_util_start_editor_from_filelist(key, dupe_listview_get_selection(dw, dw->listview), NULL, dw->window);
2041 }
2042
2043 static void dupe_window_collection_from_selection(DupeWindow *dw)
2044 {
2045         CollectWindow *w;
2046         GList *list;
2047
2048         list = dupe_listview_get_selection(dw, dw->listview);
2049         w = collection_window_new(NULL);
2050         collection_table_add_filelist(w->table, list);
2051         filelist_free(list);
2052 }
2053
2054 static void dupe_window_append_file_list(DupeWindow *dw, gint on_second)
2055 {
2056         GList *list;
2057
2058         dw->second_drop = (dw->second_set && on_second);
2059
2060         list = layout_list(NULL);
2061         dupe_window_add_files(dw, list, FALSE);
2062         filelist_free(list);
2063 }
2064
2065 /*
2066  *-------------------------------------------------------------------
2067  * main pop-up menu callbacks
2068  *-------------------------------------------------------------------
2069  */
2070
2071 static void dupe_menu_view_cb(GtkWidget *widget, gpointer data)
2072 {
2073         DupeWindow *dw = data;
2074
2075         if (dw->click_item) dupe_menu_view(dw, dw->click_item, dw->listview, FALSE);
2076 }
2077
2078 static void dupe_menu_viewnew_cb(GtkWidget *widget, gpointer data)
2079 {
2080         DupeWindow *dw = data;
2081
2082         if (dw->click_item) dupe_menu_view(dw, dw->click_item, dw->listview, TRUE);
2083 }
2084
2085 static void dupe_menu_select_all_cb(GtkWidget *widget, gpointer data)
2086 {
2087         DupeWindow *dw = data;
2088         GtkTreeSelection *selection;
2089
2090         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
2091         gtk_tree_selection_select_all(selection);
2092 }
2093
2094 static void dupe_menu_select_none_cb(GtkWidget *widget, gpointer data)
2095 {
2096         DupeWindow *dw = data;
2097         GtkTreeSelection *selection;
2098
2099         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
2100         gtk_tree_selection_unselect_all(selection);
2101 }
2102
2103 static void dupe_menu_select_dupes_set1_cb(GtkWidget *widget, gpointer data)
2104 {
2105         DupeWindow *dw = data;
2106
2107         dupe_listview_select_dupes(dw, TRUE);
2108 }
2109
2110 static void dupe_menu_select_dupes_set2_cb(GtkWidget *widget, gpointer data)
2111 {
2112         DupeWindow *dw = data;
2113
2114         dupe_listview_select_dupes(dw, FALSE);
2115 }
2116
2117 static void dupe_menu_edit_cb(GtkWidget *widget, gpointer data)
2118 {
2119         DupeWindow *dw;
2120         const gchar *key = data;
2121
2122         dw = submenu_item_get_data(widget);
2123         if (!dw) return;
2124
2125         dupe_window_edit_selected(dw, key);
2126 }
2127
2128 static void dupe_menu_collection_cb(GtkWidget *widget, gpointer data)
2129 {
2130         DupeWindow *dw = data;
2131
2132         dupe_window_collection_from_selection(dw);
2133 }
2134
2135 static void dupe_menu_print_cb(GtkWidget *widget, gpointer data)
2136 {
2137         DupeWindow *dw = data;
2138         FileData *fd;
2139
2140         fd = (dw->click_item) ? dw->click_item->fd : NULL;
2141
2142         print_window_new(fd,
2143                          dupe_listview_get_selection(dw, dw->listview),
2144                          dupe_listview_get_filelist(dw, dw->listview), dw->window);
2145 }
2146
2147 static void dupe_menu_copy_cb(GtkWidget *widget, gpointer data)
2148 {
2149         DupeWindow *dw = data;
2150
2151         file_util_copy(NULL, dupe_listview_get_selection(dw, dw->listview), NULL, dw->window);
2152 }
2153
2154 static void dupe_menu_move_cb(GtkWidget *widget, gpointer data)
2155 {
2156         DupeWindow *dw = data;
2157
2158         file_util_move(NULL, dupe_listview_get_selection(dw, dw->listview), NULL, dw->window);
2159 }
2160
2161 static void dupe_menu_rename_cb(GtkWidget *widget, gpointer data)
2162 {
2163         DupeWindow *dw = data;
2164
2165         file_util_rename(NULL, dupe_listview_get_selection(dw, dw->listview), dw->window);
2166 }
2167
2168 static void dupe_menu_delete_cb(GtkWidget *widget, gpointer data)
2169 {
2170         DupeWindow *dw = data;
2171
2172         file_util_delete(NULL, dupe_listview_get_selection(dw, dw->listview), dw->window);
2173 }
2174
2175 static void dupe_menu_copy_path_cb(GtkWidget *widget, gpointer data)
2176 {
2177         DupeWindow *dw = data;
2178
2179         file_util_copy_path_list_to_clipboard(dupe_listview_get_selection(dw, dw->listview));
2180 }
2181
2182 static void dupe_menu_remove_cb(GtkWidget *widget, gpointer data)
2183 {
2184         DupeWindow *dw = data;
2185
2186         dupe_window_remove_selection(dw, dw->listview);
2187 }
2188
2189 static void dupe_menu_clear_cb(GtkWidget *widget, gpointer data)
2190 {
2191         DupeWindow *dw = data;
2192
2193         dupe_window_clear(dw);
2194 }
2195
2196 static void dupe_menu_close_cb(GtkWidget *widget, gpointer data)
2197 {
2198         DupeWindow *dw = data;
2199
2200         dupe_window_close(dw);
2201 }
2202
2203 static void dupe_menu_popup_destroy_cb(GtkWidget *widget, gpointer data)
2204 {
2205         GList *editmenu_fd_list = data;
2206
2207         filelist_free(editmenu_fd_list);
2208 }
2209
2210 static GList *dupe_window_get_fd_list(DupeWindow *dw)
2211 {
2212         GList *list;
2213
2214         if (gtk_widget_has_focus(dw->second_listview))
2215                 {
2216                 list = dupe_listview_get_selection(dw, dw->second_listview);
2217                 }
2218         else
2219                 {
2220                 list = dupe_listview_get_selection(dw, dw->listview);
2221                 }
2222
2223         return list;
2224 }
2225
2226 static GtkWidget *dupe_menu_popup_main(DupeWindow *dw, DupeItem *di)
2227 {
2228         GtkWidget *menu;
2229         GtkWidget *item;
2230         gint on_row;
2231         GList *editmenu_fd_list;
2232
2233         on_row = (di != NULL);
2234
2235         menu = popup_menu_short_lived();
2236
2237         menu_item_add_sensitive(menu, _("_View"), on_row,
2238                                 G_CALLBACK(dupe_menu_view_cb), dw);
2239         menu_item_add_stock_sensitive(menu, _("View in _new window"), GTK_STOCK_NEW, on_row,
2240                                 G_CALLBACK(dupe_menu_viewnew_cb), dw);
2241         menu_item_add_divider(menu);
2242         menu_item_add_sensitive(menu, _("Select all"), (dw->dupes != NULL),
2243                                 G_CALLBACK(dupe_menu_select_all_cb), dw);
2244         menu_item_add_sensitive(menu, _("Select none"), (dw->dupes != NULL),
2245                                 G_CALLBACK(dupe_menu_select_none_cb), dw);
2246         menu_item_add_sensitive(menu, _("Select group _1 duplicates"), (dw->dupes != NULL),
2247                                 G_CALLBACK(dupe_menu_select_dupes_set1_cb), dw);
2248         menu_item_add_sensitive(menu, _("Select group _2 duplicates"), (dw->dupes != NULL),
2249                                 G_CALLBACK(dupe_menu_select_dupes_set2_cb), dw);
2250         menu_item_add_divider(menu);
2251
2252         editmenu_fd_list = dupe_window_get_fd_list(dw);
2253         g_signal_connect(G_OBJECT(menu), "destroy",
2254                          G_CALLBACK(dupe_menu_popup_destroy_cb), editmenu_fd_list);
2255         submenu_add_edit(menu, &item, G_CALLBACK(dupe_menu_edit_cb), dw, editmenu_fd_list);
2256         if (!on_row) gtk_widget_set_sensitive(item, FALSE);
2257         menu_item_add_stock_sensitive(menu, _("Add to new collection"), GTK_STOCK_INDEX, on_row,
2258                                 G_CALLBACK(dupe_menu_collection_cb), dw);
2259         menu_item_add_stock_sensitive(menu, _("Print..."), GTK_STOCK_PRINT, on_row,
2260                                 G_CALLBACK(dupe_menu_print_cb), dw);
2261         menu_item_add_divider(menu);
2262         menu_item_add_stock_sensitive(menu, _("_Copy..."), GTK_STOCK_COPY, on_row,
2263                                 G_CALLBACK(dupe_menu_copy_cb), dw);
2264         menu_item_add_sensitive(menu, _("_Move..."), on_row,
2265                                 G_CALLBACK(dupe_menu_move_cb), dw);
2266         menu_item_add_sensitive(menu, _("_Rename..."), on_row,
2267                                 G_CALLBACK(dupe_menu_rename_cb), dw);
2268         menu_item_add_stock_sensitive(menu, _("_Delete..."), GTK_STOCK_DELETE, on_row,
2269                                 G_CALLBACK(dupe_menu_delete_cb), dw);
2270         menu_item_add_sensitive(menu, _("_Copy path"), on_row,
2271                                 G_CALLBACK(dupe_menu_copy_path_cb), dw);
2272         menu_item_add_divider(menu);
2273         menu_item_add_stock_sensitive(menu, _("Rem_ove"), GTK_STOCK_REMOVE, on_row,
2274                                 G_CALLBACK(dupe_menu_remove_cb), dw);
2275         menu_item_add_stock_sensitive(menu, _("C_lear"), GTK_STOCK_CLEAR, (dw->list != NULL),
2276                                 G_CALLBACK(dupe_menu_clear_cb), dw);
2277         menu_item_add_divider(menu);
2278         menu_item_add_stock(menu, _("Close _window"), GTK_STOCK_CLOSE,
2279                             G_CALLBACK(dupe_menu_close_cb), dw);
2280
2281         return menu;
2282 }
2283
2284 static gboolean dupe_listview_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
2285 {
2286         DupeWindow *dw = data;
2287         GtkTreeModel *store;
2288         GtkTreePath *tpath;
2289         GtkTreeIter iter;
2290         DupeItem *di = NULL;
2291
2292         store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
2293
2294         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
2295                                           &tpath, NULL, NULL, NULL))
2296                 {
2297                 gtk_tree_model_get_iter(store, &iter, tpath);
2298                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
2299                 gtk_tree_path_free(tpath);
2300                 }
2301
2302         dw->click_item = di;
2303
2304         if (bevent->button == MOUSE_BUTTON_RIGHT)
2305                 {
2306                 /* right click menu */
2307                 GtkWidget *menu;
2308
2309                 if (bevent->state & GDK_CONTROL_MASK && bevent->state & GDK_SHIFT_MASK)
2310                         {
2311                         dupe_display_stats(dw, di);
2312                         return TRUE;
2313                         }
2314                 if (widget == dw->listview)
2315                         {
2316                         menu = dupe_menu_popup_main(dw, di);
2317                         }
2318                 else
2319                         {
2320                         menu = dupe_menu_popup_second(dw, di);
2321                         }
2322                 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, bevent->button, bevent->time);
2323                 }
2324
2325         if (!di) return FALSE;
2326
2327         if (bevent->button == MOUSE_BUTTON_LEFT &&
2328             bevent->type == GDK_2BUTTON_PRESS)
2329                 {
2330                 dupe_menu_view(dw, di, widget, FALSE);
2331                 }
2332
2333         if (bevent->button == MOUSE_BUTTON_MIDDLE) return TRUE;
2334
2335         if (bevent->button == MOUSE_BUTTON_RIGHT)
2336                 {
2337                 if (!dupe_listview_item_is_selected(dw, di, widget))
2338                         {
2339                         GtkTreeSelection *selection;
2340
2341                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
2342                         gtk_tree_selection_unselect_all(selection);
2343                         gtk_tree_selection_select_iter(selection, &iter);
2344
2345                         tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
2346                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
2347                         gtk_tree_path_free(tpath);
2348                         }
2349
2350                 return TRUE;
2351                 }
2352
2353         if (bevent->button == MOUSE_BUTTON_LEFT &&
2354             bevent->type == GDK_BUTTON_PRESS &&
2355             !(bevent->state & GDK_SHIFT_MASK ) &&
2356             !(bevent->state & GDK_CONTROL_MASK ) &&
2357             dupe_listview_item_is_selected(dw, di, widget))
2358                 {
2359                 /* this selection handled on release_cb */
2360                 gtk_widget_grab_focus(widget);
2361                 return TRUE;
2362                 }
2363
2364         return FALSE;
2365 }
2366
2367 static gboolean dupe_listview_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
2368 {
2369         DupeWindow *dw = data;
2370         GtkTreeModel *store;
2371         GtkTreePath *tpath;
2372         GtkTreeIter iter;
2373         DupeItem *di = NULL;
2374
2375         if (bevent->button != MOUSE_BUTTON_LEFT && bevent->button != MOUSE_BUTTON_MIDDLE) return TRUE;
2376
2377         store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
2378
2379         if ((bevent->x != 0 || bevent->y != 0) &&
2380             gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
2381                                           &tpath, NULL, NULL, NULL))
2382                 {
2383                 gtk_tree_model_get_iter(store, &iter, tpath);
2384                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
2385                 gtk_tree_path_free(tpath);
2386                 }
2387
2388         if (bevent->button == MOUSE_BUTTON_MIDDLE)
2389                 {
2390                 if (di && dw->click_item == di)
2391                         {
2392                         GtkTreeSelection *selection;
2393
2394                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
2395                         if (dupe_listview_item_is_selected(dw, di, widget))
2396                                 {
2397                                 gtk_tree_selection_unselect_iter(selection, &iter);
2398                                 }
2399                         else
2400                                 {
2401                                 gtk_tree_selection_select_iter(selection, &iter);
2402                                 }
2403                         }
2404                 return TRUE;
2405                 }
2406
2407         if (di && dw->click_item == di &&
2408             !(bevent->state & GDK_SHIFT_MASK ) &&
2409             !(bevent->state & GDK_CONTROL_MASK ) &&
2410             dupe_listview_item_is_selected(dw, di, widget))
2411                 {
2412                 GtkTreeSelection *selection;
2413
2414                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
2415                 gtk_tree_selection_unselect_all(selection);
2416                 gtk_tree_selection_select_iter(selection, &iter);
2417
2418                 tpath = gtk_tree_model_get_path(store, &iter);
2419                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
2420                 gtk_tree_path_free(tpath);
2421
2422                 return TRUE;
2423                 }
2424
2425         return FALSE;
2426 }
2427
2428 /*
2429  *-------------------------------------------------------------------
2430  * second set stuff
2431  *-------------------------------------------------------------------
2432  */
2433
2434 static void dupe_second_update_status(DupeWindow *dw)
2435 {
2436         gchar *buf;
2437
2438         buf = g_strdup_printf(_("%d files (set 2)"), g_list_length(dw->second_list));
2439         gtk_label_set_text(GTK_LABEL(dw->second_status_label), buf);
2440         g_free(buf);
2441 }
2442
2443 static void dupe_second_add(DupeWindow *dw, DupeItem *di)
2444 {
2445         GtkListStore *store;
2446         GtkTreeIter iter;
2447
2448         if (!di) return;
2449
2450         di->second = TRUE;
2451         dw->second_list = g_list_prepend(dw->second_list, di);
2452
2453         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
2454         gtk_list_store_append(store, &iter);
2455         gtk_list_store_set(store, &iter, DUPE_COLUMN_POINTER, di, 1, di->fd->path, -1);
2456
2457         dupe_second_update_status(dw);
2458 }
2459
2460 static void dupe_second_remove(DupeWindow *dw, DupeItem *di)
2461 {
2462         GtkListStore *store;
2463         GtkTreeIter iter;
2464
2465         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
2466         if (dupe_listview_find_item(store, di, &iter) >= 0)
2467                 {
2468                 tree_view_move_cursor_away(GTK_TREE_VIEW(dw->second_listview), &iter, TRUE);
2469                 gtk_list_store_remove(store, &iter);
2470                 }
2471
2472         dw->second_list = g_list_remove(dw->second_list, di);
2473
2474         dupe_second_update_status(dw);
2475 }
2476
2477 static void dupe_second_clear(DupeWindow *dw)
2478 {
2479         GtkListStore *store;
2480
2481         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->second_listview)));
2482         gtk_list_store_clear(store);
2483         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dw->second_listview));
2484
2485         g_list_free(dw->dupes);
2486         dw->dupes = NULL;
2487
2488         dupe_list_free(dw->second_list);
2489         dw->second_list = NULL;
2490
2491         dupe_match_reset_list(dw->list);
2492
2493         dupe_second_update_status(dw);
2494 }
2495
2496 static void dupe_second_menu_view_cb(GtkWidget *widget, gpointer data)
2497 {
2498         DupeWindow *dw = data;
2499
2500         if (dw->click_item) dupe_menu_view(dw, dw->click_item, dw->second_listview, FALSE);
2501 }
2502
2503 static void dupe_second_menu_viewnew_cb(GtkWidget *widget, gpointer data)
2504 {
2505         DupeWindow *dw = data;
2506
2507         if (dw->click_item) dupe_menu_view(dw, dw->click_item, dw->second_listview, TRUE);
2508 }
2509
2510 static void dupe_second_menu_select_all_cb(GtkWidget *widget, gpointer data)
2511 {
2512         GtkTreeSelection *selection;
2513         DupeWindow *dw = data;
2514
2515         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->second_listview));
2516         gtk_tree_selection_select_all(selection);
2517 }
2518
2519 static void dupe_second_menu_select_none_cb(GtkWidget *widget, gpointer data)
2520 {
2521         GtkTreeSelection *selection;
2522         DupeWindow *dw = data;
2523
2524         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->second_listview));
2525         gtk_tree_selection_unselect_all(selection);
2526 }
2527
2528 static void dupe_second_menu_remove_cb(GtkWidget *widget, gpointer data)
2529 {
2530         DupeWindow *dw = data;
2531
2532         dupe_window_remove_selection(dw, dw->second_listview);
2533 }
2534
2535 static void dupe_second_menu_clear_cb(GtkWidget *widget, gpointer data)
2536 {
2537         DupeWindow *dw = data;
2538
2539         dupe_second_clear(dw);
2540         dupe_window_recompare(dw);
2541 }
2542
2543 static GtkWidget *dupe_menu_popup_second(DupeWindow *dw, DupeItem *di)
2544 {
2545         GtkWidget *menu;
2546         gboolean notempty = (dw->second_list != NULL);
2547         gboolean on_row = (di != NULL);
2548
2549         menu = popup_menu_short_lived();
2550         menu_item_add_sensitive(menu, _("_View"), on_row,
2551                                 G_CALLBACK(dupe_second_menu_view_cb), dw);
2552         menu_item_add_stock_sensitive(menu, _("View in _new window"), GTK_STOCK_NEW, on_row,
2553                                 G_CALLBACK(dupe_second_menu_viewnew_cb), dw);
2554         menu_item_add_divider(menu);
2555         menu_item_add_sensitive(menu, _("Select all"), notempty,
2556                                 G_CALLBACK(dupe_second_menu_select_all_cb), dw);
2557         menu_item_add_sensitive(menu, _("Select none"), notempty,
2558                                 G_CALLBACK(dupe_second_menu_select_none_cb), dw);
2559         menu_item_add_divider(menu);
2560         menu_item_add_stock_sensitive(menu, _("Rem_ove"), GTK_STOCK_REMOVE, on_row,
2561                                       G_CALLBACK(dupe_second_menu_remove_cb), dw);
2562         menu_item_add_stock_sensitive(menu, _("C_lear"), GTK_STOCK_CLEAR, notempty,
2563                                    G_CALLBACK(dupe_second_menu_clear_cb), dw);
2564         menu_item_add_divider(menu);
2565         menu_item_add_stock(menu, _("Close _window"), GTK_STOCK_CLOSE,
2566                             G_CALLBACK(dupe_menu_close_cb), dw);
2567
2568         return menu;
2569 }
2570
2571 static void dupe_second_set_toggle_cb(GtkWidget *widget, gpointer data)
2572 {
2573         DupeWindow *dw = data;
2574
2575         dw->second_set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
2576
2577         if (dw->second_set)
2578                 {
2579                 dupe_second_update_status(dw);
2580                 gtk_table_set_col_spacings(GTK_TABLE(dw->table), PREF_PAD_GAP);
2581                 gtk_widget_show(dw->second_vbox);
2582                 }
2583         else
2584                 {
2585                 gtk_table_set_col_spacings(GTK_TABLE(dw->table), 0);
2586                 gtk_widget_hide(dw->second_vbox);
2587                 dupe_second_clear(dw);
2588                 }
2589
2590         dupe_window_recompare(dw);
2591 }
2592
2593 /*
2594  *-------------------------------------------------------------------
2595  * match type menu
2596  *-------------------------------------------------------------------
2597  */
2598
2599 enum {
2600         DUPE_MENU_COLUMN_NAME = 0,
2601         DUPE_MENU_COLUMN_MASK
2602 };
2603
2604 static void dupe_menu_type_cb(GtkWidget *combo, gpointer data)
2605 {
2606         DupeWindow *dw = data;
2607         GtkTreeModel *store;
2608         GtkTreeIter iter;
2609
2610         store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
2611         if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter)) return;
2612         gtk_tree_model_get(store, &iter, DUPE_MENU_COLUMN_MASK, &dw->match_mask, -1);
2613
2614         dupe_window_recompare(dw);
2615 }
2616
2617 static void dupe_menu_add_item(GtkListStore *store, const gchar *text, DupeMatchType type, DupeWindow *dw)
2618 {
2619         GtkTreeIter iter;
2620
2621         gtk_list_store_append(store, &iter);
2622         gtk_list_store_set(store, &iter, DUPE_MENU_COLUMN_NAME, text,
2623                                          DUPE_MENU_COLUMN_MASK, type, -1);
2624
2625         if (dw->match_mask == type) gtk_combo_box_set_active_iter(GTK_COMBO_BOX(dw->combo), &iter);
2626 }
2627
2628 static void dupe_menu_setup(DupeWindow *dw)
2629 {
2630         GtkListStore *store;
2631         GtkCellRenderer *renderer;
2632
2633         store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
2634         dw->combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
2635         g_object_unref(store);
2636
2637         renderer = gtk_cell_renderer_text_new();
2638         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dw->combo), renderer, TRUE);
2639         gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dw->combo), renderer,
2640                                        "text", DUPE_MENU_COLUMN_NAME, NULL);
2641
2642         dupe_menu_add_item(store, _("Name"), DUPE_MATCH_NAME, dw);
2643         dupe_menu_add_item(store, _("Name case-insensitive"), DUPE_MATCH_NAME_CI, dw);
2644         dupe_menu_add_item(store, _("Size"), DUPE_MATCH_SIZE, dw);
2645         dupe_menu_add_item(store, _("Date"), DUPE_MATCH_DATE, dw);
2646         dupe_menu_add_item(store, _("Dimensions"), DUPE_MATCH_DIM, dw);
2647         dupe_menu_add_item(store, _("Checksum"), DUPE_MATCH_SUM, dw);
2648         dupe_menu_add_item(store, _("Path"), DUPE_MATCH_PATH, dw);
2649         dupe_menu_add_item(store, _("Similarity (high)"), DUPE_MATCH_SIM_HIGH, dw);
2650         dupe_menu_add_item(store, _("Similarity"), DUPE_MATCH_SIM_MED, dw);
2651         dupe_menu_add_item(store, _("Similarity (low)"), DUPE_MATCH_SIM_LOW, dw);
2652         dupe_menu_add_item(store, _("Similarity (custom)"), DUPE_MATCH_SIM_CUSTOM, dw);
2653
2654         g_signal_connect(G_OBJECT(dw->combo), "changed",
2655                          G_CALLBACK(dupe_menu_type_cb), dw);
2656 }
2657
2658 /*
2659  *-------------------------------------------------------------------
2660  * list view columns
2661  *-------------------------------------------------------------------
2662  */
2663
2664 /* this overrides the low default of a GtkCellRenderer from 100 to CELL_HEIGHT_OVERRIDE, something sane for our purposes */
2665
2666 #define CELL_HEIGHT_OVERRIDE 512
2667
2668 void cell_renderer_height_override(GtkCellRenderer *renderer)
2669 {
2670         GParamSpec *spec;
2671
2672         spec = g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(renderer)), "height");
2673         if (spec && G_IS_PARAM_SPEC_INT(spec))
2674                 {
2675                 GParamSpecInt *spec_int;
2676
2677                 spec_int = G_PARAM_SPEC_INT(spec);
2678                 if (spec_int->maximum < CELL_HEIGHT_OVERRIDE) spec_int->maximum = CELL_HEIGHT_OVERRIDE;
2679                 }
2680 }
2681
2682 static GdkColor *dupe_listview_color_shifted(GtkWidget *widget)
2683 {
2684         static GdkColor color;
2685         static GtkWidget *done = NULL;
2686
2687         if (done != widget)
2688                 {
2689                 GtkStyle *style;
2690
2691                 style = gtk_widget_get_style(widget);
2692                 memcpy(&color, &style->base[GTK_STATE_NORMAL], sizeof(color));
2693                 shift_color(&color, -1, 0);
2694                 done = widget;
2695                 }
2696
2697         return &color;
2698 }
2699
2700 static void dupe_listview_color_cb(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
2701                                    GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
2702 {
2703         DupeWindow *dw = data;
2704         gboolean set;
2705
2706         gtk_tree_model_get(tree_model, iter, DUPE_COLUMN_COLOR, &set, -1);
2707         g_object_set(G_OBJECT(cell),
2708                      "cell-background-gdk", dupe_listview_color_shifted(dw->listview),
2709                      "cell-background-set", set, NULL);
2710 }
2711
2712 static void dupe_listview_add_column(DupeWindow *dw, GtkWidget *listview, gint n, const gchar *title, gboolean image, gboolean right_justify)
2713 {
2714         GtkTreeViewColumn *column;
2715         GtkCellRenderer *renderer;
2716
2717         column = gtk_tree_view_column_new();
2718         gtk_tree_view_column_set_title(column, title);
2719         gtk_tree_view_column_set_min_width(column, 4);
2720
2721         if (n != DUPE_COLUMN_RANK &&
2722             n != DUPE_COLUMN_THUMB)
2723                 {
2724                 gtk_tree_view_column_set_resizable(column, TRUE);
2725                 }
2726
2727         if (!image)
2728                 {
2729                 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
2730                 renderer = gtk_cell_renderer_text_new();
2731                 if (right_justify)
2732                         {
2733                         g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
2734                         }
2735                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2736                 gtk_tree_view_column_add_attribute(column, renderer, "text", n);
2737                 }
2738         else
2739                 {
2740                 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
2741                 renderer = gtk_cell_renderer_pixbuf_new();
2742                 cell_renderer_height_override(renderer);
2743                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2744                 gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", n);
2745                 }
2746
2747         if (listview == dw->listview)
2748                 {
2749                 /* sets background before rendering */
2750                 gtk_tree_view_column_set_cell_data_func(column, renderer, dupe_listview_color_cb, dw, NULL);
2751                 }
2752
2753         gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column);
2754 }
2755
2756 static void dupe_listview_set_height(GtkWidget *listview, gboolean thumb)
2757 {
2758         GtkTreeViewColumn *column;
2759         GtkCellRenderer *cell;
2760         GList *list;
2761
2762         column = gtk_tree_view_get_column(GTK_TREE_VIEW(listview), DUPE_COLUMN_THUMB - 1);
2763         if (!column) return;
2764
2765         gtk_tree_view_column_set_fixed_width(column, (thumb) ? options->thumbnails.max_width : 4);
2766
2767         list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
2768         if (!list) return;
2769         cell = list->data;
2770         g_list_free(list);
2771
2772         g_object_set(G_OBJECT(cell), "height", (thumb) ? options->thumbnails.max_height : -1, NULL);
2773         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(listview));
2774 }
2775
2776
2777 /*
2778  *-------------------------------------------------------------------
2779  * misc cb
2780  *-------------------------------------------------------------------
2781  */
2782
2783 static void dupe_window_show_thumb_cb(GtkWidget *widget, gpointer data)
2784 {
2785         DupeWindow *dw = data;
2786
2787         dw->show_thumbs = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
2788
2789         if (dw->show_thumbs)
2790                 {
2791                 if (!dw->working) dupe_thumb_step(dw);
2792                 }
2793         else
2794                 {
2795                 GtkTreeModel *store;
2796                 GtkTreeIter iter;
2797                 gboolean valid;
2798
2799                 thumb_loader_free(dw->thumb_loader);
2800                 dw->thumb_loader = NULL;
2801
2802                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview));
2803                 valid = gtk_tree_model_get_iter_first(store, &iter);
2804
2805                 while (valid)
2806                         {
2807                         gtk_list_store_set(GTK_LIST_STORE(store), &iter, DUPE_COLUMN_THUMB, NULL, -1);
2808                         valid = gtk_tree_model_iter_next(store, &iter);
2809                         }
2810                 dupe_window_update_progress(dw, NULL, 0.0, FALSE);
2811                 }
2812
2813         dupe_listview_set_height(dw->listview, dw->show_thumbs);
2814 }
2815
2816 static void dupe_popup_menu_pos_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
2817 {
2818         GtkWidget *view = data;
2819         GtkTreePath *tpath;
2820         gint cx, cy, cw, ch;
2821         gint column;
2822
2823         gtk_tree_view_get_cursor(GTK_TREE_VIEW(view), &tpath, NULL);
2824         if (!tpath) return;
2825
2826         if (gtk_tree_view_get_column(GTK_TREE_VIEW(view), DUPE_COLUMN_NAME - 1) != NULL)
2827                 {
2828                 column = DUPE_COLUMN_NAME - 1;
2829                 }
2830         else
2831                 {
2832                 /* dw->second_listview */
2833                 column = 0;
2834                 }
2835         tree_view_get_cell_clamped(GTK_TREE_VIEW(view), tpath, column, TRUE, &cx, &cy, &cw, &ch);
2836         gtk_tree_path_free(tpath);
2837         cy += ch;
2838         popup_menu_position_clamp(menu, &cx, &cy, 0);
2839         *x = cx;
2840         *y = cy;
2841 }
2842
2843 static gboolean dupe_window_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
2844 {
2845         DupeWindow *dw = data;
2846         gboolean stop_signal = FALSE;
2847         gboolean on_second;
2848         GtkWidget *listview;
2849         GtkTreeModel *store;
2850         GtkTreeSelection *selection;
2851         GList *slist;
2852         DupeItem *di = NULL;
2853
2854         on_second = gtk_widget_has_focus(dw->second_listview);
2855
2856         if (on_second)
2857                 {
2858                 listview = dw->second_listview;
2859                 }
2860         else
2861                 {
2862                 listview = dw->listview;
2863                 }
2864
2865         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));
2866         slist = gtk_tree_selection_get_selected_rows(selection, &store);
2867         if (slist)
2868                 {
2869                 GtkTreePath *tpath;
2870                 GtkTreeIter iter;
2871                 GList *last;
2872
2873                 last = g_list_last(slist);
2874                 tpath = last->data;
2875
2876                 /* last is newest selected file */
2877                 gtk_tree_model_get_iter(store, &iter, tpath);
2878                 gtk_tree_model_get(store, &iter, DUPE_COLUMN_POINTER, &di, -1);
2879                 }
2880         g_list_foreach(slist, (GFunc)gtk_tree_path_free, NULL);
2881         g_list_free(slist);
2882
2883         if (event->state & GDK_CONTROL_MASK)
2884                 {
2885                 if (!on_second)
2886                         {
2887                         stop_signal = TRUE;
2888                         switch (event->keyval)
2889                                 {
2890                                 case '1':
2891                                 case '2':
2892                                 case '3':
2893                                 case '4':
2894                                 case '5':
2895                                 case '6':
2896                                 case '7':
2897                                 case '8':
2898                                 case '9':
2899                                 case '0':
2900                                         break;
2901                                 case 'C': case 'c':
2902                                         file_util_copy(NULL, dupe_listview_get_selection(dw, listview),
2903                                                        NULL, dw->window);
2904                                         break;
2905                                 case 'M': case 'm':
2906                                         file_util_move(NULL, dupe_listview_get_selection(dw, listview),
2907                                                        NULL, dw->window);
2908                                         break;
2909                                 case 'R': case 'r':
2910                                         file_util_rename(NULL, dupe_listview_get_selection(dw, listview), dw->window);
2911                                         break;
2912                                 case 'D': case 'd':
2913                                         file_util_delete(NULL, dupe_listview_get_selection(dw, listview), dw->window);
2914                                         break;
2915                                 default:
2916                                         stop_signal = FALSE;
2917                                         break;
2918                                 }
2919                         }
2920
2921                 if (!stop_signal)
2922                         {
2923                         stop_signal = TRUE;
2924                         switch (event->keyval)
2925                                 {
2926                                 case 'A': case 'a':
2927                                         if (event->state & GDK_SHIFT_MASK)
2928                                                 {
2929                                                 gtk_tree_selection_unselect_all(selection);
2930                                                 }
2931                                         else
2932                                                 {
2933                                                 gtk_tree_selection_select_all(selection);
2934                                                 }
2935                                         break;
2936                                 case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
2937                                         if (on_second)
2938                                                 {
2939                                                 dupe_second_clear(dw);
2940                                                 dupe_window_recompare(dw);
2941                                                 }
2942                                         else
2943                                                 {
2944                                                 dupe_window_clear(dw);
2945                                                 }
2946                                         break;
2947                                 case 'L': case 'l':
2948                                         dupe_window_append_file_list(dw, FALSE);
2949                                         break;
2950                                 case 'T': case 't':
2951                                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dw->button_thumbs),
2952                                                 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dw->button_thumbs)));
2953                                         break;
2954                                 case 'W': case 'w':
2955                                         dupe_window_close(dw);
2956                                         break;
2957                                 default:
2958                                         stop_signal = FALSE;
2959                                         break;
2960                                 }
2961                         }
2962                 }
2963         else
2964                 {
2965                 stop_signal = TRUE;
2966                 switch (event->keyval)
2967                         {
2968                         case GDK_KEY_Return: case GDK_KEY_KP_Enter:
2969                                 dupe_menu_view(dw, di, listview, FALSE);
2970                                 break;
2971                         case 'V': case 'v':
2972                                 dupe_menu_view(dw, di, listview, TRUE);
2973                                 break;
2974                         case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
2975                                 dupe_window_remove_selection(dw, listview);
2976                                 break;
2977                         case 'C': case 'c':
2978                                 if (!on_second)
2979                                         {
2980                                         dupe_window_collection_from_selection(dw);
2981                                         }
2982                                 break;
2983                         case '1':
2984                                 dupe_listview_select_dupes(dw, TRUE);
2985                                 break;
2986                         case '2':
2987                                 dupe_listview_select_dupes(dw, FALSE);
2988                                 break;
2989                         case GDK_KEY_Menu:
2990                         case GDK_KEY_F10:
2991                                 if (!on_second)
2992                                         {
2993                                         GtkWidget *menu;
2994
2995                                         menu = dupe_menu_popup_main(dw, di);
2996                                         gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
2997                                                        dupe_popup_menu_pos_cb, listview, 0, GDK_CURRENT_TIME);
2998                                         }
2999                                 else
3000                                         {
3001                                         GtkWidget *menu;
3002
3003                                         menu = dupe_menu_popup_second(dw, di);
3004                                         gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
3005                                                        dupe_popup_menu_pos_cb, listview, 0, GDK_CURRENT_TIME);
3006                                         }
3007                                 break;
3008                         default:
3009                                 stop_signal = FALSE;
3010                                 break;
3011                         }
3012                 }
3013
3014         return stop_signal;
3015 }
3016
3017
3018 void dupe_window_clear(DupeWindow *dw)
3019 {
3020         GtkListStore *store;
3021
3022         dupe_check_stop(dw);
3023
3024         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dw->listview)));
3025         gtk_list_store_clear(store);
3026         gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dw->listview));
3027
3028         g_list_free(dw->dupes);
3029         dw->dupes = NULL;
3030
3031         dupe_list_free(dw->list);
3032         dw->list = NULL;
3033
3034         dupe_match_reset_list(dw->second_list);
3035
3036         dupe_window_update_count(dw, FALSE);
3037         dupe_window_update_progress(dw, NULL, 0.0, FALSE);
3038 }
3039
3040 void dupe_window_close(DupeWindow *dw)
3041 {
3042         dupe_check_stop(dw);
3043
3044         dupe_window_list = g_list_remove(dupe_window_list, dw);
3045         gtk_widget_destroy(dw->window);
3046
3047         g_list_free(dw->dupes);
3048         dupe_list_free(dw->list);
3049
3050         dupe_list_free(dw->second_list);
3051
3052         file_data_unregister_notify_func(dupe_notify_cb, dw);
3053
3054         g_free(dw);
3055 }
3056
3057 static gint dupe_window_delete(GtkWidget *widget, GdkEvent *event, gpointer data)
3058 {
3059         DupeWindow *dw = data;
3060         dupe_window_close(dw);
3061
3062         return TRUE;
3063 }
3064
3065 /* collection and files can be NULL */
3066 DupeWindow *dupe_window_new(DupeMatchType match_mask)
3067 {
3068         DupeWindow *dw;
3069         GtkWidget *vbox;
3070         GtkWidget *scrolled;
3071         GtkWidget *frame;
3072         GtkWidget *status_box;
3073         GtkWidget *label;
3074         GtkWidget *button;
3075         GtkListStore *store;
3076         GtkTreeSelection *selection;
3077         GdkGeometry geometry;
3078
3079         dw = g_new0(DupeWindow, 1);
3080
3081         dw->match_mask = match_mask;
3082
3083         dw->window = window_new(GTK_WINDOW_TOPLEVEL, "dupe", NULL, NULL, _("Find duplicates"));
3084
3085         geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
3086         geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
3087         geometry.base_width = DUPE_DEF_WIDTH;
3088         geometry.base_height = DUPE_DEF_HEIGHT;
3089         gtk_window_set_geometry_hints(GTK_WINDOW(dw->window), NULL, &geometry,
3090                                       GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE);
3091
3092         gtk_window_set_default_size(GTK_WINDOW(dw->window), DUPE_DEF_WIDTH, DUPE_DEF_HEIGHT);
3093
3094         gtk_window_set_resizable(GTK_WINDOW(dw->window), TRUE);
3095         gtk_container_set_border_width(GTK_CONTAINER(dw->window), 0);
3096
3097         g_signal_connect(G_OBJECT(dw->window), "delete_event",
3098                          G_CALLBACK(dupe_window_delete), dw);
3099         g_signal_connect(G_OBJECT(dw->window), "key_press_event",
3100                          G_CALLBACK(dupe_window_keypress_cb), dw);
3101
3102         vbox = gtk_vbox_new(FALSE, 0);
3103         gtk_container_add(GTK_CONTAINER(dw->window), vbox);
3104         gtk_widget_show(vbox);
3105
3106         dw->table = gtk_table_new(1, 3, FALSE);
3107         gtk_box_pack_start(GTK_BOX(vbox), dw->table, TRUE, TRUE, 0);
3108         gtk_widget_show(dw->table);
3109
3110         scrolled = gtk_scrolled_window_new(NULL, NULL);
3111         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
3112         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3113         gtk_table_attach_defaults(GTK_TABLE(dw->table), scrolled, 0, 2, 0, 1);
3114         gtk_widget_show(scrolled);
3115
3116         store = gtk_list_store_new(9, G_TYPE_POINTER, G_TYPE_STRING, GDK_TYPE_PIXBUF,
3117                                    G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
3118                                    G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
3119         dw->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
3120         g_object_unref(store);
3121
3122         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->listview));
3123         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
3124         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(dw->listview), TRUE);
3125         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(dw->listview), FALSE);
3126
3127         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_RANK, "", FALSE, TRUE);
3128         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_THUMB, "", TRUE, FALSE);
3129         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_NAME, _("Name"), FALSE, FALSE);
3130         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_SIZE, _("Size"), FALSE, TRUE);
3131         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_DATE, _("Date"), FALSE, TRUE);
3132         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_DIMENSIONS, _("Dimensions"), FALSE, FALSE);
3133         dupe_listview_add_column(dw, dw->listview, DUPE_COLUMN_PATH, _("Path"), FALSE, FALSE);
3134
3135         gtk_container_add(GTK_CONTAINER(scrolled), dw->listview);
3136         gtk_widget_show(dw->listview);
3137
3138         dw->second_vbox = gtk_vbox_new(FALSE, 0);
3139         gtk_table_attach_defaults(GTK_TABLE(dw->table), dw->second_vbox, 2, 3, 0, 1);
3140         if (dw->second_set)
3141                 {
3142                 gtk_table_set_col_spacings(GTK_TABLE(dw->table), PREF_PAD_GAP);
3143                 gtk_widget_show(dw->second_vbox);
3144                 }
3145         else
3146                 {
3147                 gtk_table_set_col_spacings(GTK_TABLE(dw->table), 0);
3148                 }
3149
3150         scrolled = gtk_scrolled_window_new(NULL, NULL);
3151         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
3152         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3153         gtk_box_pack_start(GTK_BOX(dw->second_vbox), scrolled, TRUE, TRUE, 0);
3154         gtk_widget_show(scrolled);
3155
3156         store = gtk_list_store_new(2, G_TYPE_POINTER, G_TYPE_STRING);
3157         dw->second_listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
3158
3159         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dw->second_listview));
3160         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_MULTIPLE);
3161
3162         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(dw->second_listview), TRUE);
3163         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(dw->second_listview), FALSE);
3164
3165         dupe_listview_add_column(dw, dw->second_listview, 1, _("Compare to:"), FALSE, FALSE);
3166
3167         gtk_container_add(GTK_CONTAINER(scrolled), dw->second_listview);
3168         gtk_widget_show(dw->second_listview);
3169
3170         dw->second_status_label = gtk_label_new("");
3171         gtk_box_pack_start(GTK_BOX(dw->second_vbox), dw->second_status_label, FALSE, FALSE, 0);
3172         gtk_widget_show(dw->second_status_label);
3173
3174         pref_line(dw->second_vbox, GTK_ORIENTATION_HORIZONTAL);
3175
3176         status_box = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
3177
3178         label = gtk_label_new(_("Compare by:"));
3179         gtk_box_pack_start(GTK_BOX(status_box), label, FALSE, FALSE, PREF_PAD_SPACE);
3180         gtk_widget_show(label);
3181
3182         dupe_menu_setup(dw);
3183         gtk_box_pack_start(GTK_BOX(status_box), dw->combo, FALSE, FALSE, 0);
3184         gtk_widget_show(dw->combo);
3185
3186         dw->button_thumbs = gtk_check_button_new_with_label(_("Thumbnails"));
3187         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dw->button_thumbs), dw->show_thumbs);
3188         g_signal_connect(G_OBJECT(dw->button_thumbs), "toggled",
3189                          G_CALLBACK(dupe_window_show_thumb_cb), dw);
3190         gtk_box_pack_start(GTK_BOX(status_box), dw->button_thumbs, FALSE, FALSE, PREF_PAD_SPACE);
3191         gtk_widget_show(dw->button_thumbs);
3192
3193         button = gtk_check_button_new_with_label(_("Compare two file sets"));
3194         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), dw->second_set);
3195         g_signal_connect(G_OBJECT(button), "toggled",
3196                          G_CALLBACK(dupe_second_set_toggle_cb), dw);
3197         gtk_box_pack_end(GTK_BOX(status_box), button, FALSE, FALSE, PREF_PAD_SPACE);
3198         gtk_widget_show(button);
3199
3200         status_box = gtk_hbox_new(FALSE, 0);
3201         gtk_box_pack_start(GTK_BOX(vbox), status_box, FALSE, FALSE, 0);
3202         gtk_widget_show(status_box);
3203
3204         frame = gtk_frame_new(NULL);
3205         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
3206         gtk_box_pack_start(GTK_BOX(status_box), frame, TRUE, TRUE, 0);
3207         gtk_widget_show(frame);
3208
3209         dw->status_label = gtk_label_new("");
3210         gtk_container_add(GTK_CONTAINER(frame), dw->status_label);
3211         gtk_widget_show(dw->status_label);
3212
3213         dw->extra_label = gtk_progress_bar_new();
3214         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dw->extra_label), 0.0);
3215         gtk_box_pack_end(GTK_BOX(status_box), dw->extra_label, FALSE, FALSE, 0);
3216         gtk_widget_show(dw->extra_label);
3217
3218         dupe_dnd_init(dw);
3219
3220         /* order is important here, dnd_init should be seeing mouse
3221          * presses before we possibly handle (and stop) the signal
3222          */
3223         g_signal_connect(G_OBJECT(dw->listview), "button_press_event",
3224                          G_CALLBACK(dupe_listview_press_cb), dw);
3225         g_signal_connect(G_OBJECT(dw->listview), "button_release_event",
3226                          G_CALLBACK(dupe_listview_release_cb), dw);
3227         g_signal_connect(G_OBJECT(dw->second_listview), "button_press_event",
3228                          G_CALLBACK(dupe_listview_press_cb), dw);
3229         g_signal_connect(G_OBJECT(dw->second_listview), "button_release_event",
3230                          G_CALLBACK(dupe_listview_release_cb), dw);
3231
3232         gtk_widget_show(dw->window);
3233
3234         dupe_window_update_count(dw, TRUE);
3235         dupe_window_update_progress(dw, NULL, 0.0, FALSE);
3236
3237         dupe_window_list = g_list_append(dupe_window_list, dw);
3238
3239         file_data_register_notify_func(dupe_notify_cb, dw, NOTIFY_PRIORITY_MEDIUM);
3240
3241         return dw;
3242 }
3243
3244 /*
3245  *-------------------------------------------------------------------
3246  * dnd confirm dir
3247  *-------------------------------------------------------------------
3248  */
3249
3250 typedef struct {
3251         DupeWindow *dw;
3252         GList *list;
3253 } CDupeConfirmD;
3254
3255 static void confirm_dir_list_cancel(GtkWidget *widget, gpointer data)
3256 {
3257         /* do nothing */
3258 }
3259
3260 static void confirm_dir_list_add(GtkWidget *widget, gpointer data)
3261 {
3262         CDupeConfirmD *d = data;
3263         GList *work;
3264
3265         dupe_window_add_files(d->dw, d->list, FALSE);
3266
3267         work = d->list;
3268         while (work)
3269                 {
3270                 FileData *fd = work->data;
3271                 work = work->next;
3272                 if (isdir(fd->path))
3273                         {
3274                         GList *list;
3275
3276                         filelist_read(fd, &list, NULL);
3277                         list = filelist_filter(list, FALSE);
3278                         if (list)
3279                                 {
3280                                 dupe_window_add_files(d->dw, list, FALSE);
3281                                 filelist_free(list);
3282                                 }
3283                         }
3284                 }
3285 }
3286
3287 static void confirm_dir_list_recurse(GtkWidget *widget, gpointer data)
3288 {
3289         CDupeConfirmD *d = data;
3290         dupe_window_add_files(d->dw, d->list, TRUE);
3291 }
3292
3293 static void confirm_dir_list_skip(GtkWidget *widget, gpointer data)
3294 {
3295         CDupeConfirmD *d = data;
3296         dupe_window_add_files(d->dw, d->list, FALSE);
3297 }
3298
3299 static void confirm_dir_list_destroy(GtkWidget *widget, gpointer data)
3300 {
3301         CDupeConfirmD *d = data;
3302         filelist_free(d->list);
3303         g_free(d);
3304 }
3305
3306 static GtkWidget *dupe_confirm_dir_list(DupeWindow *dw, GList *list)
3307 {
3308         GtkWidget *menu;
3309         CDupeConfirmD *d;
3310
3311         d = g_new0(CDupeConfirmD, 1);
3312         d->dw = dw;
3313         d->list = list;
3314
3315         menu = popup_menu_short_lived();
3316         g_signal_connect(G_OBJECT(menu), "destroy",
3317                          G_CALLBACK(confirm_dir_list_destroy), d);
3318
3319         menu_item_add_stock(menu, _("Dropped list includes folders."), GTK_STOCK_DND_MULTIPLE, NULL, NULL);
3320         menu_item_add_divider(menu);
3321         menu_item_add_stock(menu, _("_Add contents"), GTK_STOCK_OK, G_CALLBACK(confirm_dir_list_add), d);
3322         menu_item_add_stock(menu, _("Add contents _recursive"), GTK_STOCK_ADD, G_CALLBACK(confirm_dir_list_recurse), d);
3323         menu_item_add_stock(menu, _("_Skip folders"), GTK_STOCK_REMOVE, G_CALLBACK(confirm_dir_list_skip), d);
3324         menu_item_add_divider(menu);
3325         menu_item_add_stock(menu, _("Cancel"), GTK_STOCK_CANCEL, G_CALLBACK(confirm_dir_list_cancel), d);
3326
3327         return menu;
3328 }
3329
3330 /*
3331  *-------------------------------------------------------------------
3332  * dnd
3333  *-------------------------------------------------------------------
3334  */
3335
3336 static GtkTargetEntry dupe_drag_types[] = {
3337         { "text/uri-list", 0, TARGET_URI_LIST },
3338         { "text/plain", 0, TARGET_TEXT_PLAIN }
3339 };
3340 static gint n_dupe_drag_types = 2;
3341
3342 static GtkTargetEntry dupe_drop_types[] = {
3343         { TARGET_APP_COLLECTION_MEMBER_STRING, 0, TARGET_APP_COLLECTION_MEMBER },
3344         { "text/uri-list", 0, TARGET_URI_LIST }
3345 };
3346 static gint n_dupe_drop_types = 2;
3347
3348 static void dupe_dnd_data_set(GtkWidget *widget, GdkDragContext *context,
3349                               GtkSelectionData *selection_data, guint info,
3350                               guint time, gpointer data)
3351 {
3352         DupeWindow *dw = data;
3353         GList *list;
3354
3355         switch (info)
3356                 {
3357                 case TARGET_URI_LIST:
3358                 case TARGET_TEXT_PLAIN:
3359                         list = dupe_listview_get_selection(dw, widget);
3360                         if (!list) return;
3361                         uri_selection_data_set_uris_from_filelist(selection_data, list);
3362                         filelist_free(list);
3363                         break;
3364                 default:
3365                         break;
3366                 }
3367 }
3368
3369 static void dupe_dnd_data_get(GtkWidget *widget, GdkDragContext *context,
3370                               gint x, gint y,
3371                               GtkSelectionData *selection_data, guint info,
3372                               guint time, gpointer data)
3373 {
3374         DupeWindow *dw = data;
3375         GtkWidget *source;
3376         GList *list = NULL;
3377         GList *work;
3378
3379         source = gtk_drag_get_source_widget(context);
3380         if (source == dw->listview || source == dw->second_listview) return;
3381
3382         dw->second_drop = (dw->second_set && widget == dw->second_listview);
3383
3384         switch (info)
3385                 {
3386                 case TARGET_APP_COLLECTION_MEMBER:
3387                         collection_from_dnd_data((gchar *)gtk_selection_data_get_data(selection_data), &list, NULL);
3388                         break;
3389                 case TARGET_URI_LIST:
3390                         list = uri_filelist_from_gtk_selection_data(selection_data);
3391                         work = list;
3392                         while (work)
3393                                 {
3394                                 FileData *fd = work->data;
3395                                 if (isdir(fd->path))
3396                                         {
3397                                         GtkWidget *menu;
3398                                         menu = dupe_confirm_dir_list(dw, list);
3399                                         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, time);
3400                                         return;
3401                                         }
3402                                 work = work->next;
3403                                 }
3404                         break;
3405                 default:
3406                         list = NULL;
3407                         break;
3408                 }
3409
3410         if (list)
3411                 {
3412                 dupe_window_add_files(dw, list, FALSE);
3413                 filelist_free(list);
3414                 }
3415 }
3416
3417 static void dupe_dest_set(GtkWidget *widget, gboolean enable)
3418 {
3419         if (enable)
3420                 {
3421                 gtk_drag_dest_set(widget,
3422                         GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
3423                         dupe_drop_types, n_dupe_drop_types,
3424                         GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_ASK);
3425
3426                 }
3427         else
3428                 {
3429                 gtk_drag_dest_unset(widget);
3430                 }
3431 }
3432
3433 static void dupe_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
3434 {
3435         DupeWindow *dw = data;
3436         dupe_dest_set(dw->listview, FALSE);
3437         dupe_dest_set(dw->second_listview, FALSE);
3438
3439         if (dw->click_item && !dupe_listview_item_is_selected(dw, dw->click_item, widget))
3440                 {
3441                 GtkListStore *store;
3442                 GtkTreeIter iter;
3443
3444                 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(widget)));
3445                 if (dupe_listview_find_item(store, dw->click_item, &iter) >= 0)
3446                         {
3447                         GtkTreeSelection *selection;
3448                         GtkTreePath *tpath;
3449
3450                         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
3451                         gtk_tree_selection_unselect_all(selection);
3452                         gtk_tree_selection_select_iter(selection, &iter);
3453
3454                         tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
3455                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
3456                         gtk_tree_path_free(tpath);
3457                         }
3458                 }
3459
3460         if (dw->show_thumbs &&
3461             widget == dw->listview &&
3462             dw->click_item && dw->click_item->pixbuf)
3463                 {
3464                 GtkTreeSelection *selection;
3465                 gint items;
3466
3467                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
3468                 items = gtk_tree_selection_count_selected_rows(selection);
3469                 dnd_set_drag_icon(widget, context, dw->click_item->pixbuf, items);
3470                 }
3471 }
3472
3473 static void dupe_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
3474 {
3475         DupeWindow *dw = data;
3476         dupe_dest_set(dw->listview, TRUE);
3477         dupe_dest_set(dw->second_listview, TRUE);
3478 }
3479
3480 static void dupe_dnd_init(DupeWindow *dw)
3481 {
3482         gtk_drag_source_set(dw->listview, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
3483                             dupe_drag_types, n_dupe_drag_types,
3484                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
3485         g_signal_connect(G_OBJECT(dw->listview), "drag_data_get",
3486                          G_CALLBACK(dupe_dnd_data_set), dw);
3487         g_signal_connect(G_OBJECT(dw->listview), "drag_begin",
3488                          G_CALLBACK(dupe_dnd_begin), dw);
3489         g_signal_connect(G_OBJECT(dw->listview), "drag_end",
3490                          G_CALLBACK(dupe_dnd_end), dw);
3491
3492         dupe_dest_set(dw->listview, TRUE);
3493         g_signal_connect(G_OBJECT(dw->listview), "drag_data_received",
3494                          G_CALLBACK(dupe_dnd_data_get), dw);
3495
3496         gtk_drag_source_set(dw->second_listview, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
3497                             dupe_drag_types, n_dupe_drag_types,
3498                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
3499         g_signal_connect(G_OBJECT(dw->second_listview), "drag_data_get",
3500                          G_CALLBACK(dupe_dnd_data_set), dw);
3501         g_signal_connect(G_OBJECT(dw->second_listview), "drag_begin",
3502                          G_CALLBACK(dupe_dnd_begin), dw);
3503         g_signal_connect(G_OBJECT(dw->second_listview), "drag_end",
3504                          G_CALLBACK(dupe_dnd_end), dw);
3505
3506         dupe_dest_set(dw->second_listview, TRUE);
3507         g_signal_connect(G_OBJECT(dw->second_listview), "drag_data_received",
3508                          G_CALLBACK(dupe_dnd_data_get), dw);
3509 }
3510
3511 /*
3512  *-------------------------------------------------------------------
3513  * maintenance (move, delete, etc.)
3514  *-------------------------------------------------------------------
3515  */
3516
3517 static void dupe_notify_cb(FileData *fd, NotifyType type, gpointer data)
3518 {
3519         DupeWindow *dw = data;
3520
3521         if (!(type & NOTIFY_CHANGE) || !fd->change) return;
3522
3523         DEBUG_1("Notify dupe: %s %04x", fd->path, type);
3524
3525         switch (fd->change->type)
3526                 {
3527                 case FILEDATA_CHANGE_MOVE:
3528                 case FILEDATA_CHANGE_RENAME:
3529                         dupe_item_update_fd(dw, fd);
3530                         break;
3531                 case FILEDATA_CHANGE_COPY:
3532                         break;
3533                 case FILEDATA_CHANGE_DELETE:
3534                         while (dupe_item_remove_by_path(dw, fd->path));
3535                         break;
3536                 case FILEDATA_CHANGE_UNSPECIFIED:
3537                 case FILEDATA_CHANGE_WRITE_METADATA:
3538                         break;
3539                 }
3540
3541 }
3542 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */