src/dupe.c

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